@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/ir/index.js

@@ -1,8 +1,8 @@
-export { diffDefinitions } from '../chunk-6FSHT5IL.js';
+export { diffDefinitions } from '../chunk-7EZIANC7.js';
 import { findManifest, operationsOf, fieldsSchema } from '../chunk-QAN5MZEM.js';
 export { fieldSchema, fieldsSchema, findManifest, isTriggerOperation, operationsOf } from '../chunk-QAN5MZEM.js';
-import { usesMergedParameters, CODE_WORKFLOW_NODE_TYPE, WAIT_FOR_SIGNAL_NODE_TYPE, INTERNAL_TRIGGER_TYPES, V2_NODE_TYPES, normalizeDefinition } from '../chunk-BD7ZPG53.js';
-export { CODE_WORKFLOW_NODE_TYPE, INTERNAL_TRIGGER_TYPES, WAIT_FOR_SIGNAL_NODE_TYPE, buildIdOf, hashedProjection, irHash, normalizeDefinition, sourceHash, usesMergedParameters } from '../chunk-BD7ZPG53.js';
+import { usesMergedParameters, CODE_WORKFLOW_NODE_TYPE, WAIT_FOR_SIGNAL_NODE_TYPE, INTERNAL_TRIGGER_TYPES, SIGNAL_RUN_NODE_TYPE, SET_SEARCH_ATTRIBUTES_NODE_TYPE, V2_NODE_TYPES, normalizeDefinition } from '../chunk-NWQ5WRLE.js';
+export { CODE_WORKFLOW_NODE_TYPE, INTERNAL_TRIGGER_TYPES, PHASE_C_NODE_TYPES, SET_SEARCH_ATTRIBUTES_NODE_TYPE, SIGNAL_RUN_NODE_TYPE, WAIT_FOR_SIGNAL_NODE_TYPE, buildIdOf, hashedProjection, irHash, normalizeDefinition, sourceHash, usesMergedParameters } from '../chunk-NWQ5WRLE.js';
 export { LAYOUT_COLUMN_WIDTH, LAYOUT_ROW_HEIGHT, autoLayout } from '../chunk-5LUIDMF4.js';
 export { CanonicalJsonError, canonicalJson, sha256Hex, sha256Tagged, stableStringify } from '../chunk-E2VK7J2C.js';
 import { hasLegacyTemplate } from '../chunk-7AAZGVKD.js';
@@ -13,8 +13,41 @@ export { durationMs } from '../chunk-LNUQE6D6.js';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import { CronExpressionParser } from 'cron-parser';
 
+// src/ir/schedule-fields.ts
+var SCHEDULE_OVERLAP_POLICIES = [
+  "SKIP",
+  "BUFFER_ONE",
+  "BUFFER_ALL",
+  "CANCEL_OTHER",
+  "TERMINATE_OTHER",
+  "ALLOW_ALL"
+];
+var DEFAULT_NEW_SCHEDULE_OVERLAP_POLICY = "SKIP";
+var DEFAULT_SCHEDULE_CATCHUP_WINDOW_SECONDS = 3600;
+var SCHEDULE_POLICY_FIELDS = [
+  "overlapPolicy",
+  "catchupWindow",
+  "pauseOnFailure",
+  "limitedActions",
+  "scheduleContext",
+  "scheduleSearchAttributes"
+];
+var SCHEDULE_SPEC_FIELDS = [
+  "excludeCalendars",
+  "startAt",
+  "endAt",
+  "timezone",
+  "jitter"
+];
+
 // src/ir/schema.ts
 var JSON_SCHEMA_OBJECT = { type: "object" };
+var DURATION = {
+  oneOf: [
+    { type: "number", minimum: 0 },
+    { type: "string", minLength: 1 }
+  ]
+};
 var IR_V2_SCHEMA_ID = "https://docs.fluidgrids.ai/schemas/workflow-ir-v2.schema.json";
 var IR_V2_SCHEMA = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -182,6 +215,118 @@ var IR_V2_SCHEMA = {
               }
             }
           }
+        },
+        {
+          if: { properties: { type: { const: "internal:signal-run" } }, required: ["type"] },
+          then: {
+            description: "Phase C (fluidgrids.run-control): signal another run of the workspace (05 \xA74). A retried node delivers once (dedupe key signal-node:<nodeStateId>:<attempt>).",
+            required: ["args"],
+            properties: {
+              args: {
+                required: ["state"],
+                properties: {
+                  state: {
+                    type: "object",
+                    required: ["signalName", "target"],
+                    properties: {
+                      signalName: { type: "string", minLength: 1 },
+                      target: {
+                        description: "The run to signal: { runId }, { workflowKey, workflowId, firstRunId? } (the open run of that workflow id) or { parent: true }. Values may be expressions.",
+                        oneOf: [
+                          {
+                            type: "object",
+                            required: ["runId"],
+                            properties: { runId: { type: "string", minLength: 1 } },
+                            additionalProperties: false
+                          },
+                          {
+                            type: "object",
+                            required: ["workflowKey", "workflowId"],
+                            properties: {
+                              workflowKey: { type: "string", minLength: 1 },
+                              workflowId: { type: "string", minLength: 1 },
+                              firstRunId: { type: "string", minLength: 1 }
+                            },
+                            additionalProperties: false
+                          },
+                          {
+                            type: "object",
+                            required: ["parent"],
+                            properties: { parent: { const: true } },
+                            additionalProperties: false
+                          }
+                        ]
+                      },
+                      payload: {},
+                      failOnUndelivered: {
+                        type: "boolean",
+                        description: "Default true: an undelivered signal fails the node."
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: { type: { const: "internal:set-search-attributes" } },
+            required: ["type"]
+          },
+          then: {
+            description: "Phase C (fluidgrids.search-attributes): upsert the run search attributes (11 \xA72.8); a null value removes one. Values may be expressions; the service validates them against the workspace definitions.",
+            required: ["args"],
+            properties: {
+              args: {
+                required: ["state"],
+                properties: {
+                  state: {
+                    type: "object",
+                    required: ["attributes"],
+                    properties: {
+                      attributes: { type: "object", minProperties: 1 }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        {
+          if: { properties: { type: { const: "internal:schedule" } }, required: ["type"] },
+          then: {
+            properties: {
+              args: {
+                properties: {
+                  state: {
+                    description: "Phase C schedule policies (11 \xA72.16, \xA72.33; fluidgrids.schedule-policies). Every field is optional; a trigger without overlapPolicy keeps the ALLOW_ALL behaviour of earlier versions.",
+                    properties: {
+                      overlapPolicy: { enum: [...SCHEDULE_OVERLAP_POLICIES] },
+                      catchupWindow: DURATION,
+                      pauseOnFailure: { type: "boolean" },
+                      limitedActions: { type: "integer", minimum: 1 },
+                      scheduleContext: { type: "object" },
+                      scheduleSearchAttributes: { type: "object" },
+                      spec: {
+                        description: "One of cron, calendar or interval, plus excludeCalendars (calendar entries whose matches are skipped), startAt, endAt (ISO 8601), timezone and jitter.",
+                        properties: {
+                          cron: { type: "string" },
+                          calendar: { type: "array", items: { type: "object" } },
+                          interval: { type: "array", items: { type: "object" } },
+                          excludeCalendars: { type: "array", items: { type: "object" } },
+                          startAt: { type: "string", minLength: 1 },
+                          endAt: { type: "string", minLength: 1 },
+                          timezone: { type: "string" },
+                          jitter: DURATION
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
         }
       ]
     },
@@ -213,7 +358,18 @@ var IR_V2_SCHEMA = {
           type: ["number", "string"],
           description: "Seconds or a duration string."
         },
-        versioningBehavior: { enum: ["PINNED", "AUTO_UPGRADE"] }
+        versioningBehavior: { enum: ["PINNED", "AUTO_UPGRADE"] },
+        retry: {
+          type: "object",
+          description: "Run-level retry of DURABLE_FN runs (11 \xA72.17); delays are seconds or duration strings. Graph runs keep their own meaning of retry.",
+          properties: {
+            maxAttempts: { type: "integer", minimum: 1 },
+            initialDelay: { type: ["number", "string"] },
+            backoffMultiplier: { type: "number", minimum: 1 },
+            maxDelay: { type: ["number", "string"] },
+            nonRetryableErrorTypes: { type: "array", items: { type: "string" } }
+          }
+        }
       }
     },
     interface: {
@@ -286,7 +442,11 @@ var IR_V2_SCHEMA = {
                 type: "object",
                 properties: {
                   interface: { $ref: "#/$defs/interface" },
-                  taskQueue: { type: "string" }
+                  taskQueue: { type: "string" },
+                  config: {
+                    $ref: "#/$defs/config",
+                    description: "R2: the run-level settings of this function's workflow() declaration (retry, timeout, executionTimeout, workflowTaskTimeout, versioningBehavior). The service resolves run options per workflowFn from this table, never from the definition-level config, so a same-bundle child started on its parent's definition gets its own settings. Absent: the function declares none."
+                  }
                 }
               }
             },
@@ -303,7 +463,13 @@ var IR_V2_SCHEMA = {
             }
           }
         },
-        determinism: { enum: ["isolate", "worker"] }
+        determinism: { enum: ["isolate", "worker"] },
+        features: {
+          type: "array",
+          items: { type: "string", minLength: 1 },
+          uniqueItems: true,
+          description: "Runtime features the bundle uses (C-FEATURES): localActivity, externalCancel, childOptions, canOptions, autoUpgrade, runRetry, timeouts (SDK R2); userActivity, updates, queries, searchAttributes, dynamic and interceptors (Phase C, C-R1). A bundle without the field was built before R2 and uses none."
+        }
       }
     },
     authoring: {
@@ -447,23 +613,71 @@ function cronTimes(expression, now, tz, accept) {
   for (let i = 0; i < MAX_ITERATIONS && out.length < FIRE_TIMES; i++) {
     if (!interval.hasNext()) break;
     const date = interval.next().toDate();
-    if (accept(date)) out.push(date.toISOString());
+    const verdict = accept(date);
+    if (verdict === "stop") break;
+    if (verdict === "keep") out.push(date.toISOString());
   }
   return out;
 }
-function localParts(date, tz) {
-  if (!tz) return { weekday: date.getUTCDay(), year: date.getUTCFullYear() };
+var WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function localFields(date, tz) {
+  if (!tz)
+    return {
+      second: date.getUTCSeconds(),
+      minute: date.getUTCMinutes(),
+      hour: date.getUTCHours(),
+      dayOfMonth: date.getUTCDate(),
+      month: date.getUTCMonth() + 1,
+      dayOfWeek: date.getUTCDay(),
+      year: date.getUTCFullYear()
+    };
   const parts = new Intl.DateTimeFormat("en-US", {
     timeZone: tz,
     weekday: "short",
-    year: "numeric"
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric",
+    hourCycle: "h23"
   }).formatToParts(date);
-  const weekdayName = parts.find((part) => part.type === "weekday")?.value ?? "Sun";
-  const year = Number(parts.find((part) => part.type === "year")?.value ?? date.getUTCFullYear());
-  const weekday = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].indexOf(weekdayName);
-  return { weekday, year };
+  const part = (type) => parts.find((entry) => entry.type === type)?.value ?? "0";
+  return {
+    second: Number(part("second")),
+    minute: Number(part("minute")),
+    hour: Number(part("hour")) % 24,
+    dayOfMonth: Number(part("day")),
+    month: Number(part("month")),
+    dayOfWeek: WEEKDAYS.indexOf(part("weekday")),
+    year: Number(part("year"))
+  };
+}
+function localParts(date, tz) {
+  const fields = localFields(date, tz);
+  return { weekday: fields["dayOfWeek"] ?? 0, year: fields["year"] ?? 0 };
+}
+var MATCH_FIELDS = [
+  { name: "second", min: 0, max: 59, fallback: "0", defaultZero: true },
+  { name: "minute", min: 0, max: 59, fallback: "0", defaultZero: true },
+  { name: "hour", min: 0, max: 23, fallback: "0", defaultZero: true },
+  { name: "dayOfMonth", min: 1, max: 31, fallback: "*", defaultZero: false },
+  { name: "month", min: 1, max: 12, fallback: "*", defaultZero: false },
+  { name: "dayOfWeek", min: 0, max: 6, fallback: "*", defaultZero: false },
+  { name: "year", min: 1970, max: 9999, fallback: "*", defaultZero: false }
+];
+function calendarMatcher(entry) {
+  if (!isRecord(entry)) throw new Error("each excludeCalendars entry must be an object");
+  return MATCH_FIELDS.map((field) => {
+    const value = entry[field.name];
+    if (value === void 0) return [field.name, field.defaultZero ? /* @__PURE__ */ new Set([0]) : void 0];
+    return [field.name, new Set(rangeValues(value, field.min, field.max, field.name))];
+  });
+}
+function matches(matcher, fields) {
+  return matcher.every(([name, values]) => values === void 0 || values.has(fields[name] ?? -1));
 }
-function calendarTimes(entries, now, tz) {
+function calendarTimes(entries, now, tz, accept) {
   const all = [];
   for (const entry of entries) {
     if (!isRecord(entry)) throw new Error("each calendar entry must be an object");
@@ -476,13 +690,15 @@ function calendarTimes(entries, now, tz) {
     all.push(
       ...cronTimes(`${expression} *`, now, tz, (date) => {
         const local = localParts(date, tz);
-        return (!weekdays || weekdays.has(local.weekday)) && (!years || years.has(local.year));
+        if (!((!weekdays || weekdays.has(local.weekday)) && (!years || years.has(local.year))))
+          return "skip";
+        return accept(date);
       })
     );
   }
   return [...new Set(all)].sort().slice(0, FIRE_TIMES);
 }
-function intervalTimes(entries, now) {
+function intervalTimes(entries, now, accept) {
   const all = [];
   for (const entry of entries) {
     if (!isRecord(entry)) throw new Error("each interval entry must be an object");
@@ -494,10 +710,24 @@ function intervalTimes(entries, now) {
       throw new Error("interval.offset must be a duration below every");
     let next = Math.floor((now.getTime() - offset) / every) * every + offset;
     if (next <= now.getTime()) next += every;
-    for (let i = 0; i < FIRE_TIMES; i++) all.push(next + i * every);
+    let kept = 0;
+    for (let i = 0; i < MAX_ITERATIONS && kept < FIRE_TIMES; i++, next += every) {
+      const verdict = accept(new Date(next));
+      if (verdict === "stop") break;
+      if (verdict === "skip") continue;
+      all.push(next);
+      kept += 1;
+    }
   }
   return [...new Set(all)].sort((a, b) => a - b).slice(0, FIRE_TIMES).map((time) => new Date(time).toISOString());
 }
+function dateField(spec, field) {
+  const value = spec[field];
+  if (value === void 0) return void 0;
+  const ms = typeof value === "string" ? Date.parse(value) : Number.NaN;
+  if (Number.isNaN(ms)) throw new Error(`${field} must be an ISO 8601 date-time`);
+  return new Date(ms);
+}
 function checkScheduleSpec(spec, options = {}) {
   const now = options.now ?? /* @__PURE__ */ new Date();
   if (!isRecord(spec)) return { ok: false, problem: "spec must be an object", nextFireTimes: [] };
@@ -511,20 +741,37 @@ function checkScheduleSpec(spec, options = {}) {
   }
   const tz = timezoneOf(spec, options.timezone);
   try {
+    const startAt = dateField(spec, "startAt");
+    const endAt = dateField(spec, "endAt");
+    if (startAt && endAt && endAt.getTime() <= startAt.getTime())
+      throw new Error("endAt must be after startAt");
+    if (spec["jitter"] !== void 0 && durationMs(spec["jitter"], "s") === void 0)
+      throw new Error("jitter must be a duration");
+    const excludes = spec["excludeCalendars"];
+    if (excludes !== void 0 && !Array.isArray(excludes))
+      throw new Error("excludeCalendars must be a list");
+    const matchers = (excludes ?? []).map(calendarMatcher);
+    const from = startAt && startAt.getTime() > now.getTime() ? new Date(startAt.getTime() - 1) : now;
+    const accept = (date) => {
+      if (endAt && date.getTime() > endAt.getTime()) return "stop";
+      if (matchers.length === 0) return "keep";
+      const fields = localFields(date, tz);
+      return matchers.some((matcher) => matches(matcher, fields)) ? "skip" : "keep";
+    };
     let times;
     if (kinds[0] === "cron") {
       if (typeof spec["cron"] !== "string") throw new Error("cron must be a string");
-      times = cronTimes(spec["cron"], now, tz, () => true);
+      times = cronTimes(spec["cron"], from, tz, accept);
     } else if (kinds[0] === "calendar") {
       if (!Array.isArray(spec["calendar"]) || spec["calendar"].length === 0) {
         throw new Error("calendar must be a non-empty list");
       }
-      times = calendarTimes(spec["calendar"], now, tz);
+      times = calendarTimes(spec["calendar"], from, tz, accept);
     } else {
       if (!Array.isArray(spec["interval"]) || spec["interval"].length === 0) {
         throw new Error("interval must be a non-empty list");
       }
-      times = intervalTimes(spec["interval"], now);
+      times = intervalTimes(spec["interval"], from, accept);
     }
     if (times.length === 0)
       return { ok: false, problem: "the spec never fires", nextFireTimes: [] };
@@ -537,6 +784,26 @@ function checkScheduleSpec(spec, options = {}) {
     };
   }
 }
+function checkSchedulePolicy(state) {
+  const policy = state["overlapPolicy"];
+  if (policy !== void 0 && !(typeof policy === "string" && SCHEDULE_OVERLAP_POLICIES.includes(policy)))
+    return {
+      field: "overlapPolicy",
+      message: `overlapPolicy must be one of ${SCHEDULE_OVERLAP_POLICIES.join(", ")}`
+    };
+  const window = state["catchupWindow"];
+  if (window !== void 0 && durationMs(window, "s") === void 0)
+    return { field: "catchupWindow", message: "catchupWindow must be a duration" };
+  if (state["pauseOnFailure"] !== void 0 && typeof state["pauseOnFailure"] !== "boolean")
+    return { field: "pauseOnFailure", message: "pauseOnFailure must be true or false" };
+  const limited = state["limitedActions"];
+  if (limited !== void 0 && !(typeof limited === "number" && Number.isInteger(limited) && limited >= 1))
+    return { field: "limitedActions", message: "limitedActions must be a positive integer" };
+  for (const field of ["scheduleContext", "scheduleSearchAttributes"])
+    if (state[field] !== void 0 && !isRecord(state[field]))
+      return { field, message: `${field} must be an object` };
+  return void 0;
+}
 
 // src/ir/validate.ts
 var SLUG = /^[a-z][a-z0-9-]{0,62}$/;
@@ -778,7 +1045,8 @@ function validate(definition, options = {}) {
           message: "A code-workflow node needs a code bundle on the definition",
           ...at
         });
-      } else if (typeof workflowFn !== "string" || !Object.hasOwn(workflowExports, workflowFn)) {
+      } else if (typeof workflowFn !== "string" || workflowFn === "" || // A dynamic workflow ("*", 11 §2.29) serves every other name.
+      !(Object.hasOwn(workflowExports, workflowFn) || Object.hasOwn(workflowExports, "*"))) {
         fail({
           code: "codeWorkflow.unknownFunction",
           message: `workflowFn "${String(workflowFn)}" is not exported by the bundle`,
@@ -846,6 +1114,44 @@ function validate(definition, options = {}) {
         });
       }
     }
+    if (type === "internal:schedule" && state !== void 0) {
+      const problem = checkSchedulePolicy(state);
+      if (problem !== void 0)
+        fail({
+          code: "schedule.invalidPolicy",
+          message: `Schedule policy: ${problem.message}`,
+          ...at,
+          path: `args.state.${problem.field}`
+        });
+    }
+    if (type === SIGNAL_RUN_NODE_TYPE) {
+      const target = state?.["target"];
+      const valid = isRecord(target) && (typeof target["runId"] === "string" || target["parent"] === true || typeof target["workflowKey"] === "string" && typeof target["workflowId"] === "string");
+      if (typeof state?.["signalName"] !== "string" || state["signalName"] === "")
+        fail({
+          code: "signalRun.signalNameRequired",
+          message: "A signal-run node needs a signalName",
+          ...at,
+          path: "args.state.signalName"
+        });
+      if (!valid)
+        fail({
+          code: "signalRun.invalidTarget",
+          message: "A signal-run node needs a target: { runId }, { workflowKey, workflowId } or { parent: true }",
+          ...at,
+          path: "args.state.target"
+        });
+    }
+    if (type === SET_SEARCH_ATTRIBUTES_NODE_TYPE) {
+      const attributes = state?.["attributes"];
+      if (!isRecord(attributes) || Object.keys(attributes).length === 0)
+        fail({
+          code: "setSearchAttributes.attributesRequired",
+          message: "A set-search-attributes node needs at least one attribute",
+          ...at,
+          path: "args.state.attributes"
+        });
+    }
     if (strict) {
       if (id && !SLUG.test(id)) {
         fail({
@@ -1110,4 +1416,4 @@ function deriveInterface(definition, options = {}) {
   return derived;
 }
 
-export { IR_V2_SCHEMA, IR_V2_SCHEMA_ID, WORKFLOW_DOCUMENT_FORMAT, buildExportDocument, checkScheduleSpec, deriveInterface, envelopeSchemaVersion, executorNodeView, executorView, exportDefinition, isV2Definition, isValidJsonSchema, parseWorkflowDocument, readWorkflowDocument, serializeWorkflowDocument, validate, workflowInputsSchema };
+export { DEFAULT_NEW_SCHEDULE_OVERLAP_POLICY, DEFAULT_SCHEDULE_CATCHUP_WINDOW_SECONDS, IR_V2_SCHEMA, IR_V2_SCHEMA_ID, SCHEDULE_OVERLAP_POLICIES, SCHEDULE_POLICY_FIELDS, SCHEDULE_SPEC_FIELDS, WORKFLOW_DOCUMENT_FORMAT, buildExportDocument, checkSchedulePolicy, checkScheduleSpec, deriveInterface, envelopeSchemaVersion, executorNodeView, executorView, exportDefinition, isV2Definition, isValidJsonSchema, parseWorkflowDocument, readWorkflowDocument, serializeWorkflowDocument, validate, workflowInputsSchema };

package/dist/{lower-BzmUz0sq.d.cts → lower-BtRfIW2A.d.cts}

@@ -1,6 +1,6 @@
 import { S as SourceFile } from './hash-CZkTXPCX.cjs';
-import { b as WorkflowDefinition, W as WorkflowInterface } from './types-BGoPzgcl.cjs';
-import { C as ConnectionResolver } from './assemble-BLqQ8lSu.cjs';
+import { W as WorkflowDefinition, b as WorkflowInterface, k as WorkflowConfig } from './types-V7jEEUaL.cjs';
+import { d as ConnectionResolver, a as CollectedDurableWorkflow } from './collect-CcTCKqx6.cjs';
 import { E as EsbuildApi, L as LowerError } from './lower-types-DQNBfWQn.cjs';
 
 /** One vendored package: its version and its files (paths relative to the package root). */
@@ -20,6 +20,12 @@ interface BuildBundleOptions {
     maxSourceBytes?: number;
     /** Largest bundle, in UTF-8 bytes. Default 1.5 MiB (4 MiB with vendored deps). */
     maxBundleBytes?: number;
+    /**
+     * `external` also returns a source map of the bundle (C-SOURCEMAP) in
+     * `map`. The bundle bytes, and so `buildId`, are the same as without it:
+     * no `sourceMappingURL` comment is added.
+     */
+    sourcemap?: 'external';
 }
 interface BuiltBundle {
     /** The ES module. */
@@ -33,6 +39,18 @@ interface BuiltBundle {
      */
     sourceHash: string;
     entries: string[];
+    /**
+     * The project modules (`workflows/order.ts`) and vendored files
+     * (`node_modules/<package>/<path>`) the bundle contains, sorted.
+     */
+    modules: string[];
+    /**
+     * With `sourcemap: 'external'`: the source map (version 3 JSON) of the
+     * bundle. Sources are named like build messages (`workflows/order.ts`,
+     * `node_modules/<package>/<path>`, `@fluidgrids/workflows`); the map holds
+     * no source contents, which the source archive already has.
+     */
+    map?: string;
 }
 /** Node built-in module names (without the `node:` prefix). */
 declare const NODE_BUILTINS: ReadonlySet<string>;
@@ -87,7 +105,7 @@ interface LowerOptions {
 }
 /** A problem `lower()` found in tier-2 sources without running them. */
 interface LowerIssue {
-    code: 'durable.phaseC' | 'durable.activityTypeNotAllowed';
+    code: 'durable.phaseC' | 'durable.activityTypeNotAllowed' | 'durable.localActivityTimeout' | 'durable.activityImplInBundle';
     message: string;
     module: string;
 }
@@ -108,22 +126,52 @@ interface LowerResult {
     durableExports: Record<string, {
         interface: WorkflowInterface;
         taskQueue: string;
+        config?: WorkflowConfig;
     }>;
     /** Findings in tier-2 sources (Phase C features, refused activity node types). */
     issues: LowerIssue[];
+    /**
+     * Runtime features the bundle uses (C-FEATURES), sorted; written as
+     * `code.features` when not empty. The service refuses a feature its
+     * workspace flags do not enable.
+     */
+    features: string[];
 }
 /**
  * Bundle a project. Exported so services can compute `buildId` without
  * evaluating; `buildBundle()` is the full form (vendored packages, limits).
  */
 declare function bundleProject(files: ReadonlyMap<string, string>, entries: readonly string[], esbuild: EsbuildApi): Promise<string>;
+/** The `code.exports.workflows` key of a dynamic workflow (11 §2.29). */
+declare const DYNAMIC_EXPORT = "*";
+/**
+ * Find user local activities (not run yet), refused activity node types and
+ * local-activity timeouts over the cap in the modules a tier-2 workflow may
+ * run (see {@link durableScanModules}), without running them. The runtime and
+ * the service refuse them as well; this reports them before a push. The
+ * Phase C features (queries, updates, user activities, search attributes,
+ * dynamic workflows, interceptors and sinks) are no longer findings: they are
+ * written to `code.features` and gated by the service (C-FEATURES).
+ *
+ * With `bundled` (the modules `buildBundle` put into the bundle), a
+ * user-activity implementation in one of them is reported as
+ * `durable.activityImplInBundle`: it belongs on a worker (CWD9).
+ */
+declare function scanDurableSources(files: ReadonlyMap<string, string>, modules: Iterable<string>, bundled?: readonly string[]): LowerIssue[];
+/**
+ * The modules a tier-2 workflow may run code from: every source module of a
+ * project that declares one (the declaring modules and every helper they may
+ * import), sorted. A project without tier-2 workflows has none.
+ */
+declare function durableScanModules(files: ReadonlyMap<string, string>, durable: readonly Pick<CollectedDurableWorkflow, 'module'>[]): string[];
 /**
- * Find Phase C features and refused activity node types in the modules that
- * declare tier-2 functions, without running them. The runtime and the service
- * refuse both as well; this reports them before a push.
+ * The runtime features (C-FEATURES) of a bundle: what the call sites of every
+ * module a tier-2 workflow may run show (project helpers and vendored
+ * packages included), and what its declarations' options use, sorted and
+ * without duplicates.
  */
-declare function scanDurableSources(files: ReadonlyMap<string, string>, modules: Iterable<string>): LowerIssue[];
+declare function durableFeatures(files: ReadonlyMap<string, string>, durable: readonly CollectedDurableWorkflow[], deps?: VendoredDeps): string[];
 /** Lower TypeScript sources (tier 1 and tier 2) to IR v2. */
 declare function lower(files: readonly SourceFile[] | Readonly<Record<string, string>>, options?: LowerOptions): Promise<LowerResult>;
 
-export { type BuildBundleOptions as B, DeterminismViolationError as D, type Evaluator as E, type LowerIssue as L, NODE_BUILTINS as N, type VendoredDeps as V, type VendoredPackage as a, type BuiltBundle as b, ESBUILD_VERSION as c, EVALUATION_GLOBAL as d, type LowerOptions as e, type LowerResult as f, type LoweredWorkflow as g, buildBundle as h, bundleProject as i, bundleSourceHash as j, defaultEntries as k, lower as l, splitSpecifier as m, resolvePackageEntry as r, scanDurableSources as s };
+export { type BuildBundleOptions as B, DYNAMIC_EXPORT as D, type Evaluator as E, type LowerIssue as L, NODE_BUILTINS as N, type VendoredDeps as V, type VendoredPackage as a, type BuiltBundle as b, DeterminismViolationError as c, ESBUILD_VERSION as d, EVALUATION_GLOBAL as e, type LowerOptions as f, type LowerResult as g, type LoweredWorkflow as h, buildBundle as i, bundleProject as j, bundleSourceHash as k, defaultEntries as l, durableFeatures as m, durableScanModules as n, lower as o, splitSpecifier as p, resolvePackageEntry as r, scanDurableSources as s };