@almadar/core 7.26.0 → 8.0.0

package/dist/factory/index.d.ts

@@ -0,0 +1,105 @@
+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 '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`.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * One slot the agent emits per orbital. Slim shape — agent-facing,
+ * carries only what factory dispatch needs. The studio renders forms
+ * over this; the projector turns it into a `FactoryCallSite`.
+ */
+interface OrbitalCallInput {
+    orbitalName: string;
+    organism?: string;
+    orbital?: string;
+    entityName?: string;
+    entityFields?: ReadonlyArray<EntityField>;
+    persistence?: EntityPersistence;
+    collection?: string;
+    pagePaths?: Readonly<Record<string, string>>;
+    traitOverlay?: Readonly<Record<string, {
+        config?: Readonly<Record<string, FactoryParamValue>>;
+        linkedEntity?: string;
+        name?: string;
+    }>>;
+    extraTraits?: ReadonlyArray<TraitReference>;
+}
+/**
+ * Discriminated union of typed edits. Each variant carries only the
+ * payload pieces that change. The reducer is total over the union.
+ */
+type FactoryCallPlanMutation = {
+    kind: 'set-orbital-entity-fields';
+    orbitalName: string;
+    fields: ReadonlyArray<EntityField>;
+} | {
+    kind: 'set-orbital-entity-name';
+    orbitalName: string;
+    name: string;
+} | {
+    kind: 'set-orbital-persistence';
+    orbitalName: string;
+    persistence: EntityPersistence;
+} | {
+    kind: 'set-orbital-collection';
+    orbitalName: string;
+    collection: string;
+} | {
+    kind: 'set-orbital-page-path';
+    orbitalName: string;
+    pageName: string;
+    path: string;
+} | {
+    kind: 'set-trait-override-config';
+    orbitalName: string;
+    traitName: string;
+    key: string;
+    value: FactoryParamValue;
+} | {
+    kind: 'add-extra-trait';
+    orbitalName: string;
+    trait: TraitReference;
+} | {
+    kind: 'remove-extra-trait';
+    orbitalName: string;
+    ref: string;
+} | {
+    kind: 'set-rule';
+    rule: DomainRuleOverlayEntry;
+} | {
+    kind: 'remove-rule';
+    ruleId: string;
+};
+/**
+ * State shape the reducer operates on. Mirrors the slice of the
+ * agent's analysis result that incremental edits target.
+ */
+interface FactoryCallPlanState {
+    orbitals: ReadonlyArray<OrbitalCallInput>;
+    ruleOverlay?: RuleOverlay;
+}
+/**
+ * Immutable reducer. Returns a new state; never mutates input.
+ */
+declare function applyFactoryCallPlanMutation(state: FactoryCallPlanState, m: FactoryCallPlanMutation): FactoryCallPlanState;
+
+export { type FactoryCallPlanMutation, type FactoryCallPlanState, FactoryParamValue, type OrbitalCallInput, RuleOverlay, DomainRuleOverlayEntry as RuleOverlayEntry, applyFactoryCallPlanMutation };

package/dist/factory/index.js

@@ -0,0 +1,484 @@
+// 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) {
+  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);
+  applyPresentation(presentation, signature, params, warnings);
+  applyTraitOverlay(traitOverlay, signature, params, warnings);
+  applyRuleOverlay(ruleOverlay, signature, binding, catalog, 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 applyCollection(entity, params) {
+  if (!entity.collection) return;
+  params.collection = entity.collection;
+}
+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 applyTraitOverlay(overlay, signature, params, warnings) {
+  if (!overlay) return;
+  const traitsByName = new Map(signature.traits.map((t) => [t.name, t]));
+  for (const [traitName, entry] of Object.entries(overlay)) {
+    const trait = traitsByName.get(traitName);
+    if (!trait) {
+      warnings.push({
+        field: `traitOverlay.${traitName}`,
+        reason: `factory signature has no trait named "${traitName}"`
+      });
+      continue;
+    }
+    mergeTraitOverride(traitName, entry, trait, params, warnings);
+  }
+}
+function mergeTraitOverride(traitName, entry, trait, params, warnings) {
+  const advertised = new Set(trait.overridableConfigKeys);
+  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)) {
+        warnings.push({
+          field: `traitOverlay.${traitName}.config.${k}`,
+          reason: `trait does not advertise config key "${k}" (overridableConfigKeys: [${trait.overridableConfigKeys.join(", ")}])`
+        });
+        continue;
+      }
+      mergedConfig[k] = v;
+    }
+  }
+  const next = {
+    ...existing,
+    ...Object.keys(mergedConfig).length > 0 ? { config: mergedConfig } : {}
+  };
+  params.traitOverrides = {
+    ...params.traitOverrides,
+    [traitName]: next
+  };
+}
+function applyRuleOverlay(overlay, signature, binding, catalog, params, warnings) {
+  if (!overlay) return;
+  for (const rule of overlay.rules) {
+    if (!ruleAppliesToBinding(rule, binding)) continue;
+    if (!catalog) {
+      warnings.push({
+        field: `ruleOverlay.rules.${rule.id}`,
+        reason: "rule overlay supplied without a catalog \u2014 capability lookup requires one"
+      });
+      continue;
+    }
+    const match = findTraitByCapability(catalog, rule.capability);
+    if (!match) {
+      warnings.push({
+        field: `ruleOverlay.rules.${rule.id}`,
+        reason: `no trait in the catalog advertises capability "${rule.capability}"`
+      });
+      continue;
+    }
+    appendRuleExtraTrait(rule, match, binding, params);
+    if (rule.config) {
+      threadRuleConfig(rule, match.trait, params, warnings);
+    }
+  }
+  if (overlay.ownership) {
+    for (const entry of overlay.ownership) {
+      if (entry.entity !== binding.entity.name) 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);
+}
+function findTraitByCapability(catalog, capability) {
+  for (const sig of catalog) {
+    for (const trait of sig.traits) {
+      if (trait.capabilities.includes(capability)) {
+        return { signature: sig, trait };
+      }
+    }
+  }
+  return void 0;
+}
+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
+  };
+  const existing = params.extraTraits ?? [];
+  params.extraTraits = [...existing, ref];
+}
+function organismToAlias(organism) {
+  const trimmed = organism.startsWith("std-") ? organism.slice(4) : organism;
+  return trimmed.split("-").filter((s) => s.length > 0).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function threadRuleConfig(rule, trait, params, warnings) {
+  if (!rule.config) return;
+  const advertised = new Set(trait.overridableConfigKeys);
+  const existing = params.traitOverrides?.[trait.name] ?? {};
+  const existingConfig = existing.config ?? {};
+  const merged = { ...existingConfig };
+  for (const [k, v] of Object.entries(rule.config)) {
+    if (!advertised.has(k)) {
+      warnings.push({
+        field: `ruleOverlay.rules.${rule.id}.config.${k}`,
+        reason: `trait "${trait.name}" does not advertise config key "${k}"`
+      });
+      continue;
+    }
+    merged[k] = v;
+  }
+  if (Object.keys(merged).length > 0) {
+    params.traitOverrides = {
+      ...params.traitOverrides,
+      [trait.name]: { ...existing, config: merged }
+    };
+  }
+}
+function applyOwnership(entry, params, signature, catalog, warnings) {
+  const local = signature.traits.find(
+    (t) => t.overridableConfigKeys.includes("ownerField")
+  );
+  if (local) {
+    writeOwnerField(local.name, entry.ownerField, params);
+    return;
+  }
+  if (catalog) {
+    for (const sig of catalog) {
+      const trait = sig.traits.find(
+        (t) => t.overridableConfigKeys.includes("ownerField")
+      );
+      if (trait) {
+        writeOwnerField(trait.name, entry.ownerField, params);
+        return;
+      }
+    }
+  }
+  warnings.push({
+    field: `ruleOverlay.ownership.${entry.entity}`,
+    reason: "no trait in the bound signature or catalog advertises an `ownerField` config knob"
+  });
+}
+function writeOwnerField(traitName, ownerField, params) {
+  const existing = params.traitOverrides?.[traitName] ?? {};
+  const existingConfig = existing.config ?? {};
+  params.traitOverrides = {
+    ...params.traitOverrides,
+    [traitName]: {
+      ...existing,
+      config: { ...existingConfig, ownerField }
+    }
+  };
+}
+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/factory/mutate.ts
+function applyFactoryCallPlanMutation(state, m) {
+  switch (m.kind) {
+    case "set-orbital-entity-fields":
+      return patchOrbital(state, m.orbitalName, (o) => ({
+        ...o,
+        entityFields: m.fields
+      }));
+    case "set-orbital-entity-name":
+      return patchOrbital(state, m.orbitalName, (o) => ({
+        ...o,
+        entityName: m.name
+      }));
+    case "set-orbital-persistence":
+      return patchOrbital(state, m.orbitalName, (o) => ({
+        ...o,
+        persistence: m.persistence
+      }));
+    case "set-orbital-collection":
+      return patchOrbital(state, m.orbitalName, (o) => ({
+        ...o,
+        collection: m.collection
+      }));
+    case "set-orbital-page-path":
+      return patchOrbital(state, m.orbitalName, (o) => ({
+        ...o,
+        pagePaths: { ...o.pagePaths ?? {}, [m.pageName]: m.path }
+      }));
+    case "set-trait-override-config":
+      return patchOrbital(state, m.orbitalName, (o) => {
+        const overlay = o.traitOverlay ?? {};
+        const existing = overlay[m.traitName] ?? {};
+        const existingConfig = existing.config ?? {};
+        return {
+          ...o,
+          traitOverlay: {
+            ...overlay,
+            [m.traitName]: {
+              ...existing,
+              config: { ...existingConfig, [m.key]: m.value }
+            }
+          }
+        };
+      });
+    case "add-extra-trait":
+      return patchOrbital(state, m.orbitalName, (o) => {
+        const existing = o.extraTraits ?? [];
+        if (existing.some((t) => t.ref === m.trait.ref)) return o;
+        return { ...o, extraTraits: [...existing, m.trait] };
+      });
+    case "remove-extra-trait":
+      return patchOrbital(state, m.orbitalName, (o) => ({
+        ...o,
+        extraTraits: (o.extraTraits ?? []).filter((t) => t.ref !== m.ref)
+      }));
+    case "set-rule": {
+      const rules = state.ruleOverlay?.rules ?? [];
+      const idx = rules.findIndex((r) => r.id === m.rule.id);
+      const next = idx >= 0 ? rules.map((r, i) => i === idx ? m.rule : r) : [...rules, m.rule];
+      return {
+        ...state,
+        ruleOverlay: { ...state.ruleOverlay ?? { rules: [] }, rules: next }
+      };
+    }
+    case "remove-rule": {
+      const rules = state.ruleOverlay?.rules ?? [];
+      const next = rules.filter((r) => r.id !== m.ruleId);
+      return {
+        ...state,
+        ruleOverlay: { ...state.ruleOverlay ?? { rules: [] }, rules: next }
+      };
+    }
+  }
+}
+function patchOrbital(state, orbitalName, patch) {
+  return {
+    ...state,
+    orbitals: state.orbitals.map(
+      (o) => o.orbitalName === orbitalName ? patch(o) : o
+    )
+  };
+}
+
+export { applyFactoryCallPlanMutation, diffFactoryCalls, translateDomainToParams, translateDomainToParams as translateOverlaysToParams };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map