@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-NMQT4HG3.mjs

@@ -0,0 +1,757 @@
+import { DEFAULT_THEME } from './chunk-RFVRPYR2.mjs';
+import { sha256Into } from './chunk-5YWN6H5Q.mjs';
+import { LAUNCH_FILES, LAUNCH_ITEMS, LAUNCH_RIG } from './chunk-JKGTBMU7.mjs';
+
+// src/game/kit/slots/types.ts
+var TemplateSlotError = class extends Error {
+  constructor(issues) {
+    super(issues.map(describeIssue).join("; ")), this.name = "TemplateSlotError", this.issues = issues;
+  }
+};
+function describeIssue(issue) {
+  return `${issue.path === "" ? `slot "${issue.slot}"` : `slot "${issue.slot}" at ${issue.path}`}: ${issue.reason}`;
+}
+
+// src/game/kit/slots/slots.ts
+var Theme = Object.freeze({ kind: "theme", textContrast: 4.5, accentContrast: 3 });
+function Palette(keys) {
+  return Object.freeze({ kind: "palette", keys: Object.freeze([...keys]) });
+}
+function Character(requirements) {
+  return Object.freeze({ kind: "character", rig: requirements.rig, clips: Object.freeze([...requirements.clips]) });
+}
+function SceneSlot(scene, requirements) {
+  return Object.freeze({ kind: "scene", scene, anchors: Object.freeze({ ...requirements.anchors }), spans: Object.freeze([...requirements.spans ?? []]) });
+}
+function Track(requirements) {
+  return Object.freeze(requirements.bpm === void 0 ? { kind: "track", seconds: requirements.seconds, loop: requirements.loop } : { kind: "track", seconds: requirements.seconds, loop: requirements.loop, bpm: requirements.bpm });
+}
+function Params(fields) {
+  return Object.freeze({ kind: "params", fields: Object.freeze({ ...fields }) });
+}
+function Int(min, max) {
+  return { type: "int", min, max };
+}
+function Num(min, max) {
+  return { type: "number", min, max };
+}
+function Bool() {
+  return { type: "boolean" };
+}
+function Choice(...options) {
+  return { type: "choice", options };
+}
+function anchors(min, max = min, size = {}) {
+  return { min, max, ...size };
+}
+
+// src/game/kit/slots/check.ts
+var THEME_COLORS = ["surface", "raised", "border", "accent", "on_accent", "text", "muted", "track", "danger", "success", "gold"], THEME_SIZES = ["radius", "padding", "gap", "small", "body", "title", "press_scale", "motion"], HEX_SHORT = 7, HEX_PATTERN = /^#(?:[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, BYTE = 255, RGB_MAX = 16777215, RGBA_MAX = 4294967295, BYTE_SHIFT_RED = 16, BYTE_SHIFT_GREEN = 8, SRGB_KNEE = 0.04045, SRGB_LINEAR_SCALE = 12.92, SRGB_OFFSET = 0.055, SRGB_SCALE = 1.055, SRGB_GAMMA = 2.4, LUMA_R = 0.2126, LUMA_G = 0.7152, LUMA_B = 0.0722, CONTRAST_FLARE = 0.05, DECIMALS = 100, ANCHOR_AXES = 3, SIZE_AXES = 2, MAX_ID_LENGTH = 128;
+function isRecord(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+function fmt(value) {
+  return String(Math.round(value * (100)) / (100));
+}
+function range(r, unit = "") {
+  return `${fmt(r[0])}${unit} to ${fmt(r[1])}${unit}`;
+}
+function within(value, r) {
+  return value >= r[0] && value <= r[1];
+}
+function list(items) {
+  return items.join(", ");
+}
+function parseColor(value) {
+  if (typeof value == "string") {
+    if (!HEX_PATTERN.test(value)) return null;
+    let hex2 = value.slice(1, (7)), n = Number.parseInt(hex2, 16);
+    return [(n >> (16) & (255)) / (255), (n >> (8) & (255)) / (255), (n & (255)) / (255)];
+  }
+  if (typeof value == "number") {
+    if (!Number.isInteger(value) || value < 0 || value > (4294967295)) return null;
+    let n = value > (16777215) ? value >>> (8) : value;
+    return [(n >> (16) & (255)) / (255), (n >> (8) & (255)) / (255), (n & (255)) / (255)];
+  }
+  return Array.isArray(value) && value.length === (3) && value.every((c) => typeof c == "number" && c >= 0 && c <= 1) ? [value[0], value[1], value[2]] : null;
+}
+function colorInt(value) {
+  let rgb = parseColor(value);
+  if (rgb === null) throw new RangeError(colorReason(value));
+  return Math.round(rgb[0] * (255)) << (16) | Math.round(rgb[1] * (255)) << (8) | Math.round(rgb[2] * (255));
+}
+function channel(c) {
+  return c <= (0.04045) ? c / (12.92) : ((c + (0.055)) / (1.055)) ** (2.4);
+}
+function luminance(rgb) {
+  return (0.2126) * channel(rgb[0]) + (0.7152) * channel(rgb[1]) + (0.0722) * channel(rgb[2]);
+}
+function contrastRatio(a, b) {
+  let la = luminance(a), lb = luminance(b);
+  return (Math.max(la, lb) + (0.05)) / (Math.min(la, lb) + (0.05));
+}
+function colorReason(value) {
+  return `${JSON.stringify(value)} is not a colour (use #rrggbb, #rrggbbaa or [r, g, b] from 0 to 1)`;
+}
+var Issues = class {
+  constructor(slot) {
+    this.slot = slot;
+    this.list = [];
+  }
+  add(path, reason) {
+    this.list.push({ slot: this.slot, path, reason });
+  }
+};
+function checkId(value, issues) {
+  let id = value.id;
+  return typeof id != "string" || id.length === 0 || id.length > (128) ? (issues.add("id", `needs an id of 1 to ${(128)} characters`), null) : id;
+}
+function rejectUnknown(value, known, issues, what) {
+  for (let key of Object.keys(value)) known.includes(key) || issues.add(key, `${what} has no ${key} (it takes ${list(known)})`);
+}
+function checkTheme(slot, value, issues) {
+  if (!isRecord(value))
+    return issues.add("", "a theme is an object of game theme values"), null;
+  let known = Object.keys(DEFAULT_THEME);
+  rejectUnknown(value, known, issues, "a game theme");
+  let merged = { ...DEFAULT_THEME, ...value };
+  for (let key of THEME_COLORS) parseColor(merged[key]) === null && issues.add(key, colorReason(merged[key]));
+  for (let key of THEME_SIZES) {
+    let n = merged[key];
+    (typeof n != "number" || !Number.isFinite(n) || n < 0) && issues.add(key, `${JSON.stringify(n)} is not a size of zero or more`);
+  }
+  if ((!Number.isInteger(merged.font) || merged.font < 0) && issues.add("font", `${JSON.stringify(merged.font)} is not a font handle`), merged.panel !== null && !isRecord(merged.panel) && issues.add("panel", "a panel is a nine slice or null"), issues.list.length > 0) return null;
+  let text = contrastRatio(parseColor(merged.text), parseColor(merged.surface));
+  text < slot.textContrast && issues.add("text", `text on surface has contrast ${fmt(text)}:1; the template needs at least ${fmt(slot.textContrast)}:1 to stay readable`);
+  let accent = contrastRatio(parseColor(merged.on_accent), parseColor(merged.accent));
+  return accent < slot.accentContrast && issues.add("on_accent", `on_accent on accent has contrast ${fmt(accent)}:1; the template needs at least ${fmt(slot.accentContrast)}:1 for buttons`), issues.list.length > 0 ? null : merged;
+}
+function checkPalette(slot, value, issues) {
+  if (!isRecord(value))
+    return issues.add("", `a palette is an object of colours named ${list(slot.keys)}`), null;
+  rejectUnknown(value, slot.keys, issues, "this palette");
+  for (let key of slot.keys)
+    key in value ? parseColor(value[key]) === null && issues.add(key, colorReason(value[key])) : issues.add(key, `missing the ${key} colour`);
+  return issues.list.length > 0 ? null : value;
+}
+function stringList(value) {
+  return Array.isArray(value) && value.every((v) => typeof v == "string") ? value : null;
+}
+function checkCharacter(slot, value, issues) {
+  if (!isRecord(value))
+    return issues.add("", "a character is an object with an id, a rig and its animation clips"), null;
+  rejectUnknown(value, ["id", "rig", "clips", "model", "tint"], issues, "a character"), checkId(value, issues), value.rig !== slot.rig && issues.add("rig", `rig ${JSON.stringify(value.rig)} does not match the ${JSON.stringify(slot.rig)} skeleton the template animates`);
+  let clips = stringList(value.clips);
+  if (clips === null) issues.add("clips", "clips is a list of animation clip names");
+  else {
+    let missing = slot.clips.filter((c) => !clips.includes(c));
+    missing.length > 0 && issues.add("clips", `missing the ${list(missing)} clip${missing.length === 1 ? "" : "s"} the template plays`);
+  }
+  return value.model !== void 0 && typeof value.model != "string" && issues.add("model", "model is an asset path or content digest"), value.tint !== void 0 && parseColor(value.tint) === null && issues.add("tint", colorReason(value.tint)), issues.list.length > 0 ? null : value;
+}
+function isVec(value, axes) {
+  return Array.isArray(value) && value.length === axes && value.every((c) => typeof c == "number" && Number.isFinite(c));
+}
+function distance(a, b) {
+  return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+}
+function plural(count, noun) {
+  return `${count} ${noun} anchor${count === 1 ? "" : "s"}`;
+}
+function checkScene(slot, value, issues) {
+  if (!isRecord(value))
+    return issues.add("", "a scene is an object with an id, a kind and anchors"), null;
+  if (rejectUnknown(value, ["id", "kind", "anchors", "bounds"], issues, "a scene"), checkId(value, issues), value.kind !== slot.scene)
+    return issues.add("kind", `a ${JSON.stringify(value.kind)} scene does not fit; this slot takes a ${JSON.stringify(slot.scene)}`), null;
+  if (!Array.isArray(value.anchors))
+    return issues.add("anchors", "anchors is a list of { role, position }"), null;
+  let anchors2 = [];
+  value.anchors.forEach((raw, index) => {
+    let path = `anchors[${index}]`;
+    if (!isRecord(raw) || typeof raw.role != "string" || !isVec(raw.position, (3))) {
+      issues.add(path, "an anchor needs a role and a finite [x, y, z] position");
+      return;
+    }
+    if (raw.size !== void 0 && (!isVec(raw.size, (2)) || raw.size.some((s) => s < 0))) {
+      issues.add(`${path}.size`, "size is [width, height] in metres, zero or more");
+      return;
+    }
+    anchors2.push(raw);
+  });
+  let bounds = value.bounds;
+  if (bounds !== void 0)
+    if (!isRecord(bounds) || !isVec(bounds.min, (3)) || !isVec(bounds.max, (3))) issues.add("bounds", "bounds is { min: [x, y, z], max: [x, y, z] }");
+    else {
+      let min = bounds.min, max = bounds.max;
+      anchors2.forEach((a, index) => {
+        for (let axis = 0; axis < (3); axis++)
+          if (a.position[axis] < min[axis] || a.position[axis] > max[axis]) {
+            issues.add(`anchors[${index}]`, `the ${a.role} anchor sits outside the scene bounds`);
+            return;
+          }
+      });
+    }
+  for (let role of Object.keys(slot.anchors)) {
+    let rule = slot.anchors[role], matching = anchors2.filter((a) => a.role === role);
+    if (matching.length < rule.min || matching.length > rule.max) {
+      let need = rule.min === rule.max ? `${rule.min}` : rule.max === Number.MAX_SAFE_INTEGER ? `at least ${rule.min}` : `${rule.min} to ${rule.max}`;
+      issues.add("anchors", `has ${plural(matching.length, role)}; the template needs ${need}`);
+      continue;
+    }
+    matching.forEach((a, index) => {
+      if (!(rule.width === void 0 && rule.height === void 0)) {
+        if (a.size === void 0) {
+          issues.add("anchors", `${role} anchor ${index + 1} has no size; the template checks its width and height`);
+          return;
+        }
+        rule.width !== void 0 && !within(a.size[0], rule.width) && issues.add("anchors", `${role} anchor ${index + 1} is ${fmt(a.size[0])} m wide; the template needs ${range(rule.width, " m")}`), rule.height !== void 0 && !within(a.size[1], rule.height) && issues.add("anchors", `${role} anchor ${index + 1} is ${fmt(a.size[1])} m high; the template needs ${range(rule.height, " m")}`);
+      }
+    });
+  }
+  for (let span of slot.spans) {
+    let from = anchors2.filter((a) => a.role === span.from), to = anchors2.filter((a) => a.role === span.to), same = span.from === span.to;
+    for (let i = 0; i < from.length; i++) {
+      let a = from[i];
+      for (let j = same ? i + 1 : 0; j < to.length; j++) {
+        let b = to[j], d = distance(a.position, b.position);
+        if (!within(d, span.distance)) {
+          issues.add("anchors", `${span.from} to ${span.to} distance is ${fmt(d)} m; the template's rules are built for ${range(span.distance, " m")}`);
+          break;
+        }
+      }
+    }
+  }
+  return issues.list.length > 0 ? null : value;
+}
+function checkTrack(slot, value, issues) {
+  return isRecord(value) ? (rejectUnknown(value, ["id", "seconds", "loop", "bpm", "asset"], issues, "a track"), checkId(value, issues), typeof value.seconds != "number" || !Number.isFinite(value.seconds) ? issues.add("seconds", "seconds is the track length") : within(value.seconds, slot.seconds) || issues.add("seconds", `the track is ${fmt(value.seconds)} s long; the template needs ${range(slot.seconds, " s")}`), typeof value.loop != "boolean" ? issues.add("loop", "loop is true or false") : slot.loop && !value.loop && issues.add("loop", "the track does not loop; the template plays it under the whole game"), slot.bpm !== void 0 ? typeof value.bpm != "number" ? issues.add("bpm", `the template syncs to the beat and needs a bpm of ${range(slot.bpm)}`) : within(value.bpm, slot.bpm) || issues.add("bpm", `bpm ${fmt(value.bpm)} is outside the ${range(slot.bpm)} the template syncs to`) : value.bpm !== void 0 && (typeof value.bpm != "number" || value.bpm <= 0) && issues.add("bpm", "bpm is a positive number"), value.asset !== void 0 && typeof value.asset != "string" && issues.add("asset", "asset is an asset path or content digest"), issues.list.length > 0 ? null : value) : (issues.add("", "a track is an object with an id, seconds and loop"), null);
+}
+function checkField(name, field, value, issues) {
+  switch (field.type) {
+    case "int":
+      typeof value != "number" || !Number.isInteger(value) ? issues.add(name, `${JSON.stringify(value)} is not a whole number`) : within(value, [field.min, field.max]) || issues.add(name, `${value} is outside ${range([field.min, field.max])}`);
+      return;
+    case "number":
+      typeof value != "number" || !Number.isFinite(value) ? issues.add(name, `${JSON.stringify(value)} is not a number`) : within(value, [field.min, field.max]) || issues.add(name, `${fmt(value)} is outside ${range([field.min, field.max])}`);
+      return;
+    case "boolean":
+      typeof value != "boolean" && issues.add(name, `${JSON.stringify(value)} is not true or false`);
+      return;
+    case "choice":
+      (typeof value != "string" || !field.options.includes(value)) && issues.add(name, `${JSON.stringify(value)} is not one of ${list(field.options)}`);
+  }
+}
+function checkParams(slot, value, issues) {
+  if (!isRecord(value))
+    return issues.add("", `params are an object of ${list(Object.keys(slot.fields))}`), null;
+  let names = Object.keys(slot.fields);
+  rejectUnknown(value, names, issues, "these params");
+  for (let name of names)
+    name in value ? checkField(name, slot.fields[name], value[name], issues) : issues.add(name, `missing ${name}`);
+  return issues.list.length > 0 ? null : value;
+}
+function checkSlot(name, slot, value) {
+  let issues = new Issues(name), out;
+  switch (slot.kind) {
+    case "theme":
+      out = checkTheme(slot, value, issues);
+      break;
+    case "palette":
+      out = checkPalette(slot, value, issues);
+      break;
+    case "character":
+      out = checkCharacter(slot, value, issues);
+      break;
+    case "scene":
+      out = checkScene(slot, value, issues);
+      break;
+    case "track":
+      out = checkTrack(slot, value, issues);
+      break;
+    case "params":
+      out = checkParams(slot, value, issues);
+      break;
+  }
+  return { issues: issues.list, value: issues.list.length > 0 ? null : out ?? null };
+}
+function describeSlot(slot) {
+  switch (slot.kind) {
+    case "theme":
+      return "a game theme";
+    case "palette":
+      return `a palette of ${list(slot.keys)}`;
+    case "character":
+      return `a ${slot.rig} character with ${list(slot.clips)}`;
+    case "scene":
+      return `a ${slot.scene} scene with ${Object.keys(slot.anchors).join(", ")} anchors`;
+    case "track":
+      return `a ${slot.loop ? "looping " : ""}track of ${range(slot.seconds, " s")}`;
+    case "params":
+      return `params ${list(Object.keys(slot.fields))}`;
+  }
+}
+
+// src/game/kit/slots/presets.ts
+var THEME_PRESETS = Object.freeze({
+  default: {},
+  neon: {
+    surface: "#0a0a1ae6",
+    raised: "#1a1438ff",
+    border: "#ff2bd666",
+    accent: "#00f5d4ff",
+    on_accent: "#00140fff",
+    text: "#f8f7ffff",
+    muted: "#b8a9e6ff",
+    track: "#ffffff26",
+    danger: "#ff3b6bff",
+    success: "#39ff88ff",
+    gold: "#ffe600ff"
+  },
+  midnight: {
+    surface: "#0b1020e6",
+    raised: "#18213aff",
+    border: "#ffffff1a",
+    accent: "#5b8cffff",
+    on_accent: "#050a1aff",
+    text: "#eef2ffff",
+    muted: "#9aa6c8ff",
+    track: "#ffffff22",
+    danger: "#ff5c5cff",
+    success: "#4ade80ff",
+    gold: "#ffd166ff"
+  },
+  daylight: {
+    surface: "#f7f5efee",
+    raised: "#ffffffff",
+    border: "#1b1f2a1f",
+    accent: "#0f766eff",
+    on_accent: "#ffffffff",
+    text: "#141821ff",
+    muted: "#4d5566ff",
+    track: "#1b1f2a1f",
+    danger: "#c62828ff",
+    success: "#1b873fff",
+    gold: "#b7791fff"
+  }
+});
+
+// src/game/kit/slots/template.ts
+var TEMPLATE_SCHEMA_FORMAT = "cimplify.template/1", ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/, SLOT_NAME_PATTERN = /^[a-z][a-zA-Z0-9_]{0,31}$/, PRESET_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,47}$/;
+function templateRef(id, version) {
+  return `${id}@${version}`;
+}
+function slotPresets(t, slot) {
+  let own = t.presets[slot] ?? {};
+  return t.slots[slot]?.kind === "theme" ? { ...THEME_PRESETS, ...own } : own;
+}
+function template(definition) {
+  let issues = [], structural = (slot, reason) => {
+    issues.push({ slot, path: "", reason });
+  };
+  ID_PATTERN.test(definition.id) || structural("", `template id ${JSON.stringify(definition.id)} must be lowercase letters, digits and dashes`), (!Number.isInteger(definition.version) || definition.version < 1) && structural("", "template version is a whole number from 1");
+  let names = Object.keys(definition.slots), values = {};
+  for (let name of names) {
+    SLOT_NAME_PATTERN.test(name) || structural(name, "slot names start with a letter and use letters, digits and underscores");
+    let slot = definition.slots[name], check = checkSlot(name, slot, definition.defaults[name]);
+    issues.push(...check.issues.map((i) => ({ ...i, reason: `default ${i.reason}` }))), values[name] = check.value;
+  }
+  for (let name of Object.keys(definition.defaults)) name in definition.slots || structural(name, "has a default but no slot");
+  let presets = definition.presets ?? {};
+  for (let name of Object.keys(presets)) {
+    let slot = definition.slots[name];
+    if (slot === void 0) {
+      structural(name, "has presets but no slot");
+      continue;
+    }
+    let entries = presets[name] ?? {};
+    for (let preset of Object.keys(entries)) {
+      PRESET_NAME_PATTERN.test(preset) || structural(name, `preset name ${JSON.stringify(preset)} must be lowercase letters, digits and dashes`);
+      let check = checkSlot(name, slot, entries[preset]);
+      issues.push(...check.issues.map((i) => ({ ...i, reason: `preset ${preset}: ${i.reason}` })));
+    }
+  }
+  if (issues.length > 0) throw new TemplateSlotError(issues);
+  return Object.freeze({
+    id: definition.id,
+    version: definition.version,
+    title: definition.title,
+    ref: templateRef(definition.id, definition.version),
+    slots: definition.slots,
+    defaults: definition.defaults,
+    presets: definition.presets ?? {},
+    values: Object.freeze(values)
+  });
+}
+function json(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function templateSchema(t) {
+  let slots = {};
+  for (let name of Object.keys(t.slots)) slots[name] = json(t.slots[name]);
+  return {
+    format: TEMPLATE_SCHEMA_FORMAT,
+    id: t.id,
+    version: t.version,
+    title: t.title,
+    slots,
+    defaults: json(t.defaults),
+    presets: json(t.presets)
+  };
+}
+var SLOT_KINDS = ["theme", "palette", "character", "scene", "track", "params"];
+function templateFromSchema(schema) {
+  let raw = schema;
+  if (raw === null || typeof raw != "object" || raw.format !== TEMPLATE_SCHEMA_FORMAT)
+    throw new TemplateSlotError([{ slot: "", path: "", reason: `not a template schema (format must be ${TEMPLATE_SCHEMA_FORMAT})` }]);
+  let slots = raw.slots ?? {}, bad = Object.keys(slots).filter((name) => typeof slots[name] != "object" || slots[name] === null || !SLOT_KINDS.includes(String(slots[name].kind)));
+  if (bad.length > 0) throw new TemplateSlotError(bad.map((slot) => ({ slot, path: "kind", reason: `slot kind must be one of ${SLOT_KINDS.join(", ")}` })));
+  return template({
+    id: String(raw.id),
+    version: Number(raw.version),
+    title: String(raw.title ?? raw.id),
+    slots,
+    defaults: raw.defaults ?? {},
+    presets: raw.presets ?? {}
+  });
+}
+
+// src/game/kit/slots/catalog.ts
+var RUNNER_RIG = LAUNCH_RIG, RUNNER_CLIPS = ["run", "jump", "land", "stumble"], shootoutSlots = template({
+  id: "penalty-shootout",
+  version: 1,
+  title: "Penalty shootout",
+  slots: {
+    theme: Theme,
+    music: Track({ seconds: [20, 600], loop: true }),
+    rules: Params({ kicksPerSeries: Int(1, 10), seriesPauseSeconds: Num(0.5, 5) })
+  },
+  defaults: {
+    theme: {},
+    music: { id: "shootout-terrace", seconds: 90, loop: true },
+    rules: { kicksPerSeries: 5, seriesPauseSeconds: 1.5 }
+  },
+  presets: {
+    music: {
+      drums: { id: "shootout-drums", seconds: 48, loop: true, bpm: 120 },
+      anthem: { id: "shootout-anthem", seconds: 150, loop: true, bpm: 96 }
+    },
+    rules: {
+      "sudden-death": { kicksPerSeries: 1, seriesPauseSeconds: 1 },
+      marathon: { kicksPerSeries: 10, seriesPauseSeconds: 2 }
+    }
+  }
+}), runnerSlots = template({
+  id: "endless-runner",
+  version: 1,
+  title: "Endless runner",
+  slots: {
+    theme: Theme,
+    hero: Character({ rig: RUNNER_RIG, clips: RUNNER_CLIPS }),
+    music: Track({ seconds: [30, 600], loop: true, bpm: [80, 180] }),
+    rules: Params({ startSpeed: Num(4, 14), maxSpeed: Num(12, 30), jumpVelocity: Num(5.5, 10) })
+  },
+  defaults: {
+    theme: {},
+    hero: { id: "runner", rig: RUNNER_RIG, clips: RUNNER_CLIPS, tint: "#10b981" },
+    music: { id: "runner-groove", seconds: 96, loop: true, bpm: 128 },
+    rules: { startSpeed: 9, maxSpeed: 22, jumpVelocity: 7.5 }
+  },
+  presets: {
+    hero: {
+      sprinter: { id: "sprinter", rig: RUNNER_RIG, clips: RUNNER_CLIPS, tint: "#f97316" },
+      ghost: { id: "ghost", rig: RUNNER_RIG, clips: RUNNER_CLIPS, tint: "#a5b4fc" },
+      launch: { id: LAUNCH_ITEMS.baseCharacter, rig: RUNNER_RIG, clips: RUNNER_CLIPS, model: LAUNCH_FILES.baseCharacter }
+    },
+    music: {
+      chiptune: { id: "runner-chiptune", seconds: 64, loop: true, bpm: 150 },
+      calm: { id: "runner-calm", seconds: 120, loop: true, bpm: 90 }
+    },
+    rules: {
+      chill: { startSpeed: 6, maxSpeed: 14, jumpVelocity: 7.5 },
+      turbo: { startSpeed: 12, maxSpeed: 28, jumpVelocity: 8.5 }
+    }
+  }
+}), SLOT_TEMPLATES = Object.freeze({
+  [shootoutSlots.id]: shootoutSlots,
+  [runnerSlots.id]: runnerSlots
+});
+
+// src/game/kit/slots/scene-ir.ts
+var SOLVED = "solved", SceneReportError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "SceneReportError";
+  }
+};
+function slotSceneFromReport(kind, report, options = {}) {
+  if (report.version !== 1) throw new SceneReportError(`placement report version ${report.version} is not 1`);
+  if (report.status !== SOLVED) throw new SceneReportError(`scene ${report.scene} is ${report.status}; only a solved scene can fill a slot`);
+  let role = (name) => options.roles?.[name] ?? name, anchors2 = [], top = 0;
+  for (let p of report.placements) {
+    let meta = options.catalogue?.[p.kind];
+    top = Math.max(top, p.at[1] + (meta?.height ?? 0)), anchors2.push(meta === void 0 ? { role: role(p.group), position: p.at } : { role: role(p.group), position: p.at, size: [meta.footprint[0], meta.height] });
+  }
+  for (let [name, at] of Object.entries(options.points ?? {})) anchors2.push({ role: role(name), position: [at[0], 0, at[1]] });
+  let area = options.area;
+  return area === void 0 ? { id: report.scene, kind, anchors: anchors2 } : { id: report.scene, kind, anchors: anchors2, bounds: { min: [0, 0, 0], max: [area[0], top, area[1]] } };
+}
+
+// src/game/kit/slots/manifest.ts
+var REMIX_FORMAT = 1, DIGEST_PREFIX = "sha256:", INLINE_VALUE_BYTES = 256, MAX_REMIX_DEPTH = 64, SHA256_BYTES = 32, HEX_RADIX = 16, DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/, RemixError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "RemixError";
+  }
+}, ContentRef = class {
+  constructor(digest) {
+    this.digest = digest;
+    if (!DIGEST_PATTERN.test(digest)) throw new RemixError(`${JSON.stringify(digest)} is not a sha256 content digest`);
+  }
+};
+function slotContent(digest) {
+  return new ContentRef(digest);
+}
+function canonicalSlotJson(value) {
+  if (value === null || typeof value == "boolean" || typeof value == "string") return JSON.stringify(value);
+  if (typeof value == "number") {
+    if (!Number.isFinite(value)) throw new RemixError("a remix cannot hold a non-finite number");
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `[${value.map(canonicalSlotJson).join(",")}]`;
+  if (typeof value == "object") {
+    let record = value;
+    return `{${Object.keys(record).filter((k) => record[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonicalSlotJson(record[k])}`).join(",")}}`;
+  }
+  throw new RemixError(`a remix cannot hold a ${typeof value}`);
+}
+var encoder = new TextEncoder();
+function hex(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) out += bytes[i].toString((16)).padStart(2, "0");
+  return out;
+}
+function slotDigest(value) {
+  let out = new Uint8Array((32));
+  return sha256Into(encoder.encode(canonicalSlotJson(value)), out), DIGEST_PREFIX + hex(out);
+}
+function encodeRemix(manifest) {
+  return canonicalSlotJson(manifest);
+}
+function remixDigest(manifest) {
+  return slotDigest(manifest);
+}
+function isRecord2(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+function isSlotRef(value) {
+  if (typeof value == "string") return value.length > 0;
+  if (!isRecord2(value)) return false;
+  let keys = Object.keys(value);
+  return keys.length !== 1 ? false : keys[0] === "value" ? true : keys[0] === "content" && typeof value.content == "string" && DIGEST_PATTERN.test(value.content);
+}
+function decodeRemix(input) {
+  let raw = input;
+  if (typeof input == "string")
+    try {
+      raw = JSON.parse(input);
+    } catch {
+      throw new RemixError("a remix manifest is JSON");
+    }
+  if (!isRecord2(raw)) throw new RemixError("a remix manifest is a JSON object");
+  let extra = Object.keys(raw).filter((k) => !["remix", "template", "parent", "slots"].includes(k));
+  if (extra.length > 0) throw new RemixError(`a remix manifest has no ${extra.join(", ")}`);
+  if (raw.remix !== (1)) throw new RemixError(`unsupported remix format ${JSON.stringify(raw.remix)}; this SDK reads format ${(1)}`);
+  if (typeof raw.template != "string" || !raw.template.includes("@")) throw new RemixError("a remix names its template as id@version");
+  if (raw.parent !== null && (typeof raw.parent != "string" || !DIGEST_PATTERN.test(raw.parent))) throw new RemixError("a remix parent is null or a sha256 manifest digest");
+  if (!isRecord2(raw.slots)) throw new RemixError("a remix has a slots object");
+  for (let [slot, ref] of Object.entries(raw.slots)) {
+    if (!isSlotRef(ref)) throw new RemixError(`slot "${slot}" must be a preset name, { "value": ... } or { "content": "sha256:..." }`);
+    canonicalSlotJson(ref);
+  }
+  return { remix: (1), template: raw.template, parent: raw.parent, slots: raw.slots };
+}
+function chain(manifest, sources) {
+  let out = [manifest], seen = /* @__PURE__ */ new Set([remixDigest(manifest)]), parent = manifest.parent;
+  for (; parent !== null; ) {
+    if (seen.has(parent)) throw new RemixError(`remix lineage loops back to ${parent}`);
+    if (out.length > (64)) throw new RemixError(`remix lineage is deeper than ${(64)}`);
+    seen.add(parent);
+    let found = sources.manifest?.(parent);
+    if (found === void 0) throw new RemixError(`parent remix ${parent} is not available`);
+    if (remixDigest(found) !== parent) throw new RemixError(`parent remix ${parent} does not match its digest`);
+    if (found.template !== manifest.template) throw new RemixError(`parent remix ${parent} remixes ${found.template}, not ${manifest.template}`);
+    out.push(found), parent = found.parent;
+  }
+  return out.reverse();
+}
+function remixLineage(manifest, sources = {}) {
+  let ancestors = chain(manifest, sources).slice(0, -1).map(remixDigest).reverse();
+  return { template: manifest.template, digest: remixDigest(manifest), ancestors };
+}
+function lookupRef(t, slot, ref, sources, issues) {
+  if (typeof ref == "string") {
+    let presets = slotPresets(t, slot);
+    if (!(ref in presets)) {
+      let names = Object.keys(presets);
+      issues.push({ slot, path: "", reason: names.length > 0 ? `${JSON.stringify(ref)} is not a preset (choose ${names.join(", ")})` : `${JSON.stringify(ref)} is not a preset; this slot has none, so give a value` });
+      return;
+    }
+    return presets[ref];
+  }
+  if ("value" in ref) return ref.value;
+  let found = sources.content?.(ref.content);
+  if (found === void 0) {
+    issues.push({ slot, path: "", reason: `content ${ref.content} is not available` });
+    return;
+  }
+  if (slotDigest(found) !== ref.content) {
+    issues.push({ slot, path: "", reason: `content ${ref.content} does not match its digest` });
+    return;
+  }
+  return found;
+}
+function applyRefs(t, slots, values, sources, issues) {
+  for (let slot of Object.keys(slots)) {
+    let type = t.slots[slot];
+    if (type === void 0) {
+      issues.push({ slot, path: "", reason: `${t.id} has no slot named ${slot} (it has ${Object.keys(t.slots).join(", ")})` });
+      continue;
+    }
+    let raw = lookupRef(t, slot, slots[slot], sources, issues);
+    if (raw === void 0) continue;
+    let check = checkSlot(slot, type, raw);
+    issues.push(...check.issues), check.value !== null && (values[slot] = check.value);
+  }
+}
+function resolveRemix(t, manifest, sources = {}) {
+  if (manifest.template !== t.ref) throw new RemixError(`this remix is of ${manifest.template}, not ${t.ref}`);
+  let values = { ...t.values }, issues = [];
+  for (let m of chain(manifest, sources)) applyRefs(t, m.slots, values, sources, issues);
+  if (issues.length > 0) throw new TemplateSlotError(issues);
+  return Object.freeze(values);
+}
+function remix(t, set, options = {}) {
+  let parent = options.parent ?? null, parentDigest = parent === null ? null : remixDigest(parent), content = {}, slots = {};
+  for (let slot of Object.keys(set).sort()) {
+    let value = set[slot];
+    if (value !== void 0)
+      if (typeof value == "string") slots[slot] = value;
+      else if (value instanceof ContentRef) slots[slot] = { content: value.digest };
+      else {
+        let text = canonicalSlotJson(value), copy = JSON.parse(text);
+        if (t.slots[slot]?.kind === "params" || encoder.encode(text).length <= (256)) slots[slot] = { value: copy };
+        else {
+          let digest = slotDigest(copy);
+          content[digest] = copy, slots[slot] = { content: digest };
+        }
+      }
+  }
+  let manifest = { remix: (1), template: t.ref, parent: parentDigest, slots }, given = options.sources ?? {};
+  return resolveRemix(t, manifest, {
+    manifest: (digest) => parent !== null && digest === parentDigest ? parent : given.manifest?.(digest),
+    content: (digest) => content[digest] ?? given.content?.(digest)
+  }), { manifest, digest: remixDigest(manifest), content };
+}
+function memoryRemixSources(remixes = []) {
+  let manifests = /* @__PURE__ */ new Map(), blobs = /* @__PURE__ */ new Map(), add = (r) => {
+    manifests.set(r.digest, r.manifest);
+    for (let [digest, value] of Object.entries(r.content)) blobs.set(digest, value);
+  };
+  for (let r of remixes) add(r);
+  return {
+    add,
+    manifest: (digest) => manifests.get(digest),
+    content: (digest) => blobs.get(digest)
+  };
+}
+
+// src/game/kit/slots/assign.ts
+var TEMPLATE_SLOTS_FLAG = "CIMPLIFY_TEMPLATE_SLOTS";
+function templateSlotsEnabled(env) {
+  let value = env[TEMPLATE_SLOTS_FLAG];
+  return value !== "0" && value !== "false";
+}
+var FILE_PREFIX = "@";
+function parseJson(text) {
+  try {
+    return { ok: !0, value: JSON.parse(text) };
+  } catch {
+    return { ok: false };
+  }
+}
+function literal(text) {
+  let parsed = parseJson(text);
+  return parsed.ok ? parsed.value : text;
+}
+function slotChoices(t, slot) {
+  let type = t.slots[slot];
+  if (type === void 0) return "";
+  let presets = Object.keys(slotPresets(t, slot)), shape = describeSlot(type);
+  return presets.length > 0 ? `${shape}; presets: ${presets.join(", ")}` : shape;
+}
+function assignSlots(t, pairs, options = {}) {
+  let issues = [], set = {}, params = {}, base = options.base ?? t.values;
+  for (let pair of pairs) {
+    let eq = pair.indexOf("=");
+    if (eq <= 0) {
+      issues.push({ slot: pair, path: "", reason: "write slot=value (or params as slot.field=value)" });
+      continue;
+    }
+    let key = pair.slice(0, eq), text = pair.slice(eq + 1), dot = key.indexOf("."), slot = dot < 0 ? key : key.slice(0, dot), type = t.slots[slot];
+    if (type === void 0) {
+      issues.push({ slot, path: "", reason: `${t.id} has no slot named ${slot} (it has ${Object.keys(t.slots).join(", ")})` });
+      continue;
+    }
+    if (text.startsWith(FILE_PREFIX)) {
+      if (options.readFile === void 0) {
+        issues.push({ slot, path: "", reason: "cannot read files here" });
+        continue;
+      }
+      try {
+        text = options.readFile(text.slice(FILE_PREFIX.length));
+      } catch (error) {
+        issues.push({ slot, path: "", reason: `could not read ${text.slice(FILE_PREFIX.length)}: ${error.message}` });
+        continue;
+      }
+    }
+    if (dot >= 0) {
+      let field = key.slice(dot + 1);
+      if (type.kind !== "params") {
+        issues.push({ slot, path: field, reason: `${slot} is ${describeSlot(type)}, so it takes a whole value, not ${field}` });
+        continue;
+      }
+      if (!(field in type.fields)) {
+        issues.push({ slot, path: field, reason: `${slot} has no ${field} (it has ${Object.keys(type.fields).join(", ")})` });
+        continue;
+      }
+      let current = params[slot] ?? { ...base[slot] ?? {} };
+      current[field] = literal(text), params[slot] = current;
+      continue;
+    }
+    if (text.startsWith(DIGEST_PREFIX)) {
+      try {
+        set[slot] = new ContentRef(text);
+      } catch (error) {
+        issues.push({ slot, path: "", reason: error.message });
+      }
+      continue;
+    }
+    let parsed = parseJson(text);
+    if (parsed.ok && typeof parsed.value == "object" && parsed.value !== null) {
+      set[slot] = type.kind === "params" ? { ...base[slot] ?? {}, ...parsed.value } : parsed.value;
+      continue;
+    }
+    if (type.kind === "params") {
+      issues.push({ slot, path: "", reason: `params are set per field, e.g. ${slot}.${Object.keys(type.fields)[0] ?? "field"}=value` });
+      continue;
+    }
+    if (!(text in slotPresets(t, slot))) {
+      issues.push({ slot, path: "", reason: `${JSON.stringify(text)} does not fit: the slot takes ${slotChoices(t, slot)}` });
+      continue;
+    }
+    set[slot] = text;
+  }
+  for (let slot of Object.keys(params)) set[slot] = params[slot];
+  if (issues.length > 0) throw new TemplateSlotError(issues);
+  return set;
+}
+
+export { Bool, Character, Choice, ContentRef, DIGEST_PREFIX, INLINE_VALUE_BYTES, Int, MAX_REMIX_DEPTH, Num, Palette, Params, REMIX_FORMAT, RemixError, SLOT_TEMPLATES, SceneReportError, SceneSlot, TEMPLATE_SCHEMA_FORMAT, TEMPLATE_SLOTS_FLAG, THEME_PRESETS, TemplateSlotError, Theme, Track, anchors, assignSlots, canonicalSlotJson, checkSlot, colorInt, contrastRatio, decodeRemix, describeIssue, describeSlot, encodeRemix, memoryRemixSources, parseColor, remix, remixDigest, remixLineage, resolveRemix, runnerSlots, shootoutSlots, slotChoices, slotContent, slotDigest, slotPresets, slotSceneFromReport, template, templateFromSchema, templateRef, templateSchema, templateSlotsEnabled };