@flatkit/compiler 0.1.0

package/dist/chunk-EHQSVWOD.js

@@ -0,0 +1,678 @@
+// src/cli/flatc.ts
+import { readFileSync, writeFileSync, existsSync, readdirSync, watch, mkdirSync, copyFileSync } from "fs";
+import { resolve, dirname, basename, extname, join, relative, isAbsolute } from "path";
+
+// src/compile.ts
+import { parseFlatLib, parseProgramFull } from "@flatkit/engine/flatFormat";
+import { isGroup, isInstance } from "@flatkit/engine/layers";
+function resolveRefs(layers, byName) {
+  const walk = (items) => {
+    for (const it of items) {
+      if (isInstance(it) && it.symbolId.startsWith("@")) it.symbolId = byName.get(it.symbolId.slice(1)) ?? it.symbolId;
+      if (isGroup(it)) it.layers.forEach((l) => walk(l.items));
+    }
+  };
+  layers.forEach((l) => walk(l.items));
+}
+function compileFlatpack(programSrc, assetSrcs = [], media = {}) {
+  const libs = assetSrcs.map((src) => parseFlatLib(src));
+  const symbols = libs.flatMap((l) => l.symbols);
+  const folders = libs.flatMap((l) => l.folders);
+  const prog = parseProgramFull(programSrc);
+  const byName = new Map(symbols.map((s) => [s.name, s.id]));
+  symbols.forEach((s) => resolveRefs(s.layers, byName));
+  resolveRefs(prog.layers, byName);
+  const assets = (prog.assets ?? []).map((a) => {
+    const m = media[a.data];
+    return m ? { ...a, mime: m.mime, data: m.data } : a;
+  });
+  return {
+    width: prog.width,
+    height: prog.height,
+    ...prog.background ? { background: prog.background } : {},
+    symbols,
+    ...folders.length ? { folders } : {},
+    layers: prog.layers,
+    ...prog.variables && Object.keys(prog.variables).length ? { variables: prog.variables } : {},
+    ...prog.imports?.length ? { imports: prog.imports } : {},
+    ...prog.functions?.length ? { functions: prog.functions } : {},
+    timeline: prog.timeline ?? { fps: 24, durationFrames: 60, tracks: [] },
+    ...prog.interactions?.length ? { interactions: prog.interactions } : {},
+    ...prog.interactors?.length ? { interactors: prog.interactors } : {},
+    ...assets.length ? { assets } : {}
+  };
+}
+var packToJSON = (doc) => JSON.stringify(doc);
+
+// src/cli/flatc.ts
+import { parseProgramFull as parseProgramFull2 } from "@flatkit/engine/flatFormat";
+import { hasPackage } from "@flatkit/engine/stdlib";
+import { parseUnits as parseUnits3 } from "@flatkit/engine/dsl";
+import { sanitizeDoc } from "@flatkit/engine/validateDoc";
+import { unitsToFunctions } from "@flatkit/engine/scriptDoc";
+
+// src/programDoc.ts
+import { printUnits } from "@flatkit/engine/dsl";
+
+// src/scopeProgram.ts
+function matchBrace(s, open) {
+  let depth = 0;
+  for (let i = open; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"') {
+      i++;
+      while (i < s.length && s[i] !== '"') {
+        if (s[i] === "\\") i++;
+        i++;
+      }
+      ;
+      continue;
+    }
+    if (c === "/" && s[i + 1] === "/") {
+      while (i < s.length && s[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "{") depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function splitScopeProgram(text) {
+  let rest = "";
+  let i = 0;
+  const objects = [];
+  while (i < text.length) {
+    const m = /object\s+"((?:[^"\\]|\\.)*)"\s*\{/.exec(text.slice(i));
+    if (!m) {
+      rest += text.slice(i);
+      break;
+    }
+    const start = i + m.index;
+    rest += text.slice(i, start);
+    const ob = start + m[0].length - 1;
+    const oc = matchBrace(text, ob);
+    if (oc < 0) {
+      rest += text.slice(start);
+      break;
+    }
+    objects.push({ name: m[1].replace(/\\(.)/g, (_, c) => c === "n" ? "\n" : c), body: text.slice(ob + 1, oc) });
+    i = oc + 1;
+  }
+  return { rest, objects };
+}
+function scopeRegions(text) {
+  const lineAt = (off) => text.slice(0, off).split("\n").length;
+  const regions = [];
+  let i = 0;
+  let restStart = 0;
+  while (i < text.length) {
+    const m = /object\s+"((?:[^"\\]|\\.)*)"\s*\{/.exec(text.slice(i));
+    if (!m) break;
+    const start = i + m.index;
+    const gap = text.slice(restStart, start);
+    if (gap.trim()) regions.push({ body: gap, line: lineAt(restStart) });
+    const ob = start + m[0].length - 1;
+    const oc = matchBrace(text, ob);
+    if (oc < 0) break;
+    regions.push({ body: text.slice(ob + 1, oc), line: lineAt(ob + 1) });
+    i = oc + 1;
+    restStart = i;
+  }
+  const tail = text.slice(restStart);
+  if (tail.trim()) regions.push({ body: tail, line: lineAt(restStart) });
+  return regions;
+}
+var esc = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+var indent = (body) => body.split("\n").map((l) => l.trim() ? "  " + l : l).join("\n");
+function formatObjectBlock(name, body) {
+  const inner = body.trim();
+  return `object "${esc(name)}" {
+${inner ? indent(inner) + "\n" : ""}}`;
+}
+function joinScopeProgram(rest, objects) {
+  const parts = [];
+  if (rest.trim()) parts.push(rest.trim());
+  for (const o of objects) if (o.body.trim()) parts.push(formatObjectBlock(o.name, o.body));
+  return parts.length ? parts.join("\n\n") + "\n" : "";
+}
+
+// src/programDoc.ts
+import { functionsToUnits, importsToUnits, objectToUnits, timelineToUnits, variablesToUnits } from "@flatkit/engine/scriptDoc";
+import { contextLayers, getScopeTimeline, isContainer, isGroup as isGroup2, isText, isImage } from "@flatkit/engine/layers";
+import { importedFunctions } from "@flatkit/engine/stdlib";
+import { objectNames } from "@flatkit/engine/sceneRefs";
+import { itemBBox, dropZoneBounds } from "@flatkit/engine/groups";
+import { bboxIntersects } from "@flatkit/engine/bbox";
+
+// src/lint.ts
+import { analyzeExpr, STD_CONSTANTS, STD_FUNCTIONS, STD_IDS, STD_OBJECTS } from "@flatkit/engine/expr";
+import { packageFunctionNames } from "@flatkit/engine/stdlib";
+import { parseUnits } from "@flatkit/engine/dsl";
+function collectAssigned(actions, into) {
+  for (const a of actions) {
+    if (a.do === "setVar") into.add(a.name);
+    else if (a.do === "if") {
+      collectAssigned(a.then, into);
+      if (a.else) collectAssigned(a.else, into);
+    } else if (a.do === "repeat") collectAssigned(a.body, into);
+    else if (a.do === "repeatRange") {
+      into.add(a.var);
+      collectAssigned(a.body, into);
+    }
+  }
+}
+function localVariables(units) {
+  const vars = /* @__PURE__ */ new Set();
+  for (const u of units) {
+    if (u.kind === "declare") vars.add(u.name);
+    else if (u.kind === "event" || u.kind === "frameActions") collectAssigned(u.body, vars);
+    else if (u.kind === "each") vars.add(u.as);
+    else if (u.kind === "interactor") {
+      if (u.varX) vars.add(u.varX);
+      if (u.varY) vars.add(u.varY);
+    } else if (u.kind === "drop") collectAssigned(u.body, vars);
+    else if (u.kind === "func") {
+      for (const p of u.func.params) vars.add(p);
+      if (u.func.kind === "proc") collectAssigned(u.func.body, vars);
+    }
+  }
+  return vars;
+}
+var TEXT_CALL = /\btext\s*\(/;
+function lint(src, ctx = {}) {
+  const { units, diagnostics, sites } = parseUnits(src);
+  const out = [...diagnostics];
+  const variables = localVariables(units);
+  for (const v of ctx.variables ?? []) variables.add(v);
+  const knownIds = /* @__PURE__ */ new Set([...STD_IDS, ...STD_CONSTANTS, ...variables]);
+  const knownFns = new Set(STD_FUNCTIONS);
+  for (const u of units) {
+    if (u.kind === "func") knownFns.add(u.func.name);
+    else if (u.kind === "use") for (const name of packageFunctionNames(u.name)) knownFns.add(name);
+  }
+  for (const f of ctx.functions ?? []) knownFns.add(f);
+  const knownObjs = new Set(STD_OBJECTS);
+  for (const o of ctx.objects ?? []) knownObjs.add(o);
+  const labels = ctx.labels ? new Set(ctx.labels) : null;
+  for (const s of sites) {
+    if (s.kind === "expr") {
+      if (TEXT_CALL.test(s.text)) {
+        out.push({ line: s.line, col: s.col, message: 'text("\u2026") is only allowed as an argument to "send"' });
+        continue;
+      }
+      const a = analyzeExpr(s.text);
+      if (!a.ok) {
+        out.push({ line: s.line, col: s.col, message: `invalid expression: ${a.error}` });
+        continue;
+      }
+      for (const fn of a.refs.calls) if (!knownFns.has(fn)) out.push({ line: s.line, col: s.col, message: `unknown function "${fn}"` });
+      for (const o of a.refs.members)
+        if (!knownObjs.has(o)) out.push({ line: s.line, col: s.col, message: `unknown object "${o}" (expected: ${[...knownObjs].join(", ")})` });
+      for (const id of a.refs.ids)
+        if (!knownIds.has(id))
+          out.push({ line: s.line, col: s.col, message: `unknown variable "${id}"${variables.size ? "" : ' \u2014 declare it with "let"'}` });
+    } else if (labels && !labels.has(s.name)) {
+      out.push({ line: s.line, col: s.col, message: `unknown label "${s.name}"` });
+    }
+  }
+  return out.sort((a, b) => a.line - b.line || a.col - b.col);
+}
+function lintReport(src, ctx = {}) {
+  return lint(src, ctx).map((d) => `${d.line}:${d.col}: ${d.message}`).join("\n");
+}
+
+// src/programDoc.ts
+import { parseUnits as parseUnits2 } from "@flatkit/engine/dsl";
+function scopeProgram(doc, editPath = []) {
+  const atRoot = editPath.length === 0;
+  const items = contextLayers(doc, editPath).flatMap((l) => l.items);
+  const nameCount = /* @__PURE__ */ new Map();
+  for (const it of items) if (isContainer(it) && it.name) nameCount.set(it.name, (nameCount.get(it.name) ?? 0) + 1);
+  const scripted = (it) => !!doc.interactions?.some((i) => i.targetId === it.id) || !!doc.interactors?.some((i) => i.targetId === it.id) || !!(it.expressions && Object.keys(it.expressions).length);
+  const objects = items.filter((it) => isContainer(it) && !!it.name && nameCount.get(it.name) === 1 && scripted(it)).map((it) => ({ name: it.name, body: printUnits(objectToUnits(it.id, doc.interactions, it.expressions, doc.interactors)) }));
+  const imports = atRoot ? printUnits(importsToUnits(doc.imports)) : "";
+  const funcs = atRoot ? printUnits(functionsToUnits(doc.functions)) : "";
+  const globals = atRoot ? printUnits(variablesToUnits(doc.variables)) : "";
+  const scene = printUnits(timelineToUnits(getScopeTimeline(doc, editPath)));
+  const head = [imports, globals, funcs, scene].filter((t) => t.trim()).join("\n\n");
+  return joinScopeProgram(head, objects);
+}
+function docLintContext(doc, editPath = [], extraVars) {
+  return {
+    variables: [...Object.keys(doc.variables ?? {}), ...extraVars ?? []],
+    labels: (getScopeTimeline(doc, editPath)?.labels ?? []).map((l) => l.name),
+    functions: [...(doc.functions ?? []).map((f) => f.name), ...importedFunctions(doc.imports).map((f) => f.name)],
+    objects: objectNames(contextLayers(doc, editPath))
+  };
+}
+function scopes(doc) {
+  return [{ label: "scene", editPath: [] }, ...doc.symbols.map((s) => ({ label: s.name, editPath: [{ kind: "symbol", symbolId: s.id, name: s.name }] }))];
+}
+function allScopeVariables(doc) {
+  const set = /* @__PURE__ */ new Set();
+  for (const { editPath } of scopes(doc))
+    for (const r of scopeRegions(scopeProgram(doc, editPath)))
+      for (const v of localVariables(parseUnits2(r.body).units)) set.add(v);
+  return [...set];
+}
+function itemNameById(doc, id) {
+  let found = null;
+  const walk = (layers) => {
+    for (const l of layers) for (const it of l.items) {
+      if (found) return;
+      if ("name" in it && it.id === id) {
+        found = it.name;
+        return;
+      }
+      if (isGroup2(it)) walk(it.layers);
+    }
+  };
+  walk(doc.layers);
+  return found;
+}
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\-]/g, "\\$&");
+function docStructureWarnings(doc) {
+  const out = [];
+  const names = new Set(objectNames(doc.layers));
+  for (const it of doc.interactions ?? []) {
+    if (it.event === "drop" && it.over && !names.has(it.over)) {
+      const who = itemNameById(doc, it.targetId) ?? it.targetId;
+      out.push({ scope: "scene", diag: { line: 1, col: 1, severity: "warning", message: `unknown drop zone "${it.over}" (object "${who}") \u2014 no item of the scene carries this name` } });
+    }
+  }
+  const names0 = Object.keys(doc.variables ?? {});
+  if (names0.length) {
+    const allText = scopes(doc).map(({ editPath }) => scopeProgram(doc, editPath)).join("\n");
+    for (const name of names0) {
+      const m = allText.match(new RegExp(`(?<![\\w-])${escapeRe(name)}(?![\\w-])`, "g"));
+      if ((m?.length ?? 0) <= 1) out.push({ scope: "scene", diag: { line: 1, col: 1, severity: "warning", message: `global variable "${name}" never used (declared, but neither read nor written)` } });
+    }
+  }
+  out.push(...docLayoutWarnings(doc));
+  return out;
+}
+var warn = (message) => ({ scope: "scene", diag: { line: 1, col: 1, severity: "warning", message } });
+var itemLabel = (it) => "name" in it && it.name ? it.name : "kind" in it ? it.kind : "path";
+function estTextWidth(t) {
+  const advance = (t.weight && t.weight >= 700 ? 0.56 : 0.52) * t.size;
+  let longest = 0;
+  for (const line of t.content.split("\n")) longest = Math.max(longest, line.length);
+  return longest * advance;
+}
+function docLayoutWarnings(doc) {
+  const out = [];
+  const W = doc.width, H = doc.height;
+  const TOL = 8;
+  const r0 = (n) => Math.round(n);
+  const dynamicPos = (it) => "expressions" in it && it.expressions && (it.expressions.x != null || it.expressions.y != null);
+  for (const layer of doc.layers) {
+    for (const it of layer.items) {
+      if (!(isText(it) || isImage(it)) || dynamicPos(it)) continue;
+      const b = itemBBox(doc, it);
+      if (!b) continue;
+      const visible = b.maxX > 0 && b.minX < W && b.maxY > 0 && b.minY < H;
+      const clipped = b.minX < -TOL || b.minY < -TOL || b.maxX > W + TOL || b.maxY > H + TOL;
+      if (visible && clipped) {
+        out.push(warn(`"${itemLabel(it)}" clipped at the canvas edge: bbox [${r0(b.minX)},${r0(b.minY)} -> ${r0(b.maxX)},${r0(b.maxY)}] outside 0,0 -> ${W},${H}`));
+      }
+    }
+  }
+  for (const it of doc.layers.flatMap((l) => l.items)) {
+    if (!isText(it) || it.wrap || dynamicPos(it)) continue;
+    const estW = estTextWidth(it);
+    const left = it.align === "left" ? 0 : it.align === "right" ? it.box.w - estW : it.box.w / 2 - estW / 2;
+    const wl = it.transform.e + left, wr = wl + estW;
+    if (wr > W + TOL || wl < -TOL) {
+      out.push(warn(`text "${it.content.slice(0, 24)}${it.content.length > 24 ? "\u2026" : ""}" overflows the canvas (estimated ~${r0(estW)} px, edge ${r0(wl)}->${r0(wr)} outside 0->${W}) \u2014 add "wrap"`));
+    }
+  }
+  const zones = [];
+  const collectZones = (layers) => {
+    for (const l of layers) for (const it of l.items) {
+      if (isGroup2(it) && it.hitbox && it.name) {
+        const b = dropZoneBounds(doc, it.name);
+        if (b) zones.push({ name: it.name, b });
+      }
+      if (isGroup2(it)) collectZones(it.layers);
+    }
+  };
+  collectZones(doc.layers);
+  for (let i = 0; i < zones.length; i++) for (let j = i + 1; j < zones.length; j++) {
+    if (bboxIntersects(zones[i].b, zones[j].b)) out.push(warn(`overlapping hitboxes: "${zones[i].name}" and "${zones[j].name}" -> ambiguous drop`));
+  }
+  return out;
+}
+function lintDoc(doc) {
+  const out = [];
+  const allVars = allScopeVariables(doc);
+  for (const { label, editPath } of scopes(doc)) {
+    const ctx = docLintContext(doc, editPath, allVars);
+    for (const r of scopeRegions(scopeProgram(doc, editPath))) for (const d of lint(r.body, ctx)) out.push({ scope: label, diag: { ...d, line: d.line + r.line - 1 } });
+  }
+  out.push(...docStructureWarnings(doc));
+  return out;
+}
+var sev = (d) => d.severity === "warning" ? "warning" : "error";
+function lintDocReport(doc) {
+  return lintDoc(doc).map(({ scope, diag }) => `[${scope}] ${diag.line}:${diag.col}: ${sev(diag)}: ${diag.message}`).join("\n");
+}
+function docHasErrors(doc) {
+  return lintDoc(doc).some(({ diag }) => sev(diag) === "error");
+}
+
+// src/cli/flatc.ts
+import { playHeadless } from "@flatkit/player/debug";
+var MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".avif": "image/avif",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".m4a": "audio/mp4",
+  // Fonts (RFC 8081 media types) — matches the editor's import (`font/woff2` default, FontFace API).
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf"
+  // NB: video (.mp4/.webm/…) intentionally omitted — no video runtime in the editor or player yet.
+};
+var mimeFor = (path) => MIME[extname(path).toLowerCase()] ?? "application/octet-stream";
+function isWithin(baseDir, target) {
+  const rel = relative(baseDir, target);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function printHelp() {
+  process.stdout.write(`flatc \u2014 compile a FlatInk program into a .flatpack
+
+Usage:
+  flatc <program.flatink> [assets.flat \u2026] [-o output.flatpack]
+  flatc <program.flatink> --watch
+  flatc --play <program.flatink | scene.flatpack> --script <gestures.json>
+  flatc --render <program.flatink | scene.flatpack> -o out.png [--frame N] [--at k=v[,k2=v2]] [--scale S]
+
+  program.flatink   the program (composition + logic, text DSL)
+  assets.flat       visual asset libs (default: every .flat in the program's folder)
+  -o, --out         output file (default: <program>.flatpack \u2014 the CANONICAL name, JSON inside)
+  --assets MODE     media baking: 'inline' (default, base64 in the .flatpack) or 'external'
+                    (sidecar <out>.assets/ folder; asset.data = relative key \u2014 serve the folder and
+                    play with sameOriginAssetResolver(<flatpackUrl>))
+  --check           semantic lint only (no .flatpack); exits \u22600 on ERROR (warnings do not stop)
+  --watch           recompile on every change in the folder (agent \u2192 player loop)
+  --play            run the file WITHOUT a canvas, replay --script and print { sends, vars } (JSON)
+  --trace           (with --play) HUMAN-READABLE log per gesture: emitted sends + variable diff (debug)
+  --script <f>      JSON gesture script: [{ "type": "down|move|up|cancel", "x", "y" }, { "type": "set", "name", "value" }, { "type": "wait", "frames": N }]
+                    semantic (by NAME, the engine resolves coords): { "type": "drag", "source", "target" } \xB7 { "type": "tap", "target" }
+                    \xB7 { "type": "scratch", "target" } (sweeps a reveal zone) \xB7 { "type": "connect", "source", "target" } (pulls a link wire)
+                    "wait" lets the simulation run N fixed steps (60 Hz): "every frame" + playhead advance like in real playback
+                    "expect" self-verifies: { "type": "expect", "sends": ["done"], "vars": { "score": 3 } } \u2192 exits \u22600 on mismatch
+                    (sends = sequence of names emitted SINCE the last expect; vars = current state). Great in CI.
+  --render          render a PNG IMAGE (headless skia): see what we draw (positioning)
+  --frame N         (with --render) target frame (default 0)
+  --at k=v[,k2=v2]  (with --render) force variables \u2192 capture a given state (e.g. a step of an escape)
+  --steps N         (with --render) run N fixed sim steps (60 Hz, every-frame) BEFORE capture \u2192 see a
+                    stateful act unfold without forcing every derived variable by hand in --at
+  --scale S         (with --render) resolution factor (default 2)
+  -h, --help        this help
+
+Media referenced by 'asset "id" "path" kind' are embedded (paths relative to the program).
+`);
+}
+function buildDocFromProgram(programPath, explicitFlats = [], assetMode = "inline", assetsDir = "") {
+  const baseDir = dirname(programPath);
+  const programSrc = readFileSync(programPath, "utf8");
+  const prog = parseProgramFull2(programSrc);
+  const flatPaths = new Set(explicitFlats.map((p) => resolve(p)));
+  if (!flatPaths.size) for (const f of readdirSync(baseDir).filter((f2) => f2.endsWith(".flat"))) flatPaths.add(join(baseDir, f));
+  const pkgFunctions = [];
+  const localResolved = /* @__PURE__ */ new Set();
+  for (const name of prog.imports ?? []) {
+    if (hasPackage(name)) continue;
+    const fink = join(baseDir, name + ".flatink");
+    const fflat = join(baseDir, name + ".flat");
+    if (!isWithin(baseDir, fink) || !isWithin(baseDir, fflat)) {
+      process.stderr.write(`flatc: package outside the program folder (ignored): "${name}"
+`);
+      continue;
+    }
+    let found = false;
+    if (existsSync(fink)) {
+      for (const f of unitsToFunctions(parseUnits3(readFileSync(fink, "utf8")).units)) pkgFunctions.push(f, { ...f, name: `${name}.${f.name}` });
+      found = true;
+    }
+    if (existsSync(fflat)) {
+      flatPaths.add(fflat);
+      found = true;
+    }
+    if (found) localResolved.add(name);
+    else process.stderr.write(`flatc: package not found: "${name}" (neither stdlib, nor ${name}.flatink / ${name}.flat)
+`);
+  }
+  const assetSrcs = [...flatPaths].map((p) => readFileSync(p, "utf8"));
+  const media = {};
+  const mediaCopies = [];
+  for (const a of prog.assets ?? []) {
+    const mp = resolve(baseDir, a.data);
+    if (!isWithin(baseDir, mp)) {
+      process.stderr.write(`flatc: media outside the program folder (ignored): ${a.data}
+`);
+      continue;
+    }
+    if (!existsSync(mp)) {
+      process.stderr.write(`flatc: missing media (ignored): ${a.data}
+`);
+      continue;
+    }
+    const mime = mimeFor(mp);
+    if (assetMode === "external") {
+      const key = `${assetsDir}/${a.data.replace(/\\/g, "/")}`;
+      media[a.data] = { mime, data: key };
+      mediaCopies.push({ src: mp, key });
+    } else {
+      media[a.data] = { mime, data: `data:${mime};base64,${readFileSync(mp).toString("base64")}` };
+    }
+  }
+  let doc = compileFlatpack(programSrc, assetSrcs, media);
+  if (pkgFunctions.length) doc = { ...doc, functions: [...doc.functions ?? [], ...pkgFunctions] };
+  const stdImports = (doc.imports ?? []).filter(hasPackage);
+  doc = { ...doc, imports: stdImports.length ? stdImports : void 0 };
+  return { doc, flatLibs: flatPaths.size, packages: localResolved.size, media: Object.keys(media).length, mediaCopies };
+}
+function compileOnce(programPath, explicitFlats, out, checkOnly, assetMode = "inline") {
+  const outPath = out ? resolve(out) : join(dirname(programPath), basename(programPath, extname(programPath)) + ".flatpack");
+  const assetsDir = assetMode === "external" ? basename(outPath, extname(outPath)) + ".assets" : "";
+  let built;
+  try {
+    built = buildDocFromProgram(programPath, explicitFlats, assetMode, assetsDir);
+  } catch (e) {
+    process.stderr.write(`flatc: compile error: ${e.message}
+`);
+    return 1;
+  }
+  const { doc } = built;
+  const report = lintDocReport(doc);
+  if (checkOnly) {
+    if (report) process.stderr.write(report + "\n");
+    if (docHasErrors(doc)) return 1;
+    process.stdout.write("flatc: no errors \u2713\n");
+    return 0;
+  }
+  if (report) process.stderr.write(report + "\n");
+  writeFileSync(outPath, packToJSON(doc));
+  const outDir = dirname(outPath);
+  for (const c of built.mediaCopies) {
+    const dest = join(outDir, ...c.key.split("/"));
+    if (!isWithin(outDir, dest)) continue;
+    mkdirSync(dirname(dest), { recursive: true });
+    copyFileSync(c.src, dest);
+  }
+  const where = assetMode === "external" ? ` (external \u2192 ${assetsDir}/)` : "";
+  process.stdout.write(`flatc: ${basename(outPath)} \u2713  ${doc.symbols.length} symbol(s) \xB7 ${built.flatLibs} lib(s) \xB7 ${built.packages} package(s) \xB7 ${built.media} media${where}
+`);
+  return 0;
+}
+function loadDoc(filePath) {
+  if (filePath.endsWith(".flatink")) return buildDocFromProgram(filePath).doc;
+  return sanitizeDoc(JSON.parse(readFileSync(filePath, "utf8")));
+}
+function playOnce(filePath, scriptPath, trace) {
+  if (!scriptPath) {
+    process.stderr.write("flatc: --play requires --script <gestures.json>\n");
+    return 1;
+  }
+  if (!existsSync(scriptPath)) {
+    process.stderr.write(`flatc: script not found: ${scriptPath}
+`);
+    return 1;
+  }
+  let doc, gestures;
+  try {
+    doc = loadDoc(filePath);
+  } catch (e) {
+    process.stderr.write(`flatc: cannot read: ${e.message}
+`);
+    return 1;
+  }
+  try {
+    gestures = JSON.parse(readFileSync(scriptPath, "utf8"));
+  } catch (e) {
+    process.stderr.write(`flatc: invalid JSON script: ${e.message}
+`);
+    return 1;
+  }
+  if (!Array.isArray(gestures)) {
+    process.stderr.write("flatc: the script must be an array of gestures\n");
+    return 1;
+  }
+  const res = playHeadless(doc, gestures, { trace });
+  if (!trace) process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+  else
+    for (const s of res.steps ?? []) {
+      const sends = s.sends.length ? "  sends:[" + s.sends.map((e) => e.value !== void 0 ? `${e.name}=${e.value}` : e.name).join(", ") + "]" : "";
+      const vars = Object.entries(s.changed).map(([k, [a, b]]) => `${k}:${JSON.stringify(a)}\u2192${JSON.stringify(b)}`);
+      process.stdout.write(`${s.gesture.padEnd(28)}${sends}${vars.length ? "  vars{" + vars.join(" ") + "}" : ""}
+`);
+    }
+  if (res.expectFailures?.length) {
+    for (const f of res.expectFailures) process.stderr.write(`flatc: \u2717 ${f}
+`);
+    return 1;
+  }
+  return 0;
+}
+function parseVars(spec, into) {
+  for (const pair of spec.split(",")) {
+    const i = pair.indexOf("=");
+    if (i < 0) continue;
+    const k = pair.slice(0, i).trim();
+    const v = Number(pair.slice(i + 1).trim());
+    if (k && Number.isFinite(v)) into[k] = v;
+  }
+}
+async function renderOnce(filePath, out, frame, vars, scale, steps) {
+  let doc;
+  try {
+    doc = loadDoc(filePath);
+  } catch (e) {
+    process.stderr.write(`flatc: cannot read: ${e.message}
+`);
+    return 1;
+  }
+  const outPath = out ? resolve(out) : join(dirname(filePath), basename(filePath, extname(filePath)) + ".png");
+  try {
+    const { renderDocToPng } = await import("./cli/render.js");
+    const png = await renderDocToPng(doc, { frame, vars: Object.keys(vars).length ? vars : void 0, scale, steps: steps || void 0 });
+    writeFileSync(outPath, png);
+  } catch (e) {
+    process.stderr.write(`flatc: render failed: ${e.message}
+`);
+    return 1;
+  }
+  process.stdout.write(`flatc: ${basename(outPath)} \u2713  ${doc.width}\xD7${doc.height} \xD7${scale}${frame ? ` \xB7 frame ${frame}` : ""}${steps ? ` \xB7 ${steps} step(s)` : ""}${Object.keys(vars).length ? ` \xB7 ${Object.entries(vars).map(([k, v]) => `${k}=${v}`).join(" ")}` : ""}
+`);
+  return 0;
+}
+function run(argv) {
+  const args = argv.slice(2);
+  let out = "", scriptPath = "";
+  let checkOnly = false, doWatch = false, doPlay = false, doRender = false, doTrace = false;
+  let frame = 0, scale = 2, steps = 0;
+  let assetMode = "inline";
+  const vars = {};
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "-o" || a === "--out") out = args[++i] ?? "";
+    else if (a === "--script") scriptPath = resolve(args[++i] ?? "");
+    else if (a === "--assets") assetMode = args[++i] === "external" ? "external" : "inline";
+    else if (a === "--check") checkOnly = true;
+    else if (a === "--watch") doWatch = true;
+    else if (a === "--play") doPlay = true;
+    else if (a === "--trace") doTrace = true;
+    else if (a === "--render") doRender = true;
+    else if (a === "--frame") frame = Number(args[++i] ?? "0") || 0;
+    else if (a === "--steps") steps = Math.max(0, Number(args[++i] ?? "0") || 0);
+    else if (a === "--scale") scale = Number(args[++i] ?? "2") || 2;
+    else if (a === "--at") parseVars(args[++i] ?? "", vars);
+    else if (a === "-h" || a === "--help") {
+      printHelp();
+      return 0;
+    } else positional.push(a);
+  }
+  if (!positional.length) {
+    printHelp();
+    return 1;
+  }
+  const filePath = resolve(positional[0]);
+  if (!existsSync(filePath)) {
+    process.stderr.write(`flatc: not found: ${filePath}
+`);
+    return 1;
+  }
+  const explicitFlats = positional.slice(1);
+  if (doRender) return renderOnce(filePath, out, frame, vars, scale, steps);
+  if (doPlay) return playOnce(filePath, scriptPath, doTrace);
+  if (doWatch) {
+    const code = compileOnce(filePath, explicitFlats, out, checkOnly, assetMode);
+    const baseDir = dirname(filePath);
+    let timer;
+    watch(baseDir, { recursive: false }, (_e, filename) => {
+      if (filename && (filename.endsWith(".flatpack") || filename.endsWith(".flatpack.json"))) return;
+      clearTimeout(timer);
+      timer = setTimeout(() => compileOnce(filePath, explicitFlats, out, checkOnly, assetMode), 80);
+    });
+    process.stdout.write(`flatc: watching ${baseDir} \u2026 (Ctrl+C to stop)
+`);
+    return code;
+  }
+  return compileOnce(filePath, explicitFlats, out, checkOnly, assetMode);
+}
+
+export {
+  compileFlatpack,
+  packToJSON,
+  localVariables,
+  lint,
+  lintReport,
+  splitScopeProgram,
+  scopeRegions,
+  formatObjectBlock,
+  joinScopeProgram,
+  scopeProgram,
+  docLintContext,
+  allScopeVariables,
+  docStructureWarnings,
+  docLayoutWarnings,
+  lintDoc,
+  lintDocReport,
+  docHasErrors,
+  run
+};
+//# sourceMappingURL=chunk-EHQSVWOD.js.map