@almadar/core 8.0.0 → 8.2.0

package/dist/builders.d.ts

@@ -1,7 +1,7 @@
-import { bL as UISlot, t as Effect, bg as Trait, aC as RenderUIEffect, bs as TraitEventContract, y as Entity, bu as TraitEventListener, bj as TraitConfig, B as EntityField, H as EntityPersistence, L as EntityRow, bx as TraitRef, bz as TraitReference } from './trait-BPe356_9.js';
-import { aA as UseDeclaration, B as EntityRef, ab as PageRef, X as OrbitalDefinition, a3 as OrbitalSchema, aa as Page, ac as PageRefObject } from './schema-Bg4qX43l.js';
+import { bK as UISlot, t as Effect, bg as Trait, aC as RenderUIEffect, bs as TraitEventContract, y as Entity, bu as TraitEventListener, bj as TraitConfig, B as EntityField, H as EntityPersistence, L as EntityRow, bx as TraitRef, bz as TraitReference } from './trait-g5-2JR48.js';
+import { aA as UseDeclaration, B as EntityRef, ab as PageRef, X as OrbitalDefinition, a3 as OrbitalSchema, aa as Page, ac as PageRefObject } from './schema-Cov1FvVJ.js';
 import { S as SExpr } from './expression-BVRFm0sV.js';
-export { C as ComposeBehaviorsInput, a as ComposeBehaviorsResult, E as EventWiringEntry, L as LayoutStrategy, b as applyEventWiring, c as composeBehaviors, d as detectLayoutStrategy } from './compose-behaviors-Bq8tdeBU.js';
+export { C as ComposeBehaviorsInput, a as ComposeBehaviorsResult, E as EventWiringEntry, L as LayoutStrategy, b as applyEventWiring, c as composeBehaviors, d as detectLayoutStrategy } from './compose-behaviors-DsgVjsAB.js';
 import { AnyPatternConfig } from '@almadar/patterns';
 import 'zod';
 

package/dist/{compose-behaviors-Bq8tdeBU.d.ts → compose-behaviors-DsgVjsAB.d.ts}

@@ -1,4 +1,4 @@
-import { X as OrbitalDefinition, a3 as OrbitalSchema } from './schema-Bg4qX43l.js';
+import { X as OrbitalDefinition, a3 as OrbitalSchema } from './schema-Cov1FvVJ.js';
 
 /**
  * Event Wiring

package/dist/factory/index.d.ts

@@ -1,27 +1,295 @@
-import { v as FactoryParamValue, p as DomainRuleOverlayEntry, N as RuleOverlay } from '../diff-factory-calls-DlBcMWPM.js';
-export { C as CallSiteDiff, F as FactoryCallSite, s as FactoryCallSiteParams, t as FactoryEntitySignature, u as FactoryPageSignature, w as FactorySignature, x as FactorySignatureCatalog, y as FactorySignatureEntityField, z as FactoryTraitSignature, O as OwnershipOverlayEntry, K as PresentationNavItem, M as PresentationOverlay, S as SchemaFieldType, V as TraitOverlay, W as TraitOverlayEntry, X as TraitOverlayListener, Y as TranslationBinding, Z as TranslationResult, _ as TranslationWarning, a0 as diffFactoryCalls, a1 as translateDomainToParams, a1 as translateOverlaysToParams } from '../diff-factory-calls-DlBcMWPM.js';
-import { B as EntityField, H as EntityPersistence, bz as TraitReference } from '../trait-BPe356_9.js';
+import { B as EntityField, H as EntityPersistence, bz as TraitReference, bu as TraitEventListener } from '../trait-g5-2JR48.js';
 import 'zod';
 import '../expression-BVRFm0sV.js';
 import '@almadar/patterns';
 
 /**
- * Mutation surface for the factory-call plan.
- *
- * Replaces the deleted `DomainMutation` + `applyMutation` reducer. The
- * studio + questionnaire emit `FactoryCallPlanMutation[]` to express
- * incremental edits to the agent's per-orbital params + cross-cutting
- * overlays. The planner applies them via `applyFactoryCallPlanMutation`
- * and re-projects to `FactoryCallSite[]`.
+ * OrbitalSchema field type tags. The factory-signature extractor lifts
+ * these directly from the resolved `.orb`; consumers narrow further at
+ * dispatch time.
+ */
+type SchemaFieldType = 'string' | 'number' | 'boolean' | 'date' | 'timestamp' | 'datetime' | 'array' | 'object' | 'enum' | 'relation';
+interface FactorySignatureEntityField {
+    name: string;
+    type: SchemaFieldType;
+    required: boolean;
+}
+/**
+ * The canonical entity a factory produces. Almost always one entity
+ * per orbital; modeled as an array to keep the door open for orbitals
+ * that compose multiple entities.
+ */
+interface FactoryEntitySignature {
+    /** Canonical entity name the factory's params build (e.g. `"ChatMessage"`). */
+    name: string;
+    /** Fields the factory emits, post-auto-field stripping. */
+    fields: ReadonlyArray<FactorySignatureEntityField>;
+    /** Persistence mode declared on the canonical entity in the `.orb`. */
+    persistence: EntityPersistence;
+}
+/**
+ * One overridable config knob a trait advertises. Lifted directly from
+ * the source `.lolo` `config { }` block (which carries typed
+ * declarations + defaults). Consumers (the questionnaire generator,
+ * the studio) pick a widget from `type` and pre-fill from `default`.
  *
- * Initial scope covers per-orbital config edits. Structural ops
- * (add-orbital / remove-orbital / rename-orbital) ride the analysis
- * surface directly via `analysis.orbitals` / `analysis.deletedOrbitals`
- * / `analysis.renames`.
+ * `label` is reserved for a future `.lolo` grammar extension that
+ * lets atom authors author a human-friendly question prompt; today
+ * it's always undefined and the questionnaire derives a fallback
+ * from the key name.
+ */
+interface FactoryConfigParam {
+    /** Key name as advertised by the trait. Matches the override path
+     *  `traitOverrides.<traitName>.config.<key>`. */
+    key: string;
+    /** Type tag lifted from the `.lolo` config declaration. Drives the
+     *  question widget selection. Free-form to admit array/object
+     *  brackets (`[object]`, `[string]`) and atom-defined custom tags. */
+    type: string;
+    /** Canonical default value the factory uses when no override is
+     *  supplied. Pre-fills the form widget so users see what they're
+     *  about to change. */
+    default?: FactoryParamValue;
+    /** Optional human-friendly question prompt. Reserved for a future
+     *  `.lolo` `@label` annotation. */
+    label?: string;
+    /** Optional help-text. Reserved for the same future annotation. */
+    description?: string;
+    /** Optional closed-enum value set. Reserved for the same future
+     *  annotation. */
+    enumValues?: ReadonlyArray<string>;
+}
+/**
+ * One trait the factory composes into the orbital. The projector reads
+ * these to determine which factory's trait stack covers a given
+ * orbital + which override knobs a presentation overlay can target.
+ */
+interface FactoryTraitSignature {
+    /** Canonical trait name post-rename (e.g. `"ChatMessageList"`). */
+    name: string;
+    /** Event keys this trait emits (post-rename). */
+    emittedEvents: ReadonlyArray<string>;
+    /** Event keys this trait listens for. */
+    listenedEvents: ReadonlyArray<string>;
+    /** Config knobs overridable via `traitOverrides.<name>.config.<key>`.
+     *  Each entry carries the key name plus the typed declaration lifted
+     *  from the source `.lolo` `config { }` block. */
+    overridableConfigKeys: ReadonlyArray<FactoryConfigParam>;
+    /** Capability tags lifted directly from the source `.lolo` trait's
+     *  header annotations. Free-form strings — the translator overlay
+     *  matches rules to traits by exact set membership. */
+    capabilities: ReadonlyArray<string>;
+}
+/** One page the factory emits. The path is the factory default; the
+ *  projector may override via `params.pagePaths`. */
+interface FactoryPageSignature {
+    name: string;
+    defaultPath: string;
+    primaryEntity: string;
+}
+interface FactorySignature {
+    /** Organism the factory belongs to (e.g. `"std-realtime-chat"`). */
+    organism: string;
+    /** Orbital this factory builds within that organism. */
+    orbital: string;
+    /** Tier the factory sits in (informational). */
+    tier: 'atoms' | 'molecules' | 'organisms';
+    /** Path of the generated factory source (relative to the std root). */
+    factoryPath: string;
+    /** Canonical entity surface(s) the factory produces. */
+    entities: ReadonlyArray<FactoryEntitySignature>;
+    /** Trait stack the factory composes. */
+    traits: ReadonlyArray<FactoryTraitSignature>;
+    /** Pages the factory emits. */
+    pages: ReadonlyArray<FactoryPageSignature>;
+    /** Union of all `traits[].emittedEvents`. */
+    emittedEvents: ReadonlyArray<string>;
+    /** Union of all `traits[].listenedEvents`. */
+    listenedEvents: ReadonlyArray<string>;
+}
+/**
+ * Aggregate catalog written to
+ * `packages/almadar-std/behaviors/registry/factory-signatures.json`.
+ * Sorted by organism then orbital.
+ */
+interface FactorySignatureCatalog {
+    /** Generated-by version stamp (the `@almadar/std` minor it shipped in). */
+    generatedFromStdVersion: string;
+    /** Sorted list of factory signatures. */
+    signatures: ReadonlyArray<FactorySignature>;
+}
+/**
+ * A single factory invocation, as the typed result of the translator.
+ * Lower into runtime by calling the factory at `factoryPath` with
+ * these `params`. Stable identity for downstream diffing is
+ * `(organism, orbital)`.
+ */
+interface FactoryCallSite {
+    organism: string;
+    orbital: string;
+    factoryPath: string;
+    params: FactoryCallSiteParams;
+}
+/**
+ * The typed param surface every factory's call site populates. Each
+ * field corresponds to one row in the translator's overlay → factory
+ * mapping table.
+ */
+interface FactoryCallSiteParams {
+    /** Override `signature.entities[0].name` (entity rename). */
+    entityName?: string;
+    /** Additional or overriding entity fields. Caller wins on collision. */
+    entityFields?: ReadonlyArray<EntityField>;
+    /** Override `signature.entities[0].persistence`. */
+    persistence?: EntityPersistence;
+    /** Override the entity's storage collection key. */
+    collection?: string;
+    /** Per-page path overrides keyed by `signature.pages[i].name`. */
+    pagePaths?: Readonly<Record<string, string>>;
+    /** Trait config overrides keyed by `signature.traits[i].name`. */
+    traitOverrides?: Readonly<Record<string, {
+        config?: Readonly<Record<string, FactoryParamValue>>;
+    }>>;
+    /** Extra traits to compose into the orbital that aren't part of the
+     *  canonical signature trait stack. */
+    extraTraits?: ReadonlyArray<TraitReference>;
+}
+/**
+ * Allowed leaf values for the typed factory-param surface.
+ */
+type FactoryParamValue = string | number | boolean | ReadonlyArray<FactoryParamValue> | {
+    readonly [key: string]: FactoryParamValue;
+};
+
+/**
+ * Cross-cutting presentation knobs that don't live per orbital
+ * because they're factory-layer concerns (nav items live on a layout
+ * trait; theme is a separate `ThemeRef`). The translator reads these
+ * and threads them into the matching factory params.
+ */
+interface PresentationOverlay {
+    /** Nav items to add to the orbital's layout trait. The translator
+     *  looks for a `signature.traits[i]` with `overridableConfigKeys`
+     *  including `navItems` and writes into `traitOverrides[name].config.navItems`. */
+    navAdditions?: ReadonlyArray<PresentationNavItem>;
+    /** Optional theme ref override for the orbital. */
+    themeRef?: string;
+}
+interface PresentationNavItem {
+    label: string;
+    path: string;
+    icon?: string;
+}
+/**
+ * LLM-authored trait-level overrides keyed by trait name (matches
+ * `signature.traits[].name`). Each entry's `config` keys are validated
+ * against `signature.traits[i].overridableConfigKeys`.
+ */
+type TraitOverlay = Readonly<Record<string, TraitOverlayEntry>>;
+interface TraitOverlayEntry {
+    config?: Readonly<Record<string, FactoryParamValue>>;
+    linkedEntity?: string;
+    events?: Readonly<Record<string, string>>;
+    name?: string;
+    emitsScope?: 'internal' | 'external';
+    listens?: ReadonlyArray<TraitEventListener>;
+}
+type TraitOverlayListener = TraitEventListener;
+/**
+ * Rules carry a free-form `capability: string` that the translator
+ * matches against `signature.traits[].capabilities` (source-tagged
+ * in `.lolo`).
+ */
+interface RuleOverlay {
+    rules: ReadonlyArray<RuleOverlayEntry>;
+    /** Entity-level ownership signal. The translator threads it into
+     *  the matched trait's `config.ownerField` (when the matched trait
+     *  advertises that key in `overridableConfigKeys`). */
+    ownership?: ReadonlyArray<OwnershipOverlayEntry>;
+}
+interface RuleOverlayEntry {
+    id: string;
+    /** Free-form capability label, matched against
+     *  `signature.traits[].capabilities` by exact set membership. */
+    capability: string;
+    description: string;
+    /** Entity names this rule binds to. Empty array = cross-cutting. */
+    appliesTo: ReadonlyArray<string>;
+    /** Optional role name (e.g. `"admin"`) when the rule is role-scoped. */
+    role?: string;
+    /** Optional extra config knobs threaded into the matched trait's
+     *  `config`. Validated against the trait's `overridableConfigKeys`. */
+    config?: Readonly<Record<string, FactoryParamValue>>;
+}
+interface OwnershipOverlayEntry {
+    /** Entity name (matches the orbital's bound entity name). */
+    entity: string;
+    /** Field name on the entity that carries the owner identifier. */
+    ownerField: string;
+}
+
+/**
+ * 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.
  *
- * @packageDocumentation
+ * 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>;
+
 /**
  * One slot the agent emits per orbital. Slim shape — agent-facing,
  * carries only what factory dispatch needs. The studio renders forms
@@ -84,7 +352,7 @@ type FactoryCallPlanMutation = {
     ref: string;
 } | {
     kind: 'set-rule';
-    rule: DomainRuleOverlayEntry;
+    rule: RuleOverlayEntry;
 } | {
     kind: 'remove-rule';
     ruleId: string;
@@ -102,4 +370,4 @@ interface FactoryCallPlanState {
  */
 declare function applyFactoryCallPlanMutation(state: FactoryCallPlanState, m: FactoryCallPlanMutation): FactoryCallPlanState;
 
-export { type FactoryCallPlanMutation, type FactoryCallPlanState, FactoryParamValue, type OrbitalCallInput, RuleOverlay, DomainRuleOverlayEntry as RuleOverlayEntry, applyFactoryCallPlanMutation };
+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 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 };

package/dist/factory/index.js

@@ -1,28 +1,12 @@
-// src/domain-language/types.ts
-var DOMAIN_TO_SCHEMA_FIELD_TYPE = {
-  "text": "string",
-  "long text": "string",
-  "number": "number",
-  "currency": "number",
-  "yes/no": "boolean",
-  "date": "date",
-  "timestamp": "timestamp",
-  "datetime": "datetime",
-  "list": "array",
-  "object": "object",
-  "enum": "enum",
-  "relation": "relation"
-};
-
-// src/domain-language/sync/translate-domain-to-params.ts
-function translateDomainToParams(binding, signature, presentation, ruleOverlay, traitOverlay, catalog) {
+// src/factory/translate.ts
+function translateOverlaysToParams(binding, signature, presentation, ruleOverlay, traitOverlay, catalog) {
   const warnings = [];
   const params = {};
-  applyEntityName(binding.entity, signature, params);
-  applyEntityFields(binding.entity, signature, params, warnings);
-  applyPersistence(binding.entity, signature, params, warnings);
-  applyCollection(binding.entity, params);
-  applyPagePaths(binding.pages ?? [], signature, params, warnings);
+  applyEntityName(binding, signature, params);
+  applyEntityFields(binding, signature, params);
+  applyPersistence(binding, signature, params, warnings);
+  applyCollection(binding, params);
+  applyPagePaths(binding, signature, params, warnings);
   applyPresentation(presentation, signature, params, warnings);
   applyTraitOverlay(traitOverlay, signature, params, warnings);
   applyRuleOverlay(ruleOverlay, signature, binding, catalog, params, warnings);
@@ -36,67 +20,62 @@ function translateDomainToParams(binding, signature, presentation, ruleOverlay,
     warnings
   };
 }
-function applyEntityName(entity, signature, params) {
+function applyEntityName(binding, signature, params) {
   if (signature.entities.length === 0) return;
-  if (entity.name === signature.entities[0].name) return;
-  params.entityName = entity.name;
+  if (binding.entityName === signature.entities[0].name) return;
+  params.entityName = binding.entityName;
 }
-function applyEntityFields(entity, signature, params, warnings) {
+function applyEntityFields(binding, signature, params) {
+  if (!binding.entityFields || binding.entityFields.length === 0) return;
   if (signature.entities.length === 0) {
-    if (entity.fields.length > 0) {
-      warnings.push({
-        field: `entity.${entity.name}.fields`,
-        reason: "factory signature does not advertise an entity surface"
-      });
-    }
+    params.entityFields = [...binding.entityFields];
     return;
   }
   const canonical = new Set(signature.entities[0].fields.map((f) => f.name));
   const extras = [];
-  for (const f of entity.fields) {
-    if (canonical.has(f.name)) continue;
-    const lowered = lowerField(f);
-    if (lowered) extras.push(lowered);
+  for (const f of binding.entityFields) {
+    if (f.name && canonical.has(f.name)) continue;
+    extras.push(f);
   }
   if (extras.length > 0) params.entityFields = extras;
 }
-function applyPersistence(entity, signature, params, warnings) {
-  if (!entity.persistence) return;
+function applyPersistence(binding, signature, params, warnings) {
+  if (!binding.persistence) return;
   if (signature.entities.length === 0) {
     warnings.push({
-      field: `entity.${entity.name}.persistence`,
+      field: `entity.${binding.entityName}.persistence`,
       reason: "factory signature has no entity to apply persistence to"
     });
     return;
   }
-  if (entity.persistence === signature.entities[0].persistence) return;
-  params.persistence = entity.persistence;
+  if (binding.persistence === signature.entities[0].persistence) return;
+  params.persistence = binding.persistence;
 }
-function applyCollection(entity, params) {
-  if (!entity.collection) return;
-  params.collection = entity.collection;
+function applyCollection(binding, params) {
+  if (!binding.collection) return;
+  params.collection = binding.collection;
 }
-function applyPagePaths(pages, signature, params, warnings) {
-  if (pages.length === 0) return;
+function applyPagePaths(binding, signature, params, warnings) {
+  if (!binding.pagePaths) return;
   const sigPages = new Map(signature.pages.map((p) => [p.name, p]));
   const overrides = {};
-  for (const p of pages) {
-    const sig = sigPages.get(p.name);
+  for (const [pageName, url] of Object.entries(binding.pagePaths)) {
+    const sig = sigPages.get(pageName);
     if (!sig) {
       warnings.push({
-        field: `page.${p.name}.url`,
-        reason: `factory signature has no page named "${p.name}"`
+        field: `page.${pageName}.url`,
+        reason: `factory signature has no page named "${pageName}"`
       });
       continue;
     }
-    if (sig.defaultPath !== p.url) overrides[p.name] = p.url;
+    if (sig.defaultPath !== url) overrides[pageName] = url;
   }
   if (Object.keys(overrides).length > 0) params.pagePaths = overrides;
 }
 function applyPresentation(overlay, signature, params, warnings) {
   if (!overlay?.navAdditions || overlay.navAdditions.length === 0) return;
   const target = signature.traits.find(
-    (t) => t.overridableConfigKeys.includes("navItems")
+    (t) => t.overridableConfigKeys.some((p) => p.key === "navItems")
   );
   if (!target) {
     warnings.push({
@@ -134,29 +113,29 @@ function applyTraitOverlay(overlay, signature, params, warnings) {
   }
 }
 function mergeTraitOverride(traitName, entry, trait, params, warnings) {
-  const advertised = new Set(trait.overridableConfigKeys);
+  const advertised = new Set(trait.overridableConfigKeys.map((p) => p.key));
   const existing = params.traitOverrides?.[traitName] ?? {};
   const existingConfig = existing.config ?? {};
   const mergedConfig = { ...existingConfig };
   if (entry.config) {
     for (const [k, v] of Object.entries(entry.config)) {
       if (!advertised.has(k)) {
+        const advertisedKeys = trait.overridableConfigKeys.map((p) => p.key).join(", ");
         warnings.push({
           field: `traitOverlay.${traitName}.config.${k}`,
-          reason: `trait does not advertise config key "${k}" (overridableConfigKeys: [${trait.overridableConfigKeys.join(", ")}])`
+          reason: `trait does not advertise config key "${k}" (overridableConfigKeys: [${advertisedKeys}])`
         });
         continue;
       }
       mergedConfig[k] = v;
     }
   }
-  const next = {
-    ...existing,
-    ...Object.keys(mergedConfig).length > 0 ? { config: mergedConfig } : {}
-  };
   params.traitOverrides = {
     ...params.traitOverrides,
-    [traitName]: next
+    [traitName]: {
+      ...existing,
+      ...Object.keys(mergedConfig).length > 0 ? { config: mergedConfig } : {}
+    }
   };
 }
 function applyRuleOverlay(overlay, signature, binding, catalog, params, warnings) {
@@ -185,14 +164,14 @@ function applyRuleOverlay(overlay, signature, binding, catalog, params, warnings
   }
   if (overlay.ownership) {
     for (const entry of overlay.ownership) {
-      if (entry.entity !== binding.entity.name) continue;
+      if (entry.entity !== binding.entityName) continue;
       applyOwnership(entry, params, signature, catalog, warnings);
     }
   }
 }
 function ruleAppliesToBinding(rule, binding) {
   if (rule.appliesTo.length === 0) return true;
-  return rule.appliesTo.includes(binding.entity.name);
+  return rule.appliesTo.includes(binding.entityName);
 }
 function findTraitByCapability(catalog, capability) {
   for (const sig of catalog) {
@@ -204,13 +183,13 @@ function findTraitByCapability(catalog, capability) {
   }
   return void 0;
 }
-function appendRuleExtraTrait(rule, match, binding, params) {
+function appendRuleExtraTrait(_rule, match, binding, params) {
   const fromPath = `std/behaviors/${match.signature.organism}`;
   const alias = organismToAlias(match.signature.organism);
   const ref = {
     from: fromPath,
     ref: `${alias}.traits.${match.trait.name}`,
-    linkedEntity: binding.entity.name
+    linkedEntity: binding.entityName
   };
   const existing = params.extraTraits ?? [];
   params.extraTraits = [...existing, ref];
@@ -221,7 +200,7 @@ function organismToAlias(organism) {
 }
 function threadRuleConfig(rule, trait, params, warnings) {
   if (!rule.config) return;
-  const advertised = new Set(trait.overridableConfigKeys);
+  const advertised = new Set(trait.overridableConfigKeys.map((p) => p.key));
   const existing = params.traitOverrides?.[trait.name] ?? {};
   const existingConfig = existing.config ?? {};
   const merged = { ...existingConfig };
@@ -244,7 +223,7 @@ function threadRuleConfig(rule, trait, params, warnings) {
 }
 function applyOwnership(entry, params, signature, catalog, warnings) {
   const local = signature.traits.find(
-    (t) => t.overridableConfigKeys.includes("ownerField")
+    (t) => t.overridableConfigKeys.some((p) => p.key === "ownerField")
   );
   if (local) {
     writeOwnerField(local.name, entry.ownerField, params);
@@ -253,7 +232,7 @@ function applyOwnership(entry, params, signature, catalog, warnings) {
   if (catalog) {
     for (const sig of catalog) {
       const trait = sig.traits.find(
-        (t) => t.overridableConfigKeys.includes("ownerField")
+        (t) => t.overridableConfigKeys.some((p) => p.key === "ownerField")
       );
       if (trait) {
         writeOwnerField(trait.name, entry.ownerField, params);
@@ -277,37 +256,6 @@ function writeOwnerField(traitName, ownerField, params) {
     }
   };
 }
-function lowerField(f) {
-  const schemaType = DOMAIN_TO_SCHEMA_FIELD_TYPE[f.fieldType];
-  if (!schemaType) return void 0;
-  const out = {
-    name: f.name,
-    type: schemaType
-  };
-  if (f.required === true) out.required = true;
-  if (f.enumValues && f.enumValues.length > 0) out.values = [...f.enumValues];
-  if (f.default !== void 0) out.default = lowerDefault(f.default);
-  if (f.items) {
-    const itemSchema = DOMAIN_TO_SCHEMA_FIELD_TYPE[f.items.type];
-    if (itemSchema) out.items = { type: itemSchema };
-  }
-  return out;
-}
-function lowerDefault(d) {
-  if (d === void 0 || d === null) return d;
-  if (typeof d === "string" || typeof d === "number" || typeof d === "boolean") {
-    return d;
-  }
-  if (Array.isArray(d)) {
-    return d.map(lowerDefault);
-  }
-  if (typeof d === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(d)) out[k] = lowerDefault(v);
-    return out;
-  }
-  return void 0;
-}
 function navItemToParamValue(item) {
   const out = {
     label: item.label,
@@ -317,7 +265,7 @@ function navItemToParamValue(item) {
   return out;
 }
 
-// src/domain-language/sync/diff-factory-calls.ts
+// src/factory/diff.ts
 function diffFactoryCalls(prior, next) {
   const out = [];
   const priorByKey = new Map(prior.map((c) => [callKey(c), c]));
@@ -349,6 +297,7 @@ function paramsEqual(a, b) {
 }
 function canonicalParams(p) {
   const keys = [
+    "collection",
     "entityFields",
     "entityName",
     "extraTraits",
@@ -479,6 +428,6 @@ function patchOrbital(state, orbitalName, patch) {
   };
 }
 
-export { applyFactoryCallPlanMutation, diffFactoryCalls, translateDomainToParams, translateDomainToParams as translateOverlaysToParams };
+export { applyFactoryCallPlanMutation, diffFactoryCalls, translateOverlaysToParams };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map