@almadar/core 8.0.0 → 8.1.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,261 @@
-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[]`.
- *
- * 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`.
+ * 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 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 keys overridable via `traitOverrides.<name>.config.<key>`. */
+    overridableConfigKeys: ReadonlyArray<string>;
+    /** 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 +318,7 @@ type FactoryCallPlanMutation = {
     ref: string;
 } | {
     kind: 'set-rule';
-    rule: DomainRuleOverlayEntry;
+    rule: RuleOverlayEntry;
 } | {
     kind: 'remove-rule';
     ruleId: string;
@@ -102,4 +336,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 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,60 +20,55 @@ 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;
 }
@@ -150,13 +129,12 @@ function mergeTraitOverride(traitName, entry, trait, params, warnings) {
       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 +163,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 +182,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];
@@ -277,37 +255,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 +264,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 +296,7 @@ function paramsEqual(a, b) {
 }
 function canonicalParams(p) {
   const keys = [
+    "collection",
     "entityFields",
     "entityName",
     "extraTraits",
@@ -479,6 +427,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