@fluidgrids/workflows 2026.1029.1 → 2026.1030.1

package/dist/{chunk-7ILGCUI6.js → chunk-C4F5KJTI.js}

@@ -1,5 +1,5 @@
 import { durationMs } from './chunk-LNUQE6D6.js';
-import { explicitRunRetryPolicy, explicitRetryPolicy } from './chunk-PWIUEWC3.js';
+import { explicitRunRetryPolicy, explicitRetryPolicy, ACTIVITY_NAME_PATTERN, TASK_QUEUE_NAME_PATTERN } from './chunk-5HIVIV53.js';
 
 // src/durable/durations.ts
 function toMs(value, what = "duration") {
@@ -47,6 +47,17 @@ function workflow(name, optionsOrFn, maybeFn) {
   checkRunOptions(name, options);
   return Object.freeze({ __fluidgrids: DURABLE_MARKER, name, options, fn });
 }
+function dynamicWorkflow(name, optionsOrFn, maybeFn) {
+  const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+  const options = typeof optionsOrFn === "function" ? {} : optionsOrFn ?? {};
+  if (typeof fn !== "function") throw new TypeError(`dynamicWorkflow("${name}") needs a function`);
+  const declared = workflow(
+    name,
+    options,
+    (ctx, input) => fn(ctx, ctx.info.workflowFn, input)
+  );
+  return Object.freeze({ ...declared, dynamic: true });
+}
 function isDurableWorkflow(value) {
   return typeof value === "object" && value !== null && value.__fluidgrids === DURABLE_MARKER && typeof value.fn === "function";
 }
@@ -100,6 +111,14 @@ function interfaceOf(definition) {
     for (const update of updates)
       out.updates[update.name] = update.description !== void 0 ? { description: update.description } : {};
   }
+  const open = definition.options.open;
+  if (open !== void 0) {
+    const flags = {};
+    if (open.signals === true) flags.signals = true;
+    if (open.queries === true) flags.queries = true;
+    if (open.updates === true) flags.updates = true;
+    if (Object.keys(flags).length > 0) out.open = flags;
+  }
   return out;
 }
 var RUN_RETRY_OPTION_KEYS = /* @__PURE__ */ new Set([
@@ -149,6 +168,126 @@ function continueAsNewRetryOf(retry) {
 }
 
 // src/generated/version.ts
-var SDK_VERSION = "2026.1029.1";
+var SDK_VERSION = "2026.1030.1";
+
+// src/durable/interceptors.ts
+var INTERCEPTORS_MARKER = "fluidgrids.workflow-interceptors";
+function workflowInterceptors(factory) {
+  if (typeof factory !== "function")
+    throw new TypeError("workflowInterceptors() needs a factory function");
+  return Object.freeze({ __fluidgrids: INTERCEPTORS_MARKER, factory });
+}
+function interceptorsFactoryOf(value) {
+  if (typeof value === "function") {
+    return value;
+  }
+  if (typeof value === "object" && value !== null && value.__fluidgrids === INTERCEPTORS_MARKER && typeof value.factory === "function")
+    return value.factory;
+  return void 0;
+}
+function resolveWorkflowInterceptors(factories) {
+  const inbound = [];
+  const outbound = [];
+  for (const factory of factories) {
+    const made = factory();
+    if (typeof made !== "object" || made === null)
+      throw new TypeError("An interceptors factory must return { inbound?, outbound? }");
+    const lists = made;
+    if (lists.inbound !== void 0) {
+      if (!Array.isArray(lists.inbound))
+        throw new TypeError("interceptors.inbound must be an array");
+      inbound.push(...lists.inbound);
+    }
+    if (lists.outbound !== void 0) {
+      if (!Array.isArray(lists.outbound))
+        throw new TypeError("interceptors.outbound must be an array");
+      outbound.push(...lists.outbound);
+    }
+  }
+  return { inbound, outbound };
+}
+function compose(interceptors, method, terminal) {
+  let next = terminal;
+  for (let index = interceptors.length - 1; index >= 0; index--) {
+    const interceptor = interceptors[index];
+    const fn = interceptor?.[method];
+    if (typeof fn !== "function") continue;
+    const inner = next;
+    const call = fn;
+    next = (input) => call.call(interceptor, input, inner);
+  }
+  return next;
+}
+
+// src/durable/activities.ts
+var ACTIVITY_MARKER = "fluidgrids.activity";
+var ACTIVITY_IMPL_MARKER = "fluidgrids.activity-impl";
+var ACTIVITY_NAME = new RegExp(ACTIVITY_NAME_PATTERN);
+var TASK_QUEUE_NAME = new RegExp(TASK_QUEUE_NAME_PATTERN);
+var DYNAMIC_ACTIVITY_NAME = "*";
+function checkActivityName(name) {
+  if (typeof name !== "string" || !ACTIVITY_NAME.test(name))
+    throw new TypeError(
+      `An activity name must match ${ACTIVITY_NAME_PATTERN} (got "${String(name)}")`
+    );
+}
+function checkTaskQueueName(queue, what = "taskQueue") {
+  if (typeof queue !== "string" || !TASK_QUEUE_NAME.test(queue))
+    throw new TypeError(`${what} must match ${TASK_QUEUE_NAME_PATTERN} (got "${String(queue)}")`);
+}
+function declareActivity(name, options = {}) {
+  checkActivityName(name);
+  if (options.taskQueue !== void 0) checkTaskQueueName(options.taskQueue);
+  return Object.freeze({ __fluidgrids: ACTIVITY_MARKER, name, options: { ...options } });
+}
+function implementActivity(definition, fn) {
+  if (!isActivityDefinition(definition))
+    throw new TypeError("implementActivity() needs a declareActivity() value");
+  if (typeof fn !== "function") throw new TypeError("implementActivity() needs a function");
+  return Object.freeze({
+    __fluidgrids: ACTIVITY_MARKER,
+    name: definition.name,
+    options: definition.options,
+    implementation: ACTIVITY_IMPL_MARKER,
+    fn,
+    dynamic: false
+  });
+}
+function defineActivity(name, optionsOrFn, maybeFn) {
+  const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+  const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+  if (typeof fn !== "function") throw new TypeError(`defineActivity("${name}") needs a function`);
+  return implementActivity(declareActivity(name, options), fn);
+}
+function dynamicActivity(fn, options = {}) {
+  if (typeof fn !== "function") throw new TypeError("dynamicActivity() needs a function");
+  if (options.taskQueue !== void 0) checkTaskQueueName(options.taskQueue);
+  return Object.freeze({
+    __fluidgrids: ACTIVITY_MARKER,
+    name: DYNAMIC_ACTIVITY_NAME,
+    options: { ...options },
+    implementation: ACTIVITY_IMPL_MARKER,
+    fn,
+    dynamic: true
+  });
+}
+function isActivityDefinition(value) {
+  return typeof value === "object" && value !== null && value.__fluidgrids === ACTIVITY_MARKER && typeof value.name === "string";
+}
+function isActivityImplementation(value) {
+  return isActivityDefinition(value) && value.implementation === ACTIVITY_IMPL_MARKER && typeof value.fn === "function";
+}
+function findActivityImplementation(implementations, name) {
+  return implementations.find((impl) => !impl.dynamic && impl.name === name) ?? implementations.find((impl) => impl.dynamic);
+}
+function executeActivity(implementation, ctx, args, interceptors = []) {
+  const fn = implementation.fn;
+  const run = compose(
+    interceptors,
+    "execute",
+    async (input) => fn(ctx, input.args)
+  );
+  return run({ args, headers: ctx.info.headers, info: ctx.info });
+}
 
-export { DURABLE_MARKER, MAX_WORKFLOW_TASK_TIMEOUT_MS, SDK_VERSION, continueAsNewRetryOf, interfaceOf, isDurableWorkflow, jsonSchemaOf, optionalMs, runRetryPolicyOf, toMs, workflow };
+export { ACTIVITY_IMPL_MARKER, ACTIVITY_MARKER, DURABLE_MARKER, DYNAMIC_ACTIVITY_NAME, INTERCEPTORS_MARKER, MAX_WORKFLOW_TASK_TIMEOUT_MS, SDK_VERSION, checkActivityName, checkTaskQueueName, compose, continueAsNewRetryOf, declareActivity, defineActivity, dynamicActivity, dynamicWorkflow, executeActivity, findActivityImplementation, implementActivity, interceptorsFactoryOf, interfaceOf, isActivityDefinition, isActivityImplementation, isDurableWorkflow, jsonSchemaOf, optionalMs, resolveWorkflowInterceptors, runRetryPolicyOf, toMs, workflow, workflowInterceptors };

package/dist/{chunk-WXXNCHUY.js → chunk-G5H32GIG.js}

@@ -1,4 +1,4 @@
-import { HISTORY_PROTOCOL } from './chunk-2DDULZFM.js';
+import { HISTORY_PROTOCOL } from './chunk-5HIVIV53.js';
 
 function failedTaskResult(cause, message) {
   return {