@cimplify/cli 0.15.3 → 0.16.0

package/dist/chunk-EAV2P4N3.mjs

@@ -0,0 +1,1941 @@
+#!/usr/bin/env node
+import { materialize, titleFromName } from './chunk-CNZAOVSK.mjs';
+import { MANIFEST_FILE, LOCKFILE, serializeLockfile, currentLockfile } from './chunk-T4MW3PD4.mjs';
+import { quoteTomlString } from './chunk-KQNZKV6E.mjs';
+import { PINNED_SDK_VERSION } from './chunk-AKACUJ3W.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-XQAHREKO.mjs';
+import { CliError, CLI_ERROR_CODE, success, warn, info, dim, result } from './chunk-KOD4GBQ5.mjs';
+import { spawnSync } from 'child_process';
+import { promises } from 'fs';
+import path from 'path';
+import { frontier, chemistry, genesis, tycoon, runner, shootout, economyToml, economyManifest, defineEconomy } from '@cimplify/sdk/game/kit';
+
+// src/interactives/templates/agents.ts
+var AGENTS_FILE = "AGENTS.md";
+var LOOP = `## The loop
+
+Work in small steps and check each one:
+
+1. Edit \`src/\`. The client entry is \`src/client.ts\` (\`export default async function main(ctx: Ctx)\`).
+2. \`cimplify build --json\` compiles the project the way publish admission does. Fix every diagnostic: each has \`file\`, \`line\`, \`column\`, \`code\` and \`message\`. Codes starting with \`styles.\` come from the style compiler and carry a did-you-mean.
+3. \`cimplify test\` runs \`tests/\` (vitest) and then the publication gates: build, analysis, types, size, and for games frame time, heap growth, cold start, GC pauses and the game UI checks (text overflow, tap targets, contrast, safe area, text size). A failed gate means publish would be refused. \`cimplify test --visual\` also compares the captures of every \`test/visual\` script with its goldens (\`--update\` rewrites them).
+4. \`cimplify capture [--device phone-landscape] [--frame 120] [--script steps.json]\` renders the game headless with a fixed clock and seed and writes a PNG to \`.cimplify/captures\`; look at it after visual changes.
+5. \`cimplify inspect\` prints the game UI tree, one line per node (rect, text, resolved style, source line), followed by the check findings and a proposed fix for each.
+6. \`cimplify dev\` opens the local simulator for a human to play.
+
+Every command takes \`--json\` and prints one \`{ "ok": true, "data": ... }\` or \`{ "ok": false, "error": ... }\` line.
+
+MCP: \`cimplify mcp\` serves the same loop as tools (\`build\`, \`test\`, \`capture\`, \`inspect\`, \`docs_search\`, \`api_lookup\`, \`create_project\`). Register it once with \`claude mcp add cimplify -- cimplify mcp\` (Claude Code) or as a stdio server named \`cimplify\` running \`cimplify mcp\` in other agents.
+
+Look things up instead of guessing: \`api_lookup\` gives the exact signature, parameters and a runnable example for any SDK symbol, style property, class or condition. The docs index for agents is \`https://cimplify.dev/interactives/llms.txt\` (full text at \`/interactives/llms-full.txt\`, machine-readable API at \`/interactives/api-index.json\`).
+`;
+var UI_CHECKS = `## Input scripts and UI checks
+
+\`--script\` plays an input script before \`capture\` or \`inspect\`, and every script in \`test/visual/\` becomes a visual test. Scripts are JSON (or TS with a default export):
+
+\`\`\`json
+{
+  "devices": ["phone-portrait", "tablet"],
+  "seed": 7,
+  "steps": [
+    { "wait": 30 },
+    { "tap": { "text": "Play" } },
+    { "drag": { "from": [40, 700], "to": [340, 700], "frames": 20 } },
+    { "key": "Space", "hold": 10 },
+    { "capture": "playing" }
+  ]
+}
+\`\`\`
+
+Steps: \`wait\` (frames), \`wait_ms\`, \`tap\` and \`drag\` (targets are \`[x, y]\` points, \`{ "node": id }\`, \`{ "name": "pauseButton" }\` for the variable the element is bound to, or \`{ "text": "Play" }\`; \`hold\` defaults to 1 frame), \`key\`, \`type\` and \`capture\` (names a screenshot). Goldens live in \`test/visual/goldens/<script>-<capture>-<device>.png\`. \`cimplify dev --record test/visual/run.json\` writes a script from a play session (frame-exact, replayed by \`capture --script\`); captures fix the clock (\`new Date()\` too) and the seed and refuse \`new Worker(...)\`.
+
+Readiness: \`capture\` reports \`readiness\` (\`first_frame\`, \`first_frame_ms\`, \`bytes_before_first_play\`, \`bytes_total\`, \`frames\`, \`stall_frames\`, \`stalls\`; a stall is a frame where a needed streamed chunk was not resident). \`cimplify test\` adds a readiness gate when \`test/readiness.json\` (an input script along a recorded path) exists; set \`"max_stalls": 0\` in it to fail on stalls. Builds warn (\`stream.stalls\`) when splat scenery is predicted to stall at mid or low tier bandwidth along \`test/camera.json\` (\`[{ "t": seconds, "at": [x, y, z] }]\`) or a default walk.
+
+Text from \`ctx.generate\` can carry a small themeable AI mark: \`generatedText(ui).show(await ctx.generate.text({ prompt, fallback }))\`, or \`rich.set(markup, result.source)\` on a \`richText\`; fallback text never shows it (\`aiMarkTheme({ fill, text })\` restyles it).
+
+The \`game UI\` gate checks \`text_overflow\`, \`tap_target\` (44 points), \`contrast\` (4.5:1, 3:1 for large text), \`safe_area\` and \`text_size\` (11 points). Fix the finding; when a node is deliberately exempt, say why with a typed reason from \`@cimplify/sdk/interactives\`:
+
+\`\`\`ts
+exemptUi(ui.text("v1.0.3", "text-[9px] text-muted"), "text_size", "legal_fine_print");
+\`\`\`
+
+Reasons per check: \`text_overflow\`: \`intentional_clip\`, \`marquee\`, \`decorative\`. \`tap_target\`: \`expanded_hit_area\`, \`dense_grid\`, \`secondary_control\`, \`decorative\`. \`contrast\`: \`decorative\`, \`disabled\`, \`logo\`, \`inside_image\`. \`safe_area\`: \`full_bleed_background\`, \`dismissible_overlay\`, \`decorative\`. \`text_size\`: \`badge_counter\`, \`legal_fine_print\`, \`decorative\`. Any other reason is a type error.
+`;
+var PROJECT = `## Project rules
+
+- \`interactive.toml\` is the manifest. Every ctx scope you call needs a \`[capabilities]\` entry with the reason shown to the player. Every external destination needs a \`[[providers]]\` entry.
+- \`cimplify.lock\` pins the SDK and libraries. Never edit it by hand; \`cimplify build\` updates it.
+- Import only \`@cimplify/sdk/interactives\`, \`@cimplify/sdk/game\`, \`@cimplify/sdk/game/kit\`, \`@cimplify/sdk/game/kit/canvas\` (and the kit template entries) plus relative files. Node built-ins, URLs and other npm packages are refused.
+- No \`fetch\`, \`XMLHttpRequest\`, \`WebSocket\`, \`eval\`, \`new Function\`, string timers, dynamic \`import()\` or \`require\`. Network goes through \`ctx\` and declared providers.
+- TypeScript runs in strict mode and every type error blocks the build.
+`;
+var GENERATIVE = `## Scenes and remixes
+
+- \`scene(name, spec)\` from \`@cimplify/sdk/game\` declares a layout as objects and relations; \`cimplify build\` compiles every scene and reports its diagnostics (\`scene.*\` codes) with the rest.
+- \`cimplify scene solve <file> [--json] [--seed n] [--export name]\` solves a scene deterministically and prints where every object landed and which relations it could not meet.
+- \`cimplify scene resolve <file> [--json] [--out assets.json] [--tier low|mid|high] [--no-generate]\` turns each kind the scene uses into a Workshop asset, retrieval first and generation as the fallback.
+- \`cimplify remix <template> [--set slot=value]... [--parent remix.json] [--out remix.json]\` swaps a slotted template's theme, characters, scenes, music or rules into a content-addressed remix manifest; with no \`--set\` it lists the slots and what fits them.
+`;
+var STYLING = `## Game UI styling
+
+\`const ui = ctx.ui.game();\` returns the engine game UI. Build nodes once, root them, then update them.
+
+\`\`\`ts
+const s = ui.styles({
+  card: { padding: 12, radius: 16, fill: tokens.surface, scale: { default: 1, ":pressed": 0.95 } },
+  wide: { direction: { default: "column", "@landscape": "row" } },
+  bar: (ratio: number) => ({ width: \`\${ratio * 100}%\` as const }),
+});
+const card = ui.box(ui.props(s.card, s.wide));
+const bar = ui.box(ui.props(s.bar(0.4), "h-2 rounded-full bg-success"));
+card.append(bar);
+ui.root(card, { anchor: "top", offset: [0, 16] });
+\`\`\`
+
+- Three equivalent forms: a plain object (\`ui.box({ padding: 12 })\`), a sheet (\`ui.styles({...})\` merged with \`ui.props(...)\`), or a class string (\`ui.box("p-3 rounded-xl bg-surface pressed:scale-95")\`). All compile at build time to the same style block.
+- \`ui.props(a, b, ...)\` takes up to eight arguments (styles, class strings, objects, themes, \`false\`, \`null\`). Later values win per property; a shorthand replaces longhands set before it.
+- Conditions: \`:pressed\` (alias \`:active\`), \`:focus\`, \`:disabled\` follow the node and its ancestors; \`@landscape\`, \`@portrait\`, \`@safe\`, \`@sm\` (640 points), \`@lg\` (1024 points) come from \`ui.environment({ width, height, safe })\`. In classes they are prefixes: \`landscape:pressed:opacity-50\`.
+- Tokens: \`tokens.surface\`, \`raised\`, \`border\`, \`accent\`, \`onAccent\`, \`text\`, \`muted\`, \`track\`, \`danger\`, \`success\`, \`gold\` (classes use kebab case: \`bg-on-accent\`). Theme with \`defineVars\`, \`createTheme\`, \`ui.theme(theme)\` or per subtree with \`ui.props(theme, ...)\`.
+- Kit widgets: \`panel\`, \`iconButton\`, \`progressBar\`, \`currencyCounter\`, \`tabs\`, \`itemCard\`, \`toast\`, \`dialogueBox\`, \`worldLabel\`, themed with \`theme({...})\`. Widgets with \`update(dt)\` need it called every frame.
+- \`rotate\` in objects is radians; \`rotate-45\` in classes is degrees. Colours are \`#rgb\`, \`#rgba\`, \`#rrggbb\`, \`#rrggbbaa\`, an RGBA number or a token.
+- Full reference: every property, class family, condition and widget with a runnable example, in the UI reference pages and through \`api_lookup\` (try \`padding\`, \`rounded-xl\`, \`:pressed\`, \`progressBar\`).
+`;
+var NATIVE_UI = `## UI
+
+Native mini apps render GenUI trees with \`ctx.ui.render(tree)\` and present sheets with \`ctx.ui.open_sheet\`. There is no DOM. Keep trees small and re-render only when state changes.
+`;
+var PERFORMANCE_GAME = `## Performance rules (the gates measure these)
+
+- Zero allocation per frame. \`fixedUpdate\` and \`update\` must not create objects: no \`new\`, array or object literals, spreads, template strings, string concatenation, \`.map\`, \`.filter\` or closures. Create typed arrays, \`Vec3\` and \`Quat\` scratch values, materials, UI nodes and styles once in \`enter()\` or a constructor and reuse them.
+- No closures in hot loops. Write plain \`for\` loops over typed arrays; pass data, not callbacks.
+- Simulation goes in \`fixedUpdate\` (fixed step, deterministic), presentation in \`update\`. Use \`game.random\`, never \`Math.random\`, and the \`detSin\`/\`detCos\` helpers in simulation that must replay.
+- Hundreds or thousands of similar things belong in an entity table (\`game.table\`): bulk op first, kernel second, column loops third.
+- Hot \`for\`, \`for-of\` and \`while\` loops over typed arrays, table columns (\`table.f32("x")\`) or ECS columns are lowered to kernels by the build automatically, with exact JavaScript results (checked bit for bit at build time). Keep their bodies numeric: arithmetic, comparisons, ternaries, \`Math.min/max/abs/floor/ceil/round/sqrt/fround\`, typed-array reads and writes at \`[i]\` or \`[i + k]\`, local numbers, and accumulators like \`sum += x\`. Calls, allocation, strings, \`break\` and reading another iteration's element keep a loop in JavaScript; the build's \`kernel.lower_missed\` warning names the line and the fix. \`cimplify capture\` or \`test\` records which loops are hot (\`.cimplify/loops.json\`) and \`cimplify inspect\` lists them. Opt a file or function out with \`no_lower = ["src/file.ts#fn"]\` under \`[kernels]\` in interactive.toml; \`exact_math = true\` there also lowers \`Math.sin/cos/tan/asin/acos/atan/atan2/exp/log/log2/pow\` and makes them identical on every device.
+- UI: never create elements, call \`ui.styles\` or build class strings inside the frame loop. Update existing nodes with \`.text()\`, \`.number()\` and \`.style(precompiledStyle)\`. Dynamic style functions (\`s.bar(ratio)\`) write into one preallocated style, so calling them per frame is free. \`ui.props\` caches by argument identity, so pass the same compiled styles each time.
+`;
+var PERFORMANCE_NATIVE = `## Performance rules
+
+- Do work in response to events, not on timers. Keep allocations out of handlers that fire often.
+- Avoid re-rendering the whole tree for a single value; render once and change only what moved.
+`;
+var MISTAKES_GAME = `## Common mistakes
+
+- Nothing appears: the node was never passed to \`ui.root(...)\` (or appended to a rooted node), or it has no size or fill.
+- \`top\`/\`left\` do nothing without \`position: "absolute"\`.
+- CSS names that do not exist here: \`background\`, \`border\`, \`boxShadow\`, \`display: "grid"\`, \`margin: "auto"\`. Use \`fill\`, \`borderWidth\` with \`borderColor\`, \`shadow\`, flex layout and \`justify\`/\`alignItems\`.
+- Building class strings at run time (\`\` \`w-\${n}\` \`\`): the compiler cannot check them and they recompile on every call. Use a dynamic style function or \`.style({ width: n })\`.
+- A dynamic percentage needs \`as const\` (\`\` width: \`\${p}%\` as const \`\`), otherwise the sheet entry is not callable.
+- Misspelt classes or properties fail the build with \`styles.unknown_class\` or \`styles.unknown_property\`; read the did-you-mean.
+- Allocating in \`update\` to format text: use \`element.number(value, { separator: "," })\` instead of building strings.
+- Forgetting to call \`update(game.clock)\` on toasts, counters, dialogue boxes and the animated widgets (timers, damage numbers, particles, tooltips, results and loading screens), so they never animate or hide. Pass the clock, not a number: a fractional dt allocates on every call.
+- Tap targets under 44 points, text under 12 points and HUD edges inside the safe area get flagged by style checks; use \`@safe\` and \`safe_area\` roots.
+- Importing \`three\`, \`phaser\` or an engine backend; the platform picks the engine.
+- Calling a ctx scope with no \`[capabilities]\` entry, or reaching the network directly.
+`;
+var MISTAKES_NATIVE = `## Common mistakes
+
+- Calling a ctx scope with no \`[capabilities]\` entry, or reaching the network directly.
+- Editing \`cimplify.lock\` by hand.
+- Payment or credential wording outside \`ctx.wallet\` and host checkout; admission refuses it.
+`;
+function agentsGuide(title, profile) {
+  const game2 = profile === "canvas";
+  const intro = `# AGENTS.md: ${title}
+
+This is a Cimplify Interactive: ${game2 ? "a canvas game built on the Cimplify game API" : "a native mini app built on GenUI"}, written in TypeScript against \`@cimplify/sdk\` and built, tested and published with the \`cimplify\` CLI. This file tells coding agents how to work on it.
+`;
+  const sections = game2 ? [intro, LOOP, UI_CHECKS, PROJECT, GENERATIVE, STYLING, PERFORMANCE_GAME, MISTAKES_GAME] : [intro, LOOP, PROJECT, NATIVE_UI, PERFORMANCE_NATIVE, MISTAKES_NATIVE];
+  return sections.join("\n");
+}
+
+// src/interactives/templates/engine-files.ts
+var C_GAME = `#define CIMPLIFY_IMPLEMENTATION
+#include <cimplify.h>
+#include <GLES3/gl3.h>
+#include <emscripten/html5.h>
+
+static const char *VERTEX_SHADER =
+  "#version 300 es\\n"
+  "uniform vec4 placement;\\n"
+  "void main() {\\n"
+  "  vec2 corner = vec2(float(gl_VertexID & 1), float((gl_VertexID >> 1) & 1));\\n"
+  "  gl_Position = vec4(placement.xy + (corner * 2.0 - 1.0) * placement.zw, 0.0, 1.0);\\n"
+  "}\\n";
+
+static const char *FRAGMENT_SHADER =
+  "#version 300 es\\n"
+  "precision mediump float;\\n"
+  "uniform vec4 tint;\\n"
+  "out vec4 color;\\n"
+  "void main() { color = tint; }\\n";
+
+enum { QUAD_VERTICES = 4, SYNC_BUFFER_BYTES = 512, FLASH_MICROS = 400000 };
+
+static GLint placement_location;
+static GLint tint_location;
+static float placement[4];
+static float tint[4];
+static int32_t sync_call;
+static int32_t flash_micros;
+static char sync_buffer[SYNC_BUFFER_BYTES];
+
+static GLuint compile(GLenum type, const char *source) {
+  GLuint shader = glCreateShader(type);
+  glShaderSource(shader, 1, &source, 0);
+  glCompileShader(shader);
+  return shader;
+}
+
+void cimplify_start(void) {
+  EmscriptenWebGLContextAttributes attributes;
+  emscripten_webgl_init_context_attributes(&attributes);
+  attributes.majorVersion = 2;
+  attributes.antialias = 0;
+  attributes.alpha = 0;
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context("#canvas", &attributes);
+  emscripten_webgl_make_context_current(context);
+  GLuint program = glCreateProgram();
+  glAttachShader(program, compile(GL_VERTEX_SHADER, VERTEX_SHADER));
+  glAttachShader(program, compile(GL_FRAGMENT_SHADER, FRAGMENT_SHADER));
+  glLinkProgram(program);
+  glUseProgram(program);
+  placement_location = glGetUniformLocation(program, "placement");
+  tint_location = glGetUniformLocation(program, "tint");
+  GLuint vertices;
+  glGenVertexArrays(1, &vertices);
+  glBindVertexArray(vertices);
+  glClearColor(0.05f, 0.07f, 0.12f, 1.0f);
+}
+
+void cimplify_frame(int32_t delta_micros) {
+  const cimplify_input *input = cimplify_input_state();
+  if (input->width <= 0 || input->height <= 0) return;
+  if (input->pointer_presses > 0 && sync_call == 0) sync_call = cimplify_call("clock.sync", "[]");
+  if (sync_call != 0 && cimplify_status(sync_call) != CIMPLIFY_PENDING) {
+    if (cimplify_status(sync_call) == CIMPLIFY_OK) flash_micros = FLASH_MICROS;
+    cimplify_take(sync_call, sync_buffer, SYNC_BUFFER_BYTES);
+    sync_call = 0;
+  }
+  flash_micros = flash_micros > delta_micros ? flash_micros - delta_micros : 0;
+  float size = 0.12f + (float)flash_micros / (float)FLASH_MICROS * 0.08f;
+  placement[0] = (float)input->pointer_x / (float)input->width * 2.0f - 1.0f;
+  placement[1] = 1.0f - (float)input->pointer_y / (float)input->height * 2.0f;
+  placement[2] = size * (float)input->height / (float)input->width;
+  placement[3] = size;
+  tint[0] = input->pointer_down ? 1.0f : 0.2f;
+  tint[1] = 0.8f;
+  tint[2] = 0.5f;
+  tint[3] = 1.0f;
+  glViewport(0, 0, input->width, input->height);
+  glClear(GL_COLOR_BUFFER_BIT);
+  glUniform4fv(placement_location, 1, placement);
+  glUniform4fv(tint_location, 1, tint);
+  glDrawArrays(GL_TRIANGLE_STRIP, 0, QUAD_VERTICES);
+}
+`;
+var RUST_CARGO = `[package]
+name = "game"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+interactives-ctx = "0.1"
+`;
+var RUST_GAME = `#![no_std]
+
+use interactives_ctx as ctx;
+
+const WIDTH: usize = 256;
+const HEIGHT: usize = 144;
+const BYTES: usize = WIDTH * HEIGHT * 4;
+const SQUARE: i32 = 12;
+const FLASH_MICROS: i32 = 400_000;
+
+struct Game {
+    frame: [u8; BYTES],
+    time_micros: u32,
+    flash_micros: i32,
+    sync: Option<ctx::Call>,
+    reply: [u8; 512],
+}
+
+static mut GAME: Game = Game { frame: [0; BYTES], time_micros: 0, flash_micros: 0, sync: None, reply: [0; 512] };
+
+#[panic_handler]
+fn panic(_: &core::panic::PanicInfo) -> ! {
+    core::arch::wasm32::unreachable()
+}
+
+fn game() -> &'static mut Game {
+    unsafe { &mut *core::ptr::addr_of_mut!(GAME) }
+}
+
+fn start() {}
+
+fn frame(delta_micros: i32) {
+    let game = game();
+    let input = ctx::input();
+    game.time_micros = game.time_micros.wrapping_add(delta_micros as u32);
+    if input.pointer_presses > 0 && game.sync.is_none() {
+        game.sync = Some(ctx::request(ctx::CTX, "clock.sync", "[]"));
+    }
+    if let Some(call) = game.sync {
+        match call.status() {
+            ctx::Status::Pending => {}
+            status => {
+                if status == ctx::Status::Ready {
+                    game.flash_micros = FLASH_MICROS;
+                }
+                let _ = call.take(&mut game.reply);
+                game.sync = None;
+            }
+        }
+    }
+    game.flash_micros = (game.flash_micros - delta_micros).max(0);
+    let (px, py) = if input.width > 0 && input.height > 0 {
+        (input.pointer_x * WIDTH as i32 / input.width, input.pointer_y * HEIGHT as i32 / input.height)
+    } else {
+        (WIDTH as i32 / 2, HEIGHT as i32 / 2)
+    };
+    let shade = (game.time_micros >> 14) as u8;
+    let square = SQUARE + game.flash_micros * SQUARE / FLASH_MICROS;
+    for (index, pixel) in game.frame.chunks_exact_mut(4).enumerate() {
+        let x = (index % WIDTH) as i32;
+        let y = (index / WIDTH) as i32;
+        let inside = (x - px).abs() < square && (y - py).abs() < square;
+        pixel[0] = if inside { 230 } else { (x as u8).wrapping_add(shade) >> 2 };
+        pixel[1] = if inside { 200 } else { (y as u8) >> 1 };
+        pixel[2] = if inside { if input.pointer_down != 0 { 255 } else { 120 } } else { 60 };
+        pixel[3] = 255;
+    }
+    ctx::present(&game.frame, WIDTH as u32, HEIGHT as u32);
+}
+
+ctx::game!(start, frame);
+`;
+var GODOT_PROJECT = `config_version=5
+
+[application]
+
+config/name="__TITLE__"
+run/main_scene="res://main.tscn"
+config/features=PackedStringArray("4.7", "GL Compatibility")
+
+[display]
+
+window/stretch/mode="canvas_items"
+
+[rendering]
+
+renderer/rendering_method="gl_compatibility"
+renderer/rendering_method.mobile="gl_compatibility"
+`;
+var GODOT_MAIN_SCENE = `[gd_scene load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://main.gd" id="1"]
+
+[node name="Main" type="Node2D"]
+script = ExtResource("1")
+`;
+var GODOT_MAIN_SCRIPT = `extends Node2D
+
+const SIZE := 96.0
+const SPIN := 1.5
+const BADGE_PACK := "extras"
+const BADGE_SCENE := "res://extras/badge.tscn"
+
+var _angle := 0.0
+var _flash := 0.0
+
+
+func _ready() -> void:
+	var cimplify := get_node_or_null("/root/Cimplify")
+	if cimplify == null:
+		return
+	if await cimplify.load_pack(BADGE_PACK):
+		var badge: PackedScene = load(BADGE_SCENE)
+		add_child(badge.instantiate())
+
+
+func _process(delta: float) -> void:
+	_angle += delta * SPIN
+	_flash = maxf(_flash - delta, 0.0)
+	queue_redraw()
+
+
+func _unhandled_input(event: InputEvent) -> void:
+	var pressed := (event is InputEventScreenTouch or event is InputEventMouseButton) and event.is_pressed()
+	if pressed:
+		_sync()
+
+
+func _sync() -> void:
+	var cimplify := get_node_or_null("/root/Cimplify")
+	if cimplify == null:
+		return
+	var result: Dictionary = await cimplify.call_ctx("clock.sync")
+	if result.get("ok", false):
+		_flash = 1.0
+
+
+func _draw() -> void:
+	draw_set_transform(get_viewport_rect().size * 0.5, _angle)
+	draw_rect(Rect2(-SIZE * 0.5, -SIZE * 0.5, SIZE, SIZE), Color(0.1 + _flash * 0.8, 0.8, 0.5))
+`;
+var GODOT_BADGE_SCENE = `[gd_scene format=3]
+
+[node name="Badge" type="ColorRect"]
+offset_left = 16.0
+offset_top = 16.0
+offset_right = 48.0
+offset_bottom = 48.0
+color = Color(0.95, 0.75, 0.2, 1)
+`;
+
+// src/interactives/templates/engines.ts
+var ENGINE_TEMPLATE_NAMES = ["wasm-c", "wasm-rust", "godot"];
+var ENGINE_TEMPLATES = {
+  "wasm-c": {
+    description: "A C game compiled to WebAssembly by Cimplify, drawing with WebGL2 and reaching ctx through cimplify.h",
+    game: "wasm",
+    engine: `language = "c"
+sources = ["native/game.c"]
+memory = "16 MiB"
+max_memory = "64 MiB"
+`,
+    minDeviceTier: "low",
+    downloadSize: "1 MiB",
+    gitignore: "node_modules\n.cimplify\n",
+    files: [{ path: "native/game.c", content: C_GAME }]
+  },
+  "wasm-rust": {
+    description: "A Rust game compiled to raw WebAssembly by Cimplify, presenting a pixel frame and reaching ctx through interactives-ctx",
+    game: "wasm",
+    engine: `language = "rust"
+crate = "native/game"
+memory = "2 MiB"
+max_memory = "16 MiB"
+`,
+    minDeviceTier: "low",
+    downloadSize: "1 MiB",
+    gitignore: "node_modules\n.cimplify\ntarget\n",
+    files: [
+      { path: "native/game/Cargo.toml", content: RUST_CARGO },
+      { path: "native/game/src/lib.rs", content: RUST_GAME }
+    ]
+  },
+  godot: {
+    description: "A Godot 4 game exported by Cimplify, reaching ctx through the Cimplify autoload and streaming a second pack after play starts",
+    game: "godot",
+    engine: `project = "game"
+runtime = "2d"
+
+[[engine.packs]]
+name = "extras"
+files = ["res://extras/*"]
+`,
+    minDeviceTier: "high",
+    downloadSize: "48 MiB",
+    gitignore: "node_modules\n.cimplify\n.godot\n",
+    files: [
+      { path: "game/project.godot", content: GODOT_PROJECT },
+      { path: "game/main.tscn", content: GODOT_MAIN_SCENE },
+      { path: "game/main.gd", content: GODOT_MAIN_SCRIPT },
+      { path: "game/extras/badge.tscn", content: GODOT_BADGE_SCENE }
+    ]
+  }
+};
+function packageJson(name) {
+  return `${JSON.stringify({ name, private: true, scripts: { dev: "cimplify dev" }, dependencies: { "@cimplify/sdk": `^${PINNED_SDK_VERSION}` } }, null, 2)}
+`;
+}
+function manifest(title, template) {
+  return `[interactive]
+name = ${quoteTomlString(title)}
+description = ${quoteTomlString(template.description)}
+category = "games"
+
+[profile]
+kind = "canvas"
+game = "${template.game}"
+
+[engine]
+${template.engine}
+[rating]
+violence = "none"
+sexuality = "none"
+language = "none"
+fear = "none"
+simulated_gambling = false
+
+[delivery]
+min_device_tier = "${template.minDeviceTier}"
+download_size = "${template.downloadSize}"
+`;
+}
+function isEngineTemplate(value) {
+  return ENGINE_TEMPLATE_NAMES.indexOf(value) >= 0;
+}
+function renderEngineTemplate(template, name) {
+  const spec = ENGINE_TEMPLATES[template];
+  const title = titleFromName(name);
+  return [
+    { path: MANIFEST_FILE, content: manifest(title, spec) },
+    { path: LOCKFILE, content: serializeLockfile(currentLockfile()) },
+    { path: "package.json", content: packageJson(name) },
+    { path: ".gitignore", content: spec.gitignore },
+    ...spec.files.map((file) => ({ path: file.path, content: file.content.replaceAll("__TITLE__", title) }))
+  ];
+}
+var FRONTIER_FEATURES = ["audio", "ai"];
+var CLIENT = `import type { Ctx } from "@cimplify/sdk/interactives";
+import { firstFrame, runCanvasGame } from "@cimplify/sdk/game/kit/canvas";
+import { frontier } from "@cimplify/sdk/game/kit";
+
+const WORLD = "my-planet";
+
+export default async function main(ctx: Ctx): Promise<void> {
+  const launched = firstFrame();
+  let ask: (() => void) | null = null;
+  const session = await frontier.joinFrontierPlanet(ctx, { world_id: WORLD, spawn: { kind: "last_location" } }, () => ask?.());
+  const { scene } = session;
+  ask = () => {
+    void (async () => {
+      const result = await ctx.ui.open_sheet({
+        title: "Invent something",
+        tree: { type: "Input", props: { label: "Describe your invention", value: "$description", placeholder: "A water wheel that powers a mill" } },
+        dismissible: true,
+      });
+      if (result.status !== "submitted") return;
+      const value = result.value as { description?: unknown } | null;
+      const description = typeof value?.description === "string" ? value.description : "";
+      if (description.trim() === "") return;
+      const run = await frontier.requestInvention(ctx.ai, {
+        description,
+        materials: ["stone", "wood", "clay", "iron", "copper", "glass"],
+        techs: ["fire"],
+        requestKey: String(ctx.clock.now()),
+      });
+      scene.commands.invent(run);
+    })();
+  };
+  await runCanvasGame(ctx, {
+    scene,
+    onFrame(game, nowMs) {
+      session.onFrame(nowMs);
+      launched.onFrame(game, nowMs);
+    },
+  });
+}
+`;
+var CONFORMANCE = `import { createGame } from "@cimplify/sdk/game";
+import { platformBackend, PREPARED_PLATFORM } from "@cimplify/sdk/game/kit/canvas";
+import { frontier } from "@cimplify/sdk/game/kit";
+
+export default async function createFrameHook(platform = PREPARED_PLATFORM): Promise<(frame: number) => void> {
+  const game = await createGame({ backend: await platformBackend(platform), seed: 1 });
+  const scene = new frontier.FrontierPlanet({ link: new frontier.ReplayFrontierLink([]), region: frontier.regionKey(0, 0, 0, 0), player: 0 });
+  game.addScene(scene);
+  game.start(scene.name);
+  return () => game.runFrame();
+}
+`;
+var TEST = `import { describe, expect, it } from "vitest";
+import { frontier } from "@cimplify/sdk/game/kit";
+
+describe("frontier planet", () => {
+  it("encodes a till command for the planet room", () => {
+    const writer = new frontier.CommandWriter();
+    const length = frontier.encodeCommand({ kind: "till", region: frontier.regionKey(0, 0, 1, 2), x: 10, z: 20 }, writer);
+    expect(length).toBe(12);
+  });
+
+  it("asks the declared invention prompt for structured output", () => {
+    const request = frontier.inventionRequest({ description: "a windmill", materials: ["wood"], techs: ["fire"], requestKey: "k" });
+    expect(request.prompt).toBe(frontier.INVENT_PROMPT);
+  });
+});
+`;
+var FRONTIER_TEMPLATE = {
+  description: "An empty planet you and your friends develop: gather, invent, build machines, farm and automate",
+  category: "games",
+  profile: "canvas",
+  game: true,
+  capabilities: {
+    ai: frontier.AI_CAPABILITY,
+    world: "Keeps your planet running while you are away and shares it with friends",
+    identity: "Shows who built what"
+  },
+  extraManifest: `${frontier.frontierAiSection()}
+[world]
+simulation = "frontier"
+`,
+  minDeviceTier: "low",
+  engineFeatures: FRONTIER_FEATURES,
+  files: [
+    { path: "src/client.ts", content: CLIENT },
+    { path: "src/conformance.ts", content: CONFORMANCE },
+    { path: "tests/frontier.test.ts", content: TEST }
+  ]
+};
+var CHEMISTRY_FEATURES = ["ai", "chemistry_1"];
+var CLIENT2 = `import type { Ctx } from "@cimplify/sdk/interactives";
+import { firstFrame, runCanvasGame } from "@cimplify/sdk/game/kit/canvas";
+import { chemistry } from "@cimplify/sdk/game/kit";
+
+export default async function main(ctx: Ctx): Promise<void> {
+  const launched = firstFrame();
+  let menu: ((which: "tool" | "invent") => void) | null = null;
+  const scene = new chemistry.ChemistrySandbox({ width: 160, height: 120, onMenu: (which) => menu?.(which) });
+  const game = await runCanvasGame(ctx, {
+    scene,
+    onFrame(game, nowMs) {
+      launched.onFrame(game, nowMs);
+    },
+  });
+  menu = (which) => {
+    if (which === "tool") {
+      scene.nextTool();
+      return;
+    }
+    void (async () => {
+      const result = await ctx.ui.open_sheet({
+        title: "Invent a reaction",
+        tree: { type: "Input", props: { label: "What should happen?", value: "$idea", placeholder: "Rust dissolves in vinegar and fizzes" } },
+        dismissible: true,
+      });
+      if (result.status !== "submitted") return;
+      const value = result.value as { idea?: unknown } | null;
+      const idea = typeof value?.idea === "string" ? value.idea.trim() : "";
+      if (idea === "") return;
+      const outcome = await chemistry.proposeReaction(game.chemistry, ctx.ai, { description: idea, requestKey: String(ctx.clock.now()) });
+      ctx.ui.toast(outcome.ok ? "Your reaction is now part of this world" : outcome.reason);
+    })();
+  };
+}
+`;
+var CONFORMANCE2 = `import { createGame } from "@cimplify/sdk/game";
+import { platformBackend, PREPARED_PLATFORM } from "@cimplify/sdk/game/kit/canvas";
+import { chemistry } from "@cimplify/sdk/game/kit";
+
+export default async function createFrameHook(platform = PREPARED_PLATFORM): Promise<(frame: number) => void> {
+  const game = await createGame({ backend: await platformBackend(platform), seed: 1 });
+  const scene = new chemistry.ChemistrySandbox({ width: 96, height: 72 });
+  game.addScene(scene);
+  game.start(scene.name);
+  return () => game.runFrame();
+}
+`;
+var TEST2 = `import { describe, expect, it } from "vitest";
+import { chemistry } from "@cimplify/sdk/game/kit";
+
+describe("chemistry sandbox", () => {
+  it("turns a model proposal into checked definition lines", () => {
+    const text = chemistry.proposalText({
+      reaction: { name: "hydrogen_pop", reactants: [{ material: "H2", count: 2 }, { material: "O2", count: 1, phase: "gas" }], products: [{ material: "H2O", count: 2 }], above_k: 850 },
+    });
+    expect(text).toContain("reaction hydrogen_pop: 2 H2 + 1 O2@g -> 2 H2O");
+  });
+
+  it("cycles through the tools", () => {
+    const scene = new chemistry.ChemistrySandbox();
+    expect(scene.nextTool()).toBe("water");
+  });
+});
+`;
+var CHEMISTRY_TEMPLATE = {
+  description: "A falling-sand chemistry sandbox: mix, heat, burn, dissolve, smelt and invent reactions",
+  category: "games",
+  profile: "canvas",
+  game: true,
+  capabilities: {
+    ai: chemistry.CHEMISTRY_AI_CAPABILITY
+  },
+  extraManifest: chemistry.chemistryAiSection(),
+  minDeviceTier: "low",
+  engineFeatures: CHEMISTRY_FEATURES,
+  files: [
+    { path: "src/client.ts", content: CLIENT2 },
+    { path: "src/conformance.ts", content: CONFORMANCE2 },
+    { path: "tests/chemistry.test.ts", content: TEST2 }
+  ]
+};
+var GENESIS_FEATURES = ["audio", "ai"];
+var CLIENT3 = `import type { Ctx } from "@cimplify/sdk/interactives";
+import { firstFrame, runCanvasGame } from "@cimplify/sdk/game/kit/canvas";
+import { genesis } from "@cimplify/sdk/game/kit";
+
+const WORLD = "my-world";
+const REALM = 0;
+
+async function words(ctx: Ctx, title: string, label: string, placeholder: string): Promise<string> {
+  const result = await ctx.ui.open_sheet({
+    title,
+    tree: { type: "Input", props: { label, value: "$words", placeholder } },
+    dismissible: true,
+  });
+  if (result.status !== "submitted") return "";
+  const value = result.value as { words?: unknown } | null;
+  return typeof value?.words === "string" ? value.words.trim() : "";
+}
+
+type World = InstanceType<typeof genesis.GenesisWorld>;
+
+async function review(ctx: Ctx, scene: World): Promise<void> {
+  const r = scene.mirror.review;
+  if (r === null) return;
+  scene.mirror.review = null;
+  const lines = [...r.problems.map((p) => "Problem: " + p.text), ...r.lines];
+  const result = await ctx.ui.open_sheet({
+    title: r.problems.length === 0 ? "Read it back before it becomes law" : "This draft cannot become law yet",
+    tree: { type: "Stack", children: lines.map((text) => ({ type: "TextContent", props: { text } })) },
+    dismissible: true,
+  });
+  if (result.status === "submitted" && r.problems.length === 0) scene.commands.enact(r);
+}
+
+export default async function main(ctx: Ctx): Promise<void> {
+  const launched = firstFrame();
+  const session = await genesis.joinGenesisWorld(ctx, { world_id: WORLD, spawn: { kind: "default" } }, {
+    onLaw(scene) {
+      void (async () => {
+        const said = await words(ctx, "Write the law", "Your constitution in your own words", "Land belongs to whoever farms it. Seven elders rule, chosen by lot each decade.");
+        if (said === "") return;
+        const run = await genesis.requestConstitution(ctx.ai, { words: said, world: scene.worldContext(), requestKey: String(ctx.clock.now()) });
+        scene.commands.draft(run, REALM);
+      })();
+    },
+    onChronicle(scene) {
+      const m = scene.mirror;
+      void (async () => {
+        const facts = genesis.factsText(m.nature.seed, m.facts.slice(-24), (s) => m.name[s] ?? 0);
+        const run = await genesis.requestChronicle(ctx.ai, { facts, realm: scene.worldContext(), requestKey: String(m.state.month) });
+        const output = run.result?.output;
+        const text = output !== null && output !== undefined && output.kind === "text" ? output.text : "";
+        if (text !== "") await ctx.ui.open_sheet({ title: "Chronicle", tree: { type: "TextContent", props: { text } }, dismissible: true });
+      })();
+    },
+  });
+  const { scene } = session;
+  await runCanvasGame(ctx, {
+    scene,
+    onFrame(game, nowMs) {
+      session.onFrame(nowMs);
+      launched.onFrame(game, nowMs);
+      if (scene.mirror.review !== null) void review(ctx, scene);
+    },
+  });
+}
+`;
+var CONFORMANCE3 = `import { createGame } from "@cimplify/sdk/game";
+import { platformBackend, PREPARED_PLATFORM } from "@cimplify/sdk/game/kit/canvas";
+import { genesis } from "@cimplify/sdk/game/kit";
+
+export default async function createFrameHook(platform = PREPARED_PLATFORM): Promise<(frame: number) => void> {
+  const game = await createGame({ backend: await platformBackend(platform), seed: 1 });
+  const scene = new genesis.GenesisWorld({ link: new genesis.ReplayGenesisLink([]) });
+  game.addScene(scene);
+  game.start(scene.name);
+  return () => game.runFrame();
+}
+`;
+var TEST3 = `import { describe, expect, it } from "vitest";
+import { genesis } from "@cimplify/sdk/game/kit";
+
+describe("genesis world", () => {
+  it("encodes a blessing decree for the world room", () => {
+    const writer = new genesis.ByteWriter();
+    const length = genesis.encodeDecree(
+      { target: { kind: "settlement", settlement: 0 }, power: { kind: "bless", mortalityQ16: 45_000, fertilityQ16: 80_000, months: 24 } },
+      writer,
+    );
+    expect(length).toBe(36);
+  });
+
+  it("asks the declared constitution prompt for structured output", () => {
+    const request = genesis.constitutionRequest({ words: "Nobody may be forced to worship.", world: "", requestKey: "k" });
+    expect(request.prompt).toBe(genesis.CONSTITUTION_PROMPT);
+  });
+});
+`;
+var GENESIS_TEMPLATE = {
+  description: "Play god on a world you write: shape nature, write its constitution, bless, curse and watch generations live out history",
+  category: "games",
+  profile: "canvas",
+  game: true,
+  capabilities: {
+    ai: genesis.AI_CAPABILITY,
+    world: "Keeps your world's history running while you are away and shares it with friends",
+    identity: "Shows which god made which decree"
+  },
+  extraManifest: `${genesis.genesisAiSection()}
+[world]
+simulation = "genesis"
+`,
+  minDeviceTier: "low",
+  engineFeatures: GENESIS_FEATURES,
+  files: [
+    { path: "src/client.ts", content: CLIENT3 },
+    { path: "src/conformance.ts", content: CONFORMANCE3 },
+    { path: "tests/genesis.test.ts", content: TEST3 }
+  ]
+};
+
+// src/interactives/templates/games.ts
+var CANVAS_BOOT = `export async function acquireCanvas(ctx: Ctx): Promise<{ canvas: HTMLCanvasElement; g: CanvasRenderingContext2D; width: number; height: number }> {
+  const surface = await ctx.graphics.acquire_surface({ api: "canvas2d", transparent: false, pixel_ratio_cap: 2, offscreen: false });
+  const canvas = surface.canvas;
+  if (!(canvas instanceof HTMLCanvasElement)) throw new Error("this template draws on an on-screen canvas");
+  const g = canvas.getContext("2d");
+  if (!g) throw new Error("2d canvas is unavailable");
+  return { canvas, g, width: surface.width, height: surface.height };
+}
+`;
+var RACING_SIM = `export const CARS = 6;
+export const LAP_METRES = 1000;
+const ACCEL = 0.000012;
+const DRAG = 0.0009;
+const AI_THROTTLE_BASE = 0.55;
+const AI_THROTTLE_SPREAD = 0.06;
+
+export class RaceSim {
+  readonly position = new Float64Array(CARS);
+  readonly speed = new Float64Array(CARS);
+  readonly laps = new Int32Array(CARS);
+  private readonly aiThrottle = new Float64Array(CARS);
+
+  constructor() {
+    for (let i = 1; i < CARS; i++) this.aiThrottle[i] = AI_THROTTLE_BASE + i * AI_THROTTLE_SPREAD;
+  }
+
+  step(stepMs: number, throttle: number): void {
+    this.aiThrottle[0] = throttle;
+    for (let i = 0; i < CARS; i++) {
+      const v = this.speed[i] + (this.aiThrottle[i] * ACCEL - DRAG * this.speed[i] * this.speed[i]) * stepMs;
+      this.speed[i] = v > 0 ? v : 0;
+      let p = this.position[i] + this.speed[i] * stepMs;
+      if (p >= LAP_METRES) {
+        p -= LAP_METRES;
+        this.laps[i]++;
+      }
+      this.position[i] = p;
+    }
+  }
+
+  rank(car: number): number {
+    const mine = this.laps[car] * LAP_METRES + this.position[car];
+    let ahead = 0;
+    for (let i = 0; i < CARS; i++) if (i !== car && this.laps[i] * LAP_METRES + this.position[i] > mine) ahead++;
+    return ahead + 1;
+  }
+}
+`;
+var RACING_CLIENT = `import type { Ctx } from "@cimplify/sdk/interactives";
+import { CARS, LAP_METRES, RaceSim } from "./sim";
+
+const COLORS = ["#10b981", "#f59e0b", "#3b82f6", "#ef4444", "#a855f7", "#14b8a6"];
+const TRACK = "#1f2937";
+const BACKGROUND = "#0b1220";
+const TEXT = "#f9fafb";
+
+${CANVAS_BOOT}
+export default async function main(ctx: Ctx): Promise<void> {
+  const { canvas, g, width, height } = await acquireCanvas(ctx);
+  const sim = new RaceSim();
+  let throttle = 0;
+  let label = "";
+  let shownLap = -1;
+  let shownRank = -1;
+  canvas.addEventListener("pointerdown", () => {
+    throttle = 1;
+  });
+  canvas.addEventListener("pointerup", () => {
+    throttle = 0;
+  });
+  const lane = height / (CARS + 1);
+  ctx.game.loop.start({
+    update(stepMs) {
+      sim.step(stepMs, throttle);
+    },
+    render() {
+      g.fillStyle = BACKGROUND;
+      g.fillRect(0, 0, width, height);
+      g.fillStyle = TRACK;
+      g.fillRect(0, lane / 2, width, lane * CARS);
+      for (let i = 0; i < CARS; i++) {
+        g.fillStyle = COLORS[i];
+        g.fillRect((sim.position[i] / LAP_METRES) * (width - 24), lane * (i + 0.6), 24, lane * 0.6);
+      }
+      const rank = sim.rank(0);
+      if (sim.laps[0] !== shownLap || rank !== shownRank) {
+        shownLap = sim.laps[0];
+        shownRank = rank;
+        label = "Lap " + (shownLap + 1) + "  P" + rank + "  hold to accelerate";
+      }
+      g.fillStyle = TEXT;
+      g.fillText(label, 12, 16);
+    },
+  });
+  ctx.on_dispose(() => ctx.game.loop.stop());
+}
+`;
+var RACING_CONFORMANCE = `import { RaceSim } from "./sim";
+
+const STEP_MS = 1000 / 60;
+const PULSE_FRAMES = 64;
+
+export default function createFrameHook(): (frame: number) => void {
+  const sim = new RaceSim();
+  return (frame) => {
+    sim.step(STEP_MS, frame % PULSE_FRAMES < PULSE_FRAMES / 2 ? 1 : 0);
+  };
+}
+`;
+var RACING_TEST = `import { describe, expect, it } from "vitest";
+import { RaceSim } from "../src/sim";
+
+describe("RaceSim", () => {
+  it("completes laps when the player holds the throttle", () => {
+    const sim = new RaceSim();
+    for (let i = 0; i < 60 * 120; i++) sim.step(1000 / 60, 1);
+    expect(sim.laps[0]).toBeGreaterThan(0);
+  });
+});
+`;
+var SPORT_SIM = `export const GROUND = 0;
+export const GOAL_X = 30;
+const GRAVITY = -0.00003;
+const RESTITUTION = 0.55;
+const KICK_UP = 0.018;
+const KICK_FORWARD = 0.012;
+const FRICTION = 0.9995;
+const X = 0;
+const Y = 1;
+const VX = 2;
+const VY = 3;
+
+export class KickSim {
+  readonly state = new Float64Array(4);
+  goals = 0;
+  kicks = 0;
+
+  kick(power: number): void {
+    if (this.state[Y] > 0.05) return;
+    this.state[VY] = KICK_UP * power;
+    this.state[VX] = KICK_FORWARD * power;
+    this.kicks++;
+  }
+
+  step(stepMs: number): void {
+    const s = this.state;
+    s[VY] += GRAVITY * stepMs;
+    s[X] += s[VX] * stepMs;
+    s[Y] += s[VY] * stepMs;
+    s[VX] *= FRICTION;
+    if (s[Y] < GROUND) {
+      s[Y] = GROUND;
+      s[VY] = -s[VY] * RESTITUTION;
+    }
+    if (s[X] >= GOAL_X) {
+      this.goals++;
+      s[X] = 0;
+      s[Y] = 0;
+      s[VX] = 0;
+      s[VY] = 0;
+    }
+  }
+
+  get x(): number {
+    return this.state[X];
+  }
+
+  get y(): number {
+    return this.state[Y];
+  }
+}
+`;
+var SPORT_CLIENT = `import type { Ctx } from "@cimplify/sdk/interactives";
+import { GOAL_X, KickSim } from "./sim";
+
+const PITCH = "#166534";
+const BALL = "#f9fafb";
+const GOAL = "#facc15";
+const BALL_RADIUS = 8;
+const METRES_TO_PIXELS = 10;
+
+${CANVAS_BOOT}
+export default async function main(ctx: Ctx): Promise<void> {
+  const { canvas, g, width, height } = await acquireCanvas(ctx);
+  const sim = new KickSim();
+  let label = "Tap to kick";
+  let shownGoals = 0;
+  canvas.addEventListener("pointerdown", () => sim.kick(1));
+  const scale = width / (GOAL_X + 4);
+  const ground = height - 24;
+  ctx.game.loop.start({
+    update(stepMs) {
+      sim.step(stepMs);
+    },
+    render() {
+      g.fillStyle = PITCH;
+      g.fillRect(0, 0, width, height);
+      g.fillStyle = GOAL;
+      g.fillRect(GOAL_X * scale, ground - 60, 6, 60);
+      g.fillStyle = BALL;
+      g.beginPath();
+      g.arc(sim.x * scale + BALL_RADIUS, ground - sim.y * METRES_TO_PIXELS - BALL_RADIUS, BALL_RADIUS, 0, Math.PI * 2);
+      g.fill();
+      if (sim.goals !== shownGoals) {
+        shownGoals = sim.goals;
+        label = "Goals " + shownGoals;
+      }
+      g.fillText(label, 12, 16);
+    },
+  });
+  ctx.on_dispose(() => ctx.game.loop.stop());
+}
+`;
+var SPORT_CONFORMANCE = `import { KickSim } from "./sim";
+
+const STEP_MS = 1000 / 60;
+const KICK_EVERY = 90;
+
+export default function createFrameHook(): (frame: number) => void {
+  const sim = new KickSim();
+  return (frame) => {
+    if (frame % KICK_EVERY === 0) sim.kick(1);
+    sim.step(STEP_MS);
+  };
+}
+`;
+var SPORT_TEST = `import { describe, expect, it } from "vitest";
+import { KickSim } from "../src/sim";
+
+describe("KickSim", () => {
+  it("scores after repeated kicks", () => {
+    const sim = new KickSim();
+    for (let i = 0; i < 60 * 60; i++) {
+      if (i % 90 === 0) sim.kick(1);
+      sim.step(1000 / 60);
+    }
+    expect(sim.goals).toBeGreaterThan(0);
+  });
+});
+`;
+var BOARD_SIM = `export const EMPTY = 0;
+export const PLAYER = 1;
+export const COMPUTER = 2;
+const LINES = new Int8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 3, 6, 1, 4, 7, 2, 5, 8, 0, 4, 8, 2, 4, 6]);
+const CENTER = 4;
+
+export class BoardSim {
+  readonly cells = new Int8Array(9);
+  winner = EMPTY;
+  moves = 0;
+
+  reset(): void {
+    this.cells.fill(EMPTY);
+    this.winner = EMPTY;
+    this.moves = 0;
+  }
+
+  get finished(): boolean {
+    return this.winner !== EMPTY || this.moves === 9;
+  }
+
+  play(cell: number): boolean {
+    if (this.finished || cell < 0 || cell > 8 || this.cells[cell] !== EMPTY) return false;
+    this.place(cell, PLAYER);
+    if (!this.finished) this.place(this.reply(), COMPUTER);
+    return true;
+  }
+
+  private place(cell: number, who: number): void {
+    this.cells[cell] = who;
+    this.moves++;
+    if (this.wins(who)) this.winner = who;
+  }
+
+  private wins(who: number): boolean {
+    for (let i = 0; i < LINES.length; i += 3) {
+      if (this.cells[LINES[i]] === who && this.cells[LINES[i + 1]] === who && this.cells[LINES[i + 2]] === who) return true;
+    }
+    return false;
+  }
+
+  private completing(who: number): number {
+    for (let i = 0; i < LINES.length; i += 3) {
+      let mine = 0;
+      let open = -1;
+      for (let j = 0; j < 3; j++) {
+        const c = this.cells[LINES[i + j]];
+        if (c === who) mine++;
+        else if (c === EMPTY) open = LINES[i + j];
+      }
+      if (mine === 2 && open >= 0) return open;
+    }
+    return -1;
+  }
+
+  private reply(): number {
+    const win = this.completing(COMPUTER);
+    if (win >= 0) return win;
+    const block = this.completing(PLAYER);
+    if (block >= 0) return block;
+    if (this.cells[CENTER] === EMPTY) return CENTER;
+    for (let i = 0; i < 9; i++) if (this.cells[i] === EMPTY) return i;
+    return -1;
+  }
+}
+`;
+var BOARD_CLIENT = `import type { Ctx } from "@cimplify/sdk/interactives";
+import { BoardSim, COMPUTER, PLAYER } from "./sim";
+
+const BACKGROUND = "#111827";
+const LINE = "#374151";
+const MARKS = ["", "#10b981", "#f59e0b"];
+
+${CANVAS_BOOT}
+export default async function main(ctx: Ctx): Promise<void> {
+  const { canvas, g, width, height } = await acquireCanvas(ctx);
+  const sim = new BoardSim();
+  const size = Math.min(width, height);
+  const cell = size / 3;
+  canvas.addEventListener("pointerdown", (event) => {
+    if (sim.finished) {
+      sim.reset();
+      return;
+    }
+    const rect = canvas.getBoundingClientRect();
+    const col = Math.floor(((event.clientX - rect.left) / rect.width) * width / cell);
+    const row = Math.floor(((event.clientY - rect.top) / rect.height) * height / cell);
+    if (col < 3 && row < 3) sim.play(row * 3 + col);
+  });
+  ctx.game.loop.start({
+    update() {},
+    render() {
+      g.fillStyle = BACKGROUND;
+      g.fillRect(0, 0, width, height);
+      g.fillStyle = LINE;
+      for (let i = 1; i < 3; i++) {
+        g.fillRect(i * cell - 1, 0, 2, size);
+        g.fillRect(0, i * cell - 1, size, 2);
+      }
+      for (let i = 0; i < 9; i++) {
+        const who = sim.cells[i];
+        if (who !== PLAYER && who !== COMPUTER) continue;
+        g.fillStyle = MARKS[who];
+        g.fillRect((i % 3) * cell + cell * 0.25, Math.floor(i / 3) * cell + cell * 0.25, cell * 0.5, cell * 0.5);
+      }
+    },
+  });
+  ctx.on_dispose(() => ctx.game.loop.stop());
+}
+`;
+var BOARD_CONFORMANCE = `import { BoardSim } from "./sim";
+
+const STRIDE = 5;
+
+export default function createFrameHook(): (frame: number) => void {
+  const sim = new BoardSim();
+  return (frame) => {
+    if (sim.finished) sim.reset();
+    sim.play((frame * STRIDE) % 9);
+  };
+}
+`;
+var BOARD_TEST = `import { describe, expect, it } from "vitest";
+import { BoardSim, COMPUTER } from "../src/sim";
+
+describe("BoardSim", () => {
+  it("blocks and then wins against a careless player", () => {
+    const sim = new BoardSim();
+    sim.play(0);
+    sim.play(1);
+    sim.play(6);
+    sim.play(8);
+    expect(sim.winner).toBe(COMPUTER);
+  });
+});
+`;
+function game(description, sim, client, conformance2, test2) {
+  return {
+    description,
+    category: "games",
+    profile: "canvas",
+    game: true,
+    capabilities: {},
+    files: [
+      { path: "src/sim.ts", content: sim },
+      { path: "src/client.ts", content: client },
+      { path: "src/conformance.ts", content: conformance2 },
+      { path: "tests/sim.test.ts", content: test2 }
+    ]
+  };
+}
+var GAME_TEMPLATES = {
+  racing: game("Hold to accelerate and race five rivals", RACING_SIM, RACING_CLIENT, RACING_CONFORMANCE, RACING_TEST),
+  sport: game("Tap to kick the ball into the goal", SPORT_SIM, SPORT_CLIENT, SPORT_CONFORMANCE, SPORT_TEST),
+  board: game("Noughts and crosses against the computer", BOARD_SIM, BOARD_CLIENT, BOARD_CONFORMANCE, BOARD_TEST)
+};
+var BOX_SCENE_FEATURES = ["audio"];
+var PENALTY_FEATURES = ["audio", "physics"];
+var DRIVING_FEATURES = ["audio", "physics", "models", "images"];
+var DANFO_CONTENT = ["cimplify/danfo-bus"];
+function conformance(game2) {
+  return `import { createTemplateHarness, platformBackend, PREPARED_PLATFORM, ${game2.module} } from "@cimplify/sdk/game/kit/canvas";
+
+const SEED = 1;
+
+export default async function createFrameHook(platform = PREPARED_PLATFORM): Promise<(frame: number) => void> {
+  const harness = await createTemplateHarness(${game2.module}.${game2.template}, await platformBackend(platform), SEED);
+  return (frame) => harness.frame(frame);
+}
+`;
+}
+function test(game2) {
+  return `import { describe, expect, it } from "vitest";
+import { createTemplateHarness, kitPublicationGates, platformBackend, PREPARED_PLATFORM, ${game2.module} } from "@cimplify/sdk/game/kit/canvas";
+
+const template = ${game2.module}.${game2.template};
+
+describe("${game2.testTitle}", () => {
+  it("makes progress under the playtest bot", async () => {
+    const harness = await createTemplateHarness(template, await platformBackend(PREPARED_PLATFORM), 1);
+    for (let i = 0; i < ${game2.testFrames}; i++) harness.frame(i);
+    expect(template.progress(harness.scene)).toBeGreaterThanOrEqual(${game2.testProgress});
+    harness.game.dispose();
+  });
+
+  it("passes the money gates", () => {
+    expect(kitPublicationGates(template.economy).filter((g) => !g.passed)).toEqual([]);
+  });
+});
+`;
+}
+var BOOT = `import type { Ctx } from "@cimplify/sdk/interactives";
+`;
+var SHOOTOUT_CLIENT = `${BOOT}import { firstFrame, FriendChallenges, Leaderboard, runCanvasGame, shootout } from "@cimplify/sdk/game/kit/canvas";
+
+export default async function main(ctx: Ctx): Promise<void> {
+  const launched = firstFrame();
+  const services = launched.reached.then(async () => ({
+    me: await ctx.identity.current(),
+    board: await Leaderboard.open((request) => ctx.open_counter(request), { name: "best-series", scope: "interactive" }),
+    challenges: new FriendChallenges(ctx.social),
+  }));
+  const scene = new shootout.PenaltyShootout({
+    seriesEnded(goals) {
+      void services.then(({ me, board, challenges }) => {
+        void board.submit(me.participant_id, goals);
+        if (goals === shootout.SHOOTOUT.kicksPerSeries) void challenges.postResult(goals);
+      });
+    },
+  });
+  await runCanvasGame(ctx, { scene, onFrame: launched.onFrame });
+}
+`;
+var RUNNER_CLIENT = `${BOOT}import { defineEconomy, firstFrame, Leaderboard, Ledger, runCanvasGame, runner } from "@cimplify/sdk/game/kit/canvas";
+
+export default async function main(ctx: Ctx): Promise<void> {
+  const launched = firstFrame();
+  const services = launched.reached.then(async () => ({
+    me: await ctx.identity.current(),
+    ledger: new Ledger(defineEconomy(runner.runnerEconomy), { economy: ctx.game.economy, keys: ctx.id }),
+    board: await Leaderboard.open((request) => ctx.open_counter(request), { name: "distance", scope: "interactive" }),
+  }));
+  const scene = new runner.EndlessRunner({
+    runEnded(distance, coins) {
+      void services.then(({ me, ledger, board }) => {
+        if (coins > 0) void ledger.earn(runner.runCoins, Math.min(coins, runner.runCoins.maxQuantity));
+        void board.submit(me.participant_id, Math.floor(distance));
+      });
+    },
+  });
+  await runCanvasGame(ctx, { scene, onFrame: launched.onFrame });
+}
+`;
+var FIVE_A_SIDE_CLIENT = `${BOOT}import { fiveASide, runCanvasGame } from "@cimplify/sdk/game/kit/canvas";
+
+export default async function main(ctx: Ctx): Promise<void> {
+  await runCanvasGame(ctx, { scene: new fiveASide.FiveASide() });
+}
+`;
+var LUDO_CLIENT = `${BOOT}import { ludo, runCanvasGame, StatusLine } from "@cimplify/sdk/game/kit/canvas";
+
+const COPY = { yourTurn: "Your turn in Ludo", waiting: "Waiting for the others", won: "You won Ludo", finished: "Game over" };
+const SEED_RANGE = 0x3fffffff;
+
+export default async function main(ctx: Ctx): Promise<void> {
+  const seed = Math.floor(ctx.random.cosmetic() * SEED_RANGE);
+  const scene = new ludo.LudoScene({ seats: 4, seed, status: new StatusLine(ctx.program), copy: COPY });
+  await runCanvasGame(ctx, { scene });
+}
+`;
+var WORD_CLIENT = `${BOOT}import { dayIndex, firstFrame, newStreak, openSaveSlots, parseStreak, recordPlay, runCanvasGame, StatusLine, streakStatus, utcOffsetMinutes, word } from "@cimplify/sdk/game/kit/canvas";
+
+const COPY = { atRisk: (days: number) => "Keep your " + days + " day word streak" };
+
+export default async function main(ctx: Ctx): Promise<void> {
+  const launched = firstFrame();
+  const status = new StatusLine(ctx.program);
+  const today = (): number => dayIndex(ctx.clock.now(), utcOffsetMinutes(ctx.locale.time_zone, ctx.clock.now()));
+  const streaks = launched.reached.then(async () => {
+    const slots = await openSaveSlots(ctx, { name: "word-streak", version: 1, initial: () => newStreak(1), parse: parseStreak });
+    const streak = (await slots.load("streak")).value;
+    const nudge = streakStatus(streak, today(), COPY);
+    if (nudge !== null) void status.set(nudge);
+    return { slots, streak };
+  });
+  const scene = new word.WordPuzzle({
+    roundEnded(won) {
+      if (!won) return;
+      void streaks.then(({ slots, streak }) => {
+        recordPlay(streak, today());
+        void status.clear();
+        void slots.save("streak", streak);
+      });
+    },
+  });
+  await runCanvasGame(ctx, { scene, onFrame: launched.onFrame });
+}
+`;
+var TYCOON_CLIENT = `${BOOT}import { Autosave, defineEconomy, firstFrame, Ledger, openSaveSlots, runCanvasGame, tycoon } from "@cimplify/sdk/game/kit/canvas";
+
+export default async function main(ctx: Ctx): Promise<void> {
+  const ledger = new Ledger(defineEconomy(tycoon.tycoonEconomy), { economy: ctx.game.economy, keys: ctx.id });
+  const scene = new tycoon.JollofTycoon((costs) => new tycoon.LedgerTycoonBank(ledger, costs));
+  let autosave: Autosave<tycoon.TycoonSave> | null = null;
+  const launched = firstFrame(() => autosave?.markDirty());
+  void launched.reached.then(async () => {
+    await ledger.refresh();
+    const slots = await openSaveSlots(ctx, tycoon.tycoonSaveSchema);
+    scene.restore((await slots.load("main")).value, ctx.clock.now());
+    autosave = new Autosave(slots, "main", () => scene.snapshot(ctx.clock.now()), ctx.lifecycle);
+  });
+  ctx.on_dispose(() => autosave?.dispose());
+  await runCanvasGame(ctx, { scene, onFrame: launched.onFrame });
+}
+`;
+var DANFO_CLIENT = `${BOOT}import { danfo, runCanvasGame } from "@cimplify/sdk/game/kit/canvas";
+
+export default async function main(ctx: Ctx): Promise<void> {
+  const art = await danfo.takeDanfoArt(ctx.assets);
+  const scene = new danfo.DanfoRoute(null, art);
+  await runCanvasGame(ctx, { scene });
+}
+`;
+var COURIER_CLIENT = `${BOOT}import { courier, runCanvasGame } from "@cimplify/sdk/game/kit/canvas";
+
+export default async function main(ctx: Ctx): Promise<void> {
+  await runCanvasGame(ctx, { scene: new courier.CourierPlaza() });
+}
+`;
+function kitGame(game2) {
+  return {
+    description: game2.description,
+    category: "games",
+    profile: "canvas",
+    game: true,
+    capabilities: game2.capabilities ?? {},
+    economy: game2.economy ? economyToml(economyManifest(defineEconomy(game2.economy))) : null,
+    minDeviceTier: game2.minDeviceTier,
+    engineFeatures: game2.engineFeatures,
+    suggestedContent: game2.suggestedContent,
+    files: [
+      { path: "src/client.ts", content: game2.client },
+      { path: "src/conformance.ts", content: conformance(game2) },
+      { path: "tests/game.test.ts", content: test(game2) }
+    ]
+  };
+}
+var KIT_GAME_TEMPLATES = {
+  shootout: kitGame({
+    description: "Five penalties against the keeper, then challenge your friends",
+    module: "shootout",
+    minDeviceTier: "mid",
+    engineFeatures: PENALTY_FEATURES,
+    template: "penaltyShootoutTemplate",
+    client: SHOOTOUT_CLIENT,
+    testTitle: "penalty shootout",
+    testFrames: 60 * 60,
+    testProgress: 5,
+    capabilities: {
+      identity: "Puts your name on the leaderboard",
+      counter: "Keeps the best series leaderboard",
+      social: "Lets you share a perfect series",
+      "game.economy": "Keeps your tokens and kits safe",
+      wallet: "Lets you buy stars with Cimples"
+    },
+    economy: shootout.shootoutEconomy
+  }),
+  runner: kitGame({
+    description: "Dodge, jump and collect coins for as long as you can",
+    module: "runner",
+    engineFeatures: BOX_SCENE_FEATURES,
+    template: "endlessRunnerTemplate",
+    client: RUNNER_CLIENT,
+    testTitle: "endless runner",
+    testFrames: 60 * 40,
+    testProgress: 250,
+    capabilities: { identity: "Puts your name on the leaderboard", counter: "Keeps the distance leaderboard", "game.economy": "Banks the coins you collect" },
+    economy: runner.runnerEconomy
+  }),
+  "five-a-side": kitGame({
+    description: "Fast five-a-side football against the computer",
+    module: "fiveASide",
+    engineFeatures: BOX_SCENE_FEATURES,
+    template: "fiveASideTemplate",
+    client: FIVE_A_SIDE_CLIENT,
+    testTitle: "five-a-side",
+    testFrames: 60 * 120,
+    testProgress: 2
+  }),
+  ludo: kitGame({
+    description: "Ludo for four, with your turn shown in your chats",
+    module: "ludo",
+    engineFeatures: BOX_SCENE_FEATURES,
+    template: "ludoTemplate",
+    client: LUDO_CLIENT,
+    testTitle: "ludo",
+    testFrames: 60 * 90,
+    testProgress: 4,
+    capabilities: { program: "Shows when it is your turn" }
+  }),
+  word: kitGame({
+    description: "Guess the five-letter word in six tries and keep your streak",
+    module: "word",
+    engineFeatures: BOX_SCENE_FEATURES,
+    template: "wordPuzzleTemplate",
+    client: WORD_CLIENT,
+    testTitle: "word puzzle",
+    testFrames: 60 * 60,
+    testProgress: 3,
+    capabilities: { store: "Remembers your streak", program: "Reminds you to keep your streak" }
+  }),
+  tycoon: kitGame({
+    description: "Grow a jollof empire from a single roadside pot",
+    module: "tycoon",
+    engineFeatures: BOX_SCENE_FEATURES,
+    template: "jollofTycoonTemplate",
+    client: TYCOON_CLIENT,
+    testTitle: "jollof tycoon",
+    testFrames: 60 * 120,
+    testProgress: 500,
+    capabilities: { store: "Saves your empire", "game.economy": "Keeps your coins safe", wallet: "Lets you buy gems with Cimples" },
+    economy: tycoon.tycoonEconomy
+  }),
+  danfo: kitGame({
+    description: "Drive a yellow danfo around a city loop, stop for passengers at Ridgeway Junction, Palm Market, Harbour Gate, Old Mill and Sunrise Estate, and count your fares",
+    module: "danfo",
+    minDeviceTier: "mid",
+    engineFeatures: DRIVING_FEATURES,
+    suggestedContent: DANFO_CONTENT,
+    template: "danfoRouteTemplate",
+    client: DANFO_CLIENT,
+    testTitle: "danfo route",
+    testFrames: 60 * 90,
+    testProgress: 600
+  }),
+  courier: kitGame({
+    description: "Run parcels round a plaza in third person with touch sticks, jumps and a camera that never clips",
+    module: "courier",
+    engineFeatures: PENALTY_FEATURES,
+    template: "courierTemplate",
+    client: COURIER_CLIENT,
+    testTitle: "courier",
+    testFrames: 60 * 60,
+    testProgress: 3
+  })
+};
+
+// src/interactives/templates/native.ts
+var BLANK_CLIENT = `import type { Ctx, UiNode } from "@cimplify/sdk/interactives";
+
+export function view(name: string): UiNode {
+  return {
+    type: "Card",
+    props: { title: "__TITLE__" },
+    children: [
+      { type: "TextContent", props: { text: "Hello, " + name, size: "title" } },
+      { type: "TextContent", props: { text: "Edit src/client.ts and save to reload.", size: "caption" } },
+    ],
+  };
+}
+
+export default async function main(ctx: Ctx): Promise<void> {
+  const persona = await ctx.identity.current();
+  ctx.ui.render(view(persona.display_name));
+}
+`;
+var BLANK_TEST = `import { describe, expect, it } from "vitest";
+import { view } from "../src/client";
+
+describe("view", () => {
+  it("greets the player by name", () => {
+    expect(JSON.stringify(view("Ama"))).toContain("Hello, Ama");
+  });
+});
+`;
+var QUIZ_CLIENT = `import type { BoundValue, Ctx, UiNode } from "@cimplify/sdk/interactives";
+
+export interface Question {
+  readonly prompt: string;
+  readonly options: readonly string[];
+  readonly answer: number;
+}
+
+export const QUESTIONS: readonly Question[] = [
+  { prompt: "Which planet is closest to the sun?", options: ["Venus", "Mercury", "Mars"], answer: 1 },
+  { prompt: "How many sides does a hexagon have?", options: ["5", "6", "8"], answer: 1 },
+  { prompt: "What is the capital of Ghana?", options: ["Kumasi", "Tamale", "Accra"], answer: 2 },
+];
+
+export const ANSWER_ACTION = "answer";
+export const QUESTION_FORM = "question";
+const ANSWER_BINDING = "answer";
+
+export function answerOf(values: readonly BoundValue[] | null | undefined): string | null {
+  if (!values) return null;
+  for (const bound of values) {
+    if (bound.binding === ANSWER_BINDING) return typeof bound.value === "string" ? bound.value : null;
+  }
+  return null;
+}
+
+export function scoreView(score: number, answered: number): UiNode {
+  return {
+    type: "Card",
+    props: { title: "__TITLE__" },
+    children: [
+      { type: "Stat", props: { label: "Score", value: score + " of " + QUESTIONS.length } },
+      { type: "Progress", props: { value: answered / QUESTIONS.length } },
+    ],
+  };
+}
+
+export function questionView(index: number, score: number): UiNode {
+  const q = QUESTIONS[index];
+  return {
+    type: "Stack",
+    children: [
+      scoreView(score, index),
+      {
+        type: "Form",
+        key: QUESTION_FORM,
+        props: {
+          title: "Question " + (index + 1) + " of " + QUESTIONS.length,
+          submitLabel: "Answer",
+          submit: "action:" + ANSWER_ACTION,
+        },
+        children: [
+          { type: "TextContent", props: { text: q.prompt, size: "title" } },
+          { type: "Choice", props: { label: "Your answer", value: "$" + ANSWER_BINDING, options: q.options } },
+        ],
+      },
+    ],
+  };
+}
+
+export default async function main(ctx: Ctx): Promise<void> {
+  let index = 0;
+  let score = 0;
+  ctx.ui.render(questionView(index, score));
+  const stop = ctx.ui.on_event((event) => {
+    if (event.action !== ANSWER_ACTION || event.trigger !== "submit") return;
+    const q = QUESTIONS[index];
+    if (answerOf(event.values) === q.options[q.answer]) score++;
+    index++;
+    if (index < QUESTIONS.length) {
+      ctx.ui.render(questionView(index, score));
+      return;
+    }
+    stop();
+    ctx.ui.render(scoreView(score, QUESTIONS.length));
+    ctx.ui.toast(score === QUESTIONS.length ? "Perfect score" : "Thanks for playing");
+  });
+  ctx.on_dispose(stop);
+}
+`;
+var QUIZ_TEST = `import { createSimulatorCtx, type UiNode } from "@cimplify/sdk/interactives";
+import { describe, expect, it } from "vitest";
+import main, { ANSWER_ACTION, QUESTION_FORM, QUESTIONS } from "../src/client";
+
+describe("quiz", () => {
+  it("scores a perfect run", async () => {
+    const trees: UiNode[] = [];
+    const sim = createSimulatorCtx({
+      profile: "native",
+      host: { render: (tree) => trees.push(tree), toast: () => {} },
+    });
+    await main(sim.ctx);
+    for (const q of QUESTIONS) {
+      sim.dispatch({
+        kind: "action",
+        action: ANSWER_ACTION,
+        element: QUESTION_FORM,
+        trigger: "submit",
+        values: [{ binding: "answer", value: q.options[q.answer] }],
+      });
+    }
+    expect(JSON.stringify(trees[trees.length - 1])).toContain(QUESTIONS.length + " of " + QUESTIONS.length);
+  });
+});
+`;
+var ORDERING_CLIENT = `import type { BoundValue, Ctx, UiNode } from "@cimplify/sdk/interactives";
+
+export interface MenuItem {
+  readonly id: string;
+  readonly name: string;
+  readonly priceMinor: number;
+}
+
+export const MENU: readonly MenuItem[] = [
+  { id: "jollof", name: "Jollof rice", priceMinor: 4500 },
+  { id: "waakye", name: "Waakye", priceMinor: 3500 },
+  { id: "kelewele", name: "Kelewele", priceMinor: 1500 },
+];
+
+export const ORDER_ACTION = "order";
+const MENU_FORM = "menu";
+const QUANTITY_PREFIX = "qty_";
+const MINOR_UNITS = 100;
+const MAX_QUANTITY = 9;
+
+function menuIndex(binding: string): number {
+  if (!binding.startsWith(QUANTITY_PREFIX)) return -1;
+  for (let i = 0; i < MENU.length; i++) {
+    if (binding.length === QUANTITY_PREFIX.length + MENU[i].id.length && binding.endsWith(MENU[i].id)) return i;
+  }
+  return -1;
+}
+
+export function quantities(values: readonly BoundValue[] | null | undefined): Int32Array {
+  const out = new Int32Array(MENU.length);
+  if (!values) return out;
+  for (const bound of values) {
+    const index = menuIndex(bound.binding);
+    const q = bound.value;
+    if (index >= 0 && typeof q === "number" && Number.isInteger(q) && q > 0) out[index] = Math.min(q, MAX_QUANTITY);
+  }
+  return out;
+}
+
+export function totalMinor(counts: Int32Array): number {
+  let total = 0;
+  for (let i = 0; i < MENU.length; i++) total += counts[i] * MENU[i].priceMinor;
+  return total;
+}
+
+function menuForm(): UiNode {
+  return {
+    type: "Form",
+    key: MENU_FORM,
+    props: {
+      title: "__TITLE__",
+      subtitle: "Choose what you would like",
+      submitLabel: "Review order",
+      submit: "action:" + ORDER_ACTION,
+    },
+    children: MENU.map((item) => ({
+      type: "Stepper",
+      props: { label: item.name, value: "$" + QUANTITY_PREFIX + item.id, min: 0, max: MAX_QUANTITY },
+    })),
+  };
+}
+
+function summary(ctx: Ctx, counts: Int32Array): UiNode {
+  const rows: UiNode[] = [];
+  for (let i = 0; i < MENU.length; i++) {
+    if (counts[i] === 0) continue;
+    rows.push({ type: "KeyValue", props: { label: counts[i] + " x " + MENU[i].name, value: ctx.locale.format_money((counts[i] * MENU[i].priceMinor / MINOR_UNITS).toFixed(2)) } });
+  }
+  rows.push({ type: "Divider" });
+  rows.push({ type: "KeyValue", props: { label: "Total", value: ctx.locale.format_money((totalMinor(counts) / MINOR_UNITS).toFixed(2)) } });
+  return { type: "Card", props: { title: "Your order" }, children: rows };
+}
+
+export default async function main(ctx: Ctx): Promise<void> {
+  ctx.ui.render(menuForm());
+  const stop = ctx.ui.on_event((event) => {
+    if (event.action !== ORDER_ACTION || event.trigger !== "submit") return;
+    stop();
+    ctx.ui.render(summary(ctx, quantities(event.values)));
+  });
+  ctx.on_dispose(stop);
+}
+`;
+var ORDERING_TEST = `import { describe, expect, it } from "vitest";
+import { quantities, totalMinor } from "../src/client";
+
+describe("ordering", () => {
+  it("totals the chosen quantities in minor units", () => {
+    const counts = quantities([
+      { binding: "qty_jollof", value: 2 },
+      { binding: "qty_kelewele", value: 1 },
+      { binding: "qty_waakye", value: -3 },
+      { binding: "note", value: 4 },
+    ]);
+    expect(Array.from(counts)).toEqual([2, 0, 1]);
+    expect(totalMinor(counts)).toBe(10500);
+  });
+});
+`;
+var BOOKING_CLIENT = `import type { BoundValue, Ctx, UiNode } from "@cimplify/sdk/interactives";
+
+export const SLOTS: readonly { readonly value: string; readonly label: string; readonly available: boolean }[] = [
+  { value: "09:00", label: "9:00 am", available: true },
+  { value: "11:00", label: "11:00 am", available: true },
+  { value: "14:00", label: "2:00 pm", available: false },
+  { value: "16:00", label: "4:00 pm", available: true },
+];
+
+export interface Booking {
+  readonly slot: string;
+  readonly party: number;
+}
+
+export const BOOK_ACTION = "book";
+const BOOKING_FORM = "booking";
+
+export function fieldsOf(values: readonly BoundValue[] | null | undefined): Readonly<Record<string, unknown>> {
+  const fields: Record<string, unknown> = {};
+  if (values) for (const bound of values) fields[bound.binding] = bound.value;
+  return fields;
+}
+
+export function bookingOf(value: unknown): Booking | null {
+  if (typeof value !== "object" || value === null) return null;
+  const record = value as Readonly<Record<string, unknown>>;
+  const slot = record.slot;
+  const party = record.party;
+  if (typeof slot !== "string" || typeof party !== "number") return null;
+  if (!SLOTS.some((s) => s.value === slot && s.available)) return null;
+  return { slot, party };
+}
+
+function bookingForm(): UiNode {
+  return {
+    type: "Form",
+    key: BOOKING_FORM,
+    props: { title: "__TITLE__", subtitle: "Book a table", submitLabel: "Book", submit: "action:" + BOOK_ACTION },
+    children: [
+      { type: "Select", props: { label: "Time", value: "$slot", options: SLOTS, title: "Pick a time" } },
+      { type: "Stepper", props: { label: "Guests", value: "$party", min: 1, max: 8 } },
+    ],
+  };
+}
+
+function confirmation(booking: Booking): UiNode {
+  return {
+    type: "Card",
+    props: { title: "Booked" },
+    children: [
+      { type: "KeyValue", props: { label: "Time", value: booking.slot } },
+      { type: "KeyValue", props: { label: "Guests", value: String(booking.party) } },
+    ],
+  };
+}
+
+export default async function main(ctx: Ctx): Promise<void> {
+  const store = await ctx.open_store({ name: "bookings", scope: "personal", classification: "personal", schema: { name: "booking", version: 1 } });
+  const saved = bookingOf((await store.get({ key: "latest" })).value);
+  if (saved) {
+    ctx.ui.render(confirmation(saved));
+    return;
+  }
+  ctx.ui.render(bookingForm());
+  let saving = false;
+  const stop = ctx.ui.on_event((event) => {
+    if (saving || event.action !== BOOK_ACTION || event.trigger !== "submit") return;
+    const booking = bookingOf(fieldsOf(event.values));
+    if (!booking) {
+      ctx.ui.toast("Choose an available time");
+      return;
+    }
+    saving = true;
+    store.commit({ writes: [{ key: "latest", op: "put", value: booking }] }).then(
+      () => {
+        stop();
+        ctx.ui.render(confirmation(booking));
+      },
+      () => {
+        saving = false;
+        ctx.ui.toast("Your booking was not saved, try again");
+      },
+    );
+  });
+  ctx.on_dispose(stop);
+}
+`;
+var BOOKING_TEST = `import { describe, expect, it } from "vitest";
+import { bookingOf, fieldsOf } from "../src/client";
+
+describe("booking", () => {
+  it("accepts an available slot and refuses a full one", () => {
+    const party = { binding: "party", value: 2 };
+    expect(bookingOf(fieldsOf([{ binding: "slot", value: "09:00" }, party]))).toEqual({ slot: "09:00", party: 2 });
+    expect(bookingOf(fieldsOf([{ binding: "slot", value: "14:00" }, party]))).toBeNull();
+    expect(bookingOf(fieldsOf(null))).toBeNull();
+  });
+});
+`;
+var NATIVE_TEMPLATES = {
+  blank: {
+    description: "A blank Interactive",
+    category: "everyday",
+    profile: "native",
+    game: false,
+    capabilities: { identity: "Greets you by your display name" },
+    files: [
+      { path: "src/client.ts", content: BLANK_CLIENT },
+      { path: "tests/client.test.ts", content: BLANK_TEST }
+    ]
+  },
+  quiz: {
+    description: "A three question quiz",
+    category: "games",
+    profile: "native",
+    game: false,
+    capabilities: {},
+    files: [
+      { path: "src/client.ts", content: QUIZ_CLIENT },
+      { path: "tests/client.test.ts", content: QUIZ_TEST }
+    ]
+  },
+  ordering: {
+    description: "Pick dishes from a menu and see your total",
+    category: "everyday",
+    profile: "native",
+    game: false,
+    capabilities: {},
+    files: [
+      { path: "src/client.ts", content: ORDERING_CLIENT },
+      { path: "tests/client.test.ts", content: ORDERING_TEST }
+    ]
+  },
+  booking: {
+    description: "Book a table at a time that suits you",
+    category: "everyday",
+    profile: "native",
+    game: false,
+    capabilities: { store: "Remembers your booking" },
+    files: [
+      { path: "src/client.ts", content: BOOKING_CLIENT },
+      { path: "tests/client.test.ts", content: BOOKING_TEST }
+    ]
+  }
+};
+
+// src/interactives/templates/index.ts
+var TEMPLATE_NAMES = [
+  "blank",
+  "quiz",
+  "ordering",
+  "booking",
+  "racing",
+  "sport",
+  "board",
+  "tycoon",
+  "shootout",
+  "runner",
+  "five-a-side",
+  "ludo",
+  "word",
+  "danfo",
+  "courier",
+  "frontier",
+  "genesis",
+  "chemistry",
+  ...ENGINE_TEMPLATE_NAMES
+];
+var TEMPLATES = {
+  blank: NATIVE_TEMPLATES.blank,
+  quiz: NATIVE_TEMPLATES.quiz,
+  ordering: NATIVE_TEMPLATES.ordering,
+  booking: NATIVE_TEMPLATES.booking,
+  racing: GAME_TEMPLATES.racing,
+  sport: GAME_TEMPLATES.sport,
+  board: GAME_TEMPLATES.board,
+  tycoon: KIT_GAME_TEMPLATES.tycoon,
+  shootout: KIT_GAME_TEMPLATES.shootout,
+  runner: KIT_GAME_TEMPLATES.runner,
+  "five-a-side": KIT_GAME_TEMPLATES["five-a-side"],
+  ludo: KIT_GAME_TEMPLATES.ludo,
+  word: KIT_GAME_TEMPLATES.word,
+  danfo: KIT_GAME_TEMPLATES.danfo,
+  courier: KIT_GAME_TEMPLATES.courier,
+  frontier: FRONTIER_TEMPLATE,
+  genesis: GENESIS_TEMPLATE,
+  chemistry: CHEMISTRY_TEMPLATE
+};
+function isTemplateName(value) {
+  return TEMPLATE_NAMES.indexOf(value) >= 0;
+}
+function suggestedContent(template) {
+  if (isEngineTemplate(template)) return [];
+  return TEMPLATES[template].suggestedContent ?? [];
+}
+function renderTemplate(template, projectName) {
+  if (isEngineTemplate(template)) return renderEngineTemplate(template, projectName);
+  const spec = TEMPLATES[template];
+  return [...materialize(projectName, spec), { path: AGENTS_FILE, content: agentsGuide(titleFromName(projectName), spec.profile) }];
+}
+
+// src/interactives/commands/create.ts
+var PROJECT_NAME = /^[a-z][a-z0-9-]{0,62}$/;
+var DEFAULT_TEMPLATE = "blank";
+async function createProject(parent, name, template) {
+  if (!PROJECT_NAME.test(name)) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `'${name}' is not a valid project name; use lowercase letters, digits and dashes`);
+  }
+  const dir = path.join(parent, name);
+  let existing = [];
+  try {
+    existing = await promises.readdir(dir);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  if (existing.length > 0) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${dir} already exists and is not empty`);
+  const files = renderTemplate(template, name);
+  for (const file of files) {
+    const target = path.join(dir, ...file.path.split("/"));
+    await promises.mkdir(path.dirname(target), { recursive: true });
+    await promises.writeFile(target, file.content);
+  }
+  return { dir, template, files: files.map((f) => f.path), suggestedContent: suggestedContent(template) };
+}
+function parseTemplate(value) {
+  if (value === void 0) return DEFAULT_TEMPLATE;
+  if (!isTemplateName(value)) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `unknown template '${value}'; choose one of ${TEMPLATE_NAMES.join(", ")}`);
+  }
+  return value;
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const name = args.positional[0];
+  if (!name) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `usage: cimplify create <name> --template <${TEMPLATE_NAMES.join("|")}>`);
+  }
+  const created = await createProject(process.cwd(), name, parseTemplate(flagString(args, "template")));
+  success(`Created ${name} from the ${created.template} template`);
+  if (!flagBool(args, "no-install")) {
+    const install = spawnSync("bun", ["install"], { cwd: created.dir, stdio: "inherit" });
+    if (install.status !== 0) warn("bun install failed; run it in the project folder");
+  }
+  info("");
+  info(`  cd ${name}`);
+  if (created.suggestedContent.length > 0) {
+    info(`  cimplify add ${created.suggestedContent.join(" ")}   ${dim("use the Workshop art; the game runs on primitives until you do")}`);
+  }
+  info(`  cimplify dev       ${dim("run it in the local simulator")}`);
+  info(`  cimplify test      ${dim("run tests and the publication gates")}`);
+  info(`  cimplify publish   ${dim("upload the source for a server build")}`);
+  result(created);
+}
+
+export { TEMPLATE_NAMES, agentsGuide, createProject, parseTemplate, run };