@almadar/runtime 6.32.0 → 6.33.0

package/dist/{chunk-YFH577FH.js → chunk-JZDLN2FS.js}

@@ -1,10 +1,12 @@
 import { parseCron, cronMinuteKey, cronMatches } from './chunk-OU3ITB5S.js';
+import { seedRandom, randomArrayElement, randomInt, shuffleArray, randomPastDate, randomBoolean, randomRecentDate, randomUuid, randomPhone, randomUrl, randomEmail, randomWords } from './chunk-OQJIK6PZ.js';
+import { collectTraitRefsFromValue, collectTraitRefsFromEffects } from './chunk-SCRAHWOC.js';
 import { createLogger, setNamespaceLevel } from '@almadar/logger';
-import { resolveBinding, evaluate, createMinimalContext, evaluateGuard, SExpressionEvaluator } from '@almadar/evaluator';
+import { createMinimalContext, resolveBinding, evaluate, evaluateGuard, SExpressionEvaluator } from '@almadar/evaluator';
 export { createMinimalContext } from '@almadar/evaluator';
 import { isKnownStdOperator } from '@almadar/std/registry';
-import { isCallSiteConfigDeclaration, OrbitalSchemaSchema, isInlineTrait, isEntityCall, isEntityReference, parseEntityRef, parseImportedTraitRef, isPageReference, isPageReferenceString, isPageReferenceObject, parsePageRef } from '@almadar/core';
-import { faker } from '@faker-js/faker';
+import { OrbitalSchemaSchema, isInlineTrait, isEntityCall, isEntityReference, parseEntityRef, parseImportedTraitRef, isPageReference, isPageReferenceString, isPageReferenceObject, parsePageRef, configRefEventKnob, normalizeCallSiteConfigToValues, resolveConfigRefEventName } from '@almadar/core';
+export { normalizeCallSiteConfigToValues } from '@almadar/core';
 
 var log = createLogger("almadar:runtime:eventbus");
 var EventBus = class {
@@ -289,6 +291,33 @@ var bindLog = createLogger("almadar:runtime:bindings");
 setNamespaceLevel("almadar:runtime:bindings", "WARN");
 var renderLog = createLogger("almadar:runtime:render-ui");
 var CLIENT_ONLY_BINDING_ROOTS = /* @__PURE__ */ new Set(["trait"]);
+var CALLSITE_PAYLOAD_PREFIX = "@callsitePayload.";
+function payloadValueToConfigValue(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") return v;
+  if (v instanceof Date) return v.toISOString();
+  if (Array.isArray(v)) return v.map(payloadValueToConfigValue);
+  if (typeof v === "object") {
+    const obj = {};
+    for (const [k, val] of Object.entries(v)) obj[k] = payloadValueToConfigValue(val);
+    return obj;
+  }
+  return String(v);
+}
+function resolveCallSitePayloadCaptures(config, payload) {
+  let ctx;
+  const out = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (typeof value === "string" && value.startsWith(CALLSITE_PAYLOAD_PREFIX)) {
+      const field = value.slice(CALLSITE_PAYLOAD_PREFIX.length);
+      if (!ctx) ctx = createMinimalContext({}, payload ?? {}, "idle");
+      out[key] = payloadValueToConfigValue(resolveBinding(`@payload.${field}`, ctx));
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
 function isClientOnlyBinding(value) {
   if (!value.startsWith("@")) return false;
   const afterAt = value.slice(1);
@@ -982,7 +1011,7 @@ var StateMachineManager = class {
 
 // src/types.ts
 var HANDLER_MANIFEST = {
-  client: ["render-ui", "render", "navigate", "notify", "emit", "set", "log", "ref", "deref", "watch", "send-server"],
+  client: ["render-ui", "render", "navigate", "notify", "emit", "set", "log", "ref", "deref", "watch", "send-server", "browser/open-file-picker", "browser/clipboard-read", "browser/clipboard-write", "browser/geolocation-current"],
   server: ["persist", "fetch", "fetch-stream", "call-service", "emit", "set", "spawn", "despawn", "log", "ref", "deref", "swap!", "atomic", "os/watch-files", "os/watch-process", "os/watch-port", "os/watch-http", "os/watch-cron", "os/watch-signal", "os/watch-env", "os/debounce"],
   test: [
     "render-ui",
@@ -1002,7 +1031,11 @@ var HANDLER_MANIFEST = {
     "swap!",
     "watch",
     "atomic",
-    "send-server"
+    "send-server",
+    "browser/open-file-picker",
+    "browser/clipboard-read",
+    "browser/clipboard-write",
+    "browser/geolocation-current"
   ],
   ssr: ["render-ui", "render", "fetch", "emit", "set", "log", "ref", "deref"]
 };
@@ -1938,6 +1971,58 @@ var EffectExecutor = class _EffectExecutor {
         }, emitCfg);
         break;
       }
+      // === Browser device operators (client-side, user-gesture) ===
+      // Async host APIs routed to dedicated handler methods. Uniform
+      // `{ result }` / `{ error }` payload via runSubstrate. On the
+      // server (or any host without the API) the handler is absent →
+      // unsupported warning; a thrown error fires `emit.failure`.
+      case "browser/open-file-picker": {
+        const [positional, emitCfg] = this.splitSubstrateEmit(args);
+        const options = positional[0];
+        await this.runSubstrate(async () => {
+          if (!this.handlers.browserOpenFilePicker) {
+            this.logUnsupported("browser/open-file-picker");
+            return null;
+          }
+          return this.handlers.browserOpenFilePicker(options);
+        }, emitCfg);
+        break;
+      }
+      case "browser/clipboard-read": {
+        const [, emitCfg] = this.splitSubstrateEmit(args);
+        await this.runSubstrate(async () => {
+          if (!this.handlers.browserClipboardRead) {
+            this.logUnsupported("browser/clipboard-read");
+            return null;
+          }
+          return this.handlers.browserClipboardRead();
+        }, emitCfg);
+        break;
+      }
+      case "browser/clipboard-write": {
+        const [positional, emitCfg] = this.splitSubstrateEmit(args);
+        const text = positional[0];
+        await this.runSubstrate(async () => {
+          if (!this.handlers.browserClipboardWrite) {
+            this.logUnsupported("browser/clipboard-write");
+            return null;
+          }
+          return this.handlers.browserClipboardWrite(text);
+        }, emitCfg);
+        break;
+      }
+      case "browser/geolocation-current": {
+        const [positional, emitCfg] = this.splitSubstrateEmit(args);
+        const options = positional[0];
+        await this.runSubstrate(async () => {
+          if (!this.handlers.browserGeolocationCurrent) {
+            this.logUnsupported("browser/geolocation-current");
+            return null;
+          }
+          return this.handlers.browserGeolocationCurrent(options);
+        }, emitCfg);
+        break;
+      }
       default: {
         if (operator.includes("/")) {
           const [positional, emitCfg] = this.splitSubstrateEmit(args);
@@ -2104,21 +2189,6 @@ function collectDeclaredConfigDefaults(trait) {
   }
   return hasAny ? defaults : void 0;
 }
-function normalizeCallSiteConfigToValues(config) {
-  if (config === void 0) {
-    return void 0;
-  }
-  const out = {};
-  let hasAny = false;
-  for (const [key, entry] of Object.entries(config)) {
-    const value = isCallSiteConfigDeclaration(entry) ? entry.default : entry;
-    if (value !== void 0) {
-      out[key] = value;
-      hasAny = true;
-    }
-  }
-  return hasAny ? out : void 0;
-}
 function collectDeclaredEntityDefaults(entity) {
   if (!entity) return void 0;
   const defaults = {};
@@ -2134,7 +2204,7 @@ function collectDeclaredEntityDefaults(entity) {
 var mockLog = createLogger("almadar:runtime:mock");
 var DEFAULT_MOCK_SEED = 42;
 function picsumUrl(entityName, fieldName, width = 400, height = 400) {
-  const seed = `${entityName}-${fieldName}-${faker.number.int({ min: 0, max: 1e3 })}`;
+  const seed = `${entityName}-${fieldName}-${randomInt({ min: 0, max: 1e3 })}`;
   return `https://picsum.photos/seed/${encodeURIComponent(seed)}/${width}/${height}`;
 }
 var SEED_REFERENCE_TIMESTAMP = "2024-01-01T00:00:00.000Z";
@@ -2152,17 +2222,17 @@ var MockPersistenceAdapter = class _MockPersistenceAdapter {
       // input doesn't overwrite the default.
       seed: config.seed ?? DEFAULT_MOCK_SEED
     };
-    faker.seed(this.config.seed);
+    seedRandom(this.config.seed);
     mockLog.debug("mock:adapter:init", { seed: this.config.seed });
   }
-  /** Re-anchor faker's PRNG to the configured seed. Called before every
+  /** Re-anchor the PRNG to the configured seed. Called before every
    *  re-seed loop so identical reseed sequences produce identical rows
-   *  (timestamps + faker-generated fields). Without this, the first
+   *  (timestamps + generated fields). Without this, the first
    *  reseed produces row set A, the second produces row set B, and
    *  diff observers see all rows as "changed" between frames. */
   resetFakerSeed() {
     if (this.config.seed !== void 0) {
-      faker.seed(this.config.seed);
+      seedRandom(this.config.seed);
     }
   }
   // ============================================================================
@@ -2188,7 +2258,7 @@ var MockPersistenceAdapter = class _MockPersistenceAdapter {
   /**
    * Register an entity schema and seed mock data.
    * If the schema has seedData, those instances are used directly.
-   * Otherwise, random mock data is generated with faker.
+   * Otherwise, random mock data is generated with the seeded PRNG.
    */
   registerEntity(schema, seedCount) {
     const normalized = schema.name.toLowerCase();
@@ -2236,10 +2306,10 @@ var MockPersistenceAdapter = class _MockPersistenceAdapter {
           if (eligible.length === 0) continue;
           const cardinality = field.relation.cardinality ?? "many";
           if (cardinality === "one" || cardinality === "many-to-one") {
-            row[field.name] = faker.helpers.arrayElement(eligible);
+            row[field.name] = randomArrayElement(eligible);
           } else {
-            const pickCount = Math.min(eligible.length, faker.number.int({ min: 2, max: 4 }));
-            row[field.name] = faker.helpers.shuffle(eligible.slice()).slice(0, pickCount);
+            const pickCount = Math.min(eligible.length, randomInt({ min: 2, max: 4 }));
+            row[field.name] = shuffleArray(eligible.slice()).slice(0, pickCount);
           }
         }
       }
@@ -2291,7 +2361,7 @@ var MockPersistenceAdapter = class _MockPersistenceAdapter {
     const id = this.nextId(entityName);
     const item = {
       id,
-      createdAt: faker.date.past({ years: 1 }).toISOString(),
+      createdAt: randomPastDate({ years: 1 }).toISOString(),
       updatedAt: SEED_REFERENCE_TIMESTAMP
     };
     for (const field of fields) {
@@ -2333,16 +2403,16 @@ var MockPersistenceAdapter = class _MockPersistenceAdapter {
       case "string":
         return this.generateStringValue(entityName, field, index);
       case "number":
-        return faker.number.int({ min: 0, max: 100 });
+        return randomInt({ min: 0, max: 100 });
       case "boolean":
-        return faker.datatype.boolean();
+        return randomBoolean();
       case "date":
       case "timestamp":
       case "datetime":
         return this.generateDateValue(field);
       case "enum":
         if (field.values && field.values.length > 0) {
-          return faker.helpers.arrayElement(field.values);
+          return randomArrayElement(field.values);
         }
         return null;
       case "relation":
@@ -2367,7 +2437,7 @@ var MockPersistenceAdapter = class _MockPersistenceAdapter {
   generateArrayValue(entityName, field, index, depth = 0) {
     if (field.type !== "array" || !field.items) return [];
     if (depth >= _MockPersistenceAdapter.MAX_NESTED_DEPTH) return [];
-    const count = faker.number.int({ min: 3, max: 5 });
+    const count = randomInt({ min: 3, max: 5 });
     const out = [];
     const elementName = field.name ?? "item";
     for (let i = 0; i < count; i++) {
@@ -2381,7 +2451,7 @@ var MockPersistenceAdapter = class _MockPersistenceAdapter {
   }
   /**
    * Generate a single object value with each declared property populated
-   * by faker. Walks `properties` and recursively delegates to
+   * by the seeded PRNG. Walks `properties` and recursively delegates to
    * `generateFieldValue` per property so nested objects-of-arrays-of-objects
    * compose correctly.
    */
@@ -2398,29 +2468,29 @@ var MockPersistenceAdapter = class _MockPersistenceAdapter {
   /**
    * Generate a string value based on the field's declared schema metadata.
    * Reads `values` (enum) first, then `format` (email/url/phone/uuid/date/
-   * datetime), then falls back to faker.lorem.words. No field-name heuristics
+   * datetime), then falls back to randomWords. No field-name heuristics
    * — the schema is the source of truth. If a caller needs a real email, they
    * declare `format: "email"`; if they need an enum, they declare `values: [...]`.
    */
   generateStringValue(entityName, field, _index) {
     const values = "values" in field ? field.values : void 0;
     if (values && values.length > 0) {
-      return faker.helpers.arrayElement(values);
+      return randomArrayElement(values);
     }
     const fieldName = field.name ?? "field";
     switch (field.format) {
       case "email":
-        return faker.internet.email();
+        return randomEmail();
       case "url":
-        return faker.internet.url();
+        return randomUrl();
       case "phone":
-        return faker.phone.number();
+        return randomPhone();
       case "uuid":
-        return faker.string.uuid();
+        return randomUuid();
       case "date":
-        return faker.date.recent().toISOString().split("T")[0];
+        return randomRecentDate().toISOString().split("T")[0];
       case "datetime":
-        return faker.date.recent().toISOString();
+        return randomRecentDate().toISOString();
       case "image":
       case "avatar":
       case "thumbnail":
@@ -2430,7 +2500,7 @@ var MockPersistenceAdapter = class _MockPersistenceAdapter {
     if (lname === "image" || lname === "imageurl" || lname === "image_url" || lname === "photo" || lname === "photourl" || lname === "photo_url" || lname === "avatar" || lname === "avatarurl" || lname === "avatar_url" || lname === "thumbnail" || lname === "thumbnailurl" || lname === "thumbnail_url" || lname === "picture" || lname === "pictureurl" || lname === "cover" || lname === "coverurl" || lname === "banner" || lname === "bannerurl") {
       return picsumUrl(entityName, fieldName);
     }
-    const value = faker.lorem.words(2);
+    const value = randomWords(2);
     mockLog.debug("field:fallback-lorem", () => ({
       entityName,
       fieldName: field.name,
@@ -2446,7 +2516,7 @@ var MockPersistenceAdapter = class _MockPersistenceAdapter {
    * field-name heuristics.
    */
   generateDateValue(field) {
-    const date = faker.date.recent({ days: 30 });
+    const date = randomRecentDate({ days: 30 });
     if (field.format === "date") return date.toISOString().split("T")[0];
     return date.toISOString();
   }
@@ -2530,7 +2600,7 @@ var MockPersistenceAdapter = class _MockPersistenceAdapter {
     this.stores.delete(normalized);
     this.idCounters.delete(normalized);
   }
-  /** Clear all data + re-anchor faker so the next seed loop reproduces
+  /** Clear all data + re-anchor the PRNG so the next seed loop reproduces
    *  identical rows. Hermetic-frame mode calls this between every step
    *  via OrbitalServerRuntime.resetMockPersistence. */
   clearAll() {
@@ -3158,6 +3228,254 @@ function createUnifiedLoader(options) {
   return new UnifiedLoader(options);
 }
 createLogger("almadar:runtime:studio-config");
+
+// src/ui/splice-lambda-traits.ts
+var TRAIT_BINDING_PREFIX = "@trait.";
+var CONFIG_BINDING_PREFIX = "@config.";
+var LambdaSpliceError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "LambdaSpliceError";
+  }
+  code;
+};
+function isRenderUiEffect(effect) {
+  return Array.isArray(effect) && effect.length >= 1 && effect[0] === "render-ui";
+}
+function renderOnlyTemplate(trait) {
+  if (trait.listens && trait.listens.length > 0) return null;
+  if (trait.ticks && trait.ticks.length > 0) return null;
+  const sm = trait.stateMachine;
+  const states = sm?.states ?? [];
+  if (states.length > 1) return null;
+  let template = null;
+  for (const transition of sm?.transitions ?? []) {
+    const selfLoop = transition.from === transition.to;
+    const guarded = transition.guard !== void 0 && transition.guard !== null;
+    if (!selfLoop || guarded) return null;
+    for (const effect of transition.effects ?? []) {
+      if (!isRenderUiEffect(effect) || !Array.isArray(effect)) return null;
+      const pattern = effect[2];
+      if (pattern === void 0) return null;
+      if (template !== null) return null;
+      template = pattern;
+    }
+  }
+  return template;
+}
+function resolveObjectPath(value, path) {
+  let cur = value;
+  for (const seg of path.split(".")) {
+    if (cur === null || typeof cur !== "object") return void 0;
+    cur = cur[seg];
+    if (cur === void 0) return void 0;
+  }
+  return cur;
+}
+function substituteConfig(expr, subs) {
+  if (typeof expr === "string") {
+    if (!expr.startsWith(CONFIG_BINDING_PREFIX)) return expr;
+    const rest = expr.slice(CONFIG_BINDING_PREFIX.length);
+    const dot = rest.indexOf(".");
+    const param = dot === -1 ? rest : rest.slice(0, dot);
+    const trailing = dot === -1 ? void 0 : rest.slice(dot + 1);
+    if (!(param in subs)) return expr;
+    const value = subs[param];
+    if (trailing === void 0) {
+      if (typeof value === "string" && value === expr) return expr;
+      return substituteConfig(value, subs);
+    }
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      const leaf = resolveObjectPath(value, trailing);
+      if (leaf !== void 0) return substituteConfig(leaf, subs);
+    }
+    return expr;
+  }
+  if (Array.isArray(expr)) {
+    return expr.map((item) => substituteConfig(item, subs));
+  }
+  if (expr !== null && typeof expr === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(expr)) {
+      out[k] = substituteConfig(v, subs);
+    }
+    return out;
+  }
+  return expr;
+}
+function buildTemplate(trait) {
+  const raw = renderOnlyTemplate(trait);
+  const emits = trait.emits ?? [];
+  if (raw === null) return { template: null, emits };
+  const defaults = collectDeclaredConfigDefaults(trait);
+  const template = defaults ? substituteConfig(raw, defaults) : raw;
+  return { template, emits };
+}
+function isLambdaForm(expr) {
+  return expr.length === 3 && (expr[0] === "fn" || expr[0] === "lambda");
+}
+function spliceExpr(expr, inLambda, st) {
+  if (typeof expr === "string") {
+    if (!inLambda || !expr.startsWith(TRAIT_BINDING_PREFIX)) return expr;
+    const name = expr.slice(TRAIT_BINDING_PREFIX.length);
+    if (name.length === 0 || name.includes(".")) return expr;
+    const entry = st.templates.get(name);
+    if (entry === void 0) return expr;
+    if (entry.template === null) {
+      throw new LambdaSpliceError(
+        "LAMBDA_STATEFUL_TRAIT",
+        `Trait "${name}" keeps its own state machine and cannot be expanded per list item \u2014 use the list pattern's item events (referenced inside a lambda in trait "${st.hostName}")`
+      );
+    }
+    if (st.visiting.includes(name)) return expr;
+    st.visiting.push(name);
+    const expanded = spliceExpr(entry.template, true, st);
+    st.visiting.pop();
+    for (const emit of entry.emits) st.merged.push([name, emit]);
+    st.spliced.add(name);
+    st.changed = true;
+    return expanded;
+  }
+  if (Array.isArray(expr)) {
+    if (isLambdaForm(expr)) {
+      return [expr[0], expr[1], spliceExpr(expr[2], true, st)];
+    }
+    return expr.map((item) => spliceExpr(item, inLambda, st));
+  }
+  if (expr !== null && typeof expr === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(expr)) {
+      out[k] = spliceExpr(v, inLambda, st);
+    }
+    return out;
+  }
+  return expr;
+}
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      out[key] = canonical(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+function mergeWrapperEmits(host, incoming) {
+  const emits = [...host.emits ?? []];
+  for (const [wrapper, emit] of incoming) {
+    const existing = emits.find((e) => e.event === emit.event);
+    if (existing) {
+      const same = JSON.stringify(canonical(existing)) === JSON.stringify(canonical(emit));
+      if (!same) {
+        throw new LambdaSpliceError(
+          "EMIT_MERGE_CONFLICT",
+          `Emit "${emit.event}" merged from spliced wrapper "${wrapper}" conflicts with an existing "${emit.event}" on host "${host.name}" (different payload shape)`
+        );
+      }
+    } else {
+      emits.push(emit);
+    }
+  }
+  return emits;
+}
+function removeConsumedWrappers(traits, pages, spliced) {
+  for (; ; ) {
+    const stillReferenced = /* @__PURE__ */ new Set();
+    for (const { trait } of traits) {
+      for (const t of trait.stateMachine?.transitions ?? []) {
+        if (t.guard !== void 0 && t.guard !== null) {
+          collectTraitRefsFromValue(t.guard, stillReferenced);
+        }
+        collectTraitRefsFromEffects(t.effects, stillReferenced);
+      }
+      for (const tick of trait.ticks ?? []) {
+        if (tick.guard !== void 0 && tick.guard !== null) {
+          collectTraitRefsFromValue(tick.guard, stillReferenced);
+        }
+        collectTraitRefsFromEffects(tick.effects, stillReferenced);
+      }
+      if (trait.config) {
+        for (const field of Object.values(trait.config)) {
+          if (field && typeof field === "object" && "default" in field && field.default !== void 0) {
+            collectTraitRefsFromValue(field.default, stillReferenced);
+          }
+        }
+      }
+    }
+    const removable = /* @__PURE__ */ new Set();
+    for (const { trait } of traits) {
+      if (spliced.has(trait.name) && !stillReferenced.has(trait.name)) {
+        removable.add(trait.name);
+      }
+    }
+    if (removable.size === 0) return;
+    for (const { page } of pages) {
+      const pageTraits = page.traits;
+      if (!pageTraits) continue;
+      const survivors2 = pageTraits.filter((pt) => !removable.has(pt.ref)).length;
+      if (survivors2 === 0) {
+        for (const pt of pageTraits) removable.delete(pt.ref);
+      }
+    }
+    if (removable.size === 0) return;
+    for (const resolvedPage of pages) {
+      const pageTraits = resolvedPage.page.traits;
+      if (pageTraits) {
+        resolvedPage.page.traits = pageTraits.filter((pt) => !removable.has(pt.ref));
+      }
+    }
+    const survivors = traits.filter(({ trait }) => !removable.has(trait.name));
+    traits.length = 0;
+    traits.push(...survivors);
+  }
+}
+function spliceLambdaTraitRefs(traits, pages) {
+  if (traits.length === 0) return;
+  const templates = /* @__PURE__ */ new Map();
+  for (const { trait } of traits) {
+    templates.set(trait.name, buildTemplate(trait));
+  }
+  const spliced = /* @__PURE__ */ new Set();
+  for (const resolved of traits) {
+    const host = resolved.trait;
+    const st = {
+      templates,
+      // Seed with the host itself so a self-reference never self-splices.
+      visiting: [host.name],
+      merged: [],
+      spliced,
+      hostName: host.name,
+      changed: false
+    };
+    const sm = host.stateMachine;
+    const nextTransitions = sm?.transitions ? sm.transitions.map((t) => ({
+      ...t,
+      effects: t.effects ? t.effects.map((e) => spliceExpr(e, false, st)) : t.effects
+    })) : sm?.transitions;
+    const nextTicks = host.ticks ? host.ticks.map((tick) => ({
+      ...tick,
+      effects: tick.effects.map((e) => spliceExpr(e, false, st))
+    })) : host.ticks;
+    if (!st.changed) {
+      continue;
+    }
+    const nextEmits = st.merged.length > 0 ? mergeWrapperEmits(host, st.merged) : host.emits;
+    resolved.trait = {
+      ...host,
+      ...sm ? { stateMachine: { ...sm, transitions: nextTransitions ?? [] } } : {},
+      ...nextTicks !== void 0 ? { ticks: nextTicks } : {},
+      ...nextEmits !== void 0 ? { emits: nextEmits } : {}
+    };
+  }
+  if (spliced.size > 0) {
+    removeConsumedWrappers(traits, pages, spliced);
+  }
+}
+
+// src/resolver/reference-resolver.ts
 var refResolverLog = createLogger("almadar:runtime:ref-resolver");
 function renameEventsInRenderUiConfig(node, rename) {
   if (node === null || node === void 0) return node;
@@ -3329,6 +3647,33 @@ function applyEventRenames(trait, renames) {
     emits: nextEmits
   };
 }
+function resolveConfigRefEmitNames(trait, callSiteConfig) {
+  const emits = trait.emits ?? [];
+  const hasRef = emits.some((em) => configRefEventKnob(em.event) !== void 0);
+  if (!hasRef) return { trait, errors: [] };
+  const effectiveConfig = {
+    ...normalizeCallSiteConfigToValues(trait.config) ?? {},
+    ...normalizeCallSiteConfigToValues(callSiteConfig) ?? {}
+  };
+  const errors = [];
+  const nextEmits = emits.map((em) => {
+    if (configRefEventKnob(em.event) === void 0) return em;
+    const result = resolveConfigRefEventName(em.event, trait.config, effectiveConfig);
+    if (!result.ok) {
+      errors.push(
+        `Trait "${trait.name}" emits \`${em.event}\` but the reference is invalid (${result.error}): the knob must be a declared string-typed config field with a default.`
+      );
+      return em;
+    }
+    refResolverLog.debug("emit-config-ref:resolved", {
+      trait: trait.name,
+      ref: em.event,
+      resolved: result.value
+    });
+    return { ...em, event: result.value };
+  });
+  return { trait: { ...trait, emits: nextEmits }, errors };
+}
 var ReferenceResolver = class {
   loader;
   options;
@@ -3383,6 +3728,14 @@ var ReferenceResolver = class {
     if (!entityResult.success || !traitsResult.success || !pagesResult.success) {
       return { success: false, errors: ["Internal error: unexpected failure state"] };
     }
+    try {
+      spliceLambdaTraitRefs(traitsResult.data, pagesResult.data);
+    } catch (e) {
+      if (e instanceof LambdaSpliceError) {
+        return { success: false, errors: [e.message] };
+      }
+      throw e;
+    }
     return {
       success: true,
       data: {
@@ -3549,10 +3902,14 @@ var ReferenceResolver = class {
    */
   resolveTraitRef(traitRef, imports) {
     if (typeof traitRef !== "string" && "stateMachine" in traitRef) {
+      const { trait: resolvedInline, errors } = resolveConfigRefEmitNames(traitRef);
+      if (errors.length > 0) {
+        return { success: false, errors };
+      }
       return {
         success: true,
         data: {
-          trait: traitRef,
+          trait: resolvedInline,
           source: { type: "inline" }
         },
         warnings: []
@@ -3603,7 +3960,11 @@ var ReferenceResolver = class {
         };
       }
       const baseTrait = overrideName ? { ...trait, name: overrideName } : trait;
-      const reboundTrait = applyLinkedEntityRename(baseTrait, linkedEntity);
+      const { trait: configResolvedTrait, errors: configRefErrors } = resolveConfigRefEmitNames(baseTrait, config);
+      if (configRefErrors.length > 0) {
+        return { success: false, errors: configRefErrors };
+      }
+      const reboundTrait = applyLinkedEntityRename(configResolvedTrait, linkedEntity);
       const renamedTrait = applyEventRenames(reboundTrait, eventRenames);
       const finalTrait = listensOverride !== void 0 ? { ...renamedTrait, listens: listensOverride } : renamedTrait;
       if (listensOverride !== void 0) {
@@ -3628,7 +3989,11 @@ var ReferenceResolver = class {
     const localTrait = this.localTraits.get(ref);
     if (localTrait) {
       const baseLocal = overrideName ? { ...localTrait, name: overrideName } : localTrait;
-      const reboundLocal = applyLinkedEntityRename(baseLocal, linkedEntity);
+      const { trait: configResolvedLocal, errors: localConfigRefErrors } = resolveConfigRefEmitNames(baseLocal, config);
+      if (localConfigRefErrors.length > 0) {
+        return { success: false, errors: localConfigRefErrors };
+      }
+      const reboundLocal = applyLinkedEntityRename(configResolvedLocal, linkedEntity);
       const renamedLocalTrait = applyEventRenames(reboundLocal, eventRenames);
       const finalLocalTrait = listensOverride !== void 0 ? { ...renamedLocalTrait, listens: listensOverride } : renamedLocalTrait;
       if (listensOverride !== void 0) {
@@ -4052,4 +4417,4 @@ var InMemoryPersistence = class {
   }
 };
 
-export { EffectExecutor, EventBus, HANDLER_MANIFEST, InMemoryPersistence, MockPersistenceAdapter, StateMachineManager, TickScheduler, buildEmitsFromTraits, collectDeclaredConfigDefaults, collectDeclaredEntityDefaults, containsBindings, createContextFromBindings, createInitialTraitState, createMockPersistence, createTestExecutor, createTickScheduler, createUnifiedLoader, extractBindings, findInitialState, findTransition, formatPayloadValidationError, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, isValidDurationString, normalizeCallSiteConfigToValues, normalizeEventKey, parseDurationString, parseNamespacedEvent, preprocessSchema, processEvent, validateEventPayload, validatePayloadShapes };
+export { CALLSITE_PAYLOAD_PREFIX, EffectExecutor, EventBus, HANDLER_MANIFEST, InMemoryPersistence, MockPersistenceAdapter, StateMachineManager, TickScheduler, buildEmitsFromTraits, collectDeclaredConfigDefaults, collectDeclaredEntityDefaults, containsBindings, createContextFromBindings, createInitialTraitState, createMockPersistence, createTestExecutor, createTickScheduler, createUnifiedLoader, extractBindings, findInitialState, findTransition, formatPayloadValidationError, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, isValidDurationString, normalizeEventKey, parseDurationString, parseNamespacedEvent, preprocessSchema, processEvent, resolveCallSitePayloadCaptures, validateEventPayload, validatePayloadShapes };