@cimplify/cli 0.15.3 → 0.16.0

package/dist/workshop-CD74D2LK.mjs

@@ -0,0 +1,1703 @@
+#!/usr/bin/env node
+import { compileScript, assetKind } from './chunk-JKECUAAV.mjs';
+import { parseToml, TomlSyntaxError, quoteTomlString } from './chunk-KQNZKV6E.mjs';
+import { promptYesNo } from './chunk-I4HNHPEM.mjs';
+import { encodeChunk } from './chunk-EYEMPIMP.mjs';
+import { sha256, canonicalJson } from './chunk-25ZPFHLF.mjs';
+import './chunk-SGT5IJVW.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-CLQYPTJ2.mjs';
+import { readAuthOrNull } from './chunk-TT4YI33G.mjs';
+import { info, dim, CliError, CLI_ERROR_CODE, step, success, result, failure, warn, bold, isAutoYes, isInteractive } from './chunk-KOD4GBQ5.mjs';
+import { mkdirSync, writeFileSync, promises, readFileSync } from 'fs';
+import path4 from 'path';
+import { createHash } from 'crypto';
+
+// src/interactives/workshop/pack.ts
+var VERSION_MANIFEST_FORMAT = 1;
+var TERMS = {
+  free_attribution: "Cimplify Workshop licence: free with attribution (terms 2026-10-10). The owner grants the licensee Interactive a worldwide, royalty-free, non-exclusive right to use, reproduce, adapt and distribute this item inside that Interactive on Cimplify, for as long as the Interactive is offered. The licensee must keep the attribution Cimplify shows in the Interactive's credits. The item may not be extracted or redistributed on its own, and may not be used to train machine-learning models.",
+  free: "Cimplify Workshop licence: free (terms 2026-10-10). The owner grants the licensee Interactive a worldwide, royalty-free, non-exclusive right to use, reproduce, adapt and distribute this item inside that Interactive on Cimplify, for as long as the Interactive is offered. Attribution is not required by this licence. The item may not be extracted or redistributed on its own, and may not be used to train machine-learning models."
+};
+function termsDigest(licence) {
+  return sha256(TERMS[licence]);
+}
+var RATING = { fear: "none", language: "none", sexuality: "none", simulated_gambling: false, violence: "none" };
+function optional(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+var PACK_TIER_RANK = { low: 0, mid: 1, high: 2 };
+function packFiles(sources, read, blobs) {
+  const files = [];
+  for (const target of Object.keys(sources).sort()) {
+    const payload = read(sources[target]);
+    const chunk = encodeChunk(assetKind(target), payload);
+    blobs.set(chunk.digest, Buffer.concat(chunk.parts));
+    files.push({ bytes: chunk.totalBytes, chunk: chunk.digest, kind: chunk.kind, path: target });
+  }
+  return files;
+}
+function packItem(item, read, packed2) {
+  const blobs = /* @__PURE__ */ new Map();
+  const tiered = [{ tier: item.tier, files: item.files }, ...item.tiers ?? []].sort(
+    (a, b) => PACK_TIER_RANK[a.tier] - PACK_TIER_RANK[b.tier]
+  );
+  const variants = tiered.map((variant) => ({ files: packFiles(variant.files, read, blobs), tier: variant.tier }));
+  const dependencies = (item.dependencies ?? []).map((reference) => {
+    const upstream = packed2.get(reference);
+    if (upstream === void 0) throw new Error(`${item.item} depends on ${reference}, which is not packed before it`);
+    return { item: reference, version: upstream.item.version, version_digest: upstream.versionDigest };
+  });
+  const manifest = {
+    ai_origin: item.ai_origin,
+    credit: {
+      authors: [...item.credit.authors],
+      licence: item.credit.licence,
+      ...optional("licence_url", item.credit.licence_url),
+      modified: item.credit.modified,
+      ...optional("source_url", item.credit.source_url),
+      title: item.credit.title
+    },
+    format: VERSION_MANIFEST_FORMAT,
+    item: item.item,
+    item_type: item.item_type,
+    name: item.name,
+    rating: RATING,
+    sources: item.sources.map((s) => ({
+      ...optional("attribution", s.attribution),
+      author: s.author,
+      kind: s.kind,
+      licence: s.licence,
+      ...optional("url", s.url)
+    })),
+    variants,
+    version: item.version,
+    ...dependencies.length === 0 ? {} : { dependencies }
+  };
+  const bytes = Buffer.from(canonicalJson(manifest), "utf8");
+  const versionDigest = sha256(bytes);
+  blobs.set(versionDigest, bytes);
+  return { item, manifest: bytes, versionDigest, blobs };
+}
+function packItems(items, read) {
+  const packed2 = /* @__PURE__ */ new Map();
+  for (const item of items) packed2.set(item.item, packItem(item, read, packed2));
+  return [...packed2.values()];
+}
+function resolutionOf(packed2) {
+  return packed2.map((p) => ({
+    item: p.item.item,
+    item_type: p.item.item_type,
+    version: p.item.version,
+    version_digest: p.versionDigest,
+    requested: false,
+    offers: [{ offer_id: `cof_${p.item.item}`, kind: p.item.licence, terms: termsDigest(p.item.licence), derivatives: "remixable", generation_allowed: true }]
+  }));
+}
+function importBody(p, owner) {
+  return {
+    owner,
+    listing: "listed",
+    details: { name: p.item.name, description: p.item.description, tags: p.item.tags },
+    manifest: p.manifest.toString("base64"),
+    blobs: [...p.blobs.entries()].filter(([digest]) => digest !== p.versionDigest).map(([, bytes]) => bytes.toString("base64")),
+    offers: [{ kind: p.item.licence, derivatives: "remixable", generation_allowed: true }]
+  };
+}
+
+// src/interactives/workshop/lagos/atlas.ts
+var GRID = 8;
+var LAGOS_QUADRANT = [0.5, 0.5, 0.5, 0.5];
+var SWATCHES = {
+  asphalt: 3882306,
+  asphaltWorn: 4868943,
+  laneWhite: 15328988,
+  laneYellow: 15906352,
+  concrete: 11117722,
+  kerb: 13617597,
+  kerbRed: 11878446,
+  paving: 10260349,
+  dirt: 10119747,
+  laterite: 10769199,
+  danfoYellow: 16168972,
+  danfoBlack: 1381914,
+  chrome: 13225169,
+  glass: 2968156,
+  brtRed: 12856107,
+  brtBlue: 2051740,
+  kekeYellow: 15909376,
+  kekeGreen: 2067020,
+  canvas: 3104314,
+  wood: 8016434,
+  woodDark: 5584417,
+  zinc: 9409689,
+  rust: 9063210,
+  ankaraRed: 13776685,
+  ankaraBlue: 2384568,
+  ankaraGreen: 3054170,
+  ankaraOrange: 15695138,
+  ankaraPurple: 8077216,
+  umbrellaWhite: 15855592,
+  tomato: 14168606,
+  plantain: 15254586,
+  pepper: 12000274,
+  palmTrunk: 7034435,
+  palmLeaf: 4160811,
+  palmLeafDark: 2907679,
+  skinDark: 5913126,
+  skinMid: 8016182,
+  skinLight: 10119753,
+  clothWhite: 15394525,
+  clothBlack: 2303275,
+  clothGold: 13081130,
+  rubber: 1842206,
+  headlight: 16773832,
+  taillight: 13704991,
+  signGreen: 1997372,
+  signWhite: 16119280,
+  wall: 14272941,
+  wallBlue: 9417417,
+  wallPink: 14263200,
+  roofTile: 10177074,
+  water: 3960447,
+  grass: 6127413,
+  shadowGray: 2763308
+};
+var NAMES = Object.keys(SWATCHES);
+function swatchUv(name) {
+  const index = NAMES.indexOf(name);
+  const col = index % GRID;
+  const row = Math.floor(index / GRID);
+  return [(col + 0.5) / GRID, (row + 0.5) / GRID];
+}
+function lagosUv(name) {
+  const uv = swatchUv(name);
+  const t = LAGOS_QUADRANT;
+  return [uv[0] * t[0] + t[2], uv[1] * t[1] + t[3]];
+}
+
+// src/interactives/workshop/lagos/geo.ts
+function normal(a, b, c) {
+  const e0 = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+  const e1 = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+  const n = [e0[1] * e1[2] - e0[2] * e1[1], e0[2] * e1[0] - e0[0] * e1[2], e0[0] * e1[1] - e0[1] * e1[0]];
+  const l = Math.hypot(n[0], n[1], n[2]) || 1;
+  return [n[0] / l, n[1] / l, n[2] / l];
+}
+var Mesh = class {
+  positions = [];
+  normals = [];
+  uvs = [];
+  indices = [];
+  get vertexCount() {
+    return this.positions.length / 3;
+  }
+  vertex(p, n, uv) {
+    this.positions.push(p[0], p[1], p[2]);
+    this.normals.push(n[0], n[1], n[2]);
+    this.uvs.push(uv[0], uv[1]);
+    return this.vertexCount - 1;
+  }
+  quad(a, b, c, d, uv) {
+    const n = normal(a, b, c);
+    const i = this.vertex(a, n, uv);
+    this.vertex(b, n, uv);
+    this.vertex(c, n, uv);
+    this.vertex(d, n, uv);
+    this.indices.push(i, i + 1, i + 2, i, i + 2, i + 3);
+  }
+  triangle(a, b, c, uv) {
+    const n = normal(a, b, c);
+    const i = this.vertex(a, n, uv);
+    this.vertex(b, n, uv);
+    this.vertex(c, n, uv);
+    this.indices.push(i, i + 1, i + 2);
+  }
+  box(center, half, uv, yaw = 0, bottom = true) {
+    const [cx, cy, cz] = center;
+    const [hx, hy, hz] = half;
+    const c = Math.cos(yaw);
+    const s = Math.sin(yaw);
+    const p = (x, y, z) => [cx + c * x + s * z, cy + y, cz - s * x + c * z];
+    const v = [p(-hx, -hy, -hz), p(hx, -hy, -hz), p(hx, -hy, hz), p(-hx, -hy, hz), p(-hx, hy, -hz), p(hx, hy, -hz), p(hx, hy, hz), p(-hx, hy, hz)];
+    this.quad(v[4], v[7], v[6], v[5], uv);
+    this.quad(v[3], v[2], v[6], v[7], uv);
+    this.quad(v[1], v[0], v[4], v[5], uv);
+    this.quad(v[2], v[1], v[5], v[6], uv);
+    this.quad(v[0], v[3], v[7], v[4], uv);
+    if (bottom) this.quad(v[0], v[1], v[2], v[3], uv);
+  }
+  cylinder(base, radius, height, sides, uv, top = true, radiusTop = radius) {
+    const [bx, by, bz] = base;
+    for (let i = 0; i < sides; i++) {
+      const a0 = i / sides * Math.PI * 2;
+      const a1 = (i + 1) / sides * Math.PI * 2;
+      const p0 = [bx + Math.cos(a0) * radius, by, bz + Math.sin(a0) * radius];
+      const p1 = [bx + Math.cos(a1) * radius, by, bz + Math.sin(a1) * radius];
+      const q0 = [bx + Math.cos(a0) * radiusTop, by + height, bz + Math.sin(a0) * radiusTop];
+      const q1 = [bx + Math.cos(a1) * radiusTop, by + height, bz + Math.sin(a1) * radiusTop];
+      this.quad(p1, p0, q0, q1, uv);
+      if (top) this.triangle([bx, by + height, bz], q1, q0, uv);
+    }
+  }
+};
+
+// src/interactives/workshop/lagos/glb.ts
+var GLB_MAGIC = 1179937895;
+var GLB_VERSION = 2;
+var CHUNK_JSON = 1313821514;
+var CHUNK_BIN = 5130562;
+var HEADER_BYTES = 12;
+var CHUNK_HEADER_BYTES = 8;
+var ALIGN = 4;
+var JSON_PAD = 32;
+var FLOAT = 5126;
+var UNSIGNED_BYTE = 5121;
+var UNSIGNED_SHORT = 5123;
+var UNSIGNED_INT = 5125;
+var ARRAY_BUFFER = 34962;
+var ELEMENT_ARRAY_BUFFER = 34963;
+var GENERATOR = "penalty-kings asset pipeline";
+var COMPONENTS = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT4: 16 };
+function pad(length) {
+  return (ALIGN - length % ALIGN) % ALIGN;
+}
+var GlbWriter = class {
+  json;
+  parts = [];
+  length = 0;
+  constructor() {
+    this.json = {
+      asset: { version: "2.0", generator: GENERATOR },
+      scene: 0,
+      scenes: [{ nodes: [] }],
+      nodes: [],
+      meshes: [],
+      accessors: [],
+      bufferViews: [],
+      buffers: [],
+      materials: [],
+      skins: [],
+      animations: [],
+      images: [],
+      textures: [],
+      samplers: []
+    };
+  }
+  view(bytes, target) {
+    const offset = this.length;
+    this.parts.push(bytes);
+    this.length += bytes.byteLength;
+    const fill = pad(this.length);
+    if (fill > 0) {
+      this.parts.push(new Uint8Array(fill));
+      this.length += fill;
+    }
+    const view = { buffer: 0, byteOffset: offset, byteLength: bytes.byteLength };
+    if (target !== void 0) view.target = target;
+    this.json.bufferViews.push(view);
+    return this.json.bufferViews.length - 1;
+  }
+  accessor(data, type, options = {}) {
+    const componentType = data instanceof Float32Array ? FLOAT : data instanceof Uint32Array ? UNSIGNED_INT : data instanceof Uint16Array ? UNSIGNED_SHORT : UNSIGNED_BYTE;
+    const width = COMPONENTS[type];
+    const view = this.view(new Uint8Array(data.buffer, data.byteOffset, data.byteLength), options.target);
+    const accessor = { bufferView: view, componentType, count: data.length / width, type };
+    if (options.bounds) {
+      const min = new Array(width).fill(Infinity);
+      const max = new Array(width).fill(-Infinity);
+      for (let i = 0; i < data.length; i++) {
+        const c = i % width;
+        if (data[i] < min[c]) min[c] = data[i];
+        if (data[i] > max[c]) max[c] = data[i];
+      }
+      accessor.min = min;
+      accessor.max = max;
+    }
+    this.json.accessors.push(accessor);
+    return this.json.accessors.length - 1;
+  }
+  material(material) {
+    this.json.materials.push(material);
+    return this.json.materials.length - 1;
+  }
+  node(node, root = false) {
+    this.json.nodes.push(node);
+    const index = this.json.nodes.length - 1;
+    if (root) this.json.scenes[0].nodes.push(index);
+    return index;
+  }
+  mesh(primitives, name) {
+    this.json.meshes.push(name === void 0 ? { primitives } : { name, primitives });
+    return this.json.meshes.length - 1;
+  }
+  toGlb() {
+    this.json.buffers.push({ byteLength: this.length });
+    const json = this.json;
+    for (const key of ["images", "textures", "samplers", "materials", "skins", "animations", "meshes"]) {
+      if (json[key].length === 0) delete json[key];
+    }
+    const text = new TextEncoder().encode(JSON.stringify(json));
+    const jsonPad = pad(text.byteLength);
+    const binLength = this.length;
+    const total = HEADER_BYTES + CHUNK_HEADER_BYTES + text.byteLength + jsonPad + CHUNK_HEADER_BYTES + binLength;
+    const out = new Uint8Array(total);
+    const view = new DataView(out.buffer);
+    view.setUint32(0, GLB_MAGIC, true);
+    view.setUint32(4, GLB_VERSION, true);
+    view.setUint32(8, total, true);
+    view.setUint32(12, text.byteLength + jsonPad, true);
+    view.setUint32(16, CHUNK_JSON, true);
+    out.set(text, 20);
+    out.fill(JSON_PAD, 20 + text.byteLength, 20 + text.byteLength + jsonPad);
+    let at = 20 + text.byteLength + jsonPad;
+    view.setUint32(at, binLength, true);
+    view.setUint32(at + 4, CHUNK_BIN, true);
+    at += CHUNK_HEADER_BYTES;
+    for (const part of this.parts) {
+      out.set(part, at);
+      at += part.byteLength;
+    }
+    return out;
+  }
+};
+function writeModel(parts, material = "atlas") {
+  const glb = new GlbWriter();
+  const mat = glb.material({ name: material, pbrMetallicRoughness: { baseColorFactor: [1, 1, 1, 1], metallicFactor: 0, roughnessFactor: 0.62 } });
+  const children = [];
+  glb.node({ name: "root", children }, true);
+  for (const part of parts) {
+    const m = part.mesh;
+    const wide = m.vertexCount > 65535;
+    const position = glb.accessor(Float32Array.from(m.positions), "VEC3", { target: ARRAY_BUFFER, bounds: true });
+    const normal2 = glb.accessor(Float32Array.from(m.normals), "VEC3", { target: ARRAY_BUFFER });
+    const uv = glb.accessor(Float32Array.from(m.uvs), "VEC2", { target: ARRAY_BUFFER });
+    const indices = glb.accessor(wide ? Uint32Array.from(m.indices) : Uint16Array.from(m.indices), "SCALAR", { target: ELEMENT_ARRAY_BUFFER });
+    const mesh = glb.mesh([{ attributes: { POSITION: position, NORMAL: normal2, TEXCOORD_0: uv }, indices, material: mat }], part.name);
+    children.push(glb.node({ name: part.name, mesh, translation: [...part.origin] }));
+  }
+  return glb.toGlb();
+}
+
+// src/interactives/workshop/lagos/props.ts
+var FABRICS = ["ankaraRed", "ankaraBlue", "ankaraGreen", "ankaraOrange", "ankaraPurple", "umbrellaWhite"];
+var GOODS = ["tomato", "plantain", "pepper", "ankaraOrange", "clothGold", "umbrellaWhite"];
+function mulberry(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function umbrella(m, center, radius, height, fabric, pole) {
+  const [x, y, z] = center;
+  m.box([x, y + height / 2, z], [0.03, height / 2, 0.03], lagosUv(pole));
+  const sides = 8;
+  const apex = [x, y + height + 0.35, z];
+  for (let i = 0; i < sides; i++) {
+    const a0 = i / sides * Math.PI * 2;
+    const a1 = (i + 1) / sides * Math.PI * 2;
+    const p0 = [x + Math.cos(a0) * radius, y + height, z + Math.sin(a0) * radius];
+    const p1 = [x + Math.cos(a1) * radius, y + height, z + Math.sin(a1) * radius];
+    const stripe = i % 2 === 0 ? fabric : "umbrellaWhite";
+    m.triangle(apex, p1, p0, lagosUv(stripe));
+    m.triangle(apex, p0, p1, lagosUv(stripe));
+  }
+}
+function stall(seed) {
+  const random = mulberry(seed);
+  const pick = (list) => list[Math.floor(random() * list.length) % list.length];
+  const m = new Mesh();
+  const wood = lagosUv("wood");
+  const dark = lagosUv("woodDark");
+  m.box([0, 0.86, 0], [0.95, 0.04, 0.5], wood);
+  for (const x of [-0.88, 0.88]) for (const z of [-0.43, 0.43]) m.box([x, 0.42, z], [0.04, 0.42, 0.04], dark);
+  const goods = pick(GOODS);
+  for (let i = 0; i < 9; i++) {
+    const gx = -0.7 + i % 5 * 0.35;
+    const gz = i < 5 ? -0.18 : 0.18;
+    const size = 0.12 + random() * 0.06;
+    m.box([gx, 0.9 + size, gz], [size, size, size], lagosUv(goods));
+  }
+  m.box([0, 0.25, 0], [0.8, 0.25, 0.4], lagosUv(pick(FABRICS)), random() * 0.1);
+  umbrella(m, [0.2, 0, 0.55], 1.25, 2.25, pick(FABRICS), "woodDark");
+  return m;
+}
+function kiosk(seed) {
+  const random = mulberry(seed);
+  const m = new Mesh();
+  const walls = ["wallBlue", "wall", "kekeGreen", "brtBlue", "ankaraOrange"];
+  const wall = lagosUv(walls[Math.floor(random() * walls.length) % walls.length]);
+  m.box([0, 1.2, 0], [1.6, 1.2, 1.3], wall);
+  m.box([0, 1.25, 1.31], [1.1, 0.55, 0.02], lagosUv("shadowGray"));
+  m.box([0, 0.72, 1.45], [1.35, 0.05, 0.18], lagosUv("wood"));
+  const roof = lagosUv("zinc");
+  m.quad([-1.8, 2.55, -1.5], [-1.8, 2.75, 1.9], [1.8, 2.75, 1.9], [1.8, 2.55, -1.5], roof);
+  m.quad([1.8, 2.55, -1.5], [1.8, 2.75, 1.9], [-1.8, 2.75, 1.9], [-1.8, 2.55, -1.5], lagosUv("rust"));
+  m.box([0, 2.95, 1.25], [1.2, 0.2, 0.03], lagosUv("signWhite"));
+  m.box([0, 2.95, 1.27], [1, 0.1, 0.02], lagosUv(FABRICS[Math.floor(random() * FABRICS.length) % FABRICS.length]));
+  return m;
+}
+function busStopSign() {
+  const m = new Mesh();
+  m.box([0, 1.3, 0], [0.04, 1.3, 0.04], lagosUv("zinc"));
+  m.box([0, 2.55, 0], [0.45, 0.28, 0.03], lagosUv("signGreen"));
+  m.box([0, 2.55, 0.035], [0.35, 0.1, 0.01], lagosUv("signWhite"));
+  return m;
+}
+function barrier(length, swatch, height = 0.8) {
+  const m = new Mesh();
+  m.box([0, height / 2, 0], [0.22, height / 2, length / 2], lagosUv(swatch));
+  m.box([0, height + 0.02, 0], [0.12, 0.02, length / 2], lagosUv("kerb"));
+  return m;
+}
+function generator() {
+  const m = new Mesh();
+  m.box([0, 0.35, 0], [0.45, 0.32, 0.3], lagosUv("ankaraRed"));
+  m.box([0, 0.72, 0], [0.38, 0.05, 0.26], lagosUv("danfoBlack"));
+  m.box([0.3, 0.75, 0], [0.05, 0.1, 0.05], lagosUv("zinc"));
+  return m;
+}
+function billboard(seed) {
+  const random = mulberry(seed);
+  const m = new Mesh();
+  const colors = ["signGreen", "brtRed", "ankaraOrange", "ankaraBlue", "kekeYellow"];
+  for (const x of [-2.2, 2.2]) m.box([x, 3.5, 0], [0.12, 3.5, 0.12], lagosUv("zinc"));
+  m.box([0, 7.8, 0], [3.2, 1.5, 0.15], lagosUv(colors[Math.floor(random() * colors.length) % colors.length]));
+  m.box([0, 8.1, 0.16], [2.4, 0.35, 0.02], lagosUv("signWhite"));
+  m.box([0, 7.3, 0.16], [1.6, 0.25, 0.02], lagosUv("clothGold"));
+  return m;
+}
+
+// src/interactives/workshop/lagos/generator.ts
+var WIRE_SEGMENTS = 12;
+var WIRE_SAG = 0.55;
+var POLE_SPAN = 18;
+var STALL_SEED = 7;
+var KIOSK_SEED = 3;
+var BILLBOARD_SEED = 2;
+var BARRIER_LENGTH = 3;
+function spokeWheel(radius, width) {
+  const m = new Mesh();
+  const tyre = lagosUv("rubber");
+  const hub = lagosUv("chrome");
+  const sides = 14;
+  for (let i = 0; i < sides; i++) {
+    const a0 = i / sides * Math.PI * 2;
+    const a1 = (i + 1) / sides * Math.PI * 2;
+    const p = (a, x) => [x, Math.sin(a) * radius, Math.cos(a) * radius];
+    m.quad(p(a0, -width / 2), p(a1, -width / 2), p(a1, width / 2), p(a0, width / 2), tyre);
+    m.triangle([width / 2 + 4e-3, 0, 0], p(a0, width / 2 + 4e-3), p(a1, width / 2 + 4e-3), hub);
+    m.triangle([-width / 2 - 4e-3, 0, 0], p(a1, -width / 2 - 4e-3), p(a0, -width / 2 - 4e-3), hub);
+  }
+  return m;
+}
+function okada() {
+  const bike = new Mesh();
+  const frame = lagosUv("ankaraRed");
+  const black = lagosUv("danfoBlack");
+  const chrome = lagosUv("chrome");
+  bike.box([0, 0.55, 0.05], [0.12, 0.12, 0.55], frame);
+  bike.box([0, 0.72, -0.25], [0.16, 0.06, 0.42], black);
+  bike.box([0, 0.66, 0.42], [0.14, 0.12, 0.18], frame);
+  bike.box([0, 0.85, 0.66], [0.04, 0.28, 0.04], chrome);
+  bike.box([0, 1.1, 0.68], [0.36, 0.025, 0.025], black);
+  bike.box([0, 0.98, 0.75], [0.08, 0.06, 0.03], lagosUv("headlight"));
+  bike.box([0, 0.62, -0.72], [0.1, 0.05, 0.05], lagosUv("taillight"));
+  bike.box([0.14, 0.42, -0.35], [0.04, 0.04, 0.28], chrome);
+  bike.box([0, 0.4, 0.1], [0.11, 0.12, 0.16], chrome);
+  const rider = new Mesh();
+  const skin = lagosUv("skinDark");
+  const shirt = lagosUv("ankaraBlue");
+  const trousers = lagosUv("clothBlack");
+  rider.box([0, 1.15, -0.2], [0.2, 0.3, 0.13], shirt);
+  rider.box([-0.12, 0.82, 0.05], [0.07, 0.07, 0.24], trousers);
+  rider.box([0.12, 0.82, 0.05], [0.07, 0.07, 0.24], trousers);
+  rider.box([-0.12, 0.55, 0.25], [0.06, 0.24, 0.06], trousers);
+  rider.box([0.12, 0.55, 0.25], [0.06, 0.24, 0.06], trousers);
+  rider.box([-0.26, 1.2, 0.2], [0.05, 0.05, 0.3], shirt);
+  rider.box([0.26, 1.2, 0.2], [0.05, 0.05, 0.3], shirt);
+  rider.box([0, 1.58, -0.18], [0.1, 0.12, 0.1], skin);
+  rider.box([0, 1.66, -0.18], [0.13, 0.08, 0.13], lagosUv("kekeYellow"));
+  const wheel = spokeWheel(0.32, 0.1);
+  return [
+    { name: "bike", mesh: bike, origin: [0, 0, 0] },
+    { name: "rider", mesh: rider, origin: [0, 0, 0] },
+    { name: "wheel-front", mesh: wheel, origin: [0, 0.32, 0.72] },
+    { name: "wheel-back", mesh: wheel, origin: [0, 0.32, -0.62] }
+  ];
+}
+function wire(m, from, to, swatch) {
+  const uv = lagosUv(swatch);
+  const thickness = 0.015;
+  for (let i = 0; i < WIRE_SEGMENTS; i++) {
+    const at = (t) => [
+      from[0] + (to[0] - from[0]) * t,
+      from[1] + (to[1] - from[1]) * t - WIRE_SAG * 4 * t * (1 - t),
+      from[2] + (to[2] - from[2]) * t
+    ];
+    const a = at(i / WIRE_SEGMENTS);
+    const b = at((i + 1) / WIRE_SEGMENTS);
+    m.quad([a[0], a[1] - thickness, a[2]], [b[0], b[1] - thickness, b[2]], [b[0], b[1] + thickness, b[2]], [a[0], a[1] + thickness, a[2]], uv);
+    m.quad([a[0], a[1] + thickness, a[2]], [b[0], b[1] + thickness, b[2]], [b[0], b[1] - thickness, b[2]], [a[0], a[1] - thickness, a[2]], uv);
+  }
+}
+function poleAndWires() {
+  const m = new Mesh();
+  const wood = lagosUv("woodDark");
+  for (const z of [0, POLE_SPAN]) {
+    m.cylinder([0, 0, z], 0.14, 9, 8, wood, true, 0.11);
+    m.box([0, 8.6, z], [1.1, 0.06, 0.06], wood);
+    for (const x of [-0.9, 0, 0.9]) m.box([x, 8.72, z], [0.04, 0.06, 0.04], lagosUv("umbrellaWhite"));
+    m.box([0.25, 7.6, z], [0.2, 0.3, 0.2], lagosUv("zinc"));
+  }
+  for (const x of [-0.9, 0, 0.9]) wire(m, [x, 8.78, 0], [x, 8.78, POLE_SPAN], "rubber");
+  return m;
+}
+function streetSignage() {
+  const shop = new Mesh();
+  shop.box([0, 1.6, 0], [0.05, 1.6, 0.05], lagosUv("zinc"));
+  shop.box([0, 3.2, 0], [1.2, 0.4, 0.04], lagosUv("ankaraPurple"));
+  shop.box([0, 3.2, 0.045], [1, 0.16, 0.01], lagosUv("clothGold"));
+  shop.box([0, 2.85, 0.045], [0.7, 0.06, 0.01], lagosUv("signWhite"));
+  return [
+    { name: "billboard", mesh: billboard(BILLBOARD_SEED), origin: [0, 0, 0] },
+    { name: "bus-stop-sign", mesh: busStopSign(), origin: [5, 0, 0] },
+    { name: "shop-sign", mesh: shop, origin: [-5, 0, 0] }
+  ];
+}
+function roadsideUmbrella() {
+  const m = new Mesh();
+  m.box([0, 1.1, 0], [0.03, 1.1, 0.03], lagosUv("woodDark"));
+  m.cylinder([0, 0, 0], 0.3, 0.12, 10, lagosUv("concrete"));
+  const apex = [0, 2.55, 0];
+  const sides = 10;
+  for (let i = 0; i < sides; i++) {
+    const a0 = i / sides * Math.PI * 2;
+    const a1 = (i + 1) / sides * Math.PI * 2;
+    const p0 = [Math.cos(a0) * 1.4, 2.15, Math.sin(a0) * 1.4];
+    const p1 = [Math.cos(a1) * 1.4, 2.15, Math.sin(a1) * 1.4];
+    const stripe = lagosUv(i % 2 === 0 ? "ankaraGreen" : "umbrellaWhite");
+    m.triangle(apex, p1, p0, stripe);
+    m.triangle(apex, p0, p1, stripe);
+  }
+  return m;
+}
+function single(name, mesh) {
+  return writeModel([{ name, mesh, origin: [0, 0, 0] }]);
+}
+function workshopAssets() {
+  return {
+    "okada.glb": writeModel(okada()),
+    "market-stall.glb": single("market-stall", stall(STALL_SEED)),
+    "kiosk.glb": single("kiosk", kiosk(KIOSK_SEED)),
+    "pole-and-wires.glb": single("pole-and-wires", poleAndWires()),
+    "street-signage.glb": writeModel(streetSignage()),
+    "roadside-umbrella.glb": single("roadside-umbrella", roadsideUmbrella()),
+    "yellow-barrier.glb": single("yellow-barrier", barrier(BARRIER_LENGTH, "kekeYellow")),
+    "generator.glb": single("generator", generator())
+  };
+}
+
+// src/interactives/workshop/packs/lagos.ts
+var KENNEY_CAR_KIT = "https://kenney.nl/assets/car-kit";
+var KENNEY_CITY_ROADS = "https://kenney.nl/assets/city-kit-roads";
+var KENNEY_CITY_COMMERCIAL = "https://kenney.nl/assets/city-kit-commercial";
+var CC0 = "CC0 1.0";
+var CC0_URL = "https://creativecommons.org/publicdomain/zero/1.0/";
+var CC0_CODE = "cc0-1.0";
+var VERSION = "1.0.0";
+var CIMPLIFY = "Cimplify";
+var KENNEY = "Kenney";
+var ATLAS = "cimplify/lagos-street-atlas";
+var LAGOS_ASSETS = "packages/sdk/test-fixtures/interactives/lagos-street/project/assets/core";
+var GENERATED_PREFIX = "generated/";
+function own() {
+  return { kind: "own_work", licence: CC0_CODE, author: CIMPLIFY };
+}
+function kenney(url) {
+  return { kind: "third_party", licence: CC0_CODE, author: KENNEY, url };
+}
+function generated(slug, name, description, tags, file, itemType = "model") {
+  return {
+    item: `cimplify/${slug}`,
+    item_type: itemType,
+    version: VERSION,
+    name,
+    description,
+    tags,
+    credit: { title: name, authors: [CIMPLIFY], licence: CC0, licence_url: CC0_URL, modified: false },
+    sources: [own()],
+    ai_origin: "none",
+    licence: "free_attribution",
+    tier: "mid",
+    files: { [file]: `${GENERATED_PREFIX}${file}` },
+    dependencies: [ATLAS]
+  };
+}
+var LAGOS_PACK = [
+  {
+    item: ATLAS,
+    item_type: "texture",
+    version: VERSION,
+    name: "Lagos street palette atlas",
+    description: "The colour atlas every Lagos street model samples: Kenney kit palettes plus a generated Lagos palette quadrant",
+    tags: ["lagos", "atlas", "palette"],
+    credit: { title: "Lagos street palette atlas", authors: [KENNEY, CIMPLIFY], licence: CC0, licence_url: CC0_URL, source_url: KENNEY_CAR_KIT, modified: true },
+    sources: [kenney(KENNEY_CAR_KIT), kenney(KENNEY_CITY_ROADS), kenney(KENNEY_CITY_COMMERCIAL), own()],
+    ai_origin: "none",
+    licence: "free_attribution",
+    tier: "mid",
+    files: { "atlas.ktx2": "atlas.ktx2" }
+  },
+  {
+    item: "cimplify/danfo-bus",
+    item_type: "model",
+    version: VERSION,
+    name: "Danfo bus",
+    description: "A yellow Lagos minibus with black bands and a roof rack, built from a recoloured van",
+    tags: ["lagos", "vehicle", "bus", "danfo"],
+    credit: { title: "Danfo bus", authors: [KENNEY, CIMPLIFY], licence: CC0, licence_url: CC0_URL, source_url: KENNEY_CAR_KIT, modified: true },
+    sources: [kenney(KENNEY_CAR_KIT), own()],
+    ai_origin: "none",
+    licence: "free_attribution",
+    tier: "mid",
+    files: { "danfo.glb": "vehicles/danfo.glb" },
+    dependencies: [ATLAS]
+  },
+  {
+    item: "cimplify/keke-napep",
+    item_type: "model",
+    version: VERSION,
+    name: "Keke napep",
+    description: "A green and yellow tricycle taxi with a canvas roof",
+    tags: ["lagos", "vehicle", "tricycle", "keke"],
+    credit: { title: "Keke napep", authors: [CIMPLIFY], licence: CC0, licence_url: CC0_URL, modified: false },
+    sources: [own()],
+    ai_origin: "none",
+    licence: "free_attribution",
+    tier: "mid",
+    files: { "keke.glb": "vehicles/keke.glb" },
+    dependencies: [ATLAS]
+  },
+  {
+    item: "cimplify/brt-bus",
+    item_type: "model",
+    version: VERSION,
+    name: "City rapid-transit bus",
+    description: "A twelve metre rapid-transit bus in a fictional red and blue livery",
+    tags: ["lagos", "vehicle", "bus", "brt"],
+    credit: { title: "City rapid-transit bus", authors: [CIMPLIFY], licence: CC0, licence_url: CC0_URL, modified: false },
+    sources: [own()],
+    ai_origin: "none",
+    licence: "free_attribution",
+    tier: "mid",
+    files: { "brt.glb": "vehicles/brt.glb" },
+    dependencies: [ATLAS]
+  },
+  generated("okada", "Okada with rider", "A commercial motorcycle with a seated rider in a helmet", ["lagos", "vehicle", "motorcycle", "okada"], "okada.glb"),
+  generated("market-stall", "Market stall", "A wooden produce stall with a striped market umbrella", ["lagos", "market", "stall", "prop"], "market-stall.glb"),
+  generated("kiosk", "Roadside kiosk", "A painted roadside kiosk with a zinc roof and a blank shop sign", ["lagos", "kiosk", "prop"], "kiosk.glb"),
+  generated("pole-and-wires", "Pole and wires", "Two wooden utility poles with crossarms, insulators and sagging wires", ["lagos", "utility", "pole", "prop"], "pole-and-wires.glb"),
+  generated("street-signage", "Street signage", "A blank billboard, a bus stop sign and a shop sign in fictional colours", ["lagos", "sign", "billboard", "prop"], "street-signage.glb"),
+  generated("roadside-umbrella", "Roadside umbrella", "A striped roadside umbrella on a weighted base", ["lagos", "umbrella", "prop"], "roadside-umbrella.glb"),
+  generated("yellow-barrier", "Yellow road barrier", "A three metre yellow concrete road barrier", ["lagos", "road", "barrier", "prop"], "yellow-barrier.glb"),
+  generated("generator", "Petrol generator", "A small red petrol generator", ["lagos", "generator", "prop"], "generator.glb")
+];
+
+// src/interactives/workshop/packs/launch.ts
+var UBC = "https://quaternius.itch.io/universal-base-characters";
+var UAL1 = "https://opengameart.org/content/universal-animation-library";
+var UAL2 = "https://opengameart.org/content/universal-animation-library-2";
+var CC02 = "CC0 1.0";
+var CC0_URL2 = "https://creativecommons.org/publicdomain/zero/1.0/";
+var CC0_CODE2 = "cc0-1.0";
+var VERSION2 = "1.0.0";
+var CIMPLIFY2 = "Cimplify";
+var QUATERNIUS = "Quaternius";
+var MATERIALS = "cimplify/starter-materials";
+var ANIMATIONS = "cimplify/humanoid-animations";
+var IDENTITY = "cimplify/identity-base";
+var LAUNCH_ASSETS = "packages/sdk/test-fixtures/interactives/launch-pack/project/assets/core";
+var LAUNCH_MATERIALS = ["cotton", "denim", "leather", "wood", "painted_metal", "brushed_metal", "concrete", "rubber", "plastic", "terrazzo", "tiles", "brick"];
+var LAUNCH_PROPS = [
+  { slug: "crate", name: "Wooden crate", tags: ["container", "wood"] },
+  { slug: "barrel", name: "Oil barrel", tags: ["container", "metal"] },
+  { slug: "traffic_cone", name: "Traffic cone", tags: ["street", "road"] },
+  { slug: "bench", name: "Park bench", tags: ["street", "seat"] },
+  { slug: "chair", name: "Chair", tags: ["furniture", "seat"] },
+  { slug: "table", name: "Table", tags: ["furniture"] },
+  { slug: "lamp_post", name: "Street lamp", tags: ["street", "light"] },
+  { slug: "bottle", name: "Bottle", tags: ["pickup", "drink"] },
+  { slug: "mug", name: "Mug", tags: ["pickup", "kitchen"] },
+  { slug: "ball", name: "Rubber ball", tags: ["sport", "pickup"] },
+  { slug: "plant_pot", name: "Potted plant", tags: ["decor", "plant"] },
+  { slug: "bin", name: "Litter bin", tags: ["street"] },
+  { slug: "fence", name: "Fence panel", tags: ["garden", "wood"] },
+  { slug: "sign", name: "Sign board", tags: ["street", "sign"] },
+  { slug: "kerb_block", name: "Concrete block", tags: ["street", "concrete"] },
+  { slug: "brick_wall", name: "Brick wall section", tags: ["wall", "brick"] },
+  { slug: "goal", name: "Small goal", tags: ["sport", "football"] }
+];
+function own2() {
+  return { kind: "own_work", licence: CC0_CODE2, author: CIMPLIFY2 };
+}
+function quaternius(url) {
+  return { kind: "third_party", licence: CC0_CODE2, author: QUATERNIUS, url };
+}
+function prop(entry) {
+  return {
+    item: `cimplify/prop-${entry.slug.replaceAll("_", "-")}`,
+    item_type: "model",
+    version: VERSION2,
+    name: entry.name,
+    description: `${entry.name} from the Cimplify starter props, textured with the starter materials`,
+    tags: ["starter", ...entry.tags],
+    credit: { title: entry.name, authors: [CIMPLIFY2], licence: CC02, licence_url: CC0_URL2, modified: false },
+    sources: [own2()],
+    ai_origin: "none",
+    licence: "free",
+    tier: "low",
+    files: { [`${entry.slug}.glb`]: `props/${entry.slug}.glb` },
+    dependencies: [MATERIALS]
+  };
+}
+var LAUNCH_PACK = [
+  {
+    item: MATERIALS,
+    item_type: "material",
+    version: VERSION2,
+    name: "Starter materials",
+    description: "Twelve tileable PBR materials (fabric, denim, leather, wood, metals, concrete, rubber, plastic, terrazzo, tiles, brick) with albedo and normal maps",
+    tags: ["starter", "material", "pbr"],
+    credit: { title: "Starter materials", authors: [CIMPLIFY2], licence: CC02, licence_url: CC0_URL2, modified: false },
+    sources: [own2()],
+    ai_origin: "none",
+    licence: "free",
+    tier: "low",
+    files: Object.fromEntries([
+      ["materials.json", "materials.json"],
+      ...LAUNCH_MATERIALS.flatMap((m) => [
+        [`${m}.ktx2`, `materials/${m}.ktx2`],
+        [`${m}-normal.ktx2`, `materials/${m}-normal.ktx2`]
+      ])
+    ])
+  },
+  {
+    item: ANIMATIONS,
+    item_type: "animation",
+    version: VERSION2,
+    name: "Humanoid animation library",
+    description: "120 clips on the standard humanoid rig: locomotion with an 8-direction strafe set and turns in place, idles, emotes, sports, driving, sitting, actions and reactions",
+    tags: ["starter", "animation", "humanoid", "locomotion", "emote", "sport"],
+    credit: { title: "Universal Animation Library 1 and 2, with Cimplify clips", authors: [QUATERNIUS, CIMPLIFY2], licence: CC02, licence_url: CC0_URL2, source_url: UAL1, modified: true },
+    sources: [quaternius(UAL1), quaternius(UAL2), own2()],
+    ai_origin: "none",
+    licence: "free",
+    tier: "low",
+    files: { "animations.glb": "animations.glb", "clips.json": "clips.json" }
+  },
+  {
+    item: IDENTITY,
+    item_type: "character",
+    version: VERSION2,
+    name: "Character identity base",
+    description: "The shared base character as a shape space: face and body controls, hair, brows and facial hair, palettes and face anchors for characters made from a photo",
+    tags: ["starter", "character", "identity"],
+    credit: { title: "Character identity base", authors: [QUATERNIUS, CIMPLIFY2], licence: CC02, licence_url: CC0_URL2, source_url: UBC, modified: true },
+    sources: [quaternius(UBC), quaternius(UAL2), own2()],
+    ai_origin: "none",
+    licence: "free",
+    tier: "low",
+    files: { "identity.cidb": "identity.cidb" },
+    dependencies: [ANIMATIONS]
+  },
+  {
+    item: "cimplify/base-character",
+    item_type: "character",
+    version: VERSION2,
+    name: "Base character",
+    description: "A stylised, rigged base character on the standard humanoid rig in an athletic outfit; every clip in the humanoid animation library plays on it",
+    tags: ["starter", "character", "rigged", "humanoid"],
+    credit: { title: "Base character", authors: [QUATERNIUS, CIMPLIFY2], licence: CC02, licence_url: CC0_URL2, source_url: UBC, modified: true },
+    sources: [quaternius(UBC), own2()],
+    ai_origin: "none",
+    licence: "free",
+    tier: "mid",
+    files: { "base-character.glb": "base-character.glb" },
+    dependencies: [ANIMATIONS, IDENTITY]
+  },
+  ...LAUNCH_PROPS.map(prop)
+];
+
+// src/interactives/workshop/packs/penalty-kings.ts
+var QUATERNIUS_PACK = "https://opengameart.org/content/animated-characters-pack";
+var POLY_HAVEN_SKY = "https://polyhaven.com/a/evening_road_01_puresky";
+var KENNEY_IMPACT = "https://kenney.nl/assets/impact-sounds";
+var KENNEY_INTERFACE = "https://kenney.nl/assets/interface-sounds";
+var APPLAUSE = "https://opengameart.org/content/applause-in-a-large-hall-or-church";
+var CC03 = "CC0 1.0";
+var CC0_URL3 = "https://creativecommons.org/publicdomain/zero/1.0/";
+var VERSION3 = "1.0.0";
+var CIMPLIFY3 = "Cimplify";
+var PENALTY_KINGS_ASSETS = "packages/sdk/test-fixtures/interactives/penalty-kings/project/assets/core";
+function own3() {
+  return { kind: "own_work", licence: "cc0-1.0", author: CIMPLIFY3 };
+}
+var PENALTY_KINGS_PACK = [
+  {
+    item: "cimplify/match-ball",
+    item_type: "model",
+    version: VERSION3,
+    name: "Match ball",
+    description: "A truncated icosahedron football with stitched panels, generated by Cimplify",
+    tags: ["football", "sport", "ball"],
+    credit: { title: "Match ball", authors: [CIMPLIFY3], licence: CC03, licence_url: CC0_URL3, modified: false },
+    sources: [own3()],
+    ai_origin: "none",
+    licence: "free_attribution",
+    tier: "mid",
+    files: { "ball.glb": "ball.glb" }
+  },
+  {
+    item: "cimplify/penalty-kings-striker",
+    item_type: "character",
+    version: VERSION3,
+    name: "Penalty Kings striker",
+    description: "A rigged striker in the emerald home kit with jog, kick, idle, celebrate and dejected clips",
+    tags: ["football", "character", "rigged"],
+    credit: { title: "Penalty Kings striker", authors: ["Quaternius", CIMPLIFY3], licence: CC03, licence_url: CC0_URL3, source_url: QUATERNIUS_PACK, modified: true },
+    sources: [{ kind: "third_party", licence: "cc0-1.0", author: "Quaternius", url: QUATERNIUS_PACK }, own3()],
+    ai_origin: "none",
+    licence: "free_attribution",
+    tier: "mid",
+    files: { "striker.glb": "striker.glb" }
+  },
+  {
+    item: "cimplify/penalty-kings-keeper",
+    item_type: "character",
+    version: VERSION3,
+    name: "Penalty Kings keeper",
+    description: "A rigged goalkeeper with ready, dive, smother, celebrate and dejected clips",
+    tags: ["football", "character", "rigged"],
+    credit: { title: "Penalty Kings keeper", authors: ["Quaternius", CIMPLIFY3], licence: CC03, licence_url: CC0_URL3, source_url: QUATERNIUS_PACK, modified: true },
+    sources: [{ kind: "third_party", licence: "cc0-1.0", author: "Quaternius", url: QUATERNIUS_PACK }, own3()],
+    ai_origin: "none",
+    licence: "free_attribution",
+    tier: "mid",
+    files: { "keeper.glb": "keeper.glb" }
+  },
+  {
+    item: "cimplify/floodlit-stadium",
+    item_type: "environment",
+    version: VERSION3,
+    name: "Floodlit stadium",
+    description: "A floodlit football stadium with stands, LED boards, an evening sky dome and its environment map",
+    tags: ["football", "stadium", "night"],
+    credit: { title: "Floodlit stadium", authors: [CIMPLIFY3, "Sergej Majboroda", "Jarod Guest"], licence: CC03, licence_url: CC0_URL3, source_url: POLY_HAVEN_SKY, modified: true },
+    sources: [own3(), { kind: "third_party", licence: "cc0-1.0", author: "Sergej Majboroda, Jarod Guest", url: POLY_HAVEN_SKY }],
+    ai_origin: "none",
+    licence: "free_attribution",
+    tier: "mid",
+    files: { "stadium.glb": "stadium.glb", "environment.ktx2": "environment.ktx2", "net.ktx2": "net.ktx2" }
+  },
+  {
+    item: "cimplify/stadium-crowd",
+    item_type: "model",
+    version: VERSION3,
+    name: "Stadium crowd",
+    description: "A skinned spectator crowd with idle, tense, cheer and groan animations",
+    tags: ["crowd", "stadium"],
+    credit: { title: "Stadium crowd", authors: [CIMPLIFY3], licence: CC03, licence_url: CC0_URL3, modified: false },
+    sources: [own3()],
+    ai_origin: "none",
+    licence: "free_attribution",
+    tier: "mid",
+    files: { "crowd.glb": "crowd.glb" }
+  },
+  {
+    item: "cimplify/football-impacts",
+    item_type: "sound",
+    version: VERSION3,
+    name: "Football impacts",
+    description: "Strike, glove, bounce, post and net sounds layered from Kenney's Impact Sounds",
+    tags: ["football", "impact", "sfx"],
+    credit: { title: "Football impacts", authors: ["Kenney", CIMPLIFY3], licence: CC03, licence_url: CC0_URL3, source_url: KENNEY_IMPACT, modified: true },
+    sources: [{ kind: "third_party", licence: "cc0-1.0", author: "Kenney", url: KENNEY_IMPACT }, own3()],
+    ai_origin: "none",
+    licence: "free_attribution",
+    tier: "mid",
+    files: {
+      "kick.m4a": "sounds/kick.m4a",
+      "glove.m4a": "sounds/glove.m4a",
+      "bounce.m4a": "sounds/bounce.m4a",
+      "post.m4a": "sounds/post.m4a",
+      "net.m4a": "sounds/net.m4a"
+    }
+  },
+  {
+    item: "kenney/interface-clicks",
+    item_type: "sound",
+    version: VERSION3,
+    name: "Interface clicks",
+    description: "Tap and confirm sounds from Kenney's Interface Sounds",
+    tags: ["ui", "sfx"],
+    credit: { title: "Interface Sounds", authors: ["Kenney"], licence: CC03, licence_url: CC0_URL3, source_url: KENNEY_INTERFACE, modified: false },
+    sources: [{ kind: "third_party", licence: "cc0-1.0", author: "Kenney", url: KENNEY_INTERFACE }],
+    ai_origin: "none",
+    licence: "free",
+    tier: "low",
+    files: { "tap.m4a": "sounds/tap.m4a", "confirm.m4a": "sounds/confirm.m4a" }
+  },
+  {
+    item: "cimplify/stadium-roar",
+    item_type: "sound",
+    version: VERSION3,
+    name: "Stadium roar",
+    description: "A synthesised crowd roar layered with applause in a large hall",
+    tags: ["crowd", "sfx"],
+    credit: { title: "Stadium roar", authors: ["eXpl0it3r", CIMPLIFY3], licence: CC03, licence_url: CC0_URL3, source_url: APPLAUSE, modified: true },
+    sources: [{ kind: "third_party", licence: "cc0-1.0", author: "eXpl0it3r", url: APPLAUSE }, own3()],
+    ai_origin: "none",
+    licence: "free_attribution",
+    tier: "mid",
+    files: { "roar.m4a": "sounds/roar.m4a" }
+  }
+];
+
+// src/interactives/workshop/packs/index.ts
+var PACK_SETS = [
+  { name: "penalty-kings", items: PENALTY_KINGS_PACK, assets: PENALTY_KINGS_ASSETS },
+  { name: "lagos-street", items: LAGOS_PACK, assets: LAGOS_ASSETS, generator: workshopAssets },
+  { name: "launch", items: LAUNCH_PACK, assets: LAUNCH_ASSETS }
+];
+function generatedAssets(set) {
+  if (set.generator === void 0) return /* @__PURE__ */ new Map();
+  return new Map(Object.entries(set.generator()).map(([file, bytes]) => [file, Buffer.from(bytes)]));
+}
+function packReader(repo, set, generated2) {
+  return (file) => {
+    if (!file.startsWith(GENERATED_PREFIX)) return readFileSync(path4.join(repo, set.assets, file));
+    const bytes = generated2.get(file.slice(GENERATED_PREFIX.length));
+    if (bytes === void 0) throw new Error(`${set.name} has no generated asset ${file}`);
+    return bytes;
+  };
+}
+async function packSet(repo, set) {
+  return packItems(set.items, packReader(repo, set, generatedAssets(set)));
+}
+async function packAll(repo, only) {
+  const sets = only === void 0 ? PACK_SETS : PACK_SETS.filter((set) => set.name === only);
+  if (sets.length === 0) throw new Error(`no Workshop pack named ${only}; packs: ${PACK_SETS.map((set) => set.name).join(", ")}`);
+  const packed2 = [];
+  for (const set of sets) packed2.push(...await packSet(repo, set));
+  return packed2;
+}
+var CONTENT_FILE = "content.toml";
+var SOURCE_DIR = "source";
+var PREVIEW_DIR = "previews";
+var ATTESTATION_VERSION = "2026-10-11";
+var ATTESTATION_TEXT = "I made this item, or I hold the rights to license it on the terms I choose. My source declarations are complete and accurate, the item uses no third-party brands, characters or recordings I have no right to, and I understand Cimplify never uses Workshop content to train models.";
+var MAX_UPLOAD_FILES = 512;
+var MAX_UPLOAD_FILE_BYTES = 64 * 1024 * 1024;
+var MAX_UPLOAD_BYTES = 256 * 1024 * 1024;
+var MAX_CREDIT_AUTHORS = 16;
+var ITEM_TYPES = [
+  "model",
+  "character",
+  "rig",
+  "animation",
+  "environment",
+  "texture",
+  "material",
+  "hdri",
+  "sound",
+  "music",
+  "font",
+  "vfx",
+  "shader",
+  "sprite",
+  "ui",
+  "component",
+  "template",
+  "tool"
+];
+var LISTINGS = ["listed", "unlisted", "team", "private"];
+var AI_ORIGINS = ["none", "assisted", "generated"];
+var SOURCE_KINDS = ["own_work", "commissioned", "third_party", "library_item", "ai_generator"];
+var SOURCE_LICENCES = ["cc0-1.0", "public-domain", "cc-by-3.0", "cc-by-4.0", "ofl-1.1", "mit", "apache-2.0", "bsd-3-clause", "own-work", "commissioned"];
+var LICENCE_KINDS = ["free_attribution", "free", "paid_per_game", "revenue_share", "team", "exclusive"];
+var DERIVATIVES = ["remixable", "no_derivatives"];
+var RATING_LEVELS = {
+  violence: ["none", "cartoon", "realistic", "graphic"],
+  sexuality: ["none", "suggestive", "explicit"],
+  language: ["none", "mild", "strong"],
+  fear: ["none", "mild", "intense"]
+};
+var TOOL_CAPABILITIES = ["read_source", "edit_source", "store_parts", "use_assistant"];
+var REFERENCE = /^[a-z0-9][a-z0-9_-]*\/[a-z0-9][a-z0-9_-]*$/;
+var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+var TAG = /^[a-z0-9-]{1,40}$/;
+var ContentProjectError = class extends Error {
+  constructor(problems) {
+    super(`${CONTENT_FILE} is invalid:
+${problems.map((p) => `  ${p}`).join("\n")}`);
+    this.problems = problems;
+  }
+  problems;
+};
+var Reader = class _Reader {
+  constructor(table, where, problems = []) {
+    this.table = table;
+    this.where = where;
+    this.problems = problems;
+  }
+  table;
+  where;
+  problems;
+  at(key) {
+    return this.where === "" ? key : `${this.where}.${key}`;
+  }
+  value(key) {
+    return this.table.entries.get(key);
+  }
+  string(key, required = true) {
+    const value = this.value(key);
+    if (value === void 0) {
+      if (required) this.problems.push(`${this.at(key)} is required`);
+      return void 0;
+    }
+    if (value.kind !== "string") {
+      this.problems.push(`${this.at(key)} must be a string`);
+      return void 0;
+    }
+    return value.value;
+  }
+  integer(key) {
+    const value = this.value(key);
+    if (value === void 0) return void 0;
+    if (value.kind !== "integer") {
+      this.problems.push(`${this.at(key)} must be an integer`);
+      return void 0;
+    }
+    return value.value;
+  }
+  boolean(key, fallback) {
+    const value = this.value(key);
+    if (value === void 0) return fallback;
+    if (value.kind !== "boolean") {
+      this.problems.push(`${this.at(key)} must be true or false`);
+      return fallback;
+    }
+    return value.value;
+  }
+  oneOf(key, allowed, fallback) {
+    const raw = this.string(key, fallback === void 0);
+    if (raw === void 0) return fallback;
+    if (!allowed.includes(raw)) {
+      this.problems.push(`${this.at(key)} must be one of ${allowed.join(", ")}`);
+      return fallback;
+    }
+    return raw;
+  }
+  strings(key) {
+    const value = this.value(key);
+    if (value === void 0) return [];
+    if (value.kind !== "array" || value.items.some((item) => item.kind !== "string")) {
+      this.problems.push(`${this.at(key)} must be an array of strings`);
+      return [];
+    }
+    return value.items.map((item) => item.value);
+  }
+  subtable(key) {
+    const value = this.value(key);
+    if (value === void 0) return void 0;
+    if (value.kind !== "table") {
+      this.problems.push(`${this.at(key)} must be a table`);
+      return void 0;
+    }
+    return this.child(value, key);
+  }
+  tables(key) {
+    const value = this.value(key);
+    if (value === void 0) return [];
+    if (value.kind !== "array" || value.items.some((item) => item.kind !== "table")) {
+      this.problems.push(`${this.at(key)} must be an array of tables ([[${key}]])`);
+      return [];
+    }
+    return value.items.map((item, index) => this.child(item, `${key}[${index}]`));
+  }
+  child(table, key) {
+    return new _Reader(table, this.at(key), this.problems);
+  }
+};
+function optional2(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function readSource(source) {
+  const kind = source.oneOf("kind", SOURCE_KINDS);
+  const licence = source.oneOf("licence", SOURCE_LICENCES);
+  const author = source.string("author");
+  if (kind === void 0 || licence === void 0 || author === void 0) return null;
+  const url = source.string("url", false);
+  if (kind === "third_party" && url === void 0) source.problems.push("a third_party source needs its url");
+  return { kind, licence, author, ...optional2("url", url), ...optional2("digest", source.string("digest", false)), ...optional2("attribution", source.string("attribution", false)) };
+}
+function readOffer(offer) {
+  const kind = offer.oneOf("kind", LICENCE_KINDS);
+  if (kind === void 0) return null;
+  const derivatives = offer.oneOf("derivatives", DERIVATIVES, "remixable") ?? "remixable";
+  const priceTable = offer.subtable("price");
+  let price;
+  if (priceTable !== void 0) {
+    const minor = priceTable.integer("minor");
+    const currency = priceTable.string("currency");
+    if (minor === void 0 || currency === void 0 || !/^[A-Z]{3}$/.test(currency) || minor <= 0) {
+      offer.problems.push("price needs a positive integer minor and an ISO 4217 currency");
+    } else price = { minor, currency };
+  }
+  const share = offer.integer("share_bps");
+  const derivativeShare = offer.integer("derivative_share_bps");
+  const team = offer.strings("team_business_ids");
+  const free = kind === "free" || kind === "free_attribution";
+  if (free && (price !== void 0 || share !== void 0)) offer.problems.push(`a ${kind} offer carries no price or share`);
+  if ((kind === "paid_per_game" || kind === "exclusive") && price === void 0) offer.problems.push(`a ${kind} offer needs a price`);
+  if (kind === "revenue_share" && (share === void 0 || share < 1 || share > 5e3)) offer.problems.push("a revenue_share offer needs share_bps between 1 and 5000");
+  if (kind === "team" && team.length === 0) offer.problems.push("a team offer names its team_business_ids");
+  return {
+    kind,
+    derivatives,
+    generation_allowed: offer.boolean("generation_allowed", free),
+    ...optional2("price", price),
+    ...optional2("share_bps", share),
+    ...optional2("derivative_share_bps", derivativeShare),
+    ...team.length === 0 ? {} : { team_business_ids: team }
+  };
+}
+function readRef(reader) {
+  const item = reader.string("item");
+  const version = reader.string("version");
+  if (item === void 0 || version === void 0) return null;
+  if (!REFERENCE.test(item)) reader.problems.push(`${item} is not an <owner>/<slug> reference`);
+  if (!SEMVER.test(version)) reader.problems.push(`${version} is not an exact version`);
+  return { item, version };
+}
+function readTool(root, itemType) {
+  const tool = root.subtable("tool");
+  if (itemType !== "tool") {
+    if (tool !== void 0) root.problems.push("only a tool item has a [tool] table");
+    return void 0;
+  }
+  const capabilities = tool?.strings("capabilities") ?? [];
+  if (capabilities.length === 0) {
+    root.problems.push(`a tool names what it may do: [tool] capabilities from ${TOOL_CAPABILITIES.join(", ")}`);
+    return void 0;
+  }
+  const unknown = capabilities.filter((c) => !TOOL_CAPABILITIES.includes(c));
+  if (unknown.length > 0) root.problems.push(`tool.capabilities must be among ${TOOL_CAPABILITIES.join(", ")}; ${unknown.join(", ")} is not`);
+  if (new Set(capabilities).size !== capabilities.length) root.problems.push("name each tool capability once");
+  return { capabilities };
+}
+function readRating(root) {
+  const rating = root.subtable("rating");
+  const level = (key) => rating?.oneOf(key, RATING_LEVELS[key], "none") ?? "none";
+  return {
+    violence: level("violence"),
+    sexuality: level("sexuality"),
+    language: level("language"),
+    fear: level("fear"),
+    simulated_gambling: rating?.boolean("simulated_gambling", false) ?? false
+  };
+}
+function parseContentToml(source) {
+  let table;
+  try {
+    table = parseToml(source);
+  } catch (err) {
+    const message = err instanceof TomlSyntaxError ? err.message : String(err);
+    throw new ContentProjectError([message]);
+  }
+  const root = new Reader(table, "");
+  const item = root.string("item") ?? "";
+  if (item !== "" && !REFERENCE.test(item)) root.problems.push("item must be <owner handle>/<slug> in lowercase");
+  const itemType = root.oneOf("type", ITEM_TYPES) ?? "model";
+  const version = root.string("version") ?? "";
+  if (version !== "" && !SEMVER.test(version)) root.problems.push("version must be major.minor.patch");
+  const name = root.string("name") ?? "";
+  if (name.trim() === "" || Buffer.byteLength(name) > 120) root.problems.push("name must be 1 to 120 bytes");
+  const description = root.string("description", false) ?? "";
+  const tags = root.strings("tags");
+  for (const tag of tags) if (!TAG.test(tag)) root.problems.push(`tag ${tag} must be lowercase words joined by hyphens`);
+  const listing = root.oneOf("listing", LISTINGS, "listed") ?? "listed";
+  const aiOrigin = root.oneOf("ai_origin", AI_ORIGINS);
+  if (aiOrigin === void 0 && root.value("ai_origin") === void 0) root.problems.push("ai_origin is required: none, assisted or generated");
+  const attestation = root.string("attestation", false) ?? "";
+  const sources = root.tables("sources").map(readSource).filter((s) => s !== null);
+  if (sources.length === 0) root.problems.push("declare at least one [[sources]] entry");
+  if (sources.some((s) => s.kind === "ai_generator") && aiOrigin === "none") root.problems.push("an ai_generator source makes ai_origin assisted or generated");
+  const offers = root.tables("offers").map(readOffer).filter((o) => o !== null);
+  if (offers.length === 0) root.problems.push("declare at least one [[offers]] licence");
+  const kinds = offers.map((o) => o.kind);
+  if (new Set(kinds).size !== kinds.length) root.problems.push("name each offer licence once");
+  const dependencies = root.tables("dependencies").map(readRef).filter((r) => r !== null);
+  const basedOn = root.tables("based_on").map(readRef).filter((r) => r !== null);
+  if (sources.some((s) => s.kind === "library_item") && basedOn.length === 0) root.problems.push("a library_item source needs a [[based_on]] upstream");
+  const credit = root.subtable("credit");
+  const authors = credit?.strings("authors") ?? [];
+  const creditAuthors = authors.length > 0 ? authors : [...new Set(sources.map((s) => s.author))];
+  if (creditAuthors.length === 0 || creditAuthors.length > MAX_CREDIT_AUTHORS) root.problems.push("credit needs between 1 and 16 authors");
+  const title = credit?.string("title", false);
+  const seller = root.string("seller_business_id", false);
+  const rating = readRating(root);
+  const tool = readTool(root, itemType);
+  if (root.problems.length > 0) throw new ContentProjectError(root.problems);
+  return {
+    item,
+    itemType,
+    version,
+    manifest: {
+      name,
+      description,
+      tags,
+      listing,
+      sources,
+      ai_origin: aiOrigin ?? "none",
+      rating,
+      attestation,
+      offers,
+      dependencies,
+      based_on: basedOn,
+      ...optional2("seller_business_id", seller),
+      credit: { ...optional2("title", title), authors: creditAuthors },
+      ...optional2("tool", tool)
+    }
+  };
+}
+function withAttestation(project) {
+  return { ...project, manifest: { ...project.manifest, attestation: ATTESTATION_VERSION } };
+}
+async function walk(root, dir, out) {
+  let entries;
+  try {
+    entries = await promises.readdir(path4.join(root, dir), { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+    if (entry.name.startsWith(".")) continue;
+    const relative = `${dir}/${entry.name}`;
+    if (entry.isDirectory()) await walk(root, relative, out);
+    else if (entry.isFile()) out.push(relative);
+  }
+}
+async function sourcePaths(root) {
+  const paths = [];
+  await walk(root, SOURCE_DIR, paths);
+  return paths;
+}
+async function collectFiles(root) {
+  const paths = [];
+  await walk(root, SOURCE_DIR, paths);
+  await walk(root, PREVIEW_DIR, paths);
+  if (paths.length === 0) throw new ContentProjectError([`put the item's files under ${SOURCE_DIR}/`]);
+  if (paths.length > MAX_UPLOAD_FILES) throw new ContentProjectError([`at most ${MAX_UPLOAD_FILES} files may be uploaded`]);
+  const files = [];
+  let total = 0;
+  for (const relative of paths) {
+    const absolute = path4.join(root, relative);
+    const bytes = await promises.readFile(absolute);
+    if (bytes.length === 0 || bytes.length > MAX_UPLOAD_FILE_BYTES) throw new ContentProjectError([`${relative} is empty or larger than 64 MiB`]);
+    total += bytes.length;
+    files.push({ path: relative, digest: createHash("sha256").update(bytes).digest("hex"), size: bytes.length, absolute });
+  }
+  if (total > MAX_UPLOAD_BYTES) throw new ContentProjectError(["the files total more than 256 MiB"]);
+  return files;
+}
+var STARTER_TOOL_SCRIPT = [
+  "function outline(): any {",
+  "  return production.read({ depth: 1 });",
+  "}",
+  "",
+  "export default { outline };",
+  ""
+].join("\n");
+function starterContentToml(item, itemType, author) {
+  const name = item.split("/")[1].replace(/[-_]/g, " ");
+  return [
+    `item = ${quoteTomlString(item)}`,
+    `type = ${quoteTomlString(itemType)}`,
+    `version = "1.0.0"`,
+    `name = ${quoteTomlString(name.charAt(0).toUpperCase() + name.slice(1))}`,
+    `description = ""`,
+    `tags = []`,
+    `listing = "listed"`,
+    `ai_origin = "none"`,
+    "",
+    "[rating]",
+    `violence = "none"`,
+    `sexuality = "none"`,
+    `language = "none"`,
+    `fear = "none"`,
+    "simulated_gambling = false",
+    "",
+    "[[sources]]",
+    `kind = "own_work"`,
+    `licence = "own-work"`,
+    `author = ${quoteTomlString(author)}`,
+    "",
+    "[[offers]]",
+    `kind = "free_attribution"`,
+    `derivatives = "remixable"`,
+    "generation_allowed = true",
+    "",
+    "[credit]",
+    `authors = [${quoteTomlString(author)}]`,
+    "",
+    ...itemType === "tool" ? ["[tool]", `capabilities = ["read_source"]`, ""] : []
+  ].join("\n");
+}
+async function initContentProject(dir, item, itemType, author) {
+  if (!REFERENCE.test(item)) throw new ContentProjectError(["--item must be <owner handle>/<slug> in lowercase"]);
+  const file = path4.join(dir, CONTENT_FILE);
+  try {
+    await promises.access(file);
+    throw new ContentProjectError([`${file} already exists`]);
+  } catch (err) {
+    if (err instanceof ContentProjectError) throw err;
+  }
+  await promises.mkdir(path4.join(dir, SOURCE_DIR), { recursive: true });
+  await promises.mkdir(path4.join(dir, PREVIEW_DIR), { recursive: true });
+  await promises.writeFile(file, starterContentToml(item, itemType, author));
+  if (itemType === "tool") await promises.writeFile(path4.join(dir, SOURCE_DIR, `${item.split("/")[1]}.ts`), STARTER_TOOL_SCRIPT);
+  return file;
+}
+var TERMINAL_UPLOAD_STAGES = /* @__PURE__ */ new Set(["in_review", "listed", "refused"]);
+var UPLOAD_POLL_MS = 1e3;
+var UPLOAD_DEADLINE_MS = 15 * 60 * 1e3;
+var ITEMS_PATH = "/v1/content/items";
+var UPLOADS_PATH = "/v1/content/uploads";
+var HttpWorkshopRemote = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async createItem(item) {
+    try {
+      await this.client.post(ITEMS_PATH, item);
+      return "created";
+    } catch (err) {
+      if (err instanceof CliError && err.code === CLI_ERROR_CODE.ALREADY_LINKED) return "exists";
+      throw err;
+    }
+  }
+  beginUpload(reference, upload) {
+    return this.client.post(`${ITEMS_PATH}/${reference}/versions`, upload);
+  }
+  uploadSource(uploadId, digest, bytes) {
+    return this.client.putBytes(`${UPLOADS_PATH}/${encodeURIComponent(uploadId)}/sources/${digest}`, bytes);
+  }
+  complete(uploadId) {
+    return this.client.post(`${UPLOADS_PATH}/${encodeURIComponent(uploadId)}/complete`);
+  }
+  status(uploadId) {
+    return this.client.get(`${UPLOADS_PATH}/${encodeURIComponent(uploadId)}`);
+  }
+};
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function publishContent(project, files, remote, options = {}) {
+  const sleep = options.sleep ?? delay;
+  const now = options.now ?? Date.now;
+  const read = options.read ?? ((file) => promises.readFile(file.absolute));
+  const manifest = project.manifest;
+  const created = await remote.createItem({
+    reference: project.item,
+    item_type: project.itemType,
+    name: manifest.name,
+    description: manifest.description,
+    tags: manifest.tags,
+    listing: manifest.listing,
+    ...options.owner === void 0 ? {} : { owner: options.owner }
+  });
+  options.progress?.onCreated?.(created);
+  const listed = files.map(({ path: path5, digest, size }) => ({ path: path5, digest, size }));
+  let status = await remote.beginUpload(project.item, { version: project.version, manifest, files: listed });
+  const missing = new Set(status.missing ?? []);
+  const wanted = files.filter((file) => missing.has(file.digest));
+  const sent = /* @__PURE__ */ new Set();
+  for (const file of wanted) {
+    if (sent.has(file.digest)) continue;
+    await remote.uploadSource(status.upload_id, file.digest, await read(file));
+    sent.add(file.digest);
+    options.progress?.onUploaded?.(file, sent.size, missing.size);
+  }
+  status = await remote.complete(status.upload_id);
+  options.progress?.onStage?.(status);
+  if (status.stage === "receiving" && (status.missing ?? []).length > 0) {
+    throw new CliError(CLI_ERROR_CODE.SERVER_ERROR, `the Workshop still waits for ${(status.missing ?? []).length} file(s) of ${project.item}@${project.version}; run publish again`);
+  }
+  const deadline = now() + (options.deadlineMs ?? UPLOAD_DEADLINE_MS);
+  while (!TERMINAL_UPLOAD_STAGES.has(status.stage)) {
+    if (now() > deadline) throw new CliError(CLI_ERROR_CODE.TIMEOUT, `the upload of ${project.item}@${project.version} is still ${status.stage}; check it with cimplify workshop status ${status.upload_id}`);
+    await sleep(options.pollMs ?? UPLOAD_POLL_MS);
+    const next = await remote.status(status.upload_id);
+    if (next.stage !== status.stage) options.progress?.onStage?.(next);
+    status = next;
+  }
+  return {
+    item: project.item,
+    version: project.version,
+    files: files.length,
+    uploaded: sent.size,
+    skipped: new Set(files.map((file) => file.digest)).size - sent.size,
+    status
+  };
+}
+var TOOL_ITEM_TYPE = "tool";
+var TOOL_SCRIPT_EXTENSION = ".ts";
+var TOOL_CHUNK_EXTENSION = ".luauc";
+var LUAU_SOURCE_EXTENSION = ".luau";
+var DECLARATION_EXTENSION = ".d.ts";
+var LUAU_VERSION_MIN = 3;
+var LUAU_VERSION_MAX = 13;
+var LUAU_VERSION_TYPES = 4;
+var LUAU_TYPES_MIN = 1;
+var LUAU_TYPES_MAX = 3;
+var LUAU_VARINT_CONTINUE = 128;
+var LUAU_VARINT_MAX_BYTES = 5;
+var ToolBuildError = class extends Error {
+  constructor(problems) {
+    super(`the tool did not build:
+${problems.map((p) => `  ${p}`).join("\n")}`);
+    this.problems = problems;
+  }
+  problems;
+};
+function isLuauBytecode(bytes) {
+  const version = bytes[0];
+  if (version === void 0 || version < LUAU_VERSION_MIN || version > LUAU_VERSION_MAX)
+    return false;
+  let at = 1;
+  if (version >= LUAU_VERSION_TYPES) {
+    const types = bytes[at];
+    if (types === void 0 || types < LUAU_TYPES_MIN || types > LUAU_TYPES_MAX) return false;
+    at += 1;
+  }
+  const end = Math.min(bytes.length, at + LUAU_VARINT_MAX_BYTES);
+  for (let i = at; i < end; i++) if ((bytes[i] & LUAU_VARINT_CONTINUE) === 0) return true;
+  return false;
+}
+function stem(relative, extension) {
+  return relative.slice(0, relative.length - extension.length);
+}
+function isScript(relative) {
+  return relative.endsWith(TOOL_SCRIPT_EXTENSION) && !relative.endsWith(DECLARATION_EXTENSION);
+}
+async function buildTool(root) {
+  const paths = await sourcePaths(root);
+  const luau = paths.filter((p) => p.toLowerCase().endsWith(LUAU_SOURCE_EXTENSION));
+  if (luau.length > 0) {
+    throw new ToolBuildError(
+      luau.map(
+        (p) => `${p} is Luau source; write the tool in TypeScript as ${stem(p, LUAU_SOURCE_EXTENSION)}${TOOL_SCRIPT_EXTENSION} and publish compiles it to ${TOOL_CHUNK_EXTENSION}`
+      )
+    );
+  }
+  const scripts = paths.filter(isScript);
+  const chunks = paths.filter((p) => p.endsWith(TOOL_CHUNK_EXTENSION));
+  if (scripts.length > 1) {
+    throw new ToolBuildError([
+      `a tool is one TypeScript script in ${SOURCE_DIR}/; found ${scripts.join(", ")}`
+    ]);
+  }
+  const script = scripts[0];
+  if (script === void 0) {
+    const chunk2 = chunks[0];
+    if (chunk2 === void 0 || chunks.length > 1) {
+      throw new ToolBuildError([
+        `a tool needs its TypeScript script in ${SOURCE_DIR}/ (for example ${SOURCE_DIR}/tool${TOOL_SCRIPT_EXTENSION}); publish compiles it to the ${TOOL_CHUNK_EXTENSION} chunk the Workshop runs`
+      ]);
+    }
+    const bytes = await promises.readFile(path4.join(root, chunk2));
+    if (!isLuauBytecode(bytes))
+      throw new ToolBuildError([`${chunk2} is not compiled Luau bytecode`]);
+    return { script: null, chunk: chunk2, bytes: bytes.length };
+  }
+  const chunk = `${stem(script, TOOL_SCRIPT_EXTENSION)}${TOOL_CHUNK_EXTENSION}`;
+  const stale = chunks.filter((p) => p !== chunk);
+  if (stale.length > 0) {
+    throw new ToolBuildError(
+      stale.map(
+        (p) => `${p} is not built from ${script}; remove it, since a tool carries one compiled chunk`
+      )
+    );
+  }
+  const compiled = compileScript(
+    path4.basename(script),
+    await promises.readFile(path4.join(root, script), "utf8"),
+    "tool"
+  );
+  if (!compiled.ok) {
+    throw new ToolBuildError(
+      compiled.diagnostics.map((d) => `${script}:${d.line}:${d.column} ${d.message}`)
+    );
+  }
+  if (!isLuauBytecode(compiled.bytecode))
+    throw new ToolBuildError([`${script} did not compile to Luau bytecode`]);
+  await promises.writeFile(path4.join(root, chunk), compiled.bytecode);
+  return { script, chunk, bytes: compiled.bytecode.length };
+}
+
+// src/interactives/commands/workshop.ts
+var USAGE = [
+  "usage: cimplify workshop pack <out-dir> [--repo <dir>] [--pack <name>]",
+  "       cimplify workshop import [--repo <dir>] [--pack <name>] [--owner <account id>]",
+  "       cimplify workshop init <dir> --type <item type> --item <handle/slug> [--author <name>]",
+  "       cimplify workshop publish [dir] [--accept-attestation] [--business <business id>]",
+  "       cimplify workshop status <upload id>"
+].join("\n");
+var PACK = "pack";
+var IMPORT = "import";
+var INIT = "init";
+var PUBLISH = "publish";
+var STATUS = "status";
+var IMPORT_PATH = "/v1/platform/content/versions";
+var BLOB_DIR = "blobs";
+var RESOLUTION_FILE = "resolution.json";
+var DEFAULT_OWNER = "system:cimplify";
+var DEFAULT_AUTHOR = "Me";
+function writeLocalWorkshop(out, packed2) {
+  mkdirSync(path4.join(out, BLOB_DIR), { recursive: true });
+  let blobs = 0;
+  for (const item of packed2) {
+    for (const [digest, bytes] of item.blobs) {
+      writeFileSync(path4.join(out, BLOB_DIR, digest), bytes);
+      blobs += 1;
+    }
+  }
+  writeFileSync(path4.join(out, RESOLUTION_FILE), JSON.stringify(resolutionOf(packed2), null, 2));
+  return blobs;
+}
+async function signedInClient(why) {
+  const auth = await readAuthOrNull();
+  if (auth === null) throw new CliError(CLI_ERROR_CODE.NOT_LOGGED_IN, why);
+  return ApiClient.fromAuth(auth);
+}
+async function packed(repo, only) {
+  try {
+    return await packAll(repo, only);
+  } catch (err) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, err instanceof Error ? err.message : String(err));
+  }
+}
+async function confirmAttestation(accepted) {
+  info(bold("Workshop attestation"));
+  info(ATTESTATION_TEXT);
+  if (accepted || isAutoYes()) return;
+  if (!isInteractive()) {
+    throw new CliError(CLI_ERROR_CODE.INTERACTIVE_REQUIRED, `accept the Workshop attestation with --accept-attestation (version ${ATTESTATION_VERSION})`);
+  }
+  if (!await promptYesNo("Do you accept this attestation?")) throw new CliError(CLI_ERROR_CODE.ABORTED, "publishing needs the Workshop attestation");
+}
+function describe(status) {
+  switch (status.stage) {
+    case "listed":
+      return `listed${status.version_digest ? ` ${dim(status.version_digest.slice(0, 12))}` : ""}`;
+    case "in_review":
+      return "waiting for review; it lists once a reviewer approves it";
+    case "refused":
+      return `refused: ${status.refusal_reason ?? "unknown"}${status.refusal_detail ? ` (${status.refusal_detail})` : ""}`;
+    default:
+      return status.stage;
+  }
+}
+async function publishDirectory(dir, remote, accept, business) {
+  let project;
+  let files;
+  try {
+    project = parseContentToml(await promises.readFile(path4.join(dir, CONTENT_FILE), "utf8"));
+    if (project.itemType === TOOL_ITEM_TYPE) {
+      const built = await buildTool(dir);
+      if (built.script !== null) info(dim(`Compiled ${built.script} to ${built.chunk} (${built.bytes} bytes)`));
+    }
+    files = await collectFiles(dir);
+  } catch (err) {
+    if (err instanceof ContentProjectError || err instanceof ToolBuildError) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, err.message);
+    if (err.code === "ENOENT") throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `no ${CONTENT_FILE} in ${dir}; start one with cimplify workshop init`);
+    throw err;
+  }
+  await confirmAttestation(accept || project.manifest.attestation === ATTESTATION_VERSION);
+  step(`Publishing ${project.item}@${project.version} (${files.length} files)`);
+  return publishContent(withAttestation(project), files, remote, {
+    ...business === void 0 ? {} : { owner: { kind: "business", id: business } },
+    progress: {
+      onCreated: (outcome) => info(dim(outcome === "created" ? `Created ${project.item}` : `${project.item} exists`)),
+      onUploaded: (file, done, total) => info(dim(`Uploaded ${file.path} (${done}/${total})`)),
+      onStage: (status) => info(describe(status))
+    }
+  });
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const [action, target] = args.positional;
+  const repo = path4.resolve(flagString(args, "repo") ?? process.cwd());
+  const only = flagString(args, "pack");
+  if (action === PACK && target) {
+    const items = await packed(repo, only);
+    const blobs = writeLocalWorkshop(path4.resolve(target), items);
+    success(`Packed ${items.length} Workshop items (${blobs} blobs) into ${target}`);
+    info(dim(`Use it with CIMPLIFY_CONTENT_REMOTE=fake CIMPLIFY_CONTENT_FAKE_ROOT=${path4.resolve(target)} cimplify add <item>`));
+    result(items.map((p) => ({ item: p.item.item, version: p.item.version, version_digest: p.versionDigest })));
+    return;
+  }
+  if (action === IMPORT) {
+    const client = await signedInClient("importing curated Workshop content needs a signed-in operator account");
+    const owner = { kind: "account", id: flagString(args, "owner") ?? DEFAULT_OWNER };
+    const imported = [];
+    for (const item of await packed(repo, only)) {
+      imported.push(await client.post(IMPORT_PATH, importBody(item, owner)));
+      info(`${item.item.item} ${item.item.version}`);
+    }
+    success(`Imported ${imported.length} Workshop items`);
+    result(imported);
+    return;
+  }
+  if (action === INIT && target) {
+    const itemType = flagString(args, "type");
+    const item = flagString(args, "item");
+    if (itemType === void 0 || !ITEM_TYPES.includes(itemType) || item === void 0) {
+      throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `init needs --item <handle/slug> and --type ${ITEM_TYPES.join("|")}`);
+    }
+    try {
+      const file = await initContentProject(path4.resolve(target), item, itemType, flagString(args, "author") ?? DEFAULT_AUTHOR);
+      success(`Wrote ${file}; put the item's files under source/ and run cimplify workshop publish`);
+      result({ content_toml: file });
+    } catch (err) {
+      if (err instanceof ContentProjectError) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, err.message);
+      throw err;
+    }
+    return;
+  }
+  if (action === PUBLISH) {
+    const client = await signedInClient("publishing to the Workshop needs a signed-in account; run cimplify login");
+    const summary = await publishDirectory(path4.resolve(target ?? process.cwd()), new HttpWorkshopRemote(client), flagBool(args, "accept-attestation"), flagString(args, "business"));
+    if (summary.status.stage === "refused") failure(`${summary.item}@${summary.version} was ${describe(summary.status)}`);
+    else if (summary.status.stage === "in_review") warn(`${summary.item}@${summary.version} is ${describe(summary.status)}`);
+    else success(`${summary.item}@${summary.version} is ${describe(summary.status)}`);
+    result(summary);
+    if (summary.status.stage === "refused") throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, describe(summary.status));
+    return;
+  }
+  if (action === STATUS && target) {
+    const client = await signedInClient("reading a Workshop upload needs a signed-in account");
+    const status = await new HttpWorkshopRemote(client).status(target);
+    info(describe(status));
+    result(status);
+    return;
+  }
+  throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, USAGE);
+}
+
+export { run as default, publishDirectory, writeLocalWorkshop };