@almadar/core 10.129.0 → 11.0.0

package/dist/factory-runtime/index.js

@@ -1,11 +1,18 @@
-import { orbitalTouchesOwnRecord, applyParamsToOrb } from '../chunk-6LR43Z5E.js';
-export { applyDeclarationEntityRename, applyDeclarationTraitRenames, applyParamsToOrb, declaredEntityName, healEntityLedgerRows, healTraitLedgerRows, rebindInlineTraitEntity, rewriteEntityInInlineTrait, rewriteTraitRefsInTree, validateOrbitalFactoryParams } from '../chunk-6LR43Z5E.js';
-export { mergeCallSiteConfigOverrides } from '../chunk-45I2O4SJ.js';
+import { orbitalTouchesOwnRecord } from '../chunk-FQLEAMAB.js';
+import '../chunk-HEXOGHQ4.js';
+import '../chunk-3URQAGD7.js';
+import '../chunk-MTBEBSNO.js';
+import { makeOrbitalWithUses, makePageRef, makeTraitRef } from '../chunk-JCD6GLBX.js';
+import { overrideDeclaredKnobs, mergeCallSiteConfigOverrides } from '../chunk-ZEI7C32D.js';
+export { mergeCallSiteConfigOverrides } from '../chunk-ZEI7C32D.js';
 import '../chunk-M4S2B5VJ.js';
-import { persistenceModeAllowsOverrides } from '../chunk-GTY53NS5.js';
-import '../chunk-QUOTJULD.js';
-import '../chunk-RYPVOI6H.js';
-import '../chunk-QRHJUS3D.js';
+import { persistenceModeAllowsOverrides } from '../chunk-FGT5OS2Y.js';
+import '../chunk-347APWFM.js';
+import { ledgerRename } from '../chunk-VG7BRFUD.js';
+import '../chunk-B4MNHGBP.js';
+import '../chunk-MGLG2XLD.js';
+import '../chunk-7GHJU5WI.js';
+import '../chunk-UZPYYI37.js';
 
 // src/factory-runtime/extract-manifest.ts
 var STATIC_PARAM_FIELDS = [
@@ -98,6 +105,518 @@ function extractManifest(orb) {
   });
 }
 
+// src/factory-runtime/apply-params-to-orb.ts
+function validateOrbitalFactoryParams(manifest, raw) {
+  if (raw === null || Array.isArray(raw)) {
+    return {
+      ok: false,
+      error: { kind: "not-object", received: Array.isArray(raw) ? "array" : "null" }
+    };
+  }
+  const ALLOWED_KEYS = new Set(manifest.paramFields.map((f) => f.name));
+  for (const key of Object.keys(raw)) {
+    if (!ALLOWED_KEYS.has(key)) {
+      return { ok: false, error: { kind: "unknown-key", key } };
+    }
+  }
+  const candidate = raw;
+  if (candidate.traitOverrides !== void 0) {
+    const to = candidate.traitOverrides;
+    if (to === null || typeof to !== "object" || Array.isArray(to)) {
+      return {
+        ok: false,
+        error: {
+          kind: "trait-overrides-not-object",
+          received: Array.isArray(to) ? "array" : typeof to
+        }
+      };
+    }
+    const allowed = new Set(manifest.traitNames);
+    for (const traitName of Object.keys(to)) {
+      if (!allowed.has(traitName)) {
+        return {
+          ok: false,
+          error: {
+            kind: "unknown-trait-override",
+            trait: traitName,
+            allowed: manifest.traitNames
+          }
+        };
+      }
+    }
+  }
+  if (candidate.config !== void 0) {
+    const cfg = candidate.config;
+    if (cfg === null || typeof cfg !== "object" || Array.isArray(cfg)) {
+      return {
+        ok: false,
+        error: { kind: "config-not-object", received: Array.isArray(cfg) ? "array" : typeof cfg }
+      };
+    }
+    const allowedKeys = manifest.configKeys ?? [];
+    for (const key of Object.keys(cfg)) {
+      if (!allowedKeys.includes(key)) {
+        return { ok: false, error: { kind: "unknown-config-key", key, allowed: allowedKeys } };
+      }
+    }
+  }
+  return { ok: true, params: candidate };
+}
+function assertResolvedEntity(entity, orbitalName, orbName) {
+  if (typeof entity === "string") {
+    throw new Error(
+      `applyParamsToOrb: orbital "${orbitalName}" in orb "${orbName}" has an unresolved entity reference (string form). Pass a resolved .orb.`
+    );
+  }
+  if ("extends" in entity) {
+    throw new Error(
+      `applyParamsToOrb: orbital "${orbitalName}" in orb "${orbName}" has an unresolved EntityCall ("extends" form). Pass a resolved .orb.`
+    );
+  }
+  return entity;
+}
+function findOrbitalOrThrow(orb, orbitalName) {
+  const orbital = orb.orbitals.find((o) => o.name === orbitalName);
+  if (!orbital) {
+    throw new Error(
+      `applyParamsToOrb: orbital "${orbitalName}" not found in orb "${orb.name}". Available: ${orb.orbitals.map((o) => o.name).join(", ")}`
+    );
+  }
+  return orbital;
+}
+function buildEntity(ctx, effectiveName, effectiveCollection, params) {
+  const canonicalFields = Array.isArray(ctx.canonicalEntity.fields) ? ctx.canonicalEntity.fields : [];
+  const extras = params.fields ?? [];
+  for (const f of extras) {
+    if (f.type === "enum") {
+      if (!Array.isArray(f.values) || f.values.length === 0) {
+        throw new Error(
+          `Field "${f.name ?? "<unnamed>"}" (type: "enum") requires a non-empty \`values: string[]\` array. Got: ${f.values === void 0 ? "undefined" : JSON.stringify(f.values)}.`
+        );
+      }
+    }
+    if (f.type === "relation") {
+      const rel = f.relation;
+      if (!rel || typeof rel.entity !== "string" || rel.entity.length === 0) {
+        throw new Error(
+          `Field "${f.name ?? "<unnamed>"}" (type: "relation") requires \`relation: { entity: <EntityName>, cardinality: "one" | "many" }\`. Got: ${rel === void 0 ? "undefined" : JSON.stringify(rel)}.`
+        );
+      }
+      if (rel.cardinality !== "one" && rel.cardinality !== "many") {
+        throw new Error(
+          `Field "${f.name ?? "<unnamed>"}" (type: "relation") requires \`relation.cardinality: "one" | "many"\`. Got: ${rel.cardinality === void 0 ? "undefined" : JSON.stringify(rel.cardinality)}.`
+        );
+      }
+    }
+  }
+  let mergedFields;
+  if (extras.length === 0) {
+    mergedFields = canonicalFields;
+  } else {
+    const extraNames = new Set(extras.map((f) => f.name));
+    mergedFields = [
+      ...canonicalFields.filter((f) => !extraNames.has(f.name)),
+      ...extras
+    ];
+  }
+  const allowPersistenceOverride = persistenceModeAllowsOverrides(
+    ctx.canonicalEntity.persistence,
+    ctx.dataBearing
+  );
+  const entity = {
+    name: effectiveName,
+    persistence: allowPersistenceOverride ? params.persistence ?? ctx.canonicalEntity.persistence : ctx.canonicalEntity.persistence,
+    fields: [...mergedFields]
+  };
+  if (allowPersistenceOverride && effectiveCollection !== void 0) {
+    entity.collection = effectiveCollection;
+  } else if (allowPersistenceOverride && entity.persistence === "persistent" && ctx.canonicalEntity.persistence === "runtime") {
+    entity.collection = `${(params.entityName ?? effectiveName).toLowerCase()}s`;
+  }
+  return entity;
+}
+function isTraitReferenceObject(t) {
+  if (t === null || typeof t !== "object") return false;
+  if (!("ref" in t)) return false;
+  return typeof t.ref === "string";
+}
+function isPageRefObject(p) {
+  if (p === null || typeof p !== "object") return false;
+  if (!("ref" in p)) return false;
+  return typeof p.ref === "string";
+}
+function rewriteInlineLinkedEntity(shape, oldName, newName) {
+  if (shape.linkedEntity !== oldName) return shape;
+  return { ...shape, linkedEntity: newName };
+}
+var ENTITY_POSITIONAL_OPS = [
+  { op: "fetch", entityIndex: 1 },
+  { op: "spawn", entityIndex: 1 },
+  { op: "persist", actionGuard: /* @__PURE__ */ new Set(["create", "update", "delete"]), entityIndex: 2 }
+];
+var ENTITY_VALUED_PROPS = /* @__PURE__ */ new Set([
+  "entity",
+  "source",
+  "entityType",
+  "linkedEntity"
+]);
+function rewriteEntityInSExpr(value, oldName, newName) {
+  if (value === null) return null;
+  if (typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value === "string") {
+    const prefix = `@${oldName}`;
+    if (value === prefix || value.startsWith(`${prefix}.`)) {
+      return `@${newName}${value.slice(prefix.length)}`;
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const first = value[0];
+    if (typeof first === "string") {
+      for (const entry of ENTITY_POSITIONAL_OPS) {
+        if (first !== entry.op) continue;
+        if (entry.actionGuard !== void 0) {
+          const action = value[1];
+          if (typeof action !== "string" || !entry.actionGuard.has(action)) continue;
+        }
+        const at = entry.entityIndex;
+        const slot = value[at];
+        if (typeof slot !== "string" || slot !== oldName) continue;
+        const rewritten = [];
+        for (let i = 0; i < value.length; i++) {
+          rewritten.push(i === at ? newName : rewriteEntityInSExpr(value[i], oldName, newName));
+        }
+        return rewritten;
+      }
+    }
+    return value.map((v) => rewriteEntityInSExpr(v, oldName, newName));
+  }
+  return rewriteEntityInSExprMap(value, oldName, newName);
+}
+function rewriteEntityInSExprMap(obj, oldName, newName) {
+  const next = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (ENTITY_VALUED_PROPS.has(k) && typeof v === "string" && v === oldName) {
+      next[k] = newName;
+    } else {
+      next[k] = rewriteEntityInSExpr(v, oldName, newName);
+    }
+  }
+  return next;
+}
+function rewritePayloadFieldType(typeStr, oldName, newName) {
+  if (typeStr === oldName) return newName;
+  if (typeStr === `[${oldName}]`) return `[${newName}]`;
+  return typeStr;
+}
+function rewriteEventContract(contract, oldName, newName) {
+  if (!contract.payloadSchema || contract.payloadSchema.length === 0) return contract;
+  return {
+    ...contract,
+    payloadSchema: contract.payloadSchema.map((f) => {
+      const next = { ...f, type: rewritePayloadFieldType(f.type, oldName, newName) };
+      if (typeof f.entity === "string" && f.entity === oldName) {
+        next.entity = newName;
+      }
+      return next;
+    })
+  };
+}
+function rewriteListener(listener, oldName, newName) {
+  if (!listener.payloadMapping) return listener;
+  const nextMapping = {};
+  for (const [k, v] of Object.entries(listener.payloadMapping)) {
+    nextMapping[k] = rewriteEntityInSExpr(v, oldName, newName);
+  }
+  return { ...listener, payloadMapping: nextMapping };
+}
+function rewriteTick(tick, oldName, newName) {
+  const next = { ...tick };
+  if (next.guard !== void 0 && next.guard !== null) {
+    next.guard = rewriteEntityInSExpr(next.guard, oldName, newName);
+  }
+  next.effects = next.effects.map(
+    (e) => rewriteEntityInSExpr(e, oldName, newName)
+  );
+  return next;
+}
+function rebindInlineTraitEntity(trait, oldName, newName) {
+  if (oldName === newName) return trait;
+  return rewriteEntityInInlineTrait(rewriteInlineLinkedEntity(trait, oldName, newName), oldName, newName);
+}
+function rewriteEntityInInlineTrait(trait, oldName, newName) {
+  if (oldName === newName) return trait;
+  const next = { ...trait };
+  if (next.stateMachine) {
+    next.stateMachine = {
+      ...next.stateMachine,
+      transitions: next.stateMachine.transitions.map((t) => {
+        const updated = { ...t };
+        if (updated.guard !== void 0 && updated.guard !== null) {
+          updated.guard = rewriteEntityInSExpr(updated.guard, oldName, newName);
+        }
+        if (updated.effects) {
+          updated.effects = updated.effects.map(
+            (e) => rewriteEntityInSExpr(e, oldName, newName)
+          );
+        }
+        return updated;
+      })
+    };
+  }
+  if (next.initialEffects) {
+    next.initialEffects = next.initialEffects.map(
+      (e) => rewriteEntityInSExpr(e, oldName, newName)
+    );
+  }
+  if (next.ticks) {
+    next.ticks = next.ticks.map((t) => rewriteTick(t, oldName, newName));
+  }
+  if (next.emits) {
+    next.emits = next.emits.map((c) => rewriteEventContract(c, oldName, newName));
+  }
+  if (next.listens) {
+    next.listens = next.listens.map((l) => rewriteListener(l, oldName, newName));
+  }
+  return next;
+}
+function rebuildTraits(traits) {
+  return traits.map((t) => {
+    if (!isTraitReferenceObject(t)) return t;
+    return makeTraitRef({ ...t });
+  });
+}
+function rebuildPages(pages) {
+  if (!pages) return [];
+  return pages.map((p) => {
+    if (!isPageRefObject(p)) return p;
+    return makePageRef({ ...p });
+  });
+}
+function rewriteTraitRefToken(value, renames) {
+  const prefix = "@trait.";
+  if (!value.startsWith(prefix)) return value;
+  const rest = value.slice(prefix.length);
+  const splitAt = rest.search(/[.[]/);
+  const name = splitAt === -1 ? rest : rest.slice(0, splitAt);
+  const to = renames.get(name);
+  if (to === void 0) return value;
+  return `${prefix}${to}${splitAt === -1 ? "" : rest.slice(splitAt)}`;
+}
+function rewriteTraitRefsInTree(node, renames) {
+  if (typeof node === "string") return rewriteTraitRefToken(node, renames);
+  if (Array.isArray(node)) return node.map((item) => rewriteTraitRefsInTree(item, renames));
+  if (node !== null && typeof node === "object") {
+    const out = {};
+    for (const [key, value] of Object.entries(node)) out[key] = rewriteTraitRefsInTree(value, renames);
+    return out;
+  }
+  return node;
+}
+function rekeyTraitEmbedIds(embedIds, renames) {
+  let out;
+  for (const [token, id] of Object.entries(embedIds)) {
+    const to = renames.get(token);
+    if (to === void 0) continue;
+    out = out ?? { ...embedIds };
+    delete out[token];
+    out[to] = id;
+  }
+  return out ?? embedIds;
+}
+function applyDeclarationTraitRenames(schema, renames, at) {
+  if (renames.size === 0) return schema;
+  const renamedTraitIds = [];
+  const renameDeclaration = (t) => {
+    if (typeof t !== "object" || t === null) return t;
+    let next = t;
+    const named = t;
+    if (typeof named.name === "string") {
+      const renamed = renames.get(named.name);
+      if (renamed !== void 0) {
+        const id = t.id;
+        if (typeof id === "string") renamedTraitIds.push({ id, to: renamed });
+        next = { ...next, name: renamed };
+      }
+    }
+    const walked = rewriteTraitRefsInTree(next, renames);
+    const embedIds = walked.traitEmbedIds;
+    if (embedIds !== void 0) {
+      const rekeyed = rekeyTraitEmbedIds(embedIds, renames);
+      if (rekeyed !== embedIds) {
+        walked.traitEmbedIds = rekeyed;
+      }
+    }
+    return walked;
+  };
+  const renamePageTraitRefs = (p) => {
+    if (typeof p !== "object" || p === null) return p;
+    const walked = rewriteTraitRefsInTree(p, renames);
+    const traits = walked.traits;
+    if (!Array.isArray(traits)) return walked;
+    return {
+      ...walked,
+      traits: traits.map((t) => {
+        if (typeof t === "string") return renames.get(t) ?? t;
+        const to = renames.get(t.ref);
+        return to === void 0 ? t : { ...t, ref: to };
+      })
+    };
+  };
+  const orbitals = schema.orbitals.map((orbital) => {
+    if (!("traits" in orbital) || !Array.isArray(orbital.traits)) return orbital;
+    return {
+      ...orbital,
+      traits: orbital.traits.map(renameDeclaration),
+      ...orbital.pages !== void 0 ? { pages: orbital.pages.map(renamePageTraitRefs) } : {}
+    };
+  });
+  let ledger = schema.ledger;
+  if (ledger !== void 0) {
+    for (const { id, to } of renamedTraitIds) {
+      ledger = ledgerRename(ledger, id, to, at);
+    }
+  }
+  return { ...schema, orbitals, ...ledger !== schema.ledger ? { ledger } : {} };
+}
+function declaredEntityName(orbital) {
+  const entity = orbital.entity;
+  if (typeof entity === "object" && entity !== null && typeof entity.name === "string") return entity.name;
+  return orbital.reference?.entity ?? null;
+}
+function applyDeclarationEntityRename(schema, rename, at) {
+  if (rename.from === rename.to) return schema;
+  const linkedEntityIsFrom = (shape) => shape.linkedEntity === rename.from;
+  const renamedEntityIds = [];
+  const orbitals = schema.orbitals.map((orbital) => {
+    const entity = orbital.entity;
+    if (orbital.reference !== void 0 && orbital.reference.entity === rename.from) {
+      return {
+        ...orbital,
+        reference: { ...orbital.reference, entity: rename.to },
+        traits: orbital.traits.map(
+          (t) => typeof t === "object" && t !== null && linkedEntityIsFrom(t) ? { ...t, linkedEntity: rename.to } : t
+        )
+      };
+    }
+    if (typeof entity !== "object" || entity === null || entity.name !== rename.from) {
+      return orbital;
+    }
+    const entityId = entity.id;
+    if (typeof entityId === "string") renamedEntityIds.push(entityId);
+    const traits = orbital.traits.map(
+      (t) => typeof t === "object" && t !== null && linkedEntityIsFrom(t) ? { ...t, linkedEntity: rename.to } : t
+    );
+    const pages = orbital.pages?.map(
+      (p) => typeof p === "object" && p !== null && linkedEntityIsFrom(p) ? { ...p, linkedEntity: rename.to } : p
+    );
+    return {
+      ...orbital,
+      entity: { ...entity, name: rename.to },
+      traits,
+      ...pages !== void 0 ? { pages } : {}
+    };
+  });
+  let ledger = schema.ledger;
+  if (ledger !== void 0) {
+    for (const id of renamedEntityIds) {
+      ledger = ledgerRename(ledger, id, rename.to, at);
+    }
+  }
+  return { ...schema, orbitals, ...ledger !== schema.ledger ? { ledger } : {} };
+}
+function healEntityLedgerRows(schema, at) {
+  let ledger = schema.ledger;
+  if (ledger === void 0) return schema;
+  for (const orbital of schema.orbitals) {
+    const entity = orbital.entity;
+    if (typeof entity !== "object" || entity === null) continue;
+    const id = entity.id;
+    const name = entity.name;
+    if (typeof id !== "string" || typeof name !== "string") continue;
+    const entry = ledger.entries[id];
+    if (entry === void 0 || entry.kind !== "entity" || entry.curName === name) continue;
+    ledger = ledgerRename(ledger, id, name, at);
+  }
+  return ledger !== schema.ledger ? { ...schema, ledger } : schema;
+}
+function healTraitLedgerRows(schema, at) {
+  let ledger = schema.ledger;
+  if (ledger === void 0) return schema;
+  for (const orbital of schema.orbitals) {
+    for (const trait of orbital.traits ?? []) {
+      if (typeof trait !== "object" || trait === null) continue;
+      const id = trait.id;
+      if (typeof id !== "string") continue;
+      const declared = trait;
+      const name = typeof declared.name === "string" ? declared.name : typeof declared.ref === "string" ? declared.ref.slice(declared.ref.lastIndexOf(".") + 1) : void 0;
+      if (name === void 0) continue;
+      const entry = ledger.entries[id];
+      if (entry === void 0 || entry.kind !== "trait" || entry.curName === name) continue;
+      ledger = ledgerRename(ledger, id, name, at);
+    }
+  }
+  return ledger !== schema.ledger ? { ...schema, ledger } : schema;
+}
+function applyParamsToOrb(orb, orbitalName, _manifest, params) {
+  const orbital = findOrbitalOrThrow(orb, orbitalName);
+  const canonicalEntity = assertResolvedEntity(orbital.entity, orbitalName, orb.name);
+  const canonicalEntityName = canonicalEntity.name;
+  const effectiveCollection = typeof canonicalEntity.collection === "string" ? params.collection ?? (params.entityName ? `${params.entityName.toLowerCase()}s` : canonicalEntity.collection) : params.collection;
+  const ctx = { canonicalEntity, dataBearing: orbitalTouchesOwnRecord(orbital) };
+  const built = makeOrbitalWithUses({
+    name: orbital.name,
+    uses: orbital.uses ?? [],
+    // Derived `expects` declarations ride the overlay untouched — they name
+    // SIBLING entities (never the orbital's own), so the entityName rename
+    // below cannot affect them.
+    ...orbital.expects !== void 0 ? { expects: orbital.expects } : {},
+    entity: buildEntity(ctx, canonicalEntityName, effectiveCollection, params),
+    traits: rebuildTraits(orbital.traits),
+    pages: rebuildPages(orbital.pages)
+  });
+  if (orbital.config !== void 0) {
+    built.config = params.config !== void 0 ? overrideDeclaredKnobs(orbital.config, params.config) : orbital.config;
+  }
+  if (built.traits && params.traitOverrides !== void 0) {
+    built.traits = built.traits.map((t) => {
+      if (!isTraitReferenceObject(t) || typeof t.name !== "string") return t;
+      const override = params.traitOverrides?.[t.name];
+      if (!override) return t;
+      const merged = { ...t };
+      if (override.config !== void 0) {
+        merged.config = mergeCallSiteConfigOverrides(t.config ?? {}, override.config);
+      }
+      if (override.linkedEntity !== void 0) merged.linkedEntity = override.linkedEntity;
+      if (override.events !== void 0) {
+        if (override.events === null || typeof override.events !== "object" || Array.isArray(override.events)) {
+          throw new Error(
+            `traitOverrides["${t.name}"].events must be a Record<string,string> (rename map like { "OPEN": "ADD_ITEM" }), got ${Array.isArray(override.events) ? "an array" : typeof override.events}`
+          );
+        }
+        for (const [k, v] of Object.entries(override.events)) {
+          if (typeof v !== "string") {
+            throw new Error(
+              `traitOverrides["${t.name}"].events["${k}"] must be a string (target event name), got ${typeof v}`
+            );
+          }
+        }
+        merged.events = { ...t.events ?? {}, ...override.events };
+      }
+      if (override.emitsScope !== void 0) merged.emitsScope = override.emitsScope;
+      if (override.listens !== void 0) merged.listens = override.listens;
+      return merged;
+    });
+  }
+  if (built.pages && params.pagePath !== void 0) {
+    built.pages = built.pages.map((p, idx) => {
+      if (!isPageRefObject(p) || idx !== 0) return p;
+      return { ...p, path: params.pagePath };
+    });
+  }
+  return built;
+}
+
 // src/factory-runtime/apply-params-to-whole-orb.ts
 function applyParamsToWholeOrb(orb, manifests, params) {
   const manifestByOrbital = /* @__PURE__ */ new Map();
@@ -116,6 +635,6 @@ function applyParamsToWholeOrb(orb, manifests, params) {
   return { ...orb, orbitals: rebuilt };
 }
 
-export { applyParamsToWholeOrb, extractManifest, paramFieldsFor };
+export { applyDeclarationEntityRename, applyDeclarationTraitRenames, applyParamsToOrb, applyParamsToWholeOrb, declaredEntityName, extractManifest, healEntityLedgerRows, healTraitLedgerRows, paramFieldsFor, rebindInlineTraitEntity, rewriteEntityInInlineTrait, rewriteTraitRefsInTree, validateOrbitalFactoryParams };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map