@fluidgrids/workflows 2026.1029.1 → 2026.1030.1

package/dist/ir/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunkNEIUQASE_cjs = require('../chunk-NEIUQASE.cjs');
+var chunk4QKB4ARC_cjs = require('../chunk-4QKB4ARC.cjs');
 var chunkCPDK3K5N_cjs = require('../chunk-CPDK3K5N.cjs');
-var chunkGBQ33SIZ_cjs = require('../chunk-GBQ33SIZ.cjs');
+var chunk54FLQNUM_cjs = require('../chunk-54FLQNUM.cjs');
 var chunkG4UEPUGO_cjs = require('../chunk-G4UEPUGO.cjs');
 var chunkQKZL3ONM_cjs = require('../chunk-QKZL3ONM.cjs');
 var chunkTBDXTV22_cjs = require('../chunk-TBDXTV22.cjs');
@@ -12,8 +12,41 @@ require('../chunk-Z2Y65YOY.cjs');
 var _2020_js = require('ajv/dist/2020.js');
 var cronParser = require('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",
@@ -181,6 +214,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
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
         }
       ]
     },
@@ -322,7 +467,7 @@ var IR_V2_SCHEMA = {
           type: "array",
           items: { type: "string", minLength: 1 },
           uniqueItems: true,
-          description: "Runtime features the bundle uses (C-FEATURES, SDK R2): localActivity, externalCancel, childOptions, canOptions, autoUpgrade, runRetry, timeouts; Phase C adds userActivity, updates, queries, searchAttributes, dynamic and interceptors. A bundle without the field was built before R2 and uses none."
+          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."
         }
       }
     },
@@ -367,7 +512,7 @@ function executorNodeView(node) {
   const args = chunkSAENRNBJ_cjs.isRecord(record["args"]) ? record["args"] : void 0;
   const dataArgs = chunkSAENRNBJ_cjs.isRecord(data?.["args"]) ? data["args"] : void 0;
   const type = typeof record["type"] === "string" ? record["type"] : "";
-  const merged = chunkGBQ33SIZ_cjs.usesMergedParameters(type);
+  const merged = chunk54FLQNUM_cjs.usesMergedParameters(type);
   let parameters;
   if (merged) {
     const config = chunkSAENRNBJ_cjs.isRecord(record["config"]) ? record["config"] : {};
@@ -467,23 +612,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 (!chunkSAENRNBJ_cjs.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 (!chunkSAENRNBJ_cjs.isRecord(entry)) throw new Error("each calendar entry must be an object");
@@ -496,13 +689,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 (!chunkSAENRNBJ_cjs.isRecord(entry)) throw new Error("each interval entry must be an object");
@@ -514,10 +709,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 (!chunkSAENRNBJ_cjs.isRecord(spec)) return { ok: false, problem: "spec must be an object", nextFireTimes: [] };
@@ -531,20 +740,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 && chunkFR7KYWRO_cjs.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: [] };
@@ -557,6 +783,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 && chunkFR7KYWRO_cjs.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 && !chunkSAENRNBJ_cjs.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}$/;
@@ -626,7 +872,7 @@ function isHardSchemaError(error) {
 function legacyMirrors(node) {
   const found = [];
   const type = typeof node["type"] === "string" ? node["type"] : "";
-  const merged = chunkGBQ33SIZ_cjs.usesMergedParameters(type);
+  const merged = chunk54FLQNUM_cjs.usesMergedParameters(type);
   const data = chunkSAENRNBJ_cjs.isRecord(node["data"]) ? node["data"] : void 0;
   const dataArgs = chunkSAENRNBJ_cjs.isRecord(data?.["args"]) ? data["args"] : void 0;
   if (data) {
@@ -790,7 +1036,7 @@ function validate(definition, options = {}) {
     const type = typeof node["type"] === "string" ? node["type"] : "";
     const args = chunkSAENRNBJ_cjs.isRecord(node["args"]) ? node["args"] : void 0;
     const state = chunkSAENRNBJ_cjs.isRecord(args?.["state"]) ? args["state"] : void 0;
-    if (type === chunkGBQ33SIZ_cjs.CODE_WORKFLOW_NODE_TYPE) {
+    if (type === chunk54FLQNUM_cjs.CODE_WORKFLOW_NODE_TYPE) {
       const workflowFn = state?.["workflowFn"];
       if (!code) {
         fail({
@@ -798,7 +1044,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`,
@@ -823,7 +1070,7 @@ function validate(definition, options = {}) {
           path: "args.state.timeout"
         });
     }
-    if (type === chunkGBQ33SIZ_cjs.WAIT_FOR_SIGNAL_NODE_TYPE) {
+    if (type === chunk54FLQNUM_cjs.WAIT_FOR_SIGNAL_NODE_TYPE) {
       const until = state?.["limitWaitUntil"];
       if (until !== void 0 && (typeof until !== "string" || Number.isNaN(Date.parse(until))))
         fail({
@@ -833,7 +1080,7 @@ function validate(definition, options = {}) {
           path: "args.state.limitWaitUntil"
         });
     }
-    const isTrigger = chunkGBQ33SIZ_cjs.INTERNAL_TRIGGER_TYPES.has(type) || id !== void 0 && (incoming.get(id) ?? 0) === 0;
+    const isTrigger = chunk54FLQNUM_cjs.INTERNAL_TRIGGER_TYPES.has(type) || id !== void 0 && (incoming.get(id) ?? 0) === 0;
     if (isTrigger && state?.["startDelay"] !== void 0) {
       const delay = chunkFR7KYWRO_cjs.durationMs(state["startDelay"], "s");
       if (delay === void 0) {
@@ -866,6 +1113,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 === chunk54FLQNUM_cjs.SIGNAL_RUN_NODE_TYPE) {
+      const target = state?.["target"];
+      const valid = chunkSAENRNBJ_cjs.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 === chunk54FLQNUM_cjs.SET_SEARCH_ATTRIBUTES_NODE_TYPE) {
+      const attributes = state?.["attributes"];
+      if (!chunkSAENRNBJ_cjs.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({
@@ -1023,14 +1308,14 @@ function isV2Definition(definition) {
   const data = definition["data"];
   const nodes = chunkSAENRNBJ_cjs.isRecord(data) && Array.isArray(data["nodes"]) ? data["nodes"] : [];
   return nodes.some(
-    (node) => chunkSAENRNBJ_cjs.isRecord(node) && typeof node["type"] === "string" && chunkGBQ33SIZ_cjs.V2_NODE_TYPES.has(node["type"])
+    (node) => chunkSAENRNBJ_cjs.isRecord(node) && typeof node["type"] === "string" && chunk54FLQNUM_cjs.V2_NODE_TYPES.has(node["type"])
   );
 }
 function envelopeSchemaVersion(definition) {
   return isV2Definition(definition) ? 2 : 1;
 }
 function exportDefinition(definition) {
-  return isV2Definition(definition) ? chunkGBQ33SIZ_cjs.normalizeDefinition(definition) : definition;
+  return isV2Definition(definition) ? chunk54FLQNUM_cjs.normalizeDefinition(definition) : definition;
 }
 function buildExportDocument(input) {
   return {
@@ -1132,7 +1417,7 @@ function deriveInterface(definition, options = {}) {
 
 Object.defineProperty(exports, "diffDefinitions", {
   enumerable: true,
-  get: function () { return chunkNEIUQASE_cjs.diffDefinitions; }
+  get: function () { return chunk4QKB4ARC_cjs.diffDefinitions; }
 });
 Object.defineProperty(exports, "fieldSchema", {
   enumerable: true,
@@ -1156,39 +1441,51 @@ Object.defineProperty(exports, "operationsOf", {
 });
 Object.defineProperty(exports, "CODE_WORKFLOW_NODE_TYPE", {
   enumerable: true,
-  get: function () { return chunkGBQ33SIZ_cjs.CODE_WORKFLOW_NODE_TYPE; }
+  get: function () { return chunk54FLQNUM_cjs.CODE_WORKFLOW_NODE_TYPE; }
 });
 Object.defineProperty(exports, "INTERNAL_TRIGGER_TYPES", {
   enumerable: true,
-  get: function () { return chunkGBQ33SIZ_cjs.INTERNAL_TRIGGER_TYPES; }
+  get: function () { return chunk54FLQNUM_cjs.INTERNAL_TRIGGER_TYPES; }
+});
+Object.defineProperty(exports, "PHASE_C_NODE_TYPES", {
+  enumerable: true,
+  get: function () { return chunk54FLQNUM_cjs.PHASE_C_NODE_TYPES; }
+});
+Object.defineProperty(exports, "SET_SEARCH_ATTRIBUTES_NODE_TYPE", {
+  enumerable: true,
+  get: function () { return chunk54FLQNUM_cjs.SET_SEARCH_ATTRIBUTES_NODE_TYPE; }
+});
+Object.defineProperty(exports, "SIGNAL_RUN_NODE_TYPE", {
+  enumerable: true,
+  get: function () { return chunk54FLQNUM_cjs.SIGNAL_RUN_NODE_TYPE; }
 });
 Object.defineProperty(exports, "WAIT_FOR_SIGNAL_NODE_TYPE", {
   enumerable: true,
-  get: function () { return chunkGBQ33SIZ_cjs.WAIT_FOR_SIGNAL_NODE_TYPE; }
+  get: function () { return chunk54FLQNUM_cjs.WAIT_FOR_SIGNAL_NODE_TYPE; }
 });
 Object.defineProperty(exports, "buildIdOf", {
   enumerable: true,
-  get: function () { return chunkGBQ33SIZ_cjs.buildIdOf; }
+  get: function () { return chunk54FLQNUM_cjs.buildIdOf; }
 });
 Object.defineProperty(exports, "hashedProjection", {
   enumerable: true,
-  get: function () { return chunkGBQ33SIZ_cjs.hashedProjection; }
+  get: function () { return chunk54FLQNUM_cjs.hashedProjection; }
 });
 Object.defineProperty(exports, "irHash", {
   enumerable: true,
-  get: function () { return chunkGBQ33SIZ_cjs.irHash; }
+  get: function () { return chunk54FLQNUM_cjs.irHash; }
 });
 Object.defineProperty(exports, "normalizeDefinition", {
   enumerable: true,
-  get: function () { return chunkGBQ33SIZ_cjs.normalizeDefinition; }
+  get: function () { return chunk54FLQNUM_cjs.normalizeDefinition; }
 });
 Object.defineProperty(exports, "sourceHash", {
   enumerable: true,
-  get: function () { return chunkGBQ33SIZ_cjs.sourceHash; }
+  get: function () { return chunk54FLQNUM_cjs.sourceHash; }
 });
 Object.defineProperty(exports, "usesMergedParameters", {
   enumerable: true,
-  get: function () { return chunkGBQ33SIZ_cjs.usesMergedParameters; }
+  get: function () { return chunk54FLQNUM_cjs.usesMergedParameters; }
 });
 Object.defineProperty(exports, "LAYOUT_COLUMN_WIDTH", {
   enumerable: true,
@@ -1242,10 +1539,16 @@ Object.defineProperty(exports, "durationMs", {
   enumerable: true,
   get: function () { return chunkFR7KYWRO_cjs.durationMs; }
 });
+exports.DEFAULT_NEW_SCHEDULE_OVERLAP_POLICY = DEFAULT_NEW_SCHEDULE_OVERLAP_POLICY;
+exports.DEFAULT_SCHEDULE_CATCHUP_WINDOW_SECONDS = DEFAULT_SCHEDULE_CATCHUP_WINDOW_SECONDS;
 exports.IR_V2_SCHEMA = IR_V2_SCHEMA;
 exports.IR_V2_SCHEMA_ID = IR_V2_SCHEMA_ID;
+exports.SCHEDULE_OVERLAP_POLICIES = SCHEDULE_OVERLAP_POLICIES;
+exports.SCHEDULE_POLICY_FIELDS = SCHEDULE_POLICY_FIELDS;
+exports.SCHEDULE_SPEC_FIELDS = SCHEDULE_SPEC_FIELDS;
 exports.WORKFLOW_DOCUMENT_FORMAT = WORKFLOW_DOCUMENT_FORMAT;
 exports.buildExportDocument = buildExportDocument;
+exports.checkSchedulePolicy = checkSchedulePolicy;
 exports.checkScheduleSpec = checkScheduleSpec;
 exports.deriveInterface = deriveInterface;
 exports.envelopeSchemaVersion = envelopeSchemaVersion;