@almadar/core 7.19.0 → 7.20.0

package/dist/domain-language/index.d.ts

@@ -1,4 +1,4 @@
-import { c$ as TraitScope, a9 as EntityPersistence, a2 as Entity, br as Page, bh as OrbitalSchema, cE as Trait } from '../schema-WX5fN1Ra.js';
+import { a6 as EntityField, a9 as EntityPersistence, cX as TraitReference, c$ as TraitScope, a2 as Entity, br as Page, bh as OrbitalSchema, cE as Trait } from '../schema-WX5fN1Ra.js';
 import { S as SExpr } from '../expression-BVRFm0sV.js';
 import 'zod';
 import '@almadar/patterns';
@@ -321,6 +321,151 @@ interface FactorySignatureCatalog {
     /** 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 {
+    /** Matches `FactorySignature.organism`. */
+    organism: string;
+    /** Matches `FactorySignature.orbital`. */
+    orbital: string;
+    /** Matches `FactorySignature.factoryPath`. Convenience pointer; the
+     *  authoritative source remains the signature catalog. */
+    factoryPath: string;
+    /** Typed param surface fed to the factory at invocation time. */
+    params: FactoryCallSiteParams;
+}
+/**
+ * The typed param surface every factory's call site populates. Each
+ * field on this interface corresponds to one row in the translator's
+ * domain↔factory mapping table. Adding a new domain concept means
+ * adding a field here AND wiring it in `translateDomainToParams`.
+ *
+ * Fields are all optional because not every factory consumes every
+ * concept; the translator only sets what the chosen signature
+ * advertises.
+ */
+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;
+    /** Per-page path overrides keyed by `signature.pages[i].name`. */
+    pagePaths?: Readonly<Record<string, string>>;
+    /** Trait config overrides keyed by `signature.traits[i].name`. Each
+     *  value is a record keyed by the trait's `overridableConfigKeys`. */
+    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. Used when a domain behavior
+     *  isn't covered by any canonical trait. */
+    extraTraits?: ReadonlyArray<TraitReference>;
+}
+/**
+ * Allowed leaf values for the typed factory-param surface. Same as
+ * `DomainFieldDefault` minus null, plus arrays + records to mirror
+ * the trait-config shape factories accept today.
+ */
+type FactoryParamValue = string | number | boolean | ReadonlyArray<FactoryParamValue> | {
+    readonly [key: string]: FactoryParamValue;
+};
+/**
+ * Discriminated union of edits to a `DomainDocument`. Each variant
+ * carries typed AST nodes already defined in this file — never raw
+ * JSON. `applyMutation` is total over this union.
+ */
+type DomainMutation = {
+    kind: 'add-entity';
+    entity: DomainEntity;
+} | {
+    kind: 'remove-entity';
+    entityName: string;
+} | {
+    kind: 'rename-entity';
+    from: string;
+    to: string;
+} | {
+    kind: 'update-entity';
+    entityName: string;
+    entity: DomainEntity;
+} | {
+    kind: 'add-field';
+    entityName: string;
+    field: DomainField;
+} | {
+    kind: 'remove-field';
+    entityName: string;
+    fieldName: string;
+} | {
+    kind: 'update-field';
+    entityName: string;
+    field: DomainField;
+} | {
+    kind: 'add-page';
+    page: DomainPage;
+} | {
+    kind: 'remove-page';
+    pageName: string;
+} | {
+    kind: 'update-page';
+    pageName: string;
+    page: DomainPage;
+} | {
+    kind: 'add-behavior';
+    behavior: DomainBehavior;
+} | {
+    kind: 'remove-behavior';
+    behaviorName: string;
+} | {
+    kind: 'update-behavior';
+    behaviorName: string;
+    behavior: DomainBehavior;
+} | {
+    kind: 'add-transition';
+    behaviorName: string;
+    transition: DomainTransition;
+} | {
+    kind: 'remove-transition';
+    behaviorName: string;
+    from: string;
+    to: string;
+    event: string;
+} | {
+    kind: 'add-relationship';
+    entityName: string;
+    relationship: DomainRelationship;
+} | {
+    kind: 'remove-relationship';
+    entityName: string;
+    targetEntity: string;
+    relationshipType: RelationshipType;
+};
+/**
+ * Cross-cutting presentation knobs that don't live in `DomainDocument`
+ * 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;
+    /** Optional icon key (consumer-resolved). */
+    icon?: string;
+}
 
 /**
  * Domain Language Tokens
@@ -802,6 +947,88 @@ declare function applySectionUpdate(schema: OrbitalSchema, sectionType: 'entity'
  */
 declare function deleteSection(schema: OrbitalSchema, sectionType: 'entity' | 'page' | 'behavior' | 'tick', sectionId: string): OrbitalSchema;
 
+/**
+ * Deterministic translator: one `DomainDocument` slice + one chosen
+ * `FactorySignature` → one `FactoryCallSite`. The agent picks the
+ * signature upstream via embedding-search over the catalog; this
+ * function does ZERO matching. It just lowers domain fields onto the
+ * factory's advertised param surface, field-by-field.
+ *
+ * The binding (which `DomainEntity` / `DomainPage[]` map to this
+ * orbital) is the agent's explicit decision and is passed in. No name
+ * matching, no scoring, no tie-breaks.
+ *
+ * Adding a new domain concept means:
+ *   1. Add a field on `DomainEntity` / `DomainPage` / `DomainBehavior`
+ *      (`packages/almadar-core/src/domain-language/types.ts`).
+ *   2. Make sure at least one factory signature advertises a
+ *      consuming knob (Phase 1.5 gate — generated by
+ *      almadar-pattern-sync from `.orb`).
+ *   3. Add one helper-fn row below that lowers the new field into
+ *      `FactoryCallSiteParams`.
+ *
+ * If a binding field has no signature consumer, the translator emits
+ * a typed warning and SKIPS the field — that's the loud signal the
+ * field shouldn't have been admitted to the language.
+ */
+
+/**
+ * The slice of `DomainDocument` that maps onto the chosen signature.
+ * The agent assembles this when it picks the signature: it knows
+ * which `DomainEntity` / `DomainPage[]` are this orbital's
+ * responsibility.
+ */
+interface TranslationBinding {
+    /** The single domain entity this signature's orbital owns. */
+    entity: DomainEntity;
+    /** Pages from the domain doc that map to this orbital's pages. The
+     *  translator pairs them with `signature.pages[]` by name. */
+    pages?: ReadonlyArray<DomainPage>;
+}
+interface TranslationWarning {
+    /** Dotted path of the domain field that couldn't be lowered. */
+    field: string;
+    /** Human-readable reason. */
+    reason: string;
+}
+interface TranslationResult {
+    callSite: FactoryCallSite;
+    warnings: ReadonlyArray<TranslationWarning>;
+}
+declare function translateDomainToParams(binding: TranslationBinding, signature: FactorySignature, presentation?: PresentationOverlay): 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>;
+
 /**
  * Section Mapping
  *
@@ -1074,4 +1301,26 @@ declare function getRegistryStats(): {
  */
 declare function generateDomainLanguageReference(): string;
 
-export { type ASTNode, type ComparisonCondition, type ComparisonOperator, type DomainBehavior, type DomainChunk, type DomainDocument, type DomainEffect, type DomainEntity, type DomainField, type DomainFieldDefault, type DomainFieldItems, type DomainFieldType, type DomainGuard, type DomainPage, type DomainPageAction, type DomainPageSection, type DomainRelationship, type DomainTick, type DomainToSchemaResult, type DomainTransition, EFFECT_REGISTRY, type EffectMapping, type EffectType, EntityPersistence, FIELD_TYPE_REGISTRY, type FactoryEntitySignature, type FactoryPageSignature, type FactorySignature, type FactorySignatureCatalog, type FactorySignatureEntityField, type FactoryTraitSignature, type FieldCheckCondition, type FieldReference, type FieldTypeMapping, GUARD_REGISTRY, type GuardCondition, type GuardMapping, KEYWORDS, Lexer, type LogicalCondition, type LogicalOperator, MULTI_WORD_KEYWORDS, type MappingStore, type MergeResult, type ParseError, type ParseResult, type RelationshipType, type SchemaToDomainResult, type SectionMapping, type SourceLocation, type SourceRange, type Token, TokenType, TraitScope, type UserCheckCondition, applySectionUpdate, computeSchemaHash, convertDomainToSchema, convertEntitiesToDomain, convertPagesToDomain, convertSchemaToDomain, convertTraitsToDomain, createMappingStore, deleteSection, detectChanges, domainKeywordToSchemaType, findMapping, findMappingByPath, findMappingsByType, formatBehaviorToDomain, formatBehaviorToSchema, formatDomainGuardToSchema, formatEntityToDomain, formatEntityToSchema, formatGuardConditionToDomain, formatGuardToDomain, formatGuardToSchema, formatMergeSummary, formatPageToDomain, formatPageToSchema, formatSchemaEntityToDomain, formatSchemaGuardToDomain, formatSchemaPageToDomain, formatSchemaTraitToDomain, generateDomainLanguageReference, generateSectionId, getEffectMapping, getFieldTypeMapping, getGuardMapping, getRegisteredEffects, getRegisteredFieldTypes, getRegisteredGuards, getRegistryStats, getSchemaPath, hasSchemaChanged, isEffectRegistered, isFieldTypeRegistered, isGuardRegistered, mergeDomainChunks, parseBehavior, parseDomainEffect, parseDomainEffects, parseDomainGuard, parseEntity, parseGuard, parsePage, parseSectionId, removeMapping, resolveConflict, schemaEntityToDomainEntity, schemaPageToDomainPage, schemaTraitToDomainBehavior, schemaTypeToDomainKeyword, tokenize, updateMappingRange, updateSchemaHash, upsertMapping, validateDomainChunk };
+/**
+ * Pure reducer for `DomainMutation` over `DomainDocument`.
+ *
+ * No I/O. No randomness. Returns a new typed `DomainDocument`
+ * (immutable update) so callers can preserve prior state for
+ * cross-turn stability. One total switch over the discriminated
+ * union — the compiler enforces exhaustiveness via the `never`
+ * default branch.
+ *
+ * Companion to `translateDomainToParams`: the UI/agent emits typed
+ * `DomainMutation[]`, the reducer applies them, the translator
+ * lowers the result onto factory call sites.
+ */
+
+/**
+ * Apply one mutation to the document. The original is not modified.
+ * Mutations targeting missing entities/pages/behaviors/fields are
+ * silently no-ops — callers that care should validate via
+ * `findEntity`-style helpers before applying.
+ */
+declare function applyMutation(doc: DomainDocument, mut: DomainMutation): DomainDocument;
+
+export { type ASTNode, type CallSiteDiff, type ComparisonCondition, type ComparisonOperator, type DomainBehavior, type DomainChunk, type DomainDocument, type DomainEffect, type DomainEntity, type DomainField, type DomainFieldDefault, type DomainFieldItems, type DomainFieldType, type DomainGuard, type DomainMutation, type DomainPage, type DomainPageAction, type DomainPageSection, type DomainRelationship, type DomainTick, type DomainToSchemaResult, type DomainTransition, EFFECT_REGISTRY, type EffectMapping, type EffectType, EntityPersistence, FIELD_TYPE_REGISTRY, type FactoryCallSite, type FactoryCallSiteParams, type FactoryEntitySignature, type FactoryPageSignature, type FactoryParamValue, type FactorySignature, type FactorySignatureCatalog, type FactorySignatureEntityField, type FactoryTraitSignature, type FieldCheckCondition, type FieldReference, type FieldTypeMapping, GUARD_REGISTRY, type GuardCondition, type GuardMapping, KEYWORDS, Lexer, type LogicalCondition, type LogicalOperator, MULTI_WORD_KEYWORDS, type MappingStore, type MergeResult, type ParseError, type ParseResult, type PresentationNavItem, type PresentationOverlay, type RelationshipType, type SchemaFieldType, type SchemaToDomainResult, type SectionMapping, type SourceLocation, type SourceRange, type Token, TokenType, TraitScope, type TranslationBinding, type TranslationResult, type TranslationWarning, type UserCheckCondition, applyMutation, applySectionUpdate, computeSchemaHash, convertDomainToSchema, convertEntitiesToDomain, convertPagesToDomain, convertSchemaToDomain, convertTraitsToDomain, createMappingStore, deleteSection, detectChanges, diffFactoryCalls, domainKeywordToSchemaType, findMapping, findMappingByPath, findMappingsByType, formatBehaviorToDomain, formatBehaviorToSchema, formatDomainGuardToSchema, formatEntityToDomain, formatEntityToSchema, formatGuardConditionToDomain, formatGuardToDomain, formatGuardToSchema, formatMergeSummary, formatPageToDomain, formatPageToSchema, formatSchemaEntityToDomain, formatSchemaGuardToDomain, formatSchemaPageToDomain, formatSchemaTraitToDomain, generateDomainLanguageReference, generateSectionId, getEffectMapping, getFieldTypeMapping, getGuardMapping, getRegisteredEffects, getRegisteredFieldTypes, getRegisteredGuards, getRegistryStats, getSchemaPath, hasSchemaChanged, isEffectRegistered, isFieldTypeRegistered, isGuardRegistered, mergeDomainChunks, parseBehavior, parseDomainEffect, parseDomainEffects, parseDomainGuard, parseEntity, parseGuard, parsePage, parseSectionId, removeMapping, resolveConflict, schemaEntityToDomainEntity, schemaPageToDomainPage, schemaTraitToDomainBehavior, schemaTypeToDomainKeyword, tokenize, translateDomainToParams, updateMappingRange, updateSchemaHash, upsertMapping, validateDomainChunk };

package/dist/domain-language/index.js

@@ -6397,6 +6397,251 @@ function parseEffectFromText(text) {
   }
 }
 
+// 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"
+};
+var UI_SLOTS2 = [
+  "main",
+  "sidebar",
+  "modal",
+  "drawer",
+  "overlay",
+  "center",
+  "toast",
+  "hud-top",
+  "hud-bottom",
+  "floating",
+  "system"
+];
+
+// src/domain-language/sync/translate-domain-to-params.ts
+function translateDomainToParams(binding, signature, presentation) {
+  const warnings = [];
+  const params = {};
+  applyEntityName(binding.entity, signature, params);
+  applyEntityFields(binding.entity, signature, params, warnings);
+  applyPersistence(binding.entity, signature, params, warnings);
+  applyPagePaths(binding.pages ?? [], signature, params, warnings);
+  applyPresentation(presentation, signature, params, warnings);
+  return {
+    callSite: {
+      organism: signature.organism,
+      orbital: signature.orbital,
+      factoryPath: signature.factoryPath,
+      params
+    },
+    warnings
+  };
+}
+function applyEntityName(entity, signature, params) {
+  if (signature.entities.length === 0) return;
+  if (entity.name === signature.entities[0].name) return;
+  params.entityName = entity.name;
+}
+function applyEntityFields(entity, signature, params, warnings) {
+  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"
+      });
+    }
+    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);
+  }
+  if (extras.length > 0) params.entityFields = extras;
+}
+function applyPersistence(entity, signature, params, warnings) {
+  if (!entity.persistence) return;
+  if (signature.entities.length === 0) {
+    warnings.push({
+      field: `entity.${entity.name}.persistence`,
+      reason: "factory signature has no entity to apply persistence to"
+    });
+    return;
+  }
+  if (entity.persistence === signature.entities[0].persistence) return;
+  params.persistence = entity.persistence;
+}
+function applyPagePaths(pages, signature, params, warnings) {
+  if (pages.length === 0) 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);
+    if (!sig) {
+      warnings.push({
+        field: `page.${p.name}.url`,
+        reason: `factory signature has no page named "${p.name}"`
+      });
+      continue;
+    }
+    if (sig.defaultPath !== p.url) overrides[p.name] = p.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")
+  );
+  if (!target) {
+    warnings.push({
+      field: "presentation.navAdditions",
+      reason: "factory signature has no trait advertising a `navItems` config key"
+    });
+    return;
+  }
+  const existing = params.traitOverrides?.[target.name] ?? {};
+  const existingConfig = existing.config ?? {};
+  const items = overlay.navAdditions.map(
+    navItemToParamValue
+  );
+  params.traitOverrides = {
+    ...params.traitOverrides,
+    [target.name]: {
+      ...existing,
+      config: { ...existingConfig, navItems: items }
+    }
+  };
+}
+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,
+    path: item.path
+  };
+  if (item.icon) out.icon = item.icon;
+  return out;
+}
+
+// src/domain-language/sync/diff-factory-calls.ts
+function diffFactoryCalls(prior, next) {
+  const out = [];
+  const priorByKey = new Map(prior.map((c) => [callKey(c), c]));
+  const nextByKey = new Map(next.map((c) => [callKey(c), c]));
+  for (const [key, p] of priorByKey) {
+    const n = nextByKey.get(key);
+    if (!n) {
+      out.push({ kind: "delete", orbitalName: p.orbital, prior: p });
+      continue;
+    }
+    if (paramsEqual(p.params, n.params)) {
+      out.push({ kind: "keep", orbitalName: p.orbital, call: n });
+    } else {
+      out.push({ kind: "edit", orbitalName: p.orbital, prior: p, next: n });
+    }
+  }
+  for (const [key, n] of nextByKey) {
+    if (!priorByKey.has(key)) {
+      out.push({ kind: "add", orbitalName: n.orbital, next: n });
+    }
+  }
+  return out;
+}
+function callKey(c) {
+  return `${c.organism}::${c.orbital}`;
+}
+function paramsEqual(a, b) {
+  return canonicalParams(a) === canonicalParams(b);
+}
+function canonicalParams(p) {
+  const keys = [
+    "entityFields",
+    "entityName",
+    "extraTraits",
+    "pagePaths",
+    "persistence",
+    "traitOverrides"
+  ];
+  const parts = [];
+  for (const k of keys) {
+    const v = p[k];
+    if (v === void 0) continue;
+    parts.push(`${k}:${canonicalNode(v)}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+function canonicalNode(v) {
+  if (v === void 0) return "u";
+  if (typeof v === "string") return JSON.stringify(v);
+  if (Array.isArray(v)) {
+    return `[${v.map((x) => canonicalParamValue(x)).join(",")}]`;
+  }
+  const keys = Object.keys(v).sort();
+  const parts = [];
+  for (const k of keys) {
+    const child = v[k];
+    parts.push(`${JSON.stringify(k)}:${canonicalParamValue(child)}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+function canonicalParamValue(v) {
+  if (v === null || v === void 0) return "u";
+  if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+    return JSON.stringify(v);
+  }
+  if (Array.isArray(v)) {
+    return `[${v.map(canonicalParamValue).join(",")}]`;
+  }
+  const keys = Object.keys(v).sort();
+  const parts = [];
+  for (const k of keys) {
+    const child = v[k];
+    if (child === void 0) continue;
+    parts.push(`${JSON.stringify(k)}:${canonicalParamValue(child)}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+
 // src/domain-language/sync/section-mapping.ts
 function createMappingStore(mappings = []) {
   return {
@@ -6617,21 +6862,6 @@ function formatMergeSummary(result) {
   return parts.join(", ") || "empty";
 }
 
-// src/domain-language/types.ts
-var UI_SLOTS2 = [
-  "main",
-  "sidebar",
-  "modal",
-  "drawer",
-  "overlay",
-  "center",
-  "toast",
-  "hud-top",
-  "hud-bottom",
-  "floating",
-  "system"
-];
-
 // src/domain-language/registry.ts
 var FIELD_TYPE_REGISTRY = {
   string: {
@@ -7069,6 +7299,141 @@ function generateDomainLanguageReference() {
   return lines.join("\n");
 }
 
-export { EFFECT_REGISTRY, FIELD_TYPE_REGISTRY, GUARD_REGISTRY, KEYWORDS, Lexer, MULTI_WORD_KEYWORDS, TokenType, applySectionUpdate, computeSchemaHash, convertDomainToSchema, convertEntitiesToDomain, convertPagesToDomain, convertSchemaToDomain, convertTraitsToDomain, createMappingStore, deleteSection, detectChanges, domainKeywordToSchemaType, findMapping, findMappingByPath, findMappingsByType, formatBehaviorToDomain, formatBehaviorToSchema, formatDomainGuardToSchema, formatEntityToDomain, formatEntityToSchema, formatGuardConditionToDomain, formatGuardToDomain, formatGuardToSchema, formatMergeSummary, formatPageToDomain, formatPageToSchema, formatSchemaEntityToDomain, formatSchemaGuardToDomain, formatSchemaPageToDomain, formatSchemaTraitToDomain, generateDomainLanguageReference, generateSectionId, getEffectMapping, getFieldTypeMapping, getGuardMapping, getRegisteredEffects, getRegisteredFieldTypes, getRegisteredGuards, getRegistryStats, getSchemaPath, hasSchemaChanged, isEffectRegistered, isFieldTypeRegistered, isGuardRegistered, mergeDomainChunks, parseBehavior, parseDomainEffect, parseDomainEffects, parseDomainGuard, parseEntity, parseGuard, parsePage, parseSectionId, removeMapping, resolveConflict, schemaEntityToDomainEntity, schemaPageToDomainPage, schemaTraitToDomainBehavior, schemaTypeToDomainKeyword, tokenize, updateMappingRange, updateSchemaHash, upsertMapping, validateDomainChunk };
+// src/domain-language/applyMutation.ts
+function applyMutation(doc, mut) {
+  switch (mut.kind) {
+    case "add-entity":
+      return { ...doc, entities: [...doc.entities, mut.entity] };
+    case "remove-entity":
+      return {
+        ...doc,
+        entities: doc.entities.filter((e) => e.name !== mut.entityName)
+      };
+    case "rename-entity":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.from, (e) => ({
+          ...e,
+          name: mut.to
+        }))
+      };
+    case "update-entity":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.entityName, () => mut.entity)
+      };
+    case "add-field":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.entityName, (e) => ({
+          ...e,
+          fields: [...e.fields, mut.field]
+        }))
+      };
+    case "remove-field":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.entityName, (e) => ({
+          ...e,
+          fields: e.fields.filter((f) => f.name !== mut.fieldName)
+        }))
+      };
+    case "update-field":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.entityName, (e) => ({
+          ...e,
+          fields: replaceField(e.fields, mut.field)
+        }))
+      };
+    case "add-page":
+      return { ...doc, pages: [...doc.pages, mut.page] };
+    case "remove-page":
+      return {
+        ...doc,
+        pages: doc.pages.filter((p) => p.name !== mut.pageName)
+      };
+    case "update-page":
+      return {
+        ...doc,
+        pages: replacePage(doc.pages, mut.pageName, () => mut.page)
+      };
+    case "add-behavior":
+      return { ...doc, behaviors: [...doc.behaviors, mut.behavior] };
+    case "remove-behavior":
+      return {
+        ...doc,
+        behaviors: doc.behaviors.filter((b) => b.name !== mut.behaviorName)
+      };
+    case "update-behavior":
+      return {
+        ...doc,
+        behaviors: replaceBehavior(
+          doc.behaviors,
+          mut.behaviorName,
+          () => mut.behavior
+        )
+      };
+    case "add-transition":
+      return {
+        ...doc,
+        behaviors: replaceBehavior(doc.behaviors, mut.behaviorName, (b) => ({
+          ...b,
+          transitions: [...b.transitions, mut.transition]
+        }))
+      };
+    case "remove-transition":
+      return {
+        ...doc,
+        behaviors: replaceBehavior(doc.behaviors, mut.behaviorName, (b) => ({
+          ...b,
+          transitions: b.transitions.filter(
+            (t) => !matchesTransition(t, mut.from, mut.to, mut.event)
+          )
+        }))
+      };
+    case "add-relationship":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.entityName, (e) => ({
+          ...e,
+          relationships: [...e.relationships, mut.relationship]
+        }))
+      };
+    case "remove-relationship":
+      return {
+        ...doc,
+        entities: replaceEntity(doc.entities, mut.entityName, (e) => ({
+          ...e,
+          relationships: e.relationships.filter(
+            (r) => !matchesRelationship(r, mut.targetEntity, mut.relationshipType)
+          )
+        }))
+      };
+    default: {
+      return doc;
+    }
+  }
+}
+function replaceEntity(entities, name, update) {
+  return entities.map((e) => e.name === name ? update(e) : e);
+}
+function replaceField(fields, next) {
+  return fields.map((f) => f.name === next.name ? next : f);
+}
+function replacePage(pages, name, update) {
+  return pages.map((p) => p.name === name ? update(p) : p);
+}
+function replaceBehavior(behaviors, name, update) {
+  return behaviors.map((b) => b.name === name ? update(b) : b);
+}
+function matchesTransition(t, from, to, event) {
+  return t.fromState === from && t.toState === to && t.event === event;
+}
+function matchesRelationship(r, targetEntity, relationshipType) {
+  return r.targetEntity === targetEntity && r.relationshipType === relationshipType;
+}
+
+export { EFFECT_REGISTRY, FIELD_TYPE_REGISTRY, GUARD_REGISTRY, KEYWORDS, Lexer, MULTI_WORD_KEYWORDS, TokenType, applyMutation, applySectionUpdate, computeSchemaHash, convertDomainToSchema, convertEntitiesToDomain, convertPagesToDomain, convertSchemaToDomain, convertTraitsToDomain, createMappingStore, deleteSection, detectChanges, diffFactoryCalls, domainKeywordToSchemaType, findMapping, findMappingByPath, findMappingsByType, formatBehaviorToDomain, formatBehaviorToSchema, formatDomainGuardToSchema, formatEntityToDomain, formatEntityToSchema, formatGuardConditionToDomain, formatGuardToDomain, formatGuardToSchema, formatMergeSummary, formatPageToDomain, formatPageToSchema, formatSchemaEntityToDomain, formatSchemaGuardToDomain, formatSchemaPageToDomain, formatSchemaTraitToDomain, generateDomainLanguageReference, generateSectionId, getEffectMapping, getFieldTypeMapping, getGuardMapping, getRegisteredEffects, getRegisteredFieldTypes, getRegisteredGuards, getRegistryStats, getSchemaPath, hasSchemaChanged, isEffectRegistered, isFieldTypeRegistered, isGuardRegistered, mergeDomainChunks, parseBehavior, parseDomainEffect, parseDomainEffects, parseDomainGuard, parseEntity, parseGuard, parsePage, parseSectionId, removeMapping, resolveConflict, schemaEntityToDomainEntity, schemaPageToDomainPage, schemaTraitToDomainBehavior, schemaTypeToDomainKeyword, tokenize, translateDomainToParams, updateMappingRange, updateSchemaHash, upsertMapping, validateDomainChunk };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map