@cimplify/sdk 0.108.0 → 0.110.2

package/dist/interactives-production.mjs

@@ -0,0 +1,1170 @@
+import { LuaTable, Args, register, LuaState, blobEvaluator, BudgetExceeded, LuaError, compileBytecode } from './chunk-Y7JWLB25.mjs';
+import './chunk-MN3YETVN.mjs';
+import './chunk-KDQOR4QQ.mjs';
+import './chunk-V7ZRH3PY.mjs';
+import './chunk-N4RGGDEL.mjs';
+import './chunk-25T4JHEA.mjs';
+
+// src/interactives/production/source.ts
+var ProductionSourceError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "ProductionSourceError";
+  }
+}, ID = /^\d+$/;
+function idText(id) {
+  return id.toString();
+}
+function fail(message) {
+  throw new ProductionSourceError(`the production source is malformed: ${message}`);
+}
+function nodeId(value) {
+  return typeof value != "string" || !ID.test(value) ? fail(`"${String(value)}" is not a node id`) : BigInt(value);
+}
+var ProductionSource = class _ProductionSource {
+  constructor(tree) {
+    this.byId = /* @__PURE__ */ new Map();
+    let visit = (value, parent) => {
+      if (typeof value != "object" || value === null || Array.isArray(value)) return fail("a node is not an object");
+      let raw = value, id = nodeId(raw.id);
+      if (typeof raw.kind != "string") return fail(`node ${id} has no kind`);
+      if (this.byId.has(id)) return fail(`node ${id} appears twice`);
+      let fields = typeof raw.fields == "object" && raw.fields !== null && !Array.isArray(raw.fields) ? raw.fields : {}, children = [], order = Array.isArray(raw.order) ? raw.order.filter((b) => typeof b == "number") : [], node2 = { id, kind: raw.kind, parent: parent ?? id, order, fields, children };
+      this.byId.set(id, node2);
+      let list2 = Array.isArray(raw.children) ? raw.children : [];
+      for (let child of list2) children.push(visit(child, id));
+      return id;
+    };
+    this.root = visit(tree, null);
+  }
+  static parse(json) {
+    let tree;
+    try {
+      tree = JSON.parse(json);
+    } catch {
+      return fail("not JSON");
+    }
+    return new _ProductionSource(tree);
+  }
+  get size() {
+    return this.byId.size;
+  }
+  get(id) {
+    return this.byId.get(id) ?? null;
+  }
+  children(parent) {
+    return this.byId.get(parent)?.children ?? [];
+  }
+  field(id, name) {
+    return this.byId.get(id)?.fields[name] ?? null;
+  }
+  isWithin(id, ancestor) {
+    let at = this.byId.get(id) ?? null;
+    for (; at !== null; ) {
+      if (at.id === ancestor) return true;
+      if (at.id === this.root) return false;
+      at = this.byId.get(at.parent) ?? null;
+    }
+    return false;
+  }
+  json(id = this.root, depth = 1) {
+    let node2 = this.byId.get(id);
+    if (node2 === void 0) return null;
+    let out = { id: idText(node2.id), kind: node2.kind, fields: node2.fields };
+    if (depth <= 0) return out;
+    let children = [];
+    for (let child of node2.children) {
+      let json = this.json(child, depth - 1);
+      json !== null && children.push(json);
+    }
+    return { ...out, children };
+  }
+};
+
+// src/interactives/production/documents.ts
+var THING_KIND = "thing", WORLD_KIND = "world", BINDING_KIND = "binding", MUSIC_KIND = "music", CROWD_KIND = "crowd";
+function node(kind, fields, children = []) {
+  let kept = {};
+  for (let [name, value] of Object.entries(fields)) value != null && (kept[name] = value);
+  return { kind, fields: kept, children };
+}
+function num(fields, name, fallback) {
+  let value = fields[name];
+  return typeof value == "number" ? value : fallback;
+}
+function maybe(fields, name) {
+  let value = fields[name];
+  return typeof value == "number" ? value : null;
+}
+function text(fields, name, fallback = "") {
+  let value = fields[name];
+  return typeof value == "string" ? value : fallback;
+}
+function texts(fields, name) {
+  let value = fields[name];
+  return Array.isArray(value) ? value.filter((item) => typeof item == "string") : [];
+}
+function nums(fields, name) {
+  let value = fields[name];
+  return Array.isArray(value) ? value.filter((item) => typeof item == "number") : [];
+}
+function vec3(fields, name) {
+  let [x = 0, y = 0, z = 0] = nums(fields, name);
+  return [x, y, z];
+}
+function point(fields, name) {
+  let [x = 0, y = 0] = nums(fields, name);
+  return [x, y];
+}
+var CAP_TIERS = ["low", "mid", "high"];
+function of(children, kind) {
+  return children.filter((child) => child.kind === kind);
+}
+function shapeFields(shape) {
+  switch (shape.kind) {
+    case "box":
+      return { shape: "box", size: [...shape.size] };
+    case "rounded":
+      return { shape: "rounded", size: [...shape.size], radius: shape.radius };
+    case "sphere":
+      return { shape: "sphere", radius: shape.radius };
+    case "cylinder":
+      return { shape: "cylinder", radius: shape.radius, height: shape.height };
+    case "tube":
+      return { shape: "tube", radius: shape.radius, length: shape.length };
+  }
+}
+function shapeOf(fields) {
+  let size = vec3(fields, "size"), radius = num(fields, "radius", 0);
+  switch (text(fields, "shape")) {
+    case "rounded":
+      return { kind: "rounded", size, radius };
+    case "sphere":
+      return { kind: "sphere", radius };
+    case "cylinder":
+      return { kind: "cylinder", radius, height: num(fields, "height", 0) };
+    case "tube":
+      return { kind: "tube", radius, length: num(fields, "length", 0) };
+    default:
+      return { kind: "box", size };
+  }
+}
+function thingSpec(thing) {
+  let parts = thing.parts.map(
+    (part) => node("thing_part", { name: part.name, id: part.id, ...shapeFields(part.shape), at: [...part.at], turn: [...part.turn], material: part.material, combine: part.combine, mirror: part.mirror })
+  ), effects = thing.effects.map(
+    (effect) => node("thing_effect", {
+      kind: effect.kind,
+      at: [...effect.at],
+      size: effect.size,
+      starts_after: effect.startsAfter ?? null,
+      lasts: effect.lasts !== void 0 && effect.lasts > 0 ? effect.lasts : null,
+      color: effect.color ?? null,
+      sound: effect.sound ?? null
+    })
+  );
+  return node(THING_KIND, { name: thing.name }, [...parts, ...effects]);
+}
+function thingOf(spec) {
+  let parts = of(spec.children, "thing_part").map(
+    ({ fields }) => ({
+      id: text(fields, "id"),
+      name: text(fields, "name"),
+      shape: shapeOf(fields),
+      at: vec3(fields, "at"),
+      turn: vec3(fields, "turn"),
+      material: text(fields, "material"),
+      combine: text(fields, "combine", "join"),
+      mirror: text(fields, "mirror", "none")
+    })
+  ), effects = of(spec.children, "thing_effect").map(({ fields }) => {
+    let effect = { kind: text(fields, "kind", "fire"), at: vec3(fields, "at"), size: num(fields, "size", 0) }, startsAfter = maybe(fields, "starts_after"), lasts = maybe(fields, "lasts"), color = maybe(fields, "color"), sound = fields.sound;
+    return {
+      ...effect,
+      ...startsAfter === null ? {} : { startsAfter },
+      ...lasts === null ? {} : { lasts },
+      ...color === null ? {} : { color },
+      sound: typeof sound == "string" ? sound : null
+    };
+  });
+  return { name: text(spec.fields, "name"), parts, effects };
+}
+function worldSpec(world) {
+  let placement = (layer) => (entry) => node("placement", { layer, kind: entry.kind, at: [...entry.at], yaw: entry.yaw }), children = [
+    ...world.ground.map((stroke) => node("ground_stroke", { op: stroke.op, at: [...stroke.at], radius: stroke.radius, strength: stroke.strength, target: stroke.target, layer: stroke.layer })),
+    ...world.roads.map(
+      (road) => node(
+        "road",
+        { width: road.width },
+        road.points.map((at) => node("road_point", { at: [...at] }))
+      )
+    ),
+    ...world.buildings.map(placement("buildings")),
+    ...world.props.map(placement("props")),
+    ...world.scatters.map((s) => node("scatter", { layer: s.layer, kinds: [...s.kinds], at: [...s.at], radius: s.radius, count: s.count, spacing: s.spacing, seed: s.seed })),
+    ...world.crowds.map((c) => node("crowd_area", { at: [...c.at], radius: c.radius, count: c.count, kinds: [...c.kinds] })),
+    ...world.lights.map((l) => node("world_light", { at: [...l.at], height: l.height, color: l.color, intensity: l.intensity })),
+    ...world.sounds.map((s) => node("sound_zone", { at: [...s.at], radius: s.radius, sound: s.sound })),
+    ...world.gates.map((at) => node("gate", { at: [...at] })),
+    ...CAP_TIERS.flatMap((tier) => {
+      let cap = world.crowdCaps?.[tier];
+      return cap == null ? [] : [node("crowd_cap", { tier, cap })];
+    })
+  ];
+  return node(WORLD_KIND, { name: world.name, place: world.place, size: [...world.size], hour: world.sky.hour, weather: world.sky.weather, day_minutes: world.sky.dayMinutes }, children);
+}
+function worldOf(spec) {
+  let f = spec.fields, placements = (layer) => of(spec.children, "placement").filter((child) => text(child.fields, "layer") === layer).map(({ fields }) => ({ kind: text(fields, "kind"), at: point(fields, "at"), yaw: num(fields, "yaw", 0) })), caps = {};
+  for (let { fields } of of(spec.children, "crowd_cap")) {
+    let tier = text(fields, "tier");
+    CAP_TIERS.includes(tier) && (caps[tier] = num(fields, "cap", 0));
+  }
+  let place = f.place;
+  return {
+    name: text(f, "name"),
+    place: typeof place == "string" ? place : null,
+    size: point(f, "size"),
+    ground: of(spec.children, "ground_stroke").map(
+      ({ fields }) => ({
+        op: text(fields, "op", "raise"),
+        at: point(fields, "at"),
+        radius: num(fields, "radius", 0),
+        strength: num(fields, "strength", 0),
+        target: maybe(fields, "target"),
+        layer: num(fields, "layer", 0)
+      })
+    ),
+    roads: of(spec.children, "road").map(({ fields, children }) => ({ points: of(children, "road_point").map((p) => point(p.fields, "at")), width: num(fields, "width", 0) })),
+    buildings: placements("buildings"),
+    props: placements("props"),
+    scatters: of(spec.children, "scatter").map(
+      ({ fields }) => ({
+        layer: text(fields, "layer", "props"),
+        kinds: texts(fields, "kinds"),
+        at: point(fields, "at"),
+        radius: num(fields, "radius", 0),
+        count: num(fields, "count", 0),
+        spacing: num(fields, "spacing", 0),
+        seed: num(fields, "seed", 0)
+      })
+    ),
+    crowds: of(spec.children, "crowd_area").map(({ fields }) => ({ at: point(fields, "at"), radius: num(fields, "radius", 0), count: num(fields, "count", 0), kinds: texts(fields, "kinds") })),
+    lights: of(spec.children, "world_light").map(({ fields }) => ({ at: point(fields, "at"), height: num(fields, "height", 0), color: num(fields, "color", 0), intensity: num(fields, "intensity", 0) })),
+    sounds: of(spec.children, "sound_zone").map(({ fields }) => ({ at: point(fields, "at"), radius: num(fields, "radius", 0), sound: text(fields, "sound") })),
+    gates: of(spec.children, "gate").map((gate) => point(gate.fields, "at")),
+    sky: { hour: num(f, "hour", 0), weather: text(f, "weather", "clear"), dayMinutes: num(f, "day_minutes", 0) },
+    ...Object.keys(caps).length > 0 ? { crowdCaps: caps } : {}
+  };
+}
+function stepSpec(step) {
+  switch (step.kind) {
+    case "pop":
+      return node("motion_step", { kind: step.kind, seconds: step.seconds, scale: step.scale });
+    case "flash":
+      return node("motion_step", { kind: step.kind, seconds: step.seconds, color: step.color });
+    default:
+      return node("motion_step", { kind: step.kind, seconds: step.seconds });
+  }
+}
+function stepOf({ fields }) {
+  let seconds = num(fields, "seconds", 0);
+  switch (text(fields, "kind")) {
+    case "pop":
+      return { kind: "pop", scale: num(fields, "scale", 1), seconds };
+    case "flash":
+      return { kind: "flash", color: num(fields, "color", 0), seconds };
+    case "settle":
+      return { kind: "settle", seconds };
+    default:
+      return { kind: "count_up", seconds };
+  }
+}
+function bindingSpec(name, binding) {
+  let motions = (binding.motions ?? []).map((motion) => node("motion", { on: motion.on, when: motion.when }, motion.steps.map(stepSpec)));
+  return node(BINDING_KIND, { name, shows: binding.shows, as: binding.as, format: binding.format ?? null, decimals: binding.decimals ?? null, vector_path: binding.vectorPath ?? null }, motions);
+}
+function bindingOf(spec) {
+  let f = spec.fields, motions = of(spec.children, "motion").map(({ fields, children }) => {
+    let when = fields.when;
+    return { on: text(fields, "on", "change"), when: typeof when == "string" ? when : null, steps: of(children, "motion_step").map(stepOf) };
+  }), format = f.format, decimals = maybe(f, "decimals"), vectorPath = f.vector_path, binding = {
+    shows: text(f, "shows"),
+    as: text(f, "as", "number"),
+    ...typeof format == "string" ? { format } : {},
+    ...decimals === null ? {} : { decimals },
+    ...typeof vectorPath == "string" ? { vectorPath } : {},
+    ...motions.length > 0 ? { motions } : {}
+  };
+  return { name: text(f, "name"), binding };
+}
+function musicSpec(music) {
+  return node(
+    MUSIC_KIND,
+    { bpm: music.bpm, beats_per_bar: music.beatsPerBar, bars: music.bars, follows_path: music.follows.path, follows_wraps: music.follows.wraps, ramp_seconds: music.rampSeconds },
+    [
+      ...music.stems.map((stem) => node("stem", { id: stem.id, sound: stem.sound, label: stem.label })),
+      ...music.moods.map((mood) => node("mood", { id: mood.id, label: mood.label, bpm: mood.bpm, layer_names: Object.keys(mood.layers), layer_gains: Object.values(mood.layers) })),
+      ...music.follows.bands.map((band) => node("mood_band", { from: band.from, to: band.to, mood: band.mood })),
+      ...music.cues.map((cue) => node("cue", { moment: cue.moment, sound: cue.sound, quantize: cue.quantize, gain: cue.gain }))
+    ]
+  );
+}
+function musicOf(spec) {
+  let f = spec.fields;
+  return {
+    bpm: num(f, "bpm", 0),
+    beatsPerBar: num(f, "beats_per_bar", 0),
+    bars: num(f, "bars", 0),
+    stems: of(spec.children, "stem").map(({ fields }) => ({ id: text(fields, "id"), sound: text(fields, "sound"), label: text(fields, "label") })),
+    moods: of(spec.children, "mood").map(({ fields }) => {
+      let names = texts(fields, "layer_names"), gains = nums(fields, "layer_gains"), layers = {};
+      return names.forEach((name, i) => {
+        layers[name] = gains[i] ?? 0;
+      }), { id: text(fields, "id"), label: text(fields, "label"), bpm: maybe(fields, "bpm"), layers };
+    }),
+    follows: { path: text(f, "follows_path"), wraps: maybe(f, "follows_wraps"), bands: of(spec.children, "mood_band").map(({ fields }) => ({ from: num(fields, "from", 0), to: num(fields, "to", 0), mood: text(fields, "mood") })) },
+    cues: of(spec.children, "cue").map(({ fields }) => ({ moment: text(fields, "moment"), sound: text(fields, "sound"), quantize: text(fields, "quantize", "now"), gain: num(fields, "gain", 0) })),
+    rampSeconds: num(f, "ramp_seconds", 0)
+  };
+}
+function crowdSpec(crowd) {
+  return node(
+    CROWD_KIND,
+    { cheer_on: crowd.cheer.on, cheer_per_tap: crowd.cheer.perTap, cheer_drain_per_second: crowd.cheer.drainPerSecond, max_watchers: crowd.maxWatchers },
+    [
+      ...crowd.votes.map((vote) => node("vote", { id: vote.id, question: vote.question, choices: [...vote.choices], opens_on: vote.opensOn, seconds: vote.seconds })),
+      ...crowd.gifts.map((gift) => node("gift", { gift: gift.gift, moment: gift.moment, label: gift.label }))
+    ]
+  );
+}
+function crowdOf(spec) {
+  let f = spec.fields;
+  return {
+    votes: of(spec.children, "vote").map(({ fields }) => ({ id: text(fields, "id"), question: text(fields, "question"), choices: texts(fields, "choices"), opensOn: text(fields, "opens_on"), seconds: num(fields, "seconds", 0) })),
+    gifts: of(spec.children, "gift").map(({ fields }) => ({ gift: text(fields, "gift"), moment: text(fields, "moment"), label: text(fields, "label") })),
+    cheer: { on: f.cheer_on === true, perTap: num(f, "cheer_per_tap", 0), drainPerSecond: num(f, "cheer_drain_per_second", 0) },
+    maxWatchers: num(f, "max_watchers", 0)
+  };
+}
+function specAt(source, id) {
+  let found = source.get(id);
+  if (found === null) return null;
+  let children = [];
+  for (let child of found.children) {
+    let spec = specAt(source, child);
+    spec !== null && children.push(spec);
+  }
+  return { kind: found.kind, fields: found.fields, children };
+}
+function documentsOf(source, kind) {
+  let out = [];
+  for (let child of source.children(source.root)) {
+    let spec = specAt(source, child);
+    spec !== null && spec.kind === kind && out.push({ id: idText(child), spec });
+  }
+  return out;
+}
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (typeof value != "object" || value === null) return value;
+  let out = {};
+  for (let key of Object.keys(value).sort()) out[key] = canonical(value[key]);
+  return out;
+}
+function same(a, b) {
+  return JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
+}
+function createAll(spec, parent, id, newId, out) {
+  out.push({ op: "create", kind: spec.kind, id, parent, fields: spec.fields });
+  for (let child of spec.children) createAll(child, id, newId(), newId, out);
+}
+function documentRequests(source, id, spec, newId) {
+  let out = [], current = specAt(source, BigInt(id));
+  if (current === null)
+    return createAll(spec, idText(source.root), id, newId, out), out;
+  for (let name of /* @__PURE__ */ new Set([...Object.keys(current.fields), ...Object.keys(spec.fields)])) {
+    let next = spec.fields[name];
+    next === void 0 ? out.push({ op: "set", id, field: name, value: null }) : same(current.fields[name], next) || out.push({ op: "set", id, field: name, value: next });
+  }
+  if (!same(current.children, spec.children)) {
+    for (let child of source.children(BigInt(id))) out.push({ op: "remove", id: idText(child) });
+    for (let child of spec.children) createAll(child, id, newId(), newId, out);
+  }
+  return out;
+}
+
+// src/interactives/production/edit.ts
+var ProductionEditError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "ProductionEditError";
+  }
+}, DIGEST_BYTES = 32, DIGEST_HEX = /^[0-9a-f]{64}$/i, RGB_HEX = /^#([0-9a-f]{6})$/i, DECIMAL = /^-?\d+$/, ID2 = /^\d+$/, HEX_RADIX = 16, MAX_COLOR = 4294967295, MAX_BYTE = 255, COMPONENTS = { vec2: 2, vec3: 3, quat: 4 };
+function fail2(message) {
+  throw new ProductionEditError(message);
+}
+function parseId(value) {
+  return typeof value == "bigint" && value >= 0n ? value : typeof value == "number" && Number.isSafeInteger(value) && value >= 0 || typeof value == "string" && ID2.test(value) ? BigInt(value) : fail2(`"${String(value)}" is not a node id`);
+}
+function finiteList(value, what, length) {
+  return !Array.isArray(value) || length !== null && value.length !== length || !value.every((x) => typeof x == "number" && Number.isFinite(x)) ? fail2(length === null ? `${what} takes a list of finite numbers` : `${what} takes ${length} finite numbers`) : value;
+}
+function integer(value, what) {
+  return typeof value == "number" && Number.isSafeInteger(value) ? String(value) : typeof value == "string" && DECIMAL.test(value) ? value : fail2(`${what} takes a whole number`);
+}
+function digest(value, what) {
+  return typeof value == "string" && DIGEST_HEX.test(value) ? value.toLowerCase() : Array.isArray(value) && value.length === (32) && value.every((b) => typeof b == "number" && Number.isInteger(b) && b >= 0 && b <= (255)) ? value.map((b) => b.toString((16)).padStart(2, "0")).join("") : fail2(`${what} takes a ${(32) * 2}-character hex digest`);
+}
+function typed(spec, value) {
+  let what = spec.name;
+  switch (spec.type) {
+    case "bool":
+      return typeof value != "boolean" ? fail2(`${what} takes true or false`) : value;
+    case "int":
+    case "time":
+      return integer(value, what);
+    case "num":
+      return typeof value != "number" || !Number.isFinite(value) ? fail2(`${what} takes a finite number`) : value;
+    case "text":
+      return typeof value != "string" ? fail2(`${what} takes text`) : value;
+    case "digest":
+      return digest(value, what);
+    case "ref":
+      return idText(parseId(value));
+    case "vec2":
+    case "vec3":
+    case "quat":
+      return finiteList(value, what, COMPONENTS[spec.type]);
+    case "nums":
+      return finiteList(value, what, null);
+    case "texts":
+      return !Array.isArray(value) || !value.every((x) => typeof x == "string") ? fail2(`${what} takes a list of text`) : value;
+    case "color": {
+      if (typeof value == "string") {
+        let match = RGB_HEX.exec(value);
+        return match === null ? fail2(`${what} takes a colour like #10b981`) : Number.parseInt(match[1], (16));
+      }
+      return typeof value != "number" || !Number.isInteger(value) || value < 0 || value > (4294967295) ? fail2(`${what} takes a colour`) : value;
+    }
+    default:
+      return fail2(`${what} holds a ${spec.type}, which this version cannot write`);
+  }
+}
+function numbersOf(value) {
+  return typeof value == "number" ? [value] : typeof value == "string" && DECIMAL.test(value) ? [Number(value)] : Array.isArray(value) ? value.filter((x) => typeof x == "number") : [];
+}
+function limited(spec, value) {
+  let limit = spec.limit;
+  if (limit === null) return;
+  let what = spec.name;
+  switch (limit.kind) {
+    case "one_of":
+      (typeof value != "string" || !limit.names.includes(value)) && fail2(`${what} is one of ${limit.names.join(", ")}`);
+      return;
+    case "positive":
+      numbersOf(value).every((x) => x > 0) || fail2(`${what} must be above 0`);
+      return;
+    case "non_negative":
+      numbersOf(value).every((x) => x >= 0) || fail2(`${what} cannot be below 0`);
+      return;
+    case "range":
+      numbersOf(value).every((x) => x >= limit.min && x <= limit.max) || fail2(`${what} runs from ${limit.min} to ${limit.max}`);
+      return;
+    case "items":
+      (!Array.isArray(value) || value.length > limit.max) && fail2(`${what} holds at most ${limit.max} items`);
+      return;
+    case "codes":
+      numbersOf(value).every((x) => Number.isInteger(x) && x >= 0 && x < limit.names.length) || fail2(`${what} is one of ${limit.names.join(", ")}`);
+      return;
+  }
+}
+function coded(spec, value) {
+  if (spec.limit?.kind !== "codes" || typeof value != "string" || DECIMAL.test(value)) return value;
+  let code = spec.limit.names.indexOf(value);
+  return code < 0 ? fail2(`${spec.name} is one of ${spec.limit.names.join(", ")}`) : code;
+}
+function valueFor(kinds, kind, field, value) {
+  let spec = kinds.field(kind, field);
+  if (spec === null) return fail2(`a ${kind} has no field "${field}"`);
+  let out = typed(spec, coded(spec, value));
+  return limited(spec, out), { type: spec.type, value: out };
+}
+var ProductionEdit = class {
+  constructor(source, kinds, ids) {
+    this.source = source;
+    this.kinds = kinds;
+    this.ids = ids;
+    this.list = [];
+    this.placed = /* @__PURE__ */ new Map();
+    this.removed = /* @__PURE__ */ new Set();
+  }
+  get changes() {
+    return this.list;
+  }
+  get size() {
+    return this.list.length;
+  }
+  kindOf(id) {
+    return this.removed.has(id) ? null : this.placed.get(id)?.kind ?? this.source.get(id)?.kind ?? null;
+  }
+  parentOf(id) {
+    return id === this.source.root ? null : this.placed.get(id)?.parent ?? this.source.get(id)?.parent ?? null;
+  }
+  exists(id) {
+    for (let at = id; at !== null; at = this.parentOf(at))
+      if (this.removed.has(at) || this.kindOf(at) === null) return false;
+    return true;
+  }
+  within(id, ancestor) {
+    for (let at = id; at !== null; at = this.parentOf(at)) if (at === ancestor) return true;
+    return false;
+  }
+  checkParent(kind, parent) {
+    let parentKind = this.exists(parent) ? this.kindOf(parent) : null;
+    parentKind === null && fail2(`node ${parent} does not exist`), this.kinds.parentAllowed(kind, parentKind) || fail2(`a ${kind} cannot go inside a ${parentKind}`);
+  }
+  sibling(parent, sibling, moving) {
+    if (sibling != null)
+      return (sibling === moving || !this.exists(sibling) || this.parentOf(sibling) !== parent) && fail2(`node ${sibling} is not a child of ${parent}`), idText(sibling);
+  }
+  placement(parent, place, moving) {
+    place.after !== void 0 && place.after !== null && place.before !== void 0 && place.before !== null && fail2("place a thing after a sibling or before one, not both");
+    let after = this.sibling(parent, place.after, moving), before = this.sibling(parent, place.before, moving);
+    return after !== void 0 ? { after } : before !== void 0 ? { before } : {};
+  }
+  create(kind, parent, fields = {}, place = {}, named = null) {
+    this.kinds.has(kind) || fail2(`"${kind}" is not a kind of thing`), this.checkParent(kind, parent);
+    let values = Object.entries(fields).map(([name, value]) => [this.kinds.field(kind, name)?.key ?? -1, valueFor(this.kinds, kind, name, value)]), where = this.placement(parent, place, null);
+    named !== null && (this.placed.has(named) || this.source.get(named) !== null) && fail2(`node ${named} already exists`);
+    let id = named ?? this.ids.newId();
+    this.placed.set(id, { kind, parent }), this.list.push({ op: "create", id: idText(id), kind, parent: idText(parent), ...where });
+    for (let [key, value] of values) this.list.push({ op: "set", id: idText(id), field: key, value });
+    return id;
+  }
+  set(id, field, value) {
+    let kind = this.exists(id) ? this.kindOf(id) : null;
+    kind === null && fail2(`node ${id} does not exist`);
+    let spec = this.kinds.field(kind, field);
+    spec === null && fail2(`a ${kind} has no field "${field}"`), this.list.push({ op: "set", id: idText(id), field: spec.key, value: value === null ? null : valueFor(this.kinds, kind, field, value) });
+  }
+  move(id, parent, place = {}) {
+    id === this.source.root && fail2("the production root cannot move");
+    let kind = this.exists(id) ? this.kindOf(id) : null;
+    kind === null && fail2(`node ${id} does not exist`), this.checkParent(kind, parent), this.within(parent, id) && fail2("a thing cannot move inside itself");
+    let where = this.placement(parent, place, id);
+    this.placed.set(id, { kind, parent }), this.list.push({ op: "move", id: idText(id), parent: idText(parent), ...where });
+  }
+  remove(id) {
+    id === this.source.root && fail2("the production root cannot be removed"), this.exists(id) || fail2(`node ${id} does not exist`), this.removed.add(id), this.list.push({ op: "delete", id: idText(id) });
+  }
+};
+
+// src/interactives/production/kinds.ts
+var ProductionKindsError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "ProductionKindsError";
+  }
+};
+function fail3(message) {
+  throw new ProductionKindsError(`the production kinds are malformed: ${message}`);
+}
+function record(value, what) {
+  return typeof value != "object" || value === null || Array.isArray(value) ? fail3(`${what} is not an object`) : value;
+}
+function list(value, what) {
+  return Array.isArray(value) ? value : fail3(`${what} is not a list`);
+}
+function text2(value, what) {
+  return typeof value != "string" ? fail3(`${what} is not text`) : value;
+}
+function whole(value, what) {
+  return typeof value != "number" || !Number.isSafeInteger(value) || value < 0 ? fail3(`${what} is not a whole number`) : value;
+}
+function finite(value, what) {
+  return typeof value != "number" || !Number.isFinite(value) ? fail3(`${what} is not a number`) : value;
+}
+function limitOf(value, what) {
+  if (value == null) return null;
+  let raw = record(value, what);
+  switch (raw.kind) {
+    case "one_of":
+    case "codes":
+      return { kind: raw.kind, names: list(raw.names, `${what}.names`).map((name, i) => text2(name, `${what}.names[${i}]`)) };
+    case "positive":
+    case "non_negative":
+      return { kind: raw.kind };
+    case "range":
+      return { kind: "range", min: finite(raw.min, `${what}.min`), max: finite(raw.max, `${what}.max`) };
+    case "items":
+      return { kind: "items", max: whole(raw.max, `${what}.max`) };
+    default:
+      return fail3(`${what} has an unknown limit`);
+  }
+}
+function kindOf(value, index) {
+  let what = `kind ${index}`, raw = record(value, what), name = text2(raw.name, `${what}.name`);
+  return {
+    code: whole(raw.code, `${name}.code`),
+    name,
+    parents: list(raw.parents, `${name}.parents`).map((parent, i) => text2(parent, `${name}.parents[${i}]`)),
+    document: raw.document === true,
+    fields: list(raw.fields, `${name}.fields`).map((field, i) => {
+      let at = `${name}.fields[${i}]`, spec = record(field, at);
+      return { key: whole(spec.key, `${at}.key`), name: text2(spec.name, `${at}.name`), type: text2(spec.type, `${at}.type`), limit: limitOf(spec.limit, `${at}.limit`) };
+    })
+  };
+}
+var ProductionKinds = class _ProductionKinds {
+  constructor(list2) {
+    this.list = list2;
+    this.byName = /* @__PURE__ */ new Map();
+    for (let kind of list2) this.byName.set(kind.name, kind);
+  }
+  static parse(json) {
+    let raw;
+    try {
+      raw = JSON.parse(json);
+    } catch {
+      return fail3("not JSON");
+    }
+    return new _ProductionKinds(list(raw, "the kind list").map(kindOf));
+  }
+  get names() {
+    return this.list.map((kind) => kind.name);
+  }
+  get editable() {
+    return this.list.filter((kind) => kind.parents.length > 0).map((kind) => kind.name);
+  }
+  has(name) {
+    return typeof name == "string" && this.byName.has(name);
+  }
+  kind(name) {
+    return this.byName.get(name) ?? null;
+  }
+  field(kind, name) {
+    return this.byName.get(kind)?.fields.find((field) => field.name === name) ?? null;
+  }
+  fieldByKey(kind, key) {
+    return this.byName.get(kind)?.fields.find((field) => field.key === key) ?? null;
+  }
+  parentAllowed(kind, parent) {
+    return this.byName.get(kind)?.parents.includes(parent) ?? false;
+  }
+};
+
+// src/interactives/production/limits.ts
+var EVERY_KIND = "every", PLUGIN_LIMITS = {
+  origin: "plugin",
+  kinds: EVERY_KIND,
+  fields: {},
+  create: true,
+  remove: true,
+  move: true,
+  maxChanges: 200,
+  maxCreates: 50,
+  maxTextBytes: 4096
+}, OUTSIDE_AGENT_LIMITS = {
+  origin: "system",
+  kinds: EVERY_KIND,
+  fields: {},
+  create: true,
+  remove: true,
+  move: true,
+  maxChanges: 500,
+  maxCreates: 200,
+  maxTextBytes: 16384
+}, PERSON_LIMITS = {
+  origin: "person",
+  kinds: EVERY_KIND,
+  fields: {},
+  create: true,
+  remove: true,
+  move: true,
+  maxChanges: 2e4,
+  maxCreates: 1e4,
+  maxTextBytes: 16384,
+  root: true
+}, READ_ONLY_LIMITS = {
+  ...PLUGIN_LIMITS,
+  kinds: [],
+  create: false,
+  remove: false,
+  move: false,
+  maxChanges: 0,
+  maxCreates: 0
+};
+function narrowLimits(base, granted) {
+  let wanted = granted.kinds ?? base.kinds, kinds = base.kinds === EVERY_KIND ? wanted : wanted === EVERY_KIND ? base.kinds : wanted.filter((kind) => base.kinds.includes(kind));
+  return {
+    origin: base.origin,
+    kinds,
+    fields: { ...base.fields, ...granted.fields },
+    create: base.create && (granted.create ?? true),
+    remove: base.remove && (granted.remove ?? true),
+    move: base.move && (granted.move ?? true),
+    maxChanges: Math.min(base.maxChanges, granted.maxChanges ?? base.maxChanges),
+    maxCreates: Math.min(base.maxCreates, granted.maxCreates ?? base.maxCreates),
+    maxTextBytes: Math.min(base.maxTextBytes, granted.maxTextBytes ?? base.maxTextBytes),
+    root: base.root === true && (granted.root ?? true)
+  };
+}
+function textBytes(value) {
+  let encoder = new TextEncoder();
+  return typeof value == "string" ? encoder.encode(value).length : Array.isArray(value) ? value.reduce((sum, item) => sum + (typeof item == "string" ? encoder.encode(item).length : 0), 0) : 0;
+}
+function checkLimits(changes, limits, kinds, kindOf2) {
+  let refusals = [];
+  changes.length > limits.maxChanges && refusals.push({ index: limits.maxChanges, reason: `at most ${limits.maxChanges} changes at a time` });
+  let allowed = (kind2) => limits.kinds === EVERY_KIND ? kinds.editable.includes(kind2) : limits.kinds.includes(kind2), creates = 0, createdKinds = /* @__PURE__ */ new Map(), kind = (id) => createdKinds.get(id) ?? kindOf2(id);
+  return changes.forEach((change, index) => {
+    let refuse = (reason) => refusals.push({ index, reason });
+    switch (change.op) {
+      case "create":
+        createdKinds.set(change.id, change.kind), limits.create ? ++creates > limits.maxCreates && refuse(`at most ${limits.maxCreates} new things at a time`) : refuse("cannot add new things"), allowed(change.kind) || refuse(`cannot add a ${change.kind}`);
+        return;
+      case "delete": {
+        let k = kind(change.id);
+        limits.remove || refuse("cannot remove things"), k !== null && !allowed(k) && refuse(`cannot remove a ${k}`);
+        return;
+      }
+      case "move": {
+        let k = kind(change.id);
+        limits.move || refuse("cannot move things"), k !== null && !allowed(k) && refuse(`cannot move a ${k}`);
+        return;
+      }
+      case "set": {
+        let k = kind(change.id);
+        if (k === null) return;
+        if (kinds.kind(k)?.parents.length === 0 ? limits.root !== true : !allowed(k)) {
+          refuse(`cannot change a ${k}`);
+          return;
+        }
+        let spec = kinds.fieldByKey(k, change.field), fields = limits.fields[k];
+        spec !== null && fields !== void 0 && !fields.includes(spec.name) && refuse(`cannot change the ${spec.name} of a ${k}`), change.value !== null && (change.value.type === "text" || change.value.type === "texts") && textBytes(change.value.value) > limits.maxTextBytes && refuse(`text longer than ${limits.maxTextBytes} bytes`);
+        return;
+      }
+    }
+  }), refusals;
+}
+
+// src/interactives/production/operations.ts
+var NEW_REF_PREFIX = "$", NEW_REF = /^\$(\d+)$/, ProductionOperations = class {
+  constructor(target, author, limits) {
+    this.target = target;
+    this.author = author;
+    this.limits = limits;
+  }
+  get kinds() {
+    return this.target.kinds;
+  }
+  snapshot() {
+    return ProductionSource.parse(this.target.sourceJson());
+  }
+  read(id = null, depth = 1) {
+    let source = this.snapshot();
+    return source.json(id === null ? source.root : parseId(id), depth);
+  }
+  apply(requests2) {
+    let source = this.snapshot(), edit = new ProductionEdit(source, this.target.kinds, { newId: () => this.target.newId(this.author) }), created = [], resolve = (ref) => {
+      let match = typeof ref == "string" ? NEW_REF.exec(ref) : null;
+      if (match === null) return parseId(ref);
+      let id = created[Number(match[1]) - 1];
+      if (id === void 0) throw new ProductionEditError(`${ref} names a thing this request has not added yet`);
+      return id;
+    }, place = (after, before) => ({
+      after: after === void 0 ? null : resolve(after),
+      before: before === void 0 ? null : resolve(before)
+    });
+    for (let index = 0; index < requests2.length; index++) {
+      let request = requests2[index];
+      try {
+        switch (request.op) {
+          case "create":
+            created.push(
+              edit.create(request.kind, request.parent === void 0 ? source.root : resolve(request.parent), request.fields ?? {}, place(request.after, request.before), request.id === void 0 ? null : parseId(request.id))
+            );
+            break;
+          case "set":
+            edit.set(resolve(request.id), request.field, request.value);
+            break;
+          case "move":
+            edit.move(resolve(request.id), resolve(request.parent), place(request.after, request.before));
+            break;
+          case "remove":
+            edit.remove(resolve(request.id));
+            break;
+          default:
+            throw new ProductionEditError(`"${String(request.op)}" is not a change`);
+        }
+      } catch (error) {
+        if (error instanceof ProductionEditError) return { ok: false, refusals: [{ index, reason: error.message }] };
+        throw error;
+      }
+    }
+    let refusals = checkLimits(edit.changes, this.limits, this.target.kinds, (id) => source.get(BigInt(id))?.kind ?? null);
+    if (refusals.length > 0) return { ok: false, refusals };
+    if (edit.size > 0)
+      try {
+        this.target.editJson(this.author, this.limits.origin, JSON.stringify(edit.changes));
+      } catch (error) {
+        return { ok: false, refusals: [{ index: requests2.length, reason: error instanceof Error ? error.message : String(error) }] };
+      }
+    return { ok: true, created: created.map(idText), changes: edit.size };
+  }
+  undo() {
+    return this.target.undo(this.author);
+  }
+  redo() {
+    return this.target.redo(this.author);
+  }
+  compile() {
+    return this.target.compile();
+  }
+};
+
+// src/interactives/production/tools.ts
+var NODE_REF = {
+  oneOf: [{ type: "string" }, { type: "integer", minimum: 0 }],
+  description: "A node id, or $1, $2, ... for things added earlier in the same request."
+};
+function changeSchema(kinds) {
+  return {
+    type: "object",
+    required: ["op"],
+    properties: {
+      op: { enum: ["create", "set", "move", "remove"] },
+      kind: { enum: kinds.editable },
+      id: NODE_REF,
+      parent: NODE_REF,
+      after: NODE_REF,
+      before: NODE_REF,
+      field: { type: "string" },
+      value: {},
+      fields: { type: "object" }
+    }
+  };
+}
+var MAX_DEPTH = 8;
+function describeKinds(kinds) {
+  return kinds.list.map((kind) => ({
+    kind: kind.name,
+    document: kind.document,
+    fields: kind.fields.map((field) => field.limit === null ? { name: field.name, type: field.type } : { name: field.name, type: field.type, limit: field.limit }),
+    goesInside: kind.parents
+  }));
+}
+function requests(args) {
+  let changes = args.changes;
+  if (!Array.isArray(changes)) throw new Error("changes must be a list");
+  return changes;
+}
+function productionTools(operations) {
+  return [
+    {
+      name: "production_kinds",
+      title: "Production kinds",
+      description: "Lists every kind of thing in a production (scenes, cast and props, things and their parts, places and their ground, roads and crowds, music, live crowds, votes and gifts, and more), their fields with the values each allows, and where each can go.",
+      inputSchema: { type: "object", properties: {} },
+      readOnly: true,
+      run: () => describeKinds(operations.kinds)
+    },
+    {
+      name: "production_read",
+      title: "Read the production",
+      description: "Reads a node of the production and its children to a depth, with field values by name. Leave id out for the root.",
+      inputSchema: {
+        type: "object",
+        properties: { id: NODE_REF, depth: { type: "integer", minimum: 0, maximum: (8) } }
+      },
+      readOnly: true,
+      run: (args) => operations.read(
+        args.id ?? null,
+        Math.min((8), Number(args.depth ?? 1))
+      )
+    },
+    {
+      name: "production_edit",
+      title: "Edit the production",
+      description: "Applies a list of changes as one undoable edit: create a thing inside a parent (optionally after or before a sibling) with fields, set or clear a field, move a thing, or remove it with everything inside. Refuses the whole list when any change is not allowed.",
+      inputSchema: {
+        type: "object",
+        required: ["changes"],
+        properties: { changes: { type: "array", items: changeSchema(operations.kinds) } }
+      },
+      readOnly: false,
+      run: (args) => operations.apply(requests(args))
+    },
+    {
+      name: "production_undo",
+      title: "Undo",
+      description: "Undoes this author's last edit.",
+      inputSchema: { type: "object", properties: {} },
+      readOnly: false,
+      run: () => ({ undone: operations.undo() })
+    },
+    {
+      name: "production_redo",
+      title: "Redo",
+      description: "Redoes this author's last undone edit.",
+      inputSchema: { type: "object", properties: {} },
+      readOnly: false,
+      run: () => ({ redone: operations.redo() })
+    },
+    {
+      name: "production_check",
+      title: "Check the production",
+      description: "Builds the production and reports how many problems it has.",
+      inputSchema: { type: "object", properties: {} },
+      readOnly: true,
+      run: () => operations.compile()
+    }
+  ];
+}
+
+// src/interactives/production/plugin.ts
+var PLUGIN_CALLS = ["kinds", "read", "edit", "undo", "redo"], PLUGIN_CALLS_PER_SECOND = 30, PLUGIN_EDITS_PER_SECOND = 10, MS_PER_SECOND = 1e3, PLUGIN_ID = /^[a-z0-9][a-z0-9-]{0,62}\/[a-z0-9][a-z0-9-]{0,62}$/, MAX_NAME = 60, PluginManifestError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "PluginManifestError";
+  }
+};
+function boolOr(value, what) {
+  if (value !== void 0) {
+    if (typeof value != "boolean") throw new PluginManifestError(`${what} must be true or false`);
+    return value;
+  }
+}
+function parsePluginManifest(value, known) {
+  if (typeof value != "object" || value === null)
+    throw new PluginManifestError("a plugin manifest is an object");
+  let raw = value;
+  if (typeof raw.id != "string" || !PLUGIN_ID.test(raw.id))
+    throw new PluginManifestError("id is owner/name in lowercase letters, digits and dashes");
+  if (typeof raw.name != "string" || raw.name.trim().length === 0 || raw.name.length > (60))
+    throw new PluginManifestError(`name is 1 to ${(60)} characters`);
+  if (typeof raw.version != "string" || raw.version.length === 0)
+    throw new PluginManifestError("version is required");
+  let grant = raw.grant ?? {}, kinds = grant.kinds;
+  if (kinds !== void 0 && (!Array.isArray(kinds) || !kinds.every((kind) => typeof kind == "string" && known.editable.includes(kind))))
+    throw new PluginManifestError("grant.kinds lists kinds of thing, not the production itself");
+  return {
+    id: raw.id,
+    name: raw.name.trim(),
+    version: raw.version,
+    grant: {
+      kinds,
+      fields: grant.fields,
+      create: boolOr(grant.create, "grant.create"),
+      remove: boolOr(grant.remove, "grant.remove"),
+      move: boolOr(grant.move, "grant.move")
+    }
+  };
+}
+function pluginLimits(manifest) {
+  return narrowLimits(PLUGIN_LIMITS, manifest.grant);
+}
+var PluginSession = class {
+  constructor(target, author, manifest) {
+    this.manifest = manifest;
+    this.windowStart = 0;
+    this.calls = 0;
+    this.edits = 0;
+    this.operations = new ProductionOperations(target, author, pluginLimits(manifest));
+  }
+  handle(request, nowMs) {
+    if (nowMs - this.windowStart >= (1e3) && (this.windowStart = nowMs, this.calls = 0, this.edits = 0), ++this.calls > (30))
+      return { id: request.id, ok: false, error: "too many calls; wait a moment" };
+    let args = request.args ?? {};
+    try {
+      switch (request.call) {
+        case "kinds":
+          return { id: request.id, ok: !0, result: describeKinds(this.operations.kinds) };
+        case "read":
+          return {
+            id: request.id,
+            ok: !0,
+            result: this.operations.read(
+              args.id ?? null,
+              Number(args.depth ?? 1)
+            )
+          };
+        case "edit":
+          return ++this.edits > (10) ? { id: request.id, ok: !1, error: "too many edits; wait a moment" } : Array.isArray(args.changes) ? {
+            id: request.id,
+            ok: !0,
+            result: this.operations.apply(args.changes)
+          } : { id: request.id, ok: !1, error: "edit takes a list of changes" };
+        case "undo":
+          return { id: request.id, ok: !0, result: this.operations.undo() };
+        case "redo":
+          return { id: request.id, ok: !0, result: this.operations.redo() };
+        default:
+          return {
+            id: request.id,
+            ok: !1,
+            error: `"${request.call}" is not something a plugin can ask for`
+          };
+      }
+    } catch (error) {
+      return {
+        id: request.id,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/interactives/production/luau.ts
+var PLUGIN_GLOBAL = "production", MAX_PLUGIN_DEPTH = 16;
+function tableToPlain(value, depth = 0) {
+  if (value === void 0) return null;
+  if (typeof value == "string" || typeof value == "number" || typeof value == "boolean")
+    return value;
+  if (typeof value == "bigint") return value.toString();
+  if (!(value instanceof LuaTable) || depth > (16)) return null;
+  let pair = [void 0, void 0], entries = [], key;
+  for (; value.next(key, pair); )
+    key = pair[0], entries.push([pair[0], pair[1]]);
+  let length = value.length();
+  if (length > 0 && entries.length === length) {
+    let list2 = [];
+    for (let i = 1; i <= length; i++) list2.push(tableToPlain(value.getInt(i), depth + 1));
+    return list2;
+  }
+  let out = {};
+  for (let [k, v] of entries)
+    (typeof k == "string" || typeof k == "number") && (out[String(k)] = tableToPlain(v, depth + 1));
+  return out;
+}
+function plainToTable(value, depth = 0) {
+  if (value == null || depth > (16)) return;
+  if (typeof value == "string" || typeof value == "number" || typeof value == "boolean")
+    return value;
+  if (typeof value == "bigint") return value.toString();
+  let table = new LuaTable();
+  if (Array.isArray(value))
+    return value.forEach((item, index) => table.set(index + 1, plainToTable(item, depth + 1))), table;
+  if (typeof value == "object") {
+    for (let [key, item] of Object.entries(value)) table.set(key, plainToTable(item, depth + 1));
+    return table;
+  }
+}
+function openProductionApi(state, session, now) {
+  let rt = state.rt, api = new LuaTable(), next = 0;
+  for (let call of PLUGIN_CALLS) {
+    let args = new Args(rt, `${PLUGIN_GLOBAL}.${call}`);
+    register(api, call, function(input) {
+      let count = arguments.length, plain = count === 0 || input === void 0 ? {} : tableToPlain(args.table(1, count, input)), request = call === "edit" && Array.isArray(plain) ? { changes: plain } : typeof plain == "object" && plain !== null && !Array.isArray(plain) ? plain : {}, reply = session.handle({ id: ++next, call, args: request }, now());
+      return rt.n = 2, rt.r[1] = reply.ok ? void 0 : reply.error, reply.ok ? plainToTable(reply.result) : void 0;
+    });
+  }
+  state.globals.set(PLUGIN_GLOBAL, api);
+}
+
+// src/interactives/production/runner.ts
+var PLUGIN_CHUNK = "plugin", DEFAULT_PLUGIN_BUDGET = 5e6, PLUGIN_BUDGET_MESSAGE = "the tool took too long and was stopped", SINGLE_OPERATION = "run", PluginLoadError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "PluginLoadError";
+  }
+};
+function loaderFor(evaluate) {
+  return (bytecode) => evaluate(compileBytecode(bytecode, { chunkname: PLUGIN_CHUNK }).source);
+}
+var ProductionPlugin = class _ProductionPlugin {
+  constructor(state, table, session, budget) {
+    this.state = state;
+    this.table = table;
+    this.session = session;
+    this.budget = budget;
+    let names = [], pair = [void 0, void 0], key;
+    for (; table.next(key, pair); )
+      key = pair[0], typeof pair[0] == "string" && typeof pair[1] == "function" && names.push(pair[0]);
+    this.operations = names.sort();
+  }
+  static async open(options) {
+    let state = new LuaState({ profile: "rive", seed: options.seed ?? 0 }), session = new PluginSession(options.target, options.author, options.manifest);
+    openProductionApi(state, session, options.now ?? (() => Date.now()));
+    let load = options.load ?? loaderFor(options.evaluate ?? blobEvaluator()), factory;
+    try {
+      factory = await load(options.bytecode);
+    } catch (error) {
+      throw new PluginLoadError(error instanceof Error ? error.message : String(error));
+    }
+    let budget = options.budget ?? (5e6);
+    state.rt.budget = budget;
+    let result;
+    try {
+      result = state.run(factory);
+    } catch (error) {
+      throw new PluginLoadError(_ProductionPlugin.message(state, error));
+    }
+    if (!result.ok) throw new PluginLoadError(state.rt.tostringValue(result.error));
+    let value = result.values[0], table;
+    if (value instanceof LuaTable)
+      table = value;
+    else if (typeof value == "function")
+      table = new LuaTable(), table.set(SINGLE_OPERATION, value);
+    else
+      throw new PluginLoadError("a tool returns a table of operations");
+    return new _ProductionPlugin(state, table, session, budget);
+  }
+  run(name, input = null) {
+    let fn = this.table.get(name);
+    if (typeof fn != "function") return { ok: false, error: `the tool has no operation ${name}` };
+    let rt = this.state.rt;
+    rt.budget = this.budget;
+    let previous = this.state.enter();
+    try {
+      let first = fn(plainToTable(input));
+      return { ok: !0, result: rt.n > 0 ? tableToPlain(first) : null };
+    } catch (error) {
+      return { ok: false, error: _ProductionPlugin.message(this.state, error) };
+    } finally {
+      this.state.exit(previous);
+    }
+  }
+  static message(state, error) {
+    if (error instanceof BudgetExceeded) return PLUGIN_BUDGET_MESSAGE;
+    let native = state.rt.native(error);
+    return native instanceof LuaError ? state.rt.tostringValue(native.value) : native instanceof Error ? native.message : String(native);
+  }
+};
+function openProductionPlugin(options) {
+  return ProductionPlugin.open(options);
+}
+
+// src/interactives/production/target.ts
+var ProductionRulesUnavailableError = class extends Error {
+  constructor() {
+    super("This production core cannot show rules as code.");
+    this.name = "ProductionRulesUnavailableError";
+  }
+}, parsed = /* @__PURE__ */ new WeakMap();
+function productionKinds(core) {
+  let known = parsed.get(core);
+  if (known !== void 0) return known;
+  let kinds = ProductionKinds.parse(core.kinds());
+  return parsed.set(core, kinds), kinds;
+}
+function productionTarget(core, draft) {
+  return {
+    kinds: productionKinds(core),
+    sourceJson: () => draft.sourceJson(),
+    editJson: (author, origin, changes) => draft.editJson(author, origin, changes),
+    newId: (author) => draft.newId(author),
+    undo: (author) => draft.undo(author),
+    redo: (author) => draft.redo(author),
+    compile: () => {
+      let compiled = draft.compile();
+      return { bytes: compiled.program.length, diagnostics: compiled.diagnostics.length };
+    },
+    rulesCode: () => {
+      if (draft.rulesCode === void 0) throw new ProductionRulesUnavailableError();
+      return draft.rulesCode();
+    },
+    applyRulesCode: (author, origin, code) => {
+      if (draft.applyRulesCode === void 0) throw new ProductionRulesUnavailableError();
+      return draft.applyRulesCode(author, origin, code);
+    }
+  };
+}
+
+export { BINDING_KIND, CROWD_KIND, DEFAULT_PLUGIN_BUDGET, EVERY_KIND, MAX_PLUGIN_DEPTH, MUSIC_KIND, NEW_REF_PREFIX, OUTSIDE_AGENT_LIMITS, PERSON_LIMITS, PLUGIN_BUDGET_MESSAGE, PLUGIN_CALLS, PLUGIN_CALLS_PER_SECOND, PLUGIN_CHUNK, PLUGIN_EDITS_PER_SECOND, PLUGIN_GLOBAL, PLUGIN_LIMITS, PluginLoadError, PluginManifestError, PluginSession, ProductionEdit, ProductionEditError, ProductionKinds, ProductionKindsError, ProductionOperations, ProductionPlugin, ProductionRulesUnavailableError, ProductionSource, ProductionSourceError, READ_ONLY_LIMITS, SINGLE_OPERATION, THING_KIND, WORLD_KIND, bindingOf, bindingSpec, checkLimits, crowdOf, crowdSpec, describeKinds, documentRequests, documentsOf, idText, musicOf, musicSpec, narrowLimits, openProductionApi, openProductionPlugin, parseId, parsePluginManifest, plainToTable, pluginLimits, productionKinds, productionTarget, productionTools, specAt, tableToPlain, thingOf, thingSpec, valueFor, worldOf, worldSpec };