@tanishqkancharla/diffmap 0.1.4 → 0.1.5

package/README.md

@@ -28,10 +28,10 @@ Keeps a spec in `specs/` that stays true to what's planned versus already in the
 
 Options:
 
-- `--port <n>` — listen port (default `4177`)
+- `--port <n>` — pin a listen port (default: a free port)
 - `--root <dir>` — workspace root for file excerpts (default the directory you ran the command from)
 
-**Done** in the top right stops the server.
+**Close server** in the top right stops the server. Hosted gist and GitHub viewers have no local server, so they omit this control.
 
 The server also stops after 24 hours without a page or source request.
 Loading or refreshing the page resets the timer; background health checks and
@@ -43,11 +43,19 @@ List every running viewer, including viewers using custom ports:
 npx @tanishqkancharla/diffmap list
 ```
 
+Update a global install to the latest `@tanishqkancharla/diffmap` on npm. `diffmap --update` does the same thing:
+
+```sh
+diffmap update
+```
+
+If you are already on the latest version, it says so and exits. Otherwise it runs the global install for the package manager that installed diffmap (`npm install --global`, `pnpm add --global`, or `bun add --global`) and prints the old and new versions. Under `npx`, or when it cannot tell how diffmap was installed, it prints the command to run instead of installing anything.
+
 Request the page with `Accept: text/markdown` to read the current source file
-instead of the rendered HTML:
+instead of the rendered HTML. Use the URL printed by `serve`:
 
 ```sh
-curl -H 'Accept: text/markdown' http://127.0.0.1:4177/
+curl -H 'Accept: text/markdown' http://127.0.0.1:<port>/
 ```
 
 ## Library

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanishqkancharla/diffmap",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Serve a spec or code walkthrough as a local page",
   "license": "MIT",
   "author": "Tanishq Kancharla",
@@ -33,7 +33,7 @@
     "lint:fix": "oxlint --fix src vite.config.ts vite.gist.config.ts bin.js",
     "prepublishOnly": "npm run typecheck && npm run lint && npm run format:check",
     "release": "npm publish",
-    "test": "tsx --test src/parseViewer.test.ts src/gist/route.test.ts src/github/route.test.ts src/github/patch.test.ts src/github/fetchRepo.test.ts src/viewer/sourceHeader.test.ts",
+    "test": "tsx --test src/cli.test.ts src/update.test.ts src/parseViewer.test.ts src/serve.test.ts src/gist/route.test.ts src/github/route.test.ts src/github/patch.test.ts src/github/fetchRepo.test.ts src/viewer/sourceHeader.test.ts src/host/home.test.ts",
     "typecheck": "tsc --noEmit",
     "build": "vite build",
     "build:gist": "vite build",
@@ -45,7 +45,7 @@
     "beautiful-mermaid": "^1.1.3",
     "errore": "^0.14.1",
     "incur": "^0.4.20",
-    "maui": "npm:@tanishqkancharla/maui@0.0.16",
+    "maui": "npm:@tanishqkancharla/maui@0.0.30",
     "md4x": "^0.0.29",
     "purse-styles": "^0.2.3",
     "react": "^19.2.8",

package/src/cli.test.ts

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import test from "node:test";
+
+const execFileAsync = promisify(execFile);
+const srcDir = fileURLToPath(new URL(".", import.meta.url));
+const packageRoot = path.resolve(srcDir, "..");
+const cliPath = path.join(srcDir, "cli.ts");
+
+async function runCli(args: string[]) {
+  try {
+    const result = await execFileAsync(
+      process.execPath,
+      ["--import", "tsx", cliPath, ...args],
+      {
+        cwd: packageRoot,
+        timeout: 20_000,
+        maxBuffer: 1_000_000,
+      },
+    );
+    return { exitCode: 0, stdout: result.stdout, stderr: result.stderr };
+  } catch (cause) {
+    if (typeof cause !== "object" || !cause) throw cause;
+    const exitCode =
+      "code" in cause && typeof cause.code === "number"
+        ? cause.code
+        : undefined;
+    const stdout =
+      "stdout" in cause && typeof cause.stdout === "string" ? cause.stdout : "";
+    const stderr =
+      "stderr" in cause && typeof cause.stderr === "string" ? cause.stderr : "";
+    return { exitCode, stdout, stderr };
+  }
+}
+
+test("diffmap --version matches package.json", async () => {
+  const pkg = JSON.parse(
+    await fs.readFile(path.join(packageRoot, "package.json"), "utf8"),
+  ) as { version: string };
+  const source = await fs.readFile(cliPath, "utf8");
+  assert.doesNotMatch(source, /version:\s*["'`]\d+\.\d+\.\d+/);
+  const result = await runCli(["--version"]);
+  assert.equal(result.exitCode, 0, result.stderr);
+  const printed = `${result.stdout}${result.stderr}`.trim();
+  assert.equal(printed, pkg.version);
+});

package/src/cli.ts

@@ -2,16 +2,25 @@
 
 import { Cli, z } from "incur";
 import { resolveFromInvokeCwd } from "./invokeCwd.js";
+import { packageVersion } from "./packageVersion.js";
 import { listRunningDiffmaps } from "./registry.js";
 import { startServer } from "./serve.js";
 import { shareMarkdownFile } from "./share.js";
+import {
+  detectInstallMethod,
+  fetchLatestVersion,
+  packageName,
+  resolveUpdateArgv,
+  runCommand,
+  runUpdate,
+} from "./update.js";
 
 const serveArgs = z.object({
   file: z.string().describe("Path to the markdown file"),
 });
 
 const serveOptions = z.object({
-  port: z.coerce.number().optional().describe("Port (default 4177)"),
+  port: z.coerce.number().optional().describe("Port (default: a free port)"),
   root: z.string().optional().describe("Workspace root for file excerpts"),
 });
 
@@ -33,7 +42,7 @@ async function* runServe(c: ServeContext) {
       c.options.root === undefined
         ? resolveFromInvokeCwd(".")
         : resolveFromInvokeCwd(c.options.root),
-    port: c.options.port === undefined ? 4177 : c.options.port,
+    port: c.options.port,
   });
   if (started instanceof Error) {
     return c.error({
@@ -48,11 +57,11 @@ async function* runServe(c: ServeContext) {
 
 const cli = Cli.create("diffmap", {
   description: "Serve a spec locally, or share it as a gist",
-  version: "0.1.3",
+  version: packageVersion,
   args: serveArgs,
   options: serveOptions,
   output: serveOutput,
-  hint: "`serve <spec.md>` runs the local viewer. `share <spec.md>` publishes a secret gist.",
+  hint: "`serve <spec.md>` runs the local viewer. `share <spec.md>` publishes a secret gist. `update` (or `--update`) installs the latest diffmap.",
   examples: [
     {
       args: { file: "spec.md" },
@@ -129,6 +138,32 @@ const cli = Cli.create("diffmap", {
       }
       return c.ok({ instances });
     },
+  })
+  .command("update", {
+    description: `Update diffmap to the latest ${packageName} on npm (same as --update)`,
+    output: z.object({
+      status: z.enum(["up-to-date", "updated", "manual"]),
+      message: z.string(),
+      current: z.string(),
+      previous: z.string().optional(),
+      latest: z.string().optional(),
+      command: z.string().optional(),
+    }),
+    async run(c) {
+      const result = await runUpdate({
+        currentVersion: packageVersion,
+        fetchLatestVersion,
+        detectInstallMethod,
+        runCommand,
+      });
+      if (result instanceof Error) {
+        return c.error({
+          code: "UPDATE_FAILED",
+          message: result.message,
+        });
+      }
+      return c.ok(result);
+    },
   });
 
-await cli.serve();
+await cli.serve(resolveUpdateArgv(process.argv.slice(2)));

package/src/errors.ts

@@ -39,3 +39,8 @@ export class DiffmapShareError extends errore.createTaggedError({
   name: "DiffmapShareError",
   message: "diffmap share failed: $reason",
 }) {}
+
+export class DiffmapUpdateError extends errore.createTaggedError({
+  name: "DiffmapUpdateError",
+  message: "diffmap update failed: $reason",
+}) {}

package/src/gist/GistApp.tsx

@@ -7,7 +7,8 @@ import type { ViewerDocument } from "../parseViewer.ts";
 import { ViewerApp } from "../viewer/ViewerApp.tsx";
 import { loadGistMarkdown, type GistDocument } from "./fetchGist.ts";
 import { GistPinContext } from "./pin.ts";
-import { GistLanding, GistLoading, GistStatus } from "./GistStatus.tsx";
+import { HostHome } from "../host/HostHome.tsx";
+import { GistLoading, GistStatus } from "./GistStatus.tsx";
 import {
   gistPath,
   parseGistPath,
@@ -83,7 +84,7 @@ export function GistApp() {
     return () => abort.abort();
   }, [route]);
 
-  if (route.kind === "home") return <GistLanding />;
+  if (route.kind === "home") return <HostHome />;
   if (route.kind === "invalid") {
     return (
       <GistStatus title="Not a gist id">

package/src/gist/GistStatus.tsx

@@ -61,52 +61,6 @@ export function GistLoading(props: { title?: string }) {
   );
 }
 
-export function GistLanding() {
-  const code = useStyles(styles.code);
-  return (
-    <GistStatus title="diffmap">
-      <P>
-        A hosted viewer for diffmap walkthroughs. This page fetches a GitHub
-        gist or a public repo file in your browser. There is no server holding
-        the markdown.
-      </P>
-      <P>
-        Canonical gist URL:{" "}
-        <code className={code}>https://diffmap.dev/g/&lt;gistId&gt;</code>.
-        Optional file:{" "}
-        <code className={code}>/g/&lt;gistId&gt;/&lt;file.md&gt;</code>. GitHub
-        spec:{" "}
-        <code className={code}>
-          https://diffmap.dev/&lt;owner&gt;/&lt;repo&gt;/pull/&lt;n&gt;/&lt;path.md&gt;
-        </code>{" "}
-        or{" "}
-        <code className={code}>
-          /&lt;owner&gt;/&lt;repo&gt;/commit/&lt;sha&gt;/&lt;path.md&gt;
-        </code>
-        . Heading hashes stay in the fragment, same as the local viewer.
-      </P>
-      <P>
-        Share a secret gist (requires <code className={code}>gh</code>
-        ):
-      </P>
-      <P>
-        <code className={code}>
-          npx @tanishqkancharla/diffmap share path/to.md
-        </code>
-      </P>
-      <P>
-        Secret gists are unlisted, not private. Anyone with the id can read
-        them. Unauthenticated GitHub API is 60 requests per hour per IP.
-      </P>
-      <P>
-        <Link href="https://github.com/tanishqkancharla/diffmap">
-          tanishqkancharla/diffmap
-        </Link>
-      </P>
-    </GistStatus>
-  );
-}
-
 const styles = {
   shell: style(flex({ direction: "column" }), {
     width: "100%",
@@ -117,7 +71,7 @@ const styles = {
     backgroundColor: colors.gray[4],
   }),
   header: style(
-    flex({ direction: "row", align: "center", justify: "between" }),
+    flex({ direction: "row", alignItems: "center", justifyContent: "between" }),
     spacing.padding({ x: 6, y: 3 }),
     flexItem({ size: "hug" }),
     border(["bottom"], "border"),
@@ -142,10 +96,7 @@ const styles = {
   title: style(text({ size: "xl", fontWeight: 600, color: "highContrast" }), {
     marginBottom: spacing.value(4),
   }),
-  loading: style(flex({ direction: "row", align: "center" }), {
+  loading: style(flex({ direction: "row", alignItems: "center" }), {
     minHeight: spacing.value(12),
   }),
-  code: style(text({ size: "sm", color: "highContrast" }), {
-    fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
-  }),
 };

package/src/host/HostHome.tsx

@@ -0,0 +1,73 @@
+import { useEffect, useState } from "react";
+import { Link, P } from "maui";
+import { init } from "md4x/standalone";
+import { parseViewerDocument } from "../parseViewer.ts";
+import type { ViewerDocument } from "../parseViewer.ts";
+import { ViewerApp } from "../viewer/ViewerApp.tsx";
+import { GistLoading, GistStatus } from "../gist/GistStatus.tsx";
+import { HostFilesContext } from "./files.ts";
+import homeSource from "./home.md?raw";
+import cliSource from "../cli.ts?raw";
+import shareSource from "../share.ts?raw";
+import parseViewerSource from "../parseViewer.ts?raw";
+import githubRouteSource from "../github/route.ts?raw";
+
+let parserReady: Promise<void> | undefined;
+
+function readyHostParser() {
+  parserReady ??= init();
+  return parserReady;
+}
+
+const hostFiles = {
+  "src/cli.ts": cliSource,
+  "src/share.ts": shareSource,
+  "src/parseViewer.ts": parseViewerSource,
+  "src/github/route.ts": githubRouteSource,
+};
+
+export function HostHome() {
+  const [view, setView] = useState<
+    | { kind: "loading" }
+    | { kind: "error"; message: string }
+    | { kind: "ready"; document: ViewerDocument }
+  >({ kind: "loading" });
+
+  useEffect(() => {
+    let cancelled = false;
+    // oxlint-disable-next-line typescript/no-floating-promises -- The effect owns this parse; ignore after unmount.
+    void readyHostParser().then(() => {
+      if (cancelled) return;
+      const parsed = parseViewerDocument(homeSource, "home.md");
+      if (parsed instanceof Error) {
+        setView({ kind: "error", message: parsed.message });
+        return;
+      }
+      setView({ kind: "ready", document: parsed });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  if (view.kind === "loading") return <GistLoading title="Loading…" />;
+  if (view.kind === "error") {
+    return (
+      <GistStatus title="Could not parse this walkthrough">
+        <P>{view.message}</P>
+      </GistStatus>
+    );
+  }
+
+  return (
+    <HostFilesContext.Provider value={hostFiles}>
+      <ViewerApp
+        document={view.document}
+        mode="host"
+        headerActions={
+          <Link href="https://github.com/tanishqkancharla/diffmap">GitHub</Link>
+        }
+      />
+    </HostFilesContext.Provider>
+  );
+}

package/src/host/files.ts

@@ -0,0 +1,10 @@
+import { createContext, useContext } from "react";
+
+/** Bundled files for the hosted homepage. `[[path]]` reads these, not GitHub. */
+export type HostFiles = Record<string, string>;
+
+export const HostFilesContext = createContext<HostFiles | undefined>(undefined);
+
+export function useHostFiles() {
+  return useContext(HostFilesContext);
+}

package/src/host/home.md

@@ -0,0 +1,194 @@
+# diffmap
+
+A viewer for specs and walkthroughs. Call stacks, mermaid that links into source, and a Diff panel. This page is one — `parseViewerDocument` plus `ViewerApp`, same path as `diffmap serve`.
+
+TOC on the left, article here, Diff on the right. Click a stack row or a mermaid node.
+
+## Install the skill
+
+```sh
+npx skills add tanishqkancharla/diffmap --skill generate-spec
+```
+
+That keeps a living spec in `specs/<name>.md`. Same file for the life of the work: what’s already in the tree, and what’s still planned. Don’t start a second walkthrough later.
+
+## Serve locally
+
+```sh
+npx @tanishqkancharla/diffmap serve specs/<name>.md
+```
+
+Bare `npx @tanishqkancharla/diffmap specs/<name>.md` is the same as `serve`. `list` shows running viewers — reuse the URL instead of starting a second server.
+
+**Close server** is only on that local page. This host has no process to stop.
+
+## Share
+
+### Gist
+
+```sh
+npx @tanishqkancharla/diffmap share specs/<name>.md
+```
+
+Prints `https://diffmap.dev/g/<gistId>` (optional `/<file.md>`). Secret gist: unlisted, not private. Anyone with the id can read it. Does not start a local server.
+
+### GitHub PR vs commit
+
+A spec on a public PR:
+
+`https://diffmap.dev/<owner>/<repo>/pull/<n>/specs/<name>.md`
+
+Pinned commit:
+
+`https://diffmap.dev/<owner>/<repo>/commit/<sha>/specs/<name>.md`
+
+The pin is one SHA. The markdown and every `[[path]]`, mermaid `%% ref`, excerpt, and hunk load from that commit, not `main`. A PR number only chooses the SHA (head at load, then pin). Refresh stays on the commit URL.
+
+## What the fences are
+
+### System flow
+
+Click a node. `%% ref` is a mermaid comment; `[[path]]` and `[[path#symbol]]` are the same references as on a stack row.
+
+```mermaid
+flowchart LR
+  Spec[Living spec] --> Serve[serve]
+  Spec --> Share[share]
+  Spec --> Pin[GitHub pin]
+  %% ref node:Spec [[src/parseViewer.ts#parseViewerDocument]]
+  %% ref node:Serve [[src/cli.ts]]
+  %% ref node:Share [[src/share.ts#shareMarkdownFile]]
+  %% ref node:Pin [[src/github/route.ts]]
+  %% ref edge:0 [[cli:new:50]]
+```
+
+````md
+```mermaid
+flowchart LR
+  Spec[Living spec] --> Serve[serve]
+  %% ref node:Serve [[src/cli.ts]]
+```
+````
+
+### Call stacks
+
+`-` is current, `+` is proposed. After a phase lands, retarget `[[path]]` to a hunk: `[[id:old:…]]` / `[[id:new:…]]`.
+
+```callstack
+ ViewerApp
+-└── CloseServerButton  # every hosted page tried to stop a server [[close:old:217]]
++└── CloseServerButton  # local mode only [[close:new:217-224]]
+     └── DiffButton
+```
+
+```callstack
+ shareMarkdownFile [[src/share.ts#shareMarkdownFile]]
+-└── print gist URL [[share:old:62]]
++└── gistViewerUrl  # https://diffmap.dev/g/<id> [[share:new:62]]
+```
+
+### Source patches
+
+Define each id once. Copy the real `git diff` (`diff --git`, `---`, `+++`, `@@`). Ranges have to sit inside an included hunk.
+
+```source-diff:cli:src/cli.ts
+diff --git a/src/cli.ts b/src/cli.ts
+--- a/src/cli.ts
++++ b/src/cli.ts
+@@ -49,4 +49,4 @@
+ const cli = Cli.create("diffmap", {
+-  description: "Serve a walkthrough",
++  description: "Serve a spec locally, or share it as a gist",
+   version: "0.1.3",
+   args: serveArgs,
+```
+
+```source-diff:share:src/share.ts
+diff --git a/src/share.ts b/src/share.ts
+--- a/src/share.ts
++++ b/src/share.ts
+@@ -59,6 +59,6 @@
+   return {
+     gistId,
+     gistUrl,
+-    viewerUrl: gistUrl,
++    viewerUrl: gistViewerUrl(gistId, undefined, process.env.DIFFMAP_ORIGIN),
+   };
+ }
+```
+
+```source-diff:close:src/viewer/ViewerApp.tsx
+diff --git a/src/viewer/ViewerApp.tsx b/src/viewer/ViewerApp.tsx
+--- a/src/viewer/ViewerApp.tsx
++++ b/src/viewer/ViewerApp.tsx
+@@ -216,3 +216,10 @@
+             {props.headerActions}
+-            <CloseServerButton onClick={() => setShutDown(true)} />
++            {props.mode === "local" && (
++              <CloseServerButton
++                onClick={() => {
++                  setShutDown(true);
++                  void closeViewer();
++                }}
++              />
++            )}
+           </div>
+```
+
+### File excerpts
+
+`start:end:path`. Locally the server reads the workspace file. Here the bundled file is sliced the same way.
+
+```58:72:src/cli.ts
+const cli = Cli.create("diffmap", {
+  description: "Serve a spec locally, or share it as a gist",
+  version: packageVersion,
+  args: serveArgs,
+  options: serveOptions,
+  output: serveOutput,
+  hint: "`serve <spec.md>` runs the local viewer. `share <spec.md>` publishes a secret gist. `update` (or `--update`) installs the latest diffmap.",
+  examples: [
+    {
+      args: { file: "spec.md" },
+      description: "Same as `diffmap serve spec.md`",
+    },
+  ],
+  run: runServe,
+})
+```
+
+### HTML
+
+Local `serve` trusts `html` in the file you pointed at. This host does not. Gist and GitHub pages are the same — no `dangerouslySetInnerHTML` from untrusted markdown.
+
+```html
+<aside>If this renders, the host leaked HTML.</aside>
+```
+
+## How a spec stays alive
+
+Write `specs/<name>.md`. Serve it while you plan. When the plan changes, edit this file. When a phase lands, paste the patch and retarget the links so the Diff panel opens the change, not just the file.
+
+### Phase 1: Spec and serve
+
+```callstack
+ generate-spec
+ └── specs/name.md
+     └── diffmap serve [[src/cli.ts]]
+```
+
+- [x] Install the skill.
+- [x] Keep one living spec.
+- [x] `diffmap serve` / `list`.
+
+### Phase 2: Share it
+
+```callstack
+ specs/name.md
+-└── localhost only
++├── diffmap share [[share:new:62]]
++└── GitHub PR URL [[src/github/route.ts]]
+```
+
+- [x] Gist URL for a snapshot.
+- [x] PR URL when the spec lives in the repo (pin to one SHA).

package/src/host/home.test.ts

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+import { parseViewerDocument } from "../parseViewer.ts";
+import type { ViewerNode } from "../parseViewer.ts";
+import type { Fence } from "../parseFence.ts";
+
+const homePath = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "home.md",
+);
+
+function collectFences(nodes: ViewerNode[]): Fence[] {
+  return nodes.flatMap((node) => {
+    if (node.type === "view") return [node.fence];
+    if (node.type === "element") return collectFences(node.children);
+    return [];
+  });
+}
+
+test("homepage markdown is a real viewer document", async () => {
+  const source = await fs.readFile(homePath, "utf8");
+  const document = parseViewerDocument(source, "home.md");
+  assert.equal(document instanceof Error, false);
+  if (document instanceof Error) return;
+
+  const fences = collectFences(document.nodes);
+  const kinds = new Set(fences.map((fence) => fence.kind));
+  assert.equal(kinds.has("mermaid"), true);
+  assert.equal(kinds.has("callstack"), true);
+  assert.equal(kinds.has("source-diff"), true);
+  assert.equal(kinds.has("file"), true);
+  assert.equal(kinds.has("html"), true);
+
+  const mermaid = fences.find((fence) => fence.kind === "mermaid");
+  assert.notEqual(mermaid, undefined);
+  if (mermaid?.kind !== "mermaid") return;
+  assert.equal(
+    mermaid.annotations.some((link) =>
+      link.annotation.references.some((ref) => ref.kind === "file"),
+    ),
+    true,
+  );
+  assert.equal(
+    mermaid.annotations.some((link) => link.target === "edge"),
+    true,
+  );
+
+  const stacks = fences.filter((fence) => fence.kind === "callstack");
+  assert.equal(
+    stacks.some((fence) =>
+      fence.kind === "callstack"
+        ? fence.lines.some((line) => line.text.startsWith("-")) &&
+          fence.lines.some((line) => line.text.startsWith("+"))
+        : false,
+    ),
+    true,
+  );
+
+  const levels = new Set(document.headings.map((heading) => heading.level));
+  assert.equal(levels.has(1), true);
+  assert.equal(levels.has(2), true);
+  assert.equal(levels.has(3), true);
+  assert.ok(document.sourceDiffs.length >= 3);
+  assert.equal(document.hasReferences, true);
+
+  const excerpt = fences.find(
+    (fence) => fence.kind === "file" && fence.path === "src/cli.ts",
+  );
+  assert.equal(excerpt?.kind, "file");
+  if (excerpt?.kind !== "file") return;
+  const cliPath = path.join(path.dirname(homePath), "..", "cli.ts");
+  const cli = await fs.readFile(cliPath, "utf8");
+  const lines = cli.split(/\n/);
+  const slice = lines.slice(excerpt.start - 1, excerpt.end).join("\n");
+  assert.equal(lines[excerpt.start - 1]?.trim().length !== 0, true);
+  assert.match(slice, /packageVersion/);
+  assert.match(slice, /\}\)\s*$/);
+  assert.equal(excerpt.source, slice);
+});

package/src/packageVersion.ts

@@ -0,0 +1,7 @@
+import { readFileSync } from "node:fs";
+
+const packageJson = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+) as { version: string };
+
+export const packageVersion = packageJson.version;