@topogram/cli 0.3.51 → 0.3.52

package/src/validator/kinds.js

@@ -7,7 +7,7 @@ export const STATEMENT_KINDS = new Set([
   "shape",
   "rule",
   "capability",
-  "component",
+  "widget",
   "decision",
   "projection",
   "orchestration",
@@ -148,7 +148,7 @@ export const FIELD_SPECS = {
     required: ["name", "description", "status"],
     allowed: ["name", "description", "actors", "roles", "reads", "creates", "updates", "deletes", "input", "output", "domain", "status"]
   },
-  component: {
+  widget: {
     required: ["name", "description", "props", "status"],
     allowed: ["name", "description", "category", "props", "events", "slots", "behavior", "behaviors", "patterns", "regions", "lookups", "dependencies", "version", "approvals", "status"]
   },
@@ -157,45 +157,45 @@ export const FIELD_SPECS = {
     allowed: ["name", "description", "context", "consequences", "pitch", "supersedes", "domain", "status"]
   },
   projection: {
-    required: ["name", "description", "platform", "realizes", "outputs", "status"],
+    required: ["name", "description", "type", "realizes", "outputs", "status"],
     allowed: [
       "name",
       "description",
-      "platform",
+      "type",
       "realizes",
       "outputs",
-      "http",
-      "http_errors",
-      "http_fields",
-      "http_responses",
-      "http_preconditions",
-      "http_idempotency",
-      "http_cache",
-      "http_delete",
-      "http_async",
-      "http_status",
-      "http_download",
-      "http_authz",
-      "http_callbacks",
-      "ui_screens",
-      "ui_collections",
-      "ui_actions",
-      "ui_visibility",
-      "ui_lookups",
-      "ui_routes",
-      "ui_web",
-      "ui_ios",
-      "ui_app_shell",
-      "ui_navigation",
-      "ui_screen_regions",
-      "ui_components",
-      "ui_design",
-      "db_tables",
-      "db_columns",
-      "db_keys",
-      "db_indexes",
-      "db_relations",
-      "db_lifecycle",
+      "endpoints",
+      "error_responses",
+      "wire_fields",
+      "responses",
+      "preconditions",
+      "idempotency",
+      "cache",
+      "delete_semantics",
+      "async_jobs",
+      "async_status",
+      "downloads",
+      "authorization",
+      "callbacks",
+      "screens",
+      "collection_views",
+      "screen_actions",
+      "visibility_rules",
+      "field_lookups",
+      "screen_routes",
+      "web_hints",
+      "ios_hints",
+      "app_shell",
+      "navigation",
+      "screen_regions",
+      "widget_bindings",
+      "design_tokens",
+      "tables",
+      "columns",
+      "keys",
+      "indexes",
+      "relations",
+      "lifecycle",
       "generator_defaults",
       "status"
     ]

package/src/validator/per-kind/{component.js → widget.js}

@@ -9,7 +9,7 @@ import {
   symbolValues
 } from "../utils.js";
 
-const COMPONENT_CATEGORIES = new Set([
+const WIDGET_CATEGORIES = new Set([
   "collection",
   "form",
   "display",
@@ -21,7 +21,7 @@ const COMPONENT_CATEGORIES = new Set([
   "service"
 ]);
 
-const COMPONENT_BEHAVIOR_KINDS = new Set([
+const WIDGET_BEHAVIOR_KINDS = new Set([
   "selection",
   "sorting",
   "filtering",
@@ -36,7 +36,7 @@ const COMPONENT_BEHAVIOR_KINDS = new Set([
   "keyboard_navigation"
 ]);
 
-const COMPONENT_BEHAVIOR_DIRECTIVES = {
+const WIDGET_BEHAVIOR_DIRECTIVES = {
   selection: new Set(["mode", "state", "emits"]),
   sorting: new Set(["fields", "default"]),
   filtering: new Set(["fields"]),
@@ -66,101 +66,101 @@ function tokenValues(token) {
   return value == null ? [] : [value];
 }
 
-function componentPropNames(statement) {
+function widgetPropNames(statement) {
   return new Set(blockEntries(getFieldValue(statement, "props"))
     .map((entry) => entry.items[0])
     .filter((item) => item?.type === "symbol")
     .map((item) => item.value));
 }
 
-function componentEventNames(statement) {
+function widgetEventNames(statement) {
   return new Set(blockEntries(getFieldValue(statement, "events"))
     .map((entry) => entry.items[0])
     .filter((item) => item?.type === "symbol")
     .map((item) => item.value));
 }
 
-function validateComponentCategory(errors, statement, fieldMap) {
+function validateWidgetCategory(errors, statement, fieldMap) {
   const field = fieldMap.get("category")?.[0];
   if (!field) {
     return;
   }
 
   if (field.value.type !== "symbol") {
-    pushError(errors, `Field 'category' on component ${statement.id} must be a symbol`, field.loc);
+    pushError(errors, `Field 'category' on widget ${statement.id} must be a symbol`, field.loc);
     return;
   }
 
-  if (!COMPONENT_CATEGORIES.has(field.value.value)) {
-    pushError(errors, `Invalid component category '${field.value.value}' on component ${statement.id}`, field.loc);
+  if (!WIDGET_CATEGORIES.has(field.value.value)) {
+    pushError(errors, `Invalid widget category '${field.value.value}' on widget ${statement.id}`, field.loc);
   }
 }
 
-function validateComponentProps(errors, statement) {
+function validateWidgetProps(errors, statement) {
   for (const entry of blockEntries(getFieldValue(statement, "props"))) {
     const [name, type, requiredness, ...rest] = entry.items;
     if (!name || !type || !requiredness) {
-      pushError(errors, `Component ${statement.id} props entries must be '<name> <type> <required|optional> [default <value>]'`, entry.loc);
+      pushError(errors, `Widget ${statement.id} props entries must be '<name> <type> <required|optional> [default <value>]'`, entry.loc);
       continue;
     }
 
     if (name.type !== "symbol" || type.type !== "symbol" || requiredness.type !== "symbol") {
-      pushError(errors, `Component ${statement.id} props entries must start with symbols`, entry.loc);
+      pushError(errors, `Widget ${statement.id} props entries must start with symbols`, entry.loc);
       continue;
     }
 
     if (requiredness.value !== "required" && requiredness.value !== "optional") {
-      pushError(errors, `Component ${statement.id} prop '${name.value}' must use required or optional`, requiredness.loc);
+      pushError(errors, `Widget ${statement.id} prop '${name.value}' must use required or optional`, requiredness.loc);
     }
 
     for (let i = 0; i < rest.length; i += 1) {
       const token = rest[i];
       if (token.type === "symbol" && token.value === "default") {
         if (!rest[i + 1]) {
-          pushError(errors, `Component ${statement.id} prop '${name.value}' default is missing a value`, token.loc);
+          pushError(errors, `Widget ${statement.id} prop '${name.value}' default is missing a value`, token.loc);
         }
         i += 1;
         continue;
       }
-      pushError(errors, `Component ${statement.id} prop '${name.value}' has unsupported directive '${token.value}'`, token.loc);
+      pushError(errors, `Widget ${statement.id} prop '${name.value}' has unsupported directive '${token.value}'`, token.loc);
     }
   }
 }
 
-function validateComponentEvents(errors, statement, registry) {
+function validateWidgetEvents(errors, statement, registry) {
   for (const entry of blockEntries(getFieldValue(statement, "events"))) {
     const [eventName, shapeRef] = entry.items;
     if (!eventName || !shapeRef) {
-      pushError(errors, `Component ${statement.id} events entries must be '<event_name> <shape_id>'`, entry.loc);
+      pushError(errors, `Widget ${statement.id} events entries must be '<event_name> <shape_id>'`, entry.loc);
       continue;
     }
 
     if (eventName.type !== "symbol" || shapeRef.type !== "symbol") {
-      pushError(errors, `Component ${statement.id} events entries must use symbols`, entry.loc);
+      pushError(errors, `Widget ${statement.id} events entries must use symbols`, entry.loc);
       continue;
     }
 
     const target = registry.get(shapeRef.value);
     if (!target) {
-      pushError(errors, `Component ${statement.id} event '${eventName.value}' references missing shape '${shapeRef.value}'`, shapeRef.loc);
+      pushError(errors, `Widget ${statement.id} event '${eventName.value}' references missing shape '${shapeRef.value}'`, shapeRef.loc);
       continue;
     }
     if (target.kind !== "shape") {
-      pushError(errors, `Component ${statement.id} event '${eventName.value}' must reference a shape, found ${target.kind} '${target.id}'`, shapeRef.loc);
+      pushError(errors, `Widget ${statement.id} event '${eventName.value}' must reference a shape, found ${target.kind} '${target.id}'`, shapeRef.loc);
     }
   }
 }
 
-function validateComponentSlots(errors, statement) {
+function validateWidgetSlots(errors, statement) {
   for (const entry of blockEntries(getFieldValue(statement, "slots"))) {
     const [slotName, description] = entry.items;
     if (!slotName || !description) {
-      pushError(errors, `Component ${statement.id} slots entries must be '<slot_name> <description>'`, entry.loc);
+      pushError(errors, `Widget ${statement.id} slots entries must be '<slot_name> <description>'`, entry.loc);
       continue;
     }
 
     if (slotName.type !== "symbol" || (description.type !== "string" && description.type !== "symbol")) {
-      pushError(errors, `Component ${statement.id} slots entries must use a symbol name and string or symbol description`, entry.loc);
+      pushError(errors, `Widget ${statement.id} slots entries must use a symbol name and string or symbol description`, entry.loc);
     }
   }
 }
@@ -173,7 +173,7 @@ function validateSymbolList(errors, statement, fieldMap, key, allowed, label) {
 
   for (const value of symbolValues(field.value)) {
     if (!allowed.has(value)) {
-      pushError(errors, `Component ${statement.id} ${label} '${value}' is not supported`, field.loc);
+      pushError(errors, `Widget ${statement.id} ${label} '${value}' is not supported`, field.loc);
     }
   }
 }
@@ -189,60 +189,60 @@ function validateBehaviorActionReferences(errors, statement, registry, kind, dir
     }
     pushError(
       errors,
-      `Component ${statement.id} behavior '${kind}' references unknown event or capability '${actionId}' for '${directive}'`,
+      `Widget ${statement.id} behavior '${kind}' references unknown event or capability '${actionId}' for '${directive}'`,
       valueToken.loc
     );
   }
 }
 
-function validateComponentBehaviors(errors, statement, fieldMap, registry) {
-  validateSymbolList(errors, statement, fieldMap, "behavior", COMPONENT_BEHAVIOR_KINDS, "behavior");
+function validateWidgetBehaviors(errors, statement, fieldMap, registry) {
+  validateSymbolList(errors, statement, fieldMap, "behavior", WIDGET_BEHAVIOR_KINDS, "behavior");
 
   const field = fieldMap.get("behaviors")?.[0];
   if (!field || field.value.type !== "block") {
     return;
   }
 
-  const propNames = componentPropNames(statement);
-  const eventNames = componentEventNames(statement);
+  const propNames = widgetPropNames(statement);
+  const eventNames = widgetEventNames(statement);
 
   for (const entry of field.value.entries) {
     const [kindToken, ...rest] = entry.items;
     const kind = tokenValue(kindToken);
     if (!kind || kindToken.type !== "symbol") {
-      pushError(errors, `Component ${statement.id} behaviors entries must start with a behavior kind`, entry.loc);
+      pushError(errors, `Widget ${statement.id} behaviors entries must start with a behavior kind`, entry.loc);
       continue;
     }
-    if (!COMPONENT_BEHAVIOR_KINDS.has(kind)) {
-      pushError(errors, `Component ${statement.id} behavior '${kind}' is not supported`, entry.loc);
+    if (!WIDGET_BEHAVIOR_KINDS.has(kind)) {
+      pushError(errors, `Widget ${statement.id} behavior '${kind}' is not supported`, entry.loc);
       continue;
     }
 
-    const allowedDirectives = COMPONENT_BEHAVIOR_DIRECTIVES[kind] || new Set();
+    const allowedDirectives = WIDGET_BEHAVIOR_DIRECTIVES[kind] || new Set();
     for (let i = 0; i < rest.length; i += 2) {
       const directiveToken = rest[i];
       const valueToken = rest[i + 1];
       const directive = tokenValue(directiveToken);
       if (!directive || directiveToken.type !== "symbol") {
-        pushError(errors, `Component ${statement.id} behavior '${kind}' directives must use symbol keys`, entry.loc);
+        pushError(errors, `Widget ${statement.id} behavior '${kind}' directives must use symbol keys`, entry.loc);
         continue;
       }
       if (!valueToken) {
-        pushError(errors, `Component ${statement.id} behavior '${kind}' is missing a value for '${directive}'`, directiveToken.loc);
+        pushError(errors, `Widget ${statement.id} behavior '${kind}' is missing a value for '${directive}'`, directiveToken.loc);
         continue;
       }
       if (!allowedDirectives.has(directive)) {
-        pushError(errors, `Component ${statement.id} behavior '${kind}' has unsupported directive '${directive}'`, directiveToken.loc);
+        pushError(errors, `Widget ${statement.id} behavior '${kind}' has unsupported directive '${directive}'`, directiveToken.loc);
         continue;
       }
 
       if (directive === "state" && !propNames.has(tokenValue(valueToken))) {
-        pushError(errors, `Component ${statement.id} behavior '${kind}' references unknown prop '${tokenValue(valueToken)}' for '${directive}'`, valueToken.loc);
+        pushError(errors, `Widget ${statement.id} behavior '${kind}' references unknown prop '${tokenValue(valueToken)}' for '${directive}'`, valueToken.loc);
       }
       if (directive === "emits") {
         for (const eventName of tokenValues(valueToken)) {
           if (!eventNames.has(eventName)) {
-            pushError(errors, `Component ${statement.id} behavior '${kind}' references unknown event '${eventName}' for '${directive}'`, valueToken.loc);
+            pushError(errors, `Widget ${statement.id} behavior '${kind}' references unknown event '${eventName}' for '${directive}'`, valueToken.loc);
           }
         }
       }
@@ -250,25 +250,25 @@ function validateComponentBehaviors(errors, statement, fieldMap, registry) {
         validateBehaviorActionReferences(errors, statement, registry, kind, directive, valueToken, eventNames);
       }
       if (kind === "selection" && directive === "mode" && !["single", "multi", "none"].includes(tokenValue(valueToken))) {
-        pushError(errors, `Component ${statement.id} behavior 'selection' has invalid mode '${tokenValue(valueToken)}'`, valueToken.loc);
+        pushError(errors, `Widget ${statement.id} behavior 'selection' has invalid mode '${tokenValue(valueToken)}'`, valueToken.loc);
       }
       if (kind === "pagination" && directive === "mode" && !["cursor", "paged", "infinite", "none"].includes(tokenValue(valueToken))) {
-        pushError(errors, `Component ${statement.id} behavior 'pagination' has invalid mode '${tokenValue(valueToken)}'`, valueToken.loc);
+        pushError(errors, `Widget ${statement.id} behavior 'pagination' has invalid mode '${tokenValue(valueToken)}'`, valueToken.loc);
       }
     }
   }
 }
 
-export function validateComponent(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "component") {
+export function validateWidget(errors, statement, fieldMap, registry) {
+  if (statement.kind !== "widget") {
     return;
   }
 
-  validateComponentCategory(errors, statement, fieldMap);
-  validateComponentProps(errors, statement);
-  validateComponentEvents(errors, statement, registry);
-  validateComponentSlots(errors, statement);
-  validateComponentBehaviors(errors, statement, fieldMap, registry);
+  validateWidgetCategory(errors, statement, fieldMap);
+  validateWidgetProps(errors, statement);
+  validateWidgetEvents(errors, statement, registry);
+  validateWidgetSlots(errors, statement);
+  validateWidgetBehaviors(errors, statement, fieldMap, registry);
   validateSymbolList(errors, statement, fieldMap, "patterns", UI_PATTERN_KINDS, "pattern");
   validateSymbolList(errors, statement, fieldMap, "regions", UI_REGION_KINDS, "region");
 }

package/src/{component-behavior.js → widget-behavior.js}

@@ -119,9 +119,9 @@ function behaviorStatus({ hasDirectives, state, emits }) {
 }
 
 /**
- * Build projection-specific realizations for component behavior contracts.
+ * Build projection-specific realizations for widget behavior contracts.
  *
- * Components declare reusable behavior capabilities; projection ui_components
+ * Widgets declare reusable behavior capabilities; projection widget_bindings
  * bindings provide concrete data/event outcomes. This derived contract is the
  * normalized bridge agents and generators can use without inferring behavior
  * from stack code.
@@ -130,7 +130,7 @@ function behaviorStatus({ hasDirectives, state, emits }) {
  * @param {Record<string, any>} usage
  * @returns {Array<Record<string, any>>}
  */
-export function buildComponentBehaviorRealizations(contract, usage) {
+export function buildWidgetBehaviorRealizations(contract, usage) {
   const props = propByName(contract);
   const eventNames = new Set((contract?.events || []).map((event) => event.id).filter(Boolean));
   return (contract?.behaviors || []).map((behavior) => {