lecodes-sdk 1.1.0 → 2.0.0

package/package.json

@@ -8,12 +8,20 @@
     "./compile/detectEntry": "./src/compile/detectEntry.ts",
     "./compile/shaderSchema": "./src/compile/shaderSchema.ts",
     "./compile/liteMaterial": "./src/compile/liteMaterial.ts",
+    "./color": "./src/core/color.ts",
     "./inject": "./src/inject.ts",
+    "./plugin": "./src/plugin.ts",
     "./server": "./src/server/host.ts",
     "./prompts/select": "./prompts/select.ts",
     "./global.d.ts": "./dist/global.d.ts",
     "./host.d.ts": "./dist/host.d.ts",
-    "./types.json": "./dist/types.json"
+    "./editor.d.ts": "./dist/editor.d.ts",
+    "./types.json": "./dist/types.json",
+    "./bridges/*": "./src/bridges/*.d.ts",
+    "./ui/tree": "./src/ui/tree.ts",
+    "./testing": "./tests/helpers/index.ts",
+    "./testing/preload": "./tests/helpers/preload.ts",
+    "./version": "./src/version.ts"
   },
   "scripts": {
     "build": "bun run build-types.ts",
@@ -25,7 +33,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@letary/chisel": "^0.10.0"
+    "@letary/chisel": "^0.13.0"
   },
   "devDependencies": {
     "@types/bun": "^1.3.14",
@@ -33,11 +41,12 @@
     "typescript": "~5.8.3",
     "gl-matrix": "^3.4.4"
   },
-  "version": "1.1.0",
+  "version": "2.0.0",
   "files": [
     "src",
     "dist",
     "prompts",
+    "tests/helpers",
     "README.md"
   ],
   "publishConfig": {

package/prompts/2d.md

@@ -5,7 +5,7 @@ Scene2D + nodes (Sprite, Tilemap) + aspects (SpriteAnimation, Shape2D/Physics2D/
 // ===== SCENE & NODES =====
 
 new Scene2D(options?: {
-  background?: Color   // clear color (hex string or 0xRRGGBB); settable later via scene.background
+  background?: Color   // clear color (any CSS color or 0xRRGGBB); settable later via scene.background
   filter?: 'nearest' | 'linear'  // texture sampling; default nearest (crisp pixel art), 'linear' for hi-res
 })   // art. filter is GLOBAL (one sampler for all textures), re-applied on open()
 
@@ -63,7 +63,7 @@ new Sprite(options?: {
                       // [0.5, 1] = bottom-center = "feet" — use on Y-sorted layers
   size?: Vec2Like   // world size; default = texture pixel dims (1 texel = 1 world unit)
   frame?: [u0, v0, u1, v1]   // normalized UV sub-rect
-  color?: Color   // tint MULTIPLIED with the texture; hex/packed only (default white = untinted)
+  color?: Color   // tint MULTIPLIED with the texture (default white = untinted)
   opacity?: number   // 0..1
   layer?: number
   position?: Vec2Like
@@ -259,10 +259,6 @@ sprite.aspect(Shape2D, { box: [12, 20] })   // ✅ declare the extents you want
 setLoop(() => sprite.setFramePx(...))   // WRONG
 sprite.aspect(SpriteAnimation, { size: [32, 48], clips: { walk: [0,1,2,3] } })   // ✅ then anim.play('walk')
 
-// ❌ CSS color strings on sprites — engine colors are hex/packed only (Canvas fillStyle is the exception)
-sprite.color = 'rgba(255,0,0,0.5)'   // WRONG
-sprite.color = '#ff0000'; sprite.opacity = 0.5   // ✅
-
 // ❌ attaching SpriteAnimation before the sprite has a texture — throws (the grid slices from it)
 // ❌ attaching Physics2D before Shape2D on the same node — throws (attach the shape first)
 // ❌ setting spawn position AFTER attaching Physics2D — the body already seeded from [0,0]; position first

package/prompts/3d.md

@@ -86,7 +86,7 @@ material.map = tex                         // Texture | Canvas | null
 
 // Custom compiled shaders (.mat files) — load, then set uniforms by name (chainable):
 const mat = new Material(await fetch(asset('./hologram.mat'), { useOnce: true }))
-    .set('baseColor', '#ffa200')           // '#rrggbb' / '#rrggbbaa' hex STRINGS only
+    .set('baseColor', '#ffa200')           // color STRINGS only (any CSS color); a number is a float
     .set('roughness', 0.54)                // number → float, boolean → bool
     .set('glowMap', tex)                   // Texture → sampler
     .set('dir', [0, 1, 0])                 // number[] / Float32Array → vector. NOT a Vec3 — spread it: [...v]
@@ -294,10 +294,6 @@ mat.set('lightDir', dir)
 Light.point(...)
 // ✅ Light.sun() + scene IBL is the whole lighting model; fake glows with unlit/bloom/particles
 
-// ❌ rgba()/named colors in 3D APIs — silently black
-Material.lit({ color: 'rgba(255, 0, 0, 0.5)' })
-// ✅ hex string or packed int: '#ff0000' / '#ff000080' / 0xff0000
-
 // ❌ a fresh Material per frame (or per particle) to animate a look
 setLoop(() => { mesh.material = Material.lit({ color: next() }) })
 // ✅ mutate the one material: mesh.material.color = next()  /  mat.set('progress', t)

package/prompts/README.md

@@ -1,142 +1,142 @@
-# Codegen prompts
-
-> **Scope: the le.codes PLATFORM assistant only.** These prompts are bundled into `dist/` and served
-> by claude-proxy to the in-editor chat. They are NOT used by local development — Claude Code and
-> `lecodes-cli` never read them; those get the SDK surface from `.lecodes/types` (the d.ts bundle),
-> the generated project `CLAUDE.md` (`lecodes-cli/src/commands/init/templates.ts`) and `sdk/docs`.
-> A change meant for local development belongs there, not here.
-
-The system prompt(s) sent to Claude for LeCodes code generation, split into composable modules so
-a request only pays for the API areas it can actually use. Facts come from `../docs/` (the source
-of truth) — when the SDK changes, update docs first, then mirror the change here.
-
-**Consumers:**
-- `claude-proxy/prompts/*.md` — deployed copies of `dist/` + `router.md` (see its README); the
-  proxy injects them per the `x-lecodes-bundle` header (`claude-proxy/src/proxy/bundles.ts`). An
-  unknown/missing header is a **400** (no silent fallback), and the proxy's `/health` exposes a
-  sha256-12 per bundle — `bun run check:prompts` (repo root) compares them against `dist/` to
-  catch deploy drift (`--dir <proxy>/prompts` checks a local checkout instead).
-- `packages/frontend/.../chat/engine/bundleSelect.ts` — a thin adapter over `select.ts` (imported
-  as `sdk/prompts/select`); the selection logic itself is not duplicated anywhere.
-
-## Layout
-
-```
-core.md            shared foundation: response format, entry-point rule, runtime, math, tweens
-index.md           one-line map of EVERY global — always included (anti-hallucination anchor)
-canvas.md          Canvas drawing surface — engine-independent, in every bundle (each engine
-                   module documents its own hookup: Sprite texture / UIImage src / Texture)
-ui.md              UI module (screens, router, styling, widgets, lists)
-2d.md              2D engine module (sprites, tilemaps, Box2D physics, aspects, Canvas)
-3d.md              SHARED 3D content (nodes, meshes, models, materials, physics, particles)
-3d-scene.md        non-AR scenes: Scene construction, camera control, CharacterController, example
-3d-scene-files.md  declarative .scene.ts files (defineScene/use/ref/make, SceneHandle, HUD-over-scene)
-                   — the visual scene editor's format; non-AR only (camera nodes, skybox env)
-ar.md              AR scenes: ARScene, anchors, placement controls, example — never with 3d-scene.md
-core-design.md     design mode's core: directives/context/reports, no runtime APIs (no timers/network)
-ui-design.md       design mode's UI: curated static-mockup subset of ui.md (KEEP IN SYNC with it)
-design.md          design mode: canvas conventions — kit-first, states, design_map tool, tab bar
-concept.md         concept mode: product-shaping conversation, writes ONLY design/spec.md
-compose.ts         builds dist/<bundle>.md from the modules
-select.ts          deterministic bundle detection from project code
-router-prompt.md   fallback classifier prompt (empty projects only)
-namer-prompt.md    project name + icon-emoji generator (first request of a new project)
-intake-prompt.md   new-project intake: clarifying questions + confirmable brief (two Haiku turns)
-```
-
-## Bundles (`bun run prompts/compose.ts` → `dist/`)
-
-| Bundle | Modules | For |
-|---|---|---|
-| `ui-app` | core + index + canvas + ui | apps: screens, forms, lists, chat, commerce |
-| `2d-game` | core + index + canvas + 2d + ui | flat games, drawing toys |
-| `3d-app` | core + index + canvas + 3d + 3d-scene + 3d-scene-files + ui | 3D games/viewers, scene-editor projects |
-| `ar-app` | core + index + canvas + 3d + ar + ui | AR experiences |
-| `design` | core-design + ui-design + design | design mode: the design/ prototyping canvas |
-| `concept` | concept | concept mode: shape the idea, maintain design/spec.md (~0.8k tokens) |
-
-Fixed bundles (not per-request assembly) are deliberate: **each bundle is a stable prompt prefix**,
-so Anthropic prompt caching hits on every generation after the first (~10× cheaper input, lower
-latency). Per-request cherry-picking would produce near-unique prefixes and always pay full price.
-Game bundles include the full UI module because games need HUDs/menus; the ui-app bundle omits the
-engines entirely.
-
-## Selecting the bundle
-
-`design` and `concept` are different from the engine bundles: they are selected EXPLICITLY by the
-client from the editor's mode switcher (Concept / Design / Build — `x-lecodes-bundle: design` or
-`concept`) — never routed, detected from code, or reachable via the `<bundle>` escalation. The
-engine ladder below applies to Build mode only. Concept turns also carry no code context (design
-excerpts + file names only) and the client enforces each mode's write boundary (concept:
-design/spec.md only; design: design/ only). Any bundle may end a reply with `<mode>x</mode>` — the
-client strips it and renders a "Switch to …" button; the mode never switches itself.
-
-For the engine bundles — three signals, in this order:
-
-**1. Project code — `select.ts` (primary, deterministic).**
-`detectBundle(files)` scans the project's `.ts` sources for engine globals (comments and string
-literals stripped) and returns the bundle. This is language-independent — it doesn't matter what
-language the user writes in, because it never reads the user's words at all. It covers every
-request against an existing project, i.e. the vast majority of traffic. Priority: AR > 3D > 2D;
-sources with no engine references → `ui-app`. This mirrors the engine-kind detection the compiler
-already does for project icons — if that detection is exposed server-side, reuse it instead.
-
-**0. Intake — `intake-prompt.md` (new projects, preferred over the router).**
-The session's first request against a project with no app code runs the intake instead of building:
-one Haiku call returns 2–4 clarifying questions with tappable options (including the app kind when
-the request is ambiguous between kinds), a second call turns the answers into a short brief the
-user confirms. The confirmed kind sets the first build turn's bundle explicitly (`x-lecodes-bundle`
-sent by the client — the router below never runs), and the brief seeds `design/spec.md` as the
-project concept. Intake failure or the user's Skip degrades to the flow below — it never blocks.
-Client side: `frontend/.../chat/engine/intake.ts` + the intake card in `chatController.ts`.
-
-**2. Router model — `router-prompt.md` (fallback: intake skipped/failed on empty projects).**
-When `detectBundle` returns `null` (no code yet), classify the user's first message with one cheap
-call: `claude-haiku-4-5`, temperature 0, `max_tokens: 8`, reply is a single word `ui|2d|3d|ar`.
-The prompt is meaning-based and multilingual (EN/RU examples included). Parse defensively; any
-garbage → `ui`. Cost/latency: ~1k input tokens, a few output tokens, ~200–400 ms — negligible, and
-it runs at most once per project's life.
-
-**Stickiness.** Cache the chosen bundle per conversation and only move UP
-(`upgradeBundle(current, detected)`: ui → 2d/3d → ar), re-running `detectBundle` over files the
-assistant itself just generated. Never downgrade mid-conversation — it would invalidate the prompt
-cache and confuse in-flight context. Wrong-but-bigger is harmless; wrong-but-smaller causes
-hallucinated APIs.
-
-**3. Escalation — the `<bundle>` directive (recovery from a misroute).**
-Code-based detection can never recover from a wrong-but-smaller bundle on its own: a model that
-wasn't shown an engine never emits its globals, so the upgrade never triggers. core.md ("Missing
-engine") therefore instructs the generator to reply with ONLY `<bundle>ar</bundle>` (or `3d`/`2d`)
-when the request needs engine APIs its prompt doesn't document. The client (`parseBundleDirective`
-in `select.ts`) discards that reply, upgrades the pinned bundle, and re-sends the same request
-once — upgrade-only here too; a non-upgradable directive (e.g. a 3D project asking for the 2D
-engine) surfaces as a plain explanation instead. Relatedly, the router's classifier input must be
-ONLY the user's words: the proxy cuts everything before the frontend's `[Request]` marker, so e.g.
-a `.glb` in the project snapshot can't drag an explicit AR request toward `3d`.
-
-## Naming new projects
-
-`namer-prompt.md` is unrelated to bundle selection but lives here with the other model prompts:
-an assistant request made while the project has NO CODE yet (no non-empty `.ts` file — uploaded
-assets like a `.glb` model don't count as "started") also fires one extra Haiku call in parallel
-(`x-lecodes-bundle: namer`, `chat/engine/projectNamer.ts`) that returns bare JSON `{name, emoji}`;
-the result is saved via the normal project-update API (name + `iconEmoji`, drawn by
-`VProjectIcon`). Uncached — the prompt is far below Haiku's minimum cacheable prefix. Parsing is
-defensive: a garbled reply must never rename the project, so it's rejected rather than truncated
-into place; a rename while the call is in flight also wins over the generated name.
-
-**Why not route every request with a model?** It adds a failure mode (misroute → the generator
-confidently invents APIs it wasn't shown), latency, and cost on 100% of traffic to solve a problem
-that exists only for the ~one request per project where no code exists. Residual misroutes are
-recoverable: the index.md map means the generator always knows what exists, and the `<bundle>`
-escalation directive (above) lets it swap in the right engine module instead of guessing.
-
-## Keeping prompts honest
-
-- `index.md` must list every global exported from `sdk/src/inject.ts` — same contract as
-  `docs/check.mjs`. When a global is added, update docs, then the module, then index.md.
-- Known corrections baked into these prompts (do not regress; see `docs/AUTHORING.md`):
-  `onEndReached(thresholdPx, cb)` (threshold first), `bgSize: cover|contain|tile` (no `fill`),
-  track `deltaX/deltaY` are per-move, engine colors are hex/packed-int only, `animate` can't
-  tween strings/colors, `node.physics` (not `.body`), no `Camera2D.follow`, no
-  `UIScrollable.scrollTo`, models can't be cloned.
+# Codegen prompts
+
+> **Scope: the le.codes PLATFORM assistant only.** These prompts are bundled into `dist/` and served
+> by claude-proxy to the in-editor chat. They are NOT used by local development — Claude Code and
+> `lecodes-cli` never read them; those get the SDK surface from `.lecodes/types` (the d.ts bundle),
+> the generated project `CLAUDE.md` (`lecodes-cli/src/commands/init/templates.ts`) and `sdk/docs`.
+> A change meant for local development belongs there, not here.
+
+The system prompt(s) sent to Claude for LeCodes code generation, split into composable modules so
+a request only pays for the API areas it can actually use. Facts come from `../docs/` (the source
+of truth) — when the SDK changes, update docs first, then mirror the change here.
+
+**Consumers:**
+- `claude-proxy/prompts/*.md` — deployed copies of `dist/` + `router.md` (see its README); the
+  proxy injects them per the `x-lecodes-bundle` header (`claude-proxy/src/proxy/bundles.ts`). An
+  unknown/missing header is a **400** (no silent fallback), and the proxy's `/health` exposes a
+  sha256-12 per bundle — `bun run check:prompts` (repo root) compares them against `dist/` to
+  catch deploy drift (`--dir <proxy>/prompts` checks a local checkout instead).
+- `packages/frontend/.../chat/engine/bundleSelect.ts` — a thin adapter over `select.ts` (imported
+  as `sdk/prompts/select`); the selection logic itself is not duplicated anywhere.
+
+## Layout
+
+```
+core.md            shared foundation: response format, entry-point rule, runtime, math, tweens
+index.md           one-line map of EVERY global — always included (anti-hallucination anchor)
+canvas.md          Canvas drawing surface — engine-independent, in every bundle (each engine
+                   module documents its own hookup: Sprite texture / UIImage src / Texture)
+ui.md              UI module (screens, router, styling, widgets, lists)
+2d.md              2D engine module (sprites, tilemaps, Box2D physics, aspects, Canvas)
+3d.md              SHARED 3D content (nodes, meshes, models, materials, physics, particles)
+3d-scene.md        non-AR scenes: Scene construction, camera control, CharacterController, example
+3d-scene-files.md  declarative .scene.ts files (defineScene/use/ref/make, SceneHandle, HUD-over-scene)
+                   — the visual scene editor's format; non-AR only (camera nodes, skybox env)
+ar.md              AR scenes: ARScene, anchors, placement controls, example — never with 3d-scene.md
+core-design.md     design mode's core: directives/context/reports, no runtime APIs (no timers/network)
+ui-design.md       design mode's UI: curated static-mockup subset of ui.md (KEEP IN SYNC with it)
+design.md          design mode: canvas conventions — kit-first, states, design_map tool, tab bar
+concept.md         concept mode: product-shaping conversation, writes ONLY design/spec.md
+compose.ts         builds dist/<bundle>.md from the modules
+select.ts          deterministic bundle detection from project code
+router-prompt.md   fallback classifier prompt (empty projects only)
+namer-prompt.md    project name + icon-emoji generator (first request of a new project)
+intake-prompt.md   new-project intake: clarifying questions + confirmable brief (two Haiku turns)
+```
+
+## Bundles (`bun run prompts/compose.ts` → `dist/`)
+
+| Bundle | Modules | For |
+|---|---|---|
+| `ui-app` | core + index + canvas + ui | apps: screens, forms, lists, chat, commerce |
+| `2d-game` | core + index + canvas + 2d + ui | flat games, drawing toys |
+| `3d-app` | core + index + canvas + 3d + 3d-scene + 3d-scene-files + ui | 3D games/viewers, scene-editor projects |
+| `ar-app` | core + index + canvas + 3d + ar + ui | AR experiences |
+| `design` | core-design + ui-design + design | design mode: the design/ prototyping canvas |
+| `concept` | concept | concept mode: shape the idea, maintain design/spec.md (~0.8k tokens) |
+
+Fixed bundles (not per-request assembly) are deliberate: **each bundle is a stable prompt prefix**,
+so Anthropic prompt caching hits on every generation after the first (~10× cheaper input, lower
+latency). Per-request cherry-picking would produce near-unique prefixes and always pay full price.
+Game bundles include the full UI module because games need HUDs/menus; the ui-app bundle omits the
+engines entirely.
+
+## Selecting the bundle
+
+`design` and `concept` are different from the engine bundles: they are selected EXPLICITLY by the
+client from the editor's mode switcher (Concept / Design / Build — `x-lecodes-bundle: design` or
+`concept`) — never routed, detected from code, or reachable via the `<bundle>` escalation. The
+engine ladder below applies to Build mode only. Concept turns also carry no code context (design
+excerpts + file names only) and the client enforces each mode's write boundary (concept:
+design/spec.md only; design: design/ only). Any bundle may end a reply with `<mode>x</mode>` — the
+client strips it and renders a "Switch to …" button; the mode never switches itself.
+
+For the engine bundles — three signals, in this order:
+
+**1. Project code — `select.ts` (primary, deterministic).**
+`detectBundle(files)` scans the project's `.ts` sources for engine globals (comments and string
+literals stripped) and returns the bundle. This is language-independent — it doesn't matter what
+language the user writes in, because it never reads the user's words at all. It covers every
+request against an existing project, i.e. the vast majority of traffic. Priority: AR > 3D > 2D;
+sources with no engine references → `ui-app`. This mirrors the engine-kind detection the compiler
+already does for project icons — if that detection is exposed server-side, reuse it instead.
+
+**0. Intake — `intake-prompt.md` (new projects, preferred over the router).**
+The session's first request against a project with no app code runs the intake instead of building:
+one Haiku call returns 2–4 clarifying questions with tappable options (including the app kind when
+the request is ambiguous between kinds), a second call turns the answers into a short brief the
+user confirms. The confirmed kind sets the first build turn's bundle explicitly (`x-lecodes-bundle`
+sent by the client — the router below never runs), and the brief seeds `design/spec.md` as the
+project concept. Intake failure or the user's Skip degrades to the flow below — it never blocks.
+Client side: `frontend/.../chat/engine/intake.ts` + the intake card in `chatController.ts`.
+
+**2. Router model — `router-prompt.md` (fallback: intake skipped/failed on empty projects).**
+When `detectBundle` returns `null` (no code yet), classify the user's first message with one cheap
+call: `claude-haiku-4-5`, temperature 0, `max_tokens: 8`, reply is a single word `ui|2d|3d|ar`.
+The prompt is meaning-based and multilingual (EN/RU examples included). Parse defensively; any
+garbage → `ui`. Cost/latency: ~1k input tokens, a few output tokens, ~200–400 ms — negligible, and
+it runs at most once per project's life.
+
+**Stickiness.** Cache the chosen bundle per conversation and only move UP
+(`upgradeBundle(current, detected)`: ui → 2d/3d → ar), re-running `detectBundle` over files the
+assistant itself just generated. Never downgrade mid-conversation — it would invalidate the prompt
+cache and confuse in-flight context. Wrong-but-bigger is harmless; wrong-but-smaller causes
+hallucinated APIs.
+
+**3. Escalation — the `<bundle>` directive (recovery from a misroute).**
+Code-based detection can never recover from a wrong-but-smaller bundle on its own: a model that
+wasn't shown an engine never emits its globals, so the upgrade never triggers. core.md ("Missing
+engine") therefore instructs the generator to reply with ONLY `<bundle>ar</bundle>` (or `3d`/`2d`)
+when the request needs engine APIs its prompt doesn't document. The client (`parseBundleDirective`
+in `select.ts`) discards that reply, upgrades the pinned bundle, and re-sends the same request
+once — upgrade-only here too; a non-upgradable directive (e.g. a 3D project asking for the 2D
+engine) surfaces as a plain explanation instead. Relatedly, the router's classifier input must be
+ONLY the user's words: the proxy cuts everything before the frontend's `[Request]` marker, so e.g.
+a `.glb` in the project snapshot can't drag an explicit AR request toward `3d`.
+
+## Naming new projects
+
+`namer-prompt.md` is unrelated to bundle selection but lives here with the other model prompts:
+an assistant request made while the project has NO CODE yet (no non-empty `.ts` file — uploaded
+assets like a `.glb` model don't count as "started") also fires one extra Haiku call in parallel
+(`x-lecodes-bundle: namer`, `chat/engine/projectNamer.ts`) that returns bare JSON `{name, emoji}`;
+the result is saved via the normal project-update API (name + `iconEmoji`, drawn by
+`VProjectIcon`). Uncached — the prompt is far below Haiku's minimum cacheable prefix. Parsing is
+defensive: a garbled reply must never rename the project, so it's rejected rather than truncated
+into place; a rename while the call is in flight also wins over the generated name.
+
+**Why not route every request with a model?** It adds a failure mode (misroute → the generator
+confidently invents APIs it wasn't shown), latency, and cost on 100% of traffic to solve a problem
+that exists only for the ~one request per project where no code exists. Residual misroutes are
+recoverable: the index.md map means the generator always knows what exists, and the `<bundle>`
+escalation directive (above) lets it swap in the right engine module instead of guessing.
+
+## Keeping prompts honest
+
+- `index.md` must list every global exported from `sdk/src/inject.ts` — same contract as
+  `docs/check.mjs`. When a global is added, update docs, then the module, then index.md.
+- Known corrections baked into these prompts (do not regress; see `docs/AUTHORING.md`):
+  `onEndReached(thresholdPx, cb)` (threshold first), `bgSize: cover|contain|tile` (no `fill`),
+  track `deltaX/deltaY` are per-move, colors are CSS strings / 0xRRGGBB / [r,g,b(,a)] everywhere, `animate` can't
+  tween strings/colors, `node.physics` (not `.body`), no `Camera2D.follow`, no
+  `UIScrollable.scrollTo`, models can't be cloned.

package/prompts/canvas.md

@@ -8,20 +8,21 @@ const c = new Canvas(width, height, { pixelRatio: device.pixelRatio })
 // width/height are LOGICAL units — author all drawing logical; pixelRatio only multiplies baked
 // resolution (crispness), never the on-screen size.
 
-c.fillStyle = '#ff8800'   // CSS color STRINGS work here (the exception to engine hex-only colors);
-c.lineCap = 'round'       // also strokeStyle, lineWidth, lineJoin, globalAlpha,
+c.fillStyle = '#ff8800'   // any CSS color string, as everywhere in the SDK;
+c.lineCap = 'round'       // also strokeStyle, lineWidth, lineJoin, miterLimit, globalAlpha, letterSpacing,
+c.setLineDash([4, 2])     // dashes; a gradient: c.fillStyle = c.createLinearGradient(x0,y0,x1,y1).addColorStop(0,'#fff').addColorStop(1,'transparent')
 c.font = 'bold 16px sans-serif'   // textAlign ('left'|'center'|'right'), textBaseline
                                   // custom fonts: draw only AFTER await registerFont(...)
 c.fillRect(x, y, w, h) / c.strokeRect / c.clearRect
-c.beginPath().moveTo(x,y).lineTo(x,y).arc(x,y,r,a0,a1).rect(x,y,w,h).roundRect(x,y,w,h,r).closePath()  // all chain
-c.fill() / c.stroke() / c.fillText(text, x, y) / c.strokeText(text, x, y)
-c.measureText(text): { width, ascent, descent }   // in the CURRENT font, logical px
-c.drawImage(bmp: Bitmap, dx, dy [, dw, dh])   // blits a Bitmap only (from c.toBitmap()), nothing else
+c.beginPath().moveTo(x,y).lineTo(x,y).arc(x,y,r,a0,a1).arcTo(x1,y1,x2,y2,r).ellipse(x,y,rx,ry,rot,a0,a1).rect(x,y,w,h).roundRect(x,y,w,h,r).closePath()  // all chain
+c.fill('evenodd'?) / c.stroke() / c.clip() / c.fillText(text, x, y) / c.strokeText(text, x, y)
+c.measureText(text): { width, ascent, descent }   // in the CURRENT font and letterSpacing, logical px
+c.drawImage(bmp: Bitmap, dx, dy [, dw, dh])   // blits a Bitmap only (c.toBitmap(), await c.loadImage(SvgSource(svg) | fetchResponse))
 
 c.update(): this    // after redrawing, push new pixels to EVERY texture/image this canvas produced
 c.reset(): this     // discard the recorded drawing to start over
 c.resize(w, h): this   // new logical size (takes effect next bake; measure-then-resize works pre-bake)
 c.toBitmap(): Bitmap   // rasterized snapshot, usable with drawImage
-// GOTCHA: reset() clears the recorded STATE too — font/fillStyle/textAlign fall back to defaults on
-// the next bake (getters still report old values). Re-set font & friends after every reset().
+// GOTCHA: reset() clears the recorded STATE too — font/fillStyle/textAlign fall back to defaults
+// (the getters report the defaults again). Re-set font & friends after every reset().
 // Ever-growing drawings: flatten — const snap = c.toBitmap(); c.reset(); c.drawImage(snap, 0, 0)

package/prompts/compose.ts

@@ -1,4 +1,4 @@
-// Compose the prompt bundles from the modules. Run from packages/sdk:
+// Compose the prompt bundles from the modules. Run from sdk:
 //   bun run prompts/compose.ts
 // Writes prompts/dist/<bundle>.md and prints token-ish size stats.
 

package/prompts/core.md

@@ -202,9 +202,9 @@ Mathf.clamp(v, min, max) / .lerp(a, b, t) / .remap(v, inMin, inMax, outMin, outM
 Mathf.damp(a, b, lambda, dt) / .moveTowards(a, b, maxDelta)
 Mathf.random(min, max) / .randomInt(min, max)   // randomInt inclusive both ends
 
-// Colors: hex string "#e33" | "#ff3333" | "#ff3333cc" or packed int 0xff3333.
-// rgba(...) / named colors DON'T work in 2D/3D APIs (silently become black). UI styles are the
-// exception — they also accept rgb()/rgba() and basic names ("white", "black", "transparent", …).
+// Colors (every API, UI and engine alike): any CSS color string ("#e33", "#ff3333cc", "rgb(255 0 0 / 50%)",
+// "hsl(0 100% 50%)", "red" — the CSS names, green = #008000), packed int 0xff3333 (opaque 0xRRGGBB),
+// or [r, g, b(, a)] 0..1. A non-color throws. var(--x) only in UI styles.
 
 // ===== NETWORK =====
 

package/prompts/design.md

@@ -50,7 +50,7 @@ import { colors, spacing, radius } from "./tokens"
 export const PrimaryButton = (label: string, o: { name?: string, disabled?: boolean } = {}) =>
   UIButton(UIText(label).style({ fontSize: 16, fontWeight: 700, color: o.disabled ? colors.muted : colors.onAccent }))
     .style({ height: 52, borderRadius: radius.md, bgColor: o.disabled ? colors.accentDeep : colors.accent,
-             justifyContent: "center", alignItems: "center", name: o.name, onPressed: { bgColor: colors.accentPressed } })
+             justifyContent: "center", alignItems: "center", name: o.name, $pressed: { bgColor: colors.accentPressed } })
 
 export const SectionLabel = (t: string) =>
   UIText(t.toUpperCase()).style({ fontSize: 11, fontWeight: 600, letterSpacing: 2, color: colors.faint })