openplanr 3.2.0 → 3.3.0

package/lib/host-packages/cursor/openplanr/runtime/design/scripts/design-document.mjs

@@ -18,6 +18,7 @@ import {
   currentDesign,
   designSpecPath,
   hash,
+  inspectLocalDocumentBody,
   json,
   loadReviewContext,
   parse,
@@ -44,7 +45,8 @@ import {
 import {
   DESIGN_DOCUMENT_SCHEMA,
   assertDesignDocument,
-  initialFrameHeight
+  initialFrameHeight,
+  validateDesignProps
 } from "./design-shared-protocol-contracts-b5f28f94.mjs";
 
 // packages/design/lib/design/frame-size.mjs
@@ -1620,6 +1622,15 @@ function lintDesign(html, opts = {}) {
   const { designSystem = null } = opts;
   const errors = [];
   const warnings = [];
+  if (opts.screen) {
+    const values = Object.hasOwn(opts.variant?.props ?? {}, opts.screen.id) ? opts.variant.props[opts.screen.id] : {};
+    errors.push(
+      ...validateDesignProps({
+        screens: [opts.screen],
+        variants: [{ props: { [opts.screen.id]: values } }]
+      }).map((message) => ({ rule: "invalid-instance-prop", level: "error", message }))
+    );
+  }
   const decls = [...styleBlockDecls(html), ...inlineStyleDecls(html)];
   for (const d of decls) {
     if (SPACING_PROP.test(d.prop)) {
@@ -1693,6 +1704,57 @@ function lintDesign(html, opts = {}) {
     summary: `${errors.length} error(s), ${warnings.length} warning(s)`
   };
 }
+function withoutRootTheme(html) {
+  if (!/theme-(?:light|dark)|data-theme/iu.test(html)) return null;
+  const body = inspectLocalDocumentBody(html);
+  if (!body) return null;
+  const edits = [];
+  for (const { name, value } of body.attrs) {
+    const location = body.location.attrs?.[name];
+    if (!location) continue;
+    let replacement;
+    if (name === "data-theme" && ["light", "dark"].includes(value)) replacement = "";
+    if (name === "class") {
+      const raw = html.slice(location.startOffset, location.endOffset);
+      const quoted = /^(class\s*=\s*)(["'])([\s\S]*)\2$/iu.exec(raw);
+      if (quoted) {
+        const kept = quoted[3].replace(/(^|\s)theme-(?:light|dark)(?=\s|$)/gu, "$1");
+        if (kept !== quoted[3]) replacement = `${quoted[1]}${quoted[2]}${kept}${quoted[2]}`;
+      } else if (/^class\s*=\s*theme-(?:light|dark)$/iu.test(raw)) replacement = "";
+    }
+    if (replacement !== void 0) edits.push({ ...location, replacement });
+  }
+  if (!edits.length) return null;
+  let normalized = html;
+  for (const { startOffset, endOffset, replacement } of edits.sort(
+    (a, b) => b.startOffset - a.startOffset
+  ))
+    normalized = normalized.slice(0, startOffset) + replacement + normalized.slice(endOffset);
+  return normalized;
+}
+function lintThemeOnlySources(sources) {
+  const warnings = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const { screenId, source, html } of sources) {
+    const normalized = withoutRootTheme(html);
+    if (normalized === null) continue;
+    const key = JSON.stringify({
+      html: normalized,
+      styles: source.styles ?? [],
+      scripts: source.scripts ?? []
+    });
+    const previous = seen.get(key);
+    if (previous && previous.screenId !== screenId && previous.source !== source.html && previous.html !== html)
+      warnings.push({
+        rule: "theme-only-source",
+        level: "warn",
+        screenId,
+        message: `Screens ${previous.screenId} (${previous.source}) and ${screenId} (${source.html}) differ only by a root theme marker; declare a theme prop and share one source.`
+      });
+    else seen.set(key, { screenId, source: source.html, html });
+  }
+  return warnings;
+}
 function lintCanvasData(data, { frames } = {}) {
   const errors = [];
   for (const section of data?.sections || []) {
@@ -2434,8 +2496,19 @@ function prepareDesignDocument(file, { readSource, passive = false, maxBytes } =
     ])
   );
   for (const variant of document2.variants.filter((item) => item.status === "ready")) {
+    const themeWarnings = lintThemeOnlySources(
+      document2.screens.map((screen) => {
+        const source = variant.sources?.[screen.id] ?? screen.source;
+        return {
+          screenId: screen.id,
+          source,
+          html: sourceContents.get(source.html).toString("utf8")
+        };
+      })
+    );
     for (const screenId of document2.screenOrder) {
       const screen = document2.screens.find((item) => item.id === screenId);
+      const values = Object.hasOwn(variant.props ?? {}, screenId) ? variant.props[screenId] : {};
       const bundled = bundleLocalDocument({
         root,
         source: variant.sources?.[screenId] ?? screen.source,
@@ -2443,6 +2516,14 @@ function prepareDesignDocument(file, { readSource, passive = false, maxBytes } =
         screenId,
         readSource,
         passive,
+        ...screen.props ? {
+          screenProps: Object.fromEntries(
+            Object.entries(screen.props).map(([name, declaration]) => [
+              name,
+              Object.hasOwn(values, name) ? values[name] : declaration.default
+            ])
+          )
+        } : {},
         ...maxBytes === void 0 ? {} : { maxBytes }
       });
       if (document2.frames.some(({ height }) => height === "auto"))
@@ -2465,8 +2546,12 @@ function prepareDesignDocument(file, { readSource, passive = false, maxBytes } =
           );
       }
       const report = lintDesign(bundled.html, {
-        designSystem: document2.designSystem
+        designSystem: document2.designSystem,
+        screen,
+        variant
       });
+      report.warnings.push(...themeWarnings.filter((item) => item.screenId === screenId));
+      report.summary = `${report.errors.length} error(s), ${report.warnings.length} warning(s)`;
       lint.push({ variantId: variant.id, screenId, ...report });
       for (const anchor of screen.anchors ?? []) {
         if (!bundled.html.includes(`data-planr-id="${anchor}"`) && !bundled.html.includes(`id="${anchor}"`))

package/lib/host-packages/cursor/openplanr/runtime/design/scripts/design-handoff.mjs

@@ -654,7 +654,7 @@ function compileDesignHandoffReadiness(input) {
   if (input === null || input === void 0) return designHandoffReadinessAbsence();
   const source = plainClone(input);
   const document = source.document;
-  if (!document || document.kind !== "openplanr-design-document" || document.schemaVersion !== "1.0.0" || typeof document.id !== "string" || !document.id)
+  if (!document || document.kind !== "openplanr-design-document" || !["1.0.0", "1.1.0"].includes(document.schemaVersion) || typeof document.id !== "string" || !document.id)
     throw new TypeError("Readiness requires one supported design document.");
   const revision = source.sourceRevision === null || source.sourceRevision === void 0 ? null : normalizeDigest(source.sourceRevision, "design revision");
   const direction = selectedDirection(document, source.studioState);

package/lib/host-packages/cursor/openplanr/runtime/design/scripts/design-share.mjs

@@ -1807,7 +1807,7 @@ async function importDesignShareRecovery(file, { input, ...options } = {}) {
       const pending = custody.pendingCreate ?? custody.pendingMutation.body;
       const destination = join3(root, "uploads", custody.id, pending.operationId);
       if (existsSync4(destination)) {
-        const { spoolChunkReader: spoolChunkReader2 } = await import("./design-runtime-support-6774fd3d5d02.mjs");
+        const { spoolChunkReader: spoolChunkReader2 } = await import("./design-runtime-support-25485dbf1cb2.mjs");
         const reader = spoolChunkReader2(destination, pending);
         for (const part of pending.manifest.chunks) await reader(part.index);
       } else await copyUploadSpool(custody, destination);

package/lib/host-packages/cursor/openplanr/runtime/design/scripts/design-shared-artifact-support-dependencies-design-support-protocol-contracts-3d9b1a86.mjs

@@ -15,7 +15,9 @@ import {
 } from "./design-shared-artifact-support-protocol-contracts-ea2cd15e.mjs";
 import {
   DESIGN_DOCUMENT_SCHEMA,
+  DESIGN_DOCUMENT_V120_SCHEMA,
   DESIGN_REVIEW_BUNDLE_SCHEMA,
+  validateDesignProps,
   validateJson
 } from "./design-shared-protocol-contracts-b5f28f94.mjs";
 import {
@@ -323,6 +325,7 @@ var MIME = {
 };
 var children = (node) => [...node.childNodes ?? [], ...node.content?.childNodes ?? []];
 var attr = (node, name) => node.attrs?.find((item2) => item2.name === name);
+var isPropToken = (value) => typeof value === "string" && value.length <= 128 && /^[a-z][a-z0-9-]*(?![\s\S])/u.test(value);
 var text = (node) => children(node).map((item2) => item2.value ?? "").join("");
 function setText(node, value) {
   node.childNodes = [{ nodeName: "#text", value, parentNode: node }];
@@ -332,6 +335,23 @@ function element(name, value) {
   setText(node, value);
   return node;
 }
+function parseBodySource(html) {
+  const roots = [];
+  const parser = new Parser({ sourceCodeLocationInfo: true });
+  const onStartTag = parser.onStartTag.bind(parser);
+  parser.onStartTag = (token) => {
+    if (token.tagName === "body") roots.push(token);
+    onStartTag(token);
+  };
+  parser.tokenizer.write(html, true);
+  const body = parser.document.childNodes.find((node) => node.tagName === "html")?.childNodes.find((node) => node.tagName === "body");
+  const root = roots.length === 1 && body?.sourceCodeLocation?.startTag?.startOffset === roots[0].location?.startOffset ? roots[0] : null;
+  return { document: parser.document, roots, root };
+}
+function inspectLocalDocumentBody(html) {
+  const { root } = parseBodySource(html);
+  return root ? { attrs: root.attrs, location: root.location } : null;
+}
 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}`);
@@ -353,7 +373,8 @@ function bundleLocalDocument({
   screenId,
   maxBytes = MAX_ARTIFACT_HTML_BYTES,
   readSource,
-  passive = false
+  passive = false,
+  screenProps
 }) {
   const root = realpathSync2(inputRoot);
   const files = /* @__PURE__ */ new Map();
@@ -483,7 +504,16 @@ function bundleLocalDocument({
     return value.replace(/<\/script/giu, "<\\/script");
   }
   const input = read(source.html);
-  const document = parse(input.value.toString("utf8"));
+  const propEntries = Object.entries(screenProps ?? {});
+  let document;
+  if (propEntries.length) {
+    const parsed = parseBodySource(input.value.toString("utf8"));
+    if (!parsed.root)
+      throw new Error(
+        `Screen ${screenId} source ${source.html} requires a single authored <body> root for props; found ${parsed.roots.length}.`
+      );
+    document = parsed.document;
+  } else document = parse(input.value.toString("utf8"));
   let head, body;
   const deferredScripts = [];
   const queue = [...children(document)];
@@ -575,6 +605,22 @@ function bundleLocalDocument({
     body.childNodes.push(node);
   }
   body.attrs.push({ name: "data-planr-screen", value: screenId });
+  if (propEntries.length) {
+    const classes = (attr(body, "class")?.value ?? "").split(/\s+/u).filter(Boolean).filter((item2) => !propEntries.some(([name]) => item2.startsWith(`prop-${name}-`)));
+    for (const [name, value] of propEntries) {
+      if (!isPropToken(name) || !(typeof value === "boolean" || isPropToken(value)))
+        throw new TypeError(
+          `Screen ${screenId} source ${source.html} has invalid prop ${name}: ${JSON.stringify(value)}.`
+        );
+      const attribute = `data-prop-${name}`;
+      body.attrs = body.attrs.filter((item2) => item2.name !== attribute);
+      body.attrs.push({ name: attribute, value: String(value) });
+      const prefix = `prop-${name}-`;
+      classes.push(`${prefix}${value}`);
+    }
+    body.attrs = body.attrs.filter((item2) => item2.name !== "class");
+    body.attrs.push({ name: "class", value: classes.join(" ") });
+  }
   const html = serialize(document);
   if (Buffer.byteLength(html) > maxBytes)
     throw new Error("Bundled design exceeds the output budget.");
@@ -706,14 +752,41 @@ var currentDesign2 = (
 );
 for (const key of ["frames", "layout"])
   currentDesign2.properties[key] = /** @type {Record<string, unknown>} */
-  DESIGN_DOCUMENT_SCHEMA.properties[key];
-bundleCurrent.$defs = structuredClone(DESIGN_DOCUMENT_SCHEMA.$defs);
+  DESIGN_DOCUMENT_V120_SCHEMA.properties[key];
+bundleCurrent.$defs = structuredClone(DESIGN_DOCUMENT_V120_SCHEMA.$defs);
 var currentEntries = (
   /** @type {{ items: { properties: Record<string, unknown> } }} */
   bundleCurrent.properties.entries
 );
 currentEntries.items.properties.height = { const: "auto" };
-var DESIGN_REVIEW_BUNDLE_CURRENT_SCHEMA = bundleCurrent;
+var bundleProps = (
+  /** @type {MutableSchema} */
+  structuredClone(bundleCurrent)
+);
+bundleProps.$id = "https://openplanr.dev/schemas/v1.22.0/design-review-bundle.schema.json";
+bundleProps["x-openplanr-contract"] = { id: "design-review-bundle", version: "1.22.0" };
+var propsDesign = (
+  /** @type {MutableSchema} */
+  bundleProps.properties.design
+);
+var authoredProperties = (
+  /** @type {Record<string, unknown>} */
+  DESIGN_DOCUMENT_SCHEMA.properties
+);
+propsDesign.properties.schemaVersion = authoredProperties.schemaVersion;
+for (const key of ["screens", "variants"]) {
+  const projected = (
+    /** @type {{ items: { properties: Record<string, unknown> } }} */
+    propsDesign.properties[key]
+  );
+  const authored = (
+    /** @type {{ items: { properties: Record<string, unknown> } }} */
+    authoredProperties[key]
+  );
+  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,
@@ -830,10 +903,19 @@ function assertDesignReviewMetadata(value) {
   );
 }
 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?.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
+    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.");
@@ -902,6 +984,7 @@ function reviewFingerprints({ document, context, screen, variant, frame, sourceD
   const components = context.implementation.components.filter(
     (component) => !component.screenIds?.length || component.screenIds.includes(screen.id)
   );
+  const values = Object.hasOwn(variant.props ?? {}, screen.id) ? variant.props[screen.id] : {};
   return {
     screenId: screen.id,
     variantId: variant.id,
@@ -909,7 +992,15 @@ function reviewFingerprints({ document, context, screen, variant, frame, sourceD
     contentDigest: reviewDigest({
       files: Object.entries(sourceDigests).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0),
       width: frame.width,
-      height: frame.height
+      height: frame.height,
+      ...screen.props === void 0 ? {} : {
+        props: Object.fromEntries(
+          Object.entries(screen.props).map(([name, declaration]) => [
+            name,
+            Object.hasOwn(values, name) ? values[name] : declaration.default
+          ])
+        )
+      }
     }),
     guidanceDigest: reviewDigest({
       title: screen.title,
@@ -934,6 +1025,7 @@ function bundleDesignRevision(current, state = {}) {
     kind: "openplanr-design-review-bundle",
     schemaVersion: current.envelope.schemaVersion === "1.1.0" ? "1.2.0" : "1.1.0",
     design: {
+      ...document.screens.some((screen) => screen.props !== void 0) || document.variants.some((variant) => variant.props !== void 0) ? { schemaVersion: document.schemaVersion } : {},
       ...pick(document, [
         "id",
         "title",
@@ -945,12 +1037,12 @@ function bundleDesignRevision(current, state = {}) {
         "layout"
       ]),
       screens: document.screens.map(
-        (screen) => pick(screen, ["id", "title", "description", "anchors"])
+        (screen) => pick(screen, ["id", "title", "description", "anchors", "props"])
       ),
       selectedVariant: document.variants.some(
         (variant) => variant.id === state.selectedVariant && variant.status === "ready"
       ) ? state.selectedVariant : document.selectedVariant,
-      variants: document.variants.filter((variant) => variant.status === "ready").map((variant) => pick(variant, ["id", "label", "status"]))
+      variants: document.variants.filter((variant) => variant.status === "ready").map((variant) => pick(variant, ["id", "label", "status", "props"]))
     },
     envelope: structuredClone(current.envelope),
     entries: structuredClone(current.entries),
@@ -995,6 +1087,7 @@ export {
   serialize,
   parse,
   parseFragment,
+  inspectLocalDocumentBody,
   resolveLocalDocumentFile,
   bundleLocalDocument,
   DESIGN_HANDOFF_CONTENT_SCHEMA,

package/lib/host-packages/cursor/openplanr/runtime/design/scripts/design-shared-protocol-contracts-b5f28f94.mjs

@@ -104,6 +104,7 @@ var VALIDATION_KEYWORDS = [
   "maxContains",
   "required",
   "properties",
+  "propertyNames",
   "additionalProperties",
   "maxProperties",
   "dependentRequired",
@@ -172,6 +173,7 @@ var KEYWORD_SHAPES = {
   maxContains: ["a non-negative integer", isCount],
   required: ["an array of unique strings", isUniqueStrings],
   properties: ["an object of schemas", isSchemaMap],
+  propertyNames: ["a schema", isSchema],
   additionalProperties: ["a schema", isSchema],
   maxProperties: ["a non-negative integer", isCount],
   dependentRequired: [
@@ -440,6 +442,8 @@ var validateNode = (value, schema6, path, errs, context) => {
     }
     const props = schema6.properties || {};
     for (const [k, v] of Object.entries(value)) {
+      if (schema6.propertyNames !== void 0)
+        validateNode(k, schema6.propertyNames, `${path}.${k}`, errs, context);
       if (Object.hasOwn(props, k)) evaluated.add(k);
       else if (schema6.additionalProperties !== void 0) evaluated.add(k);
       if (!Object.hasOwn(props, k)) {
@@ -4733,7 +4737,7 @@ var DESIGN_DOCUMENT_V1_SCHEMA = freeze({
     }
   }
 });
-var DESIGN_DOCUMENT_SCHEMA = freeze({
+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" },
@@ -4792,11 +4796,134 @@ var DESIGN_DOCUMENT_SCHEMA = freeze({
     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 isPropToken = (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 (!isPropToken(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 [index2, screen] of document.screens.entries()) {
+    for (const [name, prop] of Object.entries(screen.props ?? {})) {
+      const path = `$.screens[${index2}].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 [index2, variant] of document.variants.entries()) {
+    for (const [screenId, values] of Object.entries(variant.props ?? {})) {
+      const screen = screens.get(screenId);
+      const path = `$.variants[${index2}].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 [index2, item2] of (value[field] ?? []).entries()) {
@@ -5759,7 +5886,9 @@ function assertLargeObjectContract(value, kind) {
 export {
   validateJson,
   initialFrameHeight,
+  DESIGN_DOCUMENT_V120_SCHEMA,
   DESIGN_DOCUMENT_SCHEMA,
+  validateDesignProps,
   assertDesignDocument,
   DESIGN_WORKSPACE_VERSION,
   DESIGN_WORKSPACE_API,