lecodes-sdk 1.1.0 → 2.0.0

package/src/compile/__tests__/compile.test.ts

@@ -1,310 +0,0 @@
-import { test, expect } from "bun:test"
-import { compileProject } from "../compileProject"
-import { buildHeader, detectProjectKind } from "../header"
-import { desugarAssetMacros } from "../assetMacro"
-
-// The parity suite. This is the guard that lets the backend / CLI / renderer share ONE compiler:
-// it pins the header output, the engine-detection signals, the resource/shader/svg file kinds, and
-// the 2D↔3D tree-shake disjointness. No host is needed — we assert on the bundled text.
-
-test("a 3D project (new Scene) gets a name header and keeps GL enabled", async () => {
-  const js = await compileProject({
-    name: "Demo Project",
-    publicUrl: "https://le.codes",
-    entries: [ { path: "/main.ts", type: "text", text: "const s = new Scene()\nconsole.log(s)\n" } ],
-  })
-  expect(js).toContain("// name: Demo Project")
-  expect(js).not.toContain("// gl: disable") // createScene present → GL enabled
-  expect(js).toContain("_creator.createScene") // the SDK runtime got inlined
-})
-
-test("a UI-only project (no _creator) is marked gl: disable", async () => {
-  const js = await compileProject({
-    name: "UI",
-    publicUrl: "https://le.codes",
-    entries: [ { path: "/main.ts", type: "text", text: "toast('hello')\nconsole.log(1)\n" } ],
-  })
-  expect(js).toContain("// gl: disable")
-  expect(js).not.toContain("// 2d: enable")
-})
-
-test("a 2D project (new Scene2D) is marked 2d: enable and gl: disable", async () => {
-  const js = await compileProject({
-    name: "RPG",
-    publicUrl: "https://le.codes",
-    entries: [ { path: "/main.ts", type: "text", text: "const s = new Scene2D()\ns.open()\n" } ],
-  })
-  expect(js).toContain("// 2d: enable") // 2D-aware hosts bring up creator-2d
-  expect(js).toContain("// gl: disable") // every host skips Filament
-  expect(js).toContain("_creator2d.createScene")
-})
-
-test("a 3D project with a Canvas is NOT marked 2d: enable (Canvas keeps a `_creator2d.` texture path)", async () => {
-  const js = await compileProject({
-    name: "Car",
-    publicUrl: "https://le.codes",
-    entries: [ { path: "/main.ts", type: "text", text: "const c = new Canvas(64, 64)\nc.update()\nnew Scene().open()\n" } ],
-  })
-  expect(js).toContain("_creator2d.") // the canvas 2D-texture path survives tree-shaking
-  expect(js).not.toContain("// 2d: enable") // …but no Scene2D → the 2D engine is not in use
-  expect(js).not.toContain("// gl: disable")
-})
-
-test("2D and 3D bundles are DISJOINT (tree-shake drops the other engine)", async () => {
-  const twoD = await compileProject({
-    name: "2D", publicUrl: "https://le.codes", header: false,
-    entries: [ { path: "/main.ts", type: "text", text: "new Scene2D().open()\n" } ],
-  })
-  const threeD = await compileProject({
-    name: "3D", publicUrl: "https://le.codes", header: false,
-    entries: [ { path: "/main.ts", type: "text", text: "new Scene().open()\n" } ],
-  })
-  expect(twoD).toContain("_creator2d.")
-  expect(twoD).not.toContain("_creator.createScene")
-  expect(threeD).toContain("_creator.createScene")
-  expect(threeD).not.toContain("_creator2d.")
-})
-
-test("preload header extracts local-asset signals from the bundle", () => {
-  // The contract is keyed on the bundled `_creatorUtils.fetchLocal(<literal>)` call and the implicit
-  // engine archives. (Matches the worker bundler byte-for-byte: a literal arg is captured; a call
-  // through the fetchLocal wrapper captures its param name `path`, same as today.)
-  expect(buildHeader("n", '_creatorUtils.fetchLocal("hero.glb")')).toContain("// preload: hero.glb")
-  expect(buildHeader("n", "_creator.createGlb(x)")).toContain("// preload: uberarchive")
-  expect(buildHeader("n", "_creator.captureImage(s)")).toContain("// preload: capture")
-})
-
-test("resource and shader files become URL modules (asset URLs from server metadata)", async () => {
-  const js = await compileProject({
-    name: "Assets",
-    publicUrl: "https://le.codes",
-    entries: [
-      {
-        path: "/main.ts",
-        type: "text",
-        text: "import logo from \"./logo.png\"\nimport mat from \"./m.mat\"\nconst s = new Scene()\nconsole.log(logo, mat, s)\n",
-      },
-      { path: "/logo.png", type: "resource", fileSrc: "/uploads/logo123.png" },
-      {
-        path: "/m.mat",
-        type: "shader",
-        shaders: [
-          { platform: "opengl", src: "/uploads/sh_opengl.filamat" },
-          { platform: "metal", src: "/uploads/sh_metal.filamat" },
-          { platform: "desktop", src: "/uploads/sh_desktop.filamat" },
-        ],
-      },
-    ],
-  })
-  expect(js).toContain("https://le.codes/uploads/logo123.png") // resource URL inlined
-  expect(js).toContain("_creator.backend") // shader URL uses the runtime backend
-})
-
-test("locally compiled shaders load through fetchLocal (host with no asset server)", async () => {
-  // `shadersLocal` = the CLI compiled the .mat itself and stages the artifacts next to the
-  // bundle, so the module resolves a LOCAL file instead of a URL. The name is assembled at
-  // RUNTIME: one bundle serves every native backend (desktop host = "desktop" on Windows,
-  // "opengl" on Linux, Apple = "metal").
-  const js = await compileProject({
-    name: "Local shader",
-    publicUrl: "https://le.codes",
-    localAssets: true,
-    minify: false,
-    entries: [
-      { path: "/main.ts", type: "text", text: `import mat from "./m.mat"
-console.log(mat)
-` },
-      {
-        path: "/m.mat",
-        type: "shader",
-        shadersLocal: true,
-        shaders: [
-          { platform: "opengl", src: "abc123_opengl.filamat" },
-          { platform: "metal", src: "abc123_metal.filamat" },
-          { platform: "desktop", src: "abc123_desktop.filamat" },
-        ],
-      },
-    ],
-  })
-  expect(js).toContain('_creatorUtils.fetchLocal("abc123_" + _creator.backend + ".filamat")')
-  expect(js).toContain('"id:"')          // the host's local-resource scheme, like asset()
-  expect(js).not.toContain("https://le.codes/abc123") // never a URL in this mode
-})
-
-test("a shader with server artifacts keeps its URL even under localAssets", async () => {
-  // Only entries the CLI actually compiled+staged carry `shadersLocal`. A server-backed project
-  // whose shaders came from the backend must NOT be rewritten to fetchLocal — nothing staged
-  // those files next to the bundle.
-  const js = await compileProject({
-    name: "Server shader",
-    publicUrl: "https://le.codes",
-    localAssets: true,
-    minify: false,
-    entries: [
-      { path: "/main.ts", type: "text", text: `import mat from "./m.mat"
-console.log(mat)
-` },
-      {
-        path: "/m.mat",
-        type: "shader",
-        shaders: [
-          { platform: "opengl", src: "/uploads/sh_opengl.filamat" },
-          { platform: "metal", src: "/uploads/sh_metal.filamat" },
-          { platform: "desktop", src: "/uploads/sh_desktop.filamat" },
-        ],
-      },
-    ],
-  })
-  expect(js).toContain("https://le.codes/uploads/sh_")
-  expect(js).not.toContain("fetchLocal")
-})
-
-test("a computed fetchLocal argument never lands in the preload header", () => {
-  // The local-shader lookup builds its name at runtime; only literal names are files to preload.
-  const header = buildHeader("n", '_creatorUtils.fetchLocal("abc_" + _creator.backend + ".filamat")')
-  expect(header).not.toContain("// preload:")
-  expect(buildHeader("n", '_creatorUtils.fetchLocal("hero.glb")')).toContain("// preload: hero.glb")
-})
-
-test("asset() desugaring never shifts original line numbers (source-map integrity)", () => {
-  // The bundle's source map is used against the ORIGINAL file the editor shows (error overlay,
-  // element inspector). Injected import lines at the top would offset every following line.
-  const src = "const a = asset('./x.png')\nconst b = asset('./y.png')\nconst c = asset('./x.png')\nconsole.log(a, b, c)"
-  const out = desugarAssetMacros(src, "/main.ts")
-  const lines = out.split("\n")
-  expect(lines[0]).toBe("const a = __asset_0")
-  expect(lines[1]).toBe("const b = __asset_1")
-  expect(lines[2]).toBe("const c = __asset_0") // identical path → one identifier
-  expect(lines[3]).toBe("console.log(a, b, c)")
-  // The imports live AFTER the original content (ESM hoists them, so position is irrelevant).
-  expect(out.indexOf("import __asset_0")).toBeGreaterThan(out.indexOf("console.log"))
-  expect(out).toContain('import __asset_1 from "./y.png";')
-})
-
-test("a project using asset() bundles with the appended (hoisted) imports", async () => {
-  const js = await compileProject({
-    name: "A", publicUrl: "https://le.codes", header: false,
-    entries: [
-      { path: "/main.ts", type: "text", text: "const logo = asset('./logo.png')\ntoast(logo)\n" },
-      { path: "/logo.png", type: "resource", fileSrc: "/uploads/logo1.png" },
-    ],
-  })
-  expect(js).toContain("https://le.codes/uploads/logo1.png")
-})
-
-test("respects an explicit entryOverride and header:false", async () => {
-  const js = await compileProject({
-    name: "X",
-    publicUrl: "https://le.codes",
-    entryOverride: "/start.ts",
-    header: false,
-    entries: [
-      { path: "/start.ts", type: "text", text: "import { go } from \"./lib\"\ngo()\n" },
-      { path: "/lib.ts", type: "text", text: "export const go = () => new Scene()\n" },
-    ],
-  })
-  expect(js).not.toContain("// name:") // header omitted
-  expect(js).toContain("_creator.createScene") // the imported lib was bundled & called
-})
-
-test("iife format produces a self-running bundle", async () => {
-  const js = await compileProject({
-    name: "IIFE", publicUrl: "https://le.codes", header: false, format: "iife",
-    entries: [ { path: "/main.ts", type: "text", text: "new Scene2D().open()\n" } ],
-  })
-  // iife wraps in a function expression and still references host globals freely
-  expect(js).toMatch(/\(\s*\(\s*\)\s*=>\s*\{|\(function/)
-  expect(js).toContain("_creator2d.")
-})
-
-// ── User component libraries (bare-specifier imports → /__lib) ──────────────────────────────
-
-test("a project imports a component from a user library (bare specifier → /__lib)", async () => {
-  const js = await compileProject({
-    name: "L", publicUrl: "https://le.codes", header: false,
-    entries: [ { path: "/main.ts", type: "text", text: `import { Card } from "acme-ui"\nCard().open()\n` } ],
-    libraries: { "acme-ui": { "/index.ts": `export const Card = () => UIColumn()` } },
-  })
-  // The library's UIColumn call was resolved & inlined — its element-type literal survives minify.
-  expect(js).toContain(`"column"`)
-})
-
-test("a library sub-path import resolves", async () => {
-  const js = await compileProject({
-    name: "L", publicUrl: "https://le.codes", header: false,
-    entries: [ { path: "/main.ts", type: "text", text: `import { accent } from "acme-ui/theme"\ntoast(accent)\n` } ],
-    libraries: { "acme-ui": { "/theme.ts": `export const accent = "#4f46e5"` } },
-  })
-  expect(js).toContain("#4f46e5")
-})
-
-test("a library-internal relative import resolves within the /__lib prefix", async () => {
-  const js = await compileProject({
-    name: "L", publicUrl: "https://le.codes", header: false,
-    entries: [ { path: "/main.ts", type: "text", text: `import { Card } from "acme-ui"\nCard().open()\n` } ],
-    libraries: { "acme-ui": {
-      "/index.ts": `export { Card } from "./components/card"`,
-      "/components/card.ts": `export const Card = () => UIRow()`,
-    } },
-  })
-  expect(js).toContain(`"row"`) // the re-exported, library-internal component resolved & bundled
-})
-
-test("asset() inside a library resolves library-relative", async () => {
-  const js = await compileProject({
-    name: "L", publicUrl: "https://le.codes", header: false,
-    entries: [ { path: "/main.ts", type: "text", text: `import { Logo } from "acme-ui"\ntoast(Logo())\n` } ],
-    libraries: { "acme-ui": {
-      "/index.ts": `export const Logo = () => asset("./logo.png")`,
-      "/logo.png": `export default "https://le.codes/uploads/liblogo.png"`,
-    } },
-  })
-  expect(js).toContain("https://le.codes/uploads/liblogo.png")
-})
-
-test("an unknown bare import fails with the friendly library message", async () => {
-  await expect(compileProject({
-    name: "L", publicUrl: "https://le.codes", header: false,
-    entries: [ { path: "/main.ts", type: "text", text: `import { X } from "nope-lib"\nX()\n` } ],
-  })).rejects.toThrow(/Unknown library "nope-lib"/)
-})
-
-test("a bare-specifier-shaped string literal is NOT rewritten (no false positive)", async () => {
-  const js = await compileProject({
-    name: "L", publicUrl: "https://le.codes", header: false,
-    entries: [ { path: "/main.ts", type: "text", text: `const msg = "import X from 'acme-ui'"\ntoast(msg)\n` } ],
-    libraries: { "acme-ui": { "/index.ts": `export const X = 1` } },
-  })
-  expect(js).toContain("import X from 'acme-ui'") // the string literal survives verbatim
-})
-
-test("reactive_ui desugaring applies to library files (UI written like app code)", async () => {
-  const js = await compileProject({
-    name: "L", publicUrl: "https://le.codes", header: false, minify: false,
-    entries: [ { path: "/main.ts", type: "text", text: `import { List } from "acme-ui"\nList(["a","b"]).open()\n` } ],
-    libraries: { "acme-ui": { "/index.ts": `export const List = (items) => UIColumn(() => items.map(i => UIText(i)))` } },
-  })
-  expect(js).toContain("__uiMap") // the children .map inside the library got memoized like user code
-})
-
-test("buildHeader / detectProjectKind signal the engine from bundled code", () => {
-  expect(buildHeader("n", "_creator2d.createScene()")).toContain("// 2d: enable")
-  expect(buildHeader("n", "const x = 1")).toContain("// gl: disable")
-  expect(buildHeader("n", "_creator.createARController()")).toContain("// ar: enable")
-  expect(detectProjectKind("_creator2d.createScene()")).toBe("2d")
-  expect(detectProjectKind("_creator.createScene()")).toBe("3d")
-  expect(detectProjectKind("const x = 1")).toBe("ui")
-  expect(detectProjectKind("_creator.createARController()")).toBe("ar")
-})
-
-test("a .json project file is data — asset()/import gives the parsed value", async () => {
-  const js = await compileProject({
-    name: "Data", publicUrl: "https://le.codes", header: false,
-    entries: [
-      { path: "/main.ts", type: "text", text: 'toast(asset("./style.json").name)\n' },
-      { path: "/style.json", type: "text", text: '{ "name": "OSM Bright", "version": 8 }\n' },
-    ],
-  })
-  expect(js).toContain("OSM Bright")
-  expect(js).not.toContain('"./style.json"') // desugared to the import, not left as a string
-})

package/src/compile/__tests__/detectEntry.test.ts

@@ -1,151 +0,0 @@
-import { test, expect } from "bun:test"
-import { detectEntry, scanModulesFallback } from "../detectEntry"
-import { compileProject } from "../compileProject"
-
-// Entry detection contract: the entry is an import-graph ROOT (no other file imports it), with
-// /main.ts as the always-wins convention. These scenarios must resolve identically through the
-// chisel scan and the regex fallback — the suite passes with either binary generation.
-
-const text = (path: string, t: string) => ({ path, type: "text" as const, text: t })
-
-test("a side-effect registration module imported by the entry is never the entry (even when bigger)", () => {
-  const { entry, roots } = detectEntry([
-    text("/app.ts", "import './register'\ntoast('hi')\n"),
-    text("/register.ts", "// registration code, no exports, larger than the entry\n" + "registerThing()\n".repeat(20)),
-  ])
-  expect(entry).toBe("/app.ts")
-  expect(roots).toEqual(["/app.ts"])
-})
-
-test(".d.ts files are never the entry", () => {
-  const { entry } = detectEntry([
-    text("/app.ts", "toast('hi')\n"),
-    text("/globals.d.ts", "declare const BIG: number\n".repeat(50)),
-  ])
-  expect(entry).toBe("/app.ts")
-})
-
-test("the word 'export' inside a string does not disqualify the entry", () => {
-  const { entry } = detectEntry([
-    text("/app.ts", "toast(\"export done\")\ntoast('more')\n"),
-    text("/tiny.ts", "console.log(1)\n"),
-  ])
-  expect(entry).toBe("/app.ts") // both are roots; app.ts is the larger script
-})
-
-test("a single file WITH exports is still a valid entry (old heuristic errored)", () => {
-  const { entry } = detectEntry([
-    text("/app.ts", "export const state = signal(0)\nUIScreen([]).open()\n"),
-  ])
-  expect(entry).toBe("/app.ts")
-})
-
-test("/main.ts wins over a bigger unimported script", () => {
-  const { entry } = detectEntry([
-    text("/main.ts", "import { s } from './scratch'\ntoast(s)\n"),
-    text("/old-proto.ts", "console.log('leftover prototype')\n".repeat(30)),
-    text("/scratch.ts", "export const s = 'x'\n"),
-  ])
-  expect(entry).toBe("/main.ts")
-})
-
-test("an imported /main.ts is not a root — the importer wins (paranoid guard)", () => {
-  const { entry } = detectEntry([
-    text("/run.ts", "import './main'\nconsole.log('wrapper')\n"),
-    text("/main.ts", "toast('app')\n"),
-  ])
-  expect(entry).toBe("/run.ts")
-})
-
-test(".editor.ts files are never the entry and their imports don't consume candidacy", () => {
-  const { entry } = detectEntry([
-    text("/app.ts", "toast('hi')\n"),
-    text("/gizmo.editor.ts", "import './app'\nconsole.log('editor plugin, no exports, big')\n".repeat(5)),
-  ])
-  expect(entry).toBe("/app.ts")
-})
-
-test("two unrelated scripts: ambiguity is reported via roots, larger wins", () => {
-  const { entry, roots } = detectEntry([
-    text("/a.ts", "toast('a')\n".repeat(5)),
-    text("/b.ts", "toast('b')\n"),
-  ])
-  expect(entry).toBe("/a.ts")
-  expect(roots.sort()).toEqual(["/a.ts", "/b.ts"])
-})
-
-test("export-free roots beat exporting roots regardless of size", () => {
-  const { entry } = detectEntry([
-    text("/app.ts", "toast('hi')\n"),
-    text("/helpers.ts", "export const unusedHelpers = 1\n".repeat(10)),
-  ])
-  expect(entry).toBe("/app.ts")
-})
-
-test("resources and svg files never participate", () => {
-  const { entry } = detectEntry([
-    text("/app.ts", "toast('hi')\n"),
-    { path: "/logo.png", type: "resource" as const, fileSrc: "/uploads/x.png" },
-    text("/icon.svg", "<svg></svg>"),
-  ])
-  expect(entry).toBe("/app.ts")
-})
-
-// ── the regex fallback scanner (exercised directly — chisel may cover detectEntry above) ──────
-
-test("fallback scanner: resolves relative/absolute specifiers with ts/js/index fallbacks", () => {
-  const scan = scanModulesFallback({
-    "/main.ts": "import './reg'\nimport { a } from \"./sub/a\"\nimport b from '/b.js'\nimport { c } from './pkg'\nimport 'acme-lib'\n",
-    "/reg.ts": "console.log(1)",
-    "/sub/a.ts": "export const a = 1",
-    "/b.js": "export default 2",
-    "/pkg/index.ts": "export const c = 3",
-  })
-  expect(scan["/main.ts"].imports.sort()).toEqual(["/b.js", "/pkg/index.ts", "/reg.ts", "/sub/a.ts"])
-  expect(scan["/main.ts"].hasExports).toBe(false)
-  expect(scan["/sub/a.ts"].hasExports).toBe(true)
-})
-
-test("fallback scanner: multi-line imports and re-exports count as edges", () => {
-  const scan = scanModulesFallback({
-    "/main.ts": "import {\n  one,\n  two,\n} from './util'\nexport * from './hub'\n",
-    "/util.ts": "export const one = 1, two = 2",
-    "/hub.ts": "export const h = 1",
-  })
-  expect(scan["/main.ts"].imports.sort()).toEqual(["/hub.ts", "/util.ts"])
-  expect(scan["/main.ts"].hasExports).toBe(true)
-})
-
-// ── end to end through compileProject ─────────────────────────────────────────────────────────
-
-test("compileProject auto-detects the importer as entry and runs the registration module", async () => {
-  const js = await compileProject({
-    name: "Reg", publicUrl: "https://le.codes", header: false,
-    entries: [
-      text("/app.ts", "import './register'\ntoast('app-side-effect')\n"),
-      // Bigger than the entry — the old size heuristic picked this and dropped app.ts entirely.
-      text("/register.ts", "console.log('register-side-effect')\n// padding padding padding padding padding\n"),
-    ],
-  })
-  expect(js).toContain("app-side-effect")
-  expect(js).toContain("register-side-effect")
-})
-
-test("design/ screens are never the entry — a design-only project has none, app code next to a design wins", () => {
-  // A Figma import: screens on the board, shared modules, no app yet. The largest root used to win.
-  const designOnly = detectEntry([
-    text("/design/screens/a4-40.ts", "import { at } from '../shared/figma'\nexport default UIScreen([])\n" + "// big\n".repeat(50)),
-    text("/design/shared/figma.ts", "export const at = () => ({})\n"),
-    text("/app.server.ts", "export function ping() { return 1 }\n"),
-  ])
-  expect(designOnly.entry).toBe("")
-  expect(designOnly.roots).toEqual([])
-
-  // The same project once the app exists: main.ts is the entry however small it is.
-  const withApp = detectEntry([
-    text("/design/screens/a4-40.ts", "export default UIScreen([])\n" + "// big\n".repeat(50)),
-    text("/main.ts", "Router.init(home)\n"),
-  ])
-  expect(withApp.entry).toBe("/main.ts")
-  expect(withApp.roots).toEqual(["/main.ts"])
-})

package/src/compile/__tests__/fontMacro.test.ts

@@ -1,199 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { applyFontMacro, buildFontsHeaderValue, scanFontCalls, type FontMacroEntry } from "../fontMacro"
-import { parseSfnt } from "../sfnt"
-
-// ---- a minimal sfnt fixture (name + OS/2 tables — exactly what parseSfnt reads) -----------------
-
-const buildFont = (opts: { family: string, weight?: number, italic?: boolean, tag?: number }): Uint8Array => {
-  const nameStr: number[] = []
-  for (const ch of opts.family) { const c = ch.charCodeAt(0); nameStr.push(c >> 8, c & 0xff) }
-  const name = new Uint8Array(18 + nameStr.length)
-  const ndv = new DataView(name.buffer)
-  ndv.setUint16(2, 1) // count
-  ndv.setUint16(4, 18) // stringOffset
-  ndv.setUint16(6, 3) // platformID: windows
-  ndv.setUint16(8, 1) // encodingID: unicode BMP
-  ndv.setUint16(10, 0x409) // languageID: en-US
-  ndv.setUint16(12, 1) // nameID: family
-  ndv.setUint16(14, nameStr.length)
-  name.set(nameStr, 18)
-
-  const os2 = new Uint8Array(96)
-  const odv = new DataView(os2.buffer)
-  odv.setUint16(4, opts.weight ?? 400) // usWeightClass
-  odv.setUint16(62, opts.italic ? 1 : 0) // fsSelection ITALIC
-
-  const tables: [string, Uint8Array][] = [["name", name], ["OS/2", os2]]
-  const out = new Uint8Array(12 + tables.length * 16 + tables.reduce((s, [, t]) => s + t.length, 0))
-  const dv = new DataView(out.buffer)
-  dv.setUint32(0, opts.tag ?? 0x00010000)
-  dv.setUint16(4, tables.length)
-  let off = 12 + tables.length * 16
-  tables.forEach(([tag, data], i) => {
-    const rec = 12 + i * 16
-    for (let k = 0; k < 4; k++) out[rec + k] = tag.charCodeAt(k)
-    dv.setUint32(rec + 8, off)
-    dv.setUint32(rec + 12, data.length)
-    out.set(data, off)
-    off += data.length
-  })
-  return out
-}
-
-describe("parseSfnt", () => {
-  test("family from the name table, weight/italic from OS/2", () => {
-    const info = parseSfnt(buildFont({ family: "Brand Sans", weight: 600, italic: true }))
-    expect(info).toEqual({ family: "Brand Sans", weight: 600, italic: true })
-  })
-  test("OTTO (CFF) fonts parse too", () => {
-    expect(parseSfnt(buildFont({ family: "Serifed", tag: 0x4f54544f })).family).toBe("Serifed")
-  })
-  test("collections and WOFF are clear errors", () => {
-    expect(() => parseSfnt(buildFont({ family: "X", tag: 0x74746366 }))).toThrow(/collections/)
-    expect(() => parseSfnt(buildFont({ family: "X", tag: 0x774f4646 }))).toThrow(/WOFF/)
-    expect(() => parseSfnt(new Uint8Array([1, 2, 3]))).toThrow(/truncated/)
-  })
-})
-
-describe("scanFontCalls", () => {
-  test("bare registry call: id, span, no error", () => {
-    const src = `theme({ fontFamily: font("manrope") })`
-    const [c] = scanFontCalls(src)
-    expect(c.kind).toBe("registry")
-    expect(c.id).toBe("manrope")
-    expect(c.error).toBeUndefined()
-    expect(src.slice(c.start, c.end)).toBe(`font("manrope")`)
-  })
-  test("member calls, strings and comments are not matched", () => {
-    expect(scanFontCalls(`ctx.font("x"); "font(\\"y\\")"; // font("z")\n/* font("w") */`)).toHaveLength(0)
-  })
-  test("dynamic argument is a hard error", () => {
-    expect(scanFontCalls(`font(name)`)[0].error).toMatch(/string-literal/)
-  })
-  test("bad id shape is a hard error", () => {
-    expect(scanFontCalls(`font("Manrope")`)[0].error).toMatch(/registry id/)
-  })
-  test("system generic families point at plain fontFamily, not font()", () => {
-    expect(scanFontCalls(`font("serif")`)[0].error).toMatch(/system font.*fontFamily/)
-    expect(scanFontCalls(`font("monospaced")`)[0].error).toMatch(/system font/)
-    expect(scanFontCalls(`font("sans-serif")`)[0].error).toMatch(/system font/)
-  })
-  test("options: weights + italic literals", () => {
-    const [c] = scanFontCalls(`font("rubik", { weights: [400, 700], italic: true })`)
-    expect(c.weights).toEqual([400, 700])
-    expect(c.italic).toBe(true)
-  })
-  test("unknown / non-literal options are hard errors", () => {
-    expect(scanFontCalls(`font("rubik", { weight: 400 })`)[0].error).toMatch(/unknown option/)
-    expect(scanFontCalls(`font("rubik", { weights: w })`)[0].error).toMatch(/literal number array/)
-  })
-  test("path-shaped argument: file kind; options rejected; non-ttf rejected", () => {
-    expect(scanFontCalls(`font("./fonts/Brand.ttf")`)[0].kind).toBe("file")
-    expect(scanFontCalls(`font("./fonts/Brand.ttf", { weights: [400] })`)[0].error).toMatch(/no options/)
-    expect(scanFontCalls(`font("./fonts/Brand.woff2")`)[0].error).toMatch(/\.ttf\/\.otf/)
-  })
-})
-
-const entry = (path: string, text: string): FontMacroEntry => ({ path, type: "text", text })
-
-describe("applyFontMacro", () => {
-  test("cdn mode: call → imported family const; sibling module registers defaultWeights faces", async () => {
-    const entries = [entry("/index.ts", `theme({ fontFamily: font("manrope") })`)]
-    const faces = await applyFontMacro(entries, { mode: "cdn", registryBase: "https://cdn.test/v1" })
-
-    expect(faces.map((f) => f.weight).sort()).toEqual([400, 500, 700])
-    expect(entries[0].text).toContain(`theme({ fontFamily: __font_0 })`)
-    expect(entries[0].text).toContain(`import { __font_0 } from "./.index.ts.__fonts.ts"`)
-
-    const mod = entries.find((e) => e.path.endsWith(".__fonts.ts"))!
-    expect(mod.text).toContain(`export const __font_0 = "Manrope"`)
-    expect(mod.text).toContain(
-      `_creatorUI.registerFont("Manrope", "https://cdn.test/v1/manrope/manrope-400." + (_creatorUI.fontFormat ?? "ttf"), { weight: 400 }, () => {}, () => {})`,
-    )
-  })
-
-  test("weights narrow the face set; an unavailable weight is a clear error", async () => {
-    const one = [entry("/a.ts", `font("manrope", { weights: [200] })`)]
-    expect((await applyFontMacro(one, { mode: "cdn" })).map((f) => f.weight)).toEqual([200])
-    await expect(applyFontMacro([entry("/a.ts", `font("manrope", { weights: [150] })`)], { mode: "cdn" }))
-      .rejects.toThrow(/no 150 face/)
-  })
-
-  test("italic adds italic faces; a family without italics errors", async () => {
-    const entries = [entry("/a.ts", `font("rubik", { weights: [400], italic: true })`)]
-    const faces = await applyFontMacro(entries, { mode: "cdn" })
-    expect(faces.map((f) => f.italic).sort()).toEqual([false, true])
-    expect(entries.find((e) => e.path.endsWith(".__fonts.ts"))!.text).toContain(`{ weight: 400, style: "italic" }`)
-    await expect(applyFontMacro([entry("/a.ts", `font("manrope", { italic: true })`)], { mode: "cdn" }))
-      .rejects.toThrow(/no italic/)
-  })
-
-  test("unknown registry id lists available families", async () => {
-    await expect(applyFontMacro([entry("/a.ts", `font("comic-sans")`)], { mode: "cdn" }))
-      .rejects.toThrow(/unknown registry font\. Available: /)
-  })
-
-  test("vendor mode: hook called once per face; module imports the vendored entries", async () => {
-    const vendored: string[] = []
-    const entries = [entry("/shared/tokens.ts", `export const brand = font("manrope", { weights: [400, 700] })`)]
-    await applyFontMacro(entries, {
-      mode: "vendor",
-      vendorFace: (f) => { vendored.push(f.fileName); return `/assets/fonts/${f.fileName}` },
-    })
-    expect(vendored.sort()).toEqual(["manrope-400.ttf", "manrope-700.ttf"])
-    const mod = entries.find((e) => e.path.endsWith(".__fonts.ts"))!
-    expect(mod.path).toBe("shared/.tokens.ts.__fonts.ts")
-    expect(mod.text).toContain(`import __face_0 from "../assets/fonts/manrope-400.ttf"`)
-    expect(mod.text).toContain(`_creatorUI.registerFont("Manrope", __face_0, { weight: 400 }, () => {}, () => {})`)
-  })
-
-  test("project file: family/weight/italic come from the font itself; same family across files dedupes", async () => {
-    const bytes = buildFont({ family: "Brand Sans", weight: 600 })
-    const entries = [
-      entry("/index.ts", `Text("x").style({ fontFamily: font("./fonts/Brand.ttf") })`),
-      entry("/screens/home.ts", `font("../fonts/Brand.ttf")`),
-      { path: "/fonts/Brand.ttf", type: "resource" },
-    ]
-    const faces = await applyFontMacro(entries, { mode: "cdn", readBytes: () => bytes })
-    expect(faces).toHaveLength(1)
-    expect(faces[0]).toMatchObject({ family: "Brand Sans", weight: 600, italic: false, source: { kind: "entry", path: "fonts/Brand.ttf" } })
-    expect(entries[0].text).toContain(`fontFamily: __font_0`)
-    const homeMod = entries.find((e) => e.path === "screens/.home.ts.__fonts.ts")!
-    expect(homeMod.text).toContain(`import __face_0 from "../fonts/Brand.ttf"`)
-  })
-
-  test("a missing project font file is a clear error", async () => {
-    await expect(applyFontMacro([entry("/a.ts", `font("./nope.ttf")`)], { mode: "cdn", readBytes: () => null }))
-      .rejects.toThrow(/no such file/)
-  })
-
-  test("a file that declares its own `font` is left alone", async () => {
-    const src = `const font = (s: string) => s\nfont("manrope")`
-    const entries = [entry("/a.ts", src)]
-    expect(await applyFontMacro(entries, { mode: "cdn" })).toEqual([])
-    expect(entries[0].text).toBe(src)
-  })
-
-  test("two files using the same family share the face set (one registration source each)", async () => {
-    const entries = [entry("/a.ts", `font("manrope")`), entry("/b.ts", `font("manrope")`)]
-    const faces = await applyFontMacro(entries, { mode: "cdn" })
-    expect(faces).toHaveLength(3)
-    expect(entries.filter((e) => e.path.endsWith(".__fonts.ts"))).toHaveLength(2)
-  })
-})
-
-describe("buildFontsHeaderValue", () => {
-  test("cdn faces carry {fmt}; entry faces need an absolute URL or are omitted", () => {
-    const value = buildFontsHeaderValue([
-      { family: "Manrope", weight: 400, italic: false, source: { kind: "cdn", urlBase: "https://cdn.test/v1/manrope/manrope-400." } },
-      { family: "Rubik", weight: 700, italic: true, source: { kind: "cdn", urlBase: "https://cdn.test/v1/rubik/rubik-700-italic." } },
-      { family: "Brand", weight: 400, italic: false, source: { kind: "entry", path: "fonts/Brand.ttf" } },
-    ], (path) => (path === "fonts/Brand.ttf" ? "https://api.test/uploads/b.ttf" : null))
-    expect(value).toBe(
-      "Manrope@400=https://cdn.test/v1/manrope/manrope-400.{fmt};"
-      + "Rubik@700i=https://cdn.test/v1/rubik/rubik-700-italic.{fmt};"
-      + "Brand@400=https://api.test/uploads/b.ttf",
-    )
-    expect(buildFontsHeaderValue([{ family: "B", weight: 400, italic: false, source: { kind: "entry", path: "x.ttf" } }])).toBe("")
-  })
-})