@almadar/core 10.110.0 → 10.111.0

package/dist/{bus-CuAsuaHW.d.ts → bus-DS-GzSrs.d.ts}

@@ -1,6 +1,6 @@
-import { F as FieldValue, S as ServerReportedEffect, N as NamespacedEffectName, g as EntityRow, d as OrbitalId, T as TraitId, b as EventId, h as PatternConfig, i as ResolvedPatternProps, A as AnyPatternConfig } from './effect-2JoKc8Zj.js';
+import { F as FieldValue, S as ServerReportedEffect, N as NamespacedEffectName, g as EntityRow, d as OrbitalId, T as TraitId, b as EventId, h as PatternConfig, i as ResolvedPatternProps, A as AnyPatternConfig } from './effect-BD47AL48.js';
 import { z } from 'zod';
-import { a as EventPayloadValue, b as EventPayload } from './expression-DhTTuu2W.js';
+import { a as EventPayloadValue, b as EventPayload } from './expression-Dz84kipC.js';
 
 /**
  * Authenticated user context — what `@user.x` resolves against.

package/dist/{effect-2JoKc8Zj.d.ts → effect-BD47AL48.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { S as SExpr, b as EventPayload, E as Expression } from './expression-DhTTuu2W.js';
+import { S as SExpr, b as EventPayload, E as Expression } from './expression-Dz84kipC.js';
 import { J as JsonValue, R as RuntimeValue } from './json-D8gmyK3l.js';
 
 /**

package/dist/{entityAccess-CuKaSX0N.d.ts → entityAccess-Dc6o3AYo.d.ts}

@@ -1,6 +1,6 @@
-import { O as OrbitalEntity } from './effect-2JoKc8Zj.js';
-import { O as OrbitalSchema, a as OrbitalDefinition } from './schema-DqBoP7Ab.js';
-import { S as SExpr } from './expression-DhTTuu2W.js';
+import { O as OrbitalEntity } from './effect-BD47AL48.js';
+import { O as OrbitalSchema, a as OrbitalDefinition } from './schema-B3GE83sz.js';
+import { S as SExpr } from './expression-Dz84kipC.js';
 
 /**
  * Entity access policies — the declared `@read`/`@create`/`@update`/`@delete`

package/dist/{expression-DhTTuu2W.d.ts → expression-Dz84kipC.d.ts}

@@ -53,8 +53,10 @@ declare const SExprDataSchema: z.ZodType<SExpr>;
  */
 declare const SExprAtomSchema: z.ZodType<SExprAtom>;
 /**
- * Recursive schema for S-expressions.
- * Validates that arrays have at least one element and first element is a string (operator).
+ * Recursive schema for S-expressions: an atom, or a call — an array whose first element is its
+ * string operator. A call's arguments are data (`SExprDataSchema`): an argument array without
+ * an operator head is a literal list, as both evaluators read it (an inlined config list in
+ * `["array/nth", [{…}, {…}], "@entity.i"]`).
  */
 declare const SExprSchema: z.ZodType<SExpr>;
 /**

package/dist/factory/index.d.ts

@@ -1,10 +1,10 @@
-import { k as FactorySignatureCatalog, h as FactoryParamValue, c as FactoryConfigTier, b as FactoryConfigParam, F as FactoryCallSite, j as FactorySignature, R as RuleOverlay, p as RuleOverlayEntry, o as PresentationOverlay, T as TraitOverlay, J as JsonSchema } from '../types-2uS2WfIo.js';
-export { a as FactoryCallSiteParams, d as FactoryEntitySignature, e as FactoryEventSignature, f as FactoryExposure, g as FactoryPageSignature, i as FactoryProvenance, l as FactorySignatureEntityField, m as FactoryTraitSignature, n as JsonSchemaType, O as OwnershipOverlayEntry, P as PresentationNavItem, S as SchemaFieldType, q as TraitOverlayEntry, r as TraitOverlayListener } from '../types-2uS2WfIo.js';
-import { a as EntityPersistence, E as EntityField } from '../effect-2JoKc8Zj.js';
-import { a as TraitReference } from '../trait-S5uhI089.js';
-export { J as JsonValue } from '../json-D8gmyK3l.js';
+import { k as FactorySignatureCatalog, h as FactoryParamValue, c as FactoryConfigTier, b as FactoryConfigParam, F as FactoryCallSite, j as FactorySignature, R as RuleOverlay, p as RuleOverlayEntry, o as PresentationOverlay, T as TraitOverlay, J as JsonSchema } from '../types-5IX1FGgd.js';
+export { a as FactoryCallSiteParams, d as FactoryEntitySignature, e as FactoryEventSignature, f as FactoryExposure, g as FactoryPageSignature, i as FactoryProvenance, l as FactorySignatureEntityField, m as FactoryTraitSignature, n as JsonSchemaType, O as OwnershipOverlayEntry, P as PresentationNavItem, S as SchemaFieldType, q as TraitOverlayEntry, r as TraitOverlayListener } from '../types-5IX1FGgd.js';
+import { J as JsonValue } from '../json-D8gmyK3l.js';
+import { a as EntityPersistence, E as EntityField } from '../effect-BD47AL48.js';
+import { a as TraitReference } from '../trait-BNxIGRUF.js';
 import 'zod';
-import '../expression-DhTTuu2W.js';
+import '../expression-Dz84kipC.js';
 
 /**
  * Rehydrate `overridableConfigKeys` from a catalog's `knobDefs` table,
@@ -22,6 +22,80 @@ import '../expression-DhTTuu2W.js';
  */
 declare function rehydrateKnobDefs(catalog: FactorySignatureCatalog): FactorySignatureCatalog;
 
+/**
+ * Three-way merge of an orbital's factory params: the common ancestor (`base`), and each side's
+ * edit (`ours`, `theirs`). Objects merge key by key; a list whose items are objects carrying a
+ * string `id` (entity fields, trait children, nav items) merges item by item and keeps either
+ * side's reorder alongside the other's inserts; any other list is one value.
+ *
+ * Only a value both sides changed differently (`both-changed`) or an item/key one side removed
+ * while the other changed it (`delete-vs-edit`) is a conflict. A conflicted value keeps ours in
+ * `merged` until it is resolved.
+ */
+
+type ParamConflictKind = 'both-changed' | 'delete-vs-edit';
+interface ParamConflict {
+    /** Keys and item ids from the params root to the conflicted value. */
+    path: string[];
+    kind: ParamConflictKind;
+    /** `null` stands for absent. */
+    base: JsonValue;
+    ours: JsonValue;
+    theirs: JsonValue;
+}
+interface ParamsMerge {
+    merged: JsonValue;
+    conflicts: ParamConflict[];
+}
+declare function mergeParams(base: JsonValue, ours: JsonValue, theirs: JsonValue): ParamsMerge;
+
+/**
+ * The behavior-contract slice `orbital-lolo` reads at parse time (a behavior package's
+ * `loloContracts` sidecar): per behavior, each trait's `entityContract.requires` and overridable
+ * config-key types, its page names, orbital-level config and app-level config.
+ *
+ * Built from a package's own factory-signature catalog(s) and its own `.orb` documents. A behavior
+ * with no factory signature (a template, or a behavior a user published from the Studio) takes its
+ * slice from its `.orb` alone. Pure: the cascade (`@almadar-io/almadar-pattern-sync`) and the
+ * Studio's behavior packages read their files and call this, one copy of the rule.
+ */
+
+/** One trait's parse-time-checkable contract. Mirrors `TraitContract` in `orbital-lolo/src/registry.rs`. */
+interface LoloTraitContract {
+    /** Entity fields the trait reads (`@entity.<field>`); a rebind target must supply all of these. */
+    requires: string[];
+    /** Overridable config keys → their lolo type. */
+    config: Record<string, string>;
+}
+/** One orbital's parse-time-checkable contract. Mirrors `OrbitalContract` in `orbital-lolo/src/registry.rs`. */
+interface LoloOrbitalContract {
+    config: Record<string, string>;
+}
+/** One behavior's slice. Mirrors `Behavior` in `orbital-lolo/src/registry.rs`. */
+interface LoloBehaviorContract {
+    traits: Record<string, LoloTraitContract>;
+    pages: string[];
+    /** Orbital contracts, keyed by orbital name — the `Alias.orbitals.X` surface. */
+    orbitals: Record<string, LoloOrbitalContract>;
+    /** App-level (organism-wide) declared config keys → their lolo type. */
+    appConfig: Record<string, string>;
+}
+/** One behavior's `.orb` document, named as its registry file is (`<name>.orb`). */
+interface NamedOrb {
+    name: string;
+    orb: JsonValue;
+}
+/**
+ * A declared config knob's lolo type: its explicit `type` when present, else inferred from its
+ * `default`'s JS runtime type.
+ */
+declare function inferConfigType(spec: JsonValue | undefined): string | undefined;
+/** Recursively sort object keys so emitted JSON is byte-stable across runs. */
+declare function sortKeysDeep(v: JsonValue): JsonValue;
+declare function buildLoloBehaviorContracts(catalogs: readonly FactorySignatureCatalog[], orbs: readonly NamedOrb[]): Record<string, LoloBehaviorContract>;
+/** The sidecar file's content: `{ behaviors }`, key-sorted. */
+declare function serializeLoloBehaviorContracts(behaviors: Record<string, LoloBehaviorContract>): string;
+
 /**
  * Typed questionnaire surface — shapes the studio renders + answers.
  *
@@ -440,4 +514,4 @@ declare function signatureToParamsSchema(signature: FactorySignature, options?:
  */
 declare function assertNoUnsatisfiableEnum(node: JsonSchema, where: string, path?: string): void;
 
-export { type CallSiteDiff, type DomainQuestion, type DomainQuestionAnswer, type DomainQuestionAnswers, type DomainQuestionInputType, type FactoryCallPlanMutation, type FactoryCallPlanMutationTemplate, type FactoryCallPlanState, FactoryCallSite, FactoryConfigParam, FactoryConfigTier, FactoryParamValue, FactorySignature, FactorySignatureCatalog, JsonSchema, type OrbitalCallInput, PresentationOverlay, RuleOverlay, RuleOverlayEntry, TraitOverlay, type TranslationBinding, type TranslationResult, type TranslationWarning, answerToMutations, answersToMutations, applyFactoryCallPlanMutation, assertNoUnsatisfiableEnum, deriveInputType, diffFactoryCalls, generateQuestions, rehydrateKnobDefs, signatureToParamsSchema, translateOverlaysToParams };
+export { type CallSiteDiff, type DomainQuestion, type DomainQuestionAnswer, type DomainQuestionAnswers, type DomainQuestionInputType, type FactoryCallPlanMutation, type FactoryCallPlanMutationTemplate, type FactoryCallPlanState, FactoryCallSite, FactoryConfigParam, FactoryConfigTier, FactoryParamValue, FactorySignature, FactorySignatureCatalog, JsonSchema, JsonValue, type LoloBehaviorContract, type LoloOrbitalContract, type LoloTraitContract, type NamedOrb, type OrbitalCallInput, type ParamConflict, type ParamConflictKind, type ParamsMerge, PresentationOverlay, RuleOverlay, RuleOverlayEntry, TraitOverlay, type TranslationBinding, type TranslationResult, type TranslationWarning, answerToMutations, answersToMutations, applyFactoryCallPlanMutation, assertNoUnsatisfiableEnum, buildLoloBehaviorContracts, deriveInputType, diffFactoryCalls, generateQuestions, inferConfigType, mergeParams, rehydrateKnobDefs, serializeLoloBehaviorContracts, signatureToParamsSchema, sortKeysDeep, translateOverlaysToParams };

package/dist/factory/index.js

@@ -30,6 +30,181 @@ function rehydrateKnobDefs(catalog) {
   }
   return catalog;
 }
+var JsonValueSchema = z.lazy(
+  () => z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(JsonValueSchema), z.record(JsonValueSchema)])
+);
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/factory/merge.ts
+function canonical(v) {
+  if (Array.isArray(v)) return `[${v.map(canonical).join(",")}]`;
+  if (isJsonObject(v)) return `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${canonical(v[k] ?? null)}`).join(",")}}`;
+  return JSON.stringify(v);
+}
+var same = (a, b) => a === void 0 || b === void 0 ? a === b : canonical(a) === canonical(b);
+function isIdList(v) {
+  return Array.isArray(v) && v.length > 0 && v.every((i) => isJsonObject(i) && typeof i["id"] === "string");
+}
+var idList = (v) => v === void 0 || Array.isArray(v) && v.length === 0 || isIdList(v);
+function mergeParams(base, ours, theirs) {
+  const conflicts = [];
+  const merged = mergeValue([], base, ours, theirs, conflicts);
+  return { merged: merged === void 0 ? null : merged, conflicts };
+}
+function mergeValue(path, base, ours, theirs, conflicts) {
+  if (same(ours, theirs)) return ours;
+  if (same(base, ours)) return theirs;
+  if (same(base, theirs)) return ours;
+  if (ours !== void 0 && theirs !== void 0 && isJsonObject(ours) && isJsonObject(theirs) && (base === void 0 || isJsonObject(base))) {
+    return mergeObject(path, base, ours, theirs, conflicts);
+  }
+  if (ours !== void 0 && theirs !== void 0 && (isIdList(ours) || isIdList(theirs)) && idList(ours) && idList(theirs) && idList(base)) {
+    return mergeIdList(path, base ?? [], ours, theirs, conflicts);
+  }
+  conflicts.push({
+    path,
+    kind: ours === void 0 || theirs === void 0 ? "delete-vs-edit" : "both-changed",
+    base: base ?? null,
+    ours: ours ?? null,
+    theirs: theirs ?? null
+  });
+  return ours;
+}
+function mergeObject(path, base, ours, theirs, conflicts) {
+  const out = {};
+  const keys = [.../* @__PURE__ */ new Set([...Object.keys(base ?? {}), ...Object.keys(ours), ...Object.keys(theirs)])];
+  for (const key of keys) {
+    const value = mergeValue([...path, key], base?.[key], ours[key], theirs[key], conflicts);
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+var idsOf = (list) => list.map((i) => i.id);
+function mergeIdList(path, base, ours, theirs, conflicts) {
+  const byId = (list) => new Map(list.map((i) => [i.id, i]));
+  const b = byId(base);
+  const o = byId(ours);
+  const t = byId(theirs);
+  const result = /* @__PURE__ */ new Map();
+  for (const id of /* @__PURE__ */ new Set([...b.keys(), ...o.keys(), ...t.keys()])) {
+    const value = mergeValue([...path, id], b.get(id), o.get(id), t.get(id), conflicts);
+    if (value !== void 0) result.set(id, value);
+  }
+  const common = (list) => idsOf(list).filter((id) => b.has(id));
+  const reordered = (list) => canonical(common(list).filter((id) => o.has(id) && t.has(id))) !== canonical(idsOf(base).filter((id) => o.has(id) && t.has(id)));
+  const [primary, secondary] = reordered(ours) || !reordered(theirs) ? [ours, theirs] : [theirs, ours];
+  const order = idsOf(primary).filter((id) => result.has(id));
+  const secondaryIds = idsOf(secondary);
+  secondaryIds.forEach((id, index) => {
+    if (!result.has(id) || order.includes(id)) return;
+    const before = secondaryIds.slice(0, index).reverse().find((prev) => order.includes(prev));
+    order.splice(before === void 0 ? 0 : order.indexOf(before) + 1, 0, id);
+  });
+  for (const id of result.keys()) if (!order.includes(id)) order.push(id);
+  return order.map((id) => result.get(id) ?? null);
+}
+
+// src/factory/lolo-behavior-contracts.ts
+var JS_TO_LOLO_TYPE = {
+  string: "string",
+  number: "number",
+  integer: "number",
+  boolean: "boolean",
+  array: "array",
+  object: "object"
+};
+function jsToLolo(t) {
+  return JS_TO_LOLO_TYPE[t ?? ""] ?? (t || "string");
+}
+function inferConfigType(spec) {
+  if (spec === void 0 || !isJsonObject(spec)) return void 0;
+  const explicit = spec["type"];
+  if (typeof explicit === "string" && explicit.length > 0) return explicit;
+  const d = spec["default"];
+  if (Array.isArray(d)) return "array";
+  if (d === null || d === void 0) return void 0;
+  return typeof d;
+}
+function sortKeysDeep(v) {
+  if (Array.isArray(v)) return v.map(sortKeysDeep);
+  if (isJsonObject(v)) {
+    const out = {};
+    for (const k of Object.keys(v).sort()) out[k] = sortKeysDeep(v[k] ?? null);
+    return out;
+  }
+  return v;
+}
+var objectsOf = (v) => Array.isArray(v) ? v.filter(isJsonObject) : [];
+var objectOf = (v) => v !== void 0 && isJsonObject(v) ? v : {};
+var stringsOf = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+function configTypes(config) {
+  const out = {};
+  for (const [key, spec] of Object.entries(objectOf(config))) out[key] = jsToLolo(inferConfigType(spec));
+  return out;
+}
+function buildLoloBehaviorContracts(catalogs, orbs) {
+  const behaviors = {};
+  const entryFor = (name) => behaviors[name] ?? (behaviors[name] = { traits: {}, pages: [], orbitals: {}, appConfig: {} });
+  for (const raw of catalogs) {
+    const catalog = rehydrateKnobDefs(raw);
+    for (const s of catalog.signatures) {
+      if (!s.organism) continue;
+      const entry = entryFor(s.organism);
+      for (const t of s.traits) {
+        if (t.name in entry.traits) continue;
+        const config = {};
+        for (const ck of t.overridableConfigKeys ?? []) {
+          if (ck?.key) config[ck.key] = jsToLolo(ck.type);
+        }
+        entry.traits[t.name] = { requires: [...t.entityContract?.requires ?? []], config };
+      }
+      for (const p of s.pages) {
+        if (p?.name && !entry.pages.includes(p.name)) entry.pages.push(p.name);
+      }
+    }
+  }
+  for (const entry of Object.values(behaviors)) entry.pages.sort();
+  for (const { name, orb } of orbs) {
+    if (behaviors[name]) continue;
+    const traits = {};
+    const pages = [];
+    for (const orbital of objectsOf(objectOf(orb)["orbitals"])) {
+      for (const t of objectsOf(orbital["traits"])) {
+        const traitName = t["name"];
+        if (typeof traitName !== "string") continue;
+        traits[traitName] = { requires: stringsOf(objectOf(t["entityContract"])["requires"]), config: configTypes(t["config"]) };
+      }
+      for (const p of objectsOf(orbital["pages"])) {
+        if (typeof p["name"] === "string" && p["name"]) pages.push(p["name"]);
+      }
+    }
+    behaviors[name] = { traits, pages, orbitals: {}, appConfig: {} };
+  }
+  for (const { name, orb } of orbs) {
+    const target = entryFor(name);
+    const doc = objectOf(orb);
+    Object.assign(target.appConfig, configTypes(doc["config"]));
+    for (const orbital of objectsOf(doc["orbitals"])) {
+      const orbitalName = orbital["name"];
+      if (typeof orbitalName !== "string" || !orbitalName) continue;
+      target.orbitals[orbitalName] = { config: configTypes(orbital["config"]) };
+    }
+  }
+  return behaviors;
+}
+function serializeLoloBehaviorContracts(behaviors) {
+  const doc = {};
+  for (const [name, b] of Object.entries(behaviors)) {
+    const traits = {};
+    for (const [t, c] of Object.entries(b.traits)) traits[t] = { requires: c.requires, config: c.config };
+    const orbitals = {};
+    for (const [o, c] of Object.entries(b.orbitals)) orbitals[o] = { config: c.config };
+    doc[name] = { traits, pages: b.pages, orbitals, appConfig: b.appConfig };
+  }
+  return JSON.stringify(sortKeysDeep({ behaviors: doc }));
+}
 
 // src/factory/questions/generate.ts
 function generateQuestions(plan, catalog, ruleOverlay, _userPrompt) {
@@ -500,10 +675,10 @@ function applyEntityFields(binding, signature, params) {
     params.entityFields = [...binding.entityFields];
     return;
   }
-  const canonical = new Set(signature.entities[0].fields.map((f) => f.name));
+  const canonical2 = new Set(signature.entities[0].fields.map((f) => f.name));
   const extras = [];
   for (const f of binding.entityFields) {
-    if (f.name && canonical.has(f.name)) continue;
+    if (f.name && canonical2.has(f.name)) continue;
     extras.push(f);
   }
   if (extras.length > 0) params.entityFields = extras;
@@ -53174,9 +53349,6 @@ var patterns_registry_default = {
       }
     }
   }};
-var JsonValueSchema = z.lazy(
-  () => z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(JsonValueSchema), z.record(JsonValueSchema)])
-);
 
 // src/patterns/helpers/prompt-helpers.ts
 function getAllPatternTypes() {
@@ -53585,7 +53757,7 @@ var SExprAtomSchema = z.union([
 var SExprSchema = z.lazy(
   () => z.union([
     SExprAtomSchema,
-    z.array(z.lazy(() => SExprSchema)).min(1).refine(
+    z.array(SExprDataSchema).min(1).refine(
       (arr) => typeof arr[0] === "string",
       { message: "S-expression array must have a string operator as first element" }
     )
@@ -54165,6 +54337,6 @@ var PAGE_OVERRIDE_SCHEMA = {
   }
 };
 
-export { answerToMutations, answersToMutations, applyFactoryCallPlanMutation, assertNoUnsatisfiableEnum, deriveInputType, diffFactoryCalls, generateQuestions, rehydrateKnobDefs, signatureToParamsSchema, translateOverlaysToParams };
+export { answerToMutations, answersToMutations, applyFactoryCallPlanMutation, assertNoUnsatisfiableEnum, buildLoloBehaviorContracts, deriveInputType, diffFactoryCalls, generateQuestions, inferConfigType, mergeParams, rehydrateKnobDefs, serializeLoloBehaviorContracts, signatureToParamsSchema, sortKeysDeep, translateOverlaysToParams };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map