@flatkit/compiler 0.23.0 → 0.25.0

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/manifest.ts","../src/languageCard.ts","../src/index.ts"],"sourcesContent":["// ─────────────────────────────────────────────────────────────────────────────\n//  manifest.ts — \"map of the scene\" for an LLM (and tooling introspection).\n//\n//  The language fits in < 2k tokens (see languageCard); the real context cost for an LLM\n//  is knowing WHAT IT CAN NAME in THIS scene (objects, assets, variables, functions).\n//  `docToManifest` derives this compact block from a Doc — the exact counterpart of references\n//  by name (sceneRefs): the model then references only REAL names, and the linter catches the rest.\n//\n//  Pure, derived (never stored). ~a few hundred tokens for a real scene.\n// ─────────────────────────────────────────────────────────────────────────────\nimport type { Doc, Group, Image, Instance, Layer, Text } from '@flatkit/types'\nimport { EXPR_CHANNELS, OFFSET_CHANNELS } from '@flatkit/engine/timeline'\nimport { getSymbol, isGroup, isImage, isInstance, isPoseable, isText } from '@flatkit/engine/layers'\nimport { languageCard } from './languageCard'\n\n/** Type label of a poseable (hence named) item. */\nfunction kindLabel(doc: Doc, it: Group | Instance | Text | Image): string {\n  if (isInstance(it)) { const s = getSymbol(doc, it.symbolId); return s ? `Instance:${s.name}` : 'Instance' }\n  if (isText(it)) return 'Text'\n  if (isImage(it)) return 'Image'\n  return 'Symbol' // Group (\"symbol\" in the UI)\n}\n\nexport type ManifestObject = { name: string; kind: string }\n\n/** Named scene objects (groups included, library symbols excluded), first name wins. */\nexport function manifestObjects(doc: Doc): ManifestObject[] {\n  const out: ManifestObject[] = []\n  const seen = new Set<string>()\n  const walk = (layers: Layer[]) => {\n    for (const l of layers) for (const it of l.items) {\n      if (isPoseable(it) && it.name && !seen.has(it.name)) { seen.add(it.name); out.push({ name: it.name, kind: kindLabel(doc, it) }) }\n      if (isGroup(it)) walk(it.layers)\n    }\n  }\n  walk(doc.layers)\n  return out\n}\n\n/** Variables → `name=value` (scalar) or `name[len]` (array). */\nfunction manifestVars(doc: Doc): string[] {\n  return Object.entries(doc.variables ?? {}).map(([k, v]) => (Array.isArray(v) ? `${k}[${v.length}]` : `${k}=${v}`))\n}\n\n/**\n * Compact map of the scene (objects/assets/variables/functions/packages) — injectable in a prompt.\n * Only non-empty sections appear. The names are the ones the code can reference.\n */\nexport function docToManifest(doc: Doc): string {\n  const objs = manifestObjects(doc)\n  const assets = (doc.assets ?? []).map((a) => `${a.kind}:${a.id}`)\n  const vars = manifestVars(doc)\n  const funcs = (doc.functions ?? []).map((f) => `${f.name}(${f.params.join(', ')})`)\n  const lines = ['# SCENE', `size: ${doc.width}x${doc.height}`]\n  if (objs.length) lines.push(`objects: ${objs.map((o) => `${o.name}(${o.kind})`).join(', ')}`)\n  if (assets.length) lines.push(`assets: ${assets.join(', ')}`)\n  if (vars.length) lines.push(`vars: ${vars.join(', ')}`)\n  if (funcs.length) lines.push(`funcs: ${funcs.join(', ')}`)\n  if (doc.imports?.length) lines.push(`packages: ${doc.imports.join(', ')}`)\n  lines.push(`channels: ${EXPR_CHANNELS.join(' ')}  (additive offsets: ${OFFSET_CHANNELS.join(' ')} -> pos = at + d)`)\n  return lines.join('\\n')\n}\n\n/** Full LLM context: language reference (static) + scene map (derived from the Doc). */\nexport function llmContext(doc: Doc): string {\n  return `${languageCard()}\\n\\n${docToManifest(doc)}`\n}\n","// ─────────────────────────────────────────────────────────────────────────────\n//  languageCard.ts — TERSE reference of FlatInk Script, \"system-prompt\" sized.\n//\n//  Single source of truth to steer an LLM (or a human in a hurry): condensed\n//  grammar + built-ins, ~1k tokens. The function/constant/channel lists are\n//  INTERPOLATED from expr/timeline/stdlib → never out of sync with the real engine.\n//  To be paired with `docToManifest` (manifest.ts) for the names specific to a scene.\n// ─────────────────────────────────────────────────────────────────────────────\nimport { STD_CONSTANTS, STD_FUNCTIONS } from '@flatkit/engine/expr'\nimport { EXPR_CHANNELS } from '@flatkit/engine/timeline'\nimport { PACKAGES } from '@flatkit/engine/stdlib'\n\n/** Language reference card (static, kept in sync with the engine via STD_*). */\nexport function languageCard(): string {\n  return `# FlatInk Script — reference\nNumbers only (0 = false, anything else = true). No string type (only event/label/asset names in quotes). Comment: // to end of line.\nOne statement per line — a newline ends the statement (write \\`x = 1\\` then \\`y = 2\\` on separate lines, not \\`x = 1  y = 2\\`).\n\n## Objects\nobject \"Name\" { … } attaches behavior BY NAME. The name must be a group / instance / text / image — the only things that carry a pose.\nA SHAPE (\\`rect … as \"N\"\\`) or a LAYER cannot be animated: wrap the shape in \\`group \"N\" { layer \"art\" { … } }\\`. (Naming one is a compile error.)\nOpacities MULTIPLY down the tree — do not set \\`opacity 0\\` on the shape to hide it at rest, or the group's fade-in stays invisible.\n\n## Events (attach to an object or to the scene)\nwhen loaded { }      // once, on start\nevery frame { }      // every frame\nat frame N { }       // when the playhead reaches frame N\nwhen clicked|hovered|unhovered|pressed|dragged|released|held { }\n\n## Actions\nplay · pause · go to frame N [and play|and pause] · go to \"label\"\nname = expr            // set a variable\narr[i] = expr          // write an array slot\nif cond { } else { } · repeat N times { } · repeat i from A to B { }\nmyProc() · send \"event\"[, expr | text(\"id\") | { a = expr, b … }] · sound \"assetId\"\n\n## Expressions (drive a channel, or compute in an action)\nchannel = expr         channels: ${EXPR_CHANNELS.join(' ')}   (expression wins over keyframes)\ndx = expr · dy = expr  // ADDITIVE offset: final pos = at + (dx, dy) — oscillate AROUND the anchor (dx = 30*sin(time)); absolute x/y REPLACE at\nrotationDeg = expr     // sugar for rotation = rad(expr) — author angles in DEGREES (rotation & sin/cos/atan2 are RADIANS)\noperators: + - * / %   < > <= >= == !=   && || !   cond ? a : b\ncontext: time frame clock value · mouse.x mouse.y mouse.dx mouse.dy · keys.Space keys.ArrowLeft … (keys are 1/0, use directly: keys.Space ? … : …)\n  time WRAPS every durationFrames (2.5 s by default) — clock is MONOTONE. Timestamps you capture and compare later MUST use clock\n  (\\`when wrong { shown = clock }\\` + \\`opacity = pulse(shown, 4)\\`), or the ramp replays on every loop.\nName.x Name.y Name.rotation Name.scaleX Name.scaleY Name.opacity   // any named object (identifier name), live on-screen value (read-only)\nself.x self.y self.rotation self.scaleX self.scaleY self.opacity   // the object's own channels, in its bindings (no mirror variable)\n\n## Spaces (local vs world)\nself & channels (x, y, rotation…) = LOCAL (relative to parent — what x = … sets). Name.x, mouse.x = WORLD (the stage).\nAt the scene root, local = world (the common case → nothing to think about). If an object is NESTED in a group and you\nrelate it to a world position, convert: toLocalX(x, y) toLocalY(x, y) (world → your space) · toGlobalX/Y (your space → world).\nconstants: ${STD_CONSTANTS.join(' ')}\nfunctions: ${STD_FUNCTIONS.join(' ')}\n\n## Direct manipulation (interactors)\ndrag x, y                      // object follows the pointer while held → writes vars x, y (bind them: x = vx, y = vy)\n{ enabled <expr> } gates the GESTURE only — when/pressed/released/clicked STILL fire. Guard the body: when released { if done == 0 { … } }\ndragX vx · dragY vy            // single-axis\ndrag x, y { confine to Zone  snap 10 }   // bound to a named object's box · grid snap\nturn a around cx,cy { snap 15 }    // dial/knob → a = pivot→cursor angle in RADIANS (pair: rotation = a)\nturnDeg a around cx,cy { snap 15 } // same in DEGREES (pair: rotationDeg = a) · snap is degrees on both\nwhen dropped on Zone { … }     // fires on release when the object's center is inside the named zone\n\n## Declarations\nlet name = 0 · let arr = fill(n, v) · let arr = [a, b, c]\nfn name(a, b) = expr                       // value function (use in expressions)\nfn name() { … }                            // procedure (block of actions)\neach \"Symbol\" as i { opacity = data[i] }   // bind every instance of a symbol (i = index)\nuse \"package\"          packages: ${PACKAGES.join(' ')}   // OPTIONAL: calling a package function imports it automatically\n\n## Example\nlet score = 0\nevery frame { score = score + 1 }\nobject \"Ball\" {\n  when clicked { score = score + 1 }\n  rotation = atan2(Target.y - self.y, Target.x - self.x)   // aim at another object by name\n}`\n}\n","// @flatkit/compiler -- the FlatInk language and compiler.\n//\n// Parses FlatInk Script (the .flatink DSL) and compiles a program plus its assets into a .flatpack:\n// a playable `Doc` (JSON, with the material already baked). Also ships the `flatc` CLI (`run`).\n//\n// The language layer (DSL parser/printer, .flat format) lives in @flatkit/engine and is re-exported\n// here so the compiler package is a single coherent entry point.\n\n// --- Compile a program (+ assets) into a playable .flatpack Doc ---------------\nexport { compileFlatpack, packToJSON, type MediaMap } from './compile'\n\n// --- Static analysis: lint a program / a whole Doc ----------------------------\nexport { lint, lintReport, localVariables, type LintContext } from './lint'\nexport {\n  lintDoc, lintDocReport, docHasErrors, docLintContext, allScopeVariables,\n  scopeProgram, docStructureWarnings, docLayoutWarnings,\n} from './programDoc'\n\n// --- Manifest / LLM context for a Doc -----------------------------------------\nexport { manifestObjects, docToManifest, llmContext, type ManifestObject } from './manifest'\n\n// --- The language reference card ----------------------------------------------\nexport { languageCard } from './languageCard'\n\n// --- Scope-program helpers (split/join the per-object behavior blocks) ---------\nexport { splitScopeProgram, scopeRegions, formatObjectBlock, joinScopeProgram } from './scopeProgram'\n\n// --- The flatc CLI entry point (also wired as the `flatc` bin) -----------------\nexport { run } from './cli/flatc'\n\n// --- The language layer, re-exported from the engine for convenience ----------\nexport { parseUnits, printUnits } from '@flatkit/engine/dsl'\nexport {\n  parseProgram, printProgram, parseProgramFull, printProgramFull,\n  parseFlat, parseFlatLib, exportFlatProject,\n} from '@flatkit/engine/flatFormat'\n"],"mappings":"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","names":["EXPR_CHANNELS","EXPR_CHANNELS"]}
+{"version":3,"sources":["../src/manifest.ts","../src/languageCard.ts","../src/drawingCard.ts","../src/index.ts"],"sourcesContent":["// ─────────────────────────────────────────────────────────────────────────────\n//  manifest.ts — \"map of the scene\" for an LLM (and tooling introspection).\n//\n//  The language fits in < 2k tokens (see languageCard); the real context cost for an LLM\n//  is knowing WHAT IT CAN NAME in THIS scene (objects, assets, variables, functions).\n//  `docToManifest` derives this compact block from a Doc — the exact counterpart of references\n//  by name (sceneRefs): the model then references only REAL names, and the linter catches the rest.\n//\n//  Pure, derived (never stored). ~a few hundred tokens for a real scene.\n// ─────────────────────────────────────────────────────────────────────────────\nimport type { Doc, Group, Image, Instance, ItemEvent, Layer, Text } from '@flatkit/types'\nimport { EXPR_CHANNELS, OFFSET_CHANNELS } from '@flatkit/engine/timeline'\nimport { getSymbol, isGroup, isImage, isInstance, isPoseable, isText } from '@flatkit/engine/layers'\nimport { analyzeExpr } from '@flatkit/engine/expr'\nimport { forEachAction, forEachActionExpression, forEachItemExpression } from './docWalk'\nimport { languageCard } from './languageCard'\nimport { drawingCard } from './drawingCard'\n\n/** Type label of a poseable (hence named) item. */\nfunction kindLabel(doc: Doc, it: Group | Instance | Text | Image): string {\n  if (isInstance(it)) { const s = getSymbol(doc, it.symbolId); return s ? `Instance:${s.name}` : 'Instance' }\n  if (isText(it)) return 'Text'\n  if (isImage(it)) return 'Image'\n  return 'Symbol' // Group (\"symbol\" in the UI)\n}\n\n/**\n * A named scene object and the CONTRACT the logic places on it — what a host must honour to reskin the\n * scene without touching its behavior. Deliberately free of coordinates: the names and the roles are the\n * contract, the composition stays entirely the skin's business. (A contract that carried positions would\n * hand every reskin the same layout, which is exactly the failure it exists to prevent.)\n */\nexport type ManifestObject = {\n  name: string\n  kind: string\n  /** Item events the logic handles on it (`click`, `drop`…) — the skin must keep them reachable. */\n  events: ItemEvent[]\n  /** A `drag`/`turn` interactor targets it: the pointer writes its position, so the skin must not pin it. */\n  dragged: boolean\n  /** A placement target: something drops on it, or it carries a `hitbox`. Keep the name and a generous box. */\n  zone: boolean\n  /** Channels the logic drives (bindings and modifier targets) — a skin that sets these fights the logic. */\n  channels: string[]\n  /** Document variables it reads: the game state a skin can hang its own visuals on. */\n  reads: string[]\n}\n\n/** The program's STATE: every variable a skin could meaningfully bind to. Wider than `doc.variables`,\n *  which only holds the `var`-declared ones — a variable first assigned in a handler, or written by a\n *  `drag` interactor, is just as real at runtime and is often the most interesting one to bind. */\nfunction stateVariables(doc: Doc): Set<string> {\n  const out = new Set(Object.keys(doc.variables ?? {}))\n  forEachAction(doc, (a) => {\n    if (a.do === 'setVar' || a.do === 'setIndex') out.add(a.name)\n    else if (a.do === 'repeatRange') out.add(a.var)\n  })\n  for (const i of doc.interactors ?? []) for (const v of [i.varX, i.varY, i.varT]) if (v) out.add(v)\n  return out\n}\n\n/** State variables referenced by an expression — parsed, not grepped, so `open` never matches `reopen`\n *  and a name nested inside a call still counts. An unparseable expression yields nothing (the linter\n *  reports it; the manifest stays quiet). Runtime scalars (`time`, `mouse.x`) are not state and never\n *  appear: they are not something a host can set. */\nfunction readsOf(expr: string, state: Set<string>, into: Set<string>): void {\n  const a = analyzeExpr(expr)\n  if (!a.ok) return\n  for (const id of a.refs.ids) if (state.has(id)) into.add(id)\n}\n\n/** Named scene objects (groups included, library symbols excluded) with their binding contract; first\n *  name wins, and nested groups are walked. */\nexport function manifestObjects(doc: Doc): ManifestObject[] {\n  const out: ManifestObject[] = []\n  const seen = new Set<string>()\n  const state = stateVariables(doc)\n  const dropZones = new Set((doc.interactions ?? []).filter((i) => i.event === 'drop' && i.over).map((i) => i.over as string))\n  const walk = (layers: Layer[]) => {\n    for (const l of layers) for (const it of l.items) {\n      if (isPoseable(it) && it.name && !seen.has(it.name)) {\n        seen.add(it.name)\n        const mine = (doc.interactions ?? []).filter((i) => i.targetId === it.id)\n        const channels: string[] = []\n        const reads = new Set<string>()\n        forEachItemExpression(it, (expr, channel) => { channels.push(channel); readsOf(expr, state, reads) })\n        for (const i of mine) forEachActionExpression(i.actions, (expr) => readsOf(expr, state, reads))\n        out.push({\n          name: it.name,\n          kind: kindLabel(doc, it),\n          events: [...new Set(mine.map((i) => i.event))],\n          dragged: !!doc.interactors?.some((i) => i.targetId === it.id),\n          zone: dropZones.has(it.name) || (isGroup(it) && !!it.hitbox),\n          channels,\n          reads: [...reads],\n        })\n      }\n      if (isGroup(it)) walk(it.layers)\n    }\n  }\n  walk(doc.layers)\n  return out\n}\n\n/** The events the program EMITS to its host (`send \"…\"`), in order of first appearance, deduped. The\n *  other half of the contract: the moments a host — or a skin's motion pass — can react to. */\nexport function manifestEvents(doc: Doc): string[] {\n  const events = new Set<string>()\n  forEachAction(doc, (a) => { if (a.do === 'send') events.add(a.event) })\n  return [...events]\n}\n\n/** One object's contract, as readable clauses. Empty = pure decor the skin owns outright. */\nfunction contractParts(o: ManifestObject): string[] {\n  const parts: string[] = []\n  if (o.dragged) parts.push('drag')\n  if (o.zone) parts.push('zone')\n  if (o.events.length) parts.push(`on ${o.events.join('/')}`)\n  if (o.channels.length) parts.push(`driven: ${o.channels.join(' ')}`)\n  if (o.reads.length) parts.push(`reads: ${o.reads.join(' ')}`)\n  return parts\n}\n\n/** Variables → `name=value` (scalar) or `name[len]` (array). */\nfunction manifestVars(doc: Doc): string[] {\n  return Object.entries(doc.variables ?? {}).map(([k, v]) => (Array.isArray(v) ? `${k}[${v.length}]` : `${k}=${v}`))\n}\n\n/**\n * Compact map of the scene (objects/assets/variables/functions/packages) — injectable in a prompt.\n * Only non-empty sections appear. The names are the ones the code can reference.\n */\nexport function docToManifest(doc: Doc): string {\n  const objs = manifestObjects(doc)\n  const assets = (doc.assets ?? []).map((a) => `${a.kind}:${a.id}`)\n  const vars = manifestVars(doc)\n  const funcs = (doc.functions ?? []).map((f) => `${f.name}(${f.params.join(', ')})`)\n  const lines = ['# SCENE', `size: ${doc.width}x${doc.height}`]\n  if (objs.length) lines.push(`objects: ${objs.map((o) => `${o.name}(${o.kind})`).join(', ')}`)\n  if (assets.length) lines.push(`assets: ${assets.join(', ')}`)\n  if (vars.length) lines.push(`vars: ${vars.join(', ')}`)\n  if (funcs.length) lines.push(`funcs: ${funcs.join(', ')}`)\n  if (doc.imports?.length) lines.push(`packages: ${doc.imports.join(', ')}`)\n  // The binding contract, for the objects that carry one — what a skin must honour. No positions: the\n  // composition is the skin's to invent, which is precisely what keeps two scenes from looking alike.\n  const contract = objs.map((o) => ({ o, parts: contractParts(o) })).filter(({ parts }) => parts.length)\n  if (contract.length) {\n    lines.push('contract (honour these; the layout is yours):')\n    for (const { o, parts } of contract) lines.push(`  ${o.name} - ${parts.join(', ')}`)\n  }\n  const events = manifestEvents(doc)\n  if (events.length) lines.push(`events: ${events.join(', ')}`)\n  lines.push(`channels: ${EXPR_CHANNELS.join(' ')}  (additive offsets: ${OFFSET_CHANNELS.join(' ')} -> pos = at + d)`)\n  return lines.join('\\n')\n}\n\n/**\n * EVERYTHING a model needs to write a whole program: both language references (static) + the scene map\n * derived from the Doc. It is the bundle, not the map — if you only want the names this scene can\n * reference (because you already inject the references yourself), that is **`docToManifest(doc)`**, and\n * calling this instead ships the cards a second time.\n *\n * The DRAWING card is included by default. Handed the behavior card alone, a model asked for decor\n * invents a shapes grammar — and what it invents does not compile. Pass `{ drawing: false }` when the\n * model only edits behavior and the prompt budget is tight.\n */\nexport function llmContext(doc: Doc, opts: { drawing?: boolean } = {}): string {\n  const cards = opts.drawing === false ? languageCard() : `${languageCard()}\\n\\n${drawingCard()}`\n  return `${cards}\\n\\n${docToManifest(doc)}`\n}\n","// ─────────────────────────────────────────────────────────────────────────────\n//  languageCard.ts — TERSE reference of FlatInk Script, \"system-prompt\" sized.\n//\n//  Single source of truth to steer an LLM (or a human in a hurry): condensed\n//  grammar + built-ins, ~1k tokens. The function/constant/channel lists are\n//  INTERPOLATED from expr/timeline/stdlib → never out of sync with the real engine.\n//  To be paired with `docToManifest` (manifest.ts) for the names specific to a scene.\n// ─────────────────────────────────────────────────────────────────────────────\nimport { STD_CONSTANTS, STD_FUNCTIONS } from '@flatkit/engine/expr'\nimport { EXPR_CHANNELS } from '@flatkit/engine/timeline'\nimport { PACKAGES } from '@flatkit/engine/stdlib'\n\n/** Language reference card (static, kept in sync with the engine via STD_*). */\nexport function languageCard(): string {\n  return `# FlatInk Script — reference\nNumbers only (0 = false, anything else = true). No string type (only event/label/asset names in quotes). Comment: // to end of line.\nOne statement per line — a newline ends the statement (write \\`x = 1\\` then \\`y = 2\\` on separate lines, not \\`x = 1  y = 2\\`).\n\n## Objects\nobject \"Name\" { … } attaches behavior BY NAME. The name must be a group / instance / text / image — the only things that carry a pose.\nA SHAPE (\\`rect … as \"N\"\\`) or a LAYER cannot be animated: wrap the shape in \\`group \"N\" { layer \"art\" { … } }\\`. (Naming one is a compile error.)\nOpacities MULTIPLY down the tree — do not set \\`opacity 0\\` on the shape to hide it at rest, or the group's fade-in stays invisible.\n\n## Events (attach to an object or to the scene)\nwhen loaded { }      // once, on start\nevery frame { }      // every frame\nat frame N { }       // when the playhead reaches frame N\nwhen clicked|hovered|unhovered|pressed|dragged|released|held { }\n\n## Actions\nplay · pause · go to frame N [and play|and pause] · go to \"label\"\nname = expr            // set a variable\narr[i] = expr          // write an array slot\nif cond { } else { } · repeat N times { } · repeat i from A to B { }\nmyProc() · send \"event\"[, expr | text(\"id\") | { a = expr, b … }] · sound \"assetId\"\n\n## Expressions (drive a channel, or compute in an action)\nchannel = expr         channels: ${EXPR_CHANNELS.join(' ')}   (expression wins over keyframes)\ndx = expr · dy = expr  // ADDITIVE offset: final pos = at + (dx, dy) — oscillate AROUND the anchor (dx = 30*sin(time)); absolute x/y REPLACE at\nrotationDeg = expr     // sugar for rotation = rad(expr) — author angles in DEGREES (rotation & sin/cos/atan2 are RADIANS)\noperators: + - * / %   < > <= >= == !=   && || !   cond ? a : b\ncontext: time frame clock value · mouse.x mouse.y mouse.dx mouse.dy · keys.Space keys.ArrowLeft … (keys are 1/0, use directly: keys.Space ? … : …)\n  time WRAPS every durationFrames (2.5 s by default) — clock is MONOTONE. Timestamps you capture and compare later MUST use clock\n  (\\`when wrong { shown = clock }\\` + \\`opacity = pulse(shown, 4)\\`), or the ramp replays on every loop.\nName.x Name.y Name.rotation Name.scaleX Name.scaleY Name.opacity   // any named object (identifier name), live on-screen value (read-only)\nself.x self.y self.rotation self.scaleX self.scaleY self.opacity   // the object's own channels, in its bindings (no mirror variable)\n\n## Spaces (local vs world)\nself & channels (x, y, rotation…) = LOCAL (relative to parent — what x = … sets). Name.x, mouse.x = WORLD (the stage).\nAt the scene root, local = world (the common case → nothing to think about). If an object is NESTED in a group and you\nrelate it to a world position, convert: toLocalX(x, y) toLocalY(x, y) (world → your space) · toGlobalX/Y (your space → world).\nconstants: ${STD_CONSTANTS.join(' ')}\nfunctions: ${STD_FUNCTIONS.join(' ')}\n\n## Direct manipulation (interactors)\ndrag x, y                      // object follows the pointer while held → writes vars x, y (bind them: x = vx, y = vy)\n{ enabled <expr> } gates the GESTURE only — when/pressed/released/clicked STILL fire. Guard the body: when released { if done == 0 { … } }\ndragX vx · dragY vy            // single-axis\ndrag x, y { confine to Zone  snap 10 }   // bound to a named object's box · grid snap\nturn a around cx,cy { snap 15 }    // dial/knob → a = pivot→cursor angle in RADIANS (pair: rotation = a)\nturnDeg a around cx,cy { snap 15 } // same in DEGREES (pair: rotationDeg = a) · snap is degrees on both\nwhen dropped on Zone { … }     // fires on release when the object's center is inside the named zone\n\n## Declarations\nlet name = 0 · let arr = fill(n, v) · let arr = [a, b, c]\nfn name(a, b) = expr                       // value function (use in expressions)\nfn name() { … }                            // procedure (block of actions)\neach \"Symbol\" as i { opacity = data[i] }   // bind every instance of a symbol (i = index)\nuse \"package\"          packages: ${PACKAGES.join(' ')}   // OPTIONAL: calling a package function imports it automatically\n\n## Example\nlet score = 0\nevery frame { score = score + 1 }\nobject \"Ball\" {\n  when clicked { score = score + 1 }\n  rotation = atan2(Target.y - self.y, Target.x - self.x)   // aim at another object by name\n}`\n}\n","// ─────────────────────────────────────────────────────────────────────────────\n//  drawingCard.ts — TERSE reference of the DRAWING half of FlatInk, \"system-prompt\" sized.\n//\n//  `languageCard` covers BEHAVIOR (events, channels, expressions) and not one word of the composition:\n//  no shapes, no paints, no filters. An integrator handing that card to a model and asking for decor was\n//  handing it a reference with nothing about drawing — so the model guessed, and what a model guesses in\n//  a DSL does not compile. The two cards are complements: pair them (plus `docToManifest` for the names\n//  of a particular scene) whenever a model has to produce a whole `.flatink`.\n//\n//  Every ```flatink example below is COMPILED by drawingCard.test.ts. A reference that is copied drifts;\n//  one that is compiled cannot. When the grammar moves, that test goes red rather than this card going\n//  quietly wrong.\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Drawing reference card (composition: shapes, paints, filters, text, clipping). */\nexport function drawingCard(): string {\n  return `# FlatInk — drawing (the \\`scene { … }\\` half)\n\nThe unit is the LAYER: \\`layer \"name\" { … }\\`, stacked bottom to top. A layer holds shapes, text, images\nand groups (which nest their own layers). Coordinates are PIXELS in the parent's frame — never percentages.\n\n## Shapes\ncircle  <cx> <cy> <r>\nellipse <cx> <cy> <rx> <ry>\nrect    <x> <y> <w> <h> [<r>]              // r = rounded corners (or <rx> <ry> for distinct)\npath    \"M0 0 C40 -20 80 20 120 0 Z\"       // raw SVG path data — total freedom\ncircle 100 100 40 as \"Ring\"                // name it (right after the geometry) → addressable\n\n## Paint\nfill #rrggbb | #rrggbbaa · nofill\nfill linear(<angle>, 0:#…, 1:#…)           // angle: 0 = →, 90 = ↓ ; stops are offset:color\nfill radial(<cx>, <cy>, <r>, 0:#…, 1:#…)   // cx/cy/r as 0..1 of the box\nstroke <paint> <width> [cap butt|round|square] [join miter|round|bevel] [miter <n>] [dash a,b]\nopacity <0..1>                             // opacities MULTIPLY down the tree\n\n## Filters — on any item, no wrapper group needed\nfilter glow <blur> <color> · filter shadow <dx> <dy> <blur> <color>\nfilter blur <radius> · filter adjust <brightness> <contrast> <saturate> <hue>\n\n## Text\ntext \"…\" at <x>,<y> box <w> <h> font \"sans-serif\" size <n> align center line 1.2 color #… [bold] [italic] [wrap]\ntext \"…\" along \"<shapeId>\" align center start 0.5     // laid along a named shape's curve\nWord-wrap is OPT-IN: without \\`wrap\\`, only an explicit \\\\n breaks a line.\n\n## Images\nimage \"<assetId>\" <w> <h> at <x>,<y>       // the asset is declared at the top: asset \"logo\" \"logo.svg\" image\n\n## Clipping\ngroup \"Name\" at x,y clip <x> <y> <w> <h> { … }    // rectangular cut, in the group's LOCAL coordinates\nmask layer \"Name\" { <shapes>  layer \"c\" { … } }   // arbitrary shape: the mask's matter clips its child layers\n\n## The five rules that decide whether it compiles\n1. WORD ORDER IS FIXED: content → \\`as \"…\"\\` → \\`at …\\` → style. So \\`text \"Hi\" at 10,10 box 200 40\\`,\n   NEVER \\`text \"Hi\" box 200 40 at 10,10\\`. A shape names itself right after its geometry.\n   Stroke options (\\`cap\\`/\\`join\\`/\\`miter\\`/\\`dash\\`) belong to the STROKE and follow it directly:\n   \\`nofill stroke #888 2 dash 6,5\\`, not \\`stroke #888 2 nofill dash 6,5\\`.\n2. A COMMENT STARTS WITH \\`//\\`. A \\`#\\` opens a COLOR.\n3. ONE STATEMENT PER LINE.\n4. Anything you intend to ANIMATE must be a \\`group \"Name\" at x,y { layer \"c\" { … } }\\`. An \\`object\\`\n   block aimed at a shape or a layer is a compile ERROR — shapes are baked material and carry no pose.\n5. A group's children are positioned RELATIVE to it. Draw them around 0,0 and place the group.\n\n## Examples\n\nA sky and a ground, in two gradients:\n\n\\`\\`\\`flatink\nsize 960 540\nscene {\n  layer \"sky\" {\n    rect 0 0 960 540 fill linear(90, 0:#1b2a4a, 1:#4a6fa5)\n    ellipse 780 90 70 70 fill radial(0.5, 0.5, 0.5, 0:#ffe9a8, 1:#ffe9a800)\n  }\n  layer \"ground\" {\n    path \"M0 430 C240 400 420 460 960 415 L960 540 L0 540 Z\" fill #2e4b34 opacity 0.85\n  }\n}\n\\`\\`\\`\n\nA line-art silhouette and a drop shadow:\n\n\\`\\`\\`flatink\nsize 200 400\nscene {\n  layer \"tree\" {\n    path \"M60 300 L60 180 M60 220 L20 170 M60 230 L100 180\" nofill stroke #23301f 8 cap round\n    circle 60 150 60 fill #3f6b3a filter shadow 0 6 12 #00000055\n  }\n}\n\\`\\`\\`\n\nA group — the only shape a behavior block can animate:\n\n\\`\\`\\`flatink\nsize 480 320\nscene {\n  layer \"life\" {\n    group \"Cloud\" at 240,120 {\n      layer \"c\" {\n        ellipse 0 0 70 26 fill #ffffff opacity 0.22\n        ellipse 46 -10 44 22 fill #ffffff opacity 0.18\n      }\n    }\n  }\n}\n\nobject \"Cloud\" {\n  dx = 30 * sin(clock)\n}\n\\`\\`\\`\n\nA panel, text, and a clipped porthole:\n\n\\`\\`\\`flatink\nsize 960 540\nscene {\n  layer \"panel\" {\n    rect 40 40 300 90 24 fill #10141c99 stroke #ffffff33 2\n    text \"Workshop\" at 60,66 box 260 40 font \"sans-serif\" size 26 color #f2f6ff\n    group \"Porthole\" at 700,300 clip -60 -60 120 120 {\n      layer \"c\" { circle 0 0 90 fill linear(0, 0:#0b3d5c, 1:#0f6f92) }\n    }\n  }\n}\n\\`\\`\\``\n}\n","// @flatkit/compiler -- the FlatInk language and compiler.\n//\n// Parses FlatInk Script (the .flatink DSL) and compiles a program plus its assets into a .flatpack:\n// a playable `Doc` (JSON, with the material already baked). Also ships the `flatc` CLI (`run`).\n//\n// The language layer (DSL parser/printer, .flat format) lives in @flatkit/engine and is re-exported\n// here so the compiler package is a single coherent entry point.\n\n// --- Compile a program (+ assets) into a playable .flatpack Doc ---------------\nexport { compileFlatpack, packToJSON, type MediaMap } from './compile'\n\n// --- Check a program the way the CLI does (source in, diagnostics out) --------\nexport { checkProgram, programDiagnostics, formatDiagnostics, type CheckDiagnostic, type CheckOptions, type CheckResult } from './check'\n\n// --- Static analysis: lint a program / a whole Doc ----------------------------\nexport { lint, lintReport, localVariables, type LintContext } from './lint'\nexport {\n  lintDoc, lintDocReport, docHasErrors, docLintContext, allScopeVariables,\n  scopeProgram, docStructureWarnings, docLayoutWarnings,\n} from './programDoc'\n\n// --- Manifest / LLM context for a Doc -----------------------------------------\nexport { manifestObjects, manifestEvents, docToManifest, llmContext, type ManifestObject } from './manifest'\n\n// --- The reference cards: behavior (languageCard) and composition (drawingCard) -\nexport { languageCard } from './languageCard'\nexport { drawingCard } from './drawingCard'\n\n// --- Scope-program helpers (split/join the per-object behavior blocks) ---------\nexport { splitScopeProgram, scopeRegions, formatObjectBlock, joinScopeProgram } from './scopeProgram'\n\n// --- The flatc CLI entry point (also wired as the `flatc` bin) -----------------\nexport { run } from './cli/flatc'\n\n// --- The language layer, re-exported from the engine for convenience ----------\nexport { parseUnits, printUnits } from '@flatkit/engine/dsl'\nexport {\n  parseProgram, printProgram, parseProgramFull, printProgramFull,\n  parseFlat, parseFlatLib, exportFlatProject,\n} from '@flatkit/engine/flatFormat'\n"],"mappings":"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","names":["EXPR_CHANNELS","EXPR_CHANNELS"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flatkit/compiler",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "The FlatInk language (parser + AST) and compiler (.flatink → .flatpack). Ships the flatc CLI.",
   "license": "MIT",
   "author": "Zwyk Studio",
@@ -26,15 +26,18 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
     },
     "./compile": {
       "types": "./dist/compile.d.ts",
-      "import": "./dist/compile.js"
+      "import": "./dist/compile.js",
+      "require": "./dist/compile.js"
     },
     "./analysis": {
       "types": "./dist/analysis.d.ts",
-      "import": "./dist/analysis.js"
+      "import": "./dist/analysis.js",
+      "require": "./dist/analysis.js"
     }
   },
   "bin": {
@@ -42,12 +45,13 @@
   },
   "files": [
     "dist",
-    "bin"
+    "bin",
+    "prompts"
   ],
   "dependencies": {
-    "@flatkit/engine": "0.23.0",
-    "@flatkit/player": "0.23.0",
-    "@flatkit/types": "0.23.0"
+    "@flatkit/engine": "0.25.0",
+    "@flatkit/types": "0.25.0",
+    "@flatkit/player": "0.25.0"
   },
   "peerDependencies": {
     "skia-canvas": "^3.0.8"

package/prompts/README.md

@@ -0,0 +1,45 @@
+# FlatInk prompts — teaching the language to a model
+
+These files ship inside `@flatkit/compiler`, so an integrator never has to copy the grammar by hand. A
+copied reference drifts from the language, and the drift is paid in DSL that the end user's compiler
+rejects. Read them from the installed package:
+
+```js
+import { readFileSync } from 'node:fs'
+const core = readFileSync(new URL('../prompts/flatink-core.md', import.meta.resolve('@flatkit/compiler')), 'utf8')
+```
+
+In a browser (or when you want something smaller and always in sync with the engine), prefer the
+generated cards instead — they interpolate the real function/channel lists and are a fraction of the size:
+
+```js
+import { languageCard, drawingCard, llmContext } from '@flatkit/compiler'
+
+llmContext(doc)              // behavior card + drawing card + the names of THIS scene
+languageCard()               // behavior only: events, channels, expressions
+drawingCard()                // composition only: shapes, paints, filters, text, clipping
+```
+
+## What each file is for
+
+| File | Use it when |
+|---|---|
+| `flatink-core.md` | the model writes a whole `.flatink` or `.flat` from scratch — the full reference |
+| `flatink-lite.md` | the task is small and the prompt budget is tight — the same language, condensed |
+| `role-asset-creator.md` | the model draws a **symbol library** (`.flat`): shapes, gradients, filters |
+| `role-motion-designer.md` | the model animates: timelines, cels, tweens, channel expressions |
+| `role-coder.md` | the model writes behavior: events, variables, interactions, `send` |
+
+Pair a role file with `flatink-core.md`: the role sets the job, the core sets the grammar.
+
+## Validating what comes back
+
+Never ship generated DSL unchecked. `checkProgram` runs exactly what `flatc --check` runs, on a string,
+with no subprocess — and its report is a serviceable repair prompt:
+
+```js
+import { checkProgram } from '@flatkit/compiler'
+
+const { ok, report } = checkProgram(srcFromTheModel)
+if (!ok) retry(report)
+```

package/prompts/flatink-core.md

@@ -0,0 +1,273 @@
+# FlatInk — generation reference (core)
+
+You generate **FlatInk** source: a small text language for animations and interactive scenes that
+compile to a single playable `.flatpack`. Output **only valid source code** in a fenced block, nothing
+else, unless the user asks for explanation. Author can verify with `flatc <file> --check`.
+
+## Two file types — pick the right one
+
+| Type | Holds | Top-level shape |
+|---|---|---|
+| `.flat` | a **symbol library** (reusable visual assets, animated or not). Not playable on its own. | one or more `symbol "Name" { … }` |
+| `.flatink` | a **program**: a scene + behavior. Playable. | `size W H` then `scene { … }` then behavior |
+
+A `.flatink` is split in **two halves with different grammars**:
+- **`scene { … }`** = composition (what you see): `layer`, shapes, `text`, `image`, `group`, `instance`.
+- **behavior** (everything after `scene`) = logic: `object "Name" { … }`, `every frame`, `var`, `fn`.
+
+## `.flatink` skeleton
+
+```
+size 480 320              # REQUIRED, must be the very first line (canvas units)
+background #0a0e1c        # optional
+timeline 30 300           # optional root timeline: fps, duration(frames). default 24 fps / 60 frames
+use "collision"           # optional stdlib/local packages
+asset "logo" "logo.svg" image   # optional media declarations
+var score = 0             # optional global state
+
+scene {
+  layer "bg"   { rect 0 0 480 320 fill #0a0e1c }
+  layer "game" {
+    circle 240 160 40 fill #ffcc00 as "Sun"
+  }
+}
+
+object "Sun" {
+  when clicked { score = score + 1 }
+  rotation = time * 30
+}
+every frame { if (score >= 10) { send "win" } }
+```
+
+## Drawing (inside `scene`/`symbol` layers)
+
+Coordinates are plain numbers; canvas origin is **top-left**. Layers stack bottom-to-top.
+
+```
+circle  <cx> <cy> <r>
+ellipse <cx> <cy> <rx> <ry>
+rect    <x> <y> <w> <h>  [<r> | <rx> <ry>]      # optional rounded corners
+path    "M0 0 L10 0 L10 10 Z"                    # raw SVG path data
+text    "Hi" font "sans-serif" size 24 align center line 1.2 color #fff box 200 40
+image   "logo" 80 80 at -40,-40                  # origin = top-left → center with at -w/2,-h/2
+group   "Name" at x,y pivot px,py { layer "c" { … } }   # nests its own layers
+instance "Symbol" as "Name" at x,y              # place a symbol from a .flat lib
+```
+
+Paint / style (work on shapes; most on text & groups too):
+```
+fill #rrggbb | nofill
+stroke #rrggbb <width> [cap butt|round|square] [join …] [miter n] [dash a,b,…]
+opacity 0..1                                       # also 8-digit hex alpha #rrggbbaa
+fill linear(90, 0:#bdecff, 1:#2f8fe0)              # angle 0 = →, 90 = ↓ ; stops offset:color
+fill radial(0.5, 0.5, 0.5, 0:#fff, 1:#000)         # cx, cy, r (0..1), then stops
+filter glow <blur> <color> | shadow <dx> <dy> <blur> <color> | blur <r> | adjust <b> <c> <s> <h>
+tint <color> <amount(0..1)>                        # Flash-style tint
+nohit                                              # drawn but ignored by hit-test
+```
+
+## Animation — timeline / cel / pose (in a `symbol`)
+
+A symbol owns a **timeline**; an animated **layer** is a track of **cels** (keyframes). Each cel lists
+the **poses** of containers declared once in the layer roster, plus (optionally) the layer's **matter**
+— the drawing at that key.
+
+```
+symbol "Wheel" {
+  timeline 24 24                          # fps, durationFrames
+  layer "spin" {
+    group "Rim" at 100,100 pivot 0,0 {    # roster: declared ONCE, posed by the cels below
+      layer "art" { circle 0 0 40 nofill stroke #333 8 }
+    }
+    cel 0 tween { pose "Rim" rotate 0 }
+    cel 24       { pose "Rim" rotate 360 }   # one full turn around the pivot, in DEGREES
+  }
+}
+
+pose "Name" [at x,y] [rotate <deg>] [scale s | scaleX sx scaleY sy]
+            [opacity o] [tint #c amt] [spin cw|ccw] [turns n] [filter …]
+```
+
+- `cel N tween { … }` interpolates this cel → the next; without `tween` the cel **holds**.
+- `ease linear|easeIn|easeOut|easeInOut|cubic(a,b,c,d)` on a cel.
+- `pose` units are **human**: degrees, multipliers, around the group's **`pivot`**.
+- A `pose` is a **patch**: it only overrides channels it names (keeps declared position/scale/etc.).
+
+### Frame-by-frame — one DRAWING per cel (`matter`)
+
+A cel can carry the layer's drawing in a `matter { … }` block. A new one per cel = classic cel animation:
+
+```
+layer "draw" {
+  cel 0 { matter { circle 0 0 30 fill #e33 } }
+  cel 1 { matter { rect -30 -30 60 60 fill #3a3 } }
+  cel 2 { matter { path "M -30 30 L 0 -30 L 30 30 Z" fill #33e } }
+}
+```
+- The matter **holds** until the next cel defining one (write a drawing once, not once per frame);
+  `morph` on the cel tweens its **shape** toward the next key instead of cutting.
+- A cel may carry both `matter { … }` and `pose "…"` (matter draws behind the posed containers).
+- Same thing with existing objects: put each drawing in a roster `group` (or `image`) and pose only the
+  one wanted on each cel — an unposed container disappears.
+
+## Channel expressions (behavior, every frame)
+
+Bind a named item's channel to an expression. Absolute channels: `x y scaleX scaleY rotation opacity`.
+Additive position offsets: `dx dy` → **`pos = at + (dx, dy)`** (binding-only; no keyframe/spring form).
+
+```
+object "Needle" {
+  rotation = atan2(mouse.y - 160, mouse.x - 240)   # RADIANS
+  opacity  = lit ? 1 : 0.3
+  dx = 30 * sin(clock)                             # sways AROUND its declared at — no base to re-inject
+}
+```
+Or bind a channel on a symbol container directly: `group "Fan" pivot 0,0 expr rotation "turns(time)" { … }`.
+
+**Stateful easing — `spring` / `smooth`.** A channel that chases its target with inertia instead of
+snapping to it. Per instance, zero cost when unused, and it snaps to the target on a seek (so tune it by
+PLAYING the preview, not by scrubbing).
+```
+group "Cable" spring rotation "hookX" stiffness 0.08 damping 0.86 { … }   # in a .flat: overshoot, settle
+group "Panel" smooth y "target" k 0.15 { … }                              # 1st order: no overshoot
+object "Dial" { spring rotation = aim { stiffness 0.08 damping 0.86 } }   # scene-side form, in .flatink
+```
+The quoted target's names must EXIST in that scope (a symbol `param`, a scene `var`) or `--check` errors.
+
+## Behavior — events, actions, interaction
+
+Events (inside `object`): `when clicked | hovered | unhovered | pressed | released | dragged | held |
+dropped on <Zone> [at pointer]`. Scene-wide: `when loaded`, `every frame`, `at frame <n>`.
+
+Actions (one per line): `<var> = <expr>` · `arr[i] = <expr>` · `if/else if/else` ·
+`repeat <n> times { }` · `repeat i from a to b { }` · `play`/`pause` · `go to frame N [and play]` ·
+`go to "label" [and play]` · `send "evt" [, <expr> | , text("id") | , { a = <expr>, b }]` · `sound "id"` · `<fn>(args)`.
+
+Drag & interactors (each writes into your vars; all accept `{ enabled <expr> }`):
+```
+drag x, y [{ confine to <Zone> · snap <grid> · enabled <expr> }]   # dragX / dragY too
+turn    <angle> around <x>,<y> [{ snap <deg> }]    # → <angle> in RADIANS → rotation = <angle> directly
+turnDeg <angle> around <x>,<y> [{ snap <deg> }]    # → <angle> in DEGREES → pair with rotationDeg = <angle>
+trace <progress> along <Group> [{ tolerance <px> }]# follow a path → 0..1 monotone
+reveal <progress> [{ brush <px> }]                 # scratch/wipe → 0..1 cumulative
+link  <endX>,<endY>,<target> to <Group>            # elastic thread → target = hit index 1..n (0=none)
+```
+
+State & helpers:
+```
+var x = 0    var arr = [0,0,0]    var z = fill(8, 0)     # runtime state (arrays via fill)
+fn dist(ax,ay,bx,by) = hypot(ax-bx, ay-by)              # value fn
+fn reset() { score = 0  go to frame 0 }                  # procedure fn
+self.hovered self.grabbed self.pressed                   # own interaction state (0/1)
+feedback lift tilt dim shake(<expr>)                     # one-liner reactions (auto use "feedback")
+```
+
+## Factoring (compile-time, zero runtime cost)
+
+```
+def gap = 70                                             # compile-time constant, used via $()
+repeat i from 0 to 4 { circle $(40 + i*gap) 80 6 fill #ffd98a }   # $(expr) = compile-time arithmetic
+symbol "Card"(label, tint = "#fff") { … text "$(label)" … fill $(tint) … }   # parameterized symbol
+instance "Card"($(i+1)) as "C$(i)" at $(80 + i*90),200
+each "Key" as i { when clicked { input = input*10 + (i+1) } }    # shared behavior over instances
+match Word1, Word2 onto Good, Bad {                       # declarative drag+drop pairing
+  correct Word1 -> Good, Word2 -> Bad
+  on done { send "win" }
+}
+at center | at center,540 | at 120,center                # canvas-relative anchor
+align top of "Bin" [offset dx,dy]                         # pin origin onto another item's bbox
+```
+
+## Expressions & stdlib
+
+Pure & numeric (no booleans: comparisons/logic yield `1`/`0`). Operators: `?: || && == != < > <= >=
++ - * / % - ! . [] fn()`.
+Built-ins: `sin cos tan asin acos atan atan2 abs sqrt pow exp log floor ceil round sign min max hypot
+clamp(x,lo,hi) lerp(a,b,t) mod(a,b) between(x,lo,hi) rad(deg) deg(rad) turns(n)`. Constants `PI TAU E`.
+Reserved: `time` (seconds, **wraps** every `durationFrames`), `clock` (seconds, **monotone**), `frame`,
+`value`, `mouse.x/y`, `keys.<Key>`, `self.*`, `<Name>.*`.
+Packages: `use "collision" | "easing" | "gesture" | "feedback"`; functions are available bare and
+qualified (`collision.boxHit(…)`). **The `use` line is optional** — calling a package function imports its
+package automatically (your own `fn` of the same name still wins). Timing: `lerp(v, target, k)` (builtin)
+eases toward a target each frame (`niv = lerp(niv, target, 0.1)`); `feedback.pulse(since, dur)` is a 1→0
+ramp over `dur` s for a readable timed feedback — capture the instant with **`clock`**:
+`var shown = -999` + `when wrong { shown = clock }`, `opacity = pulse(shown, 4)`.
+
+## CRITICAL GOTCHAS — do not get these wrong
+
+1. **`size W H` is required and MUST be the first line** of a `.flatink`. A `.flat` has no `size`.
+2. **Two grammars.** Drawing keywords live in `scene`/`symbol` layers; logic keywords live in
+   `object`/`every frame`/`fn`. Don't mix (no `var`/`when` inside `scene`; no `circle` inside `object`).
+3. **One action per line** in handlers. `x = 1  y = 2` is an error.
+4. **Angles split by context:** `pose rotate`/`scale` are **degrees & multipliers**. The
+   **`rotation` channel and `expr rotation`, plus `sin/cos/atan2`, are RADIANS.** Convert with
+   `rad(deg)`, `turns(n)` (1 turn/sec), `deg(rad)`.
+5. **Pivot or it orbits.** Rotation/scale happen around the container's `pivot` (local coords, default
+   `0,0`). Off-origin art with no pivot **orbits** instead of spinning in place.
+6. **A pose is a patch**, not a replace — it keeps every channel it doesn't mention. Don't re-state
+   `at x,y` just to change `opacity`.
+7. **A cel is a full snapshot.** A container is shown only on cels that `pose` it; omit it and it
+   **disappears** (that's how exits work). Keep a static element on its **own cel-less layer**, or use
+   `cel N hold { … }` to carry unchanged poses forward. It's per-**keyframe**, not per-frame.
+8. **A layer WITH cels draws ONLY the cel's `matter` + the containers that cel poses.** A bare shape
+   written straight into such a layer is **silently never drawn** — put it inside `cel N { matter { … } }`
+   (that IS frame-by-frame), or on a **cel-less layer** if it's static. Render order: the `matter` draws
+   **behind** the posed containers, declaration order is NOT preserved — to put a static shape in front of
+   the animation give it its **own layer above**. `flatc --check` warns on the silent drops.
+9. **`image` origin is top-left** → center with `at -w/2,-h/2`; and `as "Name"` comes **before** `at x,y`
+   (`image "id" w h as "F1" at -50,-50`) — the reverse order is a parse error.
+10. **Text doesn't wrap** unless you add `wrap` (only explicit `\n` breaks otherwise).
+11. **Rings/holes = ONE path with multiple closed subpaths** (fill is even-odd); a nested subpath cuts
+    a hole. `stroke`, `opacity`, and `filter` all exist on `path` and `text` — don't fake them.
+12. **`def`/`repeat`/`$()`/parameterized symbols are compile-time** (vanish from the model). For values
+    that change at runtime use `var`. A symbol param body sees only its params (not an outer `repeat`'s `i`).
+    A `def` is **not** a runtime variable: don't use it as a bare identifier in a behavior expression —
+    inject it with `$(name)` (`angle($(hubx), $(huby), mouse.x, mouse.y)`) or use a literal.
+13. **`$()` is for compile-time interpolation in scene coords**; runtime expressions use bare
+    identifiers and `[]` indexing. Arrays must exist before indexed write (`var hx = fill(n,0)`).
+14. **Drop test = object center** by default; use `when dropped on Zone at pointer` for the pointer, or
+    `group "Zone" … hitbox W H { … }` for an explicit rectangle. `when released` fires BEFORE the drop test.
+15. **`reveal`/`trace` progress is monotone** (never decreases). `link` works in WORLD coords.
+16. **Stroke width scales with the group** (drawn in scaled space) — don't compensate by hand.
+17. **All rotation is radians; author degrees with the `*Deg` twins.** The `rotation` channel,
+    `expr rotation`, `sin/cos/atan2`, `gesture.angle`, AND the **`turn`** interactor are **radians** — so
+    wire directly: `rotation = angle(self.x, self.y, mouse.x, mouse.y)`, or `turn a around cx,cy` then
+    `rotation = a`. To author in **degrees**, bind **`rotationDeg = <expr>`** (sugar for
+    `rotation = rad(<expr>)`) and use the **`turnDeg`** interactor (writes degrees). `snap` is always degrees.
+18. **Tweens move position straight but rotation in an ARC around the pivot.** Unwanted sideways drift
+    during a vertical move (a "sinking boat" sliding right) means either the two cels' `at x` differ, or
+    a `rotate` is arcing around an **off-center pivot**. Fix: keep the pivot at the visual center, match
+    `at x` across the cels, and descend with `at y` rather than a large tilt.
+19. **`object "X"` must name a group / instance / text / image — those alone carry a pose.** A shape *can*
+    take `as "N"` (it makes it addressable, e.g. `text … along "N"`) but it is baked material and can never
+    be animated; a LAYER can't either. Naming one is a **compile error** — to drive a shape, wrap it:
+    `group "N" { layer "art" { rect … } }`. Note that **opacities MULTIPLY**: putting `opacity 0` on the
+    shape to hide it at rest cancels the group's fade-in. `as "…"` and `at x,y` must come **right after the
+    geometry / content**, before style attributes (`font`/`box`/`fill`…): `text "…" at x,y box W H` works,
+    `text "…" box W H at x,y` fails. (`group`/`instance` take `at`/`as` normally.)
+20. **`x`/`y` REPLACE the group's `at` — they are not deltas.** `object "G" { x = bump }` overwrites the
+    local x of a group declared `at X,Y` (x snaps to `bump` ≈ 0 → it jumps to the edge). To move
+    **around** the anchor, bind the additive offsets instead: **`dx = bump`** (`pos = at + (dx, dy)`),
+    which needs no base and survives a re-layout. Re-injecting the base (`x = $(X) + bump`) is only for
+    when you genuinely want an absolute position. This is the most common "anim in the wrong place."
+21. **Parameterized symbols are `.flatink`-inline only.** `symbol "X"(args)` lives in the program, not in a
+    `.flat` lib (libs hold non-parameterized symbols, instanced without parens). Parens ⇔ parameterized.
+    A `(…)` symbol in a `.flat` (incl. one `flatc` auto-discovers in the folder) errors `"{" expected, "("`.
+22. **`{ enabled <expr> }` gates the GESTURE, not the handlers.** Once it is off the object stops being
+    draggable, but `when pressed` / `released` / `clicked` **still fire**. Guard the body yourself:
+    `when released { if done == 0 { … } }`. (A `link`'s target index is the exception — it resolves to 0.)
+23. **Timestamps use `clock`, never `time`.** `time` resets every `durationFrames` (2.5 s by default), so a
+    one-shot ramp captured on `time` REPLAYS for ever and a `shake` SKIPS on every loop. Set a long
+    `timeline` only if you need `time` itself; for instants, `clock` is the answer.
+24. **Check the program as `.flatink`.** The extension decides how a file is read: a `.flat` is a symbol
+    library, so a program saved under that name has nothing checked. `flatc` refuses it now. In a working
+    folder, `--no-libs` stops it pulling in the neighbouring `.flat` scratch files.
+
+## Self-check before returning
+- `.flatink` starts with `size`; keywords are in the correct half (scene vs behavior).
+- Every named target referenced by behavior (`object "X"`, drop zones, `align of`) exists in the scene
+  **and is a group / instance / text / image** — never a bare shape or a layer.
+- Every captured instant compared later uses `clock`, not `time`.
+- Every handler on an object whose gesture is `{ enabled … }`-gated guards its own body.
+- Pivots set for anything that rotates/scales in place; radians vs degrees correct per context.
+- Containers that persist are on cel-less layers or use `hold`; no accidental disappearance.

package/prompts/flatink-lite.md

@@ -0,0 +1,132 @@
+# FlatInk — lite reference (no tools)
+
+You write **FlatInk**, a text language for animations & interactive scenes. Output **only valid source**
+in one fenced block. You won't have a compiler — get it right in one pass. Keep DSL keywords in English.
+
+## Two file types
+- **`.flat`** = a symbol library: one or more `symbol "Name" { … }`. **No `size` line.** Not playable alone.
+- **`.flatink`** = a program: `size W H` (first line, required) → `scene { … }` → behavior. Playable.
+
+A `.flatink` has **two halves with different grammars**: `scene { … }` = composition (shapes/text/image/
+group/instance); everything after = behavior (`object`, `every frame`, `var`, `fn`). Never mix them.
+
+## `.flatink` skeleton
+```
+size 480 320                       # REQUIRED first line (canvas units; origin = top-left)
+background #0a0e1c                  # optional
+var score = 0                      # optional global runtime state
+scene {
+  layer "bg"   { rect 0 0 480 320 fill #0a0e1c }      # layers stack bottom → top
+  layer "game" { circle 240 160 40 fill #ffcc00 as "Sun" }   # `as` names an item for behavior
+}
+object "Sun" {                     # behavior attaches by name
+  when clicked { score = score + 1 }
+  rotation = time * 30             # channel binding, every frame (RADIANS)
+}
+every frame { if (score >= 10) { send "win" } }
+```
+
+## Drawing (in scene/symbol layers)
+```
+circle cx cy r   ·   ellipse cx cy rx ry   ·   rect x y w h [r | rx ry]   ·   path "M0 0 L10 0 L10 10 Z"
+text "Hi" font "sans-serif" size 24 align center line 1.2 color #fff box 200 40 [bold] [italic] [wrap]
+image "id" w h at -w/2,-h/2        # origin top-left → center yourself ; needs: asset "id" "f.png" image
+group "Name" at x,y pivot px,py { layer "c" { … } }      # nests its own layers
+instance "Symbol" as "Name" at x,y                        # place a symbol from a .flat
+```
+Style: `fill #rrggbb | nofill` · `stroke #rgb <w> [cap round][join round][dash a,b]` · `opacity 0..1` ·
+`fill linear(90, 0:#a, 1:#b)` (0=→,90=↓) · `fill radial(0.5,0.5,0.5, 0:#fff,1:#000)` ·
+`filter glow <blur> <color> | shadow <dx> <dy> <blur> <color> | blur <r>` · `tint <color> <amt>` · `nohit`.
+
+## Animation (in a symbol): timeline / cel / pose
+```
+symbol "Wheel" {
+  timeline 24 24                              # fps, durationFrames (loops [0,dur))
+  layer "spin" {
+    group "Rim" at 100,100 pivot 0,0 {        # roster: declared ONCE, posed by cels below
+      layer "art" { circle 0 0 40 nofill stroke #333 8 }
+    }
+    cel 0 tween { pose "Rim" rotate 0 }       # tween = interpolate to next cel; no tween = hold
+    cel 24       { pose "Rim" rotate 360 }    # DEGREES, around the pivot
+  }
+}
+pose "Name" [at x,y] [rotate deg] [scale s | scaleX sx scaleY sy] [opacity o] [spin cw|ccw] [turns n]
+```
+- `ease linear|easeIn|easeOut|easeInOut|cubic(a,b,c,d)` on a cel.
+- States: `states door { closed at 0  open at 24  initial closed  transition 12 ease easeInOut }`
+  → param drives the playhead (`door=0`→f0, `door=0.5`→f12). Driven by `Name.door = open`.
+- Expr channel on a container: `group "Fan" pivot 0,0 expr rotation "turns(time)" { … }` (RADIANS).
+
+## Behavior
+Events (in `object`): `when clicked | hovered | unhovered | pressed | released | dragged | held |
+dropped on <Zone> [at pointer]`. Scene-wide: `when loaded`, `every frame`, `at frame n`.
+Actions (one per line): `<var> = <expr>` · `arr[i] = <expr>` · `if/else if/else` · `repeat n times {}` ·
+`repeat i from a to b {}` · `play`/`pause` · `go to frame n [and play]` · `send "evt" [, <expr> | , text("id") | , { a = <expr>, b }]` · `sound "id"`.
+Drag/interactors (write into your vars; all take `{ enabled <expr> }`):
+```
+drag x, y [{ confine to <Zone> · snap <grid> }]    # then USE them: x = px  y = py
+turn <angle> around x,y    ·    trace <progress> along <Group>    ·    reveal <progress>
+link endX,endY,target to <Group>     # target = hit index 1..n (0=none), WORLD coords
+```
+Self-state & feedback: `self.hovered self.grabbed self.pressed` (0/1) ·
+`feedback lift tilt dim shake(<expr>)`.
+State/funcs: `var a = 0` · `var arr = fill(8,0)` · `fn dist(ax,ay,bx,by) = hypot(ax-bx,ay-by)` ·
+`fn reset() { score = 0 }`.
+
+## Factoring (compile-time, vanish from model — use `var` for runtime)
+`def gap = 70` · `repeat i from 0 to 4 { circle $(40 + i*gap) 80 6 fill #fff }` (`$()` = compile-time math)
+· `symbol "Card"(label, tint="#fff") { … text "$(label)" … fill $(tint) }` · `instance "Card"($(i+1)) as "C$(i)" at …`
+· `each "Key" as i { when clicked { … } }` · `at center` · `align top of "Bin" [offset dx,dy]`.
+
+## Expressions
+Pure numeric, no booleans (compare/logic → 1/0). Ops: `?: || && == != < > <= >= + - * / % - ! . [] fn()`.
+Funcs: `sin cos tan atan2 abs sqrt pow floor ceil round sign min max hypot clamp(x,lo,hi) lerp(a,b,t)
+mod(a,b) between(x,lo,hi) rad(deg) deg(rad) turns(n)`. Const `PI TAU E`.
+Reserved: `time`(s, **wraps**) `clock`(s, **monotone**) `frame` `value` `mouse.x/y` `keys.<Key>` `self.*` `<Name>.*`.
+Channels: `x y scaleX scaleY rotation opacity` (absolute) + `dx dy` (additive: `pos = at + (dx, dy)`).
+Stateful easing: `spring <ch> "<target>" stiffness <0..1> damping <0..1>` · `smooth <ch> "<target>" k <0..1>`
+(on a symbol container; scene-side: `spring rotation = aim { stiffness 0.08 damping 0.86 }` in an `object`).
+
+## CRITICAL GOTCHAS
+1. **`size W H` = first line of a `.flatink`** (none in `.flat`). Two grammars: drawing in `scene`, logic
+   after. Never put `var`/`when` in `scene` or `circle`/`path` in `object`.
+2. **One action per line.** A `send` carries ≤1 payload (`send "evt"` / `, <expr>` / `, text("id")` / `, { a = <expr>, b }` = named numbers).
+3. **Degrees vs radians:** `pose rotate`/`scale` = degrees & multipliers. The `rotation` channel,
+   `expr rotation`, `sin/cos/atan2`, `gesture.angle`, and the **`turn`** interactor = **RADIANS** → wire
+   directly (`rotation = angle(...)`, or `turn a around c` + `rotation = a`). To author in degrees: bind
+   **`rotationDeg`** (sugar for `rotation = rad(…)`) and use **`turnDeg`**. Helpers: `rad()`/`deg()`/`turns()`.
+4. **Set a `pivot` or it ORBITS** instead of spinning in place (pivot = local center of rotation/scale).
+   Same in a tween: position lerps straight, rotation ARCS around the pivot — a `rotate` on an off-center
+   pivot makes a sinking object drift sideways (match `at x` across cels; keep the pivot centered).
+5. **A pose is a PATCH** — keeps every channel it doesn't name. Don't restate `at x,y` to change opacity.
+6. **A cel is a full snapshot:** a container shows only on cels that `pose` it (omit → it disappears).
+   Per-**keyframe**, not per-frame. Keep statics on a **cel-less layer**, or carry forward with `cel N hold {…}`.
+7. **Render order in an animated layer:** static `path`s draw **behind** posed containers (declaration
+   order not preserved). To put a static shape in front, give it its **own layer above**.
+8. **`image` origin = top-left** (center with `at -w/2,-h/2`). **Text doesn't wrap** without `wrap`.
+9. **Rings/holes = ONE path, multiple closed subpaths** (even-odd fill). `stroke`/`opacity`/`filter`
+   exist on `path` AND `text` — don't fake them.
+10. **Drop test = object CENTER** by default (`at pointer` for the pointer; `hitbox W H` for an explicit
+    rect). `when released` fires BEFORE the drop test. `reveal`/`trace` progress is monotone.
+11. **Compile-time (`def`/`$()`/`repeat` in scene/param symbols) vs runtime (`var`)** — don't confuse. A
+    `def` isn't a runtime var: inject it in behavior expressions with `$(name)`, not as a bare identifier.
+    Use the vars an interactor writes (`drag px,py` only moves if you bind `x = px  y = py`); arrays must
+    exist before indexed writes.
+12. **`object "X"` must name a group/instance/text/image** — a shape or a layer carries no pose and is a
+    **compile error**; wrap the shape in a `group "Name"`. Opacities MULTIPLY (an `opacity 0` shape cancels
+    its group's fade-in). `as "…"`/`at x,y` go **right after the geometry/content**, before
+    `font`/`box`/`fill` (`text "…" at x,y box W H`, not `… box W H at x,y`).
+13. **`x`/`y` REPLACE a group's `at` (not deltas):** `object "G" { x = bump }` overwrites the x of a group
+    `at X,Y` → it jumps to the edge. To move **around** the anchor bind the additive offsets **`dx`/`dy`**
+    (`pos = at + (dx, dy)`): `dx = 30*sin(clock)` needs no base. Re-inject (`x = $(X) + bump`) only when you
+    really want an absolute position. Parameterized symbols
+    (`symbol "X"(args)`) are `.flatink`-inline only — never in a `.flat` lib (parens ⇔ parameterized).
+14. **`time` WRAPS every `durationFrames` (2.5 s by default); `clock` is monotone.** Capture instants with
+    `clock` (`when wrong { shown = clock }` + `opacity = pulse(shown, 4)`), or the ramp replays for ever.
+15. **`{ enabled <expr> }` gates the GESTURE only** — `when pressed`/`released`/`clicked` still fire. Guard
+    the body: `when released { if done == 0 { … } }`.
+
+## Before returning: check
+`size` first; right half for each keyword; one action/line; pivots set; radians vs degrees correct;
+every behavior target exists in the scene **and is a group/instance/text/image**; instants captured with
+`clock`; gated handlers guard their own body; persistent containers won't vanish; arrays pre-allocated.