@cimplify/cli 0.15.2 → 0.16.0

package/dist/chunk-T4MW3PD4.mjs

@@ -0,0 +1,1456 @@
+#!/usr/bin/env node
+import { quoteTomlString, parseToml, TomlSyntaxError } from './chunk-KQNZKV6E.mjs';
+import { PINNED_TYPESCRIPT_VERSION, PINNED_SDK_VERSION, SDK_PACKAGE, findLibrary } from './chunk-AKACUJ3W.mjs';
+import { compareStrings } from './chunk-25ZPFHLF.mjs';
+import { diagnostic } from './chunk-SGT5IJVW.mjs';
+import { CTX_CONTRACT_FINGERPRINT, CTX_CONTRACT_VERSION, CTX_MIN_SUPPORTED_CONTRACT_VERSION, CTX_COMPATIBLE_FINGERPRINTS, CTX_CAPABILITIES, CTX_LIMITS, ENGINE_FEATURE_NAMES, ENGINE_ARENA_BASELINE_BYTES, ENGINE_ARENA_MAX_CEILING_BYTES, ENGINE_ARENA_CHUNK_BYTES } from '@cimplify/sdk/interactives';
+import { realMoneyIn, REAL_MONEY_SUGGESTION, inWorldRefusal } from '@cimplify/sdk/game/kit';
+
+var LOCKFILE = "cimplify.lock";
+var LOCK_VERSION = 1;
+var HEX_DIGEST = /^[0-9a-f]{64}$/;
+var ITEM_REFERENCE = /^[a-z0-9][a-z0-9_-]{0,63}\/[a-z0-9][a-z0-9_-]{0,63}$/;
+var CONTENT_VERSION = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$/;
+function isItemReference(raw) {
+  return ITEM_REFERENCE.test(raw);
+}
+function sortContent(content) {
+  return content.slice().sort((a, b) => compareStrings(a.item, b.item));
+}
+function withContent(lock, content) {
+  const replaced = new Map((lock.content ?? []).map((entry) => [entry.item, entry]));
+  for (const entry of content) replaced.set(entry.item, entry);
+  return { ...lock, content: sortContent([...replaced.values()]) };
+}
+var FINGERPRINT = /^[0-9a-f]{16}$/;
+function currentLockfile(libraries = []) {
+  return {
+    lockVersion: LOCK_VERSION,
+    sdk: PINNED_SDK_VERSION,
+    ctxContractVersion: CTX_CONTRACT_VERSION,
+    ctxFingerprint: CTX_CONTRACT_FINGERPRINT,
+    typescript: PINNED_TYPESCRIPT_VERSION,
+    libraries: sortLibraries(libraries)
+  };
+}
+function sortLibraries(libraries) {
+  return libraries.slice().sort((a, b) => compareStrings(a.name, b.name));
+}
+function serializeLockfile(lock) {
+  let out = `lock_version = ${lock.lockVersion}
+
+[sdk]
+version = ${quoteTomlString(lock.sdk)}
+
+`;
+  out += `[ctx]
+contract_version = ${lock.ctxContractVersion}
+fingerprint = ${quoteTomlString(lock.ctxFingerprint)}
+
+`;
+  out += `[toolchain]
+typescript = ${quoteTomlString(lock.typescript)}
+`;
+  for (const library of sortLibraries(lock.libraries)) {
+    out += `
+[[libraries]]
+name = ${quoteTomlString(library.name)}
+version = ${quoteTomlString(library.version)}
+`;
+  }
+  for (const entry of sortContent(lock.content ?? [])) {
+    out += `
+[[content]]
+item = ${quoteTomlString(entry.item)}
+version = ${quoteTomlString(entry.version)}
+version_digest = ${quoteTomlString(entry.versionDigest)}
+licence = ${quoteTomlString(entry.licence)}
+terms = ${quoteTomlString(entry.terms)}
+`;
+  }
+  return out;
+}
+function str(table, key) {
+  const v = table?.entries.get(key);
+  return v !== void 0 && v.kind === "string" ? v.value : null;
+}
+function int(table, key) {
+  const v = table?.entries.get(key);
+  return v !== void 0 && v.kind === "integer" ? v.value : null;
+}
+function sub(root, key) {
+  const v = root.entries.get(key);
+  return v !== void 0 && v.kind === "table" ? v : null;
+}
+function parseLockfile(source, file = LOCKFILE) {
+  let root;
+  try {
+    root = parseToml(source);
+  } catch (err) {
+    if (err instanceof TomlSyntaxError) {
+      return { lockfile: null, diagnostics: [diagnostic("lock.syntax", err.reason, file, err)] };
+    }
+    throw err;
+  }
+  const diagnostics = [];
+  const fail = (code, message, at2 = root.at) => {
+    diagnostics.push(diagnostic(code, message, file, at2));
+  };
+  const lockVersion = int(root, "lock_version");
+  if (lockVersion !== LOCK_VERSION) fail("lock.version", `lock_version must be ${LOCK_VERSION}`, root.entries.get("lock_version")?.at);
+  const sdkTable = sub(root, "sdk");
+  const ctxTable = sub(root, "ctx");
+  const toolchain = sub(root, "toolchain");
+  const sdk = str(sdkTable, "version");
+  const contract = int(ctxTable, "contract_version");
+  const fingerprint = str(ctxTable, "fingerprint");
+  const typescript = str(toolchain, "typescript");
+  if (sdk === null) fail("lock.missing", "[sdk] version is missing", sdkTable?.at);
+  if (contract === null) fail("lock.missing", "[ctx] contract_version is missing", ctxTable?.at);
+  if (fingerprint === null || !FINGERPRINT.test(fingerprint)) fail("lock.missing", "[ctx] fingerprint must be 16 hex digits", ctxTable?.at);
+  if (typescript === null) fail("lock.missing", "[toolchain] typescript is missing", toolchain?.at);
+  const libraries = [];
+  const seen = /* @__PURE__ */ new Set();
+  const libs = root.entries.get("libraries");
+  if (libs !== void 0) {
+    if (libs.kind !== "array" || !libs.ofTables) {
+      fail("lock.type", "libraries must be written as [[libraries]] tables", libs.at);
+    } else {
+      for (const item of libs.items) {
+        const t = item.kind === "table" ? item : null;
+        const name = str(t, "name");
+        const version = str(t, "version");
+        if (name === null || version === null) {
+          fail("lock.missing", "each [[libraries]] needs a name and a version", item.at);
+          continue;
+        }
+        if (seen.has(name)) {
+          fail("lock.duplicate", `library '${name}' is locked twice`, item.at);
+          continue;
+        }
+        seen.add(name);
+        libraries.push({ name, version });
+      }
+    }
+  }
+  const content = [];
+  const locked = root.entries.get("content");
+  if (locked !== void 0) {
+    if (locked.kind !== "array" || !locked.ofTables) {
+      fail("lock.type", "content must be written as [[content]] tables", locked.at);
+    } else {
+      const items = /* @__PURE__ */ new Set();
+      for (const entry of locked.items) {
+        const t = entry.kind === "table" ? entry : null;
+        const item = str(t, "item");
+        const version = str(t, "version");
+        const versionDigest = str(t, "version_digest");
+        const licence = str(t, "licence");
+        const terms = str(t, "terms");
+        if (item === null || version === null || versionDigest === null || licence === null || terms === null) {
+          fail("lock.missing", "each [[content]] needs item, version, version_digest, licence and terms", entry.at);
+          continue;
+        }
+        if (!isItemReference(item) || !CONTENT_VERSION.test(version) || !HEX_DIGEST.test(versionDigest) || !HEX_DIGEST.test(terms)) {
+          fail("lock.content", `the [[content]] entry for '${item}' is malformed`, entry.at);
+          continue;
+        }
+        if (items.has(item)) {
+          fail("lock.duplicate", `content '${item}' is locked twice`, entry.at);
+          continue;
+        }
+        items.add(item);
+        content.push({ item, version, versionDigest, licence, terms });
+      }
+    }
+  }
+  if (diagnostics.length > 0 || sdk === null || contract === null || fingerprint === null || typescript === null) {
+    return { lockfile: null, diagnostics };
+  }
+  return {
+    lockfile: {
+      lockVersion: LOCK_VERSION,
+      sdk,
+      ctxContractVersion: contract,
+      ctxFingerprint: fingerprint,
+      typescript,
+      libraries,
+      ...content.length === 0 ? {} : { content: sortContent(content) }
+    },
+    diagnostics
+  };
+}
+function checkLockfile(lock, file = LOCKFILE) {
+  const out = [];
+  if (lock.sdk !== PINNED_SDK_VERSION) {
+    out.push(diagnostic("lock.sdk", `the lockfile pins ${SDK_PACKAGE} ${lock.sdk}; this build service supports ${PINNED_SDK_VERSION}`, file, null));
+  }
+  if (lock.ctxContractVersion < CTX_MIN_SUPPORTED_CONTRACT_VERSION || lock.ctxContractVersion > CTX_CONTRACT_VERSION) {
+    out.push(diagnostic("lock.ctx", `ctx contract ${lock.ctxContractVersion} is outside the supported window ${CTX_MIN_SUPPORTED_CONTRACT_VERSION} to ${CTX_CONTRACT_VERSION}`, file, null));
+  } else if (lockedMissingOperations(lock) === null) {
+    out.push(
+      diagnostic(
+        "lock.ctx",
+        `ctx fingerprint ${lock.ctxFingerprint} is not a known fingerprint of contract ${lock.ctxContractVersion} (current ${CTX_CONTRACT_FINGERPRINT}); run cimplify lock --update`,
+        file,
+        null
+      )
+    );
+  }
+  if (lock.typescript !== PINNED_TYPESCRIPT_VERSION) {
+    out.push(diagnostic("lock.toolchain", `the lockfile pins TypeScript ${lock.typescript}; the pinned toolchain is ${PINNED_TYPESCRIPT_VERSION}`, file, null));
+  }
+  for (const library of lock.libraries) {
+    const allowed = findLibrary(library.name);
+    if (allowed === null || allowed.name === SDK_PACKAGE) {
+      out.push(diagnostic("lock.library", `'${library.name}' is not on the reviewed library allowlist`, file, null));
+    } else if (allowed.version !== library.version) {
+      out.push(diagnostic("lock.library", `'${library.name}' is locked at ${library.version}; the reviewed version is ${allowed.version}`, file, null));
+    }
+  }
+  return out;
+}
+function lockedMissingOperations(lock) {
+  if (lock.ctxContractVersion === CTX_CONTRACT_VERSION && lock.ctxFingerprint === CTX_CONTRACT_FINGERPRINT) return /* @__PURE__ */ new Set();
+  if (lock.ctxContractVersion !== CTX_CONTRACT_VERSION) return /* @__PURE__ */ new Set();
+  const known = CTX_COMPATIBLE_FINGERPRINTS.find(
+    (entry) => entry.contract_version === lock.ctxContractVersion && entry.fingerprint === lock.ctxFingerprint
+  );
+  return known === void 0 ? null : new Set(known.missing_operations);
+}
+function withCurrentContract(lock) {
+  if (lock.ctxContractVersion === CTX_CONTRACT_VERSION && lock.ctxFingerprint === CTX_CONTRACT_FINGERPRINT) return lock;
+  return { ...lock, ctxContractVersion: CTX_CONTRACT_VERSION, ctxFingerprint: CTX_CONTRACT_FINGERPRINT };
+}
+function lockedVersion(lock, name) {
+  if (name === SDK_PACKAGE) return lock.sdk;
+  for (const library of lock.libraries) if (library.name === name) return library.version;
+  return null;
+}
+function withLibrary(lock, library) {
+  if (library.name === SDK_PACKAGE || lockedVersion(lock, library.name) !== null) return lock;
+  return { ...lock, libraries: sortLibraries([...lock.libraries, library]) };
+}
+var MANIFEST_FILE = "interactive.toml";
+var CATEGORIES = ["games", "everyday"];
+var PROFILE_KINDS = ["native", "canvas"];
+var ENGINE_PROFILES = ["godot", "wasm"];
+var GAME_PROFILES = ["game_api", "direct_engine:three", "direct_engine:phaser", "wasm", "godot"];
+var ENGINE_GAME_PROFILES = ["wasm", "godot"];
+var WASM_LANGUAGES = ["c", "cpp", "rust"];
+var THREAD_MODES = ["single", "isolated"];
+var GODOT_RUNTIME_KINDS = ["full", "3d", "2d"];
+var ENGINE_ENTRY = "src/cimplify.engine.ts";
+var DEVICE_TIERS = ["low", "mid", "high"];
+var ENTRY_KINDS = ["client", "room", "worker"];
+var CHANNEL_DELIVERIES = ["reliable", "latest", "unordered"];
+var DATA_USES = ["none", "anonymous", "personal"];
+var CURRENCY_CLASSES = ["soft", "premium"];
+var OFFER_GRANT_KINDS = ["item", "currency", "unlock", "effect"];
+var RULE_KINDS = ["faucet", "sink"];
+var VIOLENCE = ["none", "cartoon", "realistic", "graphic"];
+var SEXUALITY = ["none", "suggestive", "explicit"];
+var LANGUAGE = ["none", "mild", "strong"];
+var FEAR = ["none", "mild", "intense"];
+var DEFAULT_KERNELS = { lower: true, exactMath: false, noLower: [] };
+var TOP_LEVEL = ["interactive", "profile", "entries", "capabilities", "providers", "economy", "data", "ai", "rating", "delivery", "engine", "content", "credits", "world", "kernels"];
+var CONTENT_KEYS = ["item", "version", "group"];
+var CREDIT_KEYS = ["title", "authors", "licence", "licence_url", "source_url", "modified"];
+var CONTENT_ITEM = /^[a-z0-9][a-z0-9_-]{0,63}\/[a-z0-9][a-z0-9_-]{0,63}$/;
+var CONTENT_RANGE = /^(\*|[=^~]?(0|[1-9][0-9]*)(\.(0|[1-9][0-9]*)){0,2})$/;
+var MAX_CREDIT_TEXT = 512;
+var MAX_CREDIT_AUTHORS = 16;
+var WASM_ENGINE_KEYS = ["language", "sources", "includes", "crate", "threads", "memory", "max_memory", "packs"];
+var GODOT_ENGINE_KEYS = ["project", "threads", "runtime", "packs"];
+var PACK_KEYS = ["name", "files"];
+var NATIVE_DIR = "native/";
+var C_SOURCE = /\.c$/;
+var CPP_SOURCE = /\.(cc|cpp|cxx)$/;
+var ENGINE_PATH = /^[A-Za-z0-9_][A-Za-z0-9_./-]*$/;
+var GODOT_RESOURCE = /^res:\/\/[A-Za-z0-9_./*-]+$/;
+var TRAILING_SLASHES = /\/+$/;
+var WASM_PAGE_BYTES = 64 * 1024;
+var DEFAULT_WASM_MEMORY = 32 * 1024 * 1024;
+var DEFAULT_WASM_MAX_MEMORY = 256 * 1024 * 1024;
+var MAX_WASM_MEMORY = 2 * 1024 * 1024 * 1024;
+var MAX_ENGINE_PACKS = 16;
+var DATA_KEYS = ["version", "tables", "statements"];
+var TABLE_KEYS = ["name", "columns", "primary_key", "indexes", "row_scope", "mirror"];
+var COLUMN_KEYS = ["name", "type", "nullable", "classification"];
+var INDEX_KEYS = ["name", "columns", "unique"];
+var STATEMENT_KEYS = ["name", "sql", "access", "params", "owner_param", "shared_write"];
+var COLUMN_TYPES = ["text", "integer", "real", "boolean", "timestamp", "json", "blob_ref"];
+var ROW_SCOPES = ["owner", "interactive", "shared"];
+var MIRRORS = ["server_only", "device_mirror"];
+var CLASSIFICATIONS = ["public", "interactive", "personal"];
+var STATEMENT_ACCESS = ["read", "write"];
+var DATA_IDENTIFIER = /^[a-z][a-z0-9_]{0,62}$/;
+var RESERVED_DATA_PREFIX = "ix_";
+var MAX_SCHEMA_VERSION = 4294967295;
+var IDENTITY_KEYS = ["id", "name", "description", "category", "publisher"];
+var PROFILE_KEYS = ["kind", "game", "engine_features", "text_dictionaries", "engine_memory_max"];
+var ENTRY_KEYS = ["client", "room", "worker", "tick", "conformance", "channels"];
+var CHANNEL_KEYS = ["name", "schema", "from", "to", "delivery"];
+var PROVIDER_KEYS = ["id", "destination", "data_use", "purpose"];
+var ECONOMY_KEYS = ["currencies", "items", "odds", "offers", "rules"];
+var CURRENCY_KEYS = ["id", "name", "class", "in_world"];
+var ITEM_KEYS = ["id", "name", "currency", "price", "random"];
+var ODDS_KEYS = ["item", "outcomes"];
+var OUTCOME_KEYS = ["value", "parts_per_million"];
+var OFFER_KEYS = ["id", "name", "price_cimples", "grants", "odds"];
+var OFFER_GRANT_KEYS = ["kind", "id", "quantity"];
+var OFFER_ODDS_KEYS = ["label", "parts_per_million", "grants"];
+var RULE_KEYS = ["id", "kind", "currency", "item", "max_quantity"];
+var MAX_OFFER_CIMPLES = 1e6;
+var MAX_OFFER_GRANTS = 8;
+var DELIVERY_KEYS = ["min_device_tier", "download_size", "groups", "tier_groups", "parts", "progressive", "keep_on_device", "weave", "ranged", "repair_percent"];
+var MAX_REPAIR_PERCENT = 100;
+var GROUP_KEYS = ["name", "before_play", "assets"];
+var RATING_KEYS = ["violence", "sexuality", "language", "fear", "simulated_gambling"];
+var IDENTIFIER = /^[a-z][a-z0-9_-]{0,62}$/;
+var INTERACTIVE_ID = /^ixr_[A-Za-z0-9]{8,40}$/;
+var SOURCE_ENTRY = /^src\/[A-Za-z0-9_./-]+\.(ts|mts|js|mjs)$/;
+var SIZE_TEXT = /^(\d+(?:\.\d+)?)\s*(B|KB|KiB|MB|MiB|GB|GiB)$/;
+var NAME_MAX = 64;
+var DESCRIPTION_MAX = 500;
+var PURPOSE_MAX = 200;
+var MAX_DOWNLOAD_BYTES = 2 * 1024 * 1024 * 1024;
+var MAX_KEPT_DOWNLOAD_BYTES = 16 * 1024 * 1024 * 1024;
+var PROVIDER_SCHEME = "https:";
+var SIZE_UNITS = {
+  B: 1,
+  KB: 1e3,
+  KiB: 1024,
+  MB: 1e3 * 1e3,
+  MiB: 1024 * 1024,
+  GB: 1e3 * 1e3 * 1e3,
+  GiB: 1024 * 1024 * 1024
+};
+var Reader = class {
+  diagnostics = [];
+  file;
+  constructor(file) {
+    this.file = file;
+  }
+  error(code, message, at2) {
+    this.diagnostics.push(diagnostic(code, message, this.file, at2));
+  }
+  keys(table, path, allowed) {
+    for (const [key, value] of table.entries) {
+      if (allowed.indexOf(key) >= 0) continue;
+      const where = path === "" ? "at the top level" : `in [${path}]`;
+      this.error("manifest.unknown_key", `unknown key '${key}' ${where}; expected one of ${allowed.join(", ")}`, table.keyAt.get(key) ?? value.at);
+    }
+  }
+  table(parent, key, path, required) {
+    const value = parent.entries.get(key);
+    const full = join(path, key);
+    if (value === void 0) {
+      if (required) this.error("manifest.missing", `missing required table [${full}]`, parent.at);
+      return null;
+    }
+    if (value.kind !== "table") {
+      this.error("manifest.type", `'${full}' must be a table, found ${kindName(value)}`, value.at);
+      return null;
+    }
+    return value;
+  }
+  tables(parent, key, path) {
+    const value = parent.entries.get(key);
+    if (value === void 0) return [];
+    const full = join(path, key);
+    if (value.kind !== "array") {
+      this.error("manifest.type", `'${full}' must be an array of tables ([[${full}]]), found ${kindName(value)}`, value.at);
+      return [];
+    }
+    const out = [];
+    for (const item of value.items) {
+      if (item.kind !== "table") {
+        this.error("manifest.type", `each '${full}' entry must be a table, found ${kindName(item)}`, item.at);
+        continue;
+      }
+      out.push(item);
+    }
+    return out;
+  }
+  string(table, key, path, required, max = Number.MAX_SAFE_INTEGER) {
+    const value = table.entries.get(key);
+    const full = join(path, key);
+    if (value === void 0) {
+      if (required) this.error("manifest.missing", `missing required key '${full}'`, table.at);
+      return null;
+    }
+    if (value.kind !== "string") {
+      this.error("manifest.type", `'${full}' must be a string, found ${kindName(value)}`, value.at);
+      return null;
+    }
+    if (required && value.value.trim().length === 0) {
+      this.error("manifest.empty", `'${full}' must not be empty`, value.at);
+      return null;
+    }
+    if (value.value.length > max) {
+      this.error("manifest.too_long", `'${full}' is ${value.value.length} characters; the limit is ${max}`, value.at);
+      return null;
+    }
+    return value.value;
+  }
+  oneOf(table, key, path, options, required = true) {
+    const raw = this.string(table, key, path, required);
+    if (raw === null) return null;
+    if (options.indexOf(raw) < 0) {
+      this.error("manifest.value", `'${join(path, key)}' is '${raw}'; expected one of ${options.join(", ")}`, at(table, key));
+      return null;
+    }
+    return raw;
+  }
+  boolean(table, key, path, fallback) {
+    const value = table.entries.get(key);
+    if (value === void 0) {
+      if (fallback === null) this.error("manifest.missing", `missing required key '${join(path, key)}'`, table.at);
+      return fallback;
+    }
+    if (value.kind !== "boolean") {
+      this.error("manifest.type", `'${join(path, key)}' must be true or false, found ${kindName(value)}`, value.at);
+      return null;
+    }
+    return value.value;
+  }
+  integer(table, key, path, required, min, max) {
+    const value = table.entries.get(key);
+    const full = join(path, key);
+    if (value === void 0) {
+      if (required) this.error("manifest.missing", `missing required key '${full}'`, table.at);
+      return null;
+    }
+    if (value.kind !== "integer") {
+      this.error("manifest.type", `'${full}' must be an integer, found ${kindName(value)}`, value.at);
+      return null;
+    }
+    if (value.value < min || value.value > max) {
+      this.error("manifest.range", `'${full}' is ${value.value}; expected ${min} to ${max}`, value.at);
+      return null;
+    }
+    return value.value;
+  }
+  strings(table, key, path, required) {
+    const value = table.entries.get(key);
+    const full = join(path, key);
+    if (value === void 0) {
+      if (required) this.error("manifest.missing", `missing required key '${full}'`, table.at);
+      return [];
+    }
+    if (value.kind !== "array" || value.ofTables) {
+      this.error("manifest.type", `'${full}' must be an array of strings, found ${kindName(value)}`, value.at);
+      return [];
+    }
+    const out = [];
+    for (const item of value.items) {
+      if (item.kind !== "string") {
+        this.error("manifest.type", `each '${full}' entry must be a string, found ${kindName(item)}`, item.at);
+        continue;
+      }
+      out.push(item.value);
+    }
+    return out;
+  }
+};
+function join(path, key) {
+  return path === "" ? key : `${path}.${key}`;
+}
+function at(table, key) {
+  return table.entries.get(key)?.at ?? table.at;
+}
+function kindName(value) {
+  if (value.kind === "array") return value.ofTables ? "an array of tables" : "an array";
+  if (value.kind === "table") return "a table";
+  if (value.kind === "integer") return "an integer";
+  return `a ${value.kind}`;
+}
+function parseByteSize(text) {
+  const match = SIZE_TEXT.exec(text.trim());
+  if (!match) return null;
+  const bytes = Math.round(Number(match[1]) * SIZE_UNITS[match[2]]);
+  return Number.isSafeInteger(bytes) ? bytes : null;
+}
+function readIdentity(r, root) {
+  const t = r.table(root, "interactive", "", true);
+  if (!t) return null;
+  r.keys(t, "interactive", IDENTITY_KEYS);
+  const id = r.string(t, "id", "interactive", false);
+  if (id !== null && !INTERACTIVE_ID.test(id)) {
+    r.error("manifest.value", `'interactive.id' is '${id}'; ids are assigned by Cimplify on first publish and look like ixr_<letters and digits>`, at(t, "id"));
+  }
+  const name = r.string(t, "name", "interactive", true, NAME_MAX);
+  const description = r.string(t, "description", "interactive", true, DESCRIPTION_MAX);
+  const category = r.oneOf(t, "category", "interactive", CATEGORIES);
+  const publisher = r.string(t, "publisher", "interactive", false);
+  if (name === null || description === null || category === null) return null;
+  return { id, name, description, category, publisher };
+}
+function readProfile(r, root) {
+  const t = r.table(root, "profile", "", true);
+  if (!t) return null;
+  r.keys(t, "profile", PROFILE_KEYS);
+  const kindRaw = r.string(t, "kind", "profile", true);
+  if (kindRaw === null) return null;
+  if (ENGINE_PROFILES.indexOf(kindRaw) >= 0) {
+    r.error("manifest.value", `engine games run in the canvas profile; set profile.kind = "canvas" and profile.game = "${kindRaw}"`, at(t, "kind"));
+    return null;
+  }
+  if (PROFILE_KINDS.indexOf(kindRaw) < 0) {
+    r.error("manifest.value", `'profile.kind' is '${kindRaw}'; expected one of ${PROFILE_KINDS.join(", ")}`, at(t, "kind"));
+    return null;
+  }
+  const kind = kindRaw;
+  const engineFeatures = readEngineFeatures(r, t);
+  const textDictionaries = r.boolean(t, "text_dictionaries", "profile", false) === true ? { textDictionaries: true } : {};
+  const engineMemoryMax = readEngineMemoryMax(r, t);
+  const extras = engineMemoryMax === null ? textDictionaries : { ...textDictionaries, engineMemoryMax };
+  if (!t.entries.has("game")) return { kind, game: null, engineFeatures, ...extras };
+  const game = r.oneOf(t, "game", "profile", GAME_PROFILES);
+  if (game === null) return null;
+  if (kind !== "canvas" && game !== "game_api") {
+    r.error("manifest.value", `'profile.game' = "${game}" requires profile.kind = "canvas"; native games use game_api`, at(t, "game"));
+    return null;
+  }
+  return { kind, game, engineFeatures, ...extras };
+}
+function readEngineMemoryMax(r, t) {
+  const value = t.entries.get("engine_memory_max");
+  if (value === void 0) return null;
+  const bytes = value.kind === "integer" ? value.value : value.kind === "string" ? parseByteSize(value.value) : null;
+  if (bytes === null || bytes < ENGINE_ARENA_BASELINE_BYTES || bytes > ENGINE_ARENA_MAX_CEILING_BYTES || bytes % ENGINE_ARENA_CHUNK_BYTES !== 0) {
+    r.error("manifest.value", `'profile.engine_memory_max' is a whole number of 16 MiB chunks between 512 MiB and 1968 MiB, like "1 GiB"`, value.at);
+    return null;
+  }
+  return bytes;
+}
+function readEngineFeatures(r, t) {
+  if (!t.entries.has("engine_features")) return null;
+  const declared = r.strings(t, "engine_features", "profile", true);
+  const known = ENGINE_FEATURE_NAMES;
+  const unknown = declared.find((name) => known.indexOf(name) < 0);
+  if (unknown !== void 0) {
+    r.error("manifest.value", `'profile.engine_features' names '${unknown}'; expected some of ${ENGINE_FEATURE_NAMES.join(", ")}`, at(t, "engine_features"));
+    return null;
+  }
+  return ENGINE_FEATURE_NAMES.filter((name) => declared.indexOf(name) >= 0);
+}
+function readEntry(r, t, key, required) {
+  const value = r.string(t, key, "entries", required);
+  if (value === null) return null;
+  if (!SOURCE_ENTRY.test(value) || value.split("/").indexOf("..") >= 0) {
+    r.error("manifest.value", `'entries.${key}' is '${value}'; entries are TypeScript or JavaScript files under src/`, at(t, key));
+    return null;
+  }
+  return value;
+}
+function isEngineGame(game) {
+  return game !== null && ENGINE_GAME_PROFILES.indexOf(game) >= 0;
+}
+function readEntries(r, root, profile) {
+  const engine = profile !== null && isEngineGame(profile.game);
+  if (engine && !root.entries.has("entries")) return { client: ENGINE_ENTRY, room: null, worker: null, tick: null, conformance: null, channels: [] };
+  const t = r.table(root, "entries", "", true);
+  if (!t) return null;
+  r.keys(t, "entries", ENTRY_KEYS);
+  if (engine && t.entries.has("client")) {
+    r.error("manifest.value", "an engine game's client entry is built by Cimplify from [engine]; remove entries.client", at(t, "client"));
+  }
+  const client = engine ? ENGINE_ENTRY : readEntry(r, t, "client", true);
+  const room = readEntry(r, t, "room", false);
+  const worker = readEntry(r, t, "worker", false);
+  const tick = readEntry(r, t, "tick", false);
+  if (tick !== null && tick === client) {
+    r.error("manifest.value", "'entries.tick' is the authoritative room bundle; give it its own module and import shared rules from it in the client", at(t, "tick"));
+  }
+  const conformance = readEntry(r, t, "conformance", false);
+  if (conformance !== null && profile !== null && profile.game === null) {
+    r.error("manifest.value", "'entries.conformance' is only used by game profiles; set profile.game or remove it", at(t, "conformance"));
+  }
+  const declared = { client: true, room: room !== null, worker: worker !== null };
+  const channels = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const c of r.tables(t, "channels", "entries")) {
+    r.keys(c, "entries.channels", CHANNEL_KEYS);
+    const name = r.string(c, "name", "entries.channels", true);
+    const schema = r.string(c, "schema", "entries.channels", true);
+    const from = r.oneOf(c, "from", "entries.channels", ENTRY_KINDS);
+    const to = r.oneOf(c, "to", "entries.channels", ENTRY_KINDS);
+    const delivery = r.oneOf(c, "delivery", "entries.channels", CHANNEL_DELIVERIES);
+    if (name === null || schema === null || from === null || to === null || delivery === null) continue;
+    if (!IDENTIFIER.test(name)) {
+      r.error("manifest.value", `channel name '${name}' must be lowercase letters, digits, '-' or '_'`, at(c, "name"));
+      continue;
+    }
+    if (names.has(name)) {
+      r.error("manifest.duplicate", `channel '${name}' is declared twice`, at(c, "name"));
+      continue;
+    }
+    if (!declared[from] || !declared[to]) {
+      const missing = !declared[from] ? from : to;
+      r.error("manifest.value", `channel '${name}' uses the ${missing} entry, but entries.${missing} is not declared`, c.at);
+      continue;
+    }
+    if (from === to) {
+      r.error("manifest.value", `channel '${name}' must connect two different entries`, at(c, "to"));
+      continue;
+    }
+    names.add(name);
+    channels.push({ name, schema, from, to, delivery });
+  }
+  if (client === null) return null;
+  return { client, room, worker, tick, conformance, channels };
+}
+function readCapabilities(r, root) {
+  const t = r.table(root, "capabilities", "", false);
+  if (!t) return [];
+  const out = [];
+  for (const [name, value] of t.entries) {
+    if (!Object.prototype.hasOwnProperty.call(CTX_CAPABILITIES, name)) {
+      r.error("manifest.capability", `'${name}' is not a ctx capability; see the ctx reference for the list`, t.keyAt.get(name) ?? value.at);
+      continue;
+    }
+    if (value.kind !== "string") {
+      r.error("manifest.type", `capability '${name}' must be a purpose string shown to the player, found ${kindName(value)}`, value.at);
+      continue;
+    }
+    if (value.value.trim().length === 0 || value.value.length > PURPOSE_MAX) {
+      r.error("manifest.value", `capability '${name}' needs a purpose of 1 to ${PURPOSE_MAX} characters`, value.at);
+      continue;
+    }
+    out.push({ name, purpose: value.value });
+  }
+  out.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  return out;
+}
+function readProviders(r, root) {
+  const out = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const p of r.tables(root, "providers", "")) {
+    r.keys(p, "providers", PROVIDER_KEYS);
+    const id = r.string(p, "id", "providers", true);
+    const destination = r.string(p, "destination", "providers", true);
+    const dataUse = r.oneOf(p, "data_use", "providers", DATA_USES);
+    const purpose = r.string(p, "purpose", "providers", true, PURPOSE_MAX);
+    if (id === null || destination === null || dataUse === null || purpose === null) continue;
+    if (!IDENTIFIER.test(id)) {
+      r.error("manifest.value", `provider id '${id}' must be lowercase letters, digits, '-' or '_'`, at(p, "id"));
+      continue;
+    }
+    if (ids.has(id)) {
+      r.error("manifest.duplicate", `provider '${id}' is declared twice`, at(p, "id"));
+      continue;
+    }
+    let url;
+    try {
+      url = new URL(destination);
+    } catch {
+      r.error("manifest.value", `provider '${id}' destination '${destination}' is not a URL`, at(p, "destination"));
+      continue;
+    }
+    if (url.protocol !== PROVIDER_SCHEME || url.username !== "" || url.password !== "") {
+      r.error("manifest.value", `provider '${id}' destination must be an https origin without credentials`, at(p, "destination"));
+      continue;
+    }
+    ids.add(id);
+    out.push({ id, destination: url.origin, dataUse, purpose });
+  }
+  return out;
+}
+function readEconomy(r, root, context) {
+  const t = r.table(root, "economy", "", false);
+  if (!t) return { currencies: [], items: [], odds: [], offers: [], rules: [] };
+  r.keys(t, "economy", ECONOMY_KEYS);
+  const currencies = [];
+  const currencyIds = /* @__PURE__ */ new Set();
+  for (const c of r.tables(t, "currencies", "economy")) {
+    r.keys(c, "economy.currencies", CURRENCY_KEYS);
+    const id = r.string(c, "id", "economy.currencies", true);
+    const name = r.string(c, "name", "economy.currencies", true, NAME_MAX);
+    const cls = r.oneOf(c, "class", "economy.currencies", CURRENCY_CLASSES);
+    const inWorld = r.boolean(c, "in_world", "economy.currencies", false) ?? false;
+    if (id === null || name === null || cls === null) continue;
+    if (inWorld && cls !== "soft") r.error("manifest.money", `currency '${id}' is in_world, which only a soft currency may be; premium value is bought with Cimples and must never look like real money`, at(c, "in_world"));
+    const exempt = inWorld && cls === "soft";
+    const named = exempt ? null : realMoneyIn(name);
+    const money = named ?? (exempt ? null : realMoneyIn(id));
+    if (money !== null) r.error("manifest.money", `currency '${id}' uses '${money.found}'; ${REAL_MONEY_SUGGESTION}`, at(c, named !== null ? "name" : "id"));
+    const refusal = exempt && context !== null ? inWorldRefusal(id, context) : null;
+    if (refusal !== null) r.error("manifest.money", refusal, at(c, "in_world"));
+    if (!IDENTIFIER.test(id) || currencyIds.has(id)) {
+      r.error(currencyIds.has(id) ? "manifest.duplicate" : "manifest.value", `currency id '${id}' must be unique lowercase letters, digits, '-' or '_'`, at(c, "id"));
+      continue;
+    }
+    currencyIds.add(id);
+    currencies.push({ id, name, class: cls, inWorld });
+  }
+  const items = [];
+  const itemIds = /* @__PURE__ */ new Set();
+  for (const it of r.tables(t, "items", "economy")) {
+    r.keys(it, "economy.items", ITEM_KEYS);
+    const id = r.string(it, "id", "economy.items", true);
+    const name = r.string(it, "name", "economy.items", true, NAME_MAX);
+    const currency = r.string(it, "currency", "economy.items", false);
+    const price = r.integer(it, "price", "economy.items", false, 0, Number.MAX_SAFE_INTEGER);
+    const random = r.boolean(it, "random", "economy.items", false) ?? false;
+    if (id === null || name === null) continue;
+    if (!IDENTIFIER.test(id) || itemIds.has(id)) {
+      r.error(itemIds.has(id) ? "manifest.duplicate" : "manifest.value", `item id '${id}' must be unique lowercase letters, digits, '-' or '_'`, at(it, "id"));
+      continue;
+    }
+    if (currency === null !== (price === null)) {
+      r.error("manifest.value", `item '${id}' needs both currency and price, or neither`, it.at);
+      continue;
+    }
+    if (currency !== null && !currencyIds.has(currency)) {
+      r.error("manifest.reference", `item '${id}' is priced in '${currency}', which is not a declared currency`, at(it, "currency"));
+      continue;
+    }
+    itemIds.add(id);
+    items.push({ id, name, currency, price, random });
+  }
+  const odds = [];
+  const total = CTX_LIMITS.odds_parts_per_million;
+  for (const o of r.tables(t, "odds", "economy")) {
+    r.keys(o, "economy.odds", ODDS_KEYS);
+    const item = r.string(o, "item", "economy.odds", true);
+    if (item !== null && !itemIds.has(item)) {
+      r.error("manifest.reference", `odds are disclosed for '${item}', which is not a declared item`, at(o, "item"));
+    }
+    const outcomes = [];
+    let sum = 0;
+    for (const out of r.tables(o, "outcomes", "economy.odds")) {
+      r.keys(out, "economy.odds.outcomes", OUTCOME_KEYS);
+      const reward = r.string(out, "value", "economy.odds.outcomes", true);
+      const ppm = r.integer(out, "parts_per_million", "economy.odds.outcomes", true, 1, total);
+      if (reward === null || ppm === null) continue;
+      if (!itemIds.has(reward)) {
+        r.error("manifest.reference", `odds outcome '${reward}' is not a declared item`, at(out, "value"));
+        continue;
+      }
+      sum += ppm;
+      outcomes.push({ value: reward, partsPerMillion: ppm });
+    }
+    if (outcomes.length === 0) {
+      r.error("manifest.missing", `odds for '${item ?? "?"}' need at least one [[economy.odds.outcomes]]`, o.at);
+      continue;
+    }
+    if (sum !== total) {
+      r.error("manifest.odds", `odds for '${item ?? "?"}' add up to ${sum} parts per million; they must add up to exactly ${total}`, o.at);
+      continue;
+    }
+    if (item !== null) odds.push({ item, outcomes });
+  }
+  const offers = readOffers(r, t, currencyIds, itemIds);
+  const offered = new Set(offers.flatMap((o) => [...o.grants, ...o.odds.flatMap((x) => x.grants)]).filter((g) => g.kind === "item").map((g) => g.id));
+  const rules = readRules(r, t, currencies, items, offered);
+  return { currencies, items, odds, offers, rules };
+}
+function readGrants(r, owner, path, currencyIds, itemIds) {
+  const grants = [];
+  let valid = true;
+  for (const g of r.tables(owner, "grants", path)) {
+    const at_ = `${path}.grants`;
+    r.keys(g, at_, OFFER_GRANT_KEYS);
+    const kind = r.oneOf(g, "kind", at_, OFFER_GRANT_KINDS);
+    const id = r.string(g, "id", at_, true);
+    const quantity = r.integer(g, "quantity", at_, false, 1, Number.MAX_SAFE_INTEGER) ?? 1;
+    if (kind === null || id === null) {
+      valid = false;
+      continue;
+    }
+    if (kind === "currency" && !currencyIds.has(id)) {
+      r.error("manifest.reference", `offer grant '${id}' is not a declared currency`, at(g, "id"));
+      valid = false;
+      continue;
+    }
+    if (kind === "item" && !itemIds.has(id)) {
+      r.error("manifest.reference", `offer grant '${id}' is not a declared item`, at(g, "id"));
+      valid = false;
+      continue;
+    }
+    if ((kind === "unlock" || kind === "effect") && !IDENTIFIER.test(id)) {
+      r.error("manifest.value", `${kind} id '${id}' must be lowercase letters, digits, '-' or '_'`, at(g, "id"));
+      valid = false;
+      continue;
+    }
+    grants.push({ kind, id, quantity: kind === "unlock" || kind === "effect" ? 1 : quantity });
+  }
+  if (grants.length > MAX_OFFER_GRANTS) {
+    r.error("manifest.value", `an offer grants at most ${MAX_OFFER_GRANTS} holdings`, owner.at);
+    return null;
+  }
+  return valid ? grants : null;
+}
+function readOffers(r, t, currencyIds, itemIds) {
+  const offers = [];
+  const offerIds = /* @__PURE__ */ new Set();
+  const total = CTX_LIMITS.odds_parts_per_million;
+  for (const o of r.tables(t, "offers", "economy")) {
+    r.keys(o, "economy.offers", OFFER_KEYS);
+    const id = r.string(o, "id", "economy.offers", true);
+    const name = r.string(o, "name", "economy.offers", true, NAME_MAX);
+    const priceCimples = r.integer(o, "price_cimples", "economy.offers", true, 1, MAX_OFFER_CIMPLES);
+    if (id === null || name === null || priceCimples === null) continue;
+    if (!IDENTIFIER.test(id) || offerIds.has(id)) {
+      r.error(offerIds.has(id) ? "manifest.duplicate" : "manifest.value", `offer id '${id}' must be unique lowercase letters, digits, '-' or '_'`, at(o, "id"));
+      continue;
+    }
+    const grants = readGrants(r, o, "economy.offers", currencyIds, itemIds);
+    const odds = [];
+    let sum = 0;
+    let oddsValid = true;
+    for (const x of r.tables(o, "odds", "economy.offers")) {
+      r.keys(x, "economy.offers.odds", OFFER_ODDS_KEYS);
+      const label = r.string(x, "label", "economy.offers.odds", true, NAME_MAX);
+      const ppm = r.integer(x, "parts_per_million", "economy.offers.odds", true, 1, total);
+      const won = readGrants(r, x, "economy.offers.odds", currencyIds, itemIds);
+      if (label === null || ppm === null || won === null || won.length === 0) {
+        oddsValid = false;
+        continue;
+      }
+      sum += ppm;
+      odds.push({ label, partsPerMillion: ppm, grants: won });
+    }
+    if (grants === null || !oddsValid) continue;
+    if (grants.length === 0 === (odds.length === 0)) {
+      r.error("manifest.value", `offer '${id}' needs [[economy.offers.grants]] or [[economy.offers.odds]], not both and not neither`, o.at);
+      continue;
+    }
+    if (odds.length > 0 && sum !== total) {
+      r.error("manifest.odds", `odds for offer '${id}' add up to ${sum} parts per million; they must add up to exactly ${total}`, o.at);
+      continue;
+    }
+    offerIds.add(id);
+    offers.push({ id, name, priceCimples, grants, odds });
+  }
+  return offers;
+}
+function readRules(r, t, currencies, items, offered) {
+  const rules = [];
+  const ruleIds = /* @__PURE__ */ new Set();
+  for (const rule of r.tables(t, "rules", "economy")) {
+    r.keys(rule, "economy.rules", RULE_KEYS);
+    const id = r.string(rule, "id", "economy.rules", true);
+    const kind = r.oneOf(rule, "kind", "economy.rules", RULE_KINDS);
+    const currency = r.string(rule, "currency", "economy.rules", false);
+    const item = r.string(rule, "item", "economy.rules", false);
+    const maxQuantity = r.integer(rule, "max_quantity", "economy.rules", true, 1, Number.MAX_SAFE_INTEGER);
+    if (id === null || kind === null || maxQuantity === null) continue;
+    if (!IDENTIFIER.test(id) || ruleIds.has(id)) {
+      r.error(ruleIds.has(id) ? "manifest.duplicate" : "manifest.value", `rule id '${id}' must be unique lowercase letters, digits, '-' or '_'`, at(rule, "id"));
+      continue;
+    }
+    if (currency === null === (item === null)) {
+      r.error("manifest.value", `rule '${id}' names exactly one currency or item`, rule.at);
+      continue;
+    }
+    const soft = currency !== null ? currencies.some((c) => c.id === currency && c.class === "soft") : items.some((i) => i.id === item && !offered.has(i.id) && (i.currency === null || currencies.some((c) => c.id === i.currency && c.class === "soft")));
+    if (!soft) {
+      r.error("manifest.money", `rule '${id}' may only move a declared soft currency or soft item`, rule.at);
+      continue;
+    }
+    ruleIds.add(id);
+    rules.push({ id, kind, currency, item, maxQuantity });
+  }
+  return rules;
+}
+function dataName(r, table, path, what, taken) {
+  const name = r.string(table, "name", path, true);
+  if (name === null) return null;
+  if (!DATA_IDENTIFIER.test(name) || name.startsWith(RESERVED_DATA_PREFIX) || taken.has(name)) {
+    r.error(
+      taken.has(name) ? "manifest.duplicate" : "manifest.value",
+      `${what} '${name}' must be unique lowercase letters, digits and '_', starting with a letter and not with '${RESERVED_DATA_PREFIX}'`,
+      at(table, "name")
+    );
+    return null;
+  }
+  taken.add(name);
+  return name;
+}
+function readTable(r, t, taken) {
+  const path = "data.tables";
+  r.keys(t, path, TABLE_KEYS);
+  const name = dataName(r, t, path, "table", taken);
+  const columns = [];
+  const columnNames = /* @__PURE__ */ new Set();
+  for (const c of r.tables(t, "columns", path)) {
+    const columnPath = `${path}.columns`;
+    r.keys(c, columnPath, COLUMN_KEYS);
+    const column = dataName(r, c, columnPath, "column", columnNames);
+    const columnType = r.oneOf(c, "type", columnPath, COLUMN_TYPES);
+    const nullable = r.boolean(c, "nullable", columnPath, false);
+    const classification = r.oneOf(c, "classification", columnPath, CLASSIFICATIONS, false) ?? "interactive";
+    if (column === null || columnType === null || nullable === null) continue;
+    columns.push({ name: column, columnType, nullable, classification });
+  }
+  const primaryKey = r.strings(t, "primary_key", path, true);
+  for (const key of primaryKey) {
+    if (!columnNames.has(key)) r.error("manifest.reference", `primary key column '${key}' is not a column of '${name ?? "?"}'`, at(t, "primary_key"));
+  }
+  const indexes = [];
+  const indexNames = /* @__PURE__ */ new Set();
+  for (const i of r.tables(t, "indexes", path)) {
+    const indexPath = `${path}.indexes`;
+    r.keys(i, indexPath, INDEX_KEYS);
+    const index = dataName(r, i, indexPath, "index", indexNames);
+    const indexed = r.strings(i, "columns", indexPath, true);
+    const unique = r.boolean(i, "unique", indexPath, false);
+    for (const column of indexed) {
+      if (!columnNames.has(column)) r.error("manifest.reference", `index column '${column}' is not a column of '${name ?? "?"}'`, at(i, "columns"));
+    }
+    if (index === null || unique === null || indexed.length === 0) continue;
+    indexes.push({ name: index, columns: indexed, unique });
+  }
+  const rowScope = r.oneOf(t, "row_scope", path, ROW_SCOPES, false) ?? "owner";
+  const mirror = r.oneOf(t, "mirror", path, MIRRORS, false) ?? "server_only";
+  if (columns.length === 0) r.error("manifest.missing", `table '${name ?? "?"}' needs at least one [[data.tables.columns]]`, t.at);
+  if (name === null || columns.length === 0 || primaryKey.length === 0) return null;
+  return { name, columns, primaryKey, indexes, rowScope, mirror };
+}
+function readStatement(r, s, taken) {
+  const path = "data.statements";
+  r.keys(s, path, STATEMENT_KEYS);
+  const name = dataName(r, s, path, "statement", taken);
+  const sql = r.string(s, "sql", path, true);
+  const access = r.oneOf(s, "access", path, STATEMENT_ACCESS);
+  const params = r.integer(s, "params", path, false, 0, CTX_LIMITS.max_db_parameters) ?? 0;
+  const ownerParam = r.integer(s, "owner_param", path, false, 1, CTX_LIMITS.max_db_parameters);
+  const sharedWrite = r.boolean(s, "shared_write", path, false);
+  if (ownerParam !== null && ownerParam > params + 1) {
+    r.error("manifest.range", `statement '${name ?? "?"}' binds the owner at $${ownerParam}, past its ${params} parameters`, at(s, "owner_param"));
+    return null;
+  }
+  if (sharedWrite === true && access !== "write") {
+    r.error("manifest.value", `statement '${name ?? "?"}' is a read, so it cannot be a shared write`, at(s, "shared_write"));
+    return null;
+  }
+  if (name === null || sql === null || access === null || sharedWrite === null) return null;
+  return { name, sql, access, params, ownerParam, sharedWrite };
+}
+function readData(r, root) {
+  const t = r.table(root, "data", "", false);
+  if (!t) return null;
+  r.keys(t, "data", DATA_KEYS);
+  const version = r.integer(t, "version", "data", true, 1, MAX_SCHEMA_VERSION);
+  const tableNames = /* @__PURE__ */ new Set();
+  const tables = [];
+  for (const table of r.tables(t, "tables", "data")) {
+    const read = readTable(r, table, tableNames);
+    if (read !== null) tables.push(read);
+  }
+  const statementNames = /* @__PURE__ */ new Set();
+  const statements = [];
+  for (const statement of r.tables(t, "statements", "data")) {
+    const read = readStatement(r, statement, statementNames);
+    if (read !== null) statements.push(read);
+  }
+  if (version === null) return null;
+  return { version, tables, statements };
+}
+function readRating(r, root) {
+  const t = r.table(root, "rating", "", true);
+  if (!t) return null;
+  r.keys(t, "rating", RATING_KEYS);
+  const violence = r.oneOf(t, "violence", "rating", VIOLENCE);
+  const sexuality = r.oneOf(t, "sexuality", "rating", SEXUALITY);
+  const language = r.oneOf(t, "language", "rating", LANGUAGE);
+  const fear = r.oneOf(t, "fear", "rating", FEAR);
+  const gambling = r.boolean(t, "simulated_gambling", "rating", null);
+  if (sexuality === "explicit") {
+    r.error("manifest.prohibited", "sexually explicit content is not admitted on Cimplify", at(t, "sexuality"));
+    return null;
+  }
+  if (violence === null || sexuality === null || language === null || fear === null || gambling === null) return null;
+  return { violence, sexuality, language, fear, simulated_gambling: gambling };
+}
+function readDelivery(r, root) {
+  const t = r.table(root, "delivery", "", true);
+  if (!t) return null;
+  r.keys(t, "delivery", DELIVERY_KEYS);
+  const tier = r.oneOf(t, "min_device_tier", "delivery", DEVICE_TIERS);
+  const sizeValue = t.entries.get("download_size");
+  let downloadBytes = null;
+  if (sizeValue === void 0) {
+    r.error("manifest.missing", "missing required key 'delivery.download_size'", t.at);
+  } else if (sizeValue.kind === "integer") {
+    downloadBytes = sizeValue.value;
+  } else if (sizeValue.kind === "string") {
+    downloadBytes = parseByteSize(sizeValue.value);
+    if (downloadBytes === null) {
+      r.error("manifest.value", `'delivery.download_size' is '${sizeValue.value}'; write bytes or a size like "12 MiB"`, sizeValue.at);
+    }
+  } else {
+    r.error("manifest.type", `'delivery.download_size' must be bytes or a size string, found ${kindName(sizeValue)}`, sizeValue.at);
+  }
+  const keepOnDevice = r.boolean(t, "keep_on_device", "delivery", false) ?? false;
+  const maxDownload = keepOnDevice ? MAX_KEPT_DOWNLOAD_BYTES : MAX_DOWNLOAD_BYTES;
+  if (downloadBytes !== null && (downloadBytes <= 0 || downloadBytes > maxDownload)) {
+    r.error("manifest.range", `'delivery.download_size' must be between 1 byte and ${maxDownload} bytes`, sizeValue?.at ?? t.at);
+    downloadBytes = null;
+  }
+  const groups = [];
+  const names = /* @__PURE__ */ new Set();
+  let streamed = false;
+  for (const g of r.tables(t, "groups", "delivery")) {
+    r.keys(g, "delivery.groups", GROUP_KEYS);
+    const name = r.string(g, "name", "delivery.groups", true);
+    const beforePlay = r.boolean(g, "before_play", "delivery.groups", false);
+    const assets = r.strings(g, "assets", "delivery.groups", true);
+    if (name === null || beforePlay === null) continue;
+    if (!IDENTIFIER.test(name) || names.has(name)) {
+      r.error(names.has(name) ? "manifest.duplicate" : "manifest.value", `asset group '${name}' must be a unique lowercase name`, at(g, "name"));
+      continue;
+    }
+    if (beforePlay && streamed) {
+      r.error("manifest.order", `asset group '${name}' must arrive before play, so it must come before every streamed group`, g.at);
+      continue;
+    }
+    if (!beforePlay) streamed = true;
+    for (const pattern of assets) {
+      if (!pattern.startsWith("assets/") || pattern.split("/").indexOf("..") >= 0) {
+        r.error("manifest.value", `asset pattern '${pattern}' in group '${name}' must start with assets/`, at(g, "assets"));
+      }
+    }
+    names.add(name);
+    groups.push({ name, beforePlay, assets });
+  }
+  const tierGroups = r.boolean(t, "tier_groups", "delivery", false) ?? false;
+  const parts = r.boolean(t, "parts", "delivery", false) ?? false;
+  const progressive = r.boolean(t, "progressive", "delivery", false) ?? false;
+  const weave = r.boolean(t, "weave", "delivery", false) ?? false;
+  const ranged = r.boolean(t, "ranged", "delivery", false) ?? false;
+  const repairPercent = r.integer(t, "repair_percent", "delivery", false, 1, MAX_REPAIR_PERCENT);
+  if (repairPercent !== null && !ranged) {
+    r.error("manifest.value", "delivery.repair_percent needs delivery.ranged = true, because repair files cover zone files", at(t, "repair_percent"));
+  }
+  if (tier === null || downloadBytes === null) return null;
+  return {
+    minDeviceTier: tier,
+    downloadBytes,
+    groups,
+    ...tierGroups ? { tierGroups } : {},
+    ...parts ? { parts } : {},
+    ...progressive ? { progressive } : {},
+    ...keepOnDevice ? { keepOnDevice } : {},
+    ...weave ? { weave } : {},
+    ...ranged ? { ranged } : {},
+    ...repairPercent !== null && ranged ? { repairPercent } : {}
+  };
+}
+function readSize(r, t, key, path, fallback) {
+  const value = t.entries.get(key);
+  if (value === void 0) return fallback;
+  const bytes = value.kind === "integer" ? value.value : value.kind === "string" ? parseByteSize(value.value) : null;
+  if (bytes === null || bytes < WASM_PAGE_BYTES || bytes > MAX_WASM_MEMORY || bytes % WASM_PAGE_BYTES !== 0) {
+    r.error("manifest.value", `'${join(path, key)}' is a whole number of 64 KiB pages between 64 KiB and 2 GiB, like "32 MiB"`, value.at);
+    return null;
+  }
+  return bytes;
+}
+function enginePath(r, t, key, path, value, prefix) {
+  if (!ENGINE_PATH.test(value) || value.split("/").indexOf("..") >= 0 || !value.startsWith(prefix)) {
+    r.error("manifest.value", `'${join(path, key)}' entry '${value}' must be a relative path under ${prefix}`, at(t, key));
+    return false;
+  }
+  return true;
+}
+function readPacks(r, t, path, accept) {
+  const packs = [];
+  const names = /* @__PURE__ */ new Set();
+  const packPath = join(path, "packs");
+  for (const p of r.tables(t, "packs", path)) {
+    r.keys(p, packPath, PACK_KEYS);
+    const name = r.string(p, "name", packPath, true);
+    const files = r.strings(p, "files", packPath, true);
+    if (name === null) continue;
+    if (!IDENTIFIER.test(name) || names.has(name)) {
+      r.error(names.has(name) ? "manifest.duplicate" : "manifest.value", `pack '${name}' must be a unique lowercase name`, at(p, "name"));
+      continue;
+    }
+    if (files.length === 0 || !files.every(accept)) {
+      r.error("manifest.value", `pack '${name}' lists no files or a file outside the engine project`, at(p, "files"));
+      continue;
+    }
+    names.add(name);
+    packs.push({ name, files });
+  }
+  if (packs.length > MAX_ENGINE_PACKS) r.error("manifest.value", `an engine game streams at most ${MAX_ENGINE_PACKS} packs`, t.at);
+  return packs;
+}
+function readWasmEngine(r, t) {
+  const path = "engine";
+  r.keys(t, path, WASM_ENGINE_KEYS);
+  const language = r.oneOf(t, "language", path, WASM_LANGUAGES);
+  const threads = r.oneOf(t, "threads", path, THREAD_MODES, false) ?? "single";
+  const memoryBytes = readSize(r, t, "memory", path, DEFAULT_WASM_MEMORY);
+  const maxMemoryBytes = readSize(r, t, "max_memory", path, DEFAULT_WASM_MAX_MEMORY);
+  const includes = r.strings(t, "includes", path, false).filter((dir) => enginePath(r, t, "includes", path, dir, NATIVE_DIR));
+  const packs = readPacks(r, t, path, (file) => ENGINE_PATH.test(file) && file.startsWith(NATIVE_DIR) && file.split("/").indexOf("..") < 0);
+  if (language === null || memoryBytes === null || maxMemoryBytes === null) return null;
+  if (maxMemoryBytes < memoryBytes) r.error("manifest.range", "'engine.max_memory' must be at least 'engine.memory'", at(t, "max_memory"));
+  if (language === "rust") {
+    const crate = r.string(t, "crate", path, true);
+    if (t.entries.has("sources")) r.error("manifest.value", "a Rust game names its crate directory, not 'engine.sources'", at(t, "sources"));
+    if (threads === "isolated") r.error("manifest.value", 'threaded Rust needs the standard library rebuilt with atomics, which the pinned stable toolchain does not do; use threads = "single"', at(t, "threads"));
+    if (crate === null || !enginePath(r, t, "crate", path, crate, NATIVE_DIR)) return null;
+    return { kind: "wasm", language, sources: [], includes, crate, threads, memoryBytes, maxMemoryBytes, packs };
+  }
+  if (t.entries.has("crate")) r.error("manifest.value", "'engine.crate' is for Rust games", at(t, "crate"));
+  const pattern = language === "c" ? C_SOURCE : CPP_SOURCE;
+  const sources = r.strings(t, "sources", path, true).filter((source) => enginePath(r, t, "sources", path, source, NATIVE_DIR));
+  if (sources.length === 0) return null;
+  const foreign = sources.find((source) => !pattern.test(source) && !C_SOURCE.test(source));
+  if (foreign !== void 0) {
+    r.error("manifest.value", `'${foreign}' is not a ${language === "c" ? "C" : "C or C++"} translation unit`, at(t, "sources"));
+    return null;
+  }
+  return { kind: "wasm", language, sources, includes, crate: null, threads, memoryBytes, maxMemoryBytes, packs };
+}
+function readGodotEngine(r, t) {
+  const path = "engine";
+  r.keys(t, path, GODOT_ENGINE_KEYS);
+  const project = r.string(t, "project", path, true);
+  const threads = r.oneOf(t, "threads", path, THREAD_MODES, false) ?? "single";
+  const runtime = r.oneOf(t, "runtime", path, GODOT_RUNTIME_KINDS, false) ?? "full";
+  const packs = readPacks(r, t, path, (pattern) => GODOT_RESOURCE.test(pattern) && pattern.split("/").indexOf("..") < 0);
+  if (runtime === "2d" && threads === "isolated") {
+    r.error("manifest.value", `the 2D Godot runtime is single-threaded; use threads = "single", or runtime = "3d" or "full"`, at(t, "runtime"));
+    return null;
+  }
+  if (project === null || !ENGINE_PATH.test(project) || project.split("/").indexOf("..") >= 0) {
+    if (project !== null) r.error("manifest.value", `'engine.project' is '${project}'; name the directory that holds project.godot`, at(t, "project"));
+    return null;
+  }
+  return { kind: "godot", project: project.replace(TRAILING_SLASHES, ""), threads, runtime, packs };
+}
+function readEngine(r, root, profile) {
+  const game = profile?.game ?? null;
+  if (!isEngineGame(game)) {
+    if (root.entries.has("engine")) r.error("manifest.value", '[engine] is read only for profile.game = "wasm" or "godot"', root.entries.get("engine")?.at ?? root.at);
+    return null;
+  }
+  const t = r.table(root, "engine", "", true);
+  if (!t) return null;
+  return game === "wasm" ? readWasmEngine(r, t) : readGodotEngine(r, t);
+}
+var AI_KEYS = ["payer", "languages", "per_player_daily_units", "per_session_units", "per_interactive_monthly_units", "characters", "prompts", "schemas", "actions", "styles"];
+var AI_CHARACTER_KEYS = ["name", "persona", "voice", "memory", "quality", "actions", "companion", "slots"];
+var AI_PROMPT_KEYS = ["name", "template", "output", "schema", "set", "quality", "cache", "player_text", "slots"];
+var AI_SLOT_KEYS = ["name", "kind", "max_chars", "min", "max", "values", "items"];
+var AI_SCHEMA_KEYS = ["name", "schema"];
+var AI_ACTION_SET_KEYS = ["set", "actions"];
+var AI_ACTION_KEYS = ["name", "description", "args"];
+var AI_STYLE_KEYS = ["name", "description", "reference"];
+var AI_PAYERS = ["creator", "player", "sponsor"];
+var AI_MEMORY = ["none", "session", "persistent"];
+var AI_QUALITY = ["fast", "standard", "best"];
+var AI_CACHE = ["none", "personal", "interactive"];
+var AI_OUTPUTS = ["text", "structured", "actions"];
+var AI_SLOT_KINDS = ["text", "integer", "number", "choice"];
+var AI_ARG_KINDS = ["integer", "number", "text", "choice", "item"];
+var AI_NAME = /^[a-z][a-z0-9_]{0,47}$/;
+var AI_TEXT_MAX = 8e3;
+var AI_SLOT_TEXT_MAX = 200;
+var AI_UNITS_MAX = 1e9;
+var AI_DEFAULT_CAPS = [
+  ["per_player_daily_units", 5e3],
+  ["per_session_units", 3e3],
+  ["per_interactive_monthly_units", 1e5]
+];
+function tomlJson(value) {
+  if (value.kind === "array") return value.items.map(tomlJson);
+  if (value.kind === "table") {
+    const out = {};
+    for (const [key, item] of value.entries) out[key] = tomlJson(item);
+    return out;
+  }
+  return value.value;
+}
+function aiName(r, table, key, path, names) {
+  const name = r.string(table, key, path, true, 48);
+  if (name === null) return null;
+  if (!AI_NAME.test(name)) {
+    r.error("manifest.value", `'${join(path, key)}' must be lowercase letters, digits and underscores, starting with a letter`, at(table, key));
+    return null;
+  }
+  if (names !== null) {
+    if (names.has(name)) r.error("manifest.duplicate", `${path} '${name}' is declared twice`, at(table, key));
+    names.add(name);
+  }
+  return name;
+}
+function readAiSlots(r, parent, path, kinds) {
+  const out = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const s of r.tables(parent, path === "args" ? "args" : "slots", path)) {
+    r.keys(s, path, AI_SLOT_KEYS);
+    const name = aiName(r, s, "name", path, names);
+    const kind = r.oneOf(s, "kind", path, kinds);
+    if (name === null || kind === null) continue;
+    if (kind === "text") {
+      const max = r.integer(s, "max_chars", path, true, 1, AI_SLOT_TEXT_MAX);
+      if (max !== null) out.push({ name, kind, max_chars: max });
+    } else if (kind === "integer" || kind === "number") {
+      const min = r.integer(s, "min", path, true, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+      const max = r.integer(s, "max", path, true, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+      if (min !== null && max !== null) {
+        if (min > max) r.error("manifest.range", `${path} '${name}' has min above max`, at(s, "min"));
+        else out.push({ name, kind, min, max });
+      }
+    } else {
+      const key = kind === "item" ? "items" : "values";
+      const values = r.strings(s, key, path, true);
+      if (values.length === 0) r.error("manifest.missing", `${path} '${name}' needs at least one of ${key}`, s.at);
+      else out.push({ name, kind, [key]: values });
+    }
+  }
+  return out;
+}
+var WORLD_SIMULATIONS = ["build", "frontier", "genesis"];
+var WORLD_KEYS = ["simulation"];
+var KERNELS_KEYS = ["lower", "exact_math", "no_lower"];
+var NO_LOWER_ENTRY = /^[^#\s]+(#[A-Za-z_$][A-Za-z0-9_$]*)?$/;
+function readKernels(r, root) {
+  const t = r.table(root, "kernels", "", false);
+  if (!t) return null;
+  r.keys(t, "kernels", KERNELS_KEYS);
+  const lower = r.boolean(t, "lower", "kernels", DEFAULT_KERNELS.lower) ?? DEFAULT_KERNELS.lower;
+  const exactMath = r.boolean(t, "exact_math", "kernels", DEFAULT_KERNELS.exactMath) ?? DEFAULT_KERNELS.exactMath;
+  const noLower = t.entries.has("no_lower") ? r.strings(t, "no_lower", "kernels", false) : [];
+  for (const entry of noLower) {
+    if (!NO_LOWER_ENTRY.test(entry)) r.error("manifest.kernels", `[kernels] no_lower entry '${entry}' must be a source path such as src/sim.ts, or a path and function such as src/sim.ts#integrate`, at(t, "no_lower"));
+  }
+  return { lower, exactMath, noLower };
+}
+function readWorld(r, root) {
+  const t = r.table(root, "world", "", false);
+  if (!t) return null;
+  r.keys(t, "world", WORLD_KEYS);
+  const simulation = r.oneOf(t, "simulation", "world", WORLD_SIMULATIONS);
+  return simulation === null ? null : { simulation };
+}
+function readAi(r, root) {
+  const t = r.table(root, "ai", "", false);
+  if (!t) return null;
+  r.keys(t, "ai", AI_KEYS);
+  const payer = r.oneOf(t, "payer", "ai", AI_PAYERS);
+  const languages = r.strings(t, "languages", "ai", true);
+  const ai = { payer, languages };
+  for (const [key, fallback] of AI_DEFAULT_CAPS) {
+    ai[key] = r.integer(t, key, "ai", false, 1, AI_UNITS_MAX) ?? fallback;
+  }
+  if (ai.per_session_units > ai.per_player_daily_units) {
+    r.error("manifest.range", "[ai] per_session_units cannot exceed per_player_daily_units", t.at);
+  }
+  const characters = [];
+  const characterNames = /* @__PURE__ */ new Set();
+  for (const c of r.tables(t, "characters", "ai")) {
+    r.keys(c, "ai.characters", AI_CHARACTER_KEYS);
+    const name = aiName(r, c, "name", "ai.characters", characterNames);
+    const persona = r.string(c, "persona", "ai.characters", true, AI_TEXT_MAX);
+    const memory = r.oneOf(c, "memory", "ai.characters", AI_MEMORY);
+    const quality = r.oneOf(c, "quality", "ai.characters", AI_QUALITY);
+    const voice = r.string(c, "voice", "ai.characters", false, 48);
+    const actions = r.string(c, "actions", "ai.characters", false, 48);
+    const companion = r.boolean(c, "companion", "ai.characters", false) ?? false;
+    const slots = readAiSlots(r, c, "ai.characters.slots", AI_SLOT_KINDS);
+    if (name === null || persona === null || memory === null || quality === null) continue;
+    characters.push({ name, persona, voice, memory, quality, actions, companion, slots });
+  }
+  const prompts = [];
+  const promptNames = /* @__PURE__ */ new Set();
+  for (const p of r.tables(t, "prompts", "ai")) {
+    r.keys(p, "ai.prompts", AI_PROMPT_KEYS);
+    const name = aiName(r, p, "name", "ai.prompts", promptNames);
+    const template = r.string(p, "template", "ai.prompts", true, AI_TEXT_MAX);
+    const kind = r.oneOf(p, "output", "ai.prompts", AI_OUTPUTS);
+    const quality = r.oneOf(p, "quality", "ai.prompts", AI_QUALITY);
+    const cache = r.oneOf(p, "cache", "ai.prompts", AI_CACHE);
+    const playerText = r.boolean(p, "player_text", "ai.prompts", false) ?? false;
+    const slots = readAiSlots(r, p, "ai.prompts.slots", AI_SLOT_KINDS);
+    let output = null;
+    if (kind === "text") output = { kind };
+    else if (kind === "structured") output = { kind, schema: r.string(p, "schema", "ai.prompts", true, 48) };
+    else if (kind === "actions") output = { kind, set: r.string(p, "set", "ai.prompts", true, 48) };
+    if (cache === "interactive" && playerText) {
+      r.error("manifest.value", `prompt '${name ?? "?"}' is shared across players (cache = "interactive") so it cannot take player_text`, at(p, "cache"));
+      continue;
+    }
+    if (name === null || template === null || output === null || quality === null || cache === null) continue;
+    prompts.push({ name, template, output, quality, cache, player_text: playerText, slots });
+  }
+  const schemas = [];
+  const schemaNames = /* @__PURE__ */ new Set();
+  for (const s of r.tables(t, "schemas", "ai")) {
+    r.keys(s, "ai.schemas", AI_SCHEMA_KEYS);
+    const name = aiName(r, s, "name", "ai.schemas", schemaNames);
+    const schema = r.table(s, "schema", "ai.schemas", true);
+    if (name !== null && schema !== null) schemas.push({ name, schema: tomlJson(schema) });
+  }
+  const actionSets = [];
+  const setNames = /* @__PURE__ */ new Set();
+  for (const a of r.tables(t, "actions", "ai")) {
+    r.keys(a, "ai.actions", AI_ACTION_SET_KEYS);
+    const set = aiName(r, a, "set", "ai.actions", setNames);
+    const actions = [];
+    const actionNames = /* @__PURE__ */ new Set();
+    for (const action of r.tables(a, "actions", "ai.actions")) {
+      r.keys(action, "ai.actions.actions", AI_ACTION_KEYS);
+      const name = aiName(r, action, "name", "ai.actions.actions", actionNames);
+      const description = r.string(action, "description", "ai.actions.actions", false, 200) ?? "";
+      const args = readAiSlots(r, action, "args", AI_ARG_KINDS);
+      if (name !== null) actions.push({ name, description, args });
+    }
+    if (set !== null) actionSets.push({ set, actions });
+  }
+  const styles = [];
+  const styleNames = /* @__PURE__ */ new Set();
+  for (const s of r.tables(t, "styles", "ai")) {
+    r.keys(s, "ai.styles", AI_STYLE_KEYS);
+    const name = aiName(r, s, "name", "ai.styles", styleNames);
+    const description = r.string(s, "description", "ai.styles", true, 400);
+    const reference = r.string(s, "reference", "ai.styles", false, 200);
+    if (name !== null && description !== null) styles.push({ name, description, reference });
+  }
+  if (characters.length === 0 && prompts.length === 0 && styles.length === 0) {
+    r.error("manifest.missing", "[ai] declares no characters, prompts or styles", t.at);
+  }
+  ai.characters = characters;
+  ai.prompts = prompts;
+  ai.schemas = schemas;
+  ai.actions = actionSets;
+  ai.styles = styles;
+  return ai;
+}
+function readContent(r, root, groups) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const t of r.tables(root, "content", "")) {
+    r.keys(t, "content", CONTENT_KEYS);
+    const item = r.string(t, "item", "content", true);
+    const version = r.string(t, "version", "content", false) ?? "*";
+    const group = r.string(t, "group", "content", false);
+    if (item === null) continue;
+    if (!CONTENT_ITEM.test(item)) {
+      r.error("manifest.value", `'content.item' is '${item}'; write a Workshop reference like cimplify/danfo-bus`, at(t, "item"));
+      continue;
+    }
+    if (!CONTENT_RANGE.test(version)) {
+      r.error("manifest.value", `'content.version' is '${version}'; write a version range like "^2.1", "~1.0", "=1.2.3" or "*"`, at(t, "version"));
+      continue;
+    }
+    if (group !== null && groups.indexOf(group) < 0) {
+      r.error("manifest.value", `'content.group' names '${group}', which is not one of the [[delivery.groups]]`, at(t, "group"));
+      continue;
+    }
+    if (seen.has(item)) {
+      r.error("manifest.duplicate", `content '${item}' is listed twice`, t.at);
+      continue;
+    }
+    seen.add(item);
+    out.push({ item, version, group });
+  }
+  return out;
+}
+function readCredits(r, root) {
+  const out = [];
+  for (const t of r.tables(root, "credits", "")) {
+    r.keys(t, "credits", CREDIT_KEYS);
+    const title = r.string(t, "title", "credits", true, MAX_CREDIT_TEXT);
+    const licence = r.string(t, "licence", "credits", true, MAX_CREDIT_TEXT);
+    const authors = r.strings(t, "authors", "credits", true);
+    const licenceUrl = r.string(t, "licence_url", "credits", false, MAX_CREDIT_TEXT);
+    const sourceUrl = r.string(t, "source_url", "credits", false, MAX_CREDIT_TEXT);
+    const modified = r.boolean(t, "modified", "credits", false);
+    if (title === null || licence === null || modified === null) continue;
+    if (authors.length === 0 || authors.length > MAX_CREDIT_AUTHORS || authors.some((a) => a.trim().length === 0 || a.length > MAX_CREDIT_TEXT)) {
+      r.error("manifest.value", `'credits.authors' needs 1 to ${MAX_CREDIT_AUTHORS} names`, at(t, "authors"));
+      continue;
+    }
+    out.push({ title, authors, licence, licenceUrl, sourceUrl, modified });
+  }
+  return out;
+}
+function parseManifest(source, file = MANIFEST_FILE) {
+  let root;
+  try {
+    root = parseToml(source);
+  } catch (err) {
+    if (err instanceof TomlSyntaxError) {
+      return { manifest: null, diagnostics: [diagnostic("manifest.syntax", err.reason, file, err)] };
+    }
+    throw err;
+  }
+  const r = new Reader(file);
+  r.keys(root, "", TOP_LEVEL);
+  const identity = readIdentity(r, root);
+  const profile = readProfile(r, root);
+  const entries = readEntries(r, root, profile);
+  const capabilities = readCapabilities(r, root);
+  const providers = readProviders(r, root);
+  const economy = readEconomy(r, root, identity === null ? null : { category: identity.category, capabilities: capabilities.map((c) => c.name) });
+  const data = readData(r, root);
+  const ai = readAi(r, root);
+  const rating = readRating(r, root);
+  const delivery = readDelivery(r, root);
+  const engine = readEngine(r, root, profile);
+  const content = readContent(r, root, delivery?.groups.map((g) => g.name) ?? []);
+  const credits = readCredits(r, root);
+  const world = readWorld(r, root);
+  const kernels = readKernels(r, root);
+  if (world !== null && !capabilities.some((c) => c.name === "world")) {
+    r.error("manifest.capability", "[world] runs the world's simulation on the tick service, so [capabilities] must request world", root.entries.get("world")?.at ?? root.at);
+  }
+  if ((economy.offers.length > 0 || economy.currencies.some((c) => c.class === "premium")) && !capabilities.some((c) => c.name === "wallet")) {
+    r.error("manifest.capability", "premium currencies and Cimples offers are bought through ctx.wallet, so [capabilities] must request wallet", root.entries.get("economy")?.at ?? root.at);
+  }
+  if (data !== null && !capabilities.some((c) => c.name === "db")) {
+    r.error("manifest.capability", "[data] is read and written through ctx.db, so [capabilities] must request db", root.entries.get("data")?.at ?? root.at);
+  }
+  const requestsAi = capabilities.some((c) => c.name === "ai");
+  if (ai !== null && !requestsAi) {
+    r.error("manifest.capability", "[ai] is called through ctx.ai, so [capabilities] must request ai", root.entries.get("ai")?.at ?? root.at);
+  }
+  if (ai === null && requestsAi) {
+    r.error("manifest.missing", "[capabilities] requests ai, so declare its characters, prompts or styles in [ai]", root.at);
+  }
+  if (providers.length > 0 && !capabilities.some((c) => c.name === "provider")) {
+    r.error("manifest.capability", "[[providers]] are called through ctx.provider, so [capabilities] must request provider", root.entries.get("providers")?.at ?? root.at);
+  }
+  if (r.diagnostics.length > 0 || !identity || !profile || !entries || !rating || !delivery || isEngineGame(profile.game) && engine === null) {
+    return { manifest: null, diagnostics: r.diagnostics };
+  }
+  return {
+    manifest: {
+      identity,
+      profile,
+      entries,
+      capabilities,
+      providers,
+      economy,
+      data,
+      ai,
+      rating,
+      delivery,
+      engine,
+      ...content.length === 0 ? {} : { content },
+      ...credits.length === 0 ? {} : { credits },
+      ...world === null ? {} : { world },
+      ...kernels === null ? {} : { kernels }
+    },
+    diagnostics: []
+  };
+}
+function assignInteractiveId(source, id) {
+  if (!INTERACTIVE_ID.test(id)) throw new Error(`invalid interactive id ${id}`);
+  const lines = source.split("\n");
+  const header = lines.findIndex((l) => l.trim() === "[interactive]");
+  if (header < 0) throw new Error("interactive.toml has no [interactive] table");
+  lines.splice(header + 1, 0, `id = "${id}"`);
+  return lines.join("\n");
+}
+
+export { DEFAULT_KERNELS, ENGINE_ENTRY, LOCKFILE, MANIFEST_FILE, assignInteractiveId, checkLockfile, currentLockfile, isEngineGame, isItemReference, lockedMissingOperations, lockedVersion, parseLockfile, parseManifest, serializeLockfile, withContent, withCurrentContract, withLibrary };