@almadar/core 8.6.2 → 8.6.3

package/dist/factory/index.d.ts

@@ -181,7 +181,27 @@ interface FactoryConfigParam {
      *  Stays a single free-form string; consumers decide their own
      *  splitting/formatting policy. */
     synonyms?: string;
+    /** Visibility tier authored in `.lolo` as `@tier "..."` next to the
+     *  knob declaration. Drives the studio Questionnaire's filter +
+     *  disclosure: `internal` knobs are hidden entirely, `advanced` knobs
+     *  collapse under a "Show advanced" toggle, `essential` /
+     *  `customization` knobs render inline. Untagged knobs are treated as
+     *  `customization` by the studio (current visible behavior). */
+    tier?: FactoryConfigTier;
 }
+/**
+ * Audience tier for a `FactoryConfigParam`. Source-tagged via the
+ * `@tier "..."` annotation in `.lolo` — no heuristic inference on the
+ * consumer side. Missing tag = author did not tag = treat as
+ * `customization` at render time.
+ *
+ *  - `essential` — every project of this kind needs to answer (app
+ *    name, entity fields, primary nav items).
+ *  - `customization` — meaningful refinement most projects will tweak.
+ *  - `advanced` — sensible defaults; only specialised projects override.
+ *  - `internal` — platform-internal; the studio never surfaces these.
+ */
+type FactoryConfigTier = 'essential' | 'customization' | 'advanced' | 'internal';
 /**
  * One trait the factory composes into the orbital. The projector reads
  * these to determine which factory's trait stack covers a given
@@ -321,66 +341,187 @@ type FactoryParamValue = string | number | boolean | ReadonlyArray<FactoryParamV
 };
 
 /**
- * The per-orbital binding the agent assembles when it picks a
- * signature. Carries the user-authored overrides directly; no shared
- * domain ontology, no DomainDocument.
+ * Typed questionnaire surface — shapes the studio renders + answers.
+ *
+ * Each `DomainQuestion` is one open slot derived deterministically from
+ * a `FactoryCallSite` + its matching `FactorySignature`. The studio
+ * renders the widget keyed off `inputType` (with optional structural
+ * carriers `itemSchema` / `objectSchema` for complex types), and the
+ * user's answer flows through `answersToMutations` into a typed
+ * `FactoryCallPlanMutation`.
+ *
+ * Relocated from `@almadar-io/agent/analysis/questions/` — the
+ * function is a pure transform over `@almadar/core` factory types
+ * and belongs alongside them.
+ *
+ * @packageDocumentation
  */
-interface TranslationBinding {
-    /** Entity name override. When equal to `signature.entities[0].name`,
-     *  no rename is emitted. */
-    entityName: string;
-    /** Extra fields beyond the signature's canonical entity surface. */
-    entityFields?: ReadonlyArray<EntityField>;
-    /** Persistence override. */
-    persistence?: EntityPersistence;
-    /** Collection name override. */
-    collection?: string;
-    /** Per-page path overrides keyed by `signature.pages[i].name`. */
-    pagePaths?: Readonly<Record<string, string>>;
-}
-interface TranslationWarning {
-    /** Dotted path of the binding field that couldn't be lowered. */
-    field: string;
-    /** Human-readable reason. */
+
+/**
+ * One open slot in the questionnaire. The studio renders the question
+ * + input widget keyed off `inputType` + `suggestedAnswers` (and, for
+ * structured types, `itemSchema` / `objectSchema`); the answer fills
+ * the matching `mutationTemplate`.
+ */
+interface DomainQuestion {
+    /** Unique within a session. Keys the answer record. */
+    id: string;
+    /** Natural-language prompt shown to the user. */
+    question: string;
+    /** One short sentence — why this question matters. */
     reason: string;
+    /** Orbital this question scopes to (matches
+     *  `FactoryCallSite.orbital`). */
+    orbitalName: string;
+    /** Free-form capability tag this question explores. Set when the
+     *  question was emitted from a factory trait's `capabilities[]`
+     *  advertisement (e.g. `'privacy'`, `'audit'`). Undefined for
+     *  config-key-driven questions. */
+    capability?: string;
+    /** Drives the form widget. Matches a narrow type set the questionnaire
+     *  UI knows how to render. */
+    inputType: DomainQuestionInputType;
+    /** Typed slot for the answer. `answersToMutations` switches on the
+     *  template's `kind` to produce the matching
+     *  `FactoryCallPlanMutation`. */
+    mutationTemplate: FactoryCallPlanMutationTemplate;
+    /** Canonical default value from the factory signature — the studio
+     *  pre-fills the input, the user can confirm or override. */
+    defaultValue?: DomainQuestionAnswer;
+    /** Closed-enum or curated suggestions. Empty when the input is
+     *  free-form. */
+    suggestedAnswers?: ReadonlyArray<string>;
+    /** Free-text help shown under the input. */
+    helpText?: string;
+    /** Per-element schema for array-of-objects (`listOfObjects`) and
+     *  free-form chip lists (`tagList`). Propagated from
+     *  `FactoryConfigParam.items`. */
+    itemSchema?: EntityField;
+    /** Per-property schema for structured objects (`objectForm`).
+     *  Propagated from `FactoryConfigParam.properties`. */
+    objectSchema?: Readonly<Record<string, EntityField>>;
+    /** Visibility tier propagated from `FactoryConfigParam.tier`.
+     *  Undefined when the source `.lolo` did not author an explicit
+     *  `@tier` annotation — the studio treats undefined as
+     *  `'customization'`. */
+    tier?: FactoryConfigTier;
 }
-interface TranslationResult {
-    callSite: FactoryCallSite;
-    warnings: ReadonlyArray<TranslationWarning>;
-}
-declare function translateOverlaysToParams(binding: TranslationBinding, signature: FactorySignature, presentation?: PresentationOverlay, ruleOverlay?: RuleOverlay, traitOverlay?: TraitOverlay, catalog?: ReadonlyArray<FactorySignature>): TranslationResult;
-
 /**
- * Structural diff between two `FactoryCallSite[]` lists. Pure typed,
- * no side effects. Used by downstream consumers (agent planner, UI
- * cascade view) to turn a "previous calls" + "next calls" pair into a
- * minimal change set.
+ * Narrow set of widget kinds the studio renders.
  *
- * Identity for diffing is `(organism, orbital)`. Renames are not
- * handled here — they show up as a delete + add. The agent layer is
- * expected to merge those back into a `'rename'` op if it can prove
- * the underlying domain entity was renamed.
+ * The derivation in `generate.ts:deriveInputType` reads structural
+ * metadata (`param.items.properties`, `param.properties`,
+ * `param.enumValues`) on top of `param.type` so authors can ship a
+ * `[NavItem]` field and have the studio render a per-element form,
+ * not a JSON textarea.
  */
-
-type CallSiteDiff = {
-    kind: 'add';
+type DomainQuestionInputType = 'text' | 'number' | 'boolean' | 'enum' | 'persistence' | 'capability' | 'multiselect' | 'tagList' | 'fieldList' | 'urlPath' | 'listOfObjects' | 'objectForm';
+/**
+ * One variant per `FactoryCallPlanMutation.kind` the questionnaire
+ * surface supports. Each variant carries the discriminant pieces of
+ * the target mutation that are known at question-generation time
+ * (e.g. the orbital we're editing). The answer fills the remaining
+ * value in `answersToMutations`.
+ */
+type FactoryCallPlanMutationTemplate = {
+    kind: 'set-orbital-entity-name';
     orbitalName: string;
-    next: FactoryCallSite;
 } | {
-    kind: 'delete';
+    kind: 'set-orbital-entity-fields';
     orbitalName: string;
-    prior: FactoryCallSite;
 } | {
-    kind: 'edit';
+    kind: 'set-orbital-persistence';
     orbitalName: string;
-    prior: FactoryCallSite;
-    next: FactoryCallSite;
 } | {
-    kind: 'keep';
+    kind: 'set-orbital-collection';
     orbitalName: string;
-    call: FactoryCallSite;
+} | {
+    kind: 'set-orbital-page-path';
+    orbitalName: string;
+    pageName: string;
+} | {
+    kind: 'set-trait-override-config';
+    orbitalName: string;
+    traitName: string;
+    configKey: string;
+} | {
+    kind: 'add-extra-trait';
+    orbitalName: string;
+} | {
+    kind: 'remove-extra-trait';
+    orbitalName: string;
+} | {
+    kind: 'set-rule';
+    capability: string;
+    appliesTo: ReadonlyArray<string>;
+} | {
+    kind: 'remove-rule';
+    ruleId: string;
 };
-declare function diffFactoryCalls(prior: ReadonlyArray<FactoryCallSite>, next: ReadonlyArray<FactoryCallSite>): ReadonlyArray<CallSiteDiff>;
+/**
+ * Typed answer shape. The studio coerces the input into one of these
+ * before submitting. `answersToMutations` narrows on the matching
+ * `mutationTemplate.kind`.
+ *
+ * `null` means "answer skipped" (UI honours, reducer emits no
+ * mutation).
+ */
+type DomainQuestionAnswer = string | EntityPersistence | ReadonlyArray<EntityField> | TraitReference | FactoryParamValue | null;
+/**
+ * The shape passed to `answersToMutations` — keyed by
+ * `DomainQuestion.id`. Questions the user skipped MAY be omitted
+ * entirely OR carry `null`; both behave the same downstream.
+ */
+type DomainQuestionAnswers = Readonly<Record<string, DomainQuestionAnswer>>;
+
+/**
+ * `generateQuestions(plan, catalog, ruleOverlay?)`.
+ *
+ * Deterministic, no LLM call. Walks each `FactoryCallSite` in the
+ * durable plan against its matching `FactorySignature` and emits one
+ * open question per advertised knob the user hasn't already filled.
+ *
+ * Two families of questions, both source-derived:
+ *
+ *   1. CONFIG-KEY — one question per
+ *      `signature.traits[*].overridableConfigKeys[*]`. Each entry is a
+ *      `FactoryConfigParam` carrying `{ key, type, default?, label?,
+ *      description?, enumValues?, items?, properties?, tier? }` lifted
+ *      directly from the source `.lolo` `config { }` block. The widget
+ *      choice falls out of `deriveInputType` (reads `items.properties`
+ *      and `properties` so structured types render proper editors, not
+ *      JSON textareas); the prompt comes from `label` (or a humanized
+ *      fallback of `key`); the default value pre-fills the widget.
+ *      Knobs tagged `tier: 'internal'` are filtered out entirely.
+ *
+ *   2. CAPABILITY-DRIVEN — one question per unique
+ *      `signature.traits[*].capabilities[*]` tag NOT already covered
+ *      by `ruleOverlay.rules[].capability`. Surfaces a `set-rule`
+ *      mutation template scoped to the bound entity.
+ *
+ * @packageDocumentation
+ */
+
+declare function generateQuestions(plan: ReadonlyArray<FactoryCallSite>, catalog: ReadonlyArray<FactorySignature>, ruleOverlay?: RuleOverlay): DomainQuestion[];
+/**
+ * Pick a widget for a config-key question from the param's typed
+ * declaration + its structural carriers. The type tag is lifted
+ * verbatim from `.lolo`; `items.properties` and `properties` carry the
+ * per-element / per-property schema for structured types so the studio
+ * can render a real form instead of a JSON textarea.
+ *
+ *  - `[T]` with `items.properties` → `listOfObjects` (repeatable form)
+ *  - `[T]` with `enumValues`       → `multiselect` (closed checkboxes)
+ *  - `[T]` otherwise               → `tagList` (free-form chips)
+ *  - `object` with `properties`    → `objectForm` (per-property form)
+ *  - `object` otherwise            → `text` (rare; flagged by tests)
+ *  - `number` / `integer`          → `number`
+ *  - `boolean`                     → `boolean`
+ *  - `enum`                        → `enum`
+ *  - `string` with `enumValues`    → `enum`
+ *  - `string`                      → `text`
+ */
+declare function deriveInputType(param: FactoryConfigParam): DomainQuestionInputType;
 
 /**
  * One slot the agent emits per orbital. Slim shape — agent-facing,
@@ -462,4 +603,79 @@ interface FactoryCallPlanState {
  */
 declare function applyFactoryCallPlanMutation(state: FactoryCallPlanState, m: FactoryCallPlanMutation): FactoryCallPlanState;
 
-export { type CallSiteDiff, type FactoryCallPlanMutation, type FactoryCallPlanState, type FactoryCallSite, type FactoryCallSiteParams, type FactoryConfigParam, type FactoryEntitySignature, type FactoryPageSignature, type FactoryParamValue, type FactorySignature, type FactorySignatureCatalog, type FactorySignatureEntityField, type FactoryTraitSignature, type JsonSchema, type JsonSchemaType, type JsonValue, type OrbitalCallInput, type OwnershipOverlayEntry, type PresentationNavItem, type PresentationOverlay, type RuleOverlay, type RuleOverlayEntry, type SchemaFieldType, type TraitOverlay, type TraitOverlayEntry, type TraitOverlayListener, type TranslationBinding, type TranslationResult, type TranslationWarning, applyFactoryCallPlanMutation, diffFactoryCalls, translateOverlaysToParams };
+/**
+ * `answersToMutations(answers, questions)` — turns a
+ * `DomainQuestionAnswers` record into a typed
+ * `FactoryCallPlanMutation[]`. Each question's `mutationTemplate`
+ * matches one variant of the union; the answer fills in the value.
+ * `null` (or omitted) answers produce no mutation.
+ *
+ * @packageDocumentation
+ */
+
+declare function answersToMutations(answers: DomainQuestionAnswers, questions: ReadonlyArray<DomainQuestion>): FactoryCallPlanMutation[];
+declare function answerToMutations(template: FactoryCallPlanMutationTemplate, answer: DomainQuestionAnswer, _question: DomainQuestion): FactoryCallPlanMutation[];
+
+/**
+ * The per-orbital binding the agent assembles when it picks a
+ * signature. Carries the user-authored overrides directly; no shared
+ * domain ontology, no DomainDocument.
+ */
+interface TranslationBinding {
+    /** Entity name override. When equal to `signature.entities[0].name`,
+     *  no rename is emitted. */
+    entityName: string;
+    /** Extra fields beyond the signature's canonical entity surface. */
+    entityFields?: ReadonlyArray<EntityField>;
+    /** Persistence override. */
+    persistence?: EntityPersistence;
+    /** Collection name override. */
+    collection?: string;
+    /** Per-page path overrides keyed by `signature.pages[i].name`. */
+    pagePaths?: Readonly<Record<string, string>>;
+}
+interface TranslationWarning {
+    /** Dotted path of the binding field that couldn't be lowered. */
+    field: string;
+    /** Human-readable reason. */
+    reason: string;
+}
+interface TranslationResult {
+    callSite: FactoryCallSite;
+    warnings: ReadonlyArray<TranslationWarning>;
+}
+declare function translateOverlaysToParams(binding: TranslationBinding, signature: FactorySignature, presentation?: PresentationOverlay, ruleOverlay?: RuleOverlay, traitOverlay?: TraitOverlay, catalog?: ReadonlyArray<FactorySignature>): TranslationResult;
+
+/**
+ * Structural diff between two `FactoryCallSite[]` lists. Pure typed,
+ * no side effects. Used by downstream consumers (agent planner, UI
+ * cascade view) to turn a "previous calls" + "next calls" pair into a
+ * minimal change set.
+ *
+ * Identity for diffing is `(organism, orbital)`. Renames are not
+ * handled here — they show up as a delete + add. The agent layer is
+ * expected to merge those back into a `'rename'` op if it can prove
+ * the underlying domain entity was renamed.
+ */
+
+type CallSiteDiff = {
+    kind: 'add';
+    orbitalName: string;
+    next: FactoryCallSite;
+} | {
+    kind: 'delete';
+    orbitalName: string;
+    prior: FactoryCallSite;
+} | {
+    kind: 'edit';
+    orbitalName: string;
+    prior: FactoryCallSite;
+    next: FactoryCallSite;
+} | {
+    kind: 'keep';
+    orbitalName: string;
+    call: FactoryCallSite;
+};
+declare function diffFactoryCalls(prior: ReadonlyArray<FactoryCallSite>, next: ReadonlyArray<FactoryCallSite>): ReadonlyArray<CallSiteDiff>;
+
+export { type CallSiteDiff, type DomainQuestion, type DomainQuestionAnswer, type DomainQuestionAnswers, type DomainQuestionInputType, type FactoryCallPlanMutation, type FactoryCallPlanMutationTemplate, type FactoryCallPlanState, type FactoryCallSite, type FactoryCallSiteParams, type FactoryConfigParam, type FactoryConfigTier, type FactoryEntitySignature, type FactoryPageSignature, type FactoryParamValue, type FactorySignature, type FactorySignatureCatalog, type FactorySignatureEntityField, type FactoryTraitSignature, type JsonSchema, type JsonSchemaType, type JsonValue, type OrbitalCallInput, type OwnershipOverlayEntry, type PresentationNavItem, type PresentationOverlay, type RuleOverlay, type RuleOverlayEntry, type SchemaFieldType, type TraitOverlay, type TraitOverlayEntry, type TraitOverlayListener, type TranslationBinding, type TranslationResult, type TranslationWarning, answerToMutations, answersToMutations, applyFactoryCallPlanMutation, deriveInputType, diffFactoryCalls, generateQuestions, translateOverlaysToParams };

package/dist/factory/index.js

@@ -1,3 +1,294 @@
+// src/factory/questions/generate.ts
+function generateQuestions(plan, catalog, ruleOverlay) {
+  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(...capabilityQuestions(call, signature, ruleCapabilities));
+  }
+  return out;
+}
+function configKeyQuestions(call, signature) {
+  const out = [];
+  for (const trait of signature.traits) {
+    for (const param of trait.overridableConfigKeys) {
+      if (param.tier === "internal") continue;
+      if (isAlreadyCustomized(call, trait.name, param.key)) continue;
+      out.push(buildConfigKeyQuestion(call, trait, param));
+    }
+  }
+  return out;
+}
+function buildConfigKeyQuestion(call, trait, param) {
+  const label = param.label ?? humanizeKey(param.key);
+  const question = `${label}?`;
+  const reason = param.description ?? `Customizes "${param.key}" on the ${trait.name} trait. ` + (param.default !== void 0 ? `Default: ${stringifyDefault(param.default)}.` : `No default \u2014 leave blank to inherit the factory's behavior.`);
+  const out = {
+    id: `${call.orbital}.${trait.name}.${param.key}`,
+    orbitalName: call.orbital,
+    question,
+    reason,
+    inputType: deriveInputType(param),
+    mutationTemplate: {
+      kind: "set-trait-override-config",
+      orbitalName: call.orbital,
+      traitName: trait.name,
+      configKey: param.key
+    }
+  };
+  if (param.default !== void 0) {
+    out.defaultValue = param.default;
+  }
+  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;
+  }
+  return out;
+}
+function isAlreadyCustomized(call, traitName, configKey) {
+  const override = call.params.traitOverrides?.[traitName];
+  if (!override?.config) return false;
+  return Object.prototype.hasOwnProperty.call(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 === "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 capabilityQuestions(call, signature, ruleCapabilities) {
+  const entityName = call.params.entityName ?? signature.entities[0]?.name ?? call.orbital;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const trait of signature.traits) {
+    for (const cap of trait.capabilities) {
+      if (seen.has(cap)) continue;
+      seen.add(cap);
+      if (ruleCapabilities.has(cap)) continue;
+      out.push({
+        id: `${call.orbital}.capability.${cap}`,
+        orbitalName: call.orbital,
+        question: capabilityPrompt(cap, entityName),
+        reason: capabilityReason(cap, trait),
+        capability: cap,
+        inputType: "capability",
+        mutationTemplate: {
+          kind: "set-rule",
+          capability: cap,
+          appliesTo: [entityName]
+        },
+        suggestedAnswers: ["yes", "skip"]
+      });
+    }
+  }
+  return out;
+}
+function capabilityPrompt(capability, entity) {
+  return `Should "${capability}" apply to ${entity}?`;
+}
+function capabilityReason(capability, trait) {
+  return `The "${trait.name}" trait advertises capability "${capability}". Answer "yes" to wire a matching 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;
+}
+
+// src/factory/questions/reducer.ts
+var PERSISTENCE_VALUES = [
+  "persistent",
+  "runtime",
+  "singleton",
+  "instance",
+  "local"
+];
+function answersToMutations(answers, questions) {
+  const out = [];
+  for (const q of questions) {
+    const answer = answers[q.id];
+    if (answer === void 0 || answer === null) continue;
+    out.push(...answerToMutations(q.mutationTemplate, answer));
+  }
+  return out;
+}
+function answerToMutations(template, answer, _question) {
+  switch (template.kind) {
+    case "set-orbital-entity-name": {
+      if (typeof answer !== "string" || answer.length === 0) return [];
+      return [
+        {
+          kind: "set-orbital-entity-name",
+          orbitalName: template.orbitalName,
+          name: answer
+        }
+      ];
+    }
+    case "set-orbital-entity-fields": {
+      if (!isEntityFieldArray(answer)) return [];
+      if (answer.length === 0) return [];
+      return [
+        {
+          kind: "set-orbital-entity-fields",
+          orbitalName: template.orbitalName,
+          fields: answer
+        }
+      ];
+    }
+    case "set-orbital-persistence": {
+      if (!isPersistence(answer)) return [];
+      return [
+        {
+          kind: "set-orbital-persistence",
+          orbitalName: template.orbitalName,
+          persistence: answer
+        }
+      ];
+    }
+    case "set-orbital-collection": {
+      if (typeof answer !== "string" || answer.length === 0) return [];
+      return [
+        {
+          kind: "set-orbital-collection",
+          orbitalName: template.orbitalName,
+          collection: answer
+        }
+      ];
+    }
+    case "set-orbital-page-path": {
+      if (typeof answer !== "string" || answer.length === 0) return [];
+      return [
+        {
+          kind: "set-orbital-page-path",
+          orbitalName: template.orbitalName,
+          pageName: template.pageName,
+          path: answer
+        }
+      ];
+    }
+    case "set-trait-override-config": {
+      if (!isFactoryParamValue(answer)) return [];
+      return [
+        {
+          kind: "set-trait-override-config",
+          orbitalName: template.orbitalName,
+          traitName: template.traitName,
+          key: template.configKey,
+          value: answer
+        }
+      ];
+    }
+    case "add-extra-trait": {
+      if (!isTraitReference(answer)) return [];
+      return [
+        {
+          kind: "add-extra-trait",
+          orbitalName: template.orbitalName,
+          trait: answer
+        }
+      ];
+    }
+    case "remove-extra-trait": {
+      if (typeof answer !== "string" || answer.length === 0) return [];
+      return [
+        {
+          kind: "remove-extra-trait",
+          orbitalName: template.orbitalName,
+          ref: answer
+        }
+      ];
+    }
+    case "set-rule": {
+      if (typeof answer !== "string") return [];
+      if (answer !== "yes") return [];
+      const rule = {
+        id: `${template.capability}::${template.appliesTo.join(",")}`,
+        capability: template.capability,
+        description: `User accepted ${template.capability} for ${template.appliesTo.join(", ")}.`,
+        appliesTo: template.appliesTo
+      };
+      return [{ kind: "set-rule", rule }];
+    }
+    case "remove-rule": {
+      return [{ kind: "remove-rule", ruleId: template.ruleId }];
+    }
+  }
+}
+function isEntityFieldArray(a) {
+  if (!Array.isArray(a)) return false;
+  for (const x of a) {
+    if (typeof x !== "object" || x === null) return false;
+    if (!("name" in x) || !("type" in x)) return false;
+    if (typeof x.name !== "string" || typeof x.type !== "string") return false;
+  }
+  return true;
+}
+function isPersistence(a) {
+  return typeof a === "string" && PERSISTENCE_VALUES.includes(a);
+}
+function isFactoryParamValue(a) {
+  if (a === null) return false;
+  const t = typeof a;
+  if (t === "string" || t === "number" || t === "boolean") return true;
+  if (Array.isArray(a)) return true;
+  if (t === "object") return true;
+  return false;
+}
+function isTraitReference(a) {
+  if (typeof a !== "object" || a === null || Array.isArray(a)) return false;
+  if (!("ref" in a)) return false;
+  return typeof a.ref === "string";
+}
+
 // src/factory/translate.ts
 function translateOverlaysToParams(binding, signature, presentation, ruleOverlay, traitOverlay, catalog) {
   const warnings = [];
@@ -145,8 +436,9 @@ function mergeTraitOverride(traitName, entry, trait, params, warnings) {
 }
 function applyRuleOverlay(overlay, signature, binding, catalog, params, warnings) {
   if (!overlay) return;
+  const matchableNames = collectMatchableEntityNames(signature, binding);
   for (const rule of overlay.rules) {
-    if (!ruleAppliesToBinding(rule, binding)) continue;
+    if (!ruleAppliesToAnyName(rule, matchableNames)) continue;
     if (!catalog) {
       warnings.push({
         field: `ruleOverlay.rules.${rule.id}`,
@@ -169,14 +461,25 @@ function applyRuleOverlay(overlay, signature, binding, catalog, params, warnings
   }
   if (overlay.ownership) {
     for (const entry of overlay.ownership) {
-      if (entry.entity !== binding.entityName) continue;
+      if (!matchableNames.includes(entry.entity)) continue;
       applyOwnership(entry, params, signature, catalog, warnings);
     }
   }
 }
-function ruleAppliesToBinding(rule, binding) {
+function collectMatchableEntityNames(signature, binding) {
+  const out = /* @__PURE__ */ new Set();
+  if (binding.entityName.length > 0) out.add(binding.entityName);
+  for (const ent of signature.entities) {
+    if (typeof ent.name === "string" && ent.name.length > 0) out.add(ent.name);
+  }
+  return [...out];
+}
+function ruleAppliesToAnyName(rule, matchableNames) {
   if (rule.appliesTo.length === 0) return true;
-  return rule.appliesTo.includes(binding.entityName);
+  for (const n of rule.appliesTo) {
+    if (matchableNames.includes(n)) return true;
+  }
+  return false;
 }
 function findTraitByCapability(catalog, capability) {
   for (const sig of catalog) {
@@ -433,6 +736,6 @@ function patchOrbital(state, orbitalName, patch) {
   };
 }
 
-export { applyFactoryCallPlanMutation, diffFactoryCalls, translateOverlaysToParams };
+export { answerToMutations, answersToMutations, applyFactoryCallPlanMutation, deriveInputType, diffFactoryCalls, generateQuestions, translateOverlaysToParams };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map