@heyramzi/ui 0.0.0-stage → 1.53.0

package/scripts/sf-symbol.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+// Print the `sf-symbols.ts` entry for an SF Symbol, read off this Mac. node packages/ui/scripts/sf-symbol.mjs macwindow
+
+// The SF Symbols app is the better source when somebody has it open, because its export is the artwork Apple ships for that symbol at that weight.
+
+// This is for the rest of the time: it asks macOS for the symbol it would draw, takes the outline, and writes it in the same unit space the app's
+
+// exports use. How it gets a vector out of an image: `NSImage(systemSymbolName:)` hands back an `NSSymbolImageRep`, which answers `outlinePath` with the CGPath it fills.
+
+// Drawing that image into a PDF context does not work, because AppKit rasterises it into an image mask.
+
+// `outlinePath` is not API, which is why this is a script somebody runs on their own machine rather than anything the package ships.
+
+// The space: at 512pt Regular Medium the outline measures exactly twice the app's export on both axes, checked against folder, doc.on.doc and magnifyingglass,
+
+// so SCALE is 0.5 and the result drops straight into the shared 768 canvas. trash is the one symbol where the two disagree beyond that,
+
+// macOS 26 having redrawn its lid a little taller, which is a reason to prefer a fresh export when there is one.
+
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const SCALE = 0.5;
+
+const SWIFT = `
+import AppKit
+let cfg = NSImage.SymbolConfiguration(pointSize: 512, weight: .regular, scale: .medium)
+guard let rep = NSImage(systemSymbolName: CommandLine.arguments[1], accessibilityDescription: nil)?
+        .withSymbolConfiguration(cfg)?.representations.first,
+      let raw = rep.value(forKey: "outlinePath") else {
+    FileHandle.standardError.write("no such symbol\\n".data(using: .utf8)!)
+    exit(2)
+}
+print(CFCopyDescription(raw as CFTypeRef)! as String)
+`;
+
+const name = process.argv[2];
+if (!name) {
+  console.error("usage: sf-symbol.mjs <symbol-name>");
+  process.exit(1);
+}
+
+const swiftFile = join(mkdtempSync(join(tmpdir(), "sf-symbol-")), "outline.swift");
+writeFileSync(swiftFile, SWIFT);
+const dump = execFileSync("swift", [swiftFile, name], {
+  encoding: "utf8",
+  maxBuffer: 64 * 1024 * 1024,
+});
+
+/** CGPath's own description, which lists one segment per line in PostScript order. */
+const commands = [];
+for (const line of dump.split("\n")) {
+  const parts = line.trim().split(/\s+/);
+  const numbers = parts.slice(0, -1).map(Number);
+  if (numbers.some(Number.isNaN)) continue;
+  const letter = { moveto: "M", lineto: "L", curveto: "C", closepath: "Z" }[parts.at(-1)];
+  if (letter) commands.push([letter, letter === "Z" ? [] : numbers]);
+}
+
+if (!commands.length) {
+  console.error(`no outline for ${name}`);
+  process.exit(2);
+}
+
+const xs = [];
+const ys = [];
+for (const [, numbers] of commands) {
+  for (const [i, value] of numbers.entries()) (i % 2 ? ys : xs).push(value);
+}
+const minX = Math.min(...xs);
+const minY = Math.min(...ys);
+
+/** Three decimals, which is what the app's own exports carry. */
+const round = (value) => Math.round(value * SCALE * 1000) / 1000;
+
+const d = commands
+  .map(([letter, numbers]) =>
+    letter === "Z"
+      ? "Z"
+      : letter + numbers.map((v, i) => round(v - (i % 2 ? minY : minX))).join(" "),
+  )
+  .join("");
+
+const key = /^[a-z][\w]*$/i.test(name) ? name : `"${name}"`;
+console.log(`  ${key}: {
+    w: ${round(Math.max(...xs) - minX)},
+    h: ${round(Math.max(...ys) - minY)},
+    paths: [
+      "${d}",
+    ],
+  },`);

package/scripts/sync-shadcn.mjs

@@ -0,0 +1,354 @@
+#!/usr/bin/env node
+/* Sync shadcn-svelte into src/shadcn and its demos into the site, three-way
+ * per file against `.upstream/`. The rules and why: ../docs/decisions.md. */
+
+//   pnpm sync:shadcn          fetch, vendor, apply, report
+//   pnpm sync:shadcn --check  fail if upstream moved (CI / pre-release)
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { basename, dirname, relative, resolve } from "node:path";
+import {
+  CHECK,
+  classify,
+  fetchJson,
+  fetchTextIf,
+  mapLimit,
+  readLock,
+  removeDeep,
+  report,
+  sha256,
+  writeFileDeep,
+} from "./lib/sync-core.mjs";
+
+/* The vega style's registry. The bare /registry lacks the chat parts (bubble,
+ * message, marker, attachment); same item and file shape otherwise. */
+const REGISTRY = "https://shadcn-svelte.com/registry/styles/vega";
+const WANTED = new Set(["registry:ui", "registry:hook", "registry:lib"]);
+
+const PKG = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const ROOT = resolve(PKG, "../..");
+const VENDOR = `${PKG}/.upstream/shadcn`;
+const LOCK = `${PKG}/.upstream/shadcn.lock.json`;
+const LOCAL = `${PKG}/src/shadcn`;
+
+/** Ours by choice, not upstream's: don't report them as drift. */
+const LOCAL_ONLY = new Set(["hooks"]);
+
+/* The registry's aliases, resolved to what this package imports. Absolute
+ * `#src/` form, so a nested target resolves without counting `../`. */
+const ALIASES = [
+  ["$UTILS$.js", "@heyramzi/utils"],
+  ["$UI$/", "../src/shadcn"],
+  ["$HOOKS$/", "../src/shadcn/hooks"],
+  ["$LIB$/", "../src/shadcn/hooks"],
+];
+
+/* Upstream target path -> ours, where the two differ. Everything else lands at
+ * src/shadcn/<target>. */
+const REROUTE = {
+  "is-mobile/is-mobile.svelte.ts": "src/shadcn/hooks/is-mobile.svelte.ts",
+  "highlighter/highlighter.ts": "src/shadcn/hooks/highlighter.ts",
+  "use-highlighted-code/use-highlighted-code.svelte.ts":
+    "src/shadcn/hooks/use-highlighted-code.svelte.ts",
+};
+
+const DOCS = "https://raw.githubusercontent.com/huntabyte/shadcn-svelte/main/docs";
+const DEMO_VENDOR = `${PKG}/.upstream/shadcn-demos`;
+const DEMO_LOCAL = `${ROOT}/site/src/lib/shadcn-demos`;
+const DEMO_MANIFEST = `${DEMO_LOCAL}/index.ts`;
+
+/* The docs site's aliases. A demo is a docs file, not a registry payload, so it
+ * carries `$lib/...` rather than the registry's `$UI$`. */
+const DEMO_ALIASES = [
+  ["$lib/registry/ui/", "@heyramzi/ui/shadcn/"],
+  // A handful reach their neighbour by relative path instead of the alias.
+  ["../ui/", "@heyramzi/ui/shadcn/"],
+  ["$lib/registry/hooks/", "@heyramzi/ui/shadcn/hooks/"],
+  ["$lib/utils.js", "@heyramzi/utils"],
+  // The peer here is the runes build, published under its own name.
+  ["@tabler/icons-svelte/", "@tabler/icons-svelte-runes/"],
+];
+
+/* Registry primitives this package does not ship: no product imports them. Skipped, so a sync does not bring them back. */
+const NOT_SHIPPED = new Set([
+  "aspect-ratio",
+  "button-group",
+  "carousel",
+  "chart",
+  "data-table",
+  "drawer",
+  "form",
+  "input-group",
+  "item",
+  "kbd",
+  "menubar",
+  "native-select",
+  "navigation-menu",
+  "pagination",
+  "range-calendar",
+  "resizable",
+  // Its `pascalToKebab` has no importer, in the registry or here.
+  "casing",
+  // `cn` ships from @heyramzi/utils in vibe-kit, so a copy here would be a stray.
+  "utils",
+  "questionnaire",
+]);
+
+/* No demo to take: `hooks`, `is-mobile` and `utils` are not components, and `sidebar` demos as a page block. */
+const NO_DEMO = new Set([
+  "hooks",
+  "is-mobile",
+  "highlighter",
+  "use-highlighted-code",
+  "sidebar",
+  "utils",
+]);
+
+const adapt = (text) => ALIASES.reduce((acc, [from, to]) => acc.replaceAll(from, to), text);
+/* The site imports the kit the way a consumer does, so the exports map names a
+ * primitive without its `/index.js` and a hook without its `.js`. */
+const adaptDemo = (text) =>
+  DEMO_ALIASES.reduce((acc, [from, to]) => acc.replaceAll(from, to), text)
+    .replace(/(@heyramzi\/ui\/shadcn\/[a-z-]+)\/index\.js/g, "$1")
+    .replace(/(@heyramzi\/ui\/shadcn\/hooks\/[a-z-]+(?:\.svelte)?)\.js/g, "$1");
+const readIf = (path) => (existsSync(path) ? readFileSync(path, "utf8") : null);
+const route = (name, target) => `${PKG}/${REROUTE[`${name}/${target}`] ?? `src/shadcn/${target}`}`;
+/** Report a file by where it lives here, not by its upstream target. */
+const label = (path) => (path.startsWith(`${PKG}/`) ? path.slice(PKG.length + 1) : relative(ROOT, path));
+
+const pascal = (name) => name.replace(/(^|-)([a-z])/g, (_, __, c) => c.toUpperCase());
+
+/** Title and one-line description from the component's docs page. */
+const meta = (doc, name) => {
+  const head = doc?.match(/^---\n([\s\S]*?)\n---/)?.[1] ?? "";
+  const field = (key) =>
+    head
+      .match(new RegExp(`^${key}:\\s*(.+)$`, "m"))?.[1]
+      .trim()
+      .replace(/^["']|["']$/g, "");
+  return { title: field("title") ?? pascal(name), note: field("description") ?? "" };
+};
+
+/** The demo's own shadcn imports, as it spells them for a consumer. */
+const publicImports = (demo) =>
+  [...demo.matchAll(/import[^;]*?from\s+"@heyramzi\/ui\/shadcn\/[^"]+";/g)]
+    .map((m) => m[0])
+    .join("\n");
+
+/* The section's list, generated: a primitive reaches the page by being synced,
+ * never by being typed into an array. */
+async function writeManifest(demos) {
+  const rows = demos.map(
+    (d) =>
+      `  { name: ${JSON.stringify(d.name)}, title: ${JSON.stringify(d.title)}, note: ${JSON.stringify(d.note)}, path: ${JSON.stringify(d.imports)}, Comp: ${pascal(d.name)}Demo },`,
+  );
+  const text = [
+    "/* Generated by scripts/sync-shadcn.mjs. Do not edit: the demos are upstream's",
+    " * own, and the sync rewrites this list. */",
+    'import type { Component } from "svelte";',
+    ...demos.map(
+      (d) => `import ${pascal(d.name)}Demo from "./${d.name}.svelte";`,
+    ),
+    "",
+    "export type ShadcnDemo = {",
+    "  name: string;",
+    "  title: string;",
+    "  note: string;",
+    "  path: string;",
+    "  Comp: Component;",
+    "};",
+    "",
+    "export const SHADCN_DEMOS: ShadcnDemo[] = [",
+    ...rows,
+    "];",
+    "",
+  ].join("\n");
+  if (readIf(DEMO_MANIFEST) === text) return;
+  await writeFileDeep(DEMO_MANIFEST, text);
+  written.push(DEMO_MANIFEST);
+}
+
+const walk = (dir, base = "") =>
+  existsSync(dir)
+    ? readdirSync(dir, { withFileTypes: true }).flatMap((e) =>
+        e.isDirectory() ? walk(`${dir}/${e.name}`, `${base}${e.name}/`) : [`${base}${e.name}`],
+      )
+    : [];
+
+const index = await fetchJson(`${REGISTRY}/index.json`);
+const items = (Array.isArray(index) ? index : (index.items ?? [])).filter(
+  (i) => WANTED.has(i.type) && !NOT_SHIPPED.has(i.name),
+);
+
+const fetched = await mapLimit(items, 8, async (item) => ({
+  item,
+  payload: await fetchJson(`${REGISTRY}/${item.relativeUrl ?? `${item.name}.json`}`),
+}));
+
+const previous = (await readLock(LOCK))?.entries ?? {};
+const entries = {};
+const buckets = { synced: [], added: [], port: [], removed: [], unported: [] };
+const written = [];
+let unchanged = 0;
+
+for (const { item, payload } of fetched) {
+  const files = (payload.files ?? []).map((f) => ({
+    target: f.target ?? f.path,
+    content: f.content ?? "",
+  }));
+  // One hash per component, so the lock diff reads as a list of what moved.
+  const hash = sha256(files.map((f) => `${f.target}:${f.content}`).join("|"));
+
+  const states = files.map((f) => {
+    const base = readIf(`${VENDOR}/${item.name}/${f.target}`);
+    const next = adapt(f.content);
+    const path = route(item.name, f.target);
+    const state = classify(readIf(path), base === null ? null : adapt(base), next);
+    return { ...f, path, next, state, moved: base !== f.content };
+  });
+
+  /* Upstream deleted these since the last sync. Ours goes only when it was
+   * still the pristine copy of what upstream deleted. */
+  const gone = walk(`${VENDOR}/${item.name}`)
+    .filter((target) => !files.some((f) => f.target === target))
+    .map((target) => {
+      const path = route(item.name, target);
+      const base = adapt(readIf(`${VENDOR}/${item.name}/${target}`));
+      // Ours the moment it is not the pristine copy of what upstream deleted.
+      return { target, path, ours: classify(readIf(path), base, base) === "diverged" };
+    });
+
+  const moved = states.filter((s) => s.moved);
+  const fresh = !existsSync(`${LOCAL}/${item.name}`) && states.every((s) => s.state === "new");
+  const blocked =
+    states.some((s) => s.state === "dropped") ||
+    moved.some((s) => s.state === "diverged") ||
+    gone.some((g) => g.ours);
+  const apply = blocked ? [] : moved.filter((s) => s.state !== "current");
+  const drop = blocked ? [] : gone;
+
+  const adapted = states.filter((s) => s.state === "diverged" || s.state === "dropped");
+  entries[item.name] = {
+    type: item.type,
+    files: files.length,
+    sha256: hash,
+    ...(adapted.length ? { adapted: adapted.map((s) => s.target) } : {}),
+  };
+
+  if (!moved.length && !gone.length) unchanged++;
+  else if (fresh) buckets.added.push(`${item.name} — ${files.length} files, new primitive`);
+  else if (blocked)
+    for (const s of moved) buckets.port.push(`${label(s.path)} — upstream moved, ${s.state} here`);
+  else if (apply.length)
+    buckets.synced.push(`${item.name} — ${apply.map((s) => basename(s.path)).join(", ")}`);
+
+  for (const g of gone)
+    buckets.removed.push(`${label(g.path)} — gone upstream${g.ours ? ", kept (ours)" : ""}`);
+
+  if (CHECK) continue;
+
+  for (const s of apply) {
+    await writeFileDeep(s.path, s.next);
+    written.push(s.path);
+  }
+  for (const g of drop) await removeDeep(g.path);
+
+  await removeDeep(`${VENDOR}/${item.name}`);
+  for (const f of files) await writeFileDeep(`${VENDOR}/${item.name}/${f.target}`, f.content);
+}
+
+for (const name of Object.keys(previous)) {
+  if (entries[name]) continue;
+  buckets.removed.push(`${name} — gone from the registry`);
+  if (!CHECK) await removeDeep(`${VENDOR}/${name}`);
+}
+
+const ours = readdirSync(LOCAL, { withFileTypes: true })
+  .filter((e) => e.isDirectory() && !entries[e.name] && !LOCAL_ONLY.has(e.name))
+  .map((e) => e.name);
+for (const name of ours) buckets.unported.push(`${name} — in src/shadcn, not in the registry`);
+
+/* The docs site's own demo for each primitive, vendored on the same three-way
+ * rule. Upstream writes them; the site renders them. */
+const demoNames = [...Object.keys(entries), ...LOCAL_ONLY]
+  .filter((name) => !NO_DEMO.has(name))
+  .toSorted();
+
+const manifest = [];
+
+for (const name of demoNames) {
+  const [raw, doc] = await Promise.all([
+    fetchTextIf(`${DOCS}/src/lib/registry/examples/${name}-demo.svelte`),
+    fetchTextIf(`${DOCS}/content/components/${name}.md`),
+  ]);
+  if (raw === null) {
+    buckets.unported.push(`${name} — no demo upstream`);
+    continue;
+  }
+
+  const path = `${DEMO_LOCAL}/${name}.svelte`;
+  const base = readIf(`${DEMO_VENDOR}/${name}.svelte`);
+  const next = adaptDemo(raw);
+  const local = readIf(path);
+  const state = classify(local, base === null ? null : adaptDemo(base), next);
+  // The imports of the demo that renders: ours when kept, upstream's when written.
+  const shown = state === "diverged" ? local : next;
+
+  if (state === "dropped") buckets.removed.push(`${label(path)} — dropped here, kept out`);
+  else manifest.push({ name, ...meta(doc, name), imports: publicImports(shown) });
+
+  if (base !== raw) {
+    if (state === "diverged") buckets.port.push(`${label(path)} — upstream moved, ours here`);
+    else if (state !== "current") buckets.synced.push(`${name} — demo`);
+  }
+  if (CHECK) continue;
+
+  if (state === "stale" || state === "new") {
+    await writeFileDeep(path, next);
+    written.push(path);
+  }
+  await writeFileDeep(`${DEMO_VENDOR}/${name}.svelte`, raw);
+}
+
+if (!CHECK) await writeManifest(manifest);
+
+/* Upstream ships prettier with tabs everywhere; .ts here is spaces. Root cwd,
+ * because the fmt options live in the workspace vite.config.ts. */
+if (written.length) {
+  try {
+    execFileSync("pnpm", ["exec", "vp", "fmt", ...written], { cwd: ROOT, stdio: "pipe" });
+  } catch (error) {
+    console.error(`\n  vp fmt failed, ${written.length} written files are unformatted`);
+    console.error(`  ${error.message}`);
+  }
+}
+
+if (!CHECK) {
+  await writeFileDeep(
+    LOCK,
+    `${JSON.stringify(
+      {
+        source: "https://github.com/huntabyte/shadcn-svelte",
+        registry: `${REGISTRY}/index.json`,
+        fetchedAt: new Date().toISOString().slice(0, 10),
+        components: items.length,
+        localOnly: [...LOCAL_ONLY],
+        entries,
+      },
+      null,
+      "\t",
+    )}\n`,
+  );
+}
+
+process.exit(
+  report({
+    title: `shadcn-svelte — ${items.length} primitives`,
+    buckets,
+    unchanged,
+    footer: `${Object.values(entries).filter((e) => e.adapted).length} adapted here, ${LOCAL_ONLY.size} ours`,
+    trailer: `Wrote ${written.length} file${written.length === 1 ? "" : "s"}. Review \`git diff src/\`; the ! lines are yours to port.`,
+  }),
+);

package/scripts/sync-transitions.mjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+/*
+ * Sync the free transitions.dev catalogue.
+ */
+
+/*
+ * pnpm sync:transitions          fetch, vendor, report pnpm sync:transitions --check  fail if upstream moved (CI / pre-release)
+ */
+
+/*
+ * Upstream ships every transition in one JSON with a `pro` flag.
+ */
+
+/*
+ * Paid ones are dropped here and never vendored — Ramzi, 14 Sep 2026: "the pro effects we don't need them".
+ */
+
+/*
+ * Everything free lands in `.upstream/transitions/` as the pristine copy; our adapted, token-fed version lives in `src/animations/`. PORTED maps one to the other. See ../src/animations/README.md.
+ */
+
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import {
+  CHECK,
+  fetchJson,
+  githubHeadSha,
+  readLock,
+  removeDeep,
+  report,
+  sha256,
+  writeFileDeep,
+} from "./lib/sync-core.mjs";
+
+const REPO = "Jakubantalik/transitions.dev";
+const DATA = `https://raw.githubusercontent.com/${REPO}/main/scripts/transitions-data.json`;
+
+const PKG = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const VENDOR = `${PKG}/.upstream/transitions`;
+const LOCK = `${PKG}/.upstream/transitions.lock.json`;
+const SRC = `${PKG}/src`;
+
+/*
+ * upstream slug -> the file under src/ that owns it.
+ */
+
+/*
+ * Fourteen of these name the component that owns the motion instead of a file in src/animations.
+ */
+
+/*
+ * A slug absent from this map is reported as unported. The reasoning is in ../src/animations/README.md.
+ */
+const PORTED = {
+  "card-resize": "animations/resize.css",
+  "number-pop-in": "animations/digit-pop-in.css",
+  "notification-badge": "shadcn/badge/badge.svelte",
+  "text-states-swap": "animations/text-swap.css",
+  "menu-dropdown": "animations/dropdown.css",
+  "modal-open-close": "animations/modal.css",
+  "panel-reveal": "shadcn/sheet/sheet-content.svelte",
+  "page-side-by-side": "animations/page-side-by-side.css",
+  "icon-swap": "effects/theme-toggle/ThemeToggle.svelte",
+  "success-check": "animations/success-check.css",
+  "avatar-group-hover": "animations/avatar-group-hover.css",
+  "error-state-shake": "animations/input-shake.css",
+  "input-clear-with-dissolve": "animations/input-clear-dissolve.css",
+  "skeleton-loader-and-reveal": "shadcn/skeleton/skeleton.svelte",
+  "texts-reveal": "effects/reveal/TextEffect.svelte",
+  "tabs-sliding": "shadcn/tabs/tabs-list.svelte",
+  "shimmer-text": "animations/shimmer-text.css",
+  "tooltip-open-close": "shadcn/tooltip/tooltip-content.svelte",
+  "3d-tilt": "animations/card-tilt.css",
+  "dropdown-menu-morph": "animations/plus-menu-morph.css",
+  accordion: "shadcn/accordion/accordion-content.svelte",
+  "like-button": "animations/like-button.css",
+  "learn-more-hover": "animations/learn-more-hover.css",
+  "spinning-counter": "animations/spinning-counter.css",
+  "thinking-states": "animations/thinking-states.css",
+  "reasoning-stream": "ai/reasoning/ReasoningContent.svelte",
+  "streaming-text": "effects/reveal/TextEffect.svelte",
+  toggle: "shadcn/switch/switch.svelte",
+  "checkbox-check": "shadcn/checkbox/checkbox.svelte",
+  "toast-open-close": "shadcn/sonner/sonner.svelte",
+  "banner-stacking": "shadcn/sonner/sonner.svelte",
+  "matrix-dot-loader": "ai/loading-state/PixelLoader.svelte",
+};
+
+const catalogue = await fetchJson(DATA);
+const free = catalogue.filter((t) => !t.pro);
+const paid = catalogue.length - free.length;
+
+const previous = (await readLock(LOCK))?.entries ?? {};
+const entries = {};
+const buckets = { added: [], changed: [], removed: [], unported: [] };
+let unchanged = 0;
+
+for (const { slug, name, css } of free) {
+  const hash = sha256(css);
+  entries[slug] = { name, sha256: hash, local: PORTED[slug] ?? null };
+
+  if (!previous[slug]) buckets.added.push(`${slug} — ${name}`);
+  else if (previous[slug].sha256 !== hash) buckets.changed.push(`${slug} — ${name}`);
+  else unchanged++;
+
+  if (!PORTED[slug]) buckets.unported.push(`${slug} — nothing under src/ owns it`);
+  else if (!existsSync(`${SRC}/${PORTED[slug]}`))
+    buckets.unported.push(`${slug} — PORTED says ${PORTED[slug]}, which is missing`);
+
+  if (!CHECK) await writeFileDeep(`${VENDOR}/${slug}.css`, css);
+}
+
+for (const slug of Object.keys(previous)) {
+  if (entries[slug]) continue;
+  buckets.removed.push(`${slug} — gone upstream or moved to pro`);
+  if (!CHECK) await removeDeep(`${VENDOR}/${slug}.css`);
+}
+
+if (!CHECK) {
+  await writeFileDeep(
+    LOCK,
+    `${JSON.stringify(
+      {
+        source: `https://github.com/${REPO}`,
+        data: DATA,
+        ref: await githubHeadSha(REPO),
+        fetchedAt: new Date().toISOString().slice(0, 10),
+        free: free.length,
+        skippedPro: paid,
+        entries,
+      },
+      null,
+      "\t",
+    )}\n`,
+  );
+}
+
+process.exit(
+  report({
+    title: `transitions.dev — ${free.length} free`,
+    buckets,
+    unchanged,
+    footer: `${paid} pro skipped`,
+  }),
+);

package/scripts/validate-apple-symbol-exports.mjs

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import { sfSymbolExports } from "../src/icons/apple-symbol-exports.ts";
+
+const token = /[MLCZ]|[-+]?(?:\d*\.\d+|\d+\.?\d*)(?:e[-+]?\d+)?/gi;
+const arity = { M: 2, L: 2, C: 6, Z: 0 };
+
+for (const [name, symbol] of Object.entries(sfSymbolExports)) {
+  for (const dimension of [symbol.w, symbol.h, symbol.units]) {
+    assert(Number.isFinite(dimension) && dimension > 0, `${name}: invalid dimension`);
+  }
+  assert(symbol.opacity >= 0 && symbol.opacity <= 1, `${name}: invalid opacity`);
+  assert(symbol.paths.length > 0, `${name}: no paths`);
+  for (const d of symbol.paths) {
+    assert(
+      d.startsWith("M") && d.endsWith("Z"),
+      `${name}: path must start with M and close with Z`,
+    );
+    assert(d.replace(token, "").trim() === "", `${name}: unexpected path text`);
+    const tokens = d.match(token);
+    let command;
+    let count = 0;
+    const complete = () => {
+      if (!command) return;
+      assert(
+        arity[command] === 0 ? count === 0 : count > 0 && count % arity[command] === 0,
+        `${name}: invalid ${command} coordinates`,
+      );
+    };
+    for (const value of tokens) {
+      if (value in arity) {
+        complete();
+        command = value;
+        count = 0;
+      } else {
+        assert(command && Number.isFinite(Number(value)), `${name}: invalid coordinate`);
+        count++;
+      }
+    }
+    complete();
+  }
+}
+
+console.log(
+  `Validated ${Object.keys(sfSymbolExports).length} supplied Apple exports: dimensions, opacity and complete SVG path commands.`,
+);