openplanr 3.2.0 → 3.3.0

package/lib/host-packages/claude/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/claude/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,