@almadar/core 10.129.0 → 11.0.0

package/dist/{chunk-KDMV222Q.js → chunk-F6KHUW7T.js}

@@ -1,7 +1,5 @@
-import { makeLayoutTrait, makeTraitRef, makeOrbitalWithUses, makeSlot } from './chunk-6LR43Z5E.js';
-import { mergeCallSiteConfigOverrides, isInlineTrait, isCallSiteConfigDeclaration, configRefEventKnob, resolveConfigRefEventName } from './chunk-45I2O4SJ.js';
-import { persistenceModeAllowsOverrides, UI_SLOTS } from './chunk-GTY53NS5.js';
-import { getAllPatternTypes, controlBody } from './chunk-QUOTJULD.js';
+import { NUM_WIDTH_TAGS, persistenceModeAllowsOverrides, UI_SLOTS } from './chunk-FGT5OS2Y.js';
+import { getAllPatternTypes } from './chunk-MGLG2XLD.js';
 
 // src/factory/knob-defs.ts
 function rehydrateKnobDefs(catalog) {
@@ -34,6 +32,304 @@ function rehydrateKnobDefs(catalog) {
   return catalog;
 }
 
+// src/factory/questions/generate.ts
+function generateQuestions(plan, catalog, ruleOverlay, _userPrompt) {
+  const out = [];
+  const ruleCapabilities = collectRuleCapabilities(ruleOverlay);
+  for (const call of plan) {
+    const signature = findSignature(catalog, call.organism, call.orbital);
+    if (!signature) continue;
+    out.push(...configKeyQuestions(call, signature));
+    out.push(...entityFieldQuestions(call, signature));
+    out.push(...capabilityQuestions(call, signature, ruleCapabilities));
+  }
+  return out;
+}
+var TIER_D_NAMED_PRIMITIVES = /* @__PURE__ */ new Set([
+  "layoutMode",
+  "layoutPattern",
+  "viewPattern",
+  "detailPattern",
+  "detailSlot",
+  "contentTrait"
+]);
+var TIER_D_TYPES = /* @__PURE__ */ new Set(["trait", "slot", "pattern", "event"]);
+function configKeyQuestions(call, signature) {
+  const out = [];
+  for (const trait of signature.traits) {
+    for (const param of trait.overridableConfigKeys) {
+      if (param.tier === "internal") continue;
+      if (TIER_D_TYPES.has(param.type)) continue;
+      if (TIER_D_NAMED_PRIMITIVES.has(param.key)) continue;
+      out.push(buildConfigKeyQuestion(call, trait, param));
+    }
+  }
+  return out;
+}
+function buildConfigKeyQuestion(call, trait, param) {
+  const question = param.label ?? humanizeKey(param.key);
+  const callSiteOverride = callSiteOverrideValue(call, trait.name, param.key);
+  const effectiveDefault = callSiteOverride !== void 0 ? callSiteOverride : param.default;
+  const helpText = param.description;
+  const syntheticReason = `Customizes "${param.key}" on the ${trait.name} trait. ` + (effectiveDefault !== void 0 ? `Default: ${stringifyDefault(effectiveDefault)}.` : `No default \u2014 leave blank to inherit the factory's behavior.`);
+  const reason = helpText !== void 0 ? void 0 : syntheticReason;
+  const isAdvanced = !isPrimaryTier(param.tier);
+  const out = {
+    id: `${factoryCallPlanOrbitalName(call)}.${trait.name}.${param.key}`,
+    orbitalName: factoryCallPlanOrbitalName(call),
+    question,
+    inputType: deriveInputType(param),
+    mutationTemplate: {
+      kind: "set-trait-override-config",
+      orbitalName: factoryCallPlanOrbitalName(call),
+      traitName: trait.name,
+      configKey: param.key
+    }
+  };
+  if (reason !== void 0) {
+    out.reason = reason;
+  }
+  if (helpText !== void 0) {
+    out.helpText = helpText;
+  }
+  if (effectiveDefault !== void 0) {
+    out.defaultValue = effectiveDefault;
+  }
+  if (param.enumValues && param.enumValues.length > 0) {
+    out.suggestedAnswers = param.enumValues;
+  }
+  if (param.items) {
+    out.itemSchema = param.items;
+  }
+  if (param.properties) {
+    out.objectSchema = param.properties;
+  }
+  if (param.tier) {
+    out.tier = param.tier;
+  }
+  if (isAdvanced) {
+    out.advanced = true;
+  }
+  const weight = tierWeight(param.tier);
+  out.weight = weight;
+  out.priority = weight;
+  return out;
+}
+function tierWeight(tier) {
+  switch (tier) {
+    case "domain":
+    case "policy":
+      return 3;
+    case "infra":
+      return 2;
+    case "internal":
+      return 0;
+    case "presentation":
+    default:
+      return 1;
+  }
+}
+function isPrimaryTier(tier) {
+  return tier === "domain" || tier === "policy";
+}
+function callSiteOverrideValue(call, traitName, configKey) {
+  const override = call.params.traitOverrides?.[traitName];
+  if (!override?.config) return void 0;
+  if (!Object.prototype.hasOwnProperty.call(override.config, configKey)) {
+    return void 0;
+  }
+  return override.config[configKey];
+}
+function deriveInputType(param) {
+  if (param.type.startsWith("[")) {
+    if (param.items?.properties && Object.keys(param.items.properties).length > 0) {
+      return "listOfObjects";
+    }
+    if (param.enumValues && param.enumValues.length > 0) {
+      return "multiselect";
+    }
+    return "tagList";
+  }
+  if (param.type.startsWith("Map<")) {
+    return "objectForm";
+  }
+  if (param.type === "object") {
+    if (param.properties && Object.keys(param.properties).length > 0) {
+      return "objectForm";
+    }
+    return "text";
+  }
+  switch (param.type) {
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "enum":
+      return "enum";
+    case "string":
+      return param.enumValues && param.enumValues.length > 0 ? "enum" : "text";
+    default:
+      return "text";
+  }
+}
+function humanizeKey(key) {
+  const parts = key.replace(/[-_]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(" ").filter((s) => s.length > 0);
+  return parts.map((p) => /^[A-Z]+$/.test(p) ? p : p.charAt(0).toUpperCase() + p.slice(1)).join(" ");
+}
+function stringifyDefault(v) {
+  if (typeof v === "string") return JSON.stringify(v);
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  if (Array.isArray(v)) return `${v.length} item${v.length === 1 ? "" : "s"}`;
+  return "object";
+}
+function entityFieldQuestions(call, signature) {
+  if (signature.entities.length === 0) return [];
+  const entity = signature.entities[0];
+  const entityName = call.params.entityName ?? entity.name;
+  const candidateFields = entity.fields.map(signatureFieldToEntityField);
+  const fieldCandidates = {};
+  const fieldDescriptions = {};
+  const candidateNames = [];
+  for (let i = 0; i < entity.fields.length; i++) {
+    const sig = entity.fields[i];
+    const ef = candidateFields[i];
+    const name = sig.name;
+    candidateNames.push(name);
+    fieldCandidates[name] = ef;
+    if (sig.description) {
+      fieldDescriptions[name] = sig.description;
+    }
+  }
+  const weight = tierWeight("domain");
+  const q = {
+    id: `${factoryCallPlanOrbitalName(call)}.__entityFields`,
+    orbitalName: factoryCallPlanOrbitalName(call),
+    question: `Fields for ${entityName}`,
+    reason: `Defines the data model for ${entityName}. Pick the fields that matter for your use case.`,
+    inputType: "multiselect",
+    mutationTemplate: {
+      kind: "set-orbital-entity-fields",
+      orbitalName: factoryCallPlanOrbitalName(call)
+    },
+    suggestedAnswers: candidateNames,
+    defaultValue: candidateNames,
+    fieldCandidates,
+    tier: "domain",
+    weight,
+    priority: weight
+  };
+  if (Object.keys(fieldDescriptions).length > 0) {
+    q.fieldDescriptions = fieldDescriptions;
+  }
+  return [q];
+}
+function signatureFieldToEntityField(f) {
+  const base = {
+    name: f.name,
+    required: f.required,
+    description: f.description,
+    synonyms: f.synonyms,
+    intrinsic: f.intrinsic
+  };
+  switch (f.type) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "date":
+    case "timestamp":
+    case "datetime":
+    // Semantic string domains carry no dependent payload, so they pass through
+    // as-is and the question widget narrows the input accordingly.
+    case "email":
+    case "url":
+    case "phone":
+    case "uuid":
+    case "image":
+      return { ...base, type: f.type };
+    case "array":
+      return { ...base, type: "array" };
+    case "object":
+      return { ...base, type: "object" };
+    case "enum":
+      if (Array.isArray(f.values) && f.values.length > 0) {
+        return { ...base, type: "enum", values: f.values };
+      }
+      return { ...base, type: "string" };
+    case "relation":
+      if (f.relation !== void 0) {
+        return { ...base, type: "relation", relation: f.relation };
+      }
+      return { ...base, type: "string" };
+    case "node":
+      return { ...base, type: "node" };
+    case "event":
+      return { ...base, type: "event" };
+    case "money":
+    case "instant":
+    case "file":
+    case "bytes":
+      return { ...base, type: f.type };
+    default: {
+      f.type;
+      return { ...base, type: "string" };
+    }
+  }
+}
+function capabilityQuestions(call, signature, ruleCapabilities) {
+  const entityName = call.params.entityName ?? signature.entities[0]?.name ?? factoryCallPlanOrbitalName(call);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const trait of signature.traits) {
+    const policyKnobKeys = new Set(
+      trait.overridableConfigKeys.filter((p) => p.tier === "policy").map((p) => p.key)
+    );
+    for (const cap of trait.capabilities) {
+      if (seen.has(cap)) continue;
+      seen.add(cap);
+      if (ruleCapabilities.has(cap)) continue;
+      if (policyKnobKeys.has(cap)) continue;
+      out.push({
+        id: `${factoryCallPlanOrbitalName(call)}.capability.${cap}`,
+        orbitalName: factoryCallPlanOrbitalName(call),
+        question: capabilityPrompt(cap, entityName),
+        helpText: capabilityHelp(cap, trait),
+        capability: cap,
+        inputType: "boolean",
+        mutationTemplate: {
+          kind: "set-rule",
+          capability: cap,
+          appliesTo: [entityName]
+        },
+        // Capabilities encode governance/policy decisions — high impact.
+        weight: 3,
+        priority: 3
+      });
+    }
+  }
+  return out;
+}
+function capabilityPrompt(capability, entity) {
+  const label = humanizeKey(capability);
+  return `Enable ${label} for ${entity}?`;
+}
+function capabilityHelp(capability, trait) {
+  return `Turns on the "${capability}" behavior from the ${trait.name} trait. Say yes to wire a governance rule into the schema.`;
+}
+function findSignature(catalog, organism, orbital) {
+  return catalog.find((s) => s.organism === organism && s.orbital === orbital);
+}
+function collectRuleCapabilities(overlay) {
+  const out = /* @__PURE__ */ new Set();
+  for (const r of overlay?.rules ?? []) {
+    if (typeof r.capability === "string") out.add(r.capability);
+  }
+  return out;
+}
+function factoryCallPlanOrbitalName(call) {
+  return call.orbitalName ?? call.orbital;
+}
+
 // src/factory/questions/reducer.ts
 var PERSISTENCE_VALUES = [
   "persistent",
@@ -671,6 +967,7 @@ var SCALAR_FIELD_TYPES = [
   "string",
   "number",
   "int",
+  ...NUM_WIDTH_TAGS,
   "boolean",
   "date",
   "timestamp",
@@ -822,372 +1119,6 @@ var PAGE_OVERRIDE_SCHEMA = {
   }
 };
 
-// src/factory/composition.ts
-function eventNamer(contract, config) {
-  const effective = {};
-  for (const [knob, field] of Object.entries(contract.declaredConfig ?? {})) {
-    const override = config?.[knob];
-    if (typeof override === "string") effective[knob] = override;
-    else if (field.default !== void 0) effective[knob] = field.default;
-  }
-  return (event) => {
-    if (configRefEventKnob(event) === void 0) return event;
-    const r = resolveConfigRefEventName(event, contract.declaredConfig, effective);
-    return r.ok ? r.value : void 0;
-  };
-}
-function followEventName(contract, side, name, fromConfig, toConfig) {
-  const before = eventNamer(contract, fromConfig);
-  const after = eventNamer(contract, toConfig);
-  const sources = contract[side].filter((e) => before(e) === name);
-  if (sources.length === 0) return { ok: true, value: name };
-  const values = [...new Set(sources.flatMap((e) => after(e) ?? []))];
-  if (values.length > 1) return { ok: false, message: `${name} comes from ${sources.join(", ")}, which this block names differently (${values.join(", ")}) \u2014 wire one of those names` };
-  return { ok: true, value: values[0] };
-}
-function resolveBlockContract(contract, config) {
-  const unresolved = [];
-  const named = eventNamer(contract, config);
-  const resolve = (event) => {
-    const v = named(event);
-    if (v === void 0 && !unresolved.includes(event)) unresolved.push(event);
-    return v;
-  };
-  const names = (events) => events.flatMap((e) => {
-    const v = resolve(e);
-    return v === void 0 ? [] : [v];
-  });
-  const listens = contract.listens.flatMap((l) => {
-    const event = resolve(l.event);
-    const triggers = resolve(l.triggers);
-    return event === void 0 || triggers === void 0 ? [] : [{ ...l, event, triggers }];
-  });
-  return { contract: { ...contract, emits: names(contract.emits), triggers: names(contract.triggers), listens }, unresolved };
-}
-function bindsRecord(contract, record) {
-  return contract.entityRebindable || contract.linkedEntity === void 0 || contract.linkedEntity === record;
-}
-function placedBlocks(node, out) {
-  if (node.kind === "block") out.push(node.block);
-  else for (const child of node.children) placedBlocks(child, out);
-}
-function checkComposition(spec, ctx) {
-  const issues = [];
-  if (spec.entity.kind === "declare" && spec.entity.entity.persistence === "persistent" && !spec.entity.entity.collection) {
-    issues.push({ code: "missing-collection", path: "entity.collection", message: `persistent entity ${spec.entity.entity.name} declares no collection` });
-  }
-  const contracts = /* @__PURE__ */ new Map();
-  const names = /* @__PURE__ */ new Set();
-  const aliases = /* @__PURE__ */ new Map();
-  if (spec.entity.kind === "import") aliases.set(spec.entity.as, spec.entity.from);
-  for (const b of spec.blocks) {
-    const at = `blocks.${b.name}`;
-    if (names.has(b.name)) issues.push({ code: "duplicate-name", path: at, message: `two blocks are named "${b.name}"` });
-    names.add(b.name);
-    const prior = aliases.get(b.as);
-    if (prior !== void 0 && prior !== b.from) {
-      issues.push({ code: "alias-conflict", path: `${at}.as`, message: `alias "${b.as}" already names ${prior}` });
-    }
-    aliases.set(b.as, b.from);
-    const contract = ctx.block(b.from, b.trait);
-    if (contract === null) {
-      issues.push({ code: "unknown-block", path: at, message: `${b.from} declares no trait ${b.trait}` });
-      continue;
-    }
-    contracts.set(b.name, resolveBlockContract(contract, b.config).contract);
-    for (const key of Object.keys(b.config ?? {})) {
-      if (!contract.configKeys.includes(key)) {
-        issues.push({ code: "unknown-config-key", path: `${at}.config.${key}`, message: `${b.trait} declares no knob "${key}" (declares: ${contract.configKeys.join(", ")})` });
-      }
-    }
-    const recordName = spec.entity.kind === "import" ? spec.entity.entity : spec.entity.entity.name;
-    if (!bindsRecord(contract, recordName)) {
-      issues.push({
-        code: "entity-mismatch",
-        path: at,
-        message: `${b.trait} is bound to the record "${contract.linkedEntity}" and cannot be rebound \u2014 name this page's record "${contract.linkedEntity}" or use another part`
-      });
-    }
-    if (b.linkedEntity !== void 0 && !contract.entityRebindable) {
-      issues.push({ code: "not-rebindable", path: `${at}.linkedEntity`, message: `${b.trait} has a fixed entity binding` });
-    }
-  }
-  for (const b of spec.blocks) {
-    const declared = ctx.block(b.from, b.trait)?.declaredConfig ?? {};
-    for (const [key, value] of Object.entries(b.config ?? {})) {
-      if (declared[key]?.type !== "trait" || typeof value !== "string") continue;
-      const target = value.startsWith("@trait.") ? value.slice("@trait.".length) : void 0;
-      if (target === void 0 || !names.has(target)) {
-        issues.push({
-          code: "unknown-trait-ref",
-          path: `blocks.${b.name}.config.${key}`,
-          message: `${key} must be "@trait.<block>" naming a block of this composition (${[...names].join(", ")}), got "${value}"`
-        });
-      }
-    }
-  }
-  const keptNames = /* @__PURE__ */ new Set();
-  for (const k of spec.kept ?? []) {
-    if (names.has(k.name) || keptNames.has(k.name)) issues.push({ code: "duplicate-name", path: `kept.${k.name}`, message: `two parts are named "${k.name}"` });
-    keptNames.add(k.name);
-  }
-  const placed = [];
-  placedBlocks(spec.layout, placed);
-  for (const p of placed) {
-    if (!names.has(p) && !keptNames.has(p)) issues.push({ code: "layout-unknown-block", path: `layout.${p}`, message: `the layout places "${p}", which is not a block` });
-  }
-  const slotted = /* @__PURE__ */ new Set();
-  const collectSlots = (v) => {
-    if (typeof v === "string") {
-      if (v.startsWith("@trait.")) slotted.add(v.slice("@trait.".length));
-    } else if (Array.isArray(v)) {
-      for (const x of v) collectSlots(x);
-    } else if (typeof v === "object" && v !== null) {
-      for (const x of Object.values(v)) collectSlots(x);
-    }
-  };
-  for (const b of spec.blocks) for (const v of Object.values(b.config ?? {})) collectSlots(v);
-  for (const b of spec.blocks) {
-    if (!placed.includes(b.name) && !slotted.has(b.name)) issues.push({ code: "unplaced-block", path: `blocks.${b.name}`, message: `"${b.name}" is not placed in the layout` });
-  }
-  for (const [i, w] of (spec.wiring ?? []).entries()) {
-    const at = `wiring.${i}`;
-    const src = contracts.get(w.fromBlock);
-    const dst = contracts.get(w.toBlock);
-    if (!names.has(w.fromBlock) || !names.has(w.toBlock)) {
-      issues.push({ code: "unknown-wire-block", path: at, message: `wire ${w.fromBlock} \u2192 ${w.toBlock} names a missing block` });
-      continue;
-    }
-    if (src !== void 0 && !src.emits.includes(w.event)) {
-      issues.push({ code: "unknown-event", path: `${at}.event`, message: `${w.fromBlock} does not emit ${w.event} (emits: ${src.emits.join(", ")})` });
-    }
-    if (dst !== void 0 && !dst.triggers.includes(w.trigger)) {
-      issues.push({ code: "unknown-trigger", path: `${at}.trigger`, message: `${w.toBlock} handles no ${w.trigger} (handles: ${dst.triggers.join(", ")})` });
-    }
-  }
-  return issues;
-}
-function layoutTree(node) {
-  if (node.kind === "block") return makeSlot(node.block);
-  return {
-    type: "stack",
-    ...node.direction !== void 0 ? { direction: node.direction } : {},
-    ...node.gap !== void 0 ? { gap: node.gap } : {},
-    ...node.align !== void 0 ? { align: node.align } : {},
-    ...node.justify !== void 0 ? { justify: node.justify } : {},
-    ...node.className !== void 0 ? { className: node.className } : {},
-    children: node.children.map(layoutTree)
-  };
-}
-function entityName(e) {
-  return e.kind === "import" ? e.entity : e.entity.name;
-}
-function assembleComposition(spec, ctx) {
-  const issues = checkComposition(spec, ctx);
-  if (issues.length > 0) return { ok: false, issues };
-  const entity = entityName(spec.entity);
-  const uses = [];
-  const seen = /* @__PURE__ */ new Set();
-  const addUse = (from, as) => {
-    if (seen.has(as)) return;
-    seen.add(as);
-    uses.push({ from, as });
-  };
-  if (spec.entity.kind === "import") addUse(spec.entity.from, spec.entity.as);
-  for (const b of spec.blocks) addUse(b.from, b.as);
-  const root = layoutTree(spec.layout);
-  const viewName = `${spec.orbital}View`;
-  const view = makeLayoutTrait({
-    name: viewName,
-    linkedEntity: entity,
-    renderUI: typeof root === "string" ? { type: "stack", children: [root] } : root
-  });
-  const blockTraits = spec.blocks.map((b) => {
-    const declared = ctx.block(b.from, b.trait);
-    const contract = declared !== null ? resolveBlockContract(declared, b.config).contract : null;
-    const wires = (spec.wiring ?? []).filter((w) => w.toBlock === b.name);
-    const listens = wires.length > 0 && contract !== null ? [
-      ...contract.listens,
-      ...wires.map((w) => ({ event: w.event, triggers: w.trigger, source: { kind: "trait", trait: w.fromBlock } }))
-    ] : void 0;
-    const rebind = b.linkedEntity ?? (contract?.entityRebindable === true ? entity : void 0);
-    return makeTraitRef({
-      ref: `${b.as}.traits.${b.trait}`,
-      name: b.name,
-      ...rebind !== void 0 ? { linkedEntity: rebind } : {},
-      ...b.config !== void 0 ? { config: mergeCallSiteConfigOverrides({}, b.config) } : {},
-      ...listens !== void 0 ? { listens } : {}
-    });
-  });
-  if (spec.entity.kind === "import") {
-    const e = spec.entity;
-    const orbital = {
-      ...makeOrbitalWithUses({ name: spec.orbital, uses, entity: `${e.as}.orbitals.${e.orbital}.entity`, traits: [view, ...blockTraits, ...spec.kept ?? []] }),
-      reference: {
-        ref: `${e.as}.orbitals.${e.orbital}`,
-        entity: e.entity,
-        ...e.only !== void 0 ? { only: [...e.only] } : {},
-        pages: { [e.page]: spec.page.path },
-        mounts: { [e.page]: [viewName] }
-      }
-    };
-    return { ok: true, orbital };
-  }
-  return {
-    ok: true,
-    orbital: makeOrbitalWithUses({
-      name: spec.orbital,
-      uses,
-      entity: spec.entity.entity,
-      traits: [view, ...blockTraits, ...spec.kept ?? []],
-      pages: [{ name: spec.page.name, path: spec.page.path, traits: [{ ref: viewName }] }]
-    })
-  };
-}
-function blockContractOf(trait, orbitalEntity) {
-  const triggers = [];
-  for (const t of trait.stateMachine?.transitions ?? []) if (!triggers.includes(t.event)) triggers.push(t.event);
-  const sets = /* @__PURE__ */ new Set();
-  const visitEffect = (effect) => {
-    if (!Array.isArray(effect)) return;
-    if (effect[0] === "set" && typeof effect[1] === "string" && effect[1].startsWith("@entity.")) {
-      const field = effect[1].slice("@entity.".length).split(".")[0];
-      if (field !== void 0 && field.length > 0) sets.add(field);
-    }
-    for (const child of controlBody(effect)) visitEffect(child);
-  };
-  for (const t of trait.stateMachine?.transitions ?? []) for (const e of t.effects ?? []) visitEffect(e);
-  const linkedEntity = trait.linkedEntity ?? orbitalEntity;
-  return {
-    configKeys: Object.keys(trait.config ?? {}),
-    ...trait.config !== void 0 ? { declaredConfig: trait.config } : {},
-    emits: (trait.emits ?? []).map((e) => e.event),
-    triggers,
-    listens: trait.listens ?? [],
-    entityRebindable: trait.entityRebindable === true,
-    setsFields: [...sets],
-    ...linkedEntity !== void 0 ? { linkedEntity } : {}
-  };
-}
-function toParamValue(value) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
-  if (Array.isArray(value)) {
-    const out = [];
-    for (const v of value) {
-      const p = toParamValue(v);
-      if (p !== void 0) out.push(p);
-    }
-    return out;
-  }
-  if (typeof value === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-      const p = toParamValue(v);
-      if (p !== void 0) out[k] = p;
-    }
-    return out;
-  }
-  return void 0;
-}
-function decomposeOrbital(orbital) {
-  const fromOf = new Map((orbital.uses ?? []).map((u) => [u.as, u.from]));
-  const blocks = [];
-  for (const t of orbital.traits) {
-    if (typeof t === "string" || isInlineTrait(t)) continue;
-    const m = /^([A-Za-z_]\w*)\.traits\.([A-Za-z_]\w*)$/.exec(t.ref);
-    if (m === null) continue;
-    const from = fromOf.get(m[1]);
-    if (from === void 0) continue;
-    const config = {};
-    for (const [key, entry] of Object.entries(t.config ?? {})) {
-      const value = toParamValue(isCallSiteConfigDeclaration(entry) ? entry.default : entry);
-      if (value !== void 0) config[key] = value;
-    }
-    blocks.push({
-      name: t.name ?? m[2],
-      from,
-      as: m[1],
-      trait: m[2],
-      ...t.linkedEntity !== void 0 ? { linkedEntity: t.linkedEntity } : {},
-      ...Object.keys(config).length > 0 ? { config } : {}
-    });
-  }
-  return blocks;
-}
-function isTraitRefObject(t) {
-  return typeof t !== "string" && !isInlineTrait(t) && "ref" in t;
-}
-function refListens(t) {
-  return t.listens ?? [];
-}
-function sameListen(a, b) {
-  const src = (l) => l.source?.kind === "trait" ? `trait:${l.source.trait}` : JSON.stringify(l.source ?? null);
-  return a.event === b.event && a.triggers === b.triggers && src(a) === src(b);
-}
-function compositionSpecOf(orbital, ctx, chromeRefs) {
-  const kept = [];
-  for (const t of orbital.traits) {
-    if (typeof t === "string") return { ok: false, reason: `trait "${t}" is a bare name, not a block reference` };
-    if (isInlineTrait(t)) kept.push(t);
-  }
-  const refs = orbital.traits.filter(isTraitRefObject);
-  const chromeNames = new Set(refs.filter((t) => chromeRefs.has(t.ref)).map((t) => t.name ?? t.ref));
-  const blocks = decomposeOrbital(orbital).filter((b) => !chromeRefs.has(`${b.as}.traits.${b.trait}`));
-  if (blocks.length !== refs.length - chromeNames.size) {
-    return { ok: false, reason: "a trait reference names no `uses` alias" };
-  }
-  const names = new Set(blocks.map((b) => b.name));
-  const wiring = [];
-  for (const block of blocks) {
-    const ref = refs.find((t) => (t.name ?? "") === block.name || t.name === void 0 && t.ref.endsWith(`.traits.${block.name}`));
-    const contract = ctx.block(block.from, block.trait);
-    const own = contract !== null ? resolveBlockContract(contract, block.config).contract.listens : [];
-    const listens = ref !== void 0 ? refListens(ref) : [];
-    for (const l of listens) {
-      if (l.source?.kind !== "trait" || !names.has(l.source.trait) || own.some((o) => sameListen(o, l))) continue;
-      wiring.push({ fromBlock: l.source.trait, event: l.event, toBlock: block.name, trigger: l.triggers });
-    }
-  }
-  let entity;
-  let page;
-  let order;
-  if (typeof orbital.entity === "object" && !("extends" in orbital.entity)) {
-    entity = { kind: "declare", entity: orbital.entity };
-    const first = (orbital.pages ?? []).find((p) => typeof p !== "string" && !("ref" in p) && typeof p.path === "string");
-    if (first === void 0 || typeof first === "string" || "ref" in first) return { ok: false, reason: "the orbital has no inline page" };
-    page = { name: first.name, path: first.path };
-    order = (first.traits ?? []).flatMap((t) => typeof t === "string" ? [t] : "ref" in t && typeof t.ref === "string" ? [t.ref] : []);
-  } else {
-    const reference = orbital.reference;
-    const m = reference !== void 0 ? /^([A-Za-z_]\w*)\.orbitals\.([A-Za-z_]\w*)$/.exec(reference.ref) : null;
-    const from = m !== null ? (orbital.uses ?? []).find((u) => u.as === m[1])?.from : void 0;
-    const mounted = Object.entries(reference?.mounts ?? {})[0];
-    if (reference === void 0 || m === null || from === void 0 || reference.entity === void 0 || mounted === void 0) {
-      return { ok: false, reason: "the orbital neither declares its entity nor imports one with a mounted page" };
-    }
-    const [upstream, traits] = mounted;
-    entity = { kind: "import", from, as: m[1], orbital: m[2], entity: reference.entity, page: upstream, ...reference.only !== void 0 ? { only: [...reference.only] } : {} };
-    page = { name: `${orbital.name}Page`, path: reference.pages?.[upstream] ?? upstream };
-    order = [...traits];
-  }
-  const keptNames = new Set(kept.map((k) => k.name));
-  const placed = order.filter((n) => names.has(n) || keptNames.has(n));
-  for (const b of blocks) if (!placed.includes(b.name)) placed.push(b.name);
-  return {
-    ok: true,
-    spec: {
-      orbital: orbital.name,
-      entity,
-      blocks,
-      layout: { kind: "stack", direction: "vertical", children: placed.map((block) => ({ kind: "block", block })) },
-      wiring,
-      page,
-      ...kept.length > 0 ? { kept } : {}
-    }
-  };
-}
-
-export { ENTITY_FIELD_SCHEMA, answerToMutations, answersToMutations, applyFactoryCallPlanMutation, assembleComposition, assertNoUnsatisfiableEnum, bindsRecord, blockContractOf, checkComposition, compositionSpecOf, decomposeOrbital, followEventName, mapEntityFieldType, rehydrateKnobDefs, resolveBlockContract, signatureToParamsSchema };
-//# sourceMappingURL=chunk-KDMV222Q.js.map
-//# sourceMappingURL=chunk-KDMV222Q.js.map
+export { ENTITY_FIELD_SCHEMA, answerToMutations, answersToMutations, applyFactoryCallPlanMutation, assertNoUnsatisfiableEnum, deriveInputType, factoryCallPlanOrbitalName, generateQuestions, humanizeKey, rehydrateKnobDefs, signatureToParamsSchema };
+//# sourceMappingURL=chunk-F6KHUW7T.js.map
+//# sourceMappingURL=chunk-F6KHUW7T.js.map