---
title: "Jantt JSON Gantt Engine: Why npm install @jantt/core Fails"
date: "2026-10-19"
video_id: "7698264952360013087"
tiktok_url: "https://www.tiktok.com/@reporadarai/video/7698264952360013087"
creator: "@reporadarai"
category: "Coding"
tags: ["jantt", "gantt chart", "npm", "typescript", "json schema"]
excerpt: "Jantt is a real MIT-licensed JSON Gantt chart engine, but its npm packages were never published and its core declares one runtime dependency."
---
Jantt is an open-source TypeScript library that turns a JSON plan into an interactive Gantt chart, and the repository is real. The install command a TikTok promotes for it, `npm install @jantt/core`, fails as of 2026-10-27 because no Jantt package has ever been published to npm. The "zero runtime dependencies" claim is also out of date.

## What is Jantt?

A TikTok from @reporadarai scrolls through the project's GitHub README and pitches it as "The Declarative JSON Gantt Chart Engine." The repository is `AhmadHassan-BTed/Jantt`. The GitHub API describes it as "The AI-native JSON Gantt chart engine. Dependency-free interactive timelines with React, script-tag, CLI, topological DAG solver, and formal JSON schema."

The basic facts check out. The project is MIT licensed, written in TypeScript, created on 2026-08-28, not archived and not a fork. Its last push was 2026-10-26, so someone is working on it. A second copy exists at `gustavoml12/Jantt` with the same description, but the video points at the original.

The idea is that you, or an AI model, write a plan as JSON and the library handles layout, dependencies and the critical path. The repo ships a real schema at `schema/jantt.schema.json`, a draft-07 JSON Schema titled "Jantt Plan Specification v1."

The audio in the video says "Jant" with one `t` at one point. The wordmark and the repository path both spell it Jantt, so search for that.

## Why does npm install @jantt/core fail?

The end card tells viewers to run `npm install @jantt/core`. The README quickstart adds `npm install @jantt/react @jantt/core` and a script tag pointing at `https://unpkg.com/@jantt/standalone`.

On 2026-10-27 the npm registry returned HTTP 404 for `@jantt/core`, `@jantt/react`, `@jantt/standalone` and the unscoped `jantt`. A registry search for "jantt" returned zero results. The unpkg URL returns 404 too, since unpkg reads from the same registry. Running the end card command gives `npm error 404 Not Found`.

The repository shows why. The "Publish & Release" workflow in `.github/workflows/release.yml` runs only when a tag matching `v*.*.*` is pushed. The repo has zero tags, zero releases and zero runs of that workflow, so nothing has ever been sent to npm. The README's `npx jantt open` command fails for the same reason.

The working path today is to clone the repository and build it from source. The README's contributing section covers that. The video does not mention it.

## Does Jantt really have zero runtime dependencies?

The video says "Its core engine has zero runtime dependencies and weighs under 14 kilobytes compressed," and the README carries a `Dependencies 0 Runtime` badge.

The package manifest at `packages/core/package.json` declares `"fflate": "^0.8.3"` under `dependencies`. The code uses it. `packages/core/src/share-coder.ts` imports `deflateSync` and `inflateSync` from fflate, and `src/index.ts` re-exports that module, so anyone importing the package pulls fflate in.

The dependency arrived in commit `a349c2a9` on 2026-09-05, with the message "fix(share): compress shareable links with deflate-raw and enable dynamic live-update sync." That was 44 days before the video was posted.

There is one fair caveat. The Vite build config sets no `external` list, so fflate is bundled into the built `dist` files. A consumer of the built bundle loads one file. The accurate description is that the core includes one third-party compression library. The badge is a hardcoded shields.io image, not a generated count.

## Is the "under 14 KB gzipped" figure true?

It cannot be checked from the repository. No package has been published, so there is no tarball to measure. The `dist` folder is not committed. The CI workflow runs `npm ci`, `npm run build`, `npm run typecheck` and `npm test`, with no bundle-size check. Nothing in the project fails if the bundle grows past 14 KB.

The README's comparison table lists `< 14 KB` for Jantt against `~200 KB` for DHTMLX Gantt, `~35 KB` for Frappe Gantt and `~800 KB` for Mermaid.js. None of those four numbers links to a measurement, so treat the whole row as the author's estimate.

## Does Jantt use 10x fewer tokens than JSX?

The video says "AI models can generate complete timeline data using 10 times fewer tokens than JSX." The README repeats the 10x ratio six times. It gives no token counts, names no tokenizer and shows no before-and-after comparison. The closest thing is a set of benchmark prompts for Claude 3.5 Sonnet, GPT-4o and Gemini 1.5 Pro, which are prompts without results.

The schema-in, JSON-out approach is implemented. The 10x number has nothing behind it.

A smaller problem sits in the schema itself. Its `$id`, and every README example, uses `https://jantt.dev/schema/v1.json`. The domain `jantt.dev` has no DNS records, so tools that try to fetch the schema from that URL fail. The schema is available at its raw GitHub path.

## Are the tests really passing?

The README shows a `Tests 339/339 Passing` badge. It is a hardcoded image that reads the same no matter what CI does.

CI run 40298259947, from the 2026-10-26 push, failed with 2 failed and 341 passed tests across 22 files. Both failures are in `packages/core/tests/reconciler.test.ts`. Main-branch CI was green from 2026-09-06 through 2026-09-18 and first failed on 2026-10-22, three days after the video posted. So the pipeline was green when the clip went up, though the test count on the badge was already frozen.

The `Node.js >=18.0.0` badge also conflicts with the root `package.json`, which requires Node 20 or later, and with CI, which tests only Node 20.x and 22.x.

The end card showed 1,118 stars on 2026-10-19. The GitHub API returned 4,620 on 2026-10-27.

## Bottom line

Jantt is a real, active MIT project with a working JSON schema. You cannot install it from npm yet, because the release workflow has never run. The zero-dependency, 14 KB and 10x-token claims are either out of date or unmeasured, and the passing-tests badge is static.

## Sources

- [Jantt repository metadata, GitHub API](https://api.github.com/repos/AhmadHassan-BTed/Jantt): license, creation date, last push and star count.
- [Jantt README](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/README.md): badges, quickstart commands, comparison table and 10x token claim.
- [packages/core/package.json](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/packages/core/package.json): the declared fflate dependency.
- [packages/core/src/share-coder.ts](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/packages/core/src/share-coder.ts): where fflate is imported and used.
- [Commit history for packages/core/package.json](https://api.github.com/repos/AhmadHassan-BTed/Jantt/commits?path=packages/core/package.json): commit `a349c2a9` adding fflate on 2026-09-05.
- [packages/core/vite.config.ts](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/packages/core/vite.config.ts): no `external` list, so fflate is bundled.
- [.github/workflows/ci.yml](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/.github/workflows/ci.yml): the four-step pipeline and Node test matrix.
- [.github/workflows/release.yml](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/.github/workflows/release.yml): npm publishing gated on version tags.
- [CI workflow runs](https://api.github.com/repos/AhmadHassan-BTed/Jantt/actions/workflows/ci.yml/runs): the 341-of-343 result and the main-branch timeline.
- [npm registry entry for @jantt/core](https://registry.npmjs.org/@jantt%2Fcore): the HTTP 404 behind the install command.
- [npm registry search for "jantt"](https://registry.npmjs.org/-/v1/search?text=jantt): zero results.
- [schema/jantt.schema.json](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/schema/jantt.schema.json): the draft-07 schema and its `jantt.dev` `$id`.
- [cli/package.json](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/cli/package.json): the `jantt` bin behind `npx jantt open`.


## Video description and verification notes

**A 35.83 s vertical clip at 1080x1920, MP4 container (`mov,mp4,m4a,3gp,3g2,mj2`), HEVC Main profile video at yuv420p and 506,152 bps over 1,075 frames at a constant 30 fps, HE-AACv2 audio at 44.1 kHz stereo and 48,113 bps, 561,203 bps overall, 2,513,724 bytes on disk, format id `bytevc1_1080p_561193-1`; posted at epoch 1792407600, which is 2026-10-19 11:00:00 UTC, by uploader `reporadarai` (uploader id 6692521761513571333) under the channel name "Repo Radar AI", audio credited as "original sound - Repo Radar AI", with a 308-character description that names the project, the MIT-adjacent pitch and five hashtags (`#aitools #criticalpath #dag #visualization #gantt`); at the metadata capture time of 2026-10-27 05:07:01 UTC the post showed 2,031 views, 88 likes, 1 comment and 59 reposts. I read ten of the eighteen extracted frames (001, 003, 005, 007, 009, 012, 013, 015, 017, 018) covering roughly 0 s, 4 s, 8 s, 12 s, 16 s, 22 s, 24 s, 28 s, 32 s and 34 s, against a transcript of 81 words in 6 segments. The video is a single continuous scroll of a rendered GitHub README inside a fake macOS browser chrome with a "Repo Radar AI" title-bar watermark, with burned-in karaoke captions overlaid. Frame 001 shows the Jantt wordmark and logo, a pink pill reading "★ 1.1k stars", and the caption "JSON → INTERACTIVE GANTT". Frame 003 shows the subtitle "The Declarative JSON Gantt Chart Engine", the tagline "Where human intuition meets declarative AI planning.", and six shields.io badges reading `License MIT`, `TypeScript 5.4`, `Dependencies 0 Runtime`, `Tests 339/339 Passing`, `Node.js >=18.0.0` and `PRs Welcome`, above the line "Zero runtime dependencies. 100% pure TypeScript." Frame 005 (caption "GANTT CHARTS WITH") shows a screenshot of the playground: a JSON editor pane on the left with `"$schema": "https://jantt.dev/schema/v1.json"` and a "Metropolis High-Rise Construction" plan, a Gantt canvas on the right with right-angled connector lines, a "Critical Path (7)" toggle, and a hover card reading "Structural Steel Core (Floors 1-25) / Timeline Nov 14, 2026 → Jan 10, 2027 (57d) / Progress 15% / Depends On piling-pour". Frame 007 (caption "DEPENDENCIES AND WEIGHS") lists four "superpowers" including "The core math and layout engine (`@jantt/core`) is pure, zero-dependency TypeScript weighing under 14 KB gzipped." Frame 009 (caption "AI MODELS CAN") shows "Swiss Dark Mode" and a "Color Theme Gallery" with Cyber Emerald, Midnight Rose, Sunset Crimson and Master Specification Benchmark tiles. Frame 012 shows a four-way comparison table against DHTMLX Gantt, Frappe Gantt and Mermaid.js whose last row reads "Bundle Size (gzip) | < 14 KB | ~200 KB | ~35 KB | ~800 KB". Frames 013 and 015 (captions "AGAINST DARK BACKGROUNDS," and "CAN YOU SEE") show the quickstart blocks `npm install @jantt/react @jantt/core` and `<script src="https://unpkg.com/@jantt/standalone"></script>`, plus a stat strip reading "10× Fewer LLM Tokens vs JSX | 0 Runtime Dependencies | 100% Deterministic DAG Solver | 2-Way Bidirectional State Sync". Frames 017 and 018 are the end card: "Can you see an AI agent generating your next project schedule automatically with Jantt?", "FIND IT AT github.com/AhmadHassan-BTed/Jantt", "★ 1,118 STARS", "$ npm install @jantt/core" and a "@RepoRadarAI Follow for more open-source projects" bar. No terminal, no shell session, no npm install, no browser devtools and no bundle-size measurement appears in any frame I read; every interaction shown is a static screenshot embedded in the README, not a live demo. The spoken argument is that structured JSON replaces hand-written timeline code, that the core engine ships zero runtime dependencies under 14 KB compressed, and that LLMs emit timeline data in roughly a tenth of the tokens JSX would need. On the transcript-end check, the last segment ends at 33.54 s against a real audio duration of 35.79 s in `audio.mp3` and 35.81 s in the muxed AAC stream, so every segment lands inside the audio and nothing in this transcript is a past-the-end Whisper fabrication.**

## The product name is Jantt, and Whisper dropped a letter the first time it heard it

The transcript is internally inconsistent about the name. At 5.82 s the second segment reads "Jant transforms structured JSON into interactive Gantt charts with draggable tasks and timelines", with one `t`. At 28.90 s the closing segment reads "Can you see an AI agent generating your next project schedule automatically with Jantt?", with two. The burned-in text settles it: frame 001 renders the wordmark as "Jantt", and the end card in frame 018 spells out the repository path as `github.com/AhmadHassan-BTed/Jantt`. The GitHub API confirms the canonical casing and spelling: the repo `full_name` is `AhmadHassan-BTed/Jantt`. The one-letter drop at 5.82 s is a Whisper artifact, not a second product. Anyone searching for "Jant" from the audio alone lands nowhere.

The repository itself checks out on every structural fact the video and its README assert about provenance. The GitHub API reports the description "The AI-native JSON Gantt chart engine. Dependency-free interactive timelines with React, script-tag, CLI, topological DAG solver, and formal JSON schema", `language: TypeScript`, `license.spdx_id: MIT`, `created_at: 2026-08-28T07:32:35Z`, `archived: false`, `fork: false`, and topics including `gantt`, `json-schema`, `critical-path`, `dag` and `zero-dependencies`. The MIT badge in frame 003 is accurate. The project is 60 days old as of the capture date and the latest push is `2026-10-26T09:16:19Z`, so it is actively maintained. There is a second copy of the repo at `gustavoml12/Jantt` carrying the same description; the end card points at `AhmadHassan-BTed/Jantt`, which is the non-fork original by `created_at` and by the `fork: false` flag.

## The install command on the end card does not resolve: npm has no `jantt` packages at all

Frame 018 displays `$ npm install @jantt/core` as the call to action, and the README quickstart in frames 013 and 015 gives `npm install @jantt/react @jantt/core` plus a CDN path at `https://unpkg.com/@jantt/standalone`. None of those work today. Querying the npm registry on 2026-10-27 returns HTTP 404 with body `{"error":"Not found"}` for `@jantt/core`, `@jantt/react`, `@jantt/standalone` and the unscoped `jantt`. A registry search for the text `jantt` returns `{"total": 0}`. The unpkg URL in the script-tag snippet returns 404 as well, because unpkg resolves against the same registry.

The repository explains why. The publish workflow at `.github/workflows/release.yml` is named "Publish & Release" and is triggered only `on: push: tags: - "v*.*.*"`. The GitHub API reports zero releases and zero tags on the repository, and the release workflow's run list returns `total_count: 0`. The workflow has never fired, so nothing has ever been pushed to the registry. The CLI package at `cli/package.json` declares `"name": "jantt"` with `"bin": {"jantt": "./bin/jantt.js"}`, and the README advertises `npx jantt open`; that command fails for the same reason, since `npx` resolves `jantt` from npm and npm returns 404.

The practical effect is that a viewer who follows the video's instruction gets `npm error 404 Not Found - GET https://registry.npmjs.org/@jantt%2fcore`. The only working path to the code on 2026-10-27 is cloning the repository and building it from source, which the README does cover in its contributing section. The video never mentions that step.

## "Zero runtime dependencies" is contradicted by `@jantt/core`'s own package.json

At 11.08 s the video says "Its core engine has zero runtime dependencies and weighs under 14 kilobytes compressed." Frame 003 renders the matching badge `Dependencies 0 Runtime`, and frame 007 renders the README bullet "The core math and layout engine (`@jantt/core`) is pure, zero-dependency TypeScript weighing under 14 KB gzipped."

The package manifest says otherwise. `packages/core/package.json` on `main` ends with:

```
  "dependencies": {
    "fflate": "^0.8.3"
  }
```

That is a declared runtime dependency, not a devDependency. It is used, not vestigial: `packages/core/src/share-coder.ts` opens with `import { deflateSync, inflateSync, strToU8, strFromU8 } from "fflate";`, and `packages/core/src/index.ts` re-exports that module twice, once via `export * from "./share-coder";` and again by name for `compressPlanToUrlPayload`, `decompressPlanFromUrlPayload`, `cleanPlanForSharing` and `sanitizePlanForJson`. Any consumer importing the package entry point pulls fflate into the graph.

The commit history dates the change precisely. `git log` on `packages/core/package.json` shows three commits: `a377861d` on 2026-08-28 ("feat: initial release of Jantt"), `b1537d68` on 2026-08-29, and `a349c2a9` on 2026-09-05 with the message "fix(share): compress shareable links with deflate-raw and enable dynamic live-update sync". The dependency was added 44 days before this video was posted, so the claim was already stale when the clip went up.

One nuance keeps this a partial correction rather than a flat one. `packages/core/vite.config.ts` builds the library with `rollupOptions` that set only `output.assetFileNames` and declare no `external` array, so fflate is inlined into `dist/index.js` and `dist/index.cjs` at build time. A consumer of the built bundle therefore loads a single artifact with no separate fetch. The accurate statement is that the core engine vendors one third-party compression library rather than shipping none, and the shipped bundle size includes it. The badge reading `Dependencies 0 Runtime` is a hardcoded shields.io image, not a generated count.

## The "under 14 KB gzipped" figure cannot be checked from the repository, and nothing enforces it

The 14 KB number appears three times in the source material: the audio at 11.08 s, the README superpower bullet in frame 007, and the comparison table in frames 012 and 013, where the "Bundle Size (gzip)" row reads `< 14 KB` for Jantt against `~200 KB` for DHTMLX Gantt, `~35 KB` for Frappe Gantt and `~800 KB` for Mermaid.js.

I could not verify it. The measurement would have to come from a published artifact or a size check in CI, and neither exists. The npm packages are unpublished, so there is no tarball to gzip. `packages/core/package.json` lists `"files": ["dist"]`, and `dist` is a build output that is not committed to the repository. `.github/workflows/ci.yml` runs exactly four steps after setup, `npm ci`, `npm run build`, `npm run typecheck` and `npm test`, with no size-limit, bundlewatch or byte-count assertion anywhere in the job. Nothing in the project fails if the bundle crosses 14 KB.

The comparison figures for the three competitors are likewise uncited in the README; they are typed into a markdown table with tilde approximations and no link to a measurement. I am not disputing the rough magnitudes, which are plausible for those libraries, but none of the four numbers in that row traces to a source I can fetch. Treat the whole row as author-asserted. The claim that the Jantt core is small is believable for a dependency-light TypeScript layout engine, and the specific threshold of 14 KB gzipped is unverified.

## "10x fewer tokens than JSX" is a slogan repeated six times with no benchmark behind it

At 16.76 s the video says "AI models can generate complete timeline data using 10 times fewer tokens than JSX." The README states the same ratio in six separate places: the audience bullet at line 29, the superpowers bullet at line 56, the stat strip at line 177 ("Fewer LLM Tokens vs JSX"), the Mermaid pipeline diagram at line 185 ("10x fewer tokens, type-safe, 0 hallucinations"), the pipeline prose at line 192 ("Uses 10× fewer tokens than JSX"), and the capability table at line 507, which renders it in LaTeX as "$10\times$ token reduction vs JSX/HTML, zero graphical hallucinations".

Searching the README for any token count attached to that ratio returns nothing. There is no before-and-after pair of prompts, no tokenizer named, no input and output token totals, no model specified for the measurement. The nearest thing to a methodology is line 507's reference to "Copy-paste benchmark prompts for Claude 3.5 Sonnet, GPT-4o, and Gemini 1.5 Pro", which supplies prompts rather than results. The repository does ship a real schema contract at `schema/jantt.schema.json`, a draft-07 JSON Schema titled "Jantt Plan Specification v1", so the underlying mechanism (feed the model a schema, get JSON back, let the library do layout) is implemented. The quantified 10x claim is the part with nothing behind it. Mark it unverified.

The schema file carries a second small problem. Its `$id` is `https://jantt.dev/schema/v1.json`, and every JSON example in the README and in the playground screenshot at frame 005 uses that URL as the `$schema` value. The domain `jantt.dev` does not resolve: `dig jantt.dev A` returns no records and `dig jantt.dev NS` returns no delegation, while a control query for `github.com` returns `140.82.114.4` from the same resolver. Any tooling that tries to dereference `$schema` from a Jantt plan fails. The schema is reachable only at its raw GitHub path, which the README does give alongside the broken one.

## The green badges are static: CI has been red since 22 October and the live count is 341 of 343

Frame 003 shows a `Tests 339/339 Passing` badge linking to the Actions tab, and the README repeats "339/339 tests passing across 22 suites" at line 547 and again at line 817. The badge is a hardcoded `img.shields.io/badge/Tests-339%2F339%20Passing-brightgreen` URL, so it displays that text regardless of CI state.

The actual state on 2026-10-27 is a failing pipeline. CI run 40298259947, triggered by the 2026-10-26 push, reports `conclusion: failure`. Its job log shows `Install Dependencies`, `Build All Packages` and `TypeScript Typecheck` all green, then `Run Test Suite` failing with `Test Files 1 failed | 21 passed (22)` and `Tests 2 failed | 341 passed (343)`. Both failures are in `packages/core/tests/reconciler.test.ts`, in the cases "cleanly prunes dangling dependencies when predecessor tasks are deleted" and "performs autonomous JSON maintenance: prunes expired tombstones, caps bloat, strips empty timestamps", each raising `AssertionError: expected undefined not to be undefined`. The log also carries two runtime errors from the fflate code path, `Failed to decompress plan from URL payload: DOMException [InvalidCharacterError]` and `Failed to decompress plan from URL payload: Error: unexpected EOF`.

The timeline matters for fairness to the video. Filtering CI runs to the `main` branch shows an unbroken sequence of `success` from 2026-09-06 through 2026-09-18, then nothing until 2026-10-22, which failed. The video posted on 2026-10-19, between those two runs, when the last recorded main-branch result was green. The badge number was wrong on 2026-10-19 (the suite had grown past 339 and the figure is frozen), but the pipeline was not yet red. It has been red since. The CI matrix also runs Node 20.x and 22.x only, while the `Node.js >=18.0.0` badge in frame 003 promises 18; the root `package.json` sets `"engines": {"node": ">=20.0.0"}`, which contradicts the badge directly.

On stars, the video is a snapshot that has aged. Frame 001 shows "★ 1.1k stars" and frame 018 shows "★ 1,118 STARS" as of the 2026-10-19 post. The GitHub API on 2026-10-27 returns `stargazers_count: 4620` with 15 forks, 13 open issues and 1 watcher. The repository gained roughly 3,500 stars in the eight days after this video, on a project that is 60 days old. I could not pull per-star timestamps to confirm the 1,118 figure at post time, since the stargazers endpoint returned 401 and 404 for my requests, so I report the 1,118 number as what the end card displayed rather than as independently verified.

## Key Takeaways

- **Verified:** The repository is real. `AhmadHassan-BTed/Jantt` is MIT licensed, written in TypeScript, created 2026-08-28, not archived, not a fork, and last pushed 2026-10-26, per the GitHub REST API.
- **Correction:** The end card instructs `npm install @jantt/core`. The npm registry returns HTTP 404 for `@jantt/core`, `@jantt/react`, `@jantt/standalone` and `jantt`, and a registry search for "jantt" returns zero results. The publish workflow fires only on `v*.*.*` tags, and the repo has zero tags, zero releases and zero release-workflow runs. The packages have never been published.
- **Correction:** At 11.08 s the video says "Its core engine has zero runtime dependencies." `packages/core/package.json` declares `"dependencies": {"fflate": "^0.8.3"}`, imported at the top of `src/share-coder.ts` and re-exported from `src/index.ts`. The dependency was added in commit `a349c2a9` on 2026-09-05, 44 days before the post.
- **Partial correction:** `packages/core/vite.config.ts` sets no `external` list, so fflate is inlined into the built bundle and a consumer of `dist` fetches one artifact. The accurate framing is one vendored compression library rather than none.
- **Unverified:** "Under 14 kilobytes compressed" (11.08 s) and the `< 14 KB` comparison row. No package is published, `dist` is not committed, and `ci.yml` contains no bundle-size check. The competitor figures (~200 KB, ~35 KB, ~800 KB) carry no citation either.
- **Unverified:** "10 times fewer tokens than JSX" (16.76 s). The README repeats the ratio six times and supplies no token counts, no tokenizer and no measured comparison.
- **Correction:** The `Tests 339/339 Passing` badge is a hardcoded shields.io image. CI run 40298259947 on 2026-10-26 reports 2 failed and 341 passed across 22 suites, both failures in `packages/core/tests/reconciler.test.ts`. Main-branch CI was green through 2026-09-18 and first failed on 2026-10-22, three days after this video posted.
- **Clarification:** The `Node.js >=18.0.0` badge conflicts with the root `package.json`, which sets `"engines": {"node": ">=20.0.0"}`, and with `ci.yml`, which tests only Node 20.x and 22.x.
- **Clarification:** The schema's `$id` and every README example point at `https://jantt.dev/schema/v1.json`. The domain `jantt.dev` has no A record and no NS delegation, so that URL cannot be dereferenced. The schema is reachable at its raw GitHub path.
- **Context:** Whisper rendered the name as "Jant" at 5.82 s and "Jantt" at 28.90 s. The burned-in wordmark and the end-card repository path both read Jantt.
- **Context:** The video shows no terminal, no install, no live drag interaction and no measurement. Every frame is a scroll of the rendered README with embedded screenshots.
- **Context:** The end card showed 1,118 stars on 2026-10-19. The GitHub API returned 4,620 on 2026-10-27, roughly 3,500 added in eight days.

## Resources

- [AhmadHassan-BTed/Jantt repository metadata, GitHub REST API, retrieved 2026-10-27](https://api.github.com/repos/AhmadHassan-BTed/Jantt) establishes the MIT license, the 2026-08-28 creation date, the TypeScript language, the 2026-10-26 last push and the 4,620 star count I cite.
- [Jantt README.md on main, GitHub raw, retrieved 2026-10-27](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/README.md) establishes the badge set, the "zero-dependency under 14 KB gzipped" bullet, the `< 14 KB` comparison row, the six repetitions of the 10x token claim, and the `npm install @jantt/react @jantt/core` and unpkg quickstart snippets.
- [packages/core/package.json on main, GitHub raw, retrieved 2026-10-27](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/packages/core/package.json) establishes the declared runtime dependency `"fflate": "^0.8.3"` that contradicts the zero-dependency claim.
- [packages/core/src/share-coder.ts on main, GitHub raw, retrieved 2026-10-27](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/packages/core/src/share-coder.ts) establishes that fflate is imported and used, not a leftover entry.
- [Commit history for packages/core/package.json, GitHub REST API, retrieved 2026-10-27](https://api.github.com/repos/AhmadHassan-BTed/Jantt/commits?path=packages/core/package.json) establishes that commit `a349c2a9` added the fflate dependency on 2026-09-05, before the video posted.
- [packages/core/vite.config.ts on main, GitHub raw, retrieved 2026-10-27](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/packages/core/vite.config.ts) establishes the absence of an `external` list, which is why fflate is inlined into the built bundle.
- [.github/workflows/ci.yml on main, GitHub raw, retrieved 2026-10-27](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/.github/workflows/ci.yml) establishes the four-step pipeline with no bundle-size check and the Node 20.x and 22.x test matrix.
- [.github/workflows/release.yml on main, GitHub raw, retrieved 2026-10-27](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/.github/workflows/release.yml) establishes that publishing to npm is gated on `v*.*.*` tags, which the repository has never had.
- [CI workflow runs and job logs for run 40298259947, GitHub REST API, retrieved 2026-10-27](https://api.github.com/repos/AhmadHassan-BTed/Jantt/actions/workflows/ci.yml/runs) establishes the 341-of-343 test result, the two reconciler failures, and the main-branch green-through-2026-09-18 then failing-from-2026-10-22 timeline.
- [npm registry entry for @jantt/core, retrieved 2026-10-27](https://registry.npmjs.org/@jantt%2Fcore) establishes the HTTP 404 and `{"error":"Not found"}` body behind the broken install command.
- [npm registry search for "jantt", retrieved 2026-10-27](https://registry.npmjs.org/-/v1/search?text=jantt) establishes `{"total": 0}`, meaning no package under that name exists on npm.
- [schema/jantt.schema.json on main, GitHub raw, retrieved 2026-10-27](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/schema/jantt.schema.json) establishes the draft-07 "Jantt Plan Specification v1" schema and its `$id` of `https://jantt.dev/schema/v1.json`, the domain that does not resolve.
- [cli/package.json on main, GitHub raw, retrieved 2026-10-27](https://raw.githubusercontent.com/AhmadHassan-BTed/Jantt/main/cli/package.json) establishes the `jantt` bin name behind the `npx jantt open` instruction that cannot resolve.
