@morit/cli 1.2.0 → 1.4.0

package/src/workspace.js

@@ -40,7 +40,7 @@ const SAFE_SEGMENT = /^[A-Za-z0-9._-]+$/;
 const WINDOWS_RESERVED = /^(?:con|prn|aux|nul|clock\$|com[1-9]|lpt[1-9])(?:\.|$)/i;
 const UI_IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const UI_STATE_KEY = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
-const UI_BINDING = /^(?:state|data|item)(?:\.[A-Za-z0-9_-]+){0,12}$/;
+const UI_BINDING = /^(?:state|data|item|context)(?:\.[A-Za-z0-9_-]+){0,12}$/;
 const UI_TEMPLATE_BINDING = /\{\{\s*([^{}]+?)\s*\}\}/g;
 const UI_SINGLE_TEMPLATE_BINDING = /^\{\{\s*([^{}]+?)\s*\}\}$/;
 const UI_ASSET_PATH = /^assets\/[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*\.(?:gif|jpe?g|png|webp)$/i;
@@ -152,7 +152,7 @@ export class LocalWorkspace {
       version: "1.0.0",
       cloud_project_id: null,
       required_secrets: [],
-      min_morit_version: "1.7.8",
+      min_morit_version: "1.7.12",
       max_morit_version: "1.999.999",
       permissions: [],
       capabilities: [],
@@ -813,6 +813,12 @@ function validateManifest(manifest, files) {
       throw new Error(`unsupported runtime adapter: ${adapter || "missing"}`);
     }
     validateRuntime(capability, runtime, permissions, credentials, connectors, dependencies);
+    for (const [field, schema] of [["input_schema", capability.input_schema], ["output_schema", capability.output_schema]]) {
+      if (schema === undefined) continue;
+      assertObject(schema, `capability ${capability.id} ${field}`);
+      if (Buffer.byteLength(JSON.stringify(schema), "utf8") > 16 * 1024) throw new Error(`capability ${capability.id} ${field} is too large`);
+      validateResponseSchema(schema, 0, true);
+    }
     if (adapter === "sandbox_python") {
       const entrypoint = normalizeEntrypointPath(runtime.entrypoint);
       if (!entrypoint.startsWith("src/") || !entrypoint.endsWith(".py")) throw new Error("sandbox_python entrypoint must be src/*.py");
@@ -1242,10 +1248,16 @@ function validateRuntimeReferences(capabilities, connectors, connectorIds, depen
 function validateUiConfig(extension, capabilities, routeIds, files, hasStorage = false) {
   const config = extension.config === undefined ? {} : extension.config;
   const executable = new Set(capabilities.filter((value) => ["tool", "skill", "provider", "notification"].includes(value.kind)).map((value) => value.id));
+  const capabilitySchemas = new Map(capabilities.map((value) => [value.id, {
+    input_schema: value.input_schema,
+    output_schema: value.output_schema,
+  }]));
   if (hasStorage) for (const capability of STORAGE_TOOLS) executable.add(capability);
+  if (extension.point === "response" && config.ui_schema !== 2) throw new Error("response UI requires UI Runtime v2");
   if (config.ui_schema === 2) {
     if (config.placement != null && !["card", "action"].includes(extension.point)) throw new Error("UI placement is only valid for home extensions");
-    validateUiRuntimeV2(config, executable, routeIds);
+    validateUiRuntimeV2(config, executable, routeIds, capabilitySchemas);
+    validateResponseComponent(config, extension.point === "response");
     for (const asset of uiRuntimeAssetPaths(config.view)) {
       if (!(asset in files)) throw new Error(`UI image asset is not packaged: ${asset}`);
     }
@@ -1279,6 +1291,72 @@ function validateUiConfig(extension, capabilities, routeIds, files, hasStorage =
   if (config.form !== undefined) validateLegacyUiForm(config.form, executable, extension.id);
 }
 
+function validateResponseComponent(config, responsePoint) {
+  if (!responsePoint) {
+    if (Object.hasOwn(config, "a2ui")) throw new Error("A2UI metadata is only valid for response UI");
+    return;
+  }
+  const value = config.a2ui;
+  assertObject(value, "response A2UI metadata");
+  rejectUnknownFields(value, new Set(["version", "description", "schema"]), "response A2UI metadata");
+  if (Object.keys(value).length !== 3 || value.version !== "v0.9") throw new Error("response UI requires complete A2UI v0.9 metadata");
+  requireText(value.description, 500, "response A2UI description");
+  assertObject(value.schema, "response A2UI schema");
+  if (Buffer.byteLength(JSON.stringify(value.schema), "utf8") > 16 * 1024) throw new Error("response A2UI schema is too large");
+  validateResponseSchema(value.schema, 0, true);
+}
+
+function validateResponseSchema(schema, depth, root = false) {
+  const fields = new Set([
+    "type", "properties", "required", "additionalProperties", "items", "enum",
+    "minItems", "maxItems", "minLength", "maxLength", "minimum", "maximum",
+  ]);
+  if (depth > 6) throw new Error("response A2UI schema is too deep");
+  rejectUnknownFields(schema, fields, "response A2UI schema");
+  const types = new Set(["object", "array", "string", "number", "integer", "boolean", "null"]);
+  if (!types.has(schema.type) || (root && schema.type !== "object")) throw new Error("response A2UI schema type is invalid");
+  if (schema.enum !== undefined) {
+    if (!Array.isArray(schema.enum) || schema.enum.length < 1 || schema.enum.length > 32 || schema.enum.some((item) => item !== null && typeof item === "object")) throw new Error("response A2UI schema enum is invalid");
+    for (const item of schema.enum) validateUiJson(item, 0);
+  }
+  const byType = {
+    object: new Set(["properties", "required", "additionalProperties"]),
+    array: new Set(["items", "minItems", "maxItems"]),
+    string: new Set(["minLength", "maxLength"]),
+    number: new Set(["minimum", "maximum"]),
+    integer: new Set(["minimum", "maximum"]),
+    boolean: new Set(),
+    null: new Set(),
+  }[schema.type];
+  if (Object.keys(schema).some((key) => !["type", "enum"].includes(key) && !byType.has(key))) throw new Error("response A2UI schema keyword does not match its type");
+  if (schema.type === "object") {
+    const properties = schema.properties === undefined ? {} : schema.properties;
+    const required = schema.required === undefined ? [] : schema.required;
+    const additional = schema.additionalProperties === undefined ? true : schema.additionalProperties;
+    assertObject(properties, "response A2UI properties");
+    if (Object.keys(properties).length > 64 || !Array.isArray(required) || required.length > 64 || new Set(required).size !== required.length || typeof additional !== "boolean") throw new Error("response A2UI object schema is invalid");
+    for (const [key, child] of Object.entries(properties)) {
+      if (!UI_STATE_KEY.test(key)) throw new Error("response A2UI property is invalid");
+      assertObject(child, "response A2UI property schema");
+      validateResponseSchema(child, depth + 1);
+    }
+    if (required.some((key) => typeof key !== "string" || !Object.hasOwn(properties, key))) throw new Error("response A2UI required property is invalid");
+  } else if (schema.type === "array") {
+    assertObject(schema.items, "response A2UI item schema");
+    const minimum = schema.minItems === undefined ? 0 : schema.minItems;
+    const maximum = schema.maxItems === undefined ? 64 : schema.maxItems;
+    if (!Number.isInteger(minimum) || !Number.isInteger(maximum) || minimum < 0 || minimum > maximum || maximum > 64) throw new Error("response A2UI array schema is invalid");
+    validateResponseSchema(schema.items, depth + 1);
+  } else if (schema.type === "string") {
+    const minimum = schema.minLength === undefined ? 0 : schema.minLength;
+    const maximum = schema.maxLength === undefined ? 2000 : schema.maxLength;
+    if (!Number.isInteger(minimum) || !Number.isInteger(maximum) || minimum < 0 || minimum > maximum || maximum > 2000) throw new Error("response A2UI string schema is invalid");
+  } else if (["number", "integer"].includes(schema.type)) {
+    for (const bound of [schema.minimum, schema.maximum]) if (bound !== undefined && (typeof bound !== "number" || !Number.isFinite(bound))) throw new Error("response A2UI number bound is invalid");
+    if (schema.minimum !== undefined && schema.maximum !== undefined && schema.minimum > schema.maximum) throw new Error("response A2UI number range is invalid");
+  }
+}
+
 function validateLegacyUiForm(form, executable, extensionId) {
   rejectUnknownFields(form, new Set(["submit_capability", "submit_label", "fields"]), `UI ${extensionId} form`);
   if (!executable.has(form.submit_capability)) throw new Error(`UI ${extensionId} form targets an unknown capability`);
@@ -1308,7 +1386,7 @@ function validateLegacyUiForm(form, executable, extensionId) {
   }
 }
 
-function validateUiRuntimeV2(config, executable, routes) {
+function validateUiRuntimeV2(config, executable, routes, capabilitySchemas = new Map()) {
   rejectUnknownFields(config, new Set(contract.ui_runtime.config_fields), "UI Runtime v2");
   if (config.ui_schema !== 2) throw new Error("UI Runtime version must be 2");
   validateUiIcon(config.icon);
@@ -1361,6 +1439,7 @@ function validateUiRuntimeV2(config, executable, routes) {
   validateUiNavigation(config.navigation, executable, routes, sourceIds, stateKeys);
   assertObject(config.view, "UI Runtime v2 view");
   validateUiNode(config.view, 0, { value: 0 }, executable, routes, sourceIds, stateKeys, null);
+  validateUiCapabilityBindings(config, sources, capabilitySchemas);
 }
 
 function validateUiTheme(theme, variant = false) {
@@ -1532,7 +1611,7 @@ function validateUiNode(node, depth, counter, executable, routes, sources, state
   const props = node.props === undefined ? {} : node.props;
   validateUiProps(node.type, props, sources, stateKeys);
   validateUiCondition(node.visible_when, stateKeys, sources);
-  if (node.action != null && !["surface", "card", "button", "chip"].includes(node.type)) {
+  if (node.action != null && !["surface", "card", "button", "chip", "form", "field", "select", "switch"].includes(node.type)) {
     throw new Error("UI action requires an interactive component");
   }
   validateUiAction(node.action, executable, routes, sources, stateKeys);
@@ -1565,7 +1644,7 @@ function validateUiProps(nodeType, props, sources, stateKeys) {
     "border_radius", "elevation", "opacity", "clip", "enabled", "tooltip", "semantic_label", "exclude_semantics",
   ]);
   if (nodeType === "surface") rejectUnknownFields(props, surfaceProps, "surface UI component props");
-  for (const key of ["text", "title", "subtitle", "label", "supporting", "placeholder", "empty_text", "value", "tooltip", "semantic_label"]) {
+  for (const key of ["text", "title", "subtitle", "label", "supporting", "placeholder", "empty_text", "value", "tooltip", "semantic_label", "error_text", "submit_label"]) {
     if (props[key] !== undefined) {
       optionalUiTemplate(props[key], 1200, true);
       validateTemplateReferences(props[key], stateKeys, sources);
@@ -1576,6 +1655,11 @@ function validateUiProps(nodeType, props, sources, stateKeys) {
   }
   if (props.icon !== undefined) validateUiIcon(props.icon, true);
   if (props.max_lines !== undefined && (!Number.isInteger(props.max_lines) || props.max_lines < 1 || props.max_lines > 100)) throw new Error("UI numeric property max_lines is invalid");
+  if (props.input_type !== undefined && !["text", "number", "email", "url"].includes(props.input_type)) throw new Error("UI input type is invalid");
+  for (const key of ["min_length", "max_length"]) if (props[key] !== undefined && (!Number.isInteger(props[key]) || props[key] < 0 || props[key] > 2000)) throw new Error(`UI ${key} is invalid`);
+  if ((props.min_length ?? 0) > (props.max_length ?? 2000)) throw new Error("UI text length constraints are invalid");
+  for (const key of ["minimum", "maximum"]) if (props[key] !== undefined) validateUiNumber(props[key], `UI ${key}`, -1000000000, 1000000000);
+  if ((props.minimum ?? -1000000000) > (props.maximum ?? 1000000000)) throw new Error("UI numeric constraints are invalid");
   for (const key of ["columns", "size", "limit"]) {
     if (props[key] !== undefined && (!Number.isInteger(props[key]) || props[key] < 0 || props[key] > 100)) throw new Error(`UI numeric property ${key} is invalid`);
   }
@@ -1600,7 +1684,7 @@ function validateUiProps(nodeType, props, sources, stateKeys) {
   for (const key of ["left", "top", "right", "bottom"]) if (props[key] !== undefined) validateUiNumber(props[key], `UI position ${key}`, -4096, 4096);
   if (props.stack_at !== undefined && (!Number.isInteger(props.stack_at) || props.stack_at < 0 || props.stack_at > 1200)) throw new Error("UI stack_at is invalid");
   if (props.min_item_width !== undefined && (!Number.isInteger(props.min_item_width) || props.min_item_width < 96 || props.min_item_width > 600)) throw new Error("UI min_item_width is invalid");
-  for (const key of ["persist", "selected", "dense", "show_legend", "full_width", "exclude_semantics", "clip", "shrink_wrap", "enabled"]) if (props[key] !== undefined && typeof props[key] !== "boolean") throw new Error(`UI boolean property ${key} is invalid`);
+  for (const key of ["persist", "selected", "dense", "show_legend", "full_width", "exclude_semantics", "clip", "shrink_wrap", "enabled", "required", "searchable"]) if (props[key] !== undefined && typeof props[key] !== "boolean") throw new Error(`UI boolean property ${key} is invalid`);
   if (props.fit !== undefined && !["contain", "cover", "fill", "fit_width", "fit_height", "none", "scale_down"].includes(props.fit)) throw new Error("UI image fit is invalid");
   if (props.scroll_direction !== undefined && !["vertical", "horizontal"].includes(props.scroll_direction)) throw new Error("UI scroll direction is invalid");
   if (["image", "avatar"].includes(nodeType)) validateUiImageSource(props, sources);
@@ -1620,6 +1704,11 @@ function validateUiProps(nodeType, props, sources, stateKeys) {
   if (nodeType === "chart" && !["bar", "line", "donut", "scatter"].includes(chartType)) throw new Error("UI chart type is invalid");
   if (nodeType === "calendar" && props.state_key != null && !stateKeys.has(props.state_key)) throw new Error("UI calendar state is unknown");
   if (["field", "select", "switch"].includes(nodeType) && !stateKeys.has(props.state_key)) throw new Error("UI state field is unknown");
+  if (props.suggestions !== undefined || props.suggestions_source !== undefined) {
+    if (nodeType !== "field" || (props.suggestions !== undefined && props.suggestions_source !== undefined)) throw new Error("UI autocomplete options are invalid");
+    if (props.suggestions !== undefined && (!Array.isArray(props.suggestions) || props.suggestions.length < 1 || props.suggestions.length > 32 || props.suggestions.some((value) => typeof value !== "string" || !value.trim() || value.length > 120))) throw new Error("UI autocomplete options are invalid");
+    if (props.suggestions_source !== undefined) validateUiDataBinding(props.suggestions_source, sources, "autocomplete");
+  }
   if (props.options != null) {
     if (nodeType !== "select" || !Array.isArray(props.options) || props.options.length < 1 || props.options.length > 32) throw new Error("UI select options are invalid");
     for (const option of props.options) {
@@ -1628,6 +1717,18 @@ function validateUiProps(nodeType, props, sources, stateKeys) {
       optionalUiText(option.label, 80, { required: true });
     }
   }
+  if (props.options !== undefined && props.options_source !== undefined) throw new Error("UI select cannot declare two options sources");
+  if (props.options_source !== undefined) {
+    if (nodeType !== "select") throw new Error("UI options source requires a select");
+    validateUiDataBinding(props.options_source, sources, "select options");
+  }
+  if (props.searchable !== undefined && nodeType !== "select") throw new Error("UI searchable requires a select");
+  for (const key of ["required", "min_length", "max_length", "minimum", "maximum", "error_text"]) if (props[key] !== undefined && !["field", "select", "switch"].includes(nodeType)) throw new Error("UI validation properties require an input");
+  if (props.submit_label !== undefined && nodeType !== "form") throw new Error("UI submit label requires a form");
+}
+
+function validateUiDataBinding(value, sources, label) {
+  if (typeof value !== "string" || !UI_BINDING.test(value) || !value.startsWith("data.") || !sources.has(value.split(".")[1])) throw new Error(`UI ${label} source is invalid`);
 }
 
 function validateUiImageSource(props, sources) {
@@ -1669,8 +1770,21 @@ function validateUiInsets(value, label) {
   for (const item of Object.values(value)) validateUiNumber(item, label, 0, 128);
 }
 
-function validateUiCondition(condition, stateKeys, sources) {
+function validateUiCondition(condition, stateKeys, sources, depth = 0, counter = { value: 0 }) {
   if (condition == null) return;
+  assertObject(condition, "UI visibility condition");
+  counter.value += 1;
+  if (depth > 4 || counter.value > 32) throw new Error("UI visibility condition is too complex");
+  const composites = ["all", "any", "not"].filter((key) => Object.hasOwn(condition, key));
+  if (composites.length) {
+    if (composites.length !== 1 || Object.keys(condition).length !== 1) throw new Error("UI visibility condition is invalid");
+    const key = composites[0];
+    if (key === "not") return validateUiCondition(condition.not, stateKeys, sources, depth + 1, counter);
+    const children = condition[key];
+    if (!Array.isArray(children) || children.length < 1 || children.length > 8) throw new Error("UI visibility condition group is invalid");
+    for (const child of children) validateUiCondition(child, stateKeys, sources, depth + 1, counter);
+    return;
+  }
   rejectUnknownFields(condition, new Set(["path", "equals", "not_equals", "exists"]), "UI visibility condition");
   if (typeof condition.path !== "string" || !UI_BINDING.test(condition.path)) throw new Error("UI visibility path is invalid");
   validateKnownBinding(condition.path, stateKeys, sources);
@@ -1679,13 +1793,23 @@ function validateUiCondition(condition, stateKeys, sources) {
   if (checks[0] !== "exists") validateUiJson(condition[checks[0]], 0);
 }
 
-function validateUiAction(action, executable, routes, sources, stateKeys, required = false) {
+function validateUiAction(action, executable, routes, sources, stateKeys, required = false, depth = 0, counter = { value: 0 }) {
   if (action == null) {
     if (required) throw new Error("UI action is required");
     return;
   }
+  assertObject(action, "UI action");
+  counter.value += 1;
+  if (depth > 4 || counter.value > 16) throw new Error("UI action flow is too complex");
   rejectUnknownFields(action, new Set(contract.ui_runtime.action_fields), "UI action");
-  if (!["invoke", "navigate", "set_state", "refresh", "back"].includes(action.type)) throw new Error("UI action type is invalid");
+  if (!["invoke", "navigate", "set_state", "refresh", "back", "flow"].includes(action.type)) throw new Error("UI action type is invalid");
+  if (action.validate !== undefined && typeof action.validate !== "boolean") throw new Error("UI action validation flag is invalid");
+  if (action.type === "flow") {
+    rejectUnknownFields(action, new Set(["type", "mode", "actions", "continue_on_error", "validate"]), "UI action flow");
+    if (!["sequential", "parallel"].includes(action.mode) || !Array.isArray(action.actions) || action.actions.length < 1 || action.actions.length > 8 || (action.continue_on_error !== undefined && typeof action.continue_on_error !== "boolean")) throw new Error("UI action flow is invalid");
+    for (const child of action.actions) validateUiAction(child, executable, routes, sources, stateKeys, true, depth + 1, counter);
+    return;
+  }
   if (action.type === "invoke") {
     if (!executable.has(action.capability)) throw new Error("UI action targets a non-executable capability");
     optionalUiTemplate(action.query, 2000);
@@ -1700,6 +1824,11 @@ function validateUiAction(action, executable, routes, sources, stateKeys, requir
     if (!["platform", "fade", "slide", "none"].includes(transition)) throw new Error("UI navigation transition is invalid");
     const replace = action.replace === undefined ? false : action.replace;
     if (typeof replace !== "boolean") throw new Error("UI navigation replacement is invalid");
+    const parameters = action.parameters === undefined ? {} : action.parameters;
+    assertObject(parameters, "UI navigation parameters");
+    validateUiBindingValue(parameters, 0, stateKeys, sources);
+    if (action.result_state !== undefined && !stateKeys.has(action.result_state)) throw new Error("UI navigation result state is unknown");
+    if (action.result_state !== undefined && replace) throw new Error("replacement navigation cannot return a result");
   } else if (action.type === "set_state") {
     assertObject(action.values, "UI state action values");
     if (!Object.keys(action.values).length || Object.keys(action.values).some((key) => !stateKeys.has(key))) throw new Error("UI state action targets an unknown state key");
@@ -1708,8 +1837,21 @@ function validateUiAction(action, executable, routes, sources, stateKeys, requir
     if (typeof persist !== "boolean") throw new Error("UI state persistence flag is invalid");
   } else if (action.type === "refresh") {
     if (!sources.has(action.source)) throw new Error("UI refresh source is unknown");
-  } else if (Object.keys(action).length !== 1) throw new Error("back UI action cannot contain arguments");
+  } else {
+    rejectUnknownFields(action, new Set(["type", "result"]), "back UI action");
+    const result = action.result === undefined ? {} : action.result;
+    assertObject(result, "UI route result");
+    validateUiBindingValue(result, 0, stateKeys, sources);
+  }
   if (action.type !== "navigate" && (action.transition !== undefined || action.replace !== undefined)) throw new Error("navigation options require a navigate UI action");
+  const allowed = {
+    invoke: new Set(["type", "capability", "query", "arguments", "store", "validate"]),
+    navigate: new Set(["type", "target", "transition", "replace", "parameters", "result_state", "validate"]),
+    set_state: new Set(["type", "values", "persist"]),
+    refresh: new Set(["type", "source"]),
+    back: new Set(["type", "result"]),
+  }[action.type];
+  rejectUnknownFields(action, allowed, "UI action");
 }
 
 function validateUiBindingValue(value, depth, stateKeys, sources) {
@@ -1750,6 +1892,73 @@ function validateUiJson(value, depth) {
   for (const item of Object.values(value)) validateUiJson(item, depth + 1);
 }
 
+function validateUiCapabilityBindings(config, sources, capabilitySchemas) {
+  const sourceCapabilities = new Map(sources.map((source) => [source.id, source.capability]));
+  for (const source of sources) {
+    const schema = capabilitySchemas.get(source.capability)?.input_schema;
+    if (schema !== undefined && !uiSchemaAccepts(schema, source.arguments === undefined ? {} : source.arguments)) {
+      throw new Error(`UI data source ${source.id} does not match capability input_schema`);
+    }
+  }
+  function visit(value) {
+    if (typeof value === "string") {
+      for (const match of value.matchAll(UI_TEMPLATE_BINDING)) {
+        const parts = match[1].trim().split(".");
+        if (parts.length < 4 || parts[0] !== "data" || parts[2] !== "data") continue;
+        const schema = capabilitySchemas.get(sourceCapabilities.get(parts[1]))?.output_schema;
+        if (schema !== undefined && !uiSchemaHasPath(schema, parts.slice(3))) throw new Error("UI binding references an unknown capability output");
+      }
+      return;
+    }
+    if (Array.isArray(value)) return value.forEach(visit);
+    if (!value || typeof value !== "object") return;
+    if (value.type === "invoke") {
+      const schema = capabilitySchemas.get(value.capability)?.input_schema;
+      if (schema !== undefined && !uiSchemaAccepts(schema, value.arguments === undefined ? {} : value.arguments)) throw new Error("UI action does not match capability input_schema");
+    }
+    Object.values(value).forEach(visit);
+  }
+  visit(config);
+}
+
+function uiSchemaAccepts(schema, value) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return false;
+  if (typeof value === "string") {
+    const exact = UI_SINGLE_TEMPLATE_BINDING.exec(value);
+    if (exact) return true;
+    if ([...value.matchAll(UI_TEMPLATE_BINDING)].length) return schema.type === "string";
+  }
+  if (schema.enum !== undefined && !schema.enum.some((item) => JSON.stringify(item) === JSON.stringify(value))) return false;
+  if (schema.type === "null") return value === null;
+  if (schema.type === "boolean") return typeof value === "boolean";
+  if (schema.type === "integer") return Number.isInteger(value) && (schema.minimum === undefined || value >= schema.minimum) && (schema.maximum === undefined || value <= schema.maximum);
+  if (schema.type === "number") return typeof value === "number" && Number.isFinite(value) && (schema.minimum === undefined || value >= schema.minimum) && (schema.maximum === undefined || value <= schema.maximum);
+  if (schema.type === "string") return typeof value === "string" && value.length >= (schema.minLength ?? 0) && value.length <= (schema.maxLength ?? 2000);
+  if (schema.type === "array") return Array.isArray(value) && value.length >= (schema.minItems ?? 0) && value.length <= (schema.maxItems ?? 64) && value.every((item) => uiSchemaAccepts(schema.items, item));
+  if (schema.type !== "object" || !value || typeof value !== "object" || Array.isArray(value)) return false;
+  const properties = schema.properties || {};
+  if ((schema.required || []).some((key) => !Object.hasOwn(value, key))) return false;
+  if (schema.additionalProperties === false && Object.keys(value).some((key) => !Object.hasOwn(properties, key))) return false;
+  return Object.entries(value).every(([key, item]) => !Object.hasOwn(properties, key) || uiSchemaAccepts(properties[key], item));
+}
+
+function uiSchemaHasPath(schema, parts) {
+  let current = schema;
+  for (const part of parts) {
+    if (!current || typeof current !== "object" || Array.isArray(current)) return false;
+    if (current.type === "array") {
+      current = current.items;
+      if (part === "length") return true;
+      if (/^\d+$/.test(part)) continue;
+    }
+    if (!current || current.type !== "object") return false;
+    const properties = current.properties || {};
+    if (!Object.hasOwn(properties, part)) return current.additionalProperties !== false;
+    current = properties[part];
+  }
+  return true;
+}
+
 function optionalUiTemplate(value, maximum, required = false) {
   if (value === undefined || value === null) {
     if (required) throw new Error("UI text template is required");
@@ -1768,6 +1977,12 @@ function validateKnownBinding(path, stateKeys, sources) {
   const parts = path.split(".");
   if (parts[0] === "state" && (parts.length < 2 || !stateKeys.has(parts[1]))) throw new Error("UI state binding is unknown");
   if (parts[0] === "data" && (parts.length < 2 || !sources.has(parts[1]))) throw new Error("UI data binding is unknown");
+  if (parts[0] === "context") {
+    const roots = new Set(["platform", "screen", "permissions", "connections", "connected", "loading", "errors", "route"]);
+    if (parts.length < 2 || !roots.has(parts[1])) throw new Error("UI runtime context binding is unknown");
+    if (parts[1] === "screen" && (parts.length !== 3 || !["width", "height", "size_class"].includes(parts[2]))) throw new Error("UI screen context binding is unknown");
+    if (["loading", "errors"].includes(parts[1]) && (parts.length !== 3 || !sources.has(parts[2]))) throw new Error("UI data-source context binding is unknown");
+  }
 }
 
 function optionalUiText(value, maximum, { required = false, identifier = false } = {}) {