@storylet-studio/model 0.1.0

package/README.md

@@ -0,0 +1,12 @@
+# @storylet-studio/model
+
+Storylets data-model types: source shards (project / box / tags / hands /
+deck files), the compiled `.storyletsc` bundle, and the save
+envelope. The shape source-of-truth; no behaviour.
+
+Entity shapes are generic over their expression representation: source
+shards carry plain `src` strings (`Card<string>`), the compiled bundle
+carries `{ src, ast }` envelopes (`Card<Expression>`).
+
+Authored against [the bundle format](https://storylet.studio/format/bundle/)
+and [the source format](https://storylet.studio/format/shards/).

package/dist/index.cjs

@@ -0,0 +1,574 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BOX_SCHEMA: () => BOX_SCHEMA,
+  BUNDLE_EXTENSION: () => BUNDLE_EXTENSION,
+  BUNDLE_SCHEMA: () => BUNDLE_SCHEMA,
+  DECK_SCHEMA: () => DECK_SCHEMA,
+  FURNITURE_COLOURS: () => FURNITURE_COLOURS,
+  HANDS_SCHEMA: () => HANDS_SCHEMA,
+  NOTES_SCHEMA: () => NOTES_SCHEMA,
+  PLACE_GROUP: () => PLACE_GROUP,
+  PROJECT_FOLDER_EXTENSION: () => PROJECT_FOLDER_EXTENSION,
+  PROJECT_SCHEMA: () => PROJECT_SCHEMA,
+  RESERVED_PROPERTY_NAMES: () => import_expr.RESERVED_PROPERTY_NAMES,
+  SAVEFILE_SCHEMA: () => SAVEFILE_SCHEMA,
+  SAVE_SCHEMA: () => SAVE_SCHEMA,
+  SHARD_EXTENSIONS: () => SHARD_EXTENSIONS,
+  SPATIAL: () => SPATIAL,
+  TAGS_SCHEMA: () => TAGS_SCHEMA,
+  VIEW_SCHEMA: () => VIEW_SCHEMA,
+  backgroundsOf: () => backgroundsOf,
+  bindHand: () => bindHand,
+  bundleAssetPath: () => bundleAssetPath,
+  byDisplayOrder: () => byDisplayOrder,
+  centroid: () => centroid,
+  commentsOf: () => commentsOf,
+  droppedRect: () => droppedRect,
+  effectiveGameId: () => effectiveGameId,
+  framesOf: () => framesOf,
+  freeGameId: () => freeGameId,
+  freeTitle: () => freeTitle,
+  gameIdify: () => gameIdify,
+  handBinding: () => handBinding,
+  inferDeclFromWrite: () => inferDeclFromWrite,
+  isCaseOnlyPropertyName: () => import_expr.isCaseOnlyPropertyName,
+  isSpatial: () => isSpatial,
+  isValidGameId: () => isValidGameId,
+  isValidPropertyName: () => import_expr.isValidPropertyName,
+  labelPoint: () => labelPoint,
+  markOf: () => markOf,
+  marksOn: () => marksOn,
+  openThreadCounts: () => openThreadCounts,
+  pointInPolygon: () => pointInPolygon,
+  polygonBounds: () => polygonBounds,
+  polygonOf: () => polygonOf,
+  propertyNameify: () => import_expr.propertyNameify,
+  restack: () => restack,
+  spatialOf: () => spatialOf,
+  stacked: () => stacked,
+  threadsFor: () => threadsFor,
+  unbindHand: () => unbindHand,
+  withBackgrounds: () => withBackgrounds,
+  withPolygon: () => withPolygon,
+  withSpatialGroup: () => withSpatialGroup,
+  withZ: () => withZ,
+  zOf: () => zOf,
+  zoneAt: () => zoneAt,
+  zonesAt: () => zonesAt
+});
+module.exports = __toCommonJS(index_exports);
+var import_expr = require("@wildwinter/expr");
+
+// src/spatial.ts
+var SPATIAL = "spatial";
+function stacked(items) {
+  return items.map((item, index) => ({ item, z: item.z ?? index })).sort((a, b) => a.z - b.z).map((entry) => entry.item);
+}
+function restack(items, id, move) {
+  const order = items.map((item, index) => ({ id: item.id, z: item.z ?? index })).sort((a, b) => a.z - b.z);
+  const at = order.findIndex((entry) => entry.id === id);
+  if (at < 0 || order.length < 2) return void 0;
+  const front = order.length - 1;
+  if (move === "back") return at === 0 ? void 0 : order[0].z - 1;
+  if (move === "front") return at === front ? void 0 : order[front].z + 1;
+  if (move === "backward") {
+    if (at === 0) return void 0;
+    const passed2 = order[at - 1].z;
+    const beyond2 = at >= 2 ? order[at - 2].z : passed2 - 2;
+    return (passed2 + beyond2) / 2;
+  }
+  if (at === front) return void 0;
+  const passed = order[at + 1].z;
+  const beyond = at + 2 <= front ? order[at + 2].z : passed + 2;
+  return (passed + beyond) / 2;
+}
+function isSpatial(group) {
+  return spatialOf(group) !== void 0;
+}
+function spatialOf(group) {
+  const bag = group.templates?.[SPATIAL];
+  if (!isRecord(bag) || bag["map"] !== true) return void 0;
+  const backgrounds = backgroundsOf(group);
+  return { map: true, ...backgrounds.length > 0 ? { backgrounds } : {} };
+}
+function backgroundsOf(group) {
+  const bag = group.templates?.[SPATIAL];
+  if (!isRecord(bag)) return [];
+  const list = bag["backgrounds"];
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  for (const entry of list) {
+    const one = asBackground(entry);
+    if (one) out.push(one);
+  }
+  return stacked(out);
+}
+function asBackground(entry) {
+  if (!isRecord(entry)) return void 0;
+  const { id, file, x, y, width, height, opacity, z, hidden, locked } = entry;
+  if (typeof id !== "string" || id === "") return void 0;
+  if (typeof file !== "string" || file === "") return void 0;
+  const nums = [x, y, width, height];
+  if (!nums.every((n) => typeof n === "number" && Number.isFinite(n))) return void 0;
+  if (width <= 0 || height <= 0) return void 0;
+  return {
+    id,
+    file,
+    x,
+    y,
+    width,
+    height,
+    ...typeof opacity === "number" && Number.isFinite(opacity) ? { opacity: clamp01(opacity) } : {},
+    ...typeof z === "number" && Number.isFinite(z) ? { z } : {},
+    ...hidden === true ? { hidden: true } : {},
+    ...locked === true ? { locked: true } : {}
+  };
+}
+var clamp01 = (n) => Math.min(1, Math.max(0, n));
+function droppedRect(natural, view, scale, at) {
+  const safe = (n, fallback) => Number.isFinite(n) && n > 0 ? n : fallback;
+  const naturalW = safe(natural.width, 1);
+  const naturalH = safe(natural.height, 1);
+  const room = { width: safe(view.width, 800) * 0.6, height: safe(view.height, 600) * 0.6 };
+  const fit = Math.min(room.width / naturalW, room.height / naturalH) / safe(scale, 1);
+  const width = Math.max(1, Math.round(naturalW * fit));
+  const height = Math.max(1, Math.round(naturalH * fit));
+  return { x: Math.round(at.x - width / 2), y: Math.round(at.y - height / 2), width, height };
+}
+function withBackgrounds(group, backgrounds) {
+  const had = isRecord(group.templates?.[SPATIAL]) ? { ...group.templates[SPATIAL] } : {};
+  had["map"] = true;
+  if (backgrounds.length > 0) {
+    had["backgrounds"] = backgrounds.map((b) => ({
+      ...b,
+      // Whole units in, exactly as polygons are: a rect dragged by hand would
+      // otherwise write six decimal places of noise into a file two people have
+      // to merge.
+      x: Math.round(b.x),
+      y: Math.round(b.y),
+      width: Math.round(b.width),
+      height: Math.round(b.height)
+    }));
+  } else delete had["backgrounds"];
+  return setBag(group.templates, had);
+}
+function polygonOf(tag) {
+  const bag = tag.templates?.[SPATIAL];
+  if (!isRecord(bag)) return void 0;
+  const points = bag["polygon"];
+  if (!Array.isArray(points) || points.length < 3) return void 0;
+  const out = [];
+  for (const p of points) {
+    if (!isRecord(p)) return void 0;
+    const { x, y } = p;
+    if (typeof x !== "number" || typeof y !== "number") return void 0;
+    if (!Number.isFinite(x) || !Number.isFinite(y)) return void 0;
+    out.push({ x, y });
+  }
+  return out;
+}
+function withSpatialGroup(group, on) {
+  return setBag(group.templates, on ? { map: true } : void 0);
+}
+function zOf(tag) {
+  const bag = tag.templates?.[SPATIAL];
+  if (!isRecord(bag)) return void 0;
+  const z = bag["z"];
+  return typeof z === "number" && Number.isFinite(z) ? z : void 0;
+}
+function withZ(tag, z) {
+  const had = isRecord(tag.templates?.[SPATIAL]) ? { ...tag.templates[SPATIAL] } : {};
+  had["z"] = Math.round(z * 1e3) / 1e3;
+  return setBag(tag.templates, had);
+}
+function withPolygon(tag, polygon) {
+  const had = isRecord(tag.templates?.[SPATIAL]) ? { ...tag.templates[SPATIAL] } : {};
+  if (polygon === void 0) delete had["polygon"];
+  else had["polygon"] = polygon.map((p) => ({ x: Math.round(p.x), y: Math.round(p.y) }));
+  return setBag(tag.templates, Object.keys(had).length > 0 ? had : void 0);
+}
+function setBag(templates, bag) {
+  const next = { ...templates ?? {} };
+  if (bag === void 0) delete next[SPATIAL];
+  else next[SPATIAL] = bag;
+  return Object.keys(next).length > 0 ? next : void 0;
+}
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function polygonBounds(polygon) {
+  const xs = polygon.map((p) => p.x);
+  const ys = polygon.map((p) => p.y);
+  const x = Math.min(...xs);
+  const y = Math.min(...ys);
+  return { x, y, width: Math.max(...xs) - x, height: Math.max(...ys) - y };
+}
+function centroid(polygon) {
+  let twiceArea = 0;
+  let x = 0;
+  let y = 0;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const a = polygon[i];
+    const b = polygon[j];
+    const cross = a.x * b.y - b.x * a.y;
+    twiceArea += cross;
+    x += (a.x + b.x) * cross;
+    y += (a.y + b.y) * cross;
+  }
+  if (twiceArea === 0) {
+    const n = polygon.length;
+    return n === 0 ? { x: 0, y: 0 } : { x: polygon.reduce((s, p) => s + p.x, 0) / n, y: polygon.reduce((s, p) => s + p.y, 0) / n };
+  }
+  const scale = 1 / (3 * twiceArea);
+  return { x: x * scale, y: y * scale };
+}
+function labelPoint(polygon, opts = {}) {
+  if (polygon.length < 3) return centroid(polygon);
+  const box = polygonBounds(polygon);
+  if (opts.bias === "top") {
+    const lines = [];
+    for (let i = 1; i <= 8; i++) {
+      const y2 = box.y + box.height * i / 12;
+      const run2 = widestRun(polygon, y2);
+      if (run2 && run2.width > 0) lines.push({ y: y2, run: run2 });
+    }
+    const widest = Math.max(0, ...lines.map((l) => l.run.width));
+    const pick = lines.find((l) => l.run.width >= widest * 0.7);
+    if (pick) return { x: pick.run.x, y: pick.y };
+  }
+  const y = centroid(polygon).y;
+  const run = widestRun(polygon, y);
+  if (run) return { x: run.x, y };
+  const middle = centroid(polygon);
+  if (pointInPolygon(middle, polygon)) return middle;
+  const rescue = widestRun(polygon, middle.y);
+  return rescue ? { x: rescue.x, y: middle.y } : middle;
+}
+function widestRun(polygon, y) {
+  const crossings = [];
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const a = polygon[i];
+    const b = polygon[j];
+    if (a.y > y === b.y > y) continue;
+    crossings.push(a.x + (y - a.y) / (b.y - a.y) * (b.x - a.x));
+  }
+  crossings.sort((p, q) => p - q);
+  let best;
+  for (let i = 0; i + 1 < crossings.length; i += 2) {
+    const from = crossings[i];
+    const to = crossings[i + 1];
+    if (!best || to - from > best.width) best = { x: (from + to) / 2, width: to - from };
+  }
+  return best;
+}
+function pointInPolygon(point, polygon) {
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const a = polygon[i];
+    const b = polygon[j];
+    const straddles = a.y > point.y !== b.y > point.y;
+    if (!straddles) continue;
+    const at = a.x + (point.y - a.y) / (b.y - a.y) * (b.x - a.x);
+    if (point.x < at) inside = !inside;
+  }
+  return inside;
+}
+function zoneAt(point, zones) {
+  return zonesAt(point, zones)[0];
+}
+function zonesAt(point, zones) {
+  const order = stacked(zones);
+  const hits = [];
+  for (let i = order.length - 1; i >= 0; i--) {
+    const zone = order[i];
+    if (pointInPolygon(point, zone.polygon)) hits.push(zone.id);
+  }
+  return hits;
+}
+
+// src/hands.ts
+function handBinding(hand, template, groupId) {
+  if (hand.rule !== void 0) {
+    const tag = hand.rule.bindings?.[groupId];
+    return tag === void 0 ? { kind: "rule", editable: true } : { kind: "rule", tag, editable: true };
+  }
+  if (template?.chooses?.includes(groupId)) {
+    const tag = hand.chosen?.[groupId];
+    return tag === void 0 ? { kind: "chosen", editable: true } : { kind: "chosen", tag, editable: true };
+  }
+  const fixed = template?.bindings?.[groupId];
+  if (fixed !== void 0) return { kind: "fixed", tag: fixed, editable: false };
+  return { kind: "none", editable: false };
+}
+function unbindHand(hand, template, groupId) {
+  const binding = handBinding(hand, template, groupId);
+  if (!binding.editable || binding.tag === void 0) return false;
+  if (binding.kind === "rule") {
+    const bindings = { ...hand.rule.bindings };
+    delete bindings[groupId];
+    hand.rule = { ...hand.rule, ...Object.keys(bindings).length > 0 ? { bindings } : {} };
+    if (Object.keys(bindings).length === 0) delete hand.rule.bindings;
+    return true;
+  }
+  const chosen = { ...hand.chosen };
+  delete chosen[groupId];
+  if (Object.keys(chosen).length > 0) hand.chosen = chosen;
+  else delete hand.chosen;
+  return true;
+}
+function bindHand(hand, template, groupId, tagId) {
+  const binding = handBinding(hand, template, groupId);
+  if (!binding.editable || binding.tag === tagId) return false;
+  if (binding.kind === "rule") {
+    hand.rule = { ...hand.rule, bindings: { ...hand.rule.bindings, [groupId]: tagId } };
+    return true;
+  }
+  hand.chosen = { ...hand.chosen, [groupId]: tagId };
+  return true;
+}
+
+// src/furniture.ts
+var isRecord2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+var colourOf = (v) => typeof v === "string" && FURNITURE_COLOURS.includes(v) ? v : void 0;
+function framesOf(canvas) {
+  const list = canvas?.frames;
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  for (const entry of list) {
+    if (!isRecord2(entry)) continue;
+    const id = entry["id"];
+    const x = num(entry["x"]), y = num(entry["y"]);
+    const w = num(entry["w"]), h = num(entry["h"]);
+    if (typeof id !== "string" || id === "") continue;
+    if (x === void 0 || y === void 0 || w === void 0 || h === void 0) continue;
+    if (w <= 0 || h <= 0) continue;
+    const title = entry["title"];
+    const colour = colourOf(entry["colour"]);
+    const z = num(entry["z"]);
+    out.push({
+      id,
+      x,
+      y,
+      w,
+      h,
+      ...typeof title === "string" && title !== "" ? { title } : {},
+      ...colour !== void 0 ? { colour } : {},
+      ...z !== void 0 ? { z } : {}
+    });
+  }
+  return stacked(out);
+}
+
+// src/comments.ts
+var isRecord3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function markOf(thread) {
+  const mark = thread.mark;
+  if (!mark) return void 0;
+  return {
+    canvas: mark.canvas,
+    x: mark.x,
+    y: mark.y,
+    ...thread.anchor === mark.canvas ? {} : { item: thread.anchor }
+  };
+}
+var marksOn = (shard, canvas) => commentsOf(shard).filter((c) => c.mark?.canvas === canvas);
+function markIn(value) {
+  if (!isRecord3(value)) return void 0;
+  const canvas = value["canvas"], x = value["x"], y = value["y"];
+  if (typeof canvas !== "string" || canvas === "") return void 0;
+  if (typeof x !== "number" || !Number.isFinite(x)) return void 0;
+  if (typeof y !== "number" || !Number.isFinite(y)) return void 0;
+  return { mark: { canvas, x, y } };
+}
+function commentsOf(shard) {
+  const list = shard?.comments;
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  for (const entry of list) {
+    if (!isRecord3(entry)) continue;
+    const id = entry["id"], anchor = entry["anchor"];
+    if (typeof id !== "string" || id === "" || typeof anchor !== "string" || anchor === "") continue;
+    const raw = Array.isArray(entry["messages"]) ? entry["messages"] : [];
+    const messages = [];
+    for (const m of raw) {
+      if (!isRecord3(m)) continue;
+      const body = m["body"];
+      if (typeof body !== "string") continue;
+      const deleted = m["deleted"] === true;
+      if (!deleted && body.trim() === "") continue;
+      messages.push({
+        author: typeof m["author"] === "string" ? m["author"] : "",
+        ts: typeof m["ts"] === "string" ? m["ts"] : "",
+        body: deleted ? "" : body,
+        ...deleted ? { deleted: true } : {}
+      });
+    }
+    if (messages.length === 0) continue;
+    out.push({
+      id,
+      anchor,
+      ...entry["resolved"] === true ? { resolved: true } : {},
+      ...markIn(entry["mark"]) ?? {},
+      messages
+    });
+  }
+  return out;
+}
+var threadsFor = (shard, anchor) => commentsOf(shard).filter((c) => c.anchor === anchor);
+function openThreadCounts(shard) {
+  const out = {};
+  for (const thread of commentsOf(shard)) {
+    if (thread.resolved === true) continue;
+    out[thread.anchor] = (out[thread.anchor] ?? 0) + 1;
+  }
+  return out;
+}
+
+// src/infer.ts
+function inferDeclFromWrite(src) {
+  const s = src.trim();
+  if (s === "true" || s === "false") return { type: "boolean", default: false };
+  if (/^-?\d+(\.\d+)?$/.test(s)) return { type: "number", default: 0 };
+  if (/^"[^"]*"$/.test(s) || /^'[^']*'$/.test(s)) return { type: "string", default: "" };
+  if (/^(set_flags|clear_flags)\s*\(/.test(s)) return { type: "flags", default: [] };
+  if (/[+\-*/%]/.test(s) && !/^@[a-z]+\.[a-z0-9_-]+$/i.test(s)) return { type: "number", default: 0 };
+  return void 0;
+}
+
+// src/index.ts
+function gameIdify(text) {
+  return text.toLowerCase().replace(/['’]/g, "").replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function isValidGameId(gameId) {
+  return /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(gameId);
+}
+function effectiveGameId(entity) {
+  const pinned = entity.gameId?.trim();
+  if (pinned) return pinned;
+  const fromTitle = entity.title ? gameIdify(entity.title) : "";
+  return fromTitle || entity.id;
+}
+function freeGameId(base, taken) {
+  let gameId = base;
+  for (let n = 2; taken.has(gameId); n++) gameId = `${base}-${n}`;
+  return gameId;
+}
+function byDisplayOrder(items) {
+  return items.map((x, i) => ({ x, key: x.order ?? i, i })).sort((a, b) => a.key - b.key || ((a.x.id ?? "") < (b.x.id ?? "") ? -1 : (a.x.id ?? "") > (b.x.id ?? "") ? 1 : a.i - b.i)).map((e) => e.x);
+}
+function freeTitle(base, taken) {
+  let title = base;
+  for (let n = 2; taken.has(gameIdify(title)); n++) title = `${base} ${n}`;
+  return title;
+}
+var PLACE_GROUP = "place";
+var BUNDLE_SCHEMA = "storylets/bundle@0";
+var SAVE_SCHEMA = "storylets/save@1";
+var SAVEFILE_SCHEMA = "storylets/savefile@1";
+var PROJECT_FOLDER_EXTENSION = ".storylets";
+var BUNDLE_EXTENSION = ".storyletsc";
+var bundleAssetPath = (boxGameId, file) => `assets/${boxGameId}/${file}`;
+var SHARD_EXTENSIONS = {
+  project: ".storyletproj",
+  box: ".storyletbox",
+  tags: ".storylettags",
+  hands: ".storylethands",
+  deck: ".storyletdeck",
+  /** The arrangement layer: where things SIT, never what they are. Its own shard
+   *  because positions churn (an afternoon of tidying a canvas touches every
+   *  card) and content does not, so a designer arranging and a writer editing
+   *  never collide on one file (design/graphical-views.md section 1.2). */
+  view: ".storyletview",
+  /** Threaded comments: content-ADJACENT, so neither in a content shard (a
+   *  writer's deck edit must not conflict with a reviewer's comment) nor in the
+   *  arrangement sidecar (this is not where anything sits). One per box,
+   *  id-keyed (design/annotation.md). Documentation NOTES used to share this
+   *  file and were retired: `purpose` already says why a thing exists, and
+   *  Patterpad's typed routing has no destination here. */
+  notes: ".storyletnotes"
+};
+var PROJECT_SCHEMA = "storylets/project@0";
+var BOX_SCHEMA = "storylets/box@0";
+var TAGS_SCHEMA = "storylets/tags@0";
+var HANDS_SCHEMA = "storylets/hands@0";
+var DECK_SCHEMA = "storylets/deck@0";
+var VIEW_SCHEMA = "storylets/view@0";
+var NOTES_SCHEMA = "storylets/notes@0";
+var FURNITURE_COLOURS = ["paper", "amber", "sage", "sky", "rose", "slate"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BOX_SCHEMA,
+  BUNDLE_EXTENSION,
+  BUNDLE_SCHEMA,
+  DECK_SCHEMA,
+  FURNITURE_COLOURS,
+  HANDS_SCHEMA,
+  NOTES_SCHEMA,
+  PLACE_GROUP,
+  PROJECT_FOLDER_EXTENSION,
+  PROJECT_SCHEMA,
+  RESERVED_PROPERTY_NAMES,
+  SAVEFILE_SCHEMA,
+  SAVE_SCHEMA,
+  SHARD_EXTENSIONS,
+  SPATIAL,
+  TAGS_SCHEMA,
+  VIEW_SCHEMA,
+  backgroundsOf,
+  bindHand,
+  bundleAssetPath,
+  byDisplayOrder,
+  centroid,
+  commentsOf,
+  droppedRect,
+  effectiveGameId,
+  framesOf,
+  freeGameId,
+  freeTitle,
+  gameIdify,
+  handBinding,
+  inferDeclFromWrite,
+  isCaseOnlyPropertyName,
+  isSpatial,
+  isValidGameId,
+  isValidPropertyName,
+  labelPoint,
+  markOf,
+  marksOn,
+  openThreadCounts,
+  pointInPolygon,
+  polygonBounds,
+  polygonOf,
+  propertyNameify,
+  restack,
+  spatialOf,
+  stacked,
+  threadsFor,
+  unbindHand,
+  withBackgrounds,
+  withPolygon,
+  withSpatialGroup,
+  withZ,
+  zOf,
+  zoneAt,
+  zonesAt
+});