@cadenza.io/service 2.9.0 → 2.11.0

package/dist/index.js

@@ -30,25 +30,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Actor: () => import_core4.Actor,
+  Actor: () => import_core5.Actor,
   DatabaseTask: () => DatabaseTask,
-  DebounceTask: () => import_core4.DebounceTask,
+  DebounceTask: () => import_core5.DebounceTask,
   DeputyTask: () => DeputyTask,
-  EphemeralTask: () => import_core4.EphemeralTask,
+  EphemeralTask: () => import_core5.EphemeralTask,
   GraphMetadataController: () => GraphMetadataController,
-  GraphRoutine: () => import_core4.GraphRoutine,
+  GraphRoutine: () => import_core5.GraphRoutine,
   RestController: () => RestController,
   ServiceRegistry: () => ServiceRegistry,
   SignalController: () => SignalController,
   SignalTransmissionTask: () => SignalTransmissionTask,
   SocketController: () => SocketController,
-  Task: () => import_core4.Task,
+  Task: () => import_core5.Task,
   default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/Cadenza.ts
-var import_core3 = __toESM(require("@cadenza.io/core"));
+var import_core4 = __toESM(require("@cadenza.io/core"));
 
 // src/graph/definition/DeputyTask.ts
 var import_uuid = require("uuid");
@@ -3346,6 +3346,44 @@ var SocketController = class _SocketController {
     this.diagnosticsMaxClientEntries = 500;
     this.destroyedDiagnosticsTtlMs = 15 * 6e4;
     this.socketServerDefaultKey = "socket-server-default";
+    this.socketServerInitialSessionState = {
+      serverKey: this.socketServerDefaultKey,
+      useSocket: false,
+      status: "inactive",
+      securityProfile: "medium",
+      networkType: "internal",
+      connectionCount: 0,
+      lastStartedAt: null,
+      lastConnectedAt: null,
+      lastDisconnectedAt: null,
+      lastShutdownAt: null,
+      updatedAt: 0
+    };
+    this.socketClientInitialSessionState = {
+      fetchId: "",
+      serviceInstanceId: "",
+      communicationTypes: [],
+      serviceName: "",
+      serviceAddress: "",
+      servicePort: 0,
+      protocol: "http",
+      url: "",
+      socketId: null,
+      connected: false,
+      handshake: false,
+      pendingDelegations: 0,
+      pendingTimers: 0,
+      reconnectAttempts: 0,
+      connectErrors: 0,
+      reconnectErrors: 0,
+      socketErrors: 0,
+      errorCount: 0,
+      destroyed: false,
+      lastHandshakeAt: null,
+      lastHandshakeError: null,
+      lastDisconnectAt: null,
+      updatedAt: 0
+    };
     this.socketServerActor = CadenzaService.createActor(
       {
         name: "SocketServerActor",
@@ -3354,9 +3392,7 @@ var SocketController = class _SocketController {
         keyResolver: (input) => this.resolveSocketServerKey(input),
         loadPolicy: "lazy",
         writeContract: "overwrite",
-        initState: this.createInitialSocketServerSessionState(
-          this.socketServerDefaultKey
-        )
+        initState: this.socketServerInitialSessionState
       },
       { isMeta: true }
     );
@@ -3368,7 +3404,7 @@ var SocketController = class _SocketController {
         keyResolver: (input) => this.resolveSocketClientFetchId(input),
         loadPolicy: "lazy",
         writeContract: "overwrite",
-        initState: this.createInitialSocketClientSessionState()
+        initState: this.socketClientInitialSessionState
       },
       { isMeta: true }
     );
@@ -4449,48 +4485,6 @@ var SocketController = class _SocketController {
       "Connects to a specified socket server and wires runtime tasks."
     ).doOn("meta.fetch.handshake_complete").emitsOnFail("meta.socket_client.connect_failed");
   }
-  createInitialSocketServerSessionState(serverKey) {
-    return {
-      serverKey,
-      useSocket: false,
-      status: "inactive",
-      securityProfile: "medium",
-      networkType: "internal",
-      connectionCount: 0,
-      lastStartedAt: null,
-      lastConnectedAt: null,
-      lastDisconnectedAt: null,
-      lastShutdownAt: null,
-      updatedAt: 0
-    };
-  }
-  createInitialSocketClientSessionState() {
-    return {
-      fetchId: "",
-      serviceInstanceId: "",
-      communicationTypes: [],
-      serviceName: "",
-      serviceAddress: "",
-      servicePort: 0,
-      protocol: "http",
-      url: "",
-      socketId: null,
-      connected: false,
-      handshake: false,
-      pendingDelegations: 0,
-      pendingTimers: 0,
-      reconnectAttempts: 0,
-      connectErrors: 0,
-      reconnectErrors: 0,
-      socketErrors: 0,
-      errorCount: 0,
-      destroyed: false,
-      lastHandshakeAt: null,
-      lastHandshakeError: null,
-      lastDisconnectAt: null,
-      updatedAt: 0
-    };
-  }
   resolveSocketServerKey(input) {
     return String(input.serverKey ?? input.__socketServerKey ?? this.socketServerDefaultKey).trim() || this.socketServerDefaultKey;
   }
@@ -4823,6 +4817,7 @@ var SignalController = class _SignalController {
 };
 
 // src/graph/controllers/GraphMetadataController.ts
+var import_core3 = require("@cadenza.io/core");
 var GraphMetadataController = class _GraphMetadataController {
   static get instance() {
     if (!this._instance) this._instance = new _GraphMetadataController();
@@ -5040,6 +5035,139 @@ var GraphMetadataController = class _GraphMetadataController {
       "Handles task execution relationship creation",
       { concurrency: 100, isSubMeta: true }
     ).doOn("meta.node.mapped", "meta.node.detected_previous_task_execution").emits("global.meta.graph_metadata.relationship_executed");
+    CadenzaService.createMetaTask("Handle actor creation", (ctx) => {
+      return {
+        data: {
+          ...ctx.data,
+          service_name: CadenzaService.serviceRegistry.serviceName
+        }
+      };
+    }).doOn("meta.actor.created").emits("global.meta.graph_metadata.actor_created");
+    CadenzaService.createMetaTask("Handle actor task association", (ctx) => {
+      return {
+        data: {
+          ...ctx.data,
+          service_name: CadenzaService.serviceRegistry.serviceName
+        }
+      };
+    }).doOn("meta.actor.task_associated").emits("global.meta.graph_metadata.actor_task_associated");
+    const actorSessionStateInsertTask = CadenzaService.get("dbInsertActorSessionState") ?? CadenzaService.get("Insert actor_session_state in CadenzaDB") ?? CadenzaService.createCadenzaDBInsertTask(
+      "actor_session_state",
+      {},
+      { concurrency: 100, isSubMeta: true }
+    );
+    const validateActorSessionStatePersistenceTask = CadenzaService.createMetaTask(
+      "Validate actor session state persistence",
+      (ctx) => {
+        if (ctx.errored || ctx.failed || ctx.__success !== true) {
+          throw new Error(
+            String(
+              ctx.__error ?? ctx.error ?? "actor_session_state persistence query failed"
+            )
+          );
+        }
+        const rowCount = Number(ctx.rowCount ?? 0);
+        if (!Number.isFinite(rowCount) || rowCount <= 0) {
+          throw new Error(
+            "actor_session_state persistence did not affect any rows (possible stale durable_version)"
+          );
+        }
+        return {
+          __success: true,
+          persisted: true,
+          actor_name: ctx.actor_name,
+          actor_version: ctx.actor_version,
+          actor_key: ctx.actor_key,
+          service_name: ctx.service_name,
+          durable_version: ctx.durable_version
+        };
+      },
+      "Enforces strict actor session persistence success contract.",
+      { isSubMeta: true, concurrency: 100 }
+    );
+    const insertAndValidateActorSessionStateTask = actorSessionStateInsertTask.then(
+      validateActorSessionStatePersistenceTask
+    );
+    CadenzaService.createMetaTask(
+      "Persist actor session state",
+      (ctx) => {
+        const actorName = typeof ctx.actor_name === "string" ? ctx.actor_name.trim() : "";
+        const actorKey = typeof ctx.actor_key === "string" ? ctx.actor_key.trim() : "";
+        const actorVersion = Number(ctx.actor_version ?? 1);
+        const durableVersion = Number(ctx.durable_version);
+        if (!actorName) {
+          throw new Error("actor_name is required for actor session persistence");
+        }
+        if (!actorKey) {
+          throw new Error("actor_key is required for actor session persistence");
+        }
+        if (!Number.isInteger(actorVersion) || actorVersion < 1) {
+          throw new Error("actor_version must be a positive integer");
+        }
+        if (!Number.isInteger(durableVersion) || durableVersion < 0) {
+          throw new Error("durable_version must be a non-negative integer");
+        }
+        if (typeof ctx.durable_state !== "object" || ctx.durable_state === null || Array.isArray(ctx.durable_state)) {
+          throw new Error("durable_state must be a non-null object");
+        }
+        const serviceName = CadenzaService.serviceRegistry.serviceName;
+        if (!serviceName) {
+          throw new Error("service_name is not available for actor session persistence");
+        }
+        let expiresAt = null;
+        if (ctx.expires_at !== void 0 && ctx.expires_at !== null) {
+          if (ctx.expires_at instanceof Date) {
+            expiresAt = ctx.expires_at.toISOString();
+          } else if (typeof ctx.expires_at === "string" && ctx.expires_at.trim().length > 0) {
+            expiresAt = ctx.expires_at;
+          } else {
+            throw new Error("expires_at must be null, Date, or non-empty string");
+          }
+        }
+        const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        return {
+          ...ctx,
+          actor_name: actorName,
+          actor_key: actorKey,
+          actor_version: actorVersion,
+          durable_version: durableVersion,
+          expires_at: expiresAt,
+          service_name: serviceName,
+          queryData: {
+            data: {
+              actor_name: actorName,
+              actor_version: actorVersion,
+              actor_key: actorKey,
+              service_name: serviceName,
+              durable_state: ctx.durable_state,
+              durable_version: durableVersion,
+              expires_at: expiresAt,
+              updated: updatedAt
+            },
+            onConflict: {
+              target: [
+                "actor_name",
+                "actor_version",
+                "actor_key",
+                "service_name"
+              ],
+              action: {
+                do: "update",
+                set: {
+                  durable_state: "excluded",
+                  durable_version: "excluded",
+                  expires_at: "excluded",
+                  updated: "excluded"
+                },
+                where: "actor_session_state.durable_version <= excluded.durable_version"
+              }
+            }
+          }
+        };
+      },
+      "Validates and prepares actor_session_state payload for strict write-through persistence.",
+      { isSubMeta: true, concurrency: 100 }
+    ).then(insertAndValidateActorSessionStateTask).respondsTo(import_core3.META_ACTOR_SESSION_STATE_PERSIST_INTENT);
     CadenzaService.createMetaTask("Handle Intent Creation", (ctx) => {
       const intentName = ctx.data?.name;
       return {
@@ -6711,8 +6839,69 @@ function tableFieldTypeToSchemaType(type) {
 var import_uuid3 = require("uuid");
 
 // src/graph/controllers/GraphSyncController.ts
+var ACTOR_TASK_METADATA = /* @__PURE__ */ Symbol.for("@cadenza.io/core/actor-task-meta");
+function getActorTaskRuntimeMetadata(taskFunction) {
+  if (typeof taskFunction !== "function") {
+    return void 0;
+  }
+  return taskFunction[ACTOR_TASK_METADATA];
+}
+function sanitizeActorMetadataValue(value) {
+  if (value === null) {
+    return null;
+  }
+  if (value === void 0 || typeof value === "function") {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    const items = [];
+    for (const item of value) {
+      const sanitizedItem = sanitizeActorMetadataValue(item);
+      if (sanitizedItem !== void 0) {
+        items.push(sanitizedItem);
+      }
+    }
+    return items;
+  }
+  if (typeof value === "object") {
+    const output = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+      const sanitizedNestedValue = sanitizeActorMetadataValue(nestedValue);
+      if (sanitizedNestedValue !== void 0) {
+        output[key] = sanitizedNestedValue;
+      }
+    }
+    return output;
+  }
+  return value;
+}
+function buildActorRegistrationData(actor) {
+  const definition = sanitizeActorMetadataValue(
+    typeof actor?.toDefinition === "function" ? actor.toDefinition() : {}
+  );
+  const stateDefinition = definition?.state && typeof definition.state === "object" ? definition.state : {};
+  const actorKind = typeof definition?.kind === "string" ? definition.kind : actor?.kind;
+  return {
+    name: definition?.name ?? actor?.spec?.name ?? "",
+    description: definition?.description ?? actor?.spec?.description ?? "",
+    default_key: definition?.defaultKey ?? actor?.spec?.defaultKey ?? "default",
+    load_policy: definition?.loadPolicy ?? actor?.spec?.loadPolicy ?? "eager",
+    write_contract: definition?.writeContract ?? actor?.spec?.writeContract ?? "overwrite",
+    runtime_read_guard: definition?.runtimeReadGuard ?? actor?.spec?.runtimeReadGuard ?? "none",
+    consistency_profile: definition?.consistencyProfile ?? actor?.spec?.consistencyProfile ?? null,
+    key_definition: definition?.key ?? null,
+    state_definition: stateDefinition,
+    retry_policy: definition?.retry ?? {},
+    idempotency_policy: definition?.idempotency ?? {},
+    session_policy: definition?.session ?? {},
+    is_meta: actorKind === "meta",
+    version: 1
+  };
+}
 var GraphSyncController = class _GraphSyncController {
   constructor() {
+    this.registeredActors = /* @__PURE__ */ new Set();
+    this.registeredActorTaskMaps = /* @__PURE__ */ new Set();
     this.isCadenzaDBReady = false;
   }
   static get instance() {
@@ -6970,6 +7159,120 @@ var GraphSyncController = class _GraphSyncController {
         )
       )
     );
+    this.splitActorsForRegistration = CadenzaService.createMetaTask(
+      "Split actors for registration",
+      function* (ctx) {
+        CadenzaService.debounce("meta.sync_controller.synced_resource", {
+          delayMs: 3e3
+        });
+        const actors = ctx.actors ?? [];
+        for (const actor of actors) {
+          const data = {
+            ...buildActorRegistrationData(actor),
+            service_name: CadenzaService.serviceRegistry.serviceName
+          };
+          if (!data.name) {
+            continue;
+          }
+          const registrationKey = `${data.name}|${data.version}|${data.service_name}`;
+          if (this.registeredActors.has(registrationKey)) {
+            continue;
+          }
+          yield {
+            data,
+            __actorRegistrationKey: registrationKey
+          };
+        }
+      }.bind(this)
+    ).then(
+      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(
+        "actor",
+        {
+          onConflict: {
+            target: ["name", "service_name", "version"],
+            action: {
+              do: "nothing"
+            }
+          }
+        },
+        { concurrency: 30 }
+      ) : CadenzaService.get("dbInsertActor"))?.then(
+        CadenzaService.createMetaTask("Record actor registration", (ctx) => {
+          if (!ctx.__syncing) {
+            return;
+          }
+          CadenzaService.debounce("meta.sync_controller.synced_resource", {
+            delayMs: 3e3
+          });
+          this.registeredActors.add(ctx.__actorRegistrationKey);
+          return true;
+        }).then(
+          CadenzaService.createUniqueMetaTask(
+            "Gather actor registration",
+            () => true
+          ).emits("meta.sync_controller.synced_actors")
+        )
+      )
+    );
+    this.registerActorTaskMapTask = CadenzaService.createMetaTask(
+      "Split actor task maps",
+      function* (ctx) {
+        const task = ctx.task;
+        if (task.hidden || !task.register) {
+          return;
+        }
+        const metadata = getActorTaskRuntimeMetadata(task.taskFunction);
+        if (!metadata?.actorName) {
+          return;
+        }
+        const registrationKey = `${metadata.actorName}|${task.name}|${task.version}|${CadenzaService.serviceRegistry.serviceName}`;
+        if (this.registeredActorTaskMaps.has(registrationKey)) {
+          return;
+        }
+        yield {
+          data: {
+            actor_name: metadata.actorName,
+            actor_version: 1,
+            task_name: task.name,
+            task_version: task.version,
+            service_name: CadenzaService.serviceRegistry.serviceName,
+            mode: metadata.mode,
+            description: task.description ?? metadata.actorDescription ?? "",
+            is_meta: metadata.actorKind === "meta" || task.isMeta === true
+          },
+          __actorTaskMapRegistrationKey: registrationKey
+        };
+      }.bind(this)
+    ).then(
+      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(
+        "actor_task_map",
+        {
+          onConflict: {
+            target: [
+              "actor_name",
+              "actor_version",
+              "task_name",
+              "task_version",
+              "service_name"
+            ],
+            action: {
+              do: "nothing"
+            }
+          }
+        },
+        { concurrency: 30 }
+      ) : CadenzaService.get("dbInsertActorTaskMap"))?.then(
+        CadenzaService.createMetaTask("Record actor task map registration", (ctx) => {
+          if (!ctx.__syncing) {
+            return;
+          }
+          CadenzaService.debounce("meta.sync_controller.synced_resource", {
+            delayMs: 3e3
+          });
+          this.registeredActorTaskMaps.add(ctx.__actorTaskMapRegistrationKey);
+        })
+      )
+    );
     const registerSignalTask = CadenzaService.createMetaTask(
       "Record signal registration",
       (ctx) => {
@@ -7211,12 +7514,19 @@ var GraphSyncController = class _GraphSyncController {
     ).then(this.splitSignalsTask);
     CadenzaService.registry.getAllTasks.clone().doOn("meta.sync_controller.synced_signals").then(this.splitTasksForRegistration);
     CadenzaService.registry.getAllRoutines.clone().doOn("meta.sync_controller.synced_tasks").then(this.splitRoutinesTask);
+    CadenzaService.createMetaTask("Get all actors", (ctx) => {
+      return {
+        ...ctx,
+        actors: CadenzaService.getAllActors()
+      };
+    }).doOn("meta.sync_controller.synced_tasks").then(this.splitActorsForRegistration);
     CadenzaService.registry.doForEachTask.clone().doOn("meta.sync_controller.synced_tasks").then(
       this.registerTaskMapTask,
       this.registerSignalToTaskMapTask,
       this.registerIntentToTaskMapTask,
       this.registerDeputyRelationshipTask
     );
+    CadenzaService.registry.doForEachTask.clone().doOn("meta.sync_controller.synced_tasks", "meta.sync_controller.synced_actors").then(this.registerActorTaskMapTask);
     CadenzaService.registry.getAllRoutines.clone().doOn("meta.sync_controller.synced_routines").then(this.splitTasksInRoutines);
     CadenzaService.createMetaTask("Finish sync", (ctx, emit) => {
       emit("global.meta.sync_controller.synced", {
@@ -7261,12 +7571,12 @@ var CadenzaService = class {
   static bootstrap() {
     if (this.isBootstrapped) return;
     this.isBootstrapped = true;
-    import_core3.default.bootstrap();
-    this.signalBroker = import_core3.default.signalBroker;
-    this.inquiryBroker = import_core3.default.inquiryBroker;
-    this.runner = import_core3.default.runner;
-    this.metaRunner = import_core3.default.metaRunner;
-    this.registry = import_core3.default.registry;
+    import_core4.default.bootstrap();
+    this.signalBroker = import_core4.default.signalBroker;
+    this.inquiryBroker = import_core4.default.inquiryBroker;
+    this.runner = import_core4.default.runner;
+    this.metaRunner = import_core4.default.metaRunner;
+    this.registry = import_core4.default.registry;
     this.serviceRegistry = ServiceRegistry.instance;
     SignalController.instance;
     RestController.instance;
@@ -7309,7 +7619,7 @@ var CadenzaService = class {
    * @return {void} Does not return any value.
    */
   static validateName(name) {
-    import_core3.default.validateName(name);
+    import_core4.default.validateName(name);
   }
   /**
    * Gets the current run strategy from the Cadenza configuration.
@@ -7317,7 +7627,7 @@ var CadenzaService = class {
    * @return {Function} The run strategy function defined in the Cadenza configuration.
    */
   static get runStrategy() {
-    return import_core3.default.runStrategy;
+    return import_core4.default.runStrategy;
   }
   /**
    * Sets the mode for the Cadenza application.
@@ -7326,7 +7636,7 @@ var CadenzaService = class {
    * @return {void} This method does not return a value.
    */
   static setMode(mode) {
-    import_core3.default.setMode(mode);
+    import_core4.default.setMode(mode);
   }
   /**
    * Emits a signal with the specified data using the associated broker.
@@ -7344,16 +7654,16 @@ var CadenzaService = class {
    * ```
    */
   static emit(signal, data = {}, options = {}) {
-    import_core3.default.emit(signal, data, options);
+    import_core4.default.emit(signal, data, options);
   }
   static debounce(signal, context = {}, delayMs = 500) {
-    import_core3.default.debounce(signal, context, delayMs);
+    import_core4.default.debounce(signal, context, delayMs);
   }
   static schedule(signal, context, timeoutMs, exactDateTime) {
-    import_core3.default.schedule(signal, context, timeoutMs, exactDateTime);
+    import_core4.default.schedule(signal, context, timeoutMs, exactDateTime);
   }
   static interval(signal, context, intervalMs, leading = false, startDateTime) {
-    import_core3.default.interval(signal, context, intervalMs, leading, startDateTime);
+    import_core4.default.interval(signal, context, intervalMs, leading, startDateTime);
   }
   static defineIntent(intent) {
     this.inquiryBroker?.addIntent(intent);
@@ -7601,10 +7911,18 @@ var CadenzaService = class {
     });
   }
   static get(taskName) {
-    return import_core3.default.get(taskName);
+    return import_core4.default.get(taskName);
+  }
+  static getActor(actorName) {
+    const cadenzaWithActors = import_core4.default;
+    return cadenzaWithActors.getActor?.(actorName);
+  }
+  static getAllActors() {
+    const cadenzaWithActors = import_core4.default;
+    return cadenzaWithActors.getAllActors?.() ?? [];
   }
   static getRoutine(routineName) {
-    return import_core3.default.getRoutine(routineName);
+    return import_core4.default.getRoutine(routineName);
   }
   /**
    * Creates a new DeputyTask instance based on the provided routine name, service name, and options.
@@ -8170,11 +8488,11 @@ var CadenzaService = class {
   }
   static createActor(spec, options = {}) {
     this.bootstrap();
-    return new import_core3.Actor(spec, options);
+    return import_core4.default.createActor(spec, options);
   }
   static createActorFromDefinition(definition, options = {}) {
     this.bootstrap();
-    return import_core3.default.createActorFromDefinition(definition, options);
+    return import_core4.default.createActorFromDefinition(definition, options);
   }
   /**
    * Creates and registers a new task with the provided name, function, and optional details.
@@ -8248,7 +8566,7 @@ var CadenzaService = class {
    */
   static createTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core3.default.createTask(name, func, description, options);
+    return import_core4.default.createTask(name, func, description, options);
   }
   /**
    * Creates a meta task with the specified name, functionality, description, and options.
@@ -8264,7 +8582,7 @@ var CadenzaService = class {
    */
   static createMetaTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core3.default.createMetaTask(name, func, description, options);
+    return import_core4.default.createMetaTask(name, func, description, options);
   }
   /**
    * Creates a unique task by wrapping the provided task function with a uniqueness constraint.
@@ -8314,7 +8632,7 @@ var CadenzaService = class {
    */
   static createUniqueTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core3.default.createUniqueTask(name, func, description, options);
+    return import_core4.default.createUniqueTask(name, func, description, options);
   }
   /**
    * Creates a unique meta task with the specified name, function, description, and options.
@@ -8328,7 +8646,7 @@ var CadenzaService = class {
    */
   static createUniqueMetaTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core3.default.createUniqueMetaTask(name, func, description, options);
+    return import_core4.default.createUniqueMetaTask(name, func, description, options);
   }
   /**
    * Creates a throttled task with a concurrency limit of 1, ensuring that only one instance of the task can run at a time for a specific throttle tag.
@@ -8361,7 +8679,7 @@ var CadenzaService = class {
    */
   static createThrottledTask(name, func, throttledIdGetter = () => "default", description, options = {}) {
     this.bootstrap();
-    return import_core3.default.createThrottledTask(
+    return import_core4.default.createThrottledTask(
       name,
       func,
       throttledIdGetter,
@@ -8382,7 +8700,7 @@ var CadenzaService = class {
    */
   static createThrottledMetaTask(name, func, throttledIdGetter = () => "default", description, options = {}) {
     this.bootstrap();
-    return import_core3.default.createThrottledMetaTask(
+    return import_core4.default.createThrottledMetaTask(
       name,
       func,
       throttledIdGetter,
@@ -8425,7 +8743,7 @@ var CadenzaService = class {
    */
   static createDebounceTask(name, func, description, debounceTime = 1e3, options = {}) {
     this.bootstrap();
-    return import_core3.default.createDebounceTask(
+    return import_core4.default.createDebounceTask(
       name,
       func,
       description,
@@ -8446,7 +8764,7 @@ var CadenzaService = class {
    */
   static createDebounceMetaTask(name, func, description, debounceTime = 1e3, options = {}) {
     this.bootstrap();
-    return import_core3.default.createDebounceMetaTask(
+    return import_core4.default.createDebounceMetaTask(
       name,
       func,
       description,
@@ -8516,7 +8834,7 @@ var CadenzaService = class {
    */
   static createEphemeralTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core3.default.createEphemeralTask(name, func, description, options);
+    return import_core4.default.createEphemeralTask(name, func, description, options);
   }
   /**
    * Creates an ephemeral meta task with the specified name, function, description, and options.
@@ -8530,7 +8848,7 @@ var CadenzaService = class {
    */
   static createEphemeralMetaTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core3.default.createEphemeralMetaTask(name, func, description, options);
+    return import_core4.default.createEphemeralMetaTask(name, func, description, options);
   }
   /**
    * Creates a new routine with the specified name, tasks, and an optional description.
@@ -8562,7 +8880,7 @@ var CadenzaService = class {
    */
   static createRoutine(name, tasks, description = "") {
     this.bootstrap();
-    return import_core3.default.createRoutine(name, tasks, description);
+    return import_core4.default.createRoutine(name, tasks, description);
   }
   /**
    * Creates a meta routine with a given name, tasks, and optional description.
@@ -8577,10 +8895,10 @@ var CadenzaService = class {
    */
   static createMetaRoutine(name, tasks, description = "") {
     this.bootstrap();
-    return import_core3.default.createMetaRoutine(name, tasks, description);
+    return import_core4.default.createMetaRoutine(name, tasks, description);
   }
   static reset() {
-    import_core3.default.reset();
+    import_core4.default.reset();
     this.serviceRegistry.reset();
   }
 };
@@ -8589,7 +8907,7 @@ CadenzaService.serviceCreated = false;
 CadenzaService.warnedInvalidMetaIntentResponderKeys = /* @__PURE__ */ new Set();
 
 // src/index.ts
-var import_core4 = require("@cadenza.io/core");
+var import_core5 = require("@cadenza.io/core");
 var index_default = CadenzaService;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {