@popcraft/kit 0.53.6 → 0.53.8

package/dist/chunks/check-template-I4DMCUBG.js

@@ -0,0 +1,2429 @@
+import { createRequire as __popcraftRequire } from 'node:module';
+import { fileURLToPath as __popcraftPath } from 'node:url';
+import { dirname as __popcraftDirname } from 'node:path';
+const require = __popcraftRequire(import.meta.url);
+const __filename = __popcraftPath(import.meta.url);
+const __dirname = __popcraftDirname(__filename);
+import {
+  appCommands
+} from "./chunk-I7XJ2R7X.js";
+import {
+  builtinCommands
+} from "./chunk-VIPAEDFB.js";
+import "./chunk-ZLWN6LBH.js";
+import "./chunk-Q7EITIAT.js";
+import "./chunk-X36CCQ76.js";
+import "./chunk-U7FLEMSS.js";
+import "./chunk-3QD6CCCN.js";
+import "./chunk-FH4HHWJT.js";
+import "./chunk-TVGMC2CH.js";
+import "./chunk-A6XXXQQO.js";
+import "./chunk-MGMARSGY.js";
+import {
+  buildWebSite
+} from "./chunk-EI3EAVEL.js";
+import "./chunk-ATSLWELA.js";
+import "./chunk-OBMLLNDS.js";
+import "./chunk-6B6ULEDJ.js";
+import "./chunk-VOOUF5TT.js";
+import "./chunk-ZYK65XJJ.js";
+import "./chunk-3TESSHBV.js";
+import "./chunk-UCNBKWJQ.js";
+import "./chunk-2GYEKIKK.js";
+import "./chunk-YZKSEJHZ.js";
+import "./chunk-YD7Z3PGN.js";
+import "./chunk-3DMEPFEZ.js";
+import "./chunk-OZJ7KASI.js";
+import "./chunk-AUOULVIO.js";
+import "./chunk-VXB34VXD.js";
+import "./chunk-OLQTCVWP.js";
+import "./chunk-K4K3MTVW.js";
+import "./chunk-WTU6IXH3.js";
+import "./chunk-OQZFD4BD.js";
+import "./chunk-HUBA4GXU.js";
+import "./chunk-ZNG4F4F3.js";
+import "./chunk-RSS4ZNKX.js";
+import {
+  motionCueIssues
+} from "./chunk-USKIO327.js";
+import "./chunk-YDCOVIEO.js";
+import "./chunk-J3UZXEDU.js";
+import "./chunk-5NXWMSML.js";
+import "./chunk-QBC3UIBQ.js";
+import "./chunk-4DODDLBE.js";
+import "./chunk-ZWGSFZFE.js";
+import {
+  SLIDE_TRANSITIONS
+} from "./chunk-MQKAQUBK.js";
+import "./chunk-RK3HJC3E.js";
+import "./chunk-A54HJQ6T.js";
+import "./chunk-7DATU5VX.js";
+import {
+  fontDir,
+  repoRoot
+} from "./chunk-RMLMSOV3.js";
+import "./chunk-6YZC5UXW.js";
+import {
+  MAX_FRAME_PX
+} from "./chunk-AIAV7CWE.js";
+import {
+  DARK_REVIEW_KIT,
+  LIGHT_REVIEW_KIT
+} from "./chunk-CER5VOOA.js";
+import {
+  MIN_TEXT_PX,
+  PRINT_SAFE_INSET_PX,
+  contrastFailures,
+  paintedTexts
+} from "./chunk-QTVM6KVR.js";
+import "./chunk-UB6KKC2J.js";
+import {
+  warmTemplateFonts
+} from "./chunk-6TZW7HGR.js";
+import {
+  documentFromTemplate
+} from "./chunk-M2NXBDCH.js";
+import "./chunk-INZZZ5M6.js";
+import {
+  contains,
+  overlaps,
+  presetSafeRect,
+  safeArea
+} from "./chunk-EMVFY3SD.js";
+import {
+  fontsIn
+} from "./chunk-YHYYJKWR.js";
+import {
+  applyBrandKit,
+  createBrandKit
+} from "./chunk-6R3NJFQL.js";
+import "./chunk-BPI27DON.js";
+import "./chunk-QPYM3AO2.js";
+import "./chunk-ZQRVM3SJ.js";
+import "./chunk-KATP7TSA.js";
+import "./chunk-TAWWNEV3.js";
+import "./chunk-PU2DNOWP.js";
+import "./chunk-QNR4D25F.js";
+import "./chunk-CHJBZFDR.js";
+import "./chunk-PN2PTI35.js";
+import "./chunk-ERHBGJCI.js";
+import {
+  settleLayout
+} from "./chunk-JSTIX5CV.js";
+import {
+  shownNode,
+  shownTextMeasurer,
+  templateTextMeasurer
+} from "./chunk-V6567KY4.js";
+import "./chunk-5QUM6TXI.js";
+import "./chunk-RKI2WZR7.js";
+import "./chunk-EMRMDF3C.js";
+import "./chunk-W2MSYW6G.js";
+import "./chunk-YR2RU7SP.js";
+import "./chunk-5AACLY3R.js";
+import {
+  breakpointDocument,
+  breakpointsOf
+} from "./chunk-MN4EEFZJ.js";
+import "./chunk-J7N5AJ7Q.js";
+import {
+  isPhotoFrame
+} from "./chunk-BN5BXGWA.js";
+import "./chunk-42I5OWW5.js";
+import "./chunk-L4HYVWDW.js";
+import {
+  estimateTextHeight,
+  textSetting
+} from "./chunk-FR4I6EP4.js";
+import "./chunk-KRGFO6BM.js";
+import "./chunk-AVWA3JAF.js";
+import "./chunk-2SPBA2GP.js";
+import "./chunk-GDOV5QOD.js";
+import "./chunk-V36EJ24Y.js";
+import "./chunk-KBXTF45P.js";
+import "./chunk-KIVW57QH.js";
+import "./chunk-GKKSGKVP.js";
+import "./chunk-SAQ2W6VJ.js";
+import "./chunk-R77FKJO6.js";
+import "./chunk-WG5UENME.js";
+import {
+  applyAutoLayout
+} from "./chunk-KASBBLQC.js";
+import "./chunk-MRON56GU.js";
+import "./chunk-O2JSYLLI.js";
+import "./chunk-ZGIMZ6SP.js";
+import {
+  AUDIO_MODES,
+  AUDIO_SIGNAL_OPTIONS,
+  BEHAVIOUR_PRESETS,
+  LOOP_MODES,
+  isKeyableParam,
+  modifierParams
+} from "./chunk-UT3VNYCC.js";
+import "./chunk-OM5VD3WH.js";
+import "./chunk-7LDAND6F.js";
+import "./chunk-P675L74X.js";
+import "./chunk-HEQLOQAN.js";
+import {
+  motionEnd
+} from "./chunk-GFBUI5Q4.js";
+import "./chunk-HUYCKP2F.js";
+import {
+  PROTOTYPE_TRANSITION_TYPES,
+  SCENE_TRANSITION_TYPES
+} from "./chunk-WLPGSUI2.js";
+import "./chunk-637CSND3.js";
+import "./chunk-EGSRWLGD.js";
+import {
+  init_print_pages,
+  init_scene_graph,
+  listPrintPages
+} from "./chunk-OVUOQJPW.js";
+import "./chunk-3TPXU2PF.js";
+import "./chunk-L32TJYPR.js";
+import "./chunk-UECFXKFB.js";
+import "./chunk-ASE4MVE3.js";
+import {
+  init_instance_layout,
+  instanceContentHeight,
+  instanceContentWidth,
+  setTextMeasurer
+} from "./chunk-2ZG5YVYA.js";
+import "./chunk-E4OKHTNS.js";
+import "./chunk-KQKO2ZZ2.js";
+import "./chunk-CWLO43FG.js";
+import {
+  ANIMATABLE_PROPERTIES,
+  init_properties
+} from "./chunk-NIEUIAKQ.js";
+import "./chunk-XZXB3HB5.js";
+import "./chunk-UGG5XQHU.js";
+import "./chunk-SHK6YV6A.js";
+import "./chunk-M5WJSLHT.js";
+import {
+  EASINGS,
+  MOTION_EASE_PRESETS,
+  init_easing
+} from "./chunk-MVIYMAMH.js";
+import {
+  init_scene3d,
+  placement3D
+} from "./chunk-NWNYARD6.js";
+import "./chunk-WBBHPF5E.js";
+import {
+  IDENTITY4,
+  init_transform3d,
+  layerModel,
+  mul4,
+  transform4
+} from "./chunk-T2SCC6PU.js";
+import "./chunk-25VZ3OBK.js";
+import "./chunk-M2H3GLK2.js";
+import {
+  INTERACTION_TRIGGERS,
+  NAVIGATION_TYPES,
+  init_types
+} from "./chunk-ALV6EOJF.js";
+import "./chunk-Y7TG6HTD.js";
+import "./chunk-SJ63JCL4.js";
+import {
+  define_POPCRAFT_COMPONENT_IDS_default,
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-WKDVCZ45.js";
+import "./chunk-LJSVREWM.js";
+
+// packages/kit/src/check-template.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+init_instance_layout();
+
+// lib/templates/qa.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_scene_graph();
+init_instance_layout();
+init_transform3d();
+init_print_pages();
+init_scene3d();
+
+// lib/templates/editability/coverage.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/templates/editability/registry.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var defineSurfaces = (surfaces) => surfaces;
+var editOf = (e) => typeof e === "string" ? { feature: e } : e;
+var escape = (s) => s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+function patternRegex(pattern, trackPatterns) {
+  const tracks = `\\{(?:${trackPatterns.map((t) => t.split("*").map(escape).join("[^}]*")).join("|")})\\}`;
+  const body = pattern.split("{TRACK}").map((part) => part.split("*").map(escape).join(".*")).join(tracks);
+  return new RegExp(`^${body}$`);
+}
+function surfacesFor(feature, type, surfaces, match) {
+  const out = [];
+  for (const surface of surfaces) {
+    for (const raw of surface.edits) {
+      const edit = editOf(raw);
+      const types = edit.types ?? surface.types;
+      if (type && types && !types.includes(type)) continue;
+      if (match(edit.feature, feature)) {
+        out.push({ surface, edit });
+        break;
+      }
+    }
+  }
+  return out;
+}
+
+// lib/templates/editability/coverage.ts
+var OVERRIDE = /^(enum:)?prop:overrides\{\}\./;
+var AT_BREAKPOINT = /^(enum:)?prop:responsive\.[^.]+\./;
+function coverage(features, surfaces, trackPatterns) {
+  const cache = /* @__PURE__ */ new Map();
+  const match = (pattern, feature) => {
+    let re = cache.get(pattern);
+    if (!re) cache.set(pattern, re = patternRegex(pattern, trackPatterns));
+    return re.test(feature);
+  };
+  const rows = [];
+  for (const [feature, uses] of [...features].sort((a, b) => a[0].localeCompare(b[0]))) {
+    const own = (_m, e) => `${e ?? ""}prop:`;
+    const override = OVERRIDE.test(feature);
+    const lookup = feature.replace(OVERRIDE, own).replace(AT_BREAKPOINT, own);
+    const byType = /* @__PURE__ */ new Map();
+    const covering = /* @__PURE__ */ new Map();
+    const uncovered = [];
+    for (const use of uses) {
+      const type = override ? void 0 : use.type;
+      let found = byType.get(type);
+      if (!found) byType.set(type, found = surfacesFor(lookup, type, surfaces, match));
+      if (!found.length) uncovered.push(use);
+      for (const f of found) covering.set(f.surface.id, f);
+    }
+    rows.push({
+      feature,
+      templates: [...new Set(uses.map((u) => u.template))],
+      types: [...new Set(uses.map((u) => u.type).filter((t) => !!t))],
+      surfaces: [...covering.values()],
+      uncovered
+    });
+  }
+  return rows;
+}
+
+// lib/templates/editability/derived.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_properties();
+init_easing();
+var TRACK_PATTERNS = [...new Set(ANIMATABLE_PROPERTIES.map((p) => p.pattern))];
+function trackSurface() {
+  return {
+    id: "animate.tracks",
+    label: "Animate \u203A Timeline property rows (keys)",
+    kind: "timeline",
+    derived: true,
+    sources: ["lib/motion/properties.ts", "components/editor/animate/layer-rows.tsx", "components/editor/animate/key-inspector.tsx"],
+    edits: TRACK_PATTERNS.flatMap((p) => [`prop:motion.tracks{${p}}`, `prop:motion.tracks{${p}}.keys`, `prop:overrides{}.motion.tracks{${p}}`, `prop:overrides{}.motion.tracks{${p}}.keys`])
+  };
+}
+function behaviourSurface() {
+  const edits = [];
+  for (const preset of BEHAVIOUR_PRESETS) {
+    const m = preset.make(20, 1);
+    edits.push(`prop:motion.tracks{TRACK}.modifiers[${m.kind}]`, `enum:prop:motion.tracks{TRACK}.modifiers[${m.kind}].kind=${m.kind}`);
+    for (const p of modifierParams(m)) {
+      edits.push(`prop:motion.tracks{TRACK}.modifiers[${m.kind}].${p.name}`);
+      if (isKeyableParam(m, p.name)) edits.push(`prop:motion.tracks{TRACK}.modifiers[${m.kind}].animated.${p.name}`);
+    }
+  }
+  edits.push("prop:motion.tracks{TRACK}.modifiers[loop].mode", ...LOOP_MODES.map((l) => `enum:prop:motion.tracks{TRACK}.modifiers[loop].mode=${l.mode}`));
+  const spectrum = { kind: "audio", signal: "spectrum", gain: 1, from: 0, to: 1 };
+  for (const p of modifierParams(spectrum)) edits.push(`prop:motion.tracks{TRACK}.modifiers[audio].${p.name}`);
+  edits.push(
+    "prop:motion.tracks{TRACK}.modifiers[audio].signal",
+    ...AUDIO_SIGNAL_OPTIONS.map((o) => `enum:prop:motion.tracks{TRACK}.modifiers[audio].signal=${o.signal}`),
+    "prop:motion.tracks{TRACK}.modifiers[audio].mode",
+    ...AUDIO_MODES.map((o) => `enum:prop:motion.tracks{TRACK}.modifiers[audio].mode=${o.mode}`),
+    "prop:motion.tracks{TRACK}.modifiers[audio].color"
+  );
+  return {
+    id: "animate.behaviours",
+    label: "Animate \u203A Behaviours",
+    kind: "timeline",
+    derived: true,
+    sources: ["lib/motion/modifier-edit.ts", "components/editor/animate/modifier-list.tsx"],
+    edits: [...new Set(edits)]
+  };
+}
+function curveSurface() {
+  const families = new Set(Object.keys(EASINGS).map((n) => n.split("-")[0]));
+  const kinds = new Set(MOTION_EASE_PRESETS.map((p) => p.interp.kind));
+  return {
+    id: "animate.curves",
+    label: "Animate \u203A Key inspector / curve editor",
+    kind: "timeline",
+    derived: true,
+    sources: ["lib/editor/easing.ts", "components/editor/animate/bezier-editor.tsx", "components/editor/animate/key-inspector.tsx"],
+    edits: [...[...kinds].filter((k) => k !== "ease").map((k) => `interp:${k}`), "interp:bezier", ...[...families].map((f) => `interp:ease:${f}`)]
+  };
+}
+function transitionSurfaces() {
+  return [
+    {
+      id: "composition.transitionTypes",
+      label: "Animate \u203A Scenes \u203A Transition",
+      kind: "timeline",
+      derived: true,
+      sources: ["lib/motion/transitions.ts", "components/editor/animate/composition-strip.tsx"],
+      edits: SCENE_TRANSITION_TYPES.map((t) => `enum:composition:clips[].transitionIn.type=${t}`)
+    },
+    {
+      id: "slides.transitionTypes",
+      label: "Design panel \u203A Slide \u203A Transition",
+      kind: "inspector",
+      derived: true,
+      sources: ["lib/slides/slides.ts", "components/editor/design-panel.tsx"],
+      edits: SLIDE_TRANSITIONS.filter((t) => t.value !== "INSTANT").map((t) => `enum:prop:print.transition.type=${t.value}`)
+    },
+    {
+      id: "prototype.transitionTypes",
+      label: "Prototype \u203A Interaction \u203A Animation",
+      kind: "panel",
+      derived: true,
+      sources: ["lib/motion/transitions.ts", "components/editor/prototype-panel.tsx"],
+      edits: PROTOTYPE_TRANSITION_TYPES.map((t) => `enum:prop:interactions[].action.transition.type=${t}`)
+    }
+  ];
+}
+function paramKeys(schema) {
+  const def = schema._def;
+  const shape = schema.shape ?? def?.shape?.();
+  if (shape && typeof shape === "object") return Object.keys(shape);
+  if (def?.schema) return paramKeys(def.schema);
+  if (def?.innerType) return paramKeys(def.innerType);
+  return [];
+}
+function commandSurfaces(commands, dispatched, nodeProps) {
+  const out = [];
+  for (const c of commands) {
+    const ui = c.expose.ui;
+    const operable = ui && ui.palette !== false || dispatched.has(c.id);
+    if (!operable || c.effect !== "document") continue;
+    const keys = paramKeys(c.params).filter((k) => nodeProps.has(k));
+    if (!keys.length) continue;
+    out.push({
+      id: `command.${c.id}`,
+      label: `Command \u203A ${ui?.label ?? c.title}`,
+      kind: "command",
+      derived: true,
+      sources: ["lib/commands/builtin.ts"],
+      edits: keys.map((k) => `prop:${k}`)
+    });
+  }
+  return out;
+}
+var DERIVED_SURFACES = [trackSurface(), behaviourSurface(), curveSurface(), ...transitionSurfaces()];
+
+// lib/templates/editability/features.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var DEFAULTS = {
+  opacity: 1,
+  visible: true,
+  locked: false,
+  rotation: 0,
+  blendMode: "NORMAL",
+  scaleX: 1,
+  scaleY: 1,
+  anchorX: 0.5,
+  anchorY: 0.5,
+  translateX: 0,
+  translateY: 0,
+  rotateX: 0,
+  rotateY: 0,
+  z: 0,
+  cornerRadius: 0,
+  cornerSmoothing: 0,
+  textCase: "ORIGINAL",
+  textDecoration: "NONE",
+  verticalAlign: "TOP",
+  textAlign: "LEFT",
+  lineHeight: "AUTO",
+  letterSpacing: 0,
+  paragraphSpacing: 0,
+  paragraphIndent: 0,
+  layoutMode: "NONE",
+  layoutPositioning: "AUTO",
+  layoutSizingHorizontal: "FIXED",
+  layoutSizingVertical: "FIXED",
+  overflowScrolling: "NONE",
+  isFlowStartingPoint: false,
+  clipsContent: false,
+  itemSpacing: 0,
+  fontStyle: "normal",
+  primaryAxisAlignItems: "MIN",
+  counterAxisAlignItems: "MIN",
+  textAutoResize: "WIDTH_AND_HEIGHT",
+  fillRule: "NONZERO",
+  scaleMode: "FILL",
+  flipHorizontal: false,
+  flipVertical: false,
+  layoutWrap: "NO_WRAP",
+  timeOffset: 0,
+  amount: 1
+};
+var LEAVES = /* @__PURE__ */ new Set(["paths", "strokePoints", "centerline", "gradientTransform", "gradientHandlePositions", "perspective", "routingPoints", "startPoint", "endPoint", "dashPattern", "curves", "cels", "frames", "palette", "workArea", "range", "cp", "spatial", "center", "offset", "overlayOffset"]);
+var isColor = (v) => !!v && typeof v === "object" && "r" in v && "g" in v && "b" in v;
+function inertFields(n) {
+  const out = /* @__PURE__ */ new Set(["routingPoints"]);
+  if (n.type !== "SECTION") out.add("backgroundColor");
+  if (n.type === "LINE" || n.type === "ARROW") {
+    out.add("startPoint");
+    out.add("endPoint");
+  }
+  if (n.type === "STICKY") out.add("authorName");
+  if (n.layoutMode !== "GRID") for (const k of ["layoutGridColumns", "layoutGridRows", "layoutGridMinColumnWidth", "layoutGridMinRowHeight", "layoutGridColumnSizes", "layoutGridRowSizes"]) out.add(k);
+  if (n.layoutMode !== "GRID" && n.layoutWrap !== "WRAP") out.add("counterAxisSpacing");
+  return out;
+}
+var INERT_PRINT = /* @__PURE__ */ new Set(["pageSize"]);
+var AMBIENT_INERT = /* @__PURE__ */ new Set(["x", "y", "z", "targetX", "targetY", "targetZ", "coneAngle", "coneFeather"]);
+var BRAND_TOKEN = /\{\{\s*brand\.[A-Za-z0-9_-]+\s*\}\}/;
+var STRUCTURAL = /* @__PURE__ */ new Set(["id", "parentId", "childIds", "type", "name"]);
+var ID_MAPS = /* @__PURE__ */ new Set(["overrides", "componentProperties", "variantProperties", "fontFeatures", "fontVariations", "shaderParams", "rasterTiles", "valuesByMode", "codeSyntax", "patternColors"]);
+var PATH_MAPS = /* @__PURE__ */ new Set(["tracks", "componentPropertyPaths"]);
+var TYPED_MAPS = /* @__PURE__ */ new Set(["componentPropertyDefinitions"]);
+var FREE_TEXT = /* @__PURE__ */ new Set([
+  "name",
+  "characters",
+  "text",
+  "label",
+  "description",
+  "fontFamily",
+  "imageUrl",
+  "imageHash",
+  "url",
+  "link",
+  "authorName",
+  "shaderCode",
+  "shaderName",
+  "mediaHash",
+  "videoHash",
+  "videoName",
+  "notes",
+  "flowName",
+  "prefix",
+  "suffix",
+  "separator",
+  "prompt",
+  "model",
+  "path",
+  "template",
+  "importStatement",
+  "variableId",
+  "destinationId",
+  "tiltLayerId",
+  "collectionId",
+  "modeId",
+  "mainComponentId",
+  "componentId",
+  "frameId",
+  "nodeId",
+  "pathId",
+  "shapeId",
+  "styleId",
+  "fillStyleId",
+  "strokeStyleId",
+  "textStyleId",
+  "effectStyleId",
+  "gridStyleId",
+  "masterId",
+  "masterIdFirst",
+  "masterIdLeft",
+  "masterIdRight",
+  "threadPrevId",
+  "threadNextId",
+  "patternSourceId",
+  "patternPreset",
+  "presetId",
+  "defaultValue",
+  "variableValue",
+  "libraryId",
+  "variableCollectionId",
+  "defaultModeId",
+  "prop",
+  "triggerKey",
+  "textEffectPreset",
+  "referenceImageUrl",
+  "color",
+  "id",
+  "sizeId",
+  "thumbnail",
+  "value",
+  "triggerKey",
+  "sharedElement"
+]);
+var normalisePropPath = (p) => p.replace(/\[@[^\]]*\]/g, "[@]").replace(/\[#\d+\]/g, "[#]");
+var isDefault = (key, v) => {
+  if (v === void 0 || v === null || v === false || v === "") return true;
+  if (Array.isArray(v)) return v.length === 0;
+  if (typeof v === "object") return Object.keys(v).length === 0;
+  return key in DEFAULTS && DEFAULTS[key] === v;
+};
+var enumLike = (key, v) => !FREE_TEXT.has(key) && /^([A-Z][A-Z0-9_]*|[a-z][a-zA-Z]*(-[a-z]+)*)$/.test(v) && v.length <= 24;
+var itemType = (v) => {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return void 0;
+  const o = v;
+  if (typeof o.type === "string") return o.type;
+  if (typeof o.kind === "string") return o.kind;
+  return void 0;
+};
+var Collector = class {
+  constructor(template) {
+    this.template = template;
+    this.features = /* @__PURE__ */ new Map();
+  }
+  add(feature, at) {
+    if (this.context) feature = this.context(feature);
+    let uses = this.features.get(feature);
+    if (!uses) this.features.set(feature, uses = []);
+    uses.push({ template: this.template, at, ...this.nodeType ? { type: this.nodeType } : {} });
+  }
+  /** Every non-default leaf under `value`, filed as `${prefix}${path}`. */
+  walk(value, path, key, prefix, at) {
+    if (isDefault(key, value)) return;
+    if (key.startsWith("__")) this.add(`internal:${path}`, at);
+    if (LEAVES.has(key) || isColor(value)) {
+      this.leaf(value, path, key, prefix, at);
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const t = itemType(item);
+        const p = t ? `${path}[${t}]` : `${path}[]`;
+        if (t) this.add(`${prefix}${p}`, at);
+        if (item && typeof item === "object") this.walkObject(item, p, prefix, at);
+        else this.leaf(item, p, key, prefix, at);
+      }
+      return;
+    }
+    if (value && typeof value === "object") {
+      const o = value;
+      if (ID_MAPS.has(key)) {
+        this.add(`${prefix}${path}{}`, at);
+        if (key === "overrides") for (const ov of Object.values(o)) this.walkObject(ov, `${path}{}`, prefix, at);
+        return;
+      }
+      if (PATH_MAPS.has(key)) {
+        for (const [k, v] of Object.entries(o)) {
+          const p = `${path}{${normalisePropPath(k)}}`;
+          this.add(`${prefix}${p}`, at);
+          if (v && typeof v === "object") this.walkObject(v, p, prefix, at);
+        }
+        return;
+      }
+      if (TYPED_MAPS.has(key)) {
+        for (const v of Object.values(o)) {
+          const p = `${path}{${itemType(v) ?? ""}}`;
+          this.add(`${prefix}${p}`, at);
+          this.walkObject(v, p, prefix, at);
+        }
+        return;
+      }
+      if (key === "animated") {
+        for (const k of Object.keys(o)) this.add(`${prefix}${path}.${k}`, at);
+        return;
+      }
+      this.walkObject(o, path, prefix, at);
+      return;
+    }
+    this.leaf(value, path, key, prefix, at);
+  }
+  walkObject(o, path, prefix, at) {
+    for (const [k, v] of Object.entries(o)) {
+      if (path === "" && STRUCTURAL.has(k)) continue;
+      if (k === "id") continue;
+      if (path.endsWith("lights[AMBIENT]") && AMBIENT_INERT.has(k)) continue;
+      if (k === "type" || k === "kind") {
+        if (path && typeof v === "string") this.add(`enum:${prefix}${path}.${k}=${v}`, at);
+        continue;
+      }
+      if (k === "keys" && Array.isArray(v)) {
+        this.keys(v, `${path}.keys`, prefix, at);
+        continue;
+      }
+      this.walk(v, path ? `${path}.${k}` : k, k, prefix, at);
+    }
+  }
+  keys(keys, path, prefix, at) {
+    this.add(`${prefix}${path}`, at);
+    for (const k of keys) {
+      const out = k.out;
+      if (out?.kind) this.add(`interp:${out.kind}${out.kind === "ease" ? `:${String(out.name).split("-")[0]}` : ""}`, at);
+      if (k.spatial) this.add(`${prefix}${path}.spatial`, at);
+      if (k.bind) {
+        this.add(`${prefix}${path}.bind`, at);
+        const b = k.bind;
+        if (b.mul !== void 0 && b.mul !== 1) this.add(`${prefix}${path}.bind.mul`, at);
+        if (b.add !== void 0 && b.add !== 0) this.add(`${prefix}${path}.bind.add`, at);
+      }
+    }
+  }
+  leaf(v, path, key, prefix, at) {
+    if (isDefault(key, v)) return;
+    this.add(`${prefix}${path}`, at);
+    if (typeof v === "string" && enumLike(key, v)) this.add(`enum:${prefix}${path}=${v}`, at);
+  }
+};
+function collectFeatures(t, into) {
+  const c = new Collector(t.meta.id);
+  const p = t.payload;
+  for (const n of Object.values(p.nodes)) {
+    const at = `${n.type} ${n.id} "${n.name}"`;
+    c.nodeType = n.type;
+    const parent = n.parentId ? p.nodes[n.parentId] : void 0;
+    c.context = n.type === "IMAGE" && parent?.isPhotoFrame ? (f) => f === "prop:imageUrl" ? "prop:imageUrl(photoFrame)" : f : void 0;
+    c.add(`node:${n.type}`, at);
+    const inert = inertFields(n);
+    const own = Object.fromEntries(Object.entries(n).filter(([k]) => !inert.has(k)));
+    const print = own.print;
+    if (print) own.print = Object.fromEntries(Object.entries(print).filter(([k]) => !INERT_PRINT.has(k)));
+    c.walkObject(own, "", `prop:`, at);
+    if (n.type === "TEXT" && BRAND_TOKEN.test(n.characters ?? "")) c.add("text:brandToken", at);
+    if (n.type === "INSTANCE" && Object.values(n.componentProperties ?? {}).some((v) => typeof v === "string" && BRAND_TOKEN.test(v))) c.add("text:brandToken", at);
+  }
+  c.nodeType = void 0;
+  c.context = void 0;
+  for (const s of Object.values(p.styles ?? {})) {
+    c.add(`style:${s.type}`, `style ${s.name}`);
+    c.walkObject(s, "", `style.${s.type}:`, `style ${s.name}`);
+  }
+  for (const v of Object.values(p.variables ?? {})) {
+    c.add(`variable:${v.type}`, `variable ${v.name}`);
+    if (v.scopes?.length) c.add("variable.scopes", `variable ${v.name}`);
+    if (v.codeSyntax) c.add("variable.codeSyntax", `variable ${v.name}`);
+  }
+  for (const col of Object.values(p.variableCollections ?? {})) if (col.modes.length > 1) c.add("variableCollection.modes", `collection ${col.name}`);
+  for (const comp of Object.values(p.compositions ?? {})) c.walkObject(comp, "", "composition:", `composition ${comp.name}`);
+  for (const page of p.pages ?? []) if (page.guides?.length) c.add("page.guides", `page ${page.name}`);
+  if (p.facingPages) c.add("document.facingPages", "document");
+  if (p.libraries && Object.keys(p.libraries).length) c.add("document.libraries", "document");
+  for (const slot of t.meta.brandSlots ?? []) c.add(`brandSlot:${slot.kind}`, `slot ${slot.label}`);
+  if (!into) return c.features;
+  for (const [f, uses] of c.features) {
+    const all = into.get(f);
+    if (all) all.push(...uses);
+    else into.set(f, [...uses]);
+  }
+  return into;
+}
+
+// lib/templates/editability/gaps.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var GAPS = [
+  {
+    id: "page-preset-id",
+    severity: "cosmetic",
+    types: ["FRAME"],
+    features: ["prop:print.presetId"],
+    what: "Which page preset a sheet is (when its size alone names another) is template metadata a person cannot set; it only changes the size a template is offered at.",
+    where: "lib/templates/capture.ts:65",
+    fix: "None needed; or show it in the page size dialog",
+    owner: "templates"
+  },
+  {
+    id: "bump-reveal-layer",
+    severity: "degraded",
+    features: ["prop:physics.bump.reveal"],
+    what: "Which layer a bumped block shows (a used ? block) cannot be picked in the Game section; a person can still restyle that layer, or turn the bump off.",
+    where: "components/editor/panels/physics-section.tsx",
+    fix: 'A layer picker beside "Bumps when hit from below"',
+    owner: "editor"
+  }
+];
+
+// lib/templates/editability/surfaces.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// components/editor/design-panel.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var PANEL = "components/editor/design-panel.tsx";
+var SHAPES = ["RECTANGLE", "ELLIPSE", "POLYGON", "STAR", "LINE", "ARROW", "TEXT", "VECTOR", "BOOLEAN", "IMAGE", "FRAME", "COMPONENT", "COMPONENT_SET", "INSTANCE", "STICKY", "GROUP", "SECTION"];
+var LAYOUT_CONTAINERS = ["FRAME", "COMPONENT", "COMPONENT_SET"];
+var design_panel_edits_default = defineSurfaces([
+  {
+    id: "design.header",
+    label: "Design panel \u203A Layer header",
+    kind: "inspector",
+    sources: [PANEL],
+    edits: [
+      "prop:visible",
+      "prop:locked",
+      "prop:opacity",
+      { feature: "prop:isMask", witness: "vector.setMask" },
+      { feature: "prop:isMaskGroup", witness: "vector.setMask", note: 'Made with the mask it holds ("Use as mask")' },
+      { feature: "prop:componentPropertyReferences.visible", witness: "VisibilityBinding" },
+      { feature: "prop:boundVariables.visible", witness: "Boolean variable", note: "The binding menu beside the eye" }
+    ]
+  },
+  {
+    // A variant's values on its set's axes, after Combine as variants; a property (an axis too) is renamed on its row.
+    id: "design.variant",
+    label: "Design panel \u203A Variant",
+    kind: "inspector",
+    sources: [PANEL, "lib/document/component-properties.ts"],
+    types: ["COMPONENT"],
+    edits: [{ feature: "prop:variantProperties{}", witness: "VariantValuesSection" }]
+  },
+  {
+    id: "design.combineVariants",
+    label: "Design panel \u203A Combine as variants",
+    kind: "inspector",
+    sources: [PANEL],
+    edits: [{ feature: "node:COMPONENT_SET", witness: "combineAsVariants" }]
+  },
+  {
+    id: "design.instance",
+    label: "Design panel \u203A Instance",
+    kind: "inspector",
+    sources: [PANEL],
+    types: ["INSTANCE"],
+    edits: [
+      { feature: "prop:overrides{}", note: 'Every edit to a layer inside the instance becomes an override; "Reset all overrides"' },
+      "prop:isExposedInstance",
+      "prop:componentProperties{}",
+      { feature: "prop:mainComponentId", note: "Switched by a variant property (a general swap picker does not exist)" },
+      { feature: "prop:componentPropertyReferences.mainComponent", witness: "Swap with property", note: "On a nested instance inside a component" }
+    ]
+  },
+  {
+    id: "design.position",
+    label: "Design panel \u203A Position",
+    kind: "inspector",
+    sources: [PANEL],
+    edits: [
+      "prop:x",
+      "prop:y",
+      "prop:width",
+      "prop:height",
+      "prop:rotation",
+      "prop:boundVariables.x",
+      "prop:boundVariables.y",
+      "prop:boundVariables.width",
+      "prop:boundVariables.height",
+      { feature: "prop:cornerRadius", types: SHAPES },
+      { feature: "prop:cornerRadius[]", witness: "cornerRadius" },
+      "prop:cornerSmoothing",
+      "prop:boundVariables.cornerRadius",
+      { feature: "prop:pointCount", types: ["POLYGON", "STAR"] },
+      { feature: "prop:innerRadius", types: ["STAR"] },
+      { feature: "prop:flipHorizontal", witness: "node.flip" },
+      { feature: "prop:flipVertical", witness: "node.flip" },
+      "prop:minWidth",
+      "prop:maxWidth",
+      "prop:minHeight",
+      "prop:maxHeight",
+      { feature: "prop:aspectRatio", witness: "keepProportions", note: "Keep proportions: the height follows the width" },
+      // Hug / fill for a child of an auto-layout parent (a container with auto layout of its own has them in its section).
+      "prop:layoutSizingHorizontal",
+      "prop:layoutSizingVertical",
+      "enum:prop:layoutSizingHorizontal=HUG",
+      "enum:prop:layoutSizingHorizontal=FILL",
+      "enum:prop:layoutSizingVertical=HUG",
+      "enum:prop:layoutSizingVertical=FILL",
+      "prop:layoutPositioning",
+      "enum:prop:layoutPositioning=ABSOLUTE",
+      // The rest transform: pivot, scale and offset (folded under Position until one differs from its default).
+      ...["anchorX", "anchorY", "scaleX", "scaleY", "translateX", "translateY"].map((f) => ({ feature: `prop:${f}`, witness: "TransformRestRow" })),
+      "prop:clipsContent"
+    ]
+  },
+  {
+    id: "design.constraints",
+    label: "Design panel \u203A Constraints",
+    kind: "inspector",
+    sources: [PANEL],
+    edits: ["prop:constraints.horizontal", "prop:constraints.vertical", "enum:prop:constraints.*=*"].map((f) => f.includes("*") ? { feature: f, witness: "constraints" } : f)
+  },
+  {
+    id: "design.autoLayout",
+    label: "Design panel \u203A Auto layout",
+    kind: "inspector",
+    sources: [PANEL],
+    types: LAYOUT_CONTAINERS,
+    edits: [
+      "prop:layoutMode",
+      "enum:prop:layoutMode=HORIZONTAL",
+      "enum:prop:layoutMode=VERTICAL",
+      { feature: "enum:prop:layoutMode=GRID", types: ["FRAME"] },
+      "prop:primaryAxisAlignItems",
+      "enum:prop:primaryAxisAlignItems=CENTER",
+      "enum:prop:primaryAxisAlignItems=MAX",
+      "enum:prop:primaryAxisAlignItems=SPACE_BETWEEN",
+      "prop:counterAxisAlignItems",
+      "enum:prop:counterAxisAlignItems=CENTER",
+      "enum:prop:counterAxisAlignItems=MAX",
+      "prop:itemSpacing",
+      // Paired (left and right, top and bottom), or all four sides on their own; an uneven padding always shows as four.
+      { feature: "prop:padding.*", witness: "PaddingFields" },
+      // Horizontal auto layout: wrap onto new rows, with the gap between them.
+      { feature: "prop:layoutWrap", witness: "AutoLayoutWrap" },
+      { feature: "enum:prop:layoutWrap=WRAP", witness: "AutoLayoutWrap" },
+      { feature: "prop:counterAxisSpacing", witness: "AutoLayoutWrap" },
+      "prop:layoutSizingHorizontal",
+      "prop:layoutSizingVertical",
+      "enum:prop:layoutSizingHorizontal=HUG",
+      "enum:prop:layoutSizingHorizontal=FILL",
+      "enum:prop:layoutSizingVertical=HUG",
+      "enum:prop:layoutSizingVertical=FILL",
+      // Grid mode: the row gap, and the track counts and sizes.
+      "prop:layoutGridColumns",
+      "prop:layoutGridRows",
+      "prop:layoutGridMinColumnWidth",
+      "prop:layoutGridMinRowHeight",
+      "prop:layoutGridColumnSizes[]",
+      "prop:layoutGridRowSizes[]"
+    ]
+  },
+  {
+    id: "design.text",
+    label: "Design panel \u203A Text",
+    kind: "inspector",
+    sources: [PANEL],
+    types: ["TEXT"],
+    edits: [
+      "prop:characters",
+      "prop:fontFamily",
+      "prop:fontSize",
+      "prop:fontWeight",
+      "prop:fontStyle",
+      "prop:lineHeight",
+      "prop:letterSpacing",
+      // The italic toggle beside the weight.
+      { feature: "enum:prop:fontStyle=italic", witness: "fontStyle: currentFontStyle === 'italic' ? 'normal' : 'italic'" },
+      "prop:textAlign",
+      "enum:prop:textAlign=CENTER",
+      "enum:prop:textAlign=RIGHT",
+      "enum:prop:textAlign=JUSTIFIED",
+      "prop:verticalAlign",
+      "enum:prop:verticalAlign=CENTER",
+      "enum:prop:verticalAlign=BOTTOM",
+      "prop:textStyleId",
+      "prop:componentPropertyReferences.characters",
+      "prop:threadNextId",
+      "prop:threadPrevId",
+      { feature: "text:brandToken", witness: "BrandTokenFields", note: "Under the Text box: the brand/x variable each `{{brand.x}}` token reads, its words editable there" },
+      { feature: "prop:textEffectPreset", witness: "textEffectPatch" },
+      // Resizing: auto width, auto height or fixed.
+      { feature: "prop:textAutoResize", witness: "TEXT_RESIZING" },
+      { feature: "enum:prop:textAutoResize=*", witness: "TEXT_RESIZING" }
+    ]
+  },
+  {
+    id: "design.sticky",
+    label: "Design panel \u203A Text (sticky note)",
+    kind: "inspector",
+    sources: [PANEL],
+    types: ["STICKY"],
+    edits: ["prop:text"]
+  },
+  {
+    id: "design.component",
+    label: "Design panel \u203A Component / Properties",
+    kind: "inspector",
+    sources: [PANEL],
+    types: ["COMPONENT", "COMPONENT_SET"],
+    edits: [
+      "prop:description",
+      ...["BOOLEAN", "TEXT", "NUMBER", "COLOR", "IMAGE", "MOTION"].flatMap((t) => [`prop:componentPropertyDefinitions{${t}}`, `prop:componentPropertyDefinitions{${t}}.defaultValue`, `enum:prop:componentPropertyDefinitions{${t}}.type=${t}`]),
+      // A swap or variant property's default is a component picker, when it is made and after.
+      ...["INSTANCE_SWAP", "VARIANT"].flatMap((t) => [{ feature: `prop:componentPropertyDefinitions{${t}}`, witness: "picksComponent" }, `prop:componentPropertyDefinitions{${t}}.defaultValue`, `enum:prop:componentPropertyDefinitions{${t}}.type=${t}`, `prop:componentPropertyDefinitions{${t}}.preferredValues[]`]),
+      ...["min", "max", "step"].map((f) => ({ feature: `prop:componentPropertyDefinitions{NUMBER}.${f}`, witness: "setRange" })),
+      { feature: "prop:componentPropertyDefinitions{MOTION}.binds", witness: "The playback setting this property sets on each instance", note: "A select on the property row" },
+      ...["start", "speed", "loop", "hold", "trigger"].map((b) => ({ feature: `enum:prop:componentPropertyDefinitions{MOTION}.binds=${b}`, witness: "PLAYBACK_FIELDS" })),
+      { feature: "node:INSTANCE", witness: "Create Instance", types: ["INSTANCE"] },
+      "prop:codeConnect.path",
+      "prop:codeConnect.importStatement",
+      "prop:codeConnect.template",
+      "prop:codeConnect.language"
+    ]
+  },
+  {
+    id: "design.fill",
+    label: "Design panel \u203A Fill",
+    kind: "inspector",
+    sources: [PANEL],
+    edits: [
+      "prop:fills[SOLID]",
+      "enum:prop:fills[SOLID].type=SOLID",
+      "prop:fills[SOLID].color",
+      { feature: "prop:fills[*].visible", witness: "visible" },
+      { feature: "prop:fills[*].opacity", witness: "Fill opacity" },
+      { feature: "prop:fills[SOLID].boundVariables.color", witness: "Bind variable", note: "The fill row's bind button, as on a stroke" },
+      ...["prop:fillRule", "enum:prop:fillRule=*"].map((feature) => ({ feature, witness: "Fill rule", types: ["VECTOR", "BOOLEAN"] })),
+      { feature: "prop:fills[*].includeInExport", witness: "includeInExport" },
+      "prop:fillStyleId"
+    ]
+  },
+  {
+    id: "design.stroke",
+    label: "Design panel \u203A Stroke",
+    kind: "inspector",
+    sources: [PANEL, "components/editor/routing-mode-dropdown.tsx", "components/editor/stroke-endpoint-dropdown.tsx"],
+    edits: [
+      "prop:strokes[].color",
+      "prop:strokes[].width",
+      "prop:strokes[].boundVariables.color",
+      "prop:strokes[].dashPattern",
+      "prop:strokeStyleId",
+      "prop:strokes[].alignment",
+      "enum:prop:strokes[].alignment=CENTER",
+      "enum:prop:strokes[].alignment=INSIDE",
+      "enum:prop:strokes[].alignment=OUTSIDE",
+      "prop:strokes[].cap",
+      "enum:prop:strokes[].cap=NONE",
+      "enum:prop:strokes[].cap=ROUND",
+      "enum:prop:strokes[].cap=SQUARE",
+      "prop:strokes[].join",
+      "enum:prop:strokes[].join=MITER",
+      "enum:prop:strokes[].join=ROUND",
+      "enum:prop:strokes[].join=BEVEL",
+      ...["prop:routingMode", "enum:prop:routingMode=STRAIGHT", "enum:prop:routingMode=ORTHOGONAL", "enum:prop:routingMode=BEZIER"].map((feature) => ({ feature, types: ["LINE", "ARROW"] })),
+      ...["prop:startArrowhead", "prop:endArrowhead", "enum:prop:startArrowhead=*", "enum:prop:endArrowhead=*"].map((feature) => ({ feature, types: ["LINE", "ARROW"], witness: "Arrowhead" })),
+      ...["prop:trim.start", "prop:trim.end", "prop:trim.offset"].map((feature) => ({ feature, types: ["VECTOR", "RECTANGLE", "ELLIPSE", "POLYGON", "STAR"] })),
+      ...["prop:trim.mode", "enum:prop:trim.mode=SIMULTANEOUS", "enum:prop:trim.mode=SEQUENTIAL"].map((feature) => ({ feature, types: ["VECTOR"], witness: "SEQUENTIAL" }))
+    ]
+  },
+  {
+    id: "design.layer",
+    label: "Design panel \u203A Layer",
+    kind: "inspector",
+    sources: [PANEL],
+    edits: ["prop:clipToBelow", "prop:blendMode", { feature: "enum:prop:blendMode=*", witness: "blendMode" }]
+  },
+  {
+    id: "design.mask",
+    label: "Design panel \u203A Mask",
+    kind: "inspector",
+    sources: [PANEL],
+    edits: ["prop:maskType", "enum:prop:maskType=ALPHA", "enum:prop:maskType=VECTOR", "enum:prop:maskType=LUMINANCE"]
+  },
+  {
+    id: "design.image",
+    label: "Design panel \u203A Image / Mockup / Adjust",
+    kind: "inspector",
+    sources: [PANEL, "components/editor/panels/image-adjust-section.tsx", "components/editor/fill-flyout.tsx"],
+    types: ["IMAGE"],
+    edits: [
+      // The picture: replace it (a file or a stock photo) and choose its fit — the image fill's own controls.
+      { feature: "prop:imageUrl", witness: "ImageLayerSection" },
+      { feature: "prop:credit", witness: "ImageLayerSection" },
+      // A picture's credit (title, creator, licence, where it came from) travels with it: replacing the picture replaces it.
+      { feature: "prop:credit.*", witness: "ImageLayerSection" },
+      { feature: "enum:prop:credit.*=*", witness: "ImageLayerSection" },
+      { feature: "prop:scaleMode", witness: "IMAGE_LAYER_SCALE_MODES" },
+      { feature: "enum:prop:scaleMode=*", witness: "IMAGE_LAYER_SCALE_MODES" },
+      "prop:perspective",
+      { feature: "prop:adjustments[*]", witness: "adjustments" }
+    ]
+  },
+  {
+    id: "design.printPage",
+    label: "Design panel \u203A Page (master, slide show)",
+    kind: "inspector",
+    sources: [PANEL, "components/slides/notes-bar.tsx"],
+    types: ["FRAME"],
+    edits: [
+      "prop:print.masterId",
+      "prop:print.skip",
+      "prop:print.notes",
+      { feature: "prop:print.transition.type", witness: "SLIDE_TRANSITIONS" },
+      "prop:print.transition.duration",
+      { feature: "prop:print.transition.easing", witness: "SLIDE_EASINGS" },
+      { feature: "enum:prop:print.transition.easing=*", witness: "SLIDE_EASINGS" }
+    ]
+  },
+  {
+    id: "design.export",
+    label: "Design panel \u203A Export",
+    kind: "inspector",
+    sources: [PANEL],
+    edits: [{ feature: "prop:exportSettings[*]", witness: "exportSettings" }]
+  },
+  {
+    id: "design.section",
+    label: "Design panel \u203A Section",
+    kind: "inspector",
+    sources: [PANEL],
+    types: ["SECTION"],
+    edits: [{ feature: "prop:backgroundColor", witness: "SectionNode" }]
+  },
+  {
+    id: "design.page",
+    label: "Design panel (nothing selected) \u203A Page",
+    kind: "inspector",
+    sources: ["components/editor/empty-design-panel.tsx"],
+    types: ["PAGE"],
+    edits: ["prop:backgroundColor"]
+  },
+  {
+    id: "design.restTransform",
+    label: "Design panel \u203A Position \u203A Transform",
+    kind: "inspector",
+    sources: [PANEL],
+    edits: ["prop:anchorX", "prop:anchorY", "prop:scaleX", "prop:scaleY", "prop:translateX", "prop:translateY"]
+  },
+  {
+    id: "design.fillOpacityRule",
+    label: "Design panel \u203A Fill \u203A opacity and fill rule",
+    kind: "inspector",
+    sources: [PANEL],
+    edits: ["prop:fills[*].opacity", "prop:fillRule", "enum:prop:fillRule=*"]
+  },
+  {
+    id: "design.textStyles",
+    label: "Local styles \u203A Text style editor",
+    kind: "inspector",
+    sources: ["components/editor/panels/local-styles-section.tsx"],
+    edits: ["style:TEXT", "style.TEXT:*", "enum:style.TEXT:*"]
+  },
+  {
+    id: "animate.behaviourParams",
+    label: "Timeline \u203A Behaviour fields",
+    kind: "timeline",
+    sources: ["lib/motion/modifier-edit.ts"],
+    edits: ["prop:motion.tracks{TRACK}.modifiers[noise].octaves", "prop:motion.tracks{TRACK}.modifiers[noise].seed", "prop:motion.tracks{TRACK}.modifiers[bounce].end"]
+  },
+  {
+    id: "animate.keyBindingScale",
+    label: "Timeline \u203A Key binding \xD7 and +",
+    kind: "timeline",
+    sources: ["components/editor/animate/transport-bar.tsx"],
+    edits: ["prop:motion.tracks{TRACK}.keys.bind.mul", "prop:motion.tracks{TRACK}.keys.bind.add"]
+  }
+]);
+
+// components/editor/panels/effects-section.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var EF = "components/editor/panels/effects-section.tsx";
+var HT = "components/editor/panels/halftone-editor.tsx";
+var fields = (type, names) => [`prop:effects[${type}]`, `enum:prop:effects[${type}].type=${type}`, ...names.map((n) => `prop:effects[${type}].${n}`)];
+var effects_section_edits_default = defineSurfaces([
+  {
+    id: "design.effects",
+    label: "Design panel \u203A Effects",
+    kind: "inspector",
+    sources: [EF],
+    edits: [
+      ...fields("DROP_SHADOW", ["color", "offset", "blur", "spread", "visible", "showBehindTransparent"]),
+      ...fields("INNER_SHADOW", ["color", "offset", "blur", "spread", "visible"]),
+      ...fields("LAYER_BLUR", ["radius", "visible"]),
+      ...fields("BACKGROUND_BLUR", ["radius", "visible"]),
+      ...fields("PROGRESSIVE_BLUR", ["radius", "angle", "start", "end", "target", "visible"]),
+      ...fields("MOTION_BLUR", ["radius", "angle", "visible"]),
+      "enum:prop:effects[PROGRESSIVE_BLUR].target=LAYER",
+      "enum:prop:effects[PROGRESSIVE_BLUR].target=BACKGROUND",
+      ...fields("NOISE", ["amount", "density", "size", "seed", "mode", "monochrome", "colorA", "colorB", "visible"]),
+      "enum:prop:effects[NOISE].mode=MONO",
+      "enum:prop:effects[NOISE].mode=COLOR",
+      "enum:prop:effects[NOISE].mode=DUOTONE",
+      "enum:prop:effects[NOISE].mode=MULTITONE",
+      ...fields("TEXTURE", ["noise", "scale", "contrast", "opacity", "seed", "colorA", "colorB", "visible"]),
+      ...fields("GLASS", ["refraction", "dispersion", "radius", "rim", "depth", "visible"]),
+      "prop:effectStyleId"
+    ]
+  },
+  {
+    id: "design.halftone",
+    label: "Design panel \u203A Effects \u203A Halftone",
+    kind: "inspector",
+    sources: [HT, EF],
+    edits: [
+      ...fields("HALFTONE", ["angle", "dotSize", "contrast", "color1", "color2", "colorMode", "shape", "layout", "toneSource", "gradientAngle", "center", "invertTone", "bands", "visible"]),
+      ...["INK", "SOURCE"].map((v) => `enum:prop:effects[HALFTONE].colorMode=${v}`),
+      ...["UNIFORM", "LINEAR", "RADIAL"].map((v) => `enum:prop:effects[HALFTONE].layout=${v}`),
+      ...["CONTENT", "LINEAR_GRADIENT", "RADIAL_GRADIENT"].map((v) => `enum:prop:effects[HALFTONE].toneSource=${v}`),
+      { feature: "enum:prop:effects[HALFTONE].shape=*", witness: "HALFTONE_SHAPES" }
+    ]
+  }
+]);
+
+// components/editor/panels/scene3d-section.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var S3 = "components/editor/panels/scene3d-section.tsx";
+var LIGHT_FIELDS = ["color", "visible", "intensity", "x", "y", "z", "targetX", "targetY", "targetZ", "coneAngle", "coneFeather"];
+var SHOWN = {
+  AMBIENT: ["color", "visible", "intensity"],
+  POINT: ["color", "visible", "intensity", "x", "y", "z"],
+  DIRECTIONAL: ["color", "visible", "intensity", "x", "y", "z", "targetX", "targetY", "targetZ"],
+  SPOT: LIGHT_FIELDS
+};
+var scene3d_section_edits_default = defineSurfaces([
+  {
+    id: "design.scene3d",
+    label: "Design panel \u203A 3D scene",
+    kind: "inspector",
+    sources: [S3],
+    types: ["FRAME", "GROUP"],
+    edits: [
+      ...["focalLength", "x", "y", "z", "orbit", "roll", "rotateX", "rotateY"].map((f) => `prop:scene3d.camera.${f}`),
+      ...Object.entries(SHOWN).flatMap(([type, shown2]) => [`prop:scene3d.lights[${type}]`, `enum:prop:scene3d.lights[${type}].type=${type}`, ...shown2.map((f) => `prop:scene3d.lights[${type}].${f}`)]),
+      { feature: "prop:scene3d.lights[*].name", witness: "Rename light" }
+    ]
+  },
+  {
+    id: "design.layer3d",
+    label: "Design panel \u203A 3D (layer in a 3D scene)",
+    kind: "inspector",
+    sources: [S3],
+    edits: ["prop:rotateX", "prop:rotateY", "prop:z", ...["acceptsLights", "ambient", "diffuse", "specular", "shininess"].map((f) => `prop:material3d.${f}`)]
+  },
+  {
+    id: "design.component3d",
+    label: "Design panel \u203A 3D (component)",
+    kind: "inspector",
+    sources: [S3],
+    types: ["COMPONENT"],
+    edits: ["prop:preserve3d"]
+  }
+]);
+
+// components/editor/panels/motion-component-section.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var MC = "components/editor/panels/motion-component-section.tsx";
+var motion_component_section_edits_default = defineSurfaces([
+  {
+    id: "design.instanceMotion",
+    label: "Design panel \u203A Motion (instance playback)",
+    kind: "inspector",
+    sources: [MC, "lib/motion/time.ts"],
+    types: ["INSTANCE"],
+    edits: [
+      "prop:playback.start",
+      "prop:playback.speed",
+      "prop:playback.loop",
+      "prop:playback.hold",
+      "prop:playback.trigger",
+      { feature: "prop:playback.range", note: "A pair of the component timeline's markers" },
+      ...["none", "loop", "pingpong"].map((v) => `enum:prop:playback.loop=${v}`),
+      ...["last", "first"].map((v) => `enum:prop:playback.hold=${v}`),
+      ...["load", "inView", "click", "hover", "manual"].map((v) => `enum:prop:playback.trigger=${v}`)
+    ]
+  },
+  {
+    id: "design.componentInputs",
+    label: "Design panel \u203A Component inputs",
+    kind: "inspector",
+    sources: [MC],
+    edits: [{ feature: "prop:componentPropertyPaths{*}", witness: "layerInputPatch" }]
+  }
+]);
+
+// components/editor/panels/data-section.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var DATA = "components/editor/panels/data-section.tsx";
+var data_section_edits_default = defineSurfaces([
+  {
+    id: "design.data",
+    label: "Design panel \u203A Data",
+    kind: "inspector",
+    sources: [DATA],
+    edits: [
+      { feature: "prop:record.collectionId", witness: "node.setRecord", note: "The collection, then the record" },
+      { feature: "prop:record.recordId", witness: "node.setRecord" },
+      { feature: "prop:boundExpressions.prop:*", witness: "node.bindField", note: "An instance property follows a field of its record" }
+    ]
+  }
+]);
+
+// components/editor/fill-flyout.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var FF = "components/editor/fill-flyout.tsx";
+var GRADIENTS = ["GRADIENT_LINEAR", "GRADIENT_RADIAL", "GRADIENT_ANGULAR", "GRADIENT_DIAMOND"];
+var fill_flyout_edits_default = defineSurfaces([
+  {
+    id: "flyout.fill",
+    label: "Fill picker",
+    kind: "flyout",
+    sources: [FF, "components/editor/shader-code-editor.tsx", "components/editor/panels/shader-params-fields.tsx", "lib/document/library-swatches.ts"],
+    edits: [
+      ...GRADIENTS.flatMap((g) => [`prop:fills[${g}]`, `enum:prop:fills[${g}].type=${g}`, `prop:fills[${g}].gradientStops[].color`, `prop:fills[${g}].gradientStops[].position`]),
+      "prop:fills[IMAGE]",
+      "enum:prop:fills[IMAGE].type=IMAGE",
+      "prop:fills[IMAGE].imageUrl",
+      "prop:fills[IMAGE].imageCredit",
+      "prop:fills[IMAGE].scaleMode",
+      ...["FILL", "FIT", "CROP", "TILE"].map((m) => `enum:prop:fills[IMAGE].scaleMode=${m}`),
+      ...["patternScale", "patternAlignment", "patternSpacing", "patternOffset"].map((f) => `prop:fills[IMAGE].${f}`),
+      "prop:fills[PATTERN]",
+      "enum:prop:fills[PATTERN].type=PATTERN",
+      ...["patternPreset", "patternColors{}", "patternSourceId", "patternScale", "patternSpacing", "patternOffset", "patternAlignment"].map((f) => `prop:fills[PATTERN].${f}`),
+      "prop:fills[VIDEO]",
+      "enum:prop:fills[VIDEO].type=VIDEO",
+      ...["videoHash", "videoName", "scaleMode", "videoPlayback", "videoLoop", "videoMuted", "videoPosterTime"].map((f) => `prop:fills[VIDEO].${f}`),
+      ...["AUTO", "PRESENT_ONLY", "PAUSED"].map((m) => `enum:prop:fills[VIDEO].videoPlayback=${m}`),
+      "prop:fills[SHADER]",
+      "enum:prop:fills[SHADER].type=SHADER",
+      "prop:fills[SHADER].shaderCode",
+      "prop:fills[SHADER].textureParams",
+      { feature: "prop:fills[SHADER].shaderName", note: "Set by picking a preset or a saved shader" },
+      { feature: "prop:fills[SHADER].shaderParams{}", witness: "shaderParams" },
+      // A visualizer's node graph (lib/document/shader-graph.ts): picked whole from the Audio visualizers presets, its
+      // knobs edited as the shader's params; its nodes and wires in the node editor (shader-graph-editor.edits.ts).
+      { feature: "prop:fills[SHADER].shaderGraph*", witness: "graphPaint" },
+      { feature: "enum:prop:fills[SHADER].shaderGraph*", witness: "graphPaint" },
+      { feature: "prop:fills[*].boundVariables.color", witness: "fillFromSwatch", note: "The picker's Libraries tab: a variable swatch binds the colour" }
+    ]
+  }
+]);
+
+// components/editor/shader-graph/shader-graph-editor.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var SG = "components/editor/shader-graph/shader-graph-editor.tsx";
+var shader_graph_editor_edits_default = defineSurfaces([
+  {
+    id: "design.shaderNodes",
+    label: "Design panel \u203A Fill \u203A Edit nodes",
+    kind: "panel",
+    sources: [SG, "lib/commands/shader-graph.ts"],
+    edits: [
+      { feature: "prop:fills[SHADER].shaderGraph*.kind", witness: "addNode", note: "Added from the node search: double-click, Shift+A, or a wire dropped on empty space" },
+      { feature: "prop:fills[SHADER].shaderGraph*.x", witness: "moveNodes" },
+      { feature: "prop:fills[SHADER].shaderGraph*.y", witness: "moveNodes" },
+      { feature: "prop:fills[SHADER].shaderGraph*.options*", witness: "setOption" },
+      { feature: "enum:prop:fills[SHADER].shaderGraph*", witness: "setOption" },
+      { feature: "prop:fills[SHADER].shaderGraph*.inputs*", witness: "ShaderParamFields", note: "A port's value is its knob (fills[@].shaderParams), set in the inspector" },
+      { feature: "prop:fills[SHADER].shaderGraph*edges*", witness: "connect" },
+      { feature: "prop:fills[SHADER].shaderGraph*", witness: "shader.editGraph" }
+    ]
+  }
+]);
+
+// components/editor/type-details-flyout.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var type_details_flyout_edits_default = defineSurfaces([
+  {
+    id: "flyout.typeDetails",
+    label: "Design panel \u203A Text \u203A Type details",
+    kind: "flyout",
+    sources: ["components/editor/type-details-flyout.tsx", "components/editor/list-fields.tsx"],
+    types: ["TEXT"],
+    edits: [
+      "prop:textDecoration",
+      "prop:emojiStyle",
+      "prop:textCase",
+      "enum:prop:textCase=UPPER",
+      "enum:prop:textCase=LOWER",
+      "enum:prop:textCase=TITLE",
+      "prop:textVerticalTrim",
+      "prop:hyphenate",
+      "prop:columns.count",
+      "prop:columns.gap",
+      "prop:paragraphSpacing",
+      "prop:textTruncation",
+      "prop:maxLines",
+      "prop:tabStops[].position",
+      "prop:tabStops[].align",
+      "prop:tabStops[].leader",
+      ...["LEFT", "CENTER", "RIGHT", "DECIMAL"].map((a) => `enum:prop:tabStops[].align=${a}`),
+      // Lists are paragraph formatting: the flyout writes `paragraphs[].list`, and reads a node-wide `list` as its fallback.
+      { feature: "prop:paragraphs[].list.*", witness: "onParagraph" },
+      // A node-wide list is the fallback the list controls show; setting one writes the paragraphs' own (which win).
+      ...["prop:list.type", "prop:list.format", "prop:list.level", "enum:prop:list.type=*", "enum:prop:list.format=*"].map((feature) => ({ feature, witness: "list" })),
+      { feature: "prop:list.indent", witness: "List indent" },
+      "prop:textDecorationStyle",
+      "prop:textDecorationThickness",
+      "prop:textDecorationOffset",
+      { feature: "prop:fontFeatures{}", witness: "fontFeatures" },
+      { feature: "prop:fontVariations{}", witness: "fontVariations" }
+    ]
+  }
+]);
+
+// components/editor/animate/text-animator-panel.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var TA = "components/editor/animate/text-animator-panel.tsx";
+var text_animator_panel_edits_default = defineSurfaces([
+  {
+    id: "design.textAnimation",
+    label: "Design panel \u203A Text animation",
+    kind: "inspector",
+    sources: [TA, "components/editor/animate/text-animation-actions.ts"],
+    types: ["TEXT"],
+    edits: [
+      ...["name", "unit", "stagger", "order", "seed", "range", "amount", "ease"].map((f) => `prop:textAnimators[].${f}`),
+      { feature: "prop:textAnimators[].ease.*", witness: "ease" },
+      { feature: "enum:prop:textAnimators[].ease.kind=*", witness: "ease" },
+      ...["translateX", "translateY", "scale", "rotation", "opacity", "blur", "color"].map((f) => `prop:textAnimators[].props.${f}`),
+      ...["letter", "word", "line"].map((u) => `enum:prop:textAnimators[].unit=${u}`),
+      ...["forward", "reverse", "center", "random"].map((o) => `enum:prop:textAnimators[].order=${o}`),
+      ...["from", "to", "value", "prefix", "suffix", "decimals", "separator", "step"].map((f) => `prop:textCounter.${f}`)
+    ]
+  }
+]);
+
+// components/editor/animate/state-machine-panel.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var SM = "components/editor/animate/state-machine-panel.tsx";
+var state_machine_panel_edits_default = defineSurfaces([
+  {
+    id: "animate.stateMachine",
+    label: "Animate \u203A State machine",
+    kind: "panel",
+    sources: [SM],
+    types: ["FRAME"],
+    edits: [
+      "prop:stateMachine.name",
+      "prop:stateMachine.initial",
+      // States: dragged about the graph, renamed, and the stretch each plays.
+      ...["name", "from", "to", "loop", "speed", "x", "y"].map((f) => `prop:stateMachine.states.*.${f}`),
+      { feature: "prop:stateMachine.states.*.entry*", witness: "entry" },
+      { feature: "enum:prop:stateMachine.states.*.entry*.type=*", witness: "entry" },
+      // Transitions: drawn between states (or from Any state), each with its conditions.
+      ...["from", "to"].map((f) => `prop:stateMachine.transitions.*.${f}`),
+      ...["input", "op", "value"].map((f) => `prop:stateMachine.transitions.*.guards[].${f}`),
+      { feature: "enum:prop:stateMachine.transitions.*.guards[].op=*", witness: "op" },
+      ...["name", "value"].map((f) => `prop:stateMachine.inputs.*.${f}`),
+      { feature: "enum:prop:stateMachine.inputs.*.type=*", witness: "type" },
+      // Listeners: what they hear, on which layer (or which key), and the actions they run.
+      "prop:stateMachine.listeners.*.layer",
+      "prop:stateMachine.listeners.*.key",
+      { feature: "enum:prop:stateMachine.listeners.*.key=*", witness: "key" },
+      { feature: "enum:prop:stateMachine.listeners.*.type=*", witness: "type" },
+      { feature: "prop:stateMachine.listeners.*.actions*", witness: "actions" },
+      { feature: "enum:prop:stateMachine.listeners.*.actions*.type=*", witness: "actions" }
+    ]
+  }
+]);
+
+// components/editor/animate/timeline.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var A = "components/editor/animate";
+var timeline_edits_default = defineSurfaces([
+  {
+    id: "animate.layerTiming",
+    label: "Animate \u203A Layer bar (start, trim, stagger step)",
+    kind: "timeline",
+    sources: [`${A}/layer-bar.tsx`, "lib/motion/layer-time-edit.ts", `${A}/timeline-menus.tsx`],
+    edits: [
+      "prop:motion.timeOffset",
+      "prop:motion.span.in",
+      "prop:motion.span.out",
+      { feature: "prop:motion.stagger.delay", witness: "delay", note: "Layer menu \u203A Stagger children, or drag a step of the staircase" },
+      { feature: "prop:motion.stagger.order", witness: "StaggerOrderMenu", note: "Layer menu \u203A Stagger children \u203A Order" },
+      ...["index", "reverse", "center", "random"].map((o) => ({ feature: `enum:prop:motion.stagger.order=${o}`, witness: "ORDERS" })),
+      { feature: "prop:motion.stagger.order.ids[]", witness: "Custom", note: "Custom: the children as they play, each moved earlier or later" },
+      { feature: "prop:timelineColor", witness: "timelineColor" }
+    ]
+  },
+  {
+    id: "animate.timeline",
+    label: "Animate \u203A Transport bar and time ruler",
+    kind: "timeline",
+    sources: [`${A}/transport-bar.tsx`, `${A}/time-ruler.tsx`, "lib/motion/markers.ts"],
+    types: ["FRAME", "COMPONENT", "COMPONENT_SET"],
+    edits: [
+      "prop:timeline.duration",
+      "prop:timeline.fps",
+      { feature: "prop:timeline.workArea", witness: "workArea" },
+      { feature: "prop:timeline.markers[].t", witness: "updateMarker", note: "Drag a marker; add one with M" },
+      { feature: "prop:timeline.markers[].label", witness: "label" },
+      { feature: "prop:timeline.markers[pause]", witness: "pause" },
+      { feature: "prop:timeline.markers[pause].t", witness: "updateMarker" },
+      { feature: "prop:timeline.markers[pause].label", witness: "label" },
+      { feature: "enum:prop:timeline.markers[pause].kind=pause", witness: "pause" }
+    ]
+  },
+  {
+    id: "animate.keyBinding",
+    label: "Animate \u203A Transport bar \u203A Key value source",
+    kind: "timeline",
+    sources: [`${A}/transport-bar.tsx`, "lib/motion/key-selection.ts"],
+    edits: [
+      { feature: "prop:motion.tracks{TRACK}.keys.bind", witness: "setKeysBinding", note: "Which component property a key takes its value from" },
+      { feature: "prop:motion.tracks{TRACK}.keys.bind.mul", witness: "mul: v" },
+      { feature: "prop:motion.tracks{TRACK}.keys.bind.add", witness: "add: v" }
+    ]
+  },
+  {
+    // A colour key's value: a swatch in the key inspector and on the property row (it used to show read-only).
+    id: "animate.colourKeys",
+    label: "Animate \u203A Key inspector and property row (colour)",
+    kind: "timeline",
+    sources: [`${A}/key-inspector.tsx`, `${A}/property-control.tsx`],
+    edits: [{ feature: "prop:motion.tracks{*color}.keys", witness: "ColorSwatch" }, { feature: "prop:motion.tracks{*color}", witness: "ColorSwatch" }]
+  },
+  {
+    id: "canvas.motionPath",
+    label: "Canvas \u203A Motion path handles",
+    kind: "canvas",
+    sources: ["lib/editor/pointer/move/motion.ts", "lib/editor/motion-handles.ts"],
+    edits: [{ feature: "prop:motion.tracks{TRACK}.keys.spatial", witness: "setDotTangent" }]
+  }
+]);
+
+// components/editor/animate/video-inspector.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var video_inspector_edits_default = defineSurfaces([
+  {
+    id: "animate.video",
+    label: "Animate \u203A Video clip",
+    kind: "timeline",
+    sources: ["components/editor/animate/video-inspector.tsx", "lib/motion/video-clip.ts"],
+    edits: ["prop:fills[VIDEO].videoIn", "prop:fills[VIDEO].videoSpeed", "prop:fills[VIDEO].videoSound.muted"]
+  }
+]);
+
+// components/editor/pixel/pixel-grid-section.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var P = "components/editor/pixel";
+var pixel_grid_section_edits_default = defineSurfaces([
+  {
+    id: "pixel.canvas",
+    label: "Design \u203A Pixel canvas",
+    kind: "panel",
+    sources: [`${P}/pixel-grid-section.tsx`, "components/editor/shapes-panel.tsx"],
+    edits: [
+      { feature: "node:PIXEL_GRID", witness: "PIXEL_GRID", note: "Shapes \u203A Pixel canvas places one" },
+      "prop:pixelWidth",
+      "prop:pixelHeight",
+      "prop:palette",
+      "prop:tiledMode",
+      ...["RGBA", "INDEXED", "GRAYSCALE"].map((m) => `enum:prop:colorMode=${m}`),
+      ...["NONE", "X", "Y", "BOTH"].map((m) => `enum:prop:tiledMode=${m}`),
+      { feature: "prop:transparentIndex", note: "The palette slot marked transparent; its swatch cannot be deleted" }
+    ]
+  },
+  {
+    id: "pixel.timeline",
+    label: "Pixel canvas \u203A Frames",
+    kind: "timeline",
+    sources: [`${P}/pixel-timeline.tsx`],
+    edits: ["prop:activeFrame", "prop:onionSkin.prev", "prop:onionSkin.next", "prop:onionSkin.opacity"]
+  }
+]);
+
+// components/editor/animate/composition-strip.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var A2 = "components/editor/animate";
+var composition_strip_edits_default = defineSurfaces([
+  {
+    id: "composition.scenes",
+    label: "Animate \u203A Scenes (composition strip)",
+    kind: "timeline",
+    sources: [`${A2}/composition-strip.tsx`, "lib/motion/composition.ts"],
+    edits: [
+      { feature: "composition:clips[].frameId", witness: "SceneFramePicker", note: "Chosen when a scene is added; swapped in the clip inspector" },
+      "composition:clips[].in",
+      "composition:clips[].out",
+      { feature: "composition:clips[].start", witness: "sequenceClips", note: "Follows from the order and lengths of the scenes" },
+      "composition:clips[].transitionIn.duration",
+      { feature: "composition:clips[].transitionIn.interp.*", witness: "interp" },
+      { feature: "enum:composition:clips[].transitionIn.interp.kind=ease", witness: "interp" },
+      "composition:clips[].transitionIn.params.center",
+      "composition:name",
+      // The stage: size, frame rate and background (the header's size opens them).
+      ...["width", "height", "fps", "background"].map((f) => ({ feature: `composition:${f}`, witness: "CompositionSettings" }))
+    ]
+  },
+  {
+    // The flags on the strip's ruler (time-ruler.tsx's MarkerFlag): drag to move, double-click to name or delete; M or Marker adds one.
+    id: "composition.markers",
+    label: "Animate \u203A Scenes \u203A Markers",
+    kind: "timeline",
+    sources: [`${A2}/composition-strip.tsx`, `${A2}/time-ruler.tsx`, "lib/editor/modes/animate-actions.ts"],
+    edits: [
+      { feature: "composition:markers[].t", witness: "dragMarker" },
+      { feature: "composition:markers[].label", witness: "Rename marker" },
+      { feature: "composition:markers[].id", witness: "addMarker" }
+    ]
+  },
+  {
+    id: "composition.audio",
+    label: "Animate \u203A Scenes \u203A Sound lanes",
+    kind: "timeline",
+    sources: [`${A2}/audio-lanes.tsx`, `${A2}/composition-strip.tsx`],
+    edits: [
+      { feature: "composition:audio[].mediaHash", witness: "importAudioFiles" },
+      { feature: "composition:audio[].name", witness: "importAudioFiles", note: "The file's name when imported; not renamable" },
+      "composition:audio[].start",
+      "composition:audio[].in",
+      "composition:audio[].out",
+      "composition:audio[].lane",
+      "composition:audio[].fadeIn",
+      "composition:audio[].fadeOut",
+      "composition:audio[].pan",
+      "composition:audio[].muted",
+      { feature: "composition:audio[].gain.*", witness: "gain" },
+      // A frame's own lanes (its `timeline.audio`): the same lanes under the frame's timeline, the same edits.
+      { feature: "prop:timeline.audio[].mediaHash", witness: "importAudioFiles" },
+      { feature: "prop:timeline.audio[].name", witness: "importAudioFiles", note: "The file's name when imported; not renamable" },
+      ...["start", "in", "out", "lane", "fadeIn", "fadeOut", "pan", "muted"].map((f) => ({ feature: `prop:timeline.audio[].${f}`, witness: "timeline" })),
+      { feature: "prop:timeline.audio[].gain.*", witness: "gain" }
+    ]
+  }
+]);
+
+// components/editor/prototype-panel.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_types();
+var PP = "components/editor/prototype-panel.tsx";
+var TRIGGERS = INTERACTION_TRIGGERS;
+var NAVIGATION = NAVIGATION_TYPES;
+var LIVE = ["characters", "width", "height", "x", "y", "opacity", "visible", "rotation", "scaleX", "scaleY", "translateX", "translateY", "cornerRadius"];
+var EASINGS2 = ["EASE_IN", "EASE_OUT", "EASE_IN_OUT", "LINEAR", "SPRING"];
+var I = "prop:interactions[]";
+var TIMELINE_OPS = ["SCRUB", "PLAY", "PAUSE", "TOGGLE", "SEEK"];
+var DIRECTIONS = ["LEFT", "RIGHT", "UP", "DOWN"];
+var prototype_panel_edits_default = defineSurfaces([
+  {
+    id: "prototype.interactions",
+    label: "Prototype \u203A Interactions",
+    kind: "panel",
+    sources: [PP, "lib/motion/transitions.ts"],
+    edits: [
+      `${I}.trigger`,
+      ...TRIGGERS.map((t) => `enum:${I}.trigger=${t}`),
+      `${I}.triggerDelay`,
+      `${I}.triggerKey`,
+      `${I}.dragDirection`,
+      ...DIRECTIONS.map((d) => `enum:${I}.dragDirection=${d}`),
+      `${I}.action.timeline.op`,
+      ...TIMELINE_OPS.map((o) => `enum:${I}.action.timeline.op=${o}`),
+      `${I}.action.timeline.target`,
+      `${I}.action.timeline.axis`,
+      `${I}.action.timeline.distance`,
+      { feature: `${I}.action.timeline.span[]`, witness: "span" },
+      `${I}.action.timeline.release`,
+      `${I}.action.timeline.to`,
+      `${I}.action.timeline.glide`,
+      ...["X", "Y"].map((a) => `enum:${I}.action.timeline.axis=${a}`),
+      ...["HOLD", "SNAP", "PLAY"].map((r) => `enum:${I}.action.timeline.release=${r}`),
+      ...["FRAME", "INSTANCE"].map((t) => `enum:${I}.action.timeline.target=${t}`),
+      ...["NEXT", "PREV"].map((t) => `enum:${I}.action.timeline.to=${t}`),
+      `${I}.action.navigationType`,
+      ...NAVIGATION.map((n) => `enum:${I}.action.navigationType=${n}`),
+      `${I}.action.destinationId`,
+      `${I}.action.variableId`,
+      `${I}.action.variableToggle`,
+      `${I}.action.variableValue`,
+      `${I}.action.collectionId`,
+      `${I}.action.modeId`,
+      `${I}.action.variableExpression`,
+      `${I}.action.targetId`,
+      `${I}.action.branches[].condition`,
+      { feature: `enum:${I}.action.branches[].condition=*`, witness: "condition" },
+      // A Conditional's branch actions are edited with the same action editor, recursively: whatever an action has, one in a branch has too.
+      { feature: `${I}.action.branches[].actions[]*`, witness: "ActionEditor" },
+      { feature: `enum:${I}.action.branches[].actions[]*`, witness: "ActionEditor" },
+      `${I}.action.overlayPosition`,
+      ...["CENTER", "TOP_LEFT", "TOP_CENTER", "TOP_RIGHT", "BOTTOM_LEFT", "BOTTOM_CENTER", "BOTTOM_RIGHT", "MANUAL"].map((p) => `enum:${I}.action.overlayPosition=${p}`),
+      `${I}.action.overlayOffset`,
+      `${I}.action.overlayBackground.*`,
+      `${I}.action.closeOnOutsideClick`,
+      `${I}.action.orbit.degreesPerPx`,
+      `${I}.action.orbit.tilt`,
+      `${I}.action.orbit.tiltRange[]`,
+      `${I}.action.orbit.tiltLayerId`,
+      { feature: `${I}.action.transition.type`, witness: "PROTOTYPE_TRANSITION_TYPES" },
+      `${I}.action.transition.duration`,
+      `${I}.action.transition.easing`,
+      ...EASINGS2.map((e) => `enum:${I}.action.transition.easing=${e}`),
+      `${I}.action.transition.spring.*`,
+      `${I}.action.transition.stagger`,
+      `${I}.action.transition.origin`
+    ].map((e) => typeof e === "string" && e.includes("*") ? { feature: e, witness: e.split(".").slice(-2)[0] } : e)
+  },
+  {
+    id: "prototype.liveValues",
+    label: "Prototype \u203A Live values",
+    kind: "panel",
+    sources: [PP, "lib/document/expressions.ts"],
+    // LIVE_VALUE_PROPS lives beside the evaluator
+    edits: [
+      ...LIVE.map((p) => ({ feature: `prop:boundExpressions.${p}`, witness: p === "characters" ? "characters" : p })),
+      { feature: "prop:boundExpressions.imageUrl", witness: "imageUrl", note: "A picture that follows an expression: a record's picture in a list or on its page" },
+      // An expression that is a plain word (`true`) reads as an enum value to the collector: it is still an expression here.
+      { feature: "enum:prop:boundExpressions.*=*", witness: "boundExpressions" }
+    ]
+  },
+  {
+    id: "prototype.shared-element",
+    label: "Prototype \u203A Shared element",
+    kind: "panel",
+    sources: [PP],
+    edits: ["prop:sharedElement"]
+  },
+  {
+    id: "prototype.frame",
+    label: "Prototype \u203A Scrolling and flows",
+    kind: "panel",
+    sources: [PP],
+    types: ["FRAME"],
+    edits: ["prop:overflowScrolling", ...["NONE", "VERTICAL", "HORIZONTAL", "BOTH"].map((o) => `enum:prop:overflowScrolling=${o}`), "prop:isFlowStartingPoint", "prop:flowName"]
+  },
+  {
+    id: "prototype.device",
+    label: "Prototype (nothing selected) \u203A Device",
+    kind: "panel",
+    sources: [PP],
+    types: ["PAGE"],
+    edits: ["prop:prototypeDevice"]
+  }
+]);
+
+// components/editor/pages-panel.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var pages_panel_edits_default = defineSurfaces([
+  {
+    id: "panel.pages",
+    label: "Pages panel",
+    kind: "panel",
+    sources: ["components/editor/pages-panel.tsx", "components/editor/page-size-dialog.tsx", "lib/document/print-pages.ts"],
+    edits: [
+      { feature: "node:PAGE", witness: "addPage" },
+      { feature: "prop:print.isPrintPage", witness: "addPrintPage" },
+      { feature: "prop:print.index", witness: "reorderPrintPages", note: "Drag a page card onto another" },
+      { feature: "prop:print.isMaster", witness: "addMasterPage", note: "A master is added as one; a page cannot become one" },
+      { feature: "prop:print.headerHeight", witness: "addHeaderFooterToMaster" },
+      { feature: "prop:print.footerHeight", witness: "addHeaderFooterToMaster" }
+    ]
+  },
+  {
+    id: "dialog.pageSetup",
+    label: "Page setup\u2026",
+    kind: "dialog",
+    sources: ["components/editor/page-setup-dialog.tsx", "lib/document/page-setup.ts"],
+    edits: ["document.facingPages", { feature: "document.settings.*", witness: "settings" }]
+  },
+  {
+    id: "canvas.guides",
+    label: "Rulers and guides",
+    kind: "canvas",
+    sources: ["components/editor/rulers.tsx", "components/editor/context-menu.tsx"],
+    edits: [{ feature: "page.guides", witness: "addGuide" }]
+  }
+]);
+
+// components/editor/preview/control-fields.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var control_fields_edits_default = defineSurfaces([
+  {
+    id: "panel.formControl",
+    label: "Design panel \u203A Web \u203A Form control",
+    kind: "panel",
+    sources: ["components/editor/preview/control-fields.tsx", "lib/commands/site.ts"],
+    edits: [
+      { feature: "prop:control.kind", witness: "kind" },
+      { feature: "enum:prop:control.kind=*", witness: "CONTROL_KINDS" },
+      { feature: "prop:control.name", witness: "name" },
+      { feature: "prop:control.inputType", witness: "inputType" },
+      { feature: "enum:prop:control.inputType=*", witness: "INPUT_TYPES" },
+      { feature: "prop:control.placeholder", witness: "placeholder" },
+      { feature: "prop:control.required", witness: "required" },
+      { feature: "prop:control.value", witness: "value" },
+      { feature: "prop:control.checked", witness: "checked" },
+      { feature: "prop:control.options*", witness: "options" },
+      { feature: "prop:control.buttonType", witness: "buttonType" },
+      { feature: "enum:prop:control.buttonType=*", witness: "buttonType" },
+      { feature: "prop:control.variableId", witness: "variableId" },
+      { feature: "prop:control.collectionId", witness: "collectionId" },
+      { feature: "prop:control.formAction", witness: "formAction" },
+      { feature: "enum:prop:control.formAction=*", witness: "formAction" },
+      { feature: "prop:control.onSubmit*", witness: "onSubmit", note: "After sending: stay, or go to a screen. The agent and plugins can set any prototype action" },
+      { feature: "enum:prop:control.onSubmit*", witness: "onSubmit" }
+    ]
+  },
+  {
+    id: "panel.webPage",
+    label: "Design panel \u203A Web \u203A Page",
+    kind: "panel",
+    sources: ["components/editor/preview/semantics-section.tsx", "lib/commands/site.ts"],
+    edits: [
+      { feature: "prop:route.path", witness: "path" },
+      { feature: "prop:route.title", witness: "title" },
+      { feature: "prop:route.description", witness: "description" },
+      { feature: "prop:route.access", witness: "access" },
+      { feature: "enum:prop:route.access=*", witness: "access" }
+    ]
+  },
+  {
+    // What a layer is on the page: its element, its accessible name, decoration hidden from readers (a picture behind
+    // words, which only then may be cover-cropped: lib/templates/qa.ts contentImageIssues), its anchor.
+    id: "panel.webSemantics",
+    label: "Design panel \u203A Web \u203A Element",
+    kind: "panel",
+    sources: ["components/editor/preview/semantics-section.tsx"],
+    edits: [{ feature: "prop:semantics.hidden", witness: "semantics.hidden" }]
+  },
+  {
+    id: "panel.webLink",
+    label: "Design panel \u203A Web \u203A Link",
+    kind: "panel",
+    sources: ["components/editor/preview/link-fields.tsx", "lib/commands/site.ts"],
+    edits: [
+      { feature: "prop:semantics.link.kind", witness: "kind" },
+      { feature: "enum:prop:semantics.link.kind=*", witness: "email" },
+      { feature: "prop:semantics.link.value", witness: "value" },
+      { feature: "prop:semantics.link.url", witness: "url" },
+      { feature: "prop:semantics.link.frameId", witness: "frameId" },
+      { feature: "prop:semantics.link.nodeId", witness: "nodeId" }
+    ]
+  },
+  {
+    id: "panel.repeat",
+    label: "Design panel \u203A Web \u203A Repeat",
+    kind: "panel",
+    sources: ["components/editor/preview/collection-fields.tsx", "lib/commands/site.ts"],
+    edits: [{ feature: "prop:route.collectionId", witness: "collectionId", note: "A page per record: Web \u203A Page \u203A Page per" }, { feature: "prop:repeat.collectionId", witness: "collection" }, { feature: "prop:repeat.limit", witness: "limit" }, { feature: "prop:repeat.offset", witness: "offset" }, { feature: "prop:repeat.filter", witness: "filter" }]
+  }
+]);
+
+// components/editor/local-variables-modal.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var local_variables_modal_edits_default = defineSurfaces([
+  {
+    id: "dialog.variables",
+    label: "Local variables",
+    kind: "dialog",
+    sources: ["components/editor/local-variables-modal.tsx"],
+    edits: [
+      "variable:COLOR",
+      "variable:FLOAT",
+      "variable:STRING",
+      "variable:BOOLEAN",
+      "variable.scopes",
+      "variable.codeSyntax",
+      { feature: "variableCollection.modes", witness: "modes" },
+      // A brand text token's words, and a brand colour role, are the values of `brand/*` variables here.
+      { feature: "brandSlot:color", witness: "valuesByMode" },
+      { feature: "brandSlot:text", witness: "valuesByMode" }
+    ]
+  }
+]);
+
+// components/brand/brand-kit-dialog.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var brand_kit_dialog_edits_default = defineSurfaces([
+  {
+    id: "dialog.brandKit",
+    label: "Brand kit\u2026",
+    kind: "dialog",
+    sources: ["components/brand/brand-kit-dialog.tsx", "lib/brand/apply.ts"],
+    edits: ["brandSlot:color", "brandSlot:font", { feature: "brandSlot:logo", witness: "logos" }, { feature: "brandSlot:text", witness: "fields", note: "The kit's fields: name, tagline, website, email, phone, address" }]
+  }
+]);
+
+// components/editor/libraries-inspector.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var libraries_inspector_edits_default = defineSurfaces([
+  {
+    id: "panel.libraries",
+    label: "Design panel (nothing selected) \u203A Libraries",
+    kind: "panel",
+    sources: ["components/editor/libraries-inspector.tsx"],
+    edits: [{ feature: "document.libraries", witness: "libraries" }]
+  }
+]);
+
+// components/editor/layers-panel-v2.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var layers_panel_v2_edits_default = defineSurfaces([
+  {
+    id: "panel.layers",
+    label: "Layers panel",
+    kind: "panel",
+    sources: ["components/editor/layers-panel-v2.tsx"],
+    edits: ["prop:name", "prop:visible", "prop:locked", { feature: "prop:childIds", witness: "reparent" }]
+  }
+]);
+
+// components/editor/context-menu.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var context_menu_edits_default = defineSurfaces([
+  {
+    id: "menu.context",
+    label: "Context menu",
+    kind: "menu",
+    sources: ["components/editor/context-menu.tsx", "lib/document/photo-frames.ts", "lib/editor/crop.ts"],
+    edits: [
+      { feature: "prop:isMask", witness: "vector.setMask" },
+      { feature: "prop:isMaskGroup", witness: "vector.setMask" },
+      { feature: "prop:isPhotoFrame", witness: "makePhotoFrame", note: '"Use as photo frame", or "Crop image"; drop a picture on it to fill it' },
+      { feature: "node:COMPONENT", witness: "createComponent" },
+      { feature: "node:GROUP", witness: "group" },
+      "prop:locked"
+    ]
+  }
+]);
+
+// components/editor/canvas.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var TOOLS = "lib/editor/modes/toolsets.ts";
+var P2 = "lib/editor/pointer";
+var canvas_edits_default = defineSurfaces([
+  {
+    id: "canvas.tools",
+    label: "Canvas \u203A Toolbar tools",
+    kind: "canvas",
+    sources: [TOOLS, "lib/editor/media-tool.ts"],
+    edits: ["FRAME", "SECTION", "RECTANGLE", "LINE", "ARROW", "ELLIPSE", "POLYGON", "STAR", "IMAGE", "TEXT", "STICKY", "PEN"].map((t) => ({ feature: `node:${t === "PEN" ? "VECTOR" : t}`, witness: t }))
+  },
+  {
+    id: "canvas.direct",
+    label: "Canvas \u203A Move, resize, rotate",
+    kind: "canvas",
+    sources: [`${P2}/move/transform.ts`, `${P2}/pointer-move.ts`],
+    edits: ["prop:x", "prop:y", "prop:width", "prop:height", "prop:rotation"]
+  },
+  {
+    id: "canvas.text",
+    label: "Canvas \u203A Typing into a text or a sticky note",
+    kind: "canvas",
+    sources: ["components/editor/canvas.tsx"],
+    edits: [
+      { feature: "prop:characters", witness: "textEditState" },
+      { feature: "prop:text", witness: "textEditState", types: ["STICKY"] },
+      { feature: "text:brandToken", witness: "textEditState", note: "Typing into it replaces the token with the words it showed" },
+      { feature: "prop:styledSegments[]", witness: "applyTextStyle" }
+    ]
+  },
+  {
+    id: "canvas.vectorEdit",
+    label: "Canvas \u203A Edit vector (Enter on a vector)",
+    kind: "canvas",
+    sources: [`${P2}/pointer-move.ts`, "components/editor/canvas.tsx"],
+    edits: [{ feature: "prop:paths", witness: "vectorEditMode" }]
+  },
+  {
+    id: "canvas.connectors",
+    label: "Canvas \u203A Connector ends",
+    kind: "canvas",
+    sources: [`${P2}/pointer-up.ts`, `${P2}/move/transform.ts`],
+    types: ["LINE", "ARROW"],
+    edits: [
+      ...["connectorStart", "connectorEnd"].flatMap((c) => [`prop:${c}.nodeId`, `prop:${c}.position`, `enum:prop:${c}.position=*`]).map((feature) => ({ feature, witness: feature.includes("Start") ? "connectorStart" : "connectorEnd", note: "Snapped by drawing or dragging an end onto a layer" }))
+    ]
+  },
+  {
+    id: "canvas.gradientHandles",
+    label: "Canvas \u203A Gradient handles",
+    kind: "canvas",
+    sources: [`${P2}/move/edit-handles.ts`, "lib/editor/overlays/gradient-edit.ts"],
+    edits: [{ feature: "prop:fills[*].gradientHandlePositions", witness: "gradientHandlePositions" }]
+  },
+  {
+    id: "canvas.photoFrame",
+    label: "Canvas \u203A Drop a picture on a photo frame",
+    kind: "canvas",
+    sources: ["components/editor/canvas.tsx", "lib/document/photo-frames.ts"],
+    edits: [
+      { feature: "prop:imageUrl(photoFrame)", witness: "fillPhotoFrame", types: ["IMAGE"], note: "Dropping a picture on the frame replaces the one inside" },
+      { feature: "prop:imageUrl", witness: "target?.type === 'IMAGE'", types: ["IMAGE"], note: "Dropping a picture on an image layer replaces its picture" }
+    ]
+  }
+]);
+
+// components/editor/panels/text-style-editor.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var text_style_editor_edits_default = defineSurfaces([
+  {
+    id: "design.textStyle",
+    label: "Text style editor",
+    kind: "inspector",
+    sources: ["components/editor/panels/text-style-editor.tsx", "components/editor/panels/local-styles-section.tsx", "components/editor/list-fields.tsx"],
+    edits: [
+      { feature: "style:TEXT", witness: "TextStyleEditor" },
+      ...["fontFamily", "fontSize", "fontWeight", "fontStyle", "lineHeight", "letterSpacing", "paragraphSpacing", "textCase", "textAlign"].map((f) => `style.TEXT:${f}`),
+      { feature: "enum:style.TEXT:textCase=*", witness: "CASES" },
+      { feature: "enum:style.TEXT:textAlign=*", witness: "ALIGNS" },
+      // Paragraph fields: character or paragraph style, space before, hyphenation, and the style's list (the shared list fields).
+      "style.TEXT:scope",
+      { feature: "enum:style.TEXT:scope=*", witness: "SCOPES" },
+      "style.TEXT:spaceBefore",
+      "style.TEXT:hyphenate",
+      { feature: "style.TEXT:list.*", witness: "ListFields" },
+      { feature: "enum:style.TEXT:list.*", witness: "ListFields" }
+    ]
+  }
+]);
+
+// components/editor/panels/physics-section.edits.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var SECTION = "components/editor/panels/physics-section.tsx";
+var physics_section_edits_default = defineSurfaces([
+  {
+    id: "design.physics",
+    label: "Design panel \u203A Game",
+    kind: "inspector",
+    sources: [SECTION],
+    edits: [
+      "prop:physics",
+      "prop:physics.role",
+      "prop:physics.control",
+      "prop:physics.pose",
+      "prop:physics.patrol.distance",
+      "prop:physics.patrol.speed",
+      "prop:physics.parallax",
+      "prop:physics.stomp",
+      "prop:physics.bump",
+      "prop:physics.bump.reward",
+      ...["player", "solid", "platform", "collectible", "hazard", "goal", "control", "win", "pose", "parallax", "reveal"].map((r) => `enum:prop:physics.role=${r}`),
+      ...["left", "right", "jump"].map((c) => `enum:prop:physics.control=${c}`),
+      ...["idle", "run", "jump"].map((p) => `enum:prop:physics.pose=${p}`),
+      ...["speed", "jump", "gravity"].map((f) => `prop:physics.settings.${f}`)
+    ]
+  },
+  {
+    id: "design.pixelPerfect",
+    label: "Design panel \u203A Game \u203A Pixel-perfect (screen)",
+    kind: "inspector",
+    sources: [SECTION],
+    types: ["FRAME"],
+    edits: ["prop:pixelPerfect"]
+  }
+]);
+
+// lib/templates/editability/surfaces.ts
+var DECLARED = {
+  "components/editor/design-panel.edits.ts": design_panel_edits_default,
+  "components/editor/panels/effects-section.edits.ts": effects_section_edits_default,
+  "components/editor/panels/scene3d-section.edits.ts": scene3d_section_edits_default,
+  "components/editor/panels/physics-section.edits.ts": physics_section_edits_default,
+  "components/editor/panels/motion-component-section.edits.ts": motion_component_section_edits_default,
+  "components/editor/panels/data-section.edits.ts": data_section_edits_default,
+  "components/editor/fill-flyout.edits.ts": fill_flyout_edits_default,
+  "components/editor/shader-graph/shader-graph-editor.edits.ts": shader_graph_editor_edits_default,
+  "components/editor/type-details-flyout.edits.ts": type_details_flyout_edits_default,
+  "components/editor/animate/text-animator-panel.edits.ts": text_animator_panel_edits_default,
+  "components/editor/animate/state-machine-panel.edits.ts": state_machine_panel_edits_default,
+  "components/editor/animate/timeline.edits.ts": timeline_edits_default,
+  "components/editor/animate/video-inspector.edits.ts": video_inspector_edits_default,
+  "components/editor/pixel/pixel-grid-section.edits.ts": pixel_grid_section_edits_default,
+  "components/editor/animate/composition-strip.edits.ts": composition_strip_edits_default,
+  "components/editor/prototype-panel.edits.ts": prototype_panel_edits_default,
+  "components/editor/pages-panel.edits.ts": pages_panel_edits_default,
+  "components/editor/preview/control-fields.edits.ts": control_fields_edits_default,
+  "components/editor/local-variables-modal.edits.ts": local_variables_modal_edits_default,
+  "components/brand/brand-kit-dialog.edits.ts": brand_kit_dialog_edits_default,
+  "components/editor/libraries-inspector.edits.ts": libraries_inspector_edits_default,
+  "components/editor/layers-panel-v2.edits.ts": layers_panel_v2_edits_default,
+  "components/editor/context-menu.edits.ts": context_menu_edits_default,
+  "components/editor/canvas.edits.ts": canvas_edits_default,
+  "components/editor/panels/text-style-editor.edits.ts": text_style_editor_edits_default
+};
+var EDIT_SURFACES = [...Object.values(DECLARED).flat(), ...DERIVED_SURFACES];
+
+// lib/templates/qa.ts
+var shownWords = (doc, tx) => shownNode(doc, tx).characters;
+function layoutIssues(t) {
+  const out = [];
+  for (const v of t.payload.variants) {
+    const doc = documentFromTemplate(t, t.meta.name, v.sizeId);
+    for (const n of Object.values(doc.nodes)) {
+      if (n.type === "TEXT") {
+        const tx = n;
+        const h = Math.round(estimateTextHeight(shownWords(doc, tx), tx.width, tx.fontFamily, tx.fontWeight, tx.fontSize, tx.lineHeight ?? "AUTO", tx.textAutoResize !== "WIDTH_AND_HEIGHT", tx.letterSpacing ?? 0, textSetting(tx)));
+        if (Math.round(tx.height) !== h) out.push({ check: "layout", size: v.sizeId, layer: tx.name, message: `is ${Math.round(tx.height)}px tall but its words take ${h}px at ${Math.round(tx.width)}px wide: a line ${h > tx.height ? "is cut off" : "too many is left empty"}` });
+      }
+      if (n.type !== "INSTANCE") continue;
+      const c = doc.nodes[n.mainComponentId];
+      if (!c) continue;
+      const wantsH = Math.round(instanceContentHeight(doc.nodes, n.id) ?? c.height);
+      if (Math.round(n.height) !== wantsH) out.push({ check: "layout", size: v.sizeId, layer: n.name, message: `is ${Math.round(n.height)}px tall but its content takes ${wantsH}px` });
+      const wantsW = instanceContentWidth(doc.nodes, n.id) ?? c.width;
+      const centred = (c.layoutMode === "VERTICAL" ? c.counterAxisAlignItems : c.primaryAxisAlignItems) ?? "MIN";
+      if (Math.abs(wantsW - n.width) >= 0.5 && centred !== "MIN") out.push({ check: "layout", size: v.sizeId, layer: n.name, message: `is ${Math.round(n.width)}px wide but its content takes ${Math.round(wantsW)}px, and its component ${c.name} centres it, so it sits off-centre` });
+    }
+  }
+  return out;
+}
+function responsiveIssues(t) {
+  const sizes = t.payload.variants.map((v) => v.sizeId);
+  if (t.meta.kind !== "WEB" || !sizes.includes("web-tablet") || !sizes.includes("web-mobile")) return [];
+  const doc = documentFromTemplate(t, t.meta.name);
+  const nodes = Object.values(doc.nodes);
+  const out = [];
+  for (const bp of ["tablet", "phone"]) {
+    if (!nodes.some((n) => n.responsive?.[bp])) out.push({ check: "responsive", message: `nothing changes on a ${bp}: make the ${bp} size with \`k.variants\` from the desktop page (rows become columns, type steps down), so the page carries it` });
+  }
+  const media = buildWebSite(doc).pages[0]?.media?.length ?? 0;
+  if (!out.length && media !== 2) out.push({ check: "responsive", message: `the exported page has ${media} breakpoint rules, not one for the tablet and one for the phone` });
+  return out;
+}
+var DRAWN = /* @__PURE__ */ new Set(["VECTOR", "IMAGE", "RECTANGLE", "ELLIPSE", "STAR", "POLYGON", "LINE", "BOOLEAN_OPERATION"]);
+var worlds = /* @__PURE__ */ new WeakMap();
+function worldOf(doc, id, screenId) {
+  if (id === screenId || !doc.nodes[id]) return IDENTITY4;
+  const memo = worlds.get(doc) ?? worlds.set(doc, /* @__PURE__ */ new Map()).get(doc);
+  const hit = memo.get(id);
+  if (hit) return hit;
+  const n = doc.nodes[id];
+  const m = mul4(worldOf(doc, n.parentId ?? screenId, screenId), layerModel(n));
+  memo.set(id, m);
+  return m;
+}
+function drawnBox(doc, id, screenId) {
+  const n = doc.nodes[id];
+  const m = worldOf(doc, id, screenId);
+  let [x0, y0, x1, y1] = [0, 0, n.width, n.height];
+  if (n.type === "VECTOR" && n.paths?.length) {
+    const pts = n.paths.flatMap((p) => p.points);
+    if (pts.length) [x0, y0, x1, y1] = [Math.min(...pts.map((p) => p.x)), Math.min(...pts.map((p) => p.y)), Math.max(...pts.map((p) => p.x)), Math.max(...pts.map((p) => p.y))];
+  }
+  const c = [[x0, y0], [x1, y0], [x0, y1], [x1, y1]].map(([x, y]) => transform4(m, x, y, 0));
+  return { minX: Math.min(...c.map((v) => v[0])), minY: Math.min(...c.map((v) => v[1])), maxX: Math.max(...c.map((v) => v[0])), maxY: Math.max(...c.map((v) => v[1])) };
+}
+function cutShare(doc, id, screenId) {
+  const b = drawnBox(doc, id, screenId);
+  const clips = [];
+  for (let p = doc.nodes[doc.nodes[id].parentId ?? ""]; p; p = doc.nodes[p.parentId ?? ""]) {
+    if (p.clipsContent || p.id === screenId) clips.push(drawnBox(doc, p.id, screenId));
+    if (p.id === screenId) break;
+  }
+  for (const c of clips) if (b.minX <= c.minX + 0.5 && b.maxX >= c.maxX - 0.5) {
+    b.minX = Math.max(b.minX, c.minX);
+    b.maxX = Math.min(b.maxX, c.maxX);
+  }
+  const area = Math.max(1, (b.maxX - b.minX) * (b.maxY - b.minY));
+  let { minX, minY, maxX, maxY } = b;
+  for (const c of clips) {
+    minX = Math.max(minX, c.minX);
+    minY = Math.max(minY, c.minY);
+    maxX = Math.min(maxX, c.maxX);
+    maxY = Math.min(maxY, c.maxY);
+  }
+  return 1 - Math.max(0, maxX - minX) * Math.max(0, maxY - minY) / area;
+}
+var shown = (doc, id, screenId) => {
+  for (let p = doc.nodes[id]; p; p = doc.nodes[p.parentId ?? ""]) {
+    if (p.visible === false || (p.opacity ?? 1) === 0) return false;
+    if (p.id === screenId) return true;
+  }
+  return true;
+};
+function breakpointCutIssues(t) {
+  const sizes = t.payload.variants.map((v) => v.sizeId);
+  if (t.meta.kind !== "WEB" || !sizes.includes("web-tablet") || !sizes.includes("web-mobile")) return [];
+  const base = documentFromTemplate(t, t.meta.name);
+  const screenOf = (d) => d.nodes[d.pages[0]].childIds.find((id) => d.nodes[id].type === "FRAME");
+  const out = [];
+  setTextMeasurer(shownTextMeasurer(base));
+  for (const [bp, sizeId] of [["tablet", "web-tablet"], ["phone", "web-mobile"]]) {
+    const copy = documentFromTemplate(t, t.meta.name, sizeId);
+    const width = copy.nodes[screenOf(copy)].width;
+    const view = breakpointDocument({ ...base, site: { ...base.site, breakpoints: breakpointsOf(base).map((b) => b.id === bp ? { ...b, previewWidth: width } : b) } }, bp);
+    const vs = screenOf(view), cs = screenOf(copy);
+    const walk = (a, b) => {
+      const m = view.nodes[a], n = copy.nodes[b];
+      if (!m || !n || m.type !== n.type) return;
+      if ((DRAWN.has(m.type) || m.type === "TEXT") && shown(view, a, vs) && shown(copy, b, cs)) {
+        const lost = cutShare(view, a, vs), meant = cutShare(copy, b, cs);
+        if (lost > 0.08 && lost > meant + 0.08) out.push({ check: "responsive", size: sizeId, layer: m.name, message: `is ${Math.round(lost * 100)}% cut off at the ${bp} breakpoint, and ${meant > 0.01 ? `only ${Math.round(meant * 100)}%` : "whole"} in the ${bp} size: what the size changes about it (a scale, a redrawn path, a box) is not something a breakpoint carries \u2014 scale the art, or change only its box and layout` });
+      }
+      const ca = m.childIds ?? [], cb = n.childIds ?? [];
+      if (ca.length === cb.length) ca.forEach((c, i) => walk(c, cb[i]));
+    };
+    walk(vs, cs);
+  }
+  setTextMeasurer(templateTextMeasurer);
+  return out;
+}
+function pictureOf(n) {
+  if (n.type === "IMAGE") return { scaleMode: n.scaleMode ?? "FILL" };
+  const fill = (n.fills ?? []).find((f) => f.type === "IMAGE" && f.visible !== false);
+  return fill ? { scaleMode: fill.scaleMode ?? "FILL" } : null;
+}
+function contentImageIssues(t) {
+  if (t.meta.kind !== "WEB") return [];
+  const base = documentFromTemplate(t, t.meta.name);
+  const content = Object.values(base.nodes).filter((n) => !n.id.includes("::") && n.name !== "{{brand.logo}}" && !n.semantics?.hidden && pictureOf(n));
+  const out = [];
+  for (const n of content) {
+    const ar = n.aspectRatio;
+    if (!ar) out.push({ check: "responsive", layer: n.name, message: "is a content picture with a fixed height: at a narrower width it is cropped to a band instead of scaling. Make it with k.contentImage (it keeps its proportions), or mark decoration with semantics.hidden" });
+    else if (pictureOf(n).scaleMode !== "FIT") out.push({ check: "responsive", layer: n.name, message: `fits its picture with ${pictureOf(n).scaleMode}, which crops any picture of other proportions put in it: contain it (FIT)` });
+  }
+  for (const bp of ["tablet", "phone"]) {
+    const view = breakpointDocument(base, bp);
+    for (const n of content) {
+      const v = view.nodes[n.id], ar = n.aspectRatio;
+      if (!v || !ar || v.visible === false || !v.height) continue;
+      const shown2 = v.width / v.height;
+      if (Math.abs(shown2 - ar) / ar > 0.01) out.push({ check: "responsive", size: bp, layer: n.name, message: `is ${Math.round(v.width)}\xD7${Math.round(v.height)} at the ${bp} breakpoint, not its ${ar.toFixed(3)} proportions: its picture is cropped or squashed there` });
+    }
+  }
+  return out;
+}
+function breakpointOverflowIssues(t) {
+  const sizes = t.payload.variants.map((v) => v.sizeId);
+  if (t.meta.kind !== "WEB" || !Object.values(t.payload.nodes).some((n) => n.responsive) || sizes.includes("web-tablet") && sizes.includes("web-mobile")) return [];
+  const base = documentFromTemplate(t, t.meta.name);
+  const out = [];
+  setTextMeasurer(shownTextMeasurer(base));
+  for (const bp of ["tablet", "phone"]) {
+    const view = breakpointDocument(base, bp);
+    for (const screen of view.nodes[view.pages[0]].childIds.map((id) => view.nodes[id]).filter((n) => n?.type === "FRAME")) {
+      const walk = (id, clipped) => {
+        const n = view.nodes[id];
+        if (!n || n.visible === false || (n.opacity ?? 1) === 0) return;
+        if (n.type === "TEXT" && !clipped) {
+          const b = drawnBox(view, id, screen.id);
+          if (b.maxX > screen.width + 1 || b.minX < -1) out.push({ check: "responsive", size: bp, layer: n.name, message: `runs ${Math.round(Math.max(b.maxX - screen.width, -b.minX))}px off the side of the page at the ${bp} breakpoint: give it its column's width (fill) rather than the desktop's fixed one` });
+        }
+        for (const c of n.childIds ?? []) walk(c, clipped || id !== screen.id && !!n.clipsContent);
+      };
+      walk(screen.id, false);
+    }
+  }
+  setTextMeasurer(templateTextMeasurer);
+  return out;
+}
+function editSurfaces(commands, dispatched, features) {
+  const nodeProps = new Set([...features.keys()].filter((f) => f.startsWith("prop:")).map((f) => f.slice(5).split(/[.[{]/)[0]));
+  return [...EDIT_SURFACES, ...commandSurfaces(commands, dispatched, nodeProps)];
+}
+function gapFor(feature, type, match) {
+  return GAPS.find((g) => g.features.some((p) => match(p, feature)) && (!g.types || !type || g.types.includes(type)));
+}
+function featureMatcher() {
+  const cache = /* @__PURE__ */ new Map();
+  return (pattern, feature) => {
+    let re = cache.get(pattern);
+    if (!re) cache.set(pattern, re = patternRegex(pattern, TRACK_PATTERNS));
+    return re.test(feature);
+  };
+}
+function editabilityIssues(t, commands, dispatched) {
+  const features = collectFeatures(t);
+  const match = featureMatcher();
+  const out = [];
+  for (const r of coverage(features, editSurfaces(commands, dispatched, features), TRACK_PATTERNS)) {
+    for (const type of new Set(r.uncovered.map((u) => u.type))) {
+      if (gapFor(r.feature, type, match)) continue;
+      const use = r.uncovered.find((u) => u.type === type);
+      out.push({ check: "editability", layer: use.at, message: `uses ${r.feature}${type ? ` on a ${type}` : ""}, which no editor control can change: use an editable equivalent` });
+    }
+  }
+  for (const f of features.keys()) if (f.startsWith("internal:")) out.push({ check: "editability", message: `stores ${f.slice(9)}, a field only the app writes` });
+  return out;
+}
+function practiceIssues(t, o = {}) {
+  const out = [];
+  const say = (message, layer) => out.push({ check: "practice", message, ...layer ? { layer } : {} });
+  if (t.meta.kind === "BOARD") {
+    if (t.meta.tags.length < 2) say("a board needs two tags or more, so it is found");
+    if (JSON.stringify(t.meta.fonts) !== JSON.stringify(fontsIn(t.payload.nodes))) say("its listed fonts are not the fonts it uses");
+    if ((t.meta.description?.length ?? 0) <= 10) say("a board needs a description");
+    for (const n of Object.values(t.payload.nodes)) for (const p of n.fills ?? []) {
+      if (p.type === "SOLID" && !p.boundVariables?.color) say("has a solid fill on no brand colour", n.name);
+    }
+    return out;
+  }
+  const doc = documentFromTemplate(t);
+  setTextMeasurer(shownTextMeasurer(doc));
+  const nodes = Object.values(doc.nodes);
+  const vars = Object.values(doc.variables ?? {});
+  if (vars.filter((v) => v.name.startsWith("brand/")).length < 3) say("needs three brand colour roles or more (`k.brand`), so a brand kit re-skins it");
+  if (!t.meta.tags.includes("lottie")) {
+    if (!Object.values(doc.styles ?? {}).some((st) => st.type === "TEXT")) say("sets no text styles (`k.textStyle`): type should be a system a person can change once");
+    if (!nodes.some((n) => n.type === "COMPONENT")) say("has no components: repeated parts should be one component and its instances");
+    if (!nodes.some((n) => n.type === "INSTANCE")) say("uses no instances of its components");
+  }
+  for (const n of nodes) {
+    if (n.type === "PAGE") continue;
+    const parent = doc.nodes[n.parentId ?? ""];
+    const in3D = placement3D(doc.nodes, n.id);
+    const placedIn3D = !!in3D && (in3D.layerId === void 0 || in3D.layerId === n.id);
+    if (parent && parent.type !== "PAGE" && !isPhotoFrame(parent) && !parent.isMaskGroup && !placedIn3D && (parent.layoutMode ?? "NONE") === "NONE") say(`sits at picked coordinates in ${parent.name}, which has no auto layout`, n.name);
+    if (n.type === "TEXT") {
+      const tn = n;
+      if (!(tn.textStyleId && doc.styles?.[tn.textStyleId])) say("is set in no text style", n.name);
+      const first = tn.fills?.[0];
+      if (!first || first.type === "SOLID" && !first.boundVariables?.color) say("is coloured with no brand role", n.name);
+    }
+    for (const [i, p] of (n.fills ?? []).entries()) {
+      if (p.type === "SOLID" && !n.isMask && !p.boundVariables?.color && !(n.type === "TEXT" && i === 0)) say("has a solid fill on no brand colour", n.name);
+    }
+  }
+  const usedStyles = new Set(Object.values(t.payload.nodes).map((n) => n.textStyleId).filter(Boolean));
+  for (const st of Object.values(t.payload.styles ?? {})) if (st.type === "TEXT" && !usedStyles.has(st.id)) say(`its text style ${st.name} is used nowhere`);
+  for (const sheet of listPrintPages(doc, doc.pages[0])) if (sheet.layoutMode !== "VERTICAL") say("a print sheet should be a vertical auto-layout column", sheet.name);
+  for (const n of nodes) {
+    if (n.type !== "INSTANCE") continue;
+    const c = doc.nodes[n.mainComponentId];
+    if (!c) continue;
+    if (o.measuredLayout) {
+      const wants = Math.round(instanceContentHeight(doc.nodes, n.id) ?? c.height);
+      if (Math.round(n.height) !== wants) say(`is ${Math.round(n.height)}px tall but its content takes ${wants}px`, n.name);
+    }
+    const ownWidth = instanceContentWidth(doc.nodes, n.id);
+    if (Math.abs((ownWidth ?? c.width) - n.width) < 0.5 || ownWidth !== null) continue;
+    const centred = (c.layoutMode === "VERTICAL" ? c.counterAxisAlignItems : c.primaryAxisAlignItems) ?? "MIN";
+    if (centred !== "MIN") say(`is drawn at another width than ${c.name}, which centres its content, so it lands off-centre`, n.name);
+    for (const id of c.childIds) {
+      const ch = doc.nodes[id];
+      if (ch.type === "TEXT" && (ch.textAlign ?? "LEFT") !== "LEFT") say(`is drawn at another width than ${c.name}, whose text ${ch.name} is not left-aligned`, n.name);
+    }
+  }
+  if (t.meta.tags.includes("prototype")) {
+    if (!doc.pages.map((id) => doc.nodes[id].name).includes("Wireframes")) say("a prototype needs a Wireframes page");
+    if (doc.nodes[doc.pages[0]].childIds.map((id) => doc.nodes[id]).filter((n) => n.type === "FRAME").length < 3) say("a prototype needs three screens or more");
+    if (!nodes.some((n) => n.isFlowStartingPoint)) say("a prototype needs a flow start");
+    if (!nodes.some((n) => (n.interactions?.length ?? 0) > 0)) say("a prototype needs links between its screens");
+  }
+  return out;
+}
+function sheetsOf(t) {
+  setTextMeasurer(shownTextMeasurer(t.payload));
+  const out = [];
+  for (const v of t.payload.variants) {
+    const groups = t.payload.mode === "fragment" ? [v.rootIds] : v.rootIds.map((r) => [r]);
+    for (const g of groups) {
+      const root = t.payload.nodes[g[0]];
+      out.push({ sizeId: v.sizeId, width: root.width, height: root.height, texts: paintedTexts(t.payload, g) });
+    }
+  }
+  return out;
+}
+function readabilityIssues(t, o = {}) {
+  const out = [];
+  const sheets = sheetsOf(t);
+  if (Object.values(t.payload.nodes).some((n) => n.type === "TEXT") && !sheets.some((s) => s.texts.length)) out.push({ check: "contrast", message: "has text, but none of it could be measured where it is painted" });
+  for (const s of sheets) {
+    for (const f of contrastFailures(s.texts)) out.push({ check: "contrast", size: s.sizeId, layer: f.text, message: `contrast is ${f.contrast.toFixed(2)}:1 at ${f.size}px; it needs ${f.required}:1` });
+    for (const x of s.texts) if (x.fontSize < MIN_TEXT_PX[t.meta.kind] - 1e-6) out.push({ check: "text-size", size: s.sizeId, layer: x.characters.slice(0, 40), message: `is ${x.fontSize}px; a ${t.meta.kind} template sets nothing under ${MIN_TEXT_PX[t.meta.kind]}px` });
+    const r = presetSafeRect(s.sizeId, s.width, s.height);
+    if (r) {
+      for (const x of s.texts) if (!contains(r, x)) out.push({ check: "safe-area", size: s.sizeId, layer: x.characters.slice(0, 40), message: "sits where the apps draw their buttons and captions: keep words inside the safe area" });
+    }
+    if (t.meta.kind === "PRINT") {
+      const i = PRINT_SAFE_INSET_PX;
+      for (const x of s.texts) if (!contains({ x: i, y: i, width: s.width - 2 * i, height: s.height - 2 * i }, x)) out.push({ check: "trim", size: s.sizeId, layer: x.characters.slice(0, 40), message: `is within ${i}px of the trim, where the cut can take it` });
+    }
+    if (t.meta.formats?.includes("end-screen")) {
+      for (const x of s.texts) if (safeArea("youtube-end-screen").zones.some((z) => overlaps(z, x))) out.push({ check: "end-screen", size: s.sizeId, layer: x.characters.slice(0, 40), message: "sits on a slot YouTube fills with its video and subscribe elements" });
+    }
+  }
+  const unsafe = out.filter((i) => i.check === "safe-area").length;
+  return o.depictedScreenText && unsafe <= o.depictedScreenText ? out.filter((i) => i.check !== "safe-area") : out;
+}
+function motionIssues(t) {
+  if (!t.meta.animated) return [];
+  const out = [];
+  const nodes = t.payload.nodes;
+  for (const v of t.payload.variants) for (const rootId of v.rootIds) {
+    const root = nodes[rootId];
+    if (root.print?.isMaster) continue;
+    const tl = root.timeline;
+    if (!tl?.duration || tl.fps !== t.meta.fps) {
+      out.push({ check: "motion", size: v.sizeId, layer: root.name, message: `needs a timeline with a duration at ${t.meta.fps} fps, as its first size has` });
+      continue;
+    }
+    if (motionEnd(nodes, rootId) > tl.duration) out.push({ check: "motion", size: v.sizeId, layer: root.name, message: `its last key (with every delay and stagger) lands at ${Math.round(motionEnd(nodes, rootId))}ms, after the timeline ends at ${tl.duration}ms` });
+    for (const m of tl.markers ?? []) if (m.t > tl.duration) out.push({ check: "motion", size: v.sizeId, layer: root.name, message: `a marker at ${m.t}ms is past the end` });
+  }
+  for (const n of Object.values(nodes)) for (const [path, track] of Object.entries(n.motion?.tracks ?? {})) {
+    const last = track.keys[track.keys.length - 1];
+    if (last && last.out.kind !== "hold") out.push({ check: "motion", layer: n.name, message: `${path}: a curve leaves its last key into nothing (end it on a hold)` });
+  }
+  return out;
+}
+var BRAND_QA_KITS = {
+  light: LIGHT_REVIEW_KIT,
+  dark: DARK_REVIEW_KIT,
+  long: createBrandKit({ name: "Long names", fields: { name: "Northwind Coffee Roasting Collective", tagline: "Single-origin coffee, roasted in small batches on the morning it ships to you", title: "Everything our team shipped this year", handle: "@northwindcoffeeroasters", caption: "The doors of the warehouse open in" } }),
+  serif: createBrandKit({ name: "Serif", fonts: { heading: "Source Serif 4", body: "Source Serif 4" } }),
+  logo: createBrandKit({ name: "Logo", logos: ["media://0123456789abcdef0123456789abcdef"] })
+};
+function brandedSizes(t, kit) {
+  return t.payload.variants.map((v) => {
+    const doc = settleLayout(applyBrandKit(documentFromTemplate(t, t.meta.name, v.sizeId), kit));
+    const sheets = doc.nodes[doc.pages[0]].childIds.map((id) => doc.nodes[id]).filter((n) => n.type === "FRAME" && !n.print?.isMaster);
+    return { sizeId: v.sizeId, doc, sheets };
+  });
+}
+function clippedInside(doc, id, sheetId) {
+  for (let p = doc.nodes[doc.nodes[id]?.parentId ?? ""]; p && p.id !== sheetId; p = doc.nodes[p.parentId ?? ""]) if (p.clipsContent) return true;
+  return false;
+}
+function overflowingTexts(doc, sheet) {
+  return paintedTexts(doc, [sheet.id]).filter((x) => !clippedInside(doc, x.id, sheet.id)).filter((x) => x.x < -0.5 || x.y < -0.5 || x.x + x.width > sheet.width + 0.5 || x.y + x.height > sheet.height + 0.5).map((x) => x.characters.slice(0, 40));
+}
+var logosIn = (doc) => Object.values(doc.nodes).filter((n) => n.type === "IMAGE" && n.name === "{{brand.logo}}");
+function brandIssues(t, o = { contrast: true }) {
+  const out = [];
+  if (o.contrast !== false) for (const kit of [BRAND_QA_KITS.light, BRAND_QA_KITS.dark]) for (const { sizeId, doc, sheets } of brandedSizes(t, kit)) for (const s of sheets) {
+    for (const f of contrastFailures(paintedTexts(doc, [s.id]))) out.push({ check: "brand", size: sizeId, layer: f.text, message: `under the ${kit.name} kit, contrast is ${f.contrast.toFixed(2)}:1; it needs ${f.required}:1: colour words with roles that pair (text on paper, onPrimary on primary)` });
+  }
+  for (const kit of [BRAND_QA_KITS.long, BRAND_QA_KITS.serif]) for (const { sizeId, doc, sheets } of brandedSizes(t, kit)) for (const s of sheets) {
+    for (const w of overflowingTexts(doc, s)) out.push({ check: "brand", size: sizeId, layer: w, message: `runs off the sheet under the ${kit.name} kit: let it wrap in a stack rather than sit in a fixed box` });
+  }
+  const hasSlot = t.meta.brandSlots.some((s) => s.kind === "logo");
+  for (const { sizeId, doc } of brandedSizes(t, BRAND_QA_KITS.logo)) {
+    if (logosIn(doc).length > 0 !== hasSlot) out.push({ check: "brand", size: sizeId, message: hasSlot ? "lists a logo slot, but a kit's logo lands nowhere" : "draws a {{brand.logo}} image but lists no logo slot" });
+    for (const l of logosIn(doc)) if (l.imageUrl !== BRAND_QA_KITS.logo.logos[0]) out.push({ check: "brand", size: sizeId, layer: l.name, message: "does not take the kit's logo" });
+  }
+  return out;
+}
+function settledShown(doc) {
+  const nodes = { ...doc.nodes };
+  for (const [id, n] of Object.entries(nodes)) {
+    if (n.type !== "TEXT" || n.textAutoResize === "NONE") continue;
+    const m = templateTextMeasurer(shownNode(doc, n));
+    if (m) nodes[id] = { ...n, width: m.width, height: m.height };
+  }
+  return applyAutoLayout({ ...doc, nodes });
+}
+var hugs = (n) => n.layoutSizingHorizontal === "HUG" && (n.type !== "TEXT" || n.textAutoResize === "WIDTH_AND_HEIGHT");
+function hugIssues(t, counter) {
+  const out = [];
+  for (const v of t.payload.variants) {
+    const doc = documentFromTemplate(t, t.meta.name, v.sizeId);
+    setTextMeasurer(shownTextMeasurer(doc));
+    const after = settledShown(doc);
+    for (const [id, n] of Object.entries(doc.nodes)) {
+      if (!hugs(n) || id.includes("::")) continue;
+      if (counter && n.type === "INSTANCE" && instanceContentWidth(doc.nodes, id) !== null) counter.measured++;
+      const needs = after.nodes[id]?.width ?? n.width;
+      if (needs > n.width + 1) out.push({ check: "hug", size: v.sizeId, layer: `${n.type} "${n.name}"`, message: `hugs its content but is ${n.width.toFixed(1)}px wide, and its content takes ${needs.toFixed(1)}px` });
+    }
+  }
+  return out;
+}
+function pageIssues(t) {
+  return t.payload.variants.flatMap((v) => v.rootIds.map((id) => t.payload.nodes[id]).filter((n) => n && (n.width > MAX_FRAME_PX || n.height > MAX_FRAME_PX)).map((n) => ({ check: "page", size: v.sizeId, layer: n.name, message: `is ${Math.round(n.width)}\xD7${Math.round(n.height)}; nothing over ${MAX_FRAME_PX}px is pictured` })));
+}
+function allTemplateIssues(t, commands, dispatched, o = {}) {
+  const out = [...pageIssues(t), ...practiceIssues(t), ...readabilityIssues(t, o), ...motionIssues(t), ...responsiveIssues(t), ...editabilityIssues(t, commands, dispatched)];
+  setTextMeasurer(templateTextMeasurer);
+  out.push(...layoutIssues(t), ...breakpointCutIssues(t), ...contentImageIssues(t), ...breakpointOverflowIssues(t), ...brandIssues(t), ...hugIssues(t));
+  setTextMeasurer(templateTextMeasurer);
+  return out;
+}
+
+// packages/kit/src/check-template.ts
+function componentIds() {
+  if (typeof define_POPCRAFT_COMPONENT_IDS_default !== "undefined") return new Set(define_POPCRAFT_COMPONENT_IDS_default);
+  const out = /* @__PURE__ */ new Set();
+  const walk = (dir) => {
+    for (const f of readdirSync(dir)) {
+      const p = join(dir, f);
+      if (statSync(p).isDirectory()) walk(p);
+      else if (/\.tsx?$/.test(f)) for (const m of readFileSync(p, "utf8").matchAll(/'([\w.-]+)'/g)) out.add(m[1]);
+    }
+  };
+  walk(join(repoRoot(), "components"));
+  return out;
+}
+async function checkTemplate(template, o = {}) {
+  const t = { meta: { ...template.meta, id: template.meta.localId }, payload: template.payload };
+  const words = Object.values(t.payload.nodes).flatMap((n) => n.type === "TEXT" ? [n.characters, n.characters.toUpperCase()] : []);
+  await warmTemplateFonts(words, void 0, fontDir());
+  setTextMeasurer(templateTextMeasurer);
+  const commands = [...builtinCommands, ...appCommands];
+  const ids = componentIds();
+  return [...allTemplateIssues(t, commands, new Set(commands.map((c) => c.id).filter((id) => ids.has(id))), { depictedScreenText: o.source?.depictedScreenText }), ...o.source ? motionCueIssues(o.source, t) : []];
+}
+export {
+  checkTemplate
+};