@cadenza.io/core 3.25.1 → 3.26.1

package/dist/index.js

@@ -1280,6 +1280,7 @@ var SignalBroker = class _SignalBroker {
     // TODO: Signals should be a class with a the observers, registered flag and other data.
     this.signalObservers = /* @__PURE__ */ new Map();
     this.emittedSignalsRegistry = /* @__PURE__ */ new Set();
+    this.signalMetadataRegistry = /* @__PURE__ */ new Map();
     // ── Flush Strategy Management ───────────────────────────────────────
     this.flushStrategies = /* @__PURE__ */ new Map();
     this.strategyData = /* @__PURE__ */ new Map();
@@ -1312,6 +1313,47 @@ var SignalBroker = class _SignalBroker {
   setVerbose(value) {
     this.verbose = value;
   }
+  resolveSignalMetadataKey(signal) {
+    const normalizedSignal = typeof signal === "string" ? signal.trim() : "";
+    if (!normalizedSignal) {
+      return "";
+    }
+    return normalizedSignal.split(":")[0] ?? normalizedSignal;
+  }
+  normalizeSignalMetadata(metadata) {
+    if (!metadata) {
+      return void 0;
+    }
+    const deliveryMode = metadata.deliveryMode === "broadcast" ? "broadcast" : "single";
+    const broadcastFilter = metadata.broadcastFilter && typeof metadata.broadcastFilter === "object" && !Array.isArray(metadata.broadcastFilter) ? merge_default({}, metadata.broadcastFilter) : null;
+    return {
+      deliveryMode,
+      broadcastFilter
+    };
+  }
+  setSignalMetadata(signal, metadata) {
+    const metadataKey = this.resolveSignalMetadataKey(signal);
+    if (!metadataKey) {
+      return;
+    }
+    const normalized = this.normalizeSignalMetadata(metadata);
+    if (!normalized) {
+      this.signalMetadataRegistry.delete(metadataKey);
+      return;
+    }
+    this.signalMetadataRegistry.set(metadataKey, normalized);
+  }
+  getSignalMetadata(signal) {
+    const metadataKey = this.resolveSignalMetadataKey(signal);
+    if (!metadataKey) {
+      return void 0;
+    }
+    const metadata = this.signalMetadataRegistry.get(metadataKey);
+    if (!metadata) {
+      return void 0;
+    }
+    return merge_default({}, metadata);
+  }
   // Dor debugging
   logMemoryFootprint(label = "current") {
     console.log(`[${label}] SignalBroker state sizes:`);
@@ -1396,7 +1438,8 @@ var SignalBroker = class _SignalBroker {
       const processedSignals = uniqueSignals.map((signal) => ({
         signal,
         data: {
-          registered: this.signalObservers.get(signal)?.registered ?? false
+          registered: this.signalObservers.get(signal)?.registered ?? false,
+          metadata: this.getSignalMetadata(signal) ?? null
         }
       }));
       return {
@@ -1746,10 +1789,11 @@ var SignalBroker = class _SignalBroker {
   execute(signal, context) {
     const isMeta = signal.includes("meta.");
     const isSubMeta = signal.includes("sub_meta.") || context.__isSubMeta;
+    const isReceivedSignalTransmission = context.__receivedSignalTransmission === true;
     const isMetric = context.__signalEmission?.isMetric;
+    const isNewTrace = !context.__signalEmission?.executionTraceId && !context.__metadata?.__executionTraceId && !context.__executionTraceId;
     const executionTraceId = context.__signalEmission?.executionTraceId ?? context.__metadata?.__executionTraceId ?? context.__executionTraceId ?? (0, import_uuid.v4)();
     if (!isSubMeta && (!isMeta || this.debug)) {
-      const isNewTrace = !context.__signalEmission?.executionTraceId && !context.__metadata?.__executionTraceId && !context.__executionTraceId;
       if (isNewTrace) {
         this.emit("sub_meta.signal_broker.new_trace", {
           data: {
@@ -1778,21 +1822,33 @@ var SignalBroker = class _SignalBroker {
       const signalParts = signal.split(":");
       const signalName = signalParts[0];
       const signalTag = signalParts.length > 1 ? signalParts[1] : null;
+      const existingSignalEmission = context.__signalEmission && typeof context.__signalEmission === "object" ? context.__signalEmission : {};
       context.__signalEmission = {
-        ...context.__signalEmission ?? {},
-        uuid: (0, import_uuid.v4)(),
-        executionTraceId,
-        signalName,
-        signalTag,
-        emittedAt: formatTimestamp(emittedAt),
-        consumed: false,
-        consumedBy: null,
-        isMeta
+        ...existingSignalEmission,
+        fullSignalName: existingSignalEmission.fullSignalName ?? signal,
+        uuid: existingSignalEmission.uuid ?? (0, import_uuid.v4)(),
+        executionTraceId: existingSignalEmission.executionTraceId ?? executionTraceId,
+        signalName: existingSignalEmission.signalName ?? signalName,
+        signalTag: existingSignalEmission.signalTag ?? signalTag,
+        emittedAt: existingSignalEmission.emittedAt ?? formatTimestamp(emittedAt),
+        consumed: existingSignalEmission.consumed ?? false,
+        consumedBy: existingSignalEmission.consumedBy ?? null,
+        isMeta: existingSignalEmission.isMeta ?? isMeta,
+        __traceCreatedBySignalBroker: existingSignalEmission.__traceCreatedBySignalBroker ?? isNewTrace
       };
-      this.emit("sub_meta.signal_broker.emitting_signal", { ...context });
+      if (!isReceivedSignalTransmission) {
+        if (isNewTrace) {
+          context.__traceCreatedBySignalBroker = true;
+        }
+        this.emit("sub_meta.signal_broker.emitting_signal", { ...context });
+        if (isNewTrace) {
+          delete context.__traceCreatedBySignalBroker;
+        }
+      }
     } else if (isSubMeta) {
       context.__isSubMeta = true;
     }
+    delete context.__receivedSignalTransmission;
     context.__metadata = {
       ...context.__metadata,
       __executionTraceId: executionTraceId
@@ -1856,8 +1912,11 @@ var SignalBroker = class _SignalBroker {
    * @param {string} signal - The name of the signal to be added.
    * @return {void} This method does not return any value.
    */
-  addSignal(signal) {
+  addSignal(signal, metadata) {
     let _signal = signal;
+    if (metadata) {
+      this.setSignalMetadata(signal, metadata);
+    }
     if (!this.signalObservers.has(_signal)) {
       this.validateSignalName(_signal);
       this.signalObservers.set(_signal, {
@@ -1887,11 +1946,14 @@ var SignalBroker = class _SignalBroker {
    * @param routineOrTask The observer.
    * @edge Duplicates ignored; supports wildcards for broad listening.
    */
-  observe(signal, routineOrTask) {
-    this.addSignal(signal);
+  observe(signal, routineOrTask, metadata) {
+    this.addSignal(signal, metadata);
     this.signalObservers.get(signal).tasks.add(routineOrTask);
   }
-  registerEmittedSignal(signal) {
+  registerEmittedSignal(signal, metadata) {
+    if (metadata) {
+      this.setSignalMetadata(signal, metadata);
+    }
     this.emittedSignalsRegistry.add(signal);
   }
   /**
@@ -1926,6 +1988,7 @@ var SignalBroker = class _SignalBroker {
     this.clearThrottleState();
     this.signalObservers.clear();
     this.emittedSignalsRegistry.clear();
+    this.signalMetadataRegistry.clear();
   }
   shutdown() {
     this.reset();
@@ -2334,6 +2397,27 @@ var SignalEmitter = class {
 };
 
 // src/graph/execution/GraphNode.ts
+function normalizeGraphErrorMessage(error) {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (error && typeof error === "object") {
+    const record = error;
+    if (typeof record.__error === "string") {
+      return record.__error;
+    }
+    if (typeof record.error === "string") {
+      return record.error;
+    }
+    if (typeof record.message === "string") {
+      return record.message;
+    }
+  }
+  return String(error);
+}
 var GraphNode = class _GraphNode extends SignalEmitter {
   constructor(task, context, routineExecId, prevNodes = [], debug = false, verbose = false) {
     super(
@@ -2518,7 +2602,8 @@ var GraphNode = class _GraphNode extends SignalEmitter {
           {
             data: {
               taskExecutionId: this.id,
-              previousTaskExecutionId: node.id
+              previousTaskExecutionId: node.id,
+              executionTraceId: context.__metadata?.__executionTraceId ?? context.__executionTraceId ?? null
             },
             filter: {
               taskName: this.task.name,
@@ -2536,7 +2621,8 @@ var GraphNode = class _GraphNode extends SignalEmitter {
           {
             data: {
               taskExecutionId: this.id,
-              previousTaskExecutionId: context.__previousTaskExecutionId
+              previousTaskExecutionId: context.__previousTaskExecutionId,
+              executionTraceId: context.__metadata?.__executionTraceId ?? context.__executionTraceId ?? null
             },
             filter: {
               taskName: this.task.name,
@@ -2950,11 +3036,12 @@ var GraphNode = class _GraphNode extends SignalEmitter {
    * @return {void} This method does not return any value.
    */
   onError(error, errorData = {}) {
+    const normalizedError = normalizeGraphErrorMessage(error);
     this.result = {
       ...this.context.getFullContext(),
-      __error: `Node error: ${error}`,
+      __error: `Node error: ${normalizedError}`,
       __retries: this.retries,
-      error: `Node error: ${error}`,
+      error: `Node error: ${normalizedError}`,
       errored: true,
       returnedValue: this.result,
       ...errorData
@@ -3529,8 +3616,16 @@ var GraphRunner = class extends SignalEmitter {
     const isNewTrace = !context.__routineExecId && !context.__metadata?.__executionTraceId && !context.__executionTraceId;
     const executionTraceId = context.__metadata?.__executionTraceId ?? context.__executionTraceId ?? (0, import_uuid5.v4)();
     context.__executionTraceId = executionTraceId;
+    context.__traceCreatedByRunner = isNewTrace;
+    const isNewRoutine = !context.__routineExecId;
     const routineExecId = context.__routineExecId ?? (0, import_uuid5.v4)();
     context.__routineExecId = routineExecId;
+    const routineCreatedAt = formatTimestamp(Date.now());
+    context.__routineCreatedByRunner = isNewRoutine;
+    context.__routineName = routineName;
+    context.__routineVersion = routineVersion;
+    context.__routineCreatedAt = routineCreatedAt;
+    context.__routineIsMeta = isMeta;
     Cadenza.applyRuntimeValidationScopesToContext(
       context,
       routineName,
@@ -3565,8 +3660,7 @@ var GraphRunner = class extends SignalEmitter {
           executionTraceId,
           context: ctx.getContext(),
           metaContext: ctx.getMetadata(),
-          previousRoutineExecution: context.__localRoutineExecId ?? context.__metadata?.__routineExecId ?? null,
-          created: formatTimestamp(Date.now())
+          created: routineCreatedAt
         },
         __metadata: {
           __executionTraceId: executionTraceId
@@ -3799,6 +3893,7 @@ var Actor = class {
     this.stateByKey = /* @__PURE__ */ new Map();
     this.sessionByKey = /* @__PURE__ */ new Map();
     this.idempotencyByKey = /* @__PURE__ */ new Map();
+    this.writeQueueByKey = /* @__PURE__ */ new Map();
     this.nextTaskBindingIndex = 0;
     if (!spec.name || typeof spec.name !== "string") {
       throw new Error("Actor name must be a non-empty string");
@@ -3832,7 +3927,9 @@ var Actor = class {
         bindingOptions.touchSession
       );
       const actorKey = this.resolveActorKey(normalizedInput, invocationOptions);
-      this.touchSession(actorKey, invocationOptions.touchSession, Date.now());
+      const now2 = Date.now();
+      this.pruneExpiredActorKeys(now2);
+      this.touchSession(actorKey, invocationOptions.touchSession, now2);
       const runTask = async () => {
         const stateRecord = this.ensureStateRecord(actorKey);
         stateRecord.lastReadAt = Date.now();
@@ -3980,7 +4077,7 @@ var Actor = class {
         taskBindingId,
         actorKey,
         invocationOptions,
-        runTask
+        () => this.runWithPerKeyWriteSerialization(actorKey, mode, runTask)
       );
     };
     wrapped[ACTOR_TASK_METADATA] = {
@@ -4003,6 +4100,7 @@ var Actor = class {
    */
   getDurableState(actorKey) {
     const key = normalizeActorKey(actorKey) ?? this.spec.defaultKey;
+    this.pruneExpiredActorKeys(Date.now());
     return cloneForDurableState(this.ensureStateRecord(key).durableState);
   }
   /**
@@ -4010,6 +4108,7 @@ var Actor = class {
    */
   getRuntimeState(actorKey) {
     const key = normalizeActorKey(actorKey) ?? this.spec.defaultKey;
+    this.pruneExpiredActorKeys(Date.now());
     return this.ensureStateRecord(key).runtimeState;
   }
   /**
@@ -4023,6 +4122,7 @@ var Actor = class {
    */
   getDurableVersion(actorKey) {
     const key = normalizeActorKey(actorKey) ?? this.spec.defaultKey;
+    this.pruneExpiredActorKeys(Date.now());
     return this.ensureStateRecord(key).version;
   }
   /**
@@ -4030,6 +4130,7 @@ var Actor = class {
    */
   getRuntimeVersion(actorKey) {
     const key = normalizeActorKey(actorKey) ?? this.spec.defaultKey;
+    this.pruneExpiredActorKeys(Date.now());
     return this.ensureStateRecord(key).runtimeVersion;
   }
   /**
@@ -4200,6 +4301,30 @@ var Actor = class {
       existing.absoluteExpiresAt = touchedAt + absoluteTtlMs;
     }
   }
+  pruneExpiredActorKeys(now2) {
+    if (!this.spec.session?.enabled || this.sessionByKey.size === 0) {
+      return;
+    }
+    for (const [actorKey, session] of this.sessionByKey.entries()) {
+      if (!this.isSessionExpired(session, now2)) {
+        continue;
+      }
+      if (this.writeQueueByKey.has(actorKey)) {
+        continue;
+      }
+      this.stateByKey.delete(actorKey);
+      this.sessionByKey.delete(actorKey);
+    }
+  }
+  isSessionExpired(session, now2) {
+    if (session.absoluteExpiresAt !== null && now2 >= session.absoluteExpiresAt) {
+      return true;
+    }
+    if (session.idleExpiresAt !== null && now2 >= session.idleExpiresAt) {
+      return true;
+    }
+    return false;
+  }
   runWithOptionalIdempotency(taskBindingId, actorKey, options, runTask) {
     const idempotencyPolicy = this.spec.idempotency;
     const enabled = idempotencyPolicy?.enabled ?? false;
@@ -4258,6 +4383,24 @@ var Actor = class {
     });
     return promise;
   }
+  runWithPerKeyWriteSerialization(actorKey, mode, runTask) {
+    if (mode === "read") {
+      return runTask();
+    }
+    const previous = this.writeQueueByKey.get(actorKey) ?? Promise.resolve();
+    let releaseCurrent;
+    const currentGate = new Promise((resolve) => {
+      releaseCurrent = resolve;
+    });
+    const currentTail = previous.catch(() => void 0).then(() => currentGate);
+    this.writeQueueByKey.set(actorKey, currentTail);
+    return previous.catch(() => void 0).then(runTask).finally(() => {
+      releaseCurrent();
+      if (this.writeQueueByKey.get(actorKey) === currentTail) {
+        this.writeQueueByKey.delete(actorKey);
+      }
+    });
+  }
   getActiveIdempotencyRecord(compositeKey) {
     const record = this.idempotencyByKey.get(compositeKey);
     if (!record) {
@@ -4275,23 +4418,25 @@ var Actor = class {
       return;
     }
     const timeoutMs = normalizePositiveInteger(this.spec.session?.persistenceTimeoutMs) ?? 5e3;
+    const persistenceContext = {
+      actor_name: this.spec.name,
+      actor_version: 1,
+      actor_key: actorKey,
+      durable_state: cloneForDurableState(durableState),
+      durable_version: durableVersion,
+      expires_at: null
+    };
     const response = await inquire(
       META_ACTOR_SESSION_STATE_PERSIST_INTENT,
-      {
-        actor_name: this.spec.name,
-        actor_version: 1,
-        actor_key: actorKey,
-        durable_state: cloneForDurableState(durableState),
-        durable_version: durableVersion,
-        expires_at: null
-      },
+      persistenceContext,
       {
         timeout: timeoutMs,
+        requireComplete: true,
         rejectOnTimeout: true
       }
     );
     if (!isObject2(response) || response.__success !== true || response.persisted !== true) {
-      const reason = isObject2(response) ? response.__error ?? response.error : void 0;
+      const reason = isObject2(response) ? response.__error ?? response.error ?? response.internalError ?? (response.errored === true ? `errored response keys: ${Object.keys(response).join(",")}` : response.failed === true ? `failed response keys: ${Object.keys(response).join(",")}` : void 0) : void 0;
       throw new Error(
         `Actor "${this.spec.name}" durable state persistence failed for key "${actorKey}"${reason ? `: ${String(reason)}` : ""}`
       );
@@ -4325,6 +4470,20 @@ var Actor = class {
 };
 
 // src/graph/definition/Task.ts
+function normalizeSignalDefinition(input) {
+  if (typeof input === "string") {
+    return {
+      name: input
+    };
+  }
+  return {
+    name: input.name,
+    metadata: {
+      deliveryMode: input.deliveryMode,
+      broadcastFilter: input.broadcastFilter ?? null
+    }
+  };
+}
 var Task = class _Task extends SignalEmitter {
   /**
    * Constructs an instance of the task with the specified properties and configuration options.
@@ -5145,9 +5304,10 @@ var Task = class _Task extends SignalEmitter {
    * @return {this} The current instance after adding the specified signals.
    */
   doOn(...signals) {
-    signals.forEach((signal) => {
+    signals.forEach((input) => {
+      const { name: signal, metadata } = normalizeSignalDefinition(input);
       if (this.observedSignals.has(signal)) return;
-      Cadenza.signalBroker.observe(signal, this);
+      Cadenza.signalBroker.observe(signal, this, metadata);
       this.observedSignals.add(signal);
       if (this.register) {
         this.emitWithMetadata("meta.task.observed_signal", {
@@ -5168,13 +5328,14 @@ var Task = class _Task extends SignalEmitter {
    * @return {this} The current instance for method chaining.
    */
   emits(...signals) {
-    signals.forEach((signal) => {
+    signals.forEach((input) => {
+      const { name: signal } = normalizeSignalDefinition(input);
       if (this.observedSignals.has(signal))
         throw new Error(
           `Detected signal loop for task ${this.name}. Signal name: ${signal}`
         );
       this.signalsToEmitAfter.add(signal);
-      this.attachSignal(signal);
+      this.attachSignal(input);
     });
     return this;
   }
@@ -5186,9 +5347,10 @@ var Task = class _Task extends SignalEmitter {
    * @return {this} Returns the current instance for chaining.
    */
   emitsOnFail(...signals) {
-    signals.forEach((signal) => {
+    signals.forEach((input) => {
+      const { name: signal } = normalizeSignalDefinition(input);
       this.signalsToEmitOnFail.add(signal);
-      this.attachSignal(signal);
+      this.attachSignal(input);
     });
     return this;
   }
@@ -5199,9 +5361,10 @@ var Task = class _Task extends SignalEmitter {
    * @return {void} This method does not return a value.
    */
   attachSignal(...signals) {
-    signals.forEach((signal) => {
+    signals.forEach((input) => {
+      const { name: signal, metadata } = normalizeSignalDefinition(input);
       this.emitsSignals.add(signal);
-      Cadenza.signalBroker.registerEmittedSignal(signal);
+      Cadenza.signalBroker.registerEmittedSignal(signal, metadata);
       if (this.register) {
         const data = {
           signals: {