openplanr 3.3.0 → 3.4.0

package/lib/host-packages/{openai/openplanr/runtime/design/scripts/design-shared-artifact-support-dependencies-design-support-protocol-contracts-3d9b1a86.mjs → claude/openplanr/runtime/design/scripts/design-shared-artifact-support-dependencies-design-support-protocol-contracts-d707e49b.mjs}

@@ -1,6 +1,3 @@
-import {
-  isProcessAlive
-} from "./design-loopback-server.mjs";
 import {
   Parser,
   defaultTreeAdapter
@@ -11,147 +8,14 @@ import {
   hasUnescapedText
 } from "./design-parse5-tokenizer.mjs";
 import {
-  MAX_ARTIFACT_HTML_BYTES
-} from "./design-shared-artifact-support-protocol-contracts-ea2cd15e.mjs";
-import {
-  DESIGN_DOCUMENT_SCHEMA,
-  DESIGN_DOCUMENT_V120_SCHEMA,
-  DESIGN_REVIEW_BUNDLE_SCHEMA,
-  validateDesignProps,
+  MAX_ARTIFACT_HTML_BYTES,
   validateJson
-} from "./design-shared-protocol-contracts-b5f28f94.mjs";
-import {
-  canonicalizeJson,
-  sha256Hex
-} from "./design-shared-protocol-contracts-75a938cc.mjs";
-
-// packages/design/lib/design/document-state.mjs
-import { createHash, randomUUID } from "node:crypto";
-import {
-  chmodSync,
-  closeSync,
-  lstatSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  realpathSync,
-  renameSync,
-  rmSync,
-  writeFileSync
-} from "node:fs";
-import { dirname, join, resolve } from "node:path";
-var hash = (value) => createHash("sha256").update(value).digest("hex");
-var json = (value) => `${JSON.stringify(value, null, 2)}
-`;
-function readJson(path, fallback = void 0) {
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch (error) {
-    if (error.code === "ENOENT" && fallback !== void 0) return fallback;
-    throw error;
-  }
-}
-function atomicJson(path, value, { mode } = {}) {
-  atomicBytes(path, json(value), mode);
-}
-function atomicBytes(path, bytes, mode) {
-  mkdirSync(dirname(path), { recursive: true });
-  const temporary = `${path}.${randomUUID()}.tmp`;
-  try {
-    writeFileSync(temporary, bytes, { mode: 384, flag: "wx" });
-    if (mode !== void 0) chmodSync(temporary, mode);
-    renameSync(temporary, path);
-  } finally {
-    rmSync(temporary, { force: true });
-  }
-}
-function recoverDesignPublication(root, { ownsRenderLock = false } = {}) {
-  const journalPath = join(root, ".design/publication.json");
-  let journal = readJson(journalPath, null);
-  if (!journal) return;
-  const lockPath = join(root, ".design/render.lock");
-  let recoveryOwner;
-  if (!ownsRenderLock) {
-    const lock = readJson(lockPath, null);
-    if (lock && isProcessAlive(lock.pid)) return;
-    if (lock) rmSync(lockPath, { force: true });
-    recoveryOwner = randomUUID();
-    let descriptor;
-    try {
-      descriptor = openSync(lockPath, "wx", 384);
-      writeFileSync(
-        descriptor,
-        json({ pid: process.pid, owner: recoveryOwner, createdAt: Date.now() })
-      );
-    } catch (error) {
-      if (error.code === "EEXIST") return;
-      throw error;
-    } finally {
-      if (descriptor !== void 0) closeSync(descriptor);
-    }
-  }
-  try {
-    journal = readJson(journalPath, null);
-    if (!journal) return;
-    const pointer = readJson(join(root, ".design/current.json"), null);
-    const manifestPath = join(root, "finalized.json");
-    if (pointer?.revision === journal.revision) atomicJson(manifestPath, journal.manifest);
-    else if ((pointer?.revision ?? null) === journal.previousRevision) {
-      if (journal.previousManifest === null) rmSync(manifestPath, { force: true });
-      else atomicBytes(manifestPath, Buffer.from(journal.previousManifest, "base64"));
-    } else if (pointer?.revision && /^[a-f0-9]{64}$/u.test(pointer.revision)) {
-      atomicJson(
-        manifestPath,
-        readJson(join(root, ".design/revisions", pointer.revision, "render.json")).manifest
-      );
-    } else
-      throw new Error("Design publication recovery could not identify the committed revision.");
-    rmSync(journalPath, { force: true });
-  } finally {
-    if (recoveryOwner && readJson(lockPath, null)?.owner === recoveryOwner)
-      rmSync(lockPath, { force: true });
-  }
-}
-function designSpecPath(root) {
-  return /(?:^|\/)output\/feats\/feat-[^/]+\/design$/u.test(root.replaceAll("\\", "/")) ? join(dirname(root), "design-spec.md") : join(root, "design-spec.md");
-}
-function currentDesign(file, { recoverPublication = true } = {}) {
-  const root = realpathSync(dirname(resolve(file)));
-  if (recoverPublication) recoverDesignPublication(root);
-  else {
-    try {
-      lstatSync(join(root, ".design/publication.json"));
-      throw Object.assign(
-        new Error(
-          "Design publication state is pending or needs recovery. Finish or recover it with the Design utility; repair or restore an invalid .design/publication.json before retrying Plan handoff inspection."
-        ),
-        { code: "E_DESIGN_PUBLICATION_PENDING", statusCode: 409 }
-      );
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-    }
-  }
-  const pointer = readJson(join(root, ".design/current.json"), null);
-  if (!pointer || !/^[a-f0-9]{64}$/u.test(pointer.revision))
-    throw new Error("Design has no completed render. Run the render utility first.");
-  const directory = join(root, ".design/revisions", pointer.revision);
-  const prepared = readJson(join(directory, "render.json"));
-  return {
-    ...prepared,
-    root,
-    directory,
-    file: resolve(file),
-    verification: readJson(join(root, ".design/verification", `${pointer.revision}.json`), {
-      status: "unverified",
-      revision: pointer.revision
-    })
-  };
-}
+} from "./design-shared-artifact-support-protocol-contracts-9f6918b0.mjs";
 
 // packages/artifact/lib/artifact/local-document.mjs
-import { createHash as createHash2 } from "node:crypto";
-import { readFileSync as readFileSync2, realpathSync as realpathSync2, statSync } from "node:fs";
-import { dirname as dirname2, extname, isAbsolute, relative, resolve as resolve2 } from "node:path";
+import { createHash } from "node:crypto";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { dirname, extname, isAbsolute, relative, resolve } from "node:path";
 import { Script } from "node:vm";
 
 // node_modules/entities/dist/escape.js
@@ -355,13 +219,13 @@ function inspectLocalDocumentBody(html) {
 function resolveLocalDocumentFile(root, path, from = root) {
   if (typeof path !== "string" || !path || /^(?:[a-z][a-z\d+.-]*:|\/|\\)/iu.test(path))
     throw new Error(`Expected a local relative asset: ${path}`);
-  const candidate = resolve2(from, path);
+  const candidate = resolve(from, path);
   const inside = (file) => {
     const r = relative(root, file);
     return r !== ".." && !r.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && !isAbsolute(r);
   };
   if (!inside(candidate)) throw new Error(`Asset escapes design root: ${path}`);
-  const actual = realpathSync2(candidate);
+  const actual = realpathSync(candidate);
   if (!inside(actual) || !statSync(actual).isFile())
     throw new Error(`Asset is not a contained regular file: ${path}`);
   return actual;
@@ -376,7 +240,7 @@ function bundleLocalDocument({
   passive = false,
   screenProps
 }) {
-  const root = realpathSync2(inputRoot);
+  const root = realpathSync(inputRoot);
   const files = /* @__PURE__ */ new Map();
   const mediaStack = /* @__PURE__ */ new Set();
   let svgDepth = 0;
@@ -387,7 +251,7 @@ function bundleLocalDocument({
     const checked = readSource?.(path, from);
     const file = checked?.file ?? resolveLocalDocumentFile(root, path, from);
     if (!files.has(file)) {
-      const value = checked?.value ?? readFileSync2(file);
+      const value = checked?.value ?? readFileSync(file);
       bytes += value.length;
       if (bytes > maxBytes || files.size >= 1e3)
         throw new Error("Design source exceeds the local asset budget.");
@@ -416,7 +280,7 @@ function bundleLocalDocument({
         throw new Error("Circular or excessively nested SVG media cannot be published.");
       mediaStack.add(file);
       try {
-        payload = Buffer.from(passiveSvg(value.toString("utf8"), dirname2(file)));
+        payload = Buffer.from(passiveSvg(value.toString("utf8"), dirname(file)));
       } finally {
         mediaStack.delete(file);
       }
@@ -479,7 +343,7 @@ function bundleLocalDocument({
         if (stack.has(next.file)) throw new Error(`Circular stylesheet import: ${ref}`);
         const expanded = css(
           next.value.toString("utf8"),
-          dirname2(next.file),
+          dirname(next.file),
           /* @__PURE__ */ new Set([...stack, next.file])
         );
         return media.trim() ? `@media ${media.trim()}{${expanded}}` : expanded;
@@ -527,21 +391,21 @@ function bundleLocalDocument({
       );
     if (node.tagName === "meta" && attr(node, "http-equiv")?.value.toLowerCase() === "refresh")
       throw new Error("Design screens cannot redirect.");
-    if (node.tagName === "style") setText(node, css(text(node), dirname2(input.file)));
+    if (node.tagName === "style") setText(node, css(text(node), dirname(input.file)));
     if (node.tagName === "link" && attr(node, "rel")?.value.toLowerCase().split(/\s+/u).includes("stylesheet")) {
-      const linked = read(attr(node, "href")?.value, dirname2(input.file));
+      const linked = read(attr(node, "href")?.value, dirname(input.file));
       node.tagName = "style";
       node.nodeName = "style";
       node.attrs = [];
       setText(
         node,
-        css(linked.value.toString("utf8"), dirname2(linked.file), /* @__PURE__ */ new Set([linked.file]))
+        css(linked.value.toString("utf8"), dirname(linked.file), /* @__PURE__ */ new Set([linked.file]))
       );
     }
     if (node.tagName === "script") {
       const src = attr(node, "src");
       if (passive) {
-        if (src) read(src.value, dirname2(input.file));
+        if (src) read(src.value, dirname(input.file));
         node.parentNode.childNodes = node.parentNode.childNodes.filter((child) => child !== node);
         continue;
       }
@@ -549,7 +413,7 @@ function bundleLocalDocument({
       if (type === "module")
         throw new Error("Compile module scripts before using them in a portable design.");
       if (!type || /(?:javascript|ecmascript)/u.test(type)) {
-        const linked = src ? read(src.value, dirname2(input.file)) : null;
+        const linked = src ? read(src.value, dirname(input.file)) : null;
         setText(
           node,
           js(linked ? linked.value.toString("utf8") : text(node), linked?.file ?? input.file)
@@ -565,16 +429,16 @@ function bundleLocalDocument({
     }
     if (passive) node.attrs = (node.attrs ?? []).filter((item2) => !/^on/iu.test(item2.name));
     for (const item2 of node.attrs ?? []) {
-      if (item2.name === "style") item2.value = css(item2.value, dirname2(input.file));
+      if (item2.name === "style") item2.value = css(item2.value, dirname(input.file));
       if (["src", "poster"].includes(item2.name))
-        item2.value = asset(item2.value, dirname2(input.file));
+        item2.value = asset(item2.value, dirname(input.file));
       if (item2.name === "srcset")
         throw new Error("Use a local src and responsive CSS for portable design images.");
       if (["action", "formaction", "target", "formtarget"].includes(item2.name) && item2.value.trim())
         throw new Error("Design forms must use local submit handlers without navigation targets.");
       if (item2.name === "href" && !item2.value.startsWith("#")) {
         if (node.tagName === "link" || node.namespaceURI === "http://www.w3.org/2000/svg")
-          item2.value = asset(item2.value, dirname2(input.file));
+          item2.value = asset(item2.value, dirname(input.file));
         else if (node.tagName === "a")
           throw new Error('Use data-design-navigate="screen-id" for prototype navigation.');
       }
@@ -587,7 +451,7 @@ function bundleLocalDocument({
     prepend.push(
       element(
         "style",
-        css(linked.value.toString("utf8"), dirname2(linked.file), /* @__PURE__ */ new Set([linked.file]))
+        css(linked.value.toString("utf8"), dirname(linked.file), /* @__PURE__ */ new Set([linked.file]))
       )
     );
   }
@@ -630,7 +494,7 @@ function bundleLocalDocument({
     sourceDigests: Object.fromEntries(
       [...files].map(([path, value]) => [
         relative(root, path),
-        createHash2("sha256").update(value).digest("hex")
+        createHash("sha256").update(value).digest("hex")
       ])
     ),
     inputBytes: bytes,
@@ -638,6 +502,725 @@ function bundleLocalDocument({
   };
 }
 
+// packages/protocol/src/design-contracts.mjs
+var DESIGN_DOCUMENT_VERSION = "1.0.0";
+function initialFrameHeight(document) {
+  const fixed = document.frames.flatMap(
+    ({ height }) => typeof height === "number" && Number.isInteger(height) ? [height] : []
+  );
+  return fixed.length ? Math.max(...fixed) : 900;
+}
+var freeze = (value) => {
+  if (value && typeof value === "object") {
+    for (const nested of Object.values(value)) freeze(nested);
+    Object.freeze(value);
+  }
+  return value;
+};
+var FRAME_SCHEMA = {
+  type: "array",
+  minItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    required: ["id", "label", "width", "height"],
+    properties: {
+      id: { $ref: "#/$defs/id" },
+      label: { $ref: "#/$defs/text" },
+      width: { type: "integer", minimum: 1, maximum: 16384 },
+      height: { type: "integer", minimum: 1, maximum: 16384 }
+    }
+  }
+};
+var DESIGN_DOCUMENT_V1_SCHEMA = freeze({
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://openplanr.dev/schemas/v1.9.0/design-document.schema.json",
+  "x-openplanr-contract": { id: "design-document", version: "1.9.0" },
+  title: "OpenPlanr authored design document",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "kind",
+    "schemaVersion",
+    "id",
+    "title",
+    "brief",
+    "frames",
+    "screens",
+    "screenOrder",
+    "variants",
+    "selectedVariant",
+    "defaultView"
+  ],
+  properties: {
+    kind: { const: "openplanr-design-document" },
+    schemaVersion: { const: DESIGN_DOCUMENT_VERSION },
+    id: { $ref: "#/$defs/id" },
+    title: { $ref: "#/$defs/text" },
+    brief: {
+      type: "object",
+      additionalProperties: false,
+      required: ["text", "source", "provenance"],
+      properties: {
+        text: { $ref: "#/$defs/text" },
+        source: { enum: ["spec", "png", "describe"] },
+        provenance: { enum: ["spec", "inferred"] },
+        references: { type: "array", items: { $ref: "#/$defs/text" }, uniqueItems: true }
+      }
+    },
+    designSystem: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        path: { $ref: "#/$defs/localPath" },
+        tokens: { $ref: "#/$defs/localPath" },
+        spacing: {
+          type: "array",
+          minItems: 1,
+          uniqueItems: true,
+          items: { type: "number", minimum: 0, maximum: 16384 }
+        }
+      }
+    },
+    assets: { $ref: "#/$defs/paths" },
+    frames: FRAME_SCHEMA,
+    screens: {
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id", "title", "source"],
+        properties: {
+          id: { $ref: "#/$defs/id" },
+          title: { $ref: "#/$defs/text" },
+          description: { $ref: "#/$defs/text" },
+          source: { $ref: "#/$defs/source" },
+          anchors: { $ref: "#/$defs/ids" }
+        }
+      }
+    },
+    screenOrder: { type: "array", minItems: 1, items: { $ref: "#/$defs/id" }, uniqueItems: true },
+    flows: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id", "title", "screens"],
+        properties: {
+          id: { $ref: "#/$defs/id" },
+          title: { $ref: "#/$defs/text" },
+          screens: { type: "array", minItems: 1, items: { $ref: "#/$defs/id" } }
+        }
+      }
+    },
+    variants: {
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id", "label", "status"],
+        properties: {
+          id: { $ref: "#/$defs/id" },
+          label: { $ref: "#/$defs/text" },
+          description: { $ref: "#/$defs/text" },
+          status: { enum: ["ready", "failed"] },
+          issue: { $ref: "#/$defs/text" },
+          sources: { type: "object", additionalProperties: { $ref: "#/$defs/source" } }
+        },
+        if: { properties: { status: { const: "failed" } } },
+        then: { required: ["issue"] }
+      }
+    },
+    selectedVariant: { $ref: "#/$defs/id" },
+    defaultView: { enum: ["canvas", "prototype", "walkthrough"] }
+  },
+  $defs: {
+    id: { type: "string", minLength: 1, maxLength: 128, pattern: "^[A-Za-z][A-Za-z0-9_-]*$" },
+    text: { type: "string", minLength: 1, pattern: "\\S" },
+    ids: { type: "array", items: { $ref: "#/$defs/id" }, uniqueItems: true },
+    localPath: {
+      type: "string",
+      minLength: 1,
+      description: "Path relative to the authored document directory. No URL, traversal, encoded path, query or fragment.",
+      pattern: "^(?!/)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*//)(?!.*[/ ]$)[^\\\\:\\u0000-\\u001F%?#]+$"
+    },
+    paths: { type: "array", items: { $ref: "#/$defs/localPath" }, uniqueItems: true },
+    source: {
+      type: "object",
+      additionalProperties: false,
+      required: ["html"],
+      properties: {
+        html: { $ref: "#/$defs/localPath" },
+        styles: { $ref: "#/$defs/paths" },
+        scripts: { $ref: "#/$defs/paths" }
+      }
+    }
+  }
+});
+var DESIGN_DOCUMENT_V120_SCHEMA = freeze({
+  ...DESIGN_DOCUMENT_V1_SCHEMA,
+  $id: "https://openplanr.dev/schemas/v1.20.0/design-document.schema.json",
+  "x-openplanr-contract": { id: "design-document", version: "1.20.0" },
+  properties: {
+    .../** @type {Record<string, unknown>} */
+    DESIGN_DOCUMENT_V1_SCHEMA.properties,
+    frames: {
+      ...FRAME_SCHEMA,
+      items: {
+        ...FRAME_SCHEMA.items,
+        properties: {
+          ...FRAME_SCHEMA.items.properties,
+          height: { anyOf: [{ type: "integer", minimum: 1, maximum: 16384 }, { const: "auto" }] }
+        }
+      }
+    },
+    layout: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        boards: {
+          type: "object",
+          description: "Keys are screenId, screenId/frameId or screenId/frameId/variantId; each ID must exist in the document.",
+          additionalProperties: {
+            type: "object",
+            additionalProperties: false,
+            required: ["x", "y"],
+            properties: {
+              x: { $ref: "#/$defs/coordinate" },
+              y: { $ref: "#/$defs/coordinate" },
+              title: { $ref: "#/$defs/text" }
+            }
+          }
+        },
+        sections: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["id", "x", "y", "text"],
+            properties: {
+              id: { $ref: "#/$defs/id" },
+              x: { $ref: "#/$defs/coordinate" },
+              y: { $ref: "#/$defs/coordinate" },
+              text: { $ref: "#/$defs/text" },
+              maxW: { type: "integer", minimum: 1, maximum: 16384 }
+            }
+          }
+        }
+      }
+    }
+  },
+  $defs: {
+    .../** @type {Record<string, unknown>} */
+    DESIGN_DOCUMENT_V1_SCHEMA.$defs,
+    coordinate: { type: "number", minimum: -1e7, maximum: 1e7 }
+  }
+});
+var PROP_TOKEN_SCHEMA = {
+  type: "string",
+  minLength: 1,
+  maxLength: 128,
+  pattern: "^[a-z][a-z0-9-]*(?![\\s\\S])"
+};
+var propTokenPattern = new RegExp(PROP_TOKEN_SCHEMA.pattern, "u");
+var isPropToken2 = (value) => typeof value === "string" && value.length <= PROP_TOKEN_SCHEMA.maxLength && propTokenPattern.test(value);
+var currentDocument = (
+  /** @type {{ properties: Record<string, unknown>; [key: string]: unknown }} */
+  structuredClone(DESIGN_DOCUMENT_V120_SCHEMA)
+);
+currentDocument.$id = "https://openplanr.dev/schemas/v1.22.0/design-document.schema.json";
+currentDocument["x-openplanr-contract"] = { id: "design-document", version: "1.22.0" };
+currentDocument.properties.schemaVersion = { enum: ["1.0.0", "1.1.0"] };
+var screenSchema = (
+  /** @type {{ items: { properties: Record<string, unknown> } }} */
+  currentDocument.properties.screens
+);
+screenSchema.items.properties.props = {
+  type: "object",
+  propertyNames: PROP_TOKEN_SCHEMA,
+  additionalProperties: {
+    oneOf: [
+      {
+        type: "object",
+        additionalProperties: false,
+        required: ["type", "options", "default"],
+        properties: {
+          type: { const: "enum" },
+          options: {
+            type: "array",
+            minItems: 1,
+            uniqueItems: true,
+            items: PROP_TOKEN_SCHEMA
+          },
+          default: PROP_TOKEN_SCHEMA
+        }
+      },
+      {
+        type: "object",
+        additionalProperties: false,
+        required: ["type", "default"],
+        properties: { type: { const: "boolean" }, default: { type: "boolean" } }
+      }
+    ]
+  }
+};
+var variantSchema = (
+  /** @type {{ items: { properties: Record<string, unknown> } }} */
+  currentDocument.properties.variants
+);
+variantSchema.items.properties.props = {
+  type: "object",
+  propertyNames: { $ref: "#/$defs/id" },
+  additionalProperties: {
+    type: "object",
+    propertyNames: PROP_TOKEN_SCHEMA,
+    additionalProperties: { anyOf: [PROP_TOKEN_SCHEMA, { type: "boolean" }] }
+  }
+};
+currentDocument.allOf = [
+  {
+    if: { properties: { schemaVersion: { const: "1.1.0" } }, required: ["schemaVersion"] },
+    else: {
+      properties: {
+        screens: { items: { not: { required: ["props"] } } },
+        variants: { items: { not: { required: ["props"] } } }
+      }
+    }
+  }
+];
+var DESIGN_DOCUMENT_SCHEMA = freeze(currentDocument);
+function validateDesignProps(document) {
+  const errors = [];
+  const checkToken = (value, path) => {
+    if (!isPropToken2(value))
+      errors.push(
+        `${path}: ${JSON.stringify(value)} must be a lowercase token matching ${PROP_TOKEN_SCHEMA.pattern} with at most ${PROP_TOKEN_SCHEMA.maxLength} characters`
+      );
+  };
+  const screens = new Map(document.screens.map((screen) => [screen.id, screen]));
+  for (const [index, screen] of document.screens.entries()) {
+    for (const [name, prop] of Object.entries(screen.props ?? {})) {
+      const path = `$.screens[${index}].props.${name}`;
+      checkToken(name, path);
+      if (prop.type === "enum") {
+        for (const [optionIndex, option] of prop.options.entries())
+          checkToken(option, `${path}.options[${optionIndex}]`);
+        checkToken(prop.default, `${path}.default`);
+        if (!prop.options.includes(prop.default))
+          errors.push(`${path}.default: '${prop.default}' is not an enum option`);
+      }
+    }
+  }
+  for (const [index, variant] of document.variants.entries()) {
+    for (const [screenId, values] of Object.entries(variant.props ?? {})) {
+      const screen = screens.get(screenId);
+      const path = `$.variants[${index}].props.${screenId}`;
+      if (!screen) {
+        errors.push(`${path}: unknown screen '${screenId}'`);
+        continue;
+      }
+      for (const [name, value] of Object.entries(values)) {
+        checkToken(name, `${path}.${name}`);
+        if (typeof value === "string") checkToken(value, `${path}.${name}`);
+        const props = screen.props ?? {};
+        const prop = Object.hasOwn(props, name) ? props[name] : void 0;
+        if (!prop) errors.push(`${path}.${name}: unknown prop '${name}' on screen '${screenId}'`);
+        else if (prop.type === "boolean" && typeof value !== "boolean")
+          errors.push(`${path}.${name}: expected a boolean, received ${JSON.stringify(value)}`);
+        else if (prop.type === "enum" && (typeof value !== "string" || !prop.options.includes(value)))
+          errors.push(`${path}.${name}: ${JSON.stringify(value)} is not an enum option`);
+      }
+    }
+  }
+  return errors;
+}
+function validateDesignDocument(value) {
+  const errors = validateJson(value, DESIGN_DOCUMENT_SCHEMA).map(
+    ({ path, detail }) => `${path}: ${detail}`
+  );
+  if (value?.schemaVersion === "1.0.0" && ["screens", "variants"].some(
+    (field) => Array.isArray(value[field]) && value[field].some((item2) => item2 && Object.hasOwn(item2, "props"))
+  ))
+    errors.push('$.schemaVersion: props require schemaVersion "1.1.0"');
+  if (errors.length > 0) return { ok: false, errors };
+  errors.push(...validateDesignProps(value));
+  for (const field of ["frames", "screens", "flows", "variants"]) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const [index, item2] of (value[field] ?? []).entries()) {
+      if (seen.has(item2.id))
+        errors.push(`$.${field}[${index}].id: duplicate identity '${item2.id}'`);
+      seen.add(item2.id);
+    }
+  }
+  const screenIds = new Set(value.screens.map(({ id: id2 }) => id2));
+  const orderedIds = new Set(value.screenOrder);
+  for (const id2 of value.screenOrder) {
+    if (!screenIds.has(id2)) errors.push(`$.screenOrder: unknown screen '${id2}'`);
+  }
+  for (const id2 of screenIds) {
+    if (!orderedIds.has(id2)) errors.push(`$.screenOrder: missing screen '${id2}'`);
+  }
+  for (const [index, flow] of (value.flows ?? []).entries()) {
+    for (const id2 of flow.screens) {
+      if (!screenIds.has(id2)) errors.push(`$.flows[${index}].screens: unknown screen '${id2}'`);
+    }
+  }
+  for (const [index, variant] of value.variants.entries()) {
+    for (const id2 of Object.keys(variant.sources ?? {})) {
+      if (!screenIds.has(id2)) errors.push(`$.variants[${index}].sources: unknown screen '${id2}'`);
+    }
+  }
+  const frameIds = new Set(value.frames.map(({ id: id2 }) => id2));
+  const variantIds = new Set(value.variants.map(({ id: id2 }) => id2));
+  for (const [key, position] of Object.entries(value.layout?.boards ?? {})) {
+    const parts = key.split("/");
+    const path = `$.layout.boards['${key}']`;
+    if (parts.length > 3 || parts.some((id2) => !/^[A-Za-z][A-Za-z0-9_-]{0,127}$/.test(id2))) {
+      errors.push(`${path}: expected screenId, screenId/frameId or screenId/frameId/variantId`);
+    } else {
+      const [screenId, frameId, variantId] = parts;
+      if (!screenIds.has(screenId)) errors.push(`${path}: unknown screen '${screenId}'`);
+      if (frameId !== void 0 && !frameIds.has(frameId))
+        errors.push(`${path}: unknown frame '${frameId}'`);
+      if (variantId !== void 0 && !variantIds.has(variantId))
+        errors.push(`${path}: unknown variant '${variantId}'`);
+    }
+    for (const axis of ["x", "y"]) {
+      if (!Number.isFinite(position[axis]))
+        errors.push(`${path}.${axis}: expected a finite coordinate`);
+    }
+  }
+  const sectionIds = /* @__PURE__ */ new Set();
+  for (const [index, section] of (value.layout?.sections ?? []).entries()) {
+    if (sectionIds.has(section.id))
+      errors.push(`$.layout.sections[${index}].id: duplicate identity '${section.id}'`);
+    sectionIds.add(section.id);
+    for (const axis of ["x", "y"]) {
+      if (!Number.isFinite(section[axis]))
+        errors.push(`$.layout.sections[${index}].${axis}: expected a finite coordinate`);
+    }
+  }
+  const selected = value.variants.find(({ id: id2 }) => id2 === value.selectedVariant);
+  if (!selected) errors.push(`$.selectedVariant: unknown variant '${value.selectedVariant}'`);
+  else if (selected.status !== "ready")
+    errors.push("$.selectedVariant: selected variant must be ready");
+  for (const [index, spacing] of (value.designSystem?.spacing ?? []).entries()) {
+    if (!Number.isFinite(spacing))
+      errors.push(`$.designSystem.spacing[${index}]: expected a finite spacing value`);
+  }
+  return { ok: errors.length === 0, errors };
+}
+function assertDesignDocument(value) {
+  const result = validateDesignDocument(value);
+  if (!result.ok) throw new TypeError(`Invalid design document:
+${result.errors.join("\n")}`);
+  return value;
+}
+
+// packages/protocol/src/canonical-json.mjs
+var hasOwn = (value, key) => Object.hasOwn(value, key);
+function assertUnicodeScalarString(value, path) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343)) {
+        throw new TypeError(`JCS cannot canonicalize a lone high surrogate at ${path}.`);
+      }
+      index += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      throw new TypeError(`JCS cannot canonicalize a lone low surrogate at ${path}.`);
+    }
+  }
+}
+function serialize2(value, path, seen) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "string") {
+    assertUnicodeScalarString(value, path);
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError(`JCS requires a finite number at ${path}.`);
+    return JSON.stringify(value);
+  }
+  if (typeof value !== "object")
+    throw new TypeError(`JCS cannot canonicalize ${typeof value} at ${path}.`);
+  if (seen.has(value)) throw new TypeError(`JCS cannot canonicalize a cycle at ${path}.`);
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      const entries2 = [];
+      for (let index = 0; index < value.length; index += 1) {
+        if (!hasOwn(value, index))
+          throw new TypeError(`JCS cannot canonicalize a sparse array at ${path}[${index}].`);
+        entries2.push(serialize2(value[index], `${path}[${index}]`, seen));
+      }
+      return `[${entries2.join(",")}]`;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError(`JCS requires a plain JSON object at ${path}.`);
+    }
+    const entries = Object.keys(value).sort().map((key) => {
+      assertUnicodeScalarString(key, `${path} key`);
+      return `${JSON.stringify(key)}:${serialize2(value[key], `${path}.${key}`, seen)}`;
+    });
+    return `{${entries.join(",")}}`;
+  } finally {
+    seen.delete(value);
+  }
+}
+function canonicalizeJson(value) {
+  return serialize2(value, "$", /* @__PURE__ */ new Set());
+}
+var SHA256_K = /* @__PURE__ */ new Int32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var rotr = (value, bits) => value >>> bits | value << 32 - bits;
+function sha256Hex(value) {
+  const candidate = typeof value === "string" ? new TextEncoder().encode(value) : value;
+  if (!ArrayBuffer.isView(candidate) || Object.prototype.toString.call(candidate) !== "[object Uint8Array]") {
+    throw new TypeError("sha256Hex expects a string or Uint8Array.");
+  }
+  const input = new Uint8Array(candidate.buffer, candidate.byteOffset, candidate.byteLength);
+  const paddedLength = Math.ceil((input.length + 9) / 64) * 64;
+  const bytes = new Uint8Array(paddedLength);
+  bytes.set(input);
+  bytes[input.length] = 128;
+  const view = new DataView(bytes.buffer);
+  const bitLength = BigInt(input.length) * 8n;
+  view.setUint32(paddedLength - 8, Number(bitLength >> 32n & 0xffffffffn));
+  view.setUint32(paddedLength - 4, Number(bitLength & 0xffffffffn));
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const words = new Int32Array(64);
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) words[index] = view.getUint32(offset + index * 4);
+    for (let index = 16; index < 64; index += 1) {
+      const s0 = rotr(words[index - 15], 7) ^ rotr(words[index - 15], 18) ^ words[index - 15] >>> 3;
+      const s1 = rotr(words[index - 2], 17) ^ rotr(words[index - 2], 19) ^ words[index - 2] >>> 10;
+      words[index] = words[index - 16] + s0 + words[index - 7] + s1 | 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let index = 0; index < 64; index += 1) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const choice = e & f ^ ~e & g;
+      const temp1 = h + s1 + choice + SHA256_K[index] + words[index] | 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const majority = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + majority | 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 | 0;
+    }
+    h0 = h0 + a | 0;
+    h1 = h1 + b | 0;
+    h2 = h2 + c | 0;
+    h3 = h3 + d | 0;
+    h4 = h4 + e | 0;
+    h5 = h5 + f | 0;
+    h6 = h6 + g | 0;
+    h7 = h7 + h | 0;
+  }
+  return [h0, h1, h2, h3, h4, h5, h6, h7].map((part) => (part >>> 0).toString(16).padStart(8, "0")).join("");
+}
+function deepFreeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const nested of Object.values(value)) deepFreeze(nested);
+    Object.freeze(value);
+  }
+  return value;
+}
+function assertPlainDataAt(value, label, depth, seen) {
+  if (depth > 64) throw new TypeError(`${label} exceeds the maximum nesting depth.`);
+  if (value === null || ["string", "boolean"].includes(typeof value)) return;
+  if (typeof value === "number" && Number.isFinite(value)) return;
+  if (typeof value !== "object" || seen.has(value))
+    throw new TypeError(`${label} must be finite, acyclic JSON.`);
+  if (!Array.isArray(value) && ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    throw new TypeError(`${label} must contain only plain JSON objects.`);
+  seen.add(value);
+  for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (["__proto__", "prototype", "constructor"].includes(key) || !Object.hasOwn(descriptor, "value"))
+      throw new TypeError(`${label} contains a forbidden property.`);
+    assertPlainDataAt(descriptor.value, label, depth + 1, seen);
+  }
+  seen.delete(value);
+}
+function assertPlainData(value, label) {
+  assertPlainDataAt(value, label, 0, /* @__PURE__ */ new Set());
+}
+
+// packages/protocol/src/design-review-bundle-contracts.mjs
+var DESIGN_WORKSPACE_VERSION = "1.0.0";
+var designProperties = (
+  /** @type {Record<string, { items: { properties: Record<string, unknown>; required: string[] } }>} */
+  structuredClone(DESIGN_DOCUMENT_V1_SCHEMA.properties)
+);
+for (const key of ["kind", "schemaVersion", "brief", "assets", "designSystem"])
+  delete designProperties[key];
+delete designProperties.screens.items.properties.source;
+designProperties.screens.items.required = ["id", "title"];
+delete designProperties.variants.items.properties.sources;
+var DESIGN_REVIEW_BUNDLE_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://openplanr.dev/schemas/v1.9.0/design-review-bundle.schema.json",
+  "x-openplanr-contract": { id: "design-review-bundle", version: "1.9.0" },
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    kind: { const: "openplanr-design-review-bundle" },
+    schemaVersion: { const: DESIGN_WORKSPACE_VERSION },
+    design: {
+      type: "object",
+      additionalProperties: false,
+      properties: designProperties,
+      required: [
+        "id",
+        "title",
+        "frames",
+        "screens",
+        "screenOrder",
+        "variants",
+        "selectedVariant",
+        "defaultView"
+      ]
+    },
+    envelope: {
+      type: "object",
+      required: ["schemaVersion", "artifacts", "viewer"]
+    },
+    entries: {
+      type: "array",
+      minItems: 1,
+      maxItems: 256,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["artifactId", "screenId", "variantId", "frameId"],
+        properties: Object.fromEntries(
+          ["artifactId", "screenId", "variantId", "frameId"].map((key) => [
+            key,
+            { type: "string", minLength: 1, maxLength: 128 }
+          ])
+        )
+      }
+    },
+    state: {
+      type: ["object", "null"],
+      additionalProperties: false,
+      properties: {
+        positions: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            additionalProperties: false,
+            required: ["x", "y"],
+            properties: {
+              x: { type: "number", minimum: -1e7, maximum: 1e7 },
+              y: { type: "number", minimum: -1e7, maximum: 1e7 }
+            }
+          }
+        }
+      }
+    },
+    revision: { type: "string", minLength: 1, maxLength: 128 },
+    verification: {
+      type: ["object", "null"],
+      additionalProperties: false,
+      properties: {
+        status: { enum: ["verified", "unverified", "failed", "pending"] }
+      }
+    }
+  },
+  required: ["kind", "schemaVersion", "design", "envelope", "entries", "revision"],
+  $defs: structuredClone(DESIGN_DOCUMENT_V1_SCHEMA.$defs)
+};
+
 // packages/protocol/src/review-experience-contracts.mjs
 var text2 = { type: "string", maxLength: 16384 };
 var id = { type: "string", minLength: 1, maxLength: 128 };
@@ -731,7 +1314,6 @@ Object.assign(bundleV12.properties, {
   },
   fingerprints: list(DESIGN_FINGERPRINT_SCHEMA, 4096)
 });
-var DESIGN_REVIEW_BUNDLE_V12_SCHEMA = bundleV12;
 var bundleCurrent = (
   /** @type {MutableSchema} */
   structuredClone(bundleV12)
@@ -746,12 +1328,12 @@ bundleCurrent.allOf = [
     then: { properties: { envelope: bundleV12.properties.envelope } }
   }
 ];
-var currentDesign2 = (
+var currentDesign = (
   /** @type {MutableSchema} */
   bundleCurrent.properties.design
 );
 for (const key of ["frames", "layout"])
-  currentDesign2.properties[key] = /** @type {Record<string, unknown>} */
+  currentDesign.properties[key] = /** @type {Record<string, unknown>} */
   DESIGN_DOCUMENT_V120_SCHEMA.properties[key];
 bundleCurrent.$defs = structuredClone(DESIGN_DOCUMENT_V120_SCHEMA.$defs);
 var currentEntries = (
@@ -786,7 +1368,6 @@ for (const key of ["screens", "variants"]) {
   projected.items.properties.props = authored.items.properties.props;
 }
 propsDesign.allOf = structuredClone(DESIGN_DOCUMENT_SCHEMA.allOf);
-var DESIGN_REVIEW_BUNDLE_CURRENT_SCHEMA = bundleProps;
 var item = closed(
   {
     pinId: id,
@@ -887,7 +1468,6 @@ Object.assign(payloadV11.properties, {
   schemaVersion: { const: "1.1.0" },
   category: { enum: ["question", "suggestion", "change-request", "blocker"] }
 });
-var DESIGN_REVIEW_METADATA_PAYLOAD_V11_SCHEMA = payloadV11;
 function assertReviewExperience(value, contract) {
   const errors = validateJson(value, contract);
   if (errors.length)
@@ -896,44 +1476,6 @@ function assertReviewExperience(value, contract) {
     );
   return value;
 }
-function assertDesignReviewMetadata(value) {
-  return assertReviewExperience(
-    value,
-    value?.schemaVersion === "1.1.0" ? DESIGN_REVIEW_METADATA_PAYLOAD_V11_SCHEMA : DESIGN_REVIEW_METADATA_PAYLOAD_SCHEMA
-  );
-}
-function assertDesignReviewBundle(value) {
-  if (value?.design?.schemaVersion !== "1.1.0" && ["screens", "variants"].some(
-    (field) => Array.isArray(value?.design?.[field]) && value.design[field].some((item2) => item2 && Object.hasOwn(item2, "props"))
-  ))
-    throw new TypeError('Invalid design props: props require design.schemaVersion "1.1.0"');
-  assertReviewExperience(
-    value,
-    value?.design?.schemaVersion !== void 0 || ["screens", "variants"].some(
-      (field) => Array.isArray(value?.design?.[field]) && value.design[field].some((item2) => item2 && Object.hasOwn(item2, "props"))
-    ) || value?.design?.layout !== void 0 || Array.isArray(value?.design?.frames) && value.design.frames.some(({ height }) => height === "auto") ? DESIGN_REVIEW_BUNDLE_CURRENT_SCHEMA : value?.schemaVersion === "1.2.0" ? DESIGN_REVIEW_BUNDLE_V12_SCHEMA : value?.schemaVersion === "1.1.0" ? DESIGN_REVIEW_BUNDLE_V11_SCHEMA : DESIGN_REVIEW_BUNDLE_SCHEMA
-  );
-  const propErrors = validateDesignProps(value.design);
-  if (propErrors.length) throw new TypeError(`Invalid design props:
-${propErrors.join("\n")}`);
-  if (["1.1.0", "1.2.0"].includes(value.schemaVersion)) {
-    if (value.reviewContext.designId !== value.design.id || value.contextDigest !== sha256Hex(canonicalizeJson(value.reviewContext)))
-      throw new TypeError("Review context identity or digest does not match its published design.");
-    const entries = new Set(
-      value.entries.map((entry) => `${entry.screenId}:${entry.variantId}:${entry.frameId}`)
-    );
-    const seen = /* @__PURE__ */ new Set();
-    for (const item2 of value.fingerprints) {
-      const key = `${item2.screenId}:${item2.variantId}:${item2.frameId}`;
-      if (!entries.has(key) || seen.has(key))
-        throw new TypeError("Review fingerprints must identify distinct published artboards.");
-      seen.add(key);
-    }
-    if (seen.size && seen.size !== entries.size)
-      throw new TypeError("Review fingerprints must cover every published artboard.");
-  }
-  return value;
-}
 var REVIEW_EXPERIENCE_SCHEMAS = Object.freeze({
   "design-review-context": DESIGN_REVIEW_CONTEXT_SCHEMA,
   "design-review-bundle": DESIGN_REVIEW_BUNDLE_V11_SCHEMA,
@@ -942,10 +1484,10 @@ var REVIEW_EXPERIENCE_SCHEMAS = Object.freeze({
 });
 
 // packages/design/lib/design/context.mjs
-import { createHash as createHash3 } from "node:crypto";
-import { existsSync, readdirSync, readFileSync as readFileSync3, realpathSync as realpathSync3 } from "node:fs";
-import { dirname as dirname3, join as join2, resolve as resolve3 } from "node:path";
-var reviewDigest = (value) => createHash3("sha256").update(canonicalizeJson(value)).digest("hex");
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync, readdirSync, readFileSync as readFileSync2, realpathSync as realpathSync2 } from "node:fs";
+import { dirname as dirname2, join, resolve as resolve2 } from "node:path";
+var reviewDigest = (value) => createHash2("sha256").update(canonicalizeJson(value)).digest("hex");
 function emptyReviewContext(document) {
   return {
     kind: "openplanr-design-review-context",
@@ -956,10 +1498,10 @@ function emptyReviewContext(document) {
   };
 }
 function loadReviewContext(root, document, { readSource } = {}) {
-  const file = join2(root, "review-context.json");
+  const file = join(root, "review-context.json");
   if (!existsSync(file)) return emptyReviewContext(document);
   const context = JSON.parse(
-    readSource ? readSource("review-context.json", root).value.toString("utf8") : readFileSync3(resolveLocalDocumentFile(root, "review-context.json"), "utf8")
+    readSource ? readSource("review-context.json", root).value.toString("utf8") : readFileSync2(resolveLocalDocumentFile(root, "review-context.json"), "utf8")
   );
   assertReviewExperience(context, DESIGN_REVIEW_CONTEXT_SCHEMA);
   if (context.designId !== document.id)
@@ -1054,13 +1596,13 @@ function bundleDesignRevision(current, state = {}) {
     fingerprints: current.fingerprints ?? []
   };
 }
-var localRoot = (file) => realpathSync3(dirname3(resolve3(file)));
+var localRoot = (file) => realpathSync2(dirname2(resolve2(file)));
 function listDesignRevisions(file) {
   const root = localRoot(file);
-  const pointer = JSON.parse(readFileSync3(join2(root, ".design/current.json"), "utf8"));
-  const revisions = readdirSync(join2(root, ".design/revisions")).filter((name) => /^[a-f0-9]{64}$/u.test(name)).map((revision) => {
+  const pointer = JSON.parse(readFileSync2(join(root, ".design/current.json"), "utf8"));
+  const revisions = readdirSync(join(root, ".design/revisions")).filter((name) => /^[a-f0-9]{64}$/u.test(name)).map((revision) => {
     const value = JSON.parse(
-      readFileSync3(join2(root, ".design/revisions", revision, "render.json"), "utf8")
+      readFileSync2(join(root, ".design/revisions", revision, "render.json"), "utf8")
     );
     return {
       revision,
@@ -1075,7 +1617,7 @@ function readDesignRevision(file, revision) {
   if (!/^[a-f0-9]{64}$/u.test(revision)) throw new Error("Invalid design revision identity.");
   const root = localRoot(file);
   const value = JSON.parse(
-    readFileSync3(
+    readFileSync2(
       resolveLocalDocumentFile(root, `.design/revisions/${revision}/render.json`),
       "utf8"
     )
@@ -1090,24 +1632,21 @@ export {
   inspectLocalDocumentBody,
   resolveLocalDocumentFile,
   bundleLocalDocument,
+  initialFrameHeight,
+  DESIGN_DOCUMENT_SCHEMA,
+  validateDesignProps,
+  assertDesignDocument,
+  canonicalizeJson,
+  sha256Hex,
+  deepFreeze,
+  assertPlainData,
   DESIGN_HANDOFF_CONTENT_SCHEMA,
   DESIGN_HANDOFF_SCHEMA,
   assertReviewExperience,
-  assertDesignReviewMetadata,
-  assertDesignReviewBundle,
   reviewDigest,
   emptyReviewContext,
   loadReviewContext,
   reviewFingerprints,
-  bundleDesignRevision,
   listDesignRevisions,
-  readDesignRevision,
-  hash,
-  json,
-  readJson,
-  atomicJson,
-  atomicBytes,
-  recoverDesignPublication,
-  designSpecPath,
-  currentDesign
+  readDesignRevision
 };