@fluidgrids/workflows 2026.1028.2 → 2026.1029.1

package/dist/chunk-M272AHEX.js

@@ -0,0 +1,25 @@
+// src/runtime/stack.ts
+var RUNTIME_FRAME = /fluidgrids-runtime|\/runtime\/(scheduler|index)\.|WorkflowExecution|RuntimeContext/;
+function captureStack() {
+  const stack = new Error("stack").stack ?? "";
+  return stack.split("\n").slice(1).filter((line) => line.trim() !== "" && !RUNTIME_FRAME.test(line)).join("\n");
+}
+var V8_FRAME = /^\s*at (?:(.*?) \()?(.*?):(\d+):(\d+)\)?$/;
+var QUICKJS_FRAME = /^\s*at (?:(.*?) )?\(?(.*?)(?::(\d+))?(?::(\d+))?\)?$/;
+function parseStack(stack) {
+  const locations = [];
+  for (const line of stack.split("\n")) {
+    if (line.trim() === "") continue;
+    const match = V8_FRAME.exec(line) ?? QUICKJS_FRAME.exec(line);
+    if (!match) continue;
+    const location = {};
+    if (match[1]) location.functionName = match[1];
+    if (match[2]) location.filePath = match[2];
+    if (match[3]) location.line = Number(match[3]);
+    if (match[4]) location.column = Number(match[4]);
+    locations.push(location);
+  }
+  return locations;
+}
+
+export { captureStack, parseStack };

package/dist/{chunk-VRHHBPT6.js → chunk-MJ5TGYVG.js}

@@ -1,13 +1,22 @@
-import { ServerFailure, failureToError, CancelledFailure, TimeoutFailure, ApplicationError, TerminatedFailure, DeterminismViolation, HistoryLimitExceeded, PhaseCFeatureError, isCancellation, isRunFailure, errorToFailure, optionalMs, ActivityFailure, toMs, signalName, ChildRunFailure } from './chunk-C5OLWZ42.js';
+import { ServerFailure, failureToError, CancelledFailure, TimeoutFailure, ApplicationError, TerminatedFailure, DeterminismViolation, HistoryLimitExceeded, PhaseCFeatureError, isCancellation, isRunFailure, errorToFailure, ActivityFailure, signalName, ChildRunFailure } from './chunk-KXJDRQ6G.js';
+import { captureStack, parseStack } from './chunk-M272AHEX.js';
 import { createRandom, seedOf, takeShimControl, uuidFrom } from './chunk-4LYSEANA.js';
-import { isDurableWorkflow, SDK_VERSION } from './chunk-N23SKIG4.js';
-import { utf8Bytes, splitActivations, explicitRetryPolicy, CHILD_DEFAULT_CANCELLATION_TYPE, CHILD_DEFAULT_PARENT_CLOSE_POLICY } from './chunk-ABFZWYHT.js';
-import { COMMAND_EVENT_TYPES, DEFAULT_HISTORY_LIMIT, CONTINUE_AS_NEW_SUGGESTED_RATIO, HISTORY_PROTOCOL, HISTORY_LIMIT_EXCEEDED_RATIO, BUILT_IN_QUERIES } from './chunk-DJYMDLV5.js';
-import { isActivityNodeTypeAllowed } from './chunk-BO6OVILK.js';
+import { optionalMs, toMs, isDurableWorkflow, runRetryPolicyOf, continueAsNewRetryOf, SDK_VERSION } from './chunk-7ILGCUI6.js';
+import { utf8Bytes, splitActivations, CHILD_DEFAULT_CANCELLATION_TYPE, CHILD_DEFAULT_PARENT_CLOSE_POLICY } from './chunk-FWBRQWRX.js';
+import { COMMAND_EVENT_TYPES, DEFAULT_HISTORY_LIMIT, CONTINUE_AS_NEW_SUGGESTED_RATIO, HISTORY_PROTOCOL, HISTORY_LIMIT_EXCEEDED_RATIO, isActivityNodeTypeAllowed, LOCAL_ACTIVITY_MAX_TIMEOUT_MS, BUILT_IN_QUERIES } from './chunk-2DDULZFM.js';
+import { explicitRetryPolicy, computeRetryDelay } from './chunk-PWIUEWC3.js';
 
 // src/runtime/ids.ts
 var CommandIds = class {
-  counters = { a: 0, t: 0, c: 0, s: 0, x: 0, m: 0 };
+  counters = {
+    a: 0,
+    t: 0,
+    c: 0,
+    s: 0,
+    x: 0,
+    m: 0,
+    l: 0
+  };
   /** The next id of a kind: `a1`, `a2`, ... */
   next(kind) {
     this.counters[kind] += 1;
@@ -45,7 +54,7 @@ function describeCommand(command) {
     case "RECORD_MARKER":
       return `RECORD_MARKER ${command.markerId}`;
     case "RECORD_LOCAL_ACTIVITY":
-      return `RECORD_LOCAL_ACTIVITY ${command.localActivityId}`;
+      return `RECORD_LOCAL_ACTIVITY ${command.localActivityId}${command.nodeType !== void 0 ? ` (${command.nodeType} ${command.operation ?? ""})` : ""}`;
     default:
       return command.type;
   }
@@ -77,8 +86,10 @@ function mismatch(command, event) {
       return field(event, "sideEffectId") === command.sideEffectId ? void 0 : differ();
     case "RECORD_MARKER":
       return field(event, "markerId") === command.markerId ? void 0 : differ();
-    case "RECORD_LOCAL_ACTIVITY":
-      return field(event, "localActivityId") === command.localActivityId ? void 0 : differ();
+    case "RECORD_LOCAL_ACTIVITY": {
+      const sameOperation = field(event, "nodeType") === void 0 || field(event, "nodeType") === command.nodeType && field(event, "operation") === command.operation;
+      return field(event, "localActivityId") === command.localActivityId && sameOperation ? void 0 : differ();
+    }
     default:
       return void 0;
   }
@@ -114,30 +125,6 @@ function matchActivation(commands, recorded) {
   return void 0;
 }
 
-// src/runtime/stack.ts
-var RUNTIME_FRAME = /fluidgrids-runtime|\/runtime\/(scheduler|index)\.|WorkflowExecution|RuntimeContext/;
-function captureStack() {
-  const stack = new Error("stack").stack ?? "";
-  return stack.split("\n").slice(1).filter((line) => line.trim() !== "" && !RUNTIME_FRAME.test(line)).join("\n");
-}
-var V8_FRAME = /^\s*at (?:(.*?) \()?(.*?):(\d+):(\d+)\)?$/;
-var QUICKJS_FRAME = /^\s*at (?:(.*?) )?\(?(.*?)(?::(\d+))?(?::(\d+))?\)?$/;
-function parseStack(stack) {
-  const locations = [];
-  for (const line of stack.split("\n")) {
-    if (line.trim() === "") continue;
-    const match = V8_FRAME.exec(line) ?? QUICKJS_FRAME.exec(line);
-    if (!match) continue;
-    const location = {};
-    if (match[1]) location.functionName = match[1];
-    if (match[2]) location.filePath = match[2];
-    if (match[3]) location.line = Number(match[3]);
-    if (match[4]) location.column = Number(match[4]);
-    locations.push(location);
-  }
-  return locations;
-}
-
 // src/runtime/scheduler.ts
 var SDK_NAME = "@fluidgrids/workflows";
 var ContinueAsNewRequest = class {
@@ -251,6 +238,49 @@ function messageOf(error) {
 function stackTextOf(error) {
   return error instanceof Error && typeof error.stack === "string" ? error.stack : void 0;
 }
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asFailure(value) {
+  return isJsonObject(value) ? value : void 0;
+}
+function infoFromStarted(info, started) {
+  if (started?.type !== "WORKFLOW_STARTED") return { ...info };
+  const p = started.payload;
+  const out = { ...info };
+  if (Object.hasOwn(p, "lastCompletionResult")) out.lastResult = p["lastCompletionResult"] ?? null;
+  if (Object.hasOwn(p, "lastFailure")) out.lastFailure = asFailure(p["lastFailure"]) ?? null;
+  const businessId = typeof p["businessId"] === "string" ? p["businessId"] : void 0;
+  const workflowId = typeof p["workflowId"] === "string" ? p["workflowId"] : businessId;
+  if (businessId !== void 0) out.businessId = businessId;
+  if (workflowId !== void 0) out.workflowId = workflowId;
+  if (typeof p["runAttempt"] === "number") {
+    out.runAttempt = p["runAttempt"];
+    out.attempt = p["runAttempt"];
+  }
+  if (typeof p["summary"] === "string") out.summary = p["summary"];
+  if (typeof p["details"] === "string") out.details = p["details"];
+  if (isJsonObject(p["context"])) {
+    out.context = { ...p["context"] };
+    out.memo = { ...p["context"] };
+  }
+  const timeouts = {};
+  const nested = isJsonObject(p["timeouts"]) ? p["timeouts"] : {};
+  for (const key of ["executionTimeout", "runTimeout", "workflowTaskTimeout"]) {
+    const value = nested[key] ?? p[key];
+    if (typeof value === "number") timeouts[key] = value;
+  }
+  if (Object.keys(timeouts).length > 0) out.timeouts = timeouts;
+  if (p["versioningBehavior"] === "PINNED" || p["versioningBehavior"] === "AUTO_UPGRADE")
+    out.versioningBehavior = p["versioningBehavior"];
+  if (isJsonObject(p["retry"])) out.retry = p["retry"];
+  if (typeof p["priority"] === "number") out.priority = p["priority"];
+  if (typeof p["firstRunId"] === "string") out.firstRunId = p["firstRunId"];
+  if (typeof p["continuedFromRunId"] === "string") out.continuedFromRunId = p["continuedFromRunId"];
+  if (out.workflowId === void 0 && out.businessId !== void 0) out.workflowId = out.businessId;
+  if (out.runAttempt === void 0 && out.attempt !== void 0) out.runAttempt = out.attempt;
+  return out;
+}
 var WorkflowExecution = class {
   request;
   definition;
@@ -300,7 +330,16 @@ var WorkflowExecution = class {
   signalHandlers = /* @__PURE__ */ new Map();
   signalWaiters = /* @__PURE__ */ new Map();
   defaultSignalHandler;
+  defaultSignalPolicy = "WARN_AND_ABANDON";
+  signalPolicies = /* @__PURE__ */ new Map();
   runningHandlers = 0;
+  /** Running asynchronous handlers by name, for the drain warning (11 §2.18). */
+  running = /* @__PURE__ */ new Map();
+  unfinished;
+  recordedLocalActivities = /* @__PURE__ */ new Map();
+  localActivityResults = /* @__PURE__ */ new Map();
+  localActivities = /* @__PURE__ */ new Map();
+  memo;
   conditions = [];
   currentDetails;
   context;
@@ -332,17 +371,40 @@ var WorkflowExecution = class {
       } else if (event.type === "MARKER_RECORDED") {
         const id = event.payload["markerId"];
         if (typeof id === "string") this.recordedMarkers.add(id);
+      } else if (event.type === "LOCAL_ACTIVITY_COMPLETED" || event.type === "LOCAL_ACTIVITY_FAILED") {
+        const id = event.payload["localActivityId"];
+        const failure = asFailure(event.payload["failure"]);
+        const attempts = event.payload["attempts"];
+        if (typeof id === "string")
+          this.recordedLocalActivities.set(id, {
+            ...event.type === "LOCAL_ACTIVITY_FAILED" && failure ? { failure } : { result: event.payload["result"] ?? null },
+            attempts: typeof attempts === "number" ? attempts : 1
+          });
       }
     }
+    if (input.request.kind === "task")
+      for (const entry of input.request.localActivityResults ?? [])
+        this.localActivityResults.set(entry.localActivityId, {
+          ...entry.failure !== void 0 ? { failure: entry.failure } : { result: entry.result ?? null },
+          attempts: entry.attempts
+        });
     this.activations = splitActivations(
       history,
       input.request.nowMs,
       input.request.kind !== "query"
     );
     const execution = this;
+    const snapshot = infoFromStarted(input.request.info, history[0]);
+    this.memo = { ...snapshot.memo ?? snapshot.context ?? {} };
     this.info = {
-      ...input.request.info,
+      ...snapshot,
       workflowFn: input.request.workflowFn,
+      get context() {
+        return { ...execution.memo };
+      },
+      get memo() {
+        return { ...execution.memo };
+      },
       get historyLength() {
         return execution.historyLength;
       },
@@ -389,12 +451,24 @@ var WorkflowExecution = class {
       this.checkConditions();
       this.finishActivation();
     }
+    const requests = this.pendingLocalActivityRequests();
+    if (requests.length > 0) {
+      const requested = {
+        protocol: HISTORY_PROTOCOL,
+        outcome: "localActivityRequested",
+        commands: [],
+        localActivityRequests: requests,
+        logs: []
+      };
+      return requested;
+    }
     const result = {
       protocol: HISTORY_PROTOCOL,
       outcome: this.failure ? "failed" : "commands",
       commands: this.failure ? [] : this.newCommands,
       logs: this.logs
     };
+    if (!this.failure && this.unfinished !== void 0) result.unfinishedHandlers = this.unfinished;
     if (this.failure) {
       result.failure = { cause: this.failure.cause, message: this.failure.message };
       if (this.failure.stackTrace !== void 0)
@@ -405,6 +479,15 @@ var WorkflowExecution = class {
     if (this.request.kind === "query") result.queryResults = this.answerQueries();
     return result;
   }
+  /**
+   * The local activities the open activation waits for, when the task is a
+   * workflow task that has not failed or closed the run (a run that ends
+   * abandons a local activity it did not await).
+   */
+  pendingLocalActivityRequests() {
+    if (this.failure || this.closed || this.request.kind !== "task") return [];
+    return [...this.localActivities.values()].filter((entry) => !entry.replayed).map((entry) => entry.request);
+  }
   /** Fail the task (the runtime's own failures and code errors). */
   failTask(cause, message, stackTrace, seq, errorType) {
     if (!this.failure) this.failure = new TaskFailure(cause, message, stackTrace, seq, errorType);
@@ -434,11 +517,30 @@ var WorkflowExecution = class {
           void 0,
           found.seq
         );
+      else this.checkReplayedLocalActivities();
     } else {
       this.newCommands = this.commands;
     }
     this.commands = [];
   }
+  /**
+   * A local activity issued on a replayed activation without a recorded
+   * outcome is fine only when the first execution dropped it in that same
+   * activation: its scope was cancelled (the entry is gone) or the run closed.
+   * One still waiting means the first execution would have requested and
+   * recorded it, so the code diverged from the history.
+   */
+  checkReplayedLocalActivities() {
+    if (this.closed) return;
+    for (const entry of this.localActivities.values()) {
+      if (!entry.replayed) continue;
+      this.failTask(
+        "NON_DETERMINISM",
+        `Replay of ${entry.description ?? "a local activity"} found no recorded outcome: the code issued a local activity the history does not have`
+      );
+      return;
+    }
+  }
   // ---- inputs ---------------------------------------------------------------
   deliver(event) {
     const p = event.payload;
@@ -616,7 +718,7 @@ var WorkflowExecution = class {
   dispatchSignal(name, payload) {
     const handler = this.signalHandlers.get(name);
     if (handler) {
-      this.runHandler(() => handler(payload));
+      this.runHandler(() => handler(payload), name, this.signalPolicies.get(name));
       return;
     }
     const waiters = this.signalWaiters.get(name);
@@ -628,7 +730,7 @@ var WorkflowExecution = class {
     }
     if (this.defaultSignalHandler) {
       const fallback = this.defaultSignalHandler;
-      this.runHandler(() => fallback(name, payload));
+      this.runHandler(() => fallback(name, payload), name, this.defaultSignalPolicy);
       return;
     }
     const buffer = this.signalBuffers.get(name) ?? [];
@@ -644,7 +746,7 @@ var WorkflowExecution = class {
     if (position >= 0) this.signalOrder.splice(position, 1);
     return payload;
   }
-  runHandler(call) {
+  runHandler(call, name, policy = "WARN_AND_ABANDON") {
     let result;
     try {
       result = call();
@@ -654,17 +756,40 @@ var WorkflowExecution = class {
     }
     if (result instanceof Promise) {
       this.runningHandlers += 1;
-      result.then(
-        () => {
-          this.runningHandlers -= 1;
-        },
-        (error) => {
-          this.runningHandlers -= 1;
-          this.onWorkflowError(error);
-        }
-      );
+      const entry = this.running.get(name) ?? { count: 0, policy };
+      entry.count += 1;
+      entry.policy = policy;
+      this.running.set(name, entry);
+      const done = () => {
+        this.runningHandlers -= 1;
+        entry.count -= 1;
+        if (entry.count === 0) this.running.delete(name);
+      };
+      result.then(done, (error) => {
+        done();
+        this.onWorkflowError(error);
+      });
     }
   }
+  /**
+   * The drain check of 11 §2.18 when the workflow finishes: handlers still
+   * running with policy `WARN_AND_ABANDON` give one warning line and
+   * `unfinishedHandlers` in the result. A replay never reports them.
+   */
+  checkUnfinishedHandlers(command) {
+    if (this.replaying || command.type === "CANCEL_WORKFLOW") return;
+    const unfinished = [...this.running.entries()].filter(([, entry]) => entry.count > 0 && entry.policy === "WARN_AND_ABANDON").map(([name, entry]) => ({ kind: "signal", name, count: entry.count })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    if (unfinished.length === 0) return;
+    this.unfinished = unfinished;
+    const total = unfinished.reduce((sum, entry) => sum + entry.count, 0);
+    this.logs.push({
+      level: "warn",
+      message: `The workflow finished while ${total} signal handler${total === 1 ? " was" : "s were"} still running (${unfinished.map((entry) => `${entry.name} x${entry.count}`).join(
+        ", "
+      )}); await ctx.allHandlersFinished() before returning, or set unfinishedPolicy: 'ABANDON' on the handler`,
+      data: unfinished.map((entry) => ({ kind: entry.kind, name: entry.name, count: entry.count }))
+    });
+  }
   // ---- the workflow function ------------------------------------------------
   startFunction(input) {
     let promise;
@@ -762,6 +887,7 @@ var WorkflowExecution = class {
     if (this.closed || this.failure) return;
     this.commands.push(command);
     this.closed = true;
+    this.checkUnfinishedHandlers(command);
   }
   stack() {
     return this.captureStacks ? captureStack() : void 0;
@@ -839,6 +965,110 @@ var WorkflowExecution = class {
       this.activities.set(activityId, entry);
     });
   }
+  /**
+   * `ctx.localActivity` (11 §2.12). A replayed activation returns the outcome
+   * its history recorded; the open activation takes the outcome the worker
+   * passed in `localActivityResults`, or asks for the local activity
+   * (`localActivityRequested`) and waits for the same task to run again.
+   * Either way the outcome is recorded with `RECORD_LOCAL_ACTIVITY` at the
+   * call, so a replay issues the same command at the same position.
+   */
+  localActivity(scope, operation, options) {
+    if (typeof operation === "function")
+      throw new PhaseCFeatureError("ctx.localActivity with a function (user local activities)");
+    if (typeof operation !== "object" || operation === null || typeof operation.nodeType !== "string")
+      throw new TypeError(
+        "ctx.localActivity needs a node operation (from nodes.* or the generated clients)"
+      );
+    const descriptor = operation;
+    if (descriptor.role === "trigger" || !isActivityNodeTypeAllowed(descriptor.nodeType))
+      throw new ApplicationError(
+        `${descriptor.nodeType} cannot run as a durable activity: only store and registry nodes and internal:http, internal:datatable, internal:set and internal:code can`,
+        { type: "durable.activityTypeNotAllowed", errorType: "VALIDATION", nonRetryable: true }
+      );
+    if (typeof options !== "object" || options === null)
+      throw new TypeError("ctx.localActivity needs options with args");
+    const timeout = options.startToCloseTimeout === void 0 ? LOCAL_ACTIVITY_MAX_TIMEOUT_MS : toMs(options.startToCloseTimeout, "startToCloseTimeout");
+    if (timeout < 1 || timeout > LOCAL_ACTIVITY_MAX_TIMEOUT_MS)
+      throw new TypeError(
+        `A local activity's startToCloseTimeout must be between 1 ms and 30 s (got ${timeout} ms); use ctx.run for longer calls`
+      );
+    const localActivityId = this.ids.next("l");
+    const operationName = options.operation ?? descriptor.operation ?? "execute";
+    const nodeVersion = options.nodeVersion ?? descriptor.version;
+    const retry = explicitRetryPolicy(options.retry);
+    const args = toJson(options.args, `The args of ${descriptor.nodeType}`);
+    if (scope.consideredCancelled)
+      return Promise.reject(new CancelledFailure("Scope is cancelled"));
+    const label = `local activity ${localActivityId} (${descriptor.nodeType} ${operationName})`;
+    const wrap = (cause) => new ActivityFailure(
+      `Local activity ${localActivityId} (${descriptor.nodeType} ${operationName}) failed: ${cause.message}`,
+      localActivityId,
+      descriptor.nodeType,
+      operationName,
+      cause
+    );
+    const record = (outcome) => {
+      const command = {
+        type: "RECORD_LOCAL_ACTIVITY",
+        localActivityId,
+        attempts: Math.max(1, Math.round(outcome.attempts)),
+        nodeType: descriptor.nodeType,
+        operation: operationName,
+        ...outcome.failure !== void 0 ? { failure: outcome.failure } : { result: outcome.result ?? null }
+      };
+      if (options.summary !== void 0) command.summary = options.summary;
+      if (!this.push(command)) return this.never();
+      if (outcome.failure !== void 0)
+        return Promise.reject(wrap(failureToError(outcome.failure)));
+      return Promise.resolve(outcome.result ?? null);
+    };
+    const replayed = this.replaying;
+    if (replayed) {
+      const recorded = this.recordedLocalActivities.get(localActivityId);
+      if (recorded !== void 0) return record(recorded);
+    }
+    const given = replayed ? void 0 : this.localActivityResults.get(localActivityId);
+    let attempt = 1;
+    let backoffMs = 0;
+    if (given !== void 0) {
+      if (given.failure === void 0) return record(given);
+      const decision = computeRetryDelay(retry, given.attempts, given.failure);
+      if (!decision.retry) return record(given);
+      attempt = given.attempts + 1;
+      backoffMs = decision.delayMs;
+    }
+    const request = {
+      localActivityId,
+      kind: "node",
+      nodeType: descriptor.nodeType,
+      operation: operationName,
+      args,
+      retry,
+      startToCloseTimeout: timeout,
+      attempt,
+      backoffMs
+    };
+    if (nodeVersion !== void 0) request.nodeVersion = nodeVersion;
+    if (options.connection !== void 0) request.connection = options.connection;
+    if (options.summary !== void 0) request.summary = options.summary;
+    return new Promise((resolve, reject) => {
+      const entry = {
+        resolve,
+        reject,
+        description: label,
+        request,
+        replayed
+      };
+      const stack = this.stack();
+      if (stack !== void 0) entry.stack = stack;
+      entry.release = scope.onCancel(() => {
+        if (!this.localActivities.delete(localActivityId)) return;
+        reject(wrap(new CancelledFailure("Local activity cancelled")));
+      });
+      this.localActivities.set(localActivityId, entry);
+    });
+  }
   startTimer(scope, durationMs, summary) {
     return this.timer(scope, durationMs, summary).promise;
   }
@@ -960,13 +1190,18 @@ var WorkflowExecution = class {
       });
     });
   }
-  onSignal(signal, handler) {
+  onSignal(signal, handler, options = {}) {
+    if (typeof handler !== "function") throw new TypeError("ctx.onSignal needs a handler function");
+    const policy = options.unfinishedPolicy ?? "WARN_AND_ABANDON";
+    if (policy !== "WARN_AND_ABANDON" && policy !== "ABANDON")
+      throw new TypeError("unfinishedPolicy must be WARN_AND_ABANDON or ABANDON");
     const name = signalName(signal);
     this.signalHandlers.set(name, handler);
+    this.signalPolicies.set(name, policy);
     let payload = this.takeBuffered(name);
     while (payload !== void 0) {
       const value = payload;
-      this.runHandler(() => handler(value));
+      this.runHandler(() => handler(value), name, policy);
       payload = this.takeBuffered(name);
     }
   }
@@ -976,8 +1211,36 @@ var WorkflowExecution = class {
     for (const entry of buffered) {
       if (this.signalHandlers.has(entry.name)) continue;
       const payload = this.takeBuffered(entry.name);
-      if (payload !== void 0) this.runHandler(() => handler(entry.name, payload));
+      if (payload !== void 0)
+        this.runHandler(() => handler(entry.name, payload), entry.name, this.defaultSignalPolicy);
+    }
+  }
+  /** The command target of a run handle (11 §2.1, §2.24). */
+  externalTarget(target) {
+    if (typeof target === "string") {
+      if (target === "") throw new TypeError("A run handle needs a run id");
+      return { runId: target };
     }
+    if (typeof target === "object" && target !== null) {
+      if ("runId" in target && typeof target.runId === "string" && target.runId !== "")
+        return { runId: target.runId };
+      if ("workflowKey" in target && typeof target.workflowKey === "string" && target.workflowKey !== "" && typeof target.workflowId === "string" && target.workflowId !== "") {
+        const out = { workflowKey: target.workflowKey, workflowId: target.workflowId };
+        if (typeof target.firstRunId === "string" && target.firstRunId !== "")
+          out.firstRunId = target.firstRunId;
+        return out;
+      }
+    }
+    throw new TypeError("A run handle needs a run id or { workflowKey, workflowId }");
+  }
+  runHandle(target) {
+    const resolved = this.externalTarget(target);
+    return {
+      runId: "runId" in resolved ? resolved.runId : "",
+      ..."workflowId" in resolved ? { workflowKey: resolved.workflowKey, workflowId: resolved.workflowId } : {},
+      signal: (signal, payload) => this.signalExternal(resolved, signalName(signal), payload),
+      cancel: () => this.cancelExternal(resolved)
+    };
   }
   childTarget(target) {
     if (typeof target === "string") {
@@ -1004,6 +1267,12 @@ var WorkflowExecution = class {
     if (options.details !== void 0) opts["details"] = options.details;
     if (options.context !== void 0)
       opts["context"] = toJson(options.context, "The child context");
+    if (options.retry !== void 0)
+      opts["retry"] = toJson(runRetryPolicyOf(options.retry), "The child retry policy");
+    if (options.versioningBehavior !== void 0)
+      opts["versioningBehavior"] = options.versioningBehavior;
+    if (options.idReusePolicy !== void 0) opts["idReusePolicy"] = options.idReusePolicy;
+    if (options.idConflictPolicy !== void 0) opts["idConflictPolicy"] = options.idConflictPolicy;
     const durations = [
       ["startDelay", "startDelay"],
       ["executionTimeout", "executionTimeout"],
@@ -1233,17 +1502,16 @@ var WorkflowExecution = class {
     });
   }
   upsertContext(entries) {
-    this.push({
-      type: "UPSERT_CONTEXT",
-      entries: toJson(entries, "The context entries")
-    });
+    const json = toJson(entries, "The context entries");
+    if (!isJsonObject(json)) throw new TypeError("ctx.upsertContext takes an object");
+    if (this.push({ type: "UPSERT_CONTEXT", entries: json })) this.memo = { ...this.memo, ...json };
   }
   /** The request a `ctx.continueAsNew` call throws; the run ends with `CONTINUE_AS_NEW`. */
   continueAsNew(input, options) {
     const opts = {};
     if (options.taskQueue !== void 0) opts["taskQueue"] = options.taskQueue;
     if (options.retry !== void 0)
-      opts["retry"] = toJson(explicitRetryPolicy(options.retry), "retry");
+      opts["retry"] = toJson(continueAsNewRetryOf(options.retry), "retry");
     if (options.workflowTaskTimeout !== void 0)
       opts["workflowTaskTimeout"] = toMs(options.workflowTaskTimeout, "workflowTaskTimeout");
     if (options.context !== void 0) opts["context"] = toJson(options.context, "context");
@@ -1292,6 +1560,7 @@ var WorkflowExecution = class {
       out.push({ description: entry.description ?? fallback, stack: entry.stack ?? "" });
     };
     for (const entry of this.activities.values()) add(entry, "activity");
+    for (const entry of this.localActivities.values()) add(entry, "local activity");
     for (const entry of this.timers.values()) add(entry, "timer");
     for (const child of this.children.values()) {
       add(child.started, "child start");
@@ -1386,18 +1655,19 @@ ${entry.stack}`).join("\n\n")
       sleep: (duration, options = {}) => this.startTimer(scope(), toMs(duration, "sleep duration"), options.summary),
       condition: (predicate, timeout) => this.condition(scope(), predicate, timeout),
       signalReceived: (signal) => this.signalReceived(scope(), signal),
-      onSignal: (signal, handler) => this.onSignal(signal, handler),
+      onSignal: ((signal, optionsOrHandler, maybeHandler) => {
+        if (typeof optionsOrHandler === "function") this.onSignal(signal, optionsOrHandler);
+        else if (maybeHandler !== void 0)
+          this.onSignal(signal, maybeHandler, optionsOrHandler ?? {});
+        else throw new TypeError("ctx.onSignal needs a handler function");
+      }),
       setDefaultSignalHandler: (handler) => this.setDefaultSignalHandler(handler),
       child: (target, options = {}) => this.child(scope(), target, options),
       startChild: (target, options = {}) => this.startChild(scope(), target, options),
-      signalRun: (runId, signal, payload) => this.signalExternal({ runId }, signalName(signal), payload),
+      signalRun: (target, signal, payload) => this.signalExternal(this.externalTarget(target), signalName(signal), payload),
       signalParent: (signal, payload) => this.signalExternal({ parent: true }, signalName(signal), payload),
-      getRunHandle: (runId) => ({
-        runId,
-        signal: (signal, payload) => this.signalExternal({ runId }, signalName(signal), payload),
-        cancel: () => this.cancelExternal({ runId })
-      }),
-      cancelRun: (runId) => this.cancelExternal({ runId }),
+      getRunHandle: (target) => this.runHandle(target),
+      cancelRun: (target) => this.cancelExternal(this.externalTarget(target)),
       now: () => this.clock,
       random: () => this.random(),
       uuid: () => uuidFrom(this.random),
@@ -1451,9 +1721,7 @@ ${entry.stack}`).join("\n\n")
       },
       allHandlersFinished: () => this.allHandlersFinished(),
       activity: phaseC("ctx.activity (user activities)"),
-      localActivity: phaseC(
-        "ctx.localActivity (local activities)"
-      ),
+      localActivity: ((operation, options) => this.localActivity(scope(), operation, options)),
       handleQuery: phaseC("ctx.handleQuery (custom queries)"),
       handleUpdate: phaseC("ctx.handleUpdate (updates)"),
       upsertSearchAttributes: phaseC("ctx.upsertSearchAttributes (search attributes)")

package/dist/{chunk-SAOBPYYJ.cjs → chunk-NXFBVDOI.cjs}

@@ -4,7 +4,7 @@ var chunkG4UEPUGO_cjs = require('./chunk-G4UEPUGO.cjs');
 var chunkGVTZMA5C_cjs = require('./chunk-GVTZMA5C.cjs');
 var chunkTBDXTV22_cjs = require('./chunk-TBDXTV22.cjs');
 var chunkSAENRNBJ_cjs = require('./chunk-SAENRNBJ.cjs');
-var chunkDHTLALBL_cjs = require('./chunk-DHTLALBL.cjs');
+var chunkJ3PYFGKA_cjs = require('./chunk-J3PYFGKA.cjs');
 
 // src/builder/descriptors.ts
 function op(nodeType, version, operation) {
@@ -334,7 +334,7 @@ var WorkflowBuilder = class {
     let workflowFn;
     let definition;
     if (typeof fn === "string" && fn !== "") workflowFn = fn;
-    else if (chunkDHTLALBL_cjs.isDurableWorkflow(fn)) {
+    else if (chunkJ3PYFGKA_cjs.isDurableWorkflow(fn)) {
       definition = fn;
       workflowFn = fn.name;
     } else throw new chunkGVTZMA5C_cjs.BuilderError("wf.codeWorkflow needs a workflow() function or its export name");
@@ -755,7 +755,7 @@ function assembleRecording(recording, options = {}) {
   const authoring = options.authoring ?? {
     mode: "canvas",
     generator: "sdk-ts",
-    generatorVersion: chunkDHTLALBL_cjs.SDK_VERSION
+    generatorVersion: chunkJ3PYFGKA_cjs.SDK_VERSION
   };
   const out = { schemaVersion: 2 };
   for (const key of ["key", "name", "description", "interface", "code"]) {