@cadenza.io/service 1.0.0

package/dist/index.js

@@ -0,0 +1,2391 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DatabaseTask: () => DatabaseTask,
+  DeputyTask: () => DeputyTask,
+  RestController: () => RestController,
+  ServiceRegistry: () => ServiceRegistry,
+  SignalController: () => SignalController,
+  SignalTransmissionTask: () => SignalTransmissionTask,
+  SocketController: () => SocketController,
+  TaskController: () => TaskController,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/Cadenza.ts
+var import_core3 = __toESM(require("@cadenza.io/core"));
+
+// src/graph/definition/DeputyTask.ts
+var import_uuid = require("uuid");
+var import_core = require("@cadenza.io/core");
+var DeputyTask = class extends import_core.Task {
+  /**
+   * Constructs a DeputyTask as a proxy for triggering a remote flow.
+   * @param name - The local name of the DeputyTask.
+   * @param remoteRoutineName - The name of the remote routine or task to trigger.
+   * @param serviceName - The target service name (optional, defaults to local service if undefined).
+   * @param description - A description of the task's purpose (default: '').
+   * @param concurrency - The maximum number of concurrent executions (default: 0, unlimited).
+   * @param timeout - Timeout in milliseconds (default: 0, handled by engine).
+   * @param register - Whether to register the task in the registry (default: true).
+   * @param isUnique - Whether to create a unique task (default: false). A unique task will only be executed once per execution ID, merging parents.
+   * @param isMeta - Whether to create a meta task (default: false). A meta task is separate from the user logic and is only used for monitoring, optimization, and feature extensions.
+   * @param isSubMeta
+   * @param isHidden
+   * @param getTagCallback - Callback for dynamic tagging, e.g., 'return "default"'.
+   * @param inputSchema - Input schema definition.
+   * @param validateInputContext - Whether to validate the input context (default: false).
+   * @param outputSchema - Output schema definition.
+   * @param validateOutputContext - Whether to validate the output context (default: false).
+   * @param retryCount
+   * @param retryDelay
+   * @param retryDelayMax
+   * @param retryDelayFactor
+   * @emits {meta.deputy.delegation_requested} - Emitted on construction with task and service details.
+   * @note Fallbacks should be handled externally via `.doOnFail`; timeouts are managed by the engine.
+   */
+  constructor(name, remoteRoutineName, serviceName = void 0, description = "", concurrency = 0, timeout = 0, register = true, isUnique = false, isMeta = false, isSubMeta = false, isHidden = false, getTagCallback = void 0, inputSchema = void 0, validateInputContext = false, outputSchema = void 0, validateOutputContext = false, retryCount = 0, retryDelay = 0, retryDelayMax = 0, retryDelayFactor = 1) {
+    const taskFunction = (context, emit, progressCallback) => {
+      return new Promise((resolve, reject) => {
+        const processId = (0, import_uuid.v4)();
+        context.__deputyExecId = processId;
+        emit("meta.deputy.delegation_requested", __spreadValues({}, context));
+        CadenzaService.createEphemeralMetaTask(
+          `Resolve deputy ${this.remoteRoutineName}`,
+          (responseCtx) => {
+            if (responseCtx.errored) {
+              reject(new Error(responseCtx.__error));
+            } else {
+              resolve(responseCtx);
+            }
+          },
+          `Ephemeral resolver for deputy process ${processId}`
+        ).doOn(
+          `meta.socket_client.delegated:${processId}`,
+          `meta.fetch.delegated:${processId}`,
+          `meta.service_registry.load_balance_failed:${processId}`
+        );
+        CadenzaService.createEphemeralMetaTask(
+          `On progress deputy ${this.remoteRoutineName}`,
+          (ctx) => {
+            if (ctx.progress) progressCallback(ctx.progress * ctx.weight);
+          },
+          `Ephemeral task for deputy process ${processId}`,
+          {
+            once: false,
+            destroyCondition: (ctx) => ctx.progress === 1 || ctx.progress === void 0
+          }
+        ).doOn(`meta.socket_client.delegation_progress:${processId}`);
+      });
+    };
+    super(
+      name,
+      taskFunction,
+      description,
+      concurrency,
+      timeout,
+      register,
+      isUnique,
+      isMeta,
+      isSubMeta,
+      isHidden,
+      getTagCallback,
+      inputSchema,
+      validateInputContext,
+      outputSchema,
+      validateOutputContext,
+      retryCount,
+      retryDelay,
+      retryDelayMax,
+      retryDelayFactor
+    );
+    this.isDeputy = true;
+    this.remoteRoutineName = remoteRoutineName;
+    this.serviceName = serviceName;
+    this.emit("meta.deputy.created", {
+      __localTaskName: this.name,
+      __remoteRoutineName: this.remoteRoutineName,
+      __serviceName: this.serviceName
+    });
+  }
+  /**
+   * Triggers the delegation flow via a signal to the meta-layer.
+   * @param context - The GraphContext containing execution data.
+   * @param emit
+   * @param progressCallback - Callback to update progress (invoked by meta-layer).
+   * @returns A Promise resolving with the task result or rejecting on error.
+   * @emits {meta.deputy.executed} - Emitted with context to initiate delegation.
+   * @edge Engine handles timeout and error, triggering `.doOnFail` if chained.
+   * @note The resolution and progress are managed by ephemeral meta-tasks.
+   */
+  execute(context, emit, progressCallback) {
+    var _a;
+    const ctx = context.getContext();
+    const metaData = context.getMetaData();
+    const deputyContext = __spreadValues({
+      __localTaskName: this.name,
+      __remoteRoutineName: this.remoteRoutineName,
+      __serviceName: this.serviceName,
+      __contractId: (_a = metaData.__contractId) != null ? _a : null,
+      __metaData: __spreadProps(__spreadValues({}, metaData), {
+        __deputyTaskId: this.id
+      })
+    }, ctx);
+    return this.taskFunction(deputyContext, emit, progressCallback);
+  }
+};
+
+// src/graph/definition/DatabaseTask.ts
+var DatabaseTask = class extends DeputyTask {
+  /**
+   * Constructs a DatabaseTask to execute a database operation on a remote service.
+   * @param name - The local name of the DatabaseTask.
+   * @param taskName - The name of the database operation task to trigger (e.g., 'dbQueryTaskExecution').
+   * @param serviceName - The target database service name (optional, defaults to 'DatabaseService').
+   * @param description - A description of the task's purpose (default: '').
+   * @param queryData - The query data object containing operation details (e.g., { __operation: 'query', __table: 'users' }).
+   * @param concurrency - The maximum number of concurrent executions (default: 0, unlimited).
+   * @param timeout - Timeout in milliseconds (default: 0, handled by engine).
+   * @param register - Whether to register the task in the registry (default: true).
+   * @param isUnique
+   * @param isMeta
+   * @param isSubMeta
+   * @param isHidden
+   * @param getTagCallback - Callback for dynamic tagging, e.g., 'return "default"'.
+   * @param inputSchema - Input schema definition.
+   * @param validateInputContext - Whether to validate the input context (default: false).
+   * @param outputSchema - Output schema definition.
+   * @param validateOutputContext - Whether to validate the output context (default: false).
+   * @param retryCount
+   * @param retryDelay
+   * @param retryDelayMax
+   * @param retryDelayFactor
+   * @emits {meta.deputy.created} - Emitted on construction with task and service details.
+   * @note Fallbacks via `.doOnFail` externally; timeouts managed by the engine.
+   */
+  constructor(name, taskName, serviceName = void 0, description = "", queryData, concurrency = 0, timeout = 0, register = true, isUnique = false, isMeta = false, isSubMeta = false, isHidden = false, getTagCallback = void 0, inputSchema = void 0, validateInputContext = false, outputSchema = void 0, validateOutputContext = false, retryCount = 0, retryDelay = 0, retryDelayMax = 0, retryDelayFactor = 1) {
+    super(
+      name,
+      taskName,
+      serviceName,
+      description,
+      concurrency,
+      timeout,
+      register,
+      isUnique,
+      isMeta,
+      isSubMeta,
+      isHidden,
+      getTagCallback,
+      inputSchema,
+      validateInputContext,
+      outputSchema,
+      validateOutputContext,
+      retryCount,
+      retryDelay,
+      retryDelayMax,
+      retryDelayFactor
+    );
+    this.queryData = queryData;
+  }
+  /**
+   * Triggers the database operation delegation flow via a signal to the meta-layer.
+   * @param context - The GraphContext containing execution data.
+   * @param emit
+   * @param progressCallback - Callback to update progress (invoked by meta-layer).
+   * @returns A Promise resolving with the task result or rejecting on error.
+   * @emits {meta.deputy.executed} - Emitted with context including queryData to initiate delegation.
+   * @edge Engine handles timeout and error, triggering `.doOnFail` if chained.
+   * @note The resolution and progress are managed by ephemeral meta-tasks.
+   */
+  execute(context, emit, progressCallback) {
+    var _a;
+    const ctx = context.getContext();
+    const metaData = context.getMetaData();
+    const dynamicQueryData = ctx.queryData;
+    delete ctx.queryData;
+    const deputyContext = {
+      __localTaskName: this.name,
+      __remoteRoutineName: this.remoteRoutineName,
+      __serviceName: this.serviceName,
+      __contractId: (_a = metaData.__contractId) != null ? _a : null,
+      __metaData: __spreadProps(__spreadValues({}, metaData), {
+        __deputyTaskId: this.id
+      }),
+      queryData: __spreadValues(__spreadProps(__spreadValues({}, this.queryData), {
+        data: __spreadValues({}, ctx)
+      }), dynamicQueryData)
+    };
+    return this.taskFunction(deputyContext, emit, progressCallback);
+  }
+};
+
+// src/registry/ServiceRegistry.ts
+var ServiceRegistry = class _ServiceRegistry {
+  constructor() {
+    this.instances = /* @__PURE__ */ new Map();
+    this.deputies = /* @__PURE__ */ new Map();
+    this.serviceName = null;
+    this.serviceInstanceId = null;
+    this.useSocket = false;
+    this.retryCount = 3;
+    this.handleInstanceUpdateTask = CadenzaService.createMetaTask(
+      "Handle Instance Update",
+      (ctx, emit) => {
+        const { serviceInstance } = ctx;
+        const { id, serviceName, address, port, exposed } = serviceInstance;
+        if (!this.instances.has(serviceName))
+          this.instances.set(serviceName, []);
+        const instances = this.instances.get(serviceName);
+        const existing = instances.find((i) => i.id === id);
+        if (existing) {
+          Object.assign(existing, serviceInstance);
+        } else {
+          if (this.deputies.has(serviceName)) {
+            emit("meta.service_registry.dependee_registered", {
+              __serviceName: serviceName,
+              __serviceInstanceId: id,
+              __serviceAddress: address,
+              __servicePort: port,
+              __protocol: exposed ? "https" : "http"
+            });
+          }
+          instances.push(serviceInstance);
+        }
+        return true;
+      },
+      "Handles instance update from DB signal"
+    ).emitsAfter("meta.service_registry.service_discovered").doOn(
+      "meta.initializing_service",
+      "CadenzaDB.meta.service_instance.inserted",
+      "CadenzaDB.meta.service_instance.updated"
+    );
+    this.handleSocketStatusUpdateTask = CadenzaService.createMetaTask(
+      "Handle Socket Status Update",
+      (ctx) => {
+        const instanceId = ctx.__serviceInstanceId;
+        const serviceName = ctx.__serviceName;
+        const instances = this.instances.get(serviceName);
+        const instance = instances == null ? void 0 : instances.find((i) => i.id === instanceId);
+        if (instance) {
+          instance.health = ctx.health;
+          instance.numberOfRunningGraphs = ctx.numberOfRunningGraphs;
+        }
+        return true;
+      },
+      "Handles status update from socket broadcast"
+    ).doOn("meta.socket_client.status_received");
+    this.fullSyncTask = CadenzaService.createCadenzaDBQueryTask("service_instance", {
+      filter: {
+        deleted: false,
+        is_active: true,
+        is_non_responsive: false,
+        is_blocked: false
+      },
+      fields: [
+        "id",
+        "address",
+        "port",
+        "service_name",
+        "is_active",
+        "is_non_responsive",
+        "is_blocked",
+        "health",
+        "exposed"
+      ]
+    }).doOn(
+      "meta.service_registry_sync_requested",
+      "meta.service_registry.instance_inserted"
+    ).then(
+      CadenzaService.createMetaTask("Split service instances", function* (ctx) {
+        const { __serviceInstances } = ctx;
+        for (const serviceInstance of __serviceInstances) {
+          yield serviceInstance;
+        }
+      }).then(this.handleInstanceUpdateTask)
+    );
+    this.updateInstanceId = CadenzaService.createMetaTask(
+      "Update instance id",
+      (context) => {
+        const { __id, __oldId } = context;
+        const instance = this.instances.get(__oldId);
+        if (!instance) return context;
+        this.instances.set(__id, instance);
+        this.instances.delete(__oldId);
+        return context;
+      },
+      "Updates instance id."
+    ).doOn("meta.service.global_id_set");
+    this.getInstanceById = CadenzaService.createMetaTask(
+      "Get instance by id",
+      (context) => {
+        const { __id } = context;
+        let instance;
+        for (const instances of this.instances.values()) {
+          instance = instances.find((i) => i.id === __id);
+          if (instance) break;
+        }
+        return __spreadProps(__spreadValues({}, context), { __instance: instance });
+      },
+      "Gets instance by id."
+    );
+    this.getInstancesByServiceName = CadenzaService.createMetaTask(
+      "Get instances by name",
+      (context) => {
+        const { __serviceName } = context;
+        const instances = this.instances.get(__serviceName);
+        if (!instances) {
+          return false;
+        }
+        return __spreadProps(__spreadValues({}, context), { __instances: instances });
+      },
+      "Gets instances by name."
+    );
+    this.handleDeputyRegistrationTask = CadenzaService.createMetaTask(
+      "Handle Deputy Registration",
+      (ctx, emit) => {
+        const { __serviceName } = ctx;
+        this.deputies.set(__serviceName, {
+          __serviceName,
+          __remoteRoutineName: ctx.__remoteRoutineName,
+          __localTaskName: ctx.__localTaskName
+        });
+        for (const instance of this.instances.get(__serviceName)) {
+          emit(`meta.service_registry.dependee_registered:${instance.id}`, {
+            __serviceName,
+            __serviceInstanceId: instance.id,
+            __serviceAddress: instance.address,
+            __servicePort: instance.port,
+            __protocol: instance.exposed ? "https" : "http"
+          });
+        }
+      }
+    ).doOn("meta.deputy.created");
+    this.getAllInstances = CadenzaService.createMetaTask(
+      "Get all instances",
+      (context) => __spreadProps(__spreadValues({}, context), {
+        __instances: Array.from(this.instances.values()).flat()
+      }),
+      "Gets all instances."
+    );
+    this.doForEachInstance = CadenzaService.createMetaTask(
+      "Do for each instance",
+      function* (context) {
+        for (const instances of this.instances.values()) {
+          for (const instance of instances) {
+            yield __spreadProps(__spreadValues({}, context), { __instance: instance });
+          }
+        }
+      }.bind(this),
+      "Yields each instance for branching."
+    );
+    this.deleteInstance = CadenzaService.createMetaTask(
+      "Delete instance",
+      (context) => {
+        const { __id } = context;
+        this.instances.delete(__id);
+        return context;
+      },
+      "Deletes instance."
+    ).doOn("CadenzaDB.meta.service_instance.deleted");
+    this.getBalancedInstance = CadenzaService.createMetaTask(
+      "Get balanced instance",
+      (context, emit) => {
+        var _a;
+        const { __serviceName, __triedInstances, __retries } = context;
+        let retries = __retries != null ? __retries : 0;
+        let triedInstances = __triedInstances != null ? __triedInstances : [];
+        const instances = (_a = this.instances.get(__serviceName)) == null ? void 0 : _a.filter((i) => i.isActive && !i.isNonResponsive && !i.isBlocked).sort((a, b) => a.numberOfRunningGraphs - b.numberOfRunningGraphs);
+        if (!instances || instances.length === 0 || retries > this.retryCount) {
+          context.errored = true;
+          context.__error = "No active instances";
+          emit(
+            `meta.service_registry.load_balance_failed:${context.__deputyExecId}`,
+            context
+          );
+          return context;
+        }
+        let instancesToTry = instances.filter(
+          (i) => !(__triedInstances == null ? void 0 : __triedInstances.includes(i.id))
+        );
+        if (instancesToTry.length === 0) {
+          if (this.useSocket) {
+            emit(
+              `meta.service_registry.socket_failed:${context.__instance}`,
+              context
+            );
+          }
+          retries++;
+          instancesToTry = instances;
+          triedInstances = [];
+        }
+        let selected = instancesToTry[0];
+        if (retries > 0) {
+          selected = instancesToTry[Math.floor(Math.random() * instancesToTry.length)];
+        }
+        context.__instance = selected.id;
+        context.__triedInstances = triedInstances;
+        context.__triedInstances.push(selected.id);
+        context.__retries = retries;
+        if (this.useSocket) {
+          emit(
+            `meta.service_registry.selected_instance_for_socket:${context.__instance}`,
+            context
+          );
+        } else {
+          emit(
+            `meta.service_registry.selected_instance_for_fetch:${context.__instance}`,
+            context
+          );
+        }
+        return context;
+      },
+      "Gets a balanced instance for load balancing"
+    ).doOn(
+      "meta.deputy.delegation_requested",
+      "meta.signal_transmission.requested",
+      "meta.socket_client.delegate_failed",
+      "meta.fetch.delegate_failed",
+      "meta.socket_client.signal_transmission_failed"
+    );
+    this.getStatusTask = CadenzaService.createMetaTask("Get status", (ctx) => {
+      var _a, _b, _c, _d;
+      if (!this.serviceName) {
+        return {
+          __status: "error",
+          __error: "No service name defined",
+          errored: true
+        };
+      }
+      if (!this.serviceInstanceId) {
+        return {
+          __status: "error",
+          __error: "No service instance id defined",
+          errored: true
+        };
+      }
+      const self = (_a = this.instances.get(this.serviceName)) == null ? void 0 : _a.find((i) => i.id === this.serviceInstanceId);
+      return __spreadProps(__spreadValues({}, ctx), {
+        __status: "ok",
+        __numberOfRunningGraphs: (_b = self == null ? void 0 : self.numberOfRunningGraphs) != null ? _b : 0,
+        __health: (_c = self == null ? void 0 : self.health) != null ? _c : {},
+        __active: (_d = self == null ? void 0 : self.isActive) != null ? _d : false
+      });
+    }).doOn("meta.socket.status_check_requested");
+    this.insertServiceTask = CadenzaService.createCadenzaDBInsertTask(
+      "service",
+      {},
+      {
+        // validateInputContext: true,
+        inputSchema: {
+          type: "object",
+          properties: {
+            data: {
+              type: "object",
+              properties: {
+                name: {
+                  type: "string"
+                },
+                description: {
+                  type: "string"
+                },
+                display_name: {
+                  type: "string"
+                },
+                is_meta: {
+                  type: "boolean"
+                }
+              },
+              required: ["name"]
+            }
+          },
+          required: ["data"]
+        },
+        outputSchema: {
+          type: "object",
+          properties: {
+            __serviceName: {
+              type: "string"
+            }
+          },
+          required: ["__serviceName"]
+        },
+        retryCount: 100,
+        retryDelay: 1e4,
+        retryDelayMax: 6e4,
+        retryDelayFactor: 1.3
+      }
+    ).doOn("meta.create_service_requested").then(
+      CadenzaService.createMetaTask(
+        "Set service name",
+        ({ __serviceName }) => {
+          this.serviceName = __serviceName;
+          return true;
+        },
+        "Sets service name after insertion"
+      )
+    ).emitsAfter("meta.service_registry.service_inserted").emitsOnFail("meta.service_registry.service_insertion_failed");
+    this.insertServiceInstanceTask = CadenzaService.createCadenzaDBInsertTask(
+      "serviceInstance",
+      {},
+      {
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string"
+            },
+            address: {
+              type: "string"
+            },
+            port: {
+              type: "number"
+            },
+            process_pid: {
+              type: "number"
+            },
+            is_primary: {
+              type: "boolean"
+            },
+            service_name: {
+              type: "string"
+            },
+            is_active: {
+              type: "boolean"
+            },
+            is_non_responsive: {
+              type: "boolean"
+            },
+            is_blocked: {
+              type: "boolean"
+            },
+            exposed: {
+              type: "boolean"
+            }
+          },
+          required: [
+            "id",
+            "address",
+            "port",
+            "process_pid",
+            "service_name",
+            "exposed"
+          ]
+        },
+        validateInputContext: true,
+        outputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string"
+            }
+          },
+          required: ["id"]
+        },
+        validateOutputContext: true,
+        retryCount: 5,
+        retryDelay: 1e3
+      }
+    ).doOn("meta.rest.network_configured").then(
+      CadenzaService.createMetaTask(
+        "Setup service",
+        (ctx) => {
+          const { serviceInstance, __useSocket, __retryCount } = ctx;
+          this.serviceInstanceId = serviceInstance.id;
+          this.instances.set(serviceInstance.serviceName, [
+            __spreadValues({}, serviceInstance)
+          ]);
+          this.useSocket = __useSocket;
+          this.retryCount = __retryCount;
+          return true;
+        },
+        "Sets service instance id after insertion"
+      ).emitsAfter(
+        "meta.service_registry.instance_inserted",
+        "meta.process_signal_queue_requested"
+      )
+    );
+  }
+  static get instance() {
+    if (!this._instance) this._instance = new _ServiceRegistry();
+    return this._instance;
+  }
+  reset() {
+    this.instances.clear();
+  }
+};
+
+// src/graph/definition/SignalTransmissionTask.ts
+var import_core2 = require("@cadenza.io/core");
+var import_uuid2 = require("uuid");
+var SignalTransmissionTask = class extends import_core2.Task {
+  /**
+   * Constructs a DatabaseTask to execute a database operation on a remote service.
+   * @param name - The local name of the Task.
+   * @param signalName - The name of the signal to transmit to the service.
+   * @param serviceName - The target database service name (optional, defaults to 'DatabaseService').
+   * @param description - A description of the task's purpose (default: '').
+   * @param concurrency - The maximum number of concurrent executions (default: 0, unlimited).
+   * @param timeout - Timeout in milliseconds (default: 0, handled by engine).
+   * @param register - Whether to register the task in the registry (default: true).
+   * @param isUnique
+   * @param isMeta
+   * @param isSubMeta
+   * @param isHidden
+   * @param getTagCallback - Callback for dynamic tagging, e.g., 'return "default"'.
+   * @param inputSchema - Input schema definition.
+   * @param validateInputContext - Whether to validate the input context (default: false).
+   * @param outputSchema - Output schema definition.
+   * @param validateOutputContext - Whether to validate the output context (default: false).
+   * @param retryCount
+   * @param retryDelay
+   * @param retryDelayMax
+   * @param retryDelayFactor
+   * @emits {meta.deputy.created} - Emitted on construction with task and service details.
+   * @note Fallbacks via `.doOnFail` externally; timeouts managed by the engine.
+   */
+  constructor(name, signalName, serviceName, description = "", concurrency = 0, timeout = 0, register = true, isUnique = false, isMeta = false, isSubMeta = false, isHidden = false, getTagCallback = void 0, inputSchema = void 0, validateInputContext = false, outputSchema = void 0, validateOutputContext = false, retryCount = 0, retryDelay = 0, retryDelayMax = 0, retryDelayFactor = 1) {
+    const taskFunction = (context, emit) => {
+      return new Promise((resolve, reject) => {
+        const processId = (0, import_uuid2.v4)();
+        context.__routineExecId = processId;
+        emit("meta.signal_transmission.requested", context);
+        CadenzaService.createEphemeralMetaTask(
+          `Resolve signal transmission for ${this.signalName}`,
+          (responseCtx) => {
+            if (responseCtx.errored) {
+              reject(new Error(responseCtx.__error));
+            } else {
+              resolve(responseCtx);
+            }
+          },
+          `Ephemeral resolver for signal transmission ${processId}`
+        ).doOn(
+          `meta.socket_client.transmitted:${processId}`,
+          `meta.fetch.transmitted:${processId}`
+        );
+      });
+    };
+    super(
+      name,
+      taskFunction,
+      description,
+      concurrency,
+      timeout,
+      register,
+      isUnique,
+      isMeta,
+      isSubMeta,
+      isHidden,
+      getTagCallback,
+      inputSchema,
+      validateInputContext,
+      outputSchema,
+      validateOutputContext,
+      retryCount,
+      retryDelay,
+      retryDelayMax,
+      retryDelayFactor
+    );
+    this.isDeputy = true;
+    this.serviceName = serviceName;
+    this.signalName = signalName;
+  }
+  /**
+   * Triggers the database operation delegation flow via a signal to the meta-layer.
+   * @param context - The GraphContext containing execution data.
+   * @param emit
+   * @param progressCallback - Callback to update progress (invoked by meta-layer).
+   * @returns A Promise resolving with the task result or rejecting on error.
+   * @emits {meta.deputy.executed} - Emitted with context including queryData to initiate delegation.
+   * @edge Engine handles timeout and error, triggering `.doOnFail` if chained.
+   * @note The resolution and progress are managed by ephemeral meta-tasks.
+   */
+  execute(context, emit, progressCallback) {
+    var _a;
+    const ctx = context.getContext();
+    const metaData = context.getMetaData();
+    const deputyContext = __spreadValues({
+      __localTaskName: this.name,
+      __serviceName: this.serviceName,
+      __contractId: (_a = metaData.__contractId) != null ? _a : null,
+      __metaData: __spreadProps(__spreadValues({}, metaData), {
+        __deputyTaskId: this.id
+      }),
+      __signalName: this.signalName
+    }, ctx);
+    return this.taskFunction(deputyContext, emit, progressCallback);
+  }
+};
+
+// src/network/RestController.ts
+var import_express = __toESM(require("express"));
+var import_body_parser = __toESM(require("body-parser"));
+var import_helmet = __toESM(require("helmet"));
+var import_cors = __toESM(require("cors"));
+var import_rate_limiter_flexible = require("rate-limiter-flexible");
+var import_uuid3 = require("uuid");
+var import_node_http = __toESM(require("http"));
+var import_node_fs = __toESM(require("fs"));
+var import_node_https = __toESM(require("https"));
+var import_node_fetch = __toESM(require("node-fetch"));
+var RestController = class _RestController {
+  static get instance() {
+    if (!this._instance) this._instance = new _RestController();
+    return this._instance;
+  }
+  constructor() {
+    CadenzaService.createMetaRoutine(
+      "RestServer",
+      [
+        CadenzaService.createMetaTask(
+          "Setup Express app security",
+          (ctx) => {
+            var _a, _b;
+            const app = (0, import_express.default)();
+            app.use(import_body_parser.default.json());
+            switch (ctx.__securityProfile) {
+              case "low":
+                app.use((0, import_helmet.default)());
+                app.use((0, import_cors.default)({ origin: "*" }));
+                break;
+              case "medium":
+                app.use((0, import_helmet.default)());
+                app.use(
+                  (0, import_cors.default)({
+                    origin: (_a = process.env.CORS_ORIGIN) != null ? _a : "*",
+                    methods: ["GET", "POST"]
+                  })
+                );
+                app.use((req, res, next) => {
+                  new import_rate_limiter_flexible.RateLimiterMemory({
+                    points: 100,
+                    duration: 300
+                  }).consume(req.ip).then(() => next()).catch(
+                    () => res.status(429).json({ error: "Too many requests" })
+                  );
+                });
+                break;
+              case "high":
+                app.use(
+                  (0, import_helmet.default)({
+                    contentSecurityPolicy: {
+                      directives: { defaultSrc: ["'self'"] }
+                    },
+                    // Strict CSP
+                    referrerPolicy: { policy: "no-referrer" }
+                  })
+                );
+                if (!process.env.CORS_ORIGIN) {
+                  throw new Error(
+                    "CORS_ORIGIN must be set for high security profile"
+                  );
+                }
+                app.use(
+                  (0, import_cors.default)({
+                    origin: (_b = process.env.CORS_ORIGIN) != null ? _b : "*",
+                    methods: ["GET", "POST"],
+                    credentials: true
+                  })
+                );
+                app.use((req, res, next) => {
+                  new import_rate_limiter_flexible.RateLimiterMemory({
+                    points: 50,
+                    duration: 60,
+                    blockDuration: 300
+                  }).consume(req.ip).then(() => next()).catch((rej) => {
+                    if (rej.msBeforeNext > 0) {
+                      res.status(429).json({
+                        error: "Too many requests",
+                        retryAfter: rej.msBeforeNext / 1e3
+                      });
+                    } else {
+                      res.status(429).json({ error: "Rate limit exceeded, blocked" });
+                    }
+                  });
+                });
+                break;
+            }
+            return __spreadProps(__spreadValues({}, ctx), { __app: app });
+          },
+          "Sets up the Express server according to the security profile"
+        ).then(
+          CadenzaService.createMetaTask(
+            "Define RestServer",
+            (ctx) => {
+              const app = ctx.__app;
+              app.post("/handshake", (req, res) => {
+                CadenzaService.broker.emit("meta.rest.handshake", req.body);
+                res.send({ __status: "success" });
+              });
+              app.post("/delegation", (req, res) => {
+                const ctx2 = req.body;
+                const routineExecId = ctx2.__routineExecId || (0, import_uuid3.v4)();
+                CadenzaService.createEphemeralMetaTask(
+                  "Resolve delegation",
+                  (endCtx) => res.json({
+                    __status: "success",
+                    __result: endCtx.__result
+                  }),
+                  "Resolves a delegation request"
+                ).doOn(`meta.node.ended_routine_execution:${routineExecId}`).emitsAfter(`meta.rest.delegation_resolved:${routineExecId}`);
+                CadenzaService.createEphemeralMetaTask(
+                  "Delegation progress update",
+                  (progressCtx) => {
+                    if (progressCtx.__progress !== void 0) {
+                    }
+                  },
+                  "Updates delegation progress (polling-based for REST)",
+                  {
+                    once: false,
+                    destroyCondition: (progressCtx) => progressCtx.__progress === 1 || progressCtx.__graphComplete
+                  }
+                ).doOn(
+                  `meta.node.routine_execution_progress:${routineExecId}`,
+                  `meta.node.ended_routine_execution:${routineExecId}`
+                );
+                CadenzaService.broker.emit("meta.rest.delegation_requested", ctx2);
+              });
+              app.post("/signal", (req, res) => {
+                const ctx2 = req.body;
+                res.send({ __status: "success" });
+                CadenzaService.broker.emit(ctx2.__signalName, ctx2.__context);
+              });
+              app.get("/status", (req, res) => {
+                CadenzaService.createEphemeralMetaTask(
+                  "Resolve status check",
+                  (statusCtx) => res.json(statusCtx),
+                  "Resolves a status check request"
+                ).doAfter(CadenzaService.serviceRegistry.getStatusTask);
+                CadenzaService.broker.emit(
+                  "meta.rest.status_check_requested",
+                  req.query
+                );
+              });
+              return true;
+            },
+            "Starts REST server and initiates meta-handling"
+          ).then(
+            CadenzaService.createMetaTask(
+              "Configure network",
+              (ctx) => {
+                let address = "";
+                let port = ctx.__port;
+                let exposed = false;
+                const createHttpServer = (ctx2) => {
+                  const server = import_node_http.default.createServer(ctx2.__app);
+                  ctx2.__httpServer = server;
+                  server.listen(ctx2.__port, () => {
+                    var _a, _b;
+                    if (typeof (server == null ? void 0 : server.address()) === "string") {
+                      address = server.address();
+                    } else if (((_a = server == null ? void 0 : server.address()) == null ? void 0 : _a.address) === "::") {
+                      if (process.env.NODE_ENV === "development") {
+                        address = "localhost";
+                      } else if (process.env.IS_DOCKER === "true") {
+                        address = process.env.PG_GRAPH_SERVER_URL || "localhost";
+                      }
+                    } else {
+                      address = ((_b = server == null ? void 0 : server.address()) == null ? void 0 : _b.address) || "";
+                    }
+                    console.log(`Server is running on ${address}:${port}`);
+                  });
+                  CadenzaService.createMetaTask(
+                    "Shutdown HTTP Server",
+                    () => server.close(),
+                    "Shuts down the HTTP server"
+                  ).doOn("meta.server_shutdown_requested").emitsAfter("meta.rest.shutdown:http");
+                };
+                const createHttpsServer = (ctx2) => {
+                  if (!process.env.SSL_KEY_PATH || !process.env.SSL_CERT_PATH) {
+                    throw new Error(
+                      "SSL_KEY_PATH and SSL_CERT_PATH must be set"
+                    );
+                  }
+                  const options = {
+                    key: import_node_fs.default.readFileSync(process.env.SSL_KEY_PATH),
+                    cert: import_node_fs.default.readFileSync(process.env.SSL_CERT_PATH)
+                  };
+                  const httpsServer = import_node_https.default.createServer(options, ctx2.__app);
+                  ctx2.__httpsServer = httpsServer;
+                  httpsServer.listen(443, () => {
+                    var _a, _b;
+                    if (typeof (httpsServer == null ? void 0 : httpsServer.address()) === "string") {
+                      address = httpsServer.address();
+                    } else if (((_a = httpsServer == null ? void 0 : httpsServer.address()) == null ? void 0 : _a.address) === "::") {
+                      if (process.env.IS_DOCKER === "true") {
+                        address = process.env.PG_GRAPH_SERVER_URL || "localhost";
+                      }
+                    } else {
+                      address = ((_b = httpsServer == null ? void 0 : httpsServer.address()) == null ? void 0 : _b.address) || "";
+                    }
+                    exposed = true;
+                    console.log(`HTTPS Server is running on ${address}:443`);
+                  });
+                  CadenzaService.createMetaTask(
+                    "Shutdown HTTPS Server",
+                    () => httpsServer.close(),
+                    "Shuts down the HTTPS server"
+                  ).doOn("meta.server_shutdown_requested").emitsAfter("meta.rest.shutdown:https");
+                };
+                if (ctx.__networkMode === "internal") {
+                  createHttpServer(ctx);
+                } else if (ctx.__networkMode === "exposed") {
+                  createHttpServer(ctx);
+                  createHttpsServer(ctx);
+                } else if (ctx.__networkMode === "exposed-high-sec") {
+                  createHttpsServer(ctx);
+                } else if (ctx.__networkMode === "auto") {
+                  createHttpServer(ctx);
+                }
+                ctx.id = (0, import_uuid3.v4)();
+                ctx.address = address;
+                ctx.port = port;
+                ctx.exposed = exposed;
+                ctx.process_pid = process.pid;
+                ctx.service_name = ctx.__serviceName;
+                return ctx;
+              },
+              "Configures network mode"
+            ).emitsAfter("meta.rest.network_configured").emitsOnFail("meta.rest.network_configuration_failed")
+          ).emitsOnFail("meta.rest.failed")
+        )
+      ],
+      "Bootstraps the REST server as socket fallback"
+    ).doOn("meta.service_registry.service_inserted");
+    CadenzaService.createMetaTask(
+      "FetchClient",
+      (ctx) => {
+        const {
+          __serviceName,
+          __serviceInstanceId,
+          __serviceAddress,
+          __servicePort,
+          __protocol
+        } = ctx;
+        const port = __protocol === "https" ? 443 : __servicePort;
+        const URL = `${__protocol}://${__serviceAddress}:${port}`;
+        CadenzaService.createMetaTask(
+          "Send Handshake",
+          (ctx2) => __async(null, null, function* () {
+            const response = yield (0, import_node_fetch.default)(`${URL}/handshake`, {
+              method: "POST",
+              body: JSON.stringify(ctx2)
+            });
+            const result = yield response.json();
+            result.__serviceInstanceId = __serviceInstanceId;
+            return result;
+          }),
+          "Sends handshake request"
+        ).doOn("meta.fetch.handshake_requested").emitsAfter("meta.fetch.handshake_complete");
+        CadenzaService.createMetaTask(
+          "Delegate flow to REST server",
+          (ctx2, emit) => __async(null, null, function* () {
+            if (ctx2.__remoteRoutineName === void 0) {
+              return;
+            }
+            let resultContext;
+            try {
+              const response = yield (0, import_node_fetch.default)(`${URL}/delegation`, {
+                method: "POST",
+                body: JSON.stringify(ctx2)
+              });
+              resultContext = yield response.json();
+            } catch (e) {
+              resultContext = __spreadValues(__spreadValues({
+                __error: `Error: ${e}`,
+                errored: true
+              }, ctx2), ctx2.__metaData);
+            } finally {
+              emit(`meta.fetch.delegated:${ctx2.__deputyExecId}`, resultContext);
+            }
+            return resultContext;
+          }),
+          "Sends delegation request"
+        ).doOn(
+          `meta.service_registry.selected_instance_for_fetch:${__serviceInstanceId}`,
+          `meta.service_registry.socket_failed:${__serviceInstanceId}`
+        ).emitsOnFail("meta.fetch.delegate_failed");
+        CadenzaService.createMetaTask(
+          "Transmit signal to server",
+          (ctx2, emit) => __async(null, null, function* () {
+            if (ctx2.__signalName === void 0) {
+              return;
+            }
+            let response;
+            try {
+              response = yield (0, import_node_fetch.default)(`${URL}/signal`, {
+                method: "POST",
+                body: JSON.stringify(ctx2)
+              });
+              response = yield response.json();
+              if (ctx2.__routineExecId) {
+                emit(`meta.fetch.transmitted:${ctx2.__routineExecId}`, response);
+              }
+            } catch (e) {
+              response = __spreadValues({
+                __error: `Error: ${e}`,
+                errored: true
+              }, ctx2);
+            }
+            return response;
+          }),
+          "Sends signal request"
+        ).doOn(
+          `meta.service_registry.selected_instance_for_fetch:${__serviceInstanceId}`,
+          `meta.signal_controller.remote_signal_registered:${__serviceName}`,
+          "meta.signal_controller.wildcard_signal_registered"
+        ).emitsOnFail("meta.fetch.signal_transmission_failed");
+        CadenzaService.createMetaTask(
+          "Request status",
+          (ctx2) => __async(null, null, function* () {
+            let status;
+            try {
+              const response = yield (0, import_node_fetch.default)(`${URL}/status`, { method: "GET" });
+              status = yield response.json();
+            } catch (e) {
+              status = __spreadValues({
+                __error: `Error: ${e}`,
+                errored: true
+              }, ctx2);
+            }
+            return status;
+          }),
+          "Requests status"
+        ).doOn("meta.fetch.status_check_requested").emitsAfter("meta.fetch.status_checked").emitsOnFail("meta.fetch.status_check_failed");
+        return true;
+      },
+      "Manages REST client requests as fallback"
+    ).doOn("meta.service_registry.dependee_registered").emitsOnFail("meta.fetch.connect_failed");
+  }
+};
+
+// src/network/SocketController.ts
+var import_socket = require("socket.io");
+var import_rate_limiter_flexible2 = require("rate-limiter-flexible");
+var import_xss = __toESM(require("xss"));
+var import_socket2 = require("socket.io-client");
+var SocketController = class _SocketController {
+  static get instance() {
+    if (!this._instance) this._instance = new _SocketController();
+    return this._instance;
+  }
+  constructor() {
+    CadenzaService.createMetaRoutine(
+      "SocketServer",
+      [
+        CadenzaService.createMetaTask("Setup SocketServer", (ctx) => {
+          var _a, _b;
+          if (!ctx.__useSocket) {
+            return;
+          }
+          const server = new import_socket.Server((_a = ctx.__httpsServer) != null ? _a : ctx.__httpServer);
+          ctx.__socketServer = server;
+          const profile = (_b = ctx.__securityProfile) != null ? _b : "medium";
+          server.use((socket, next) => {
+            var _a2;
+            const origin = socket.handshake.headers.origin;
+            const allowedOrigins = ["*"];
+            const networkType = (_a2 = ctx.__networkType) != null ? _a2 : "internal";
+            let effectiveOrigin = origin || "unknown";
+            if (networkType === "internal") effectiveOrigin = "internal";
+            if (profile !== "low" && !allowedOrigins.includes(effectiveOrigin) && !allowedOrigins.includes("*")) {
+              return next(new Error("Unauthorized origin"));
+            }
+            const limiterOptions = {
+              low: { points: Infinity, duration: 300 },
+              medium: { points: 100, duration: 300 },
+              high: { points: 50, duration: 60, blockDuration: 300 }
+            };
+            const limiter = new import_rate_limiter_flexible2.RateLimiterMemory(limiterOptions[profile]);
+            socket.use((packet, next2) => {
+              limiter.consume(socket.handshake.address).then(() => next2()).catch((rej) => {
+                if (rej.msBeforeNext > 0) {
+                  socket.emit("error", {
+                    message: "Rate limit exceeded",
+                    retryAfter: rej.msBeforeNext / 1e3
+                  });
+                } else {
+                  socket.disconnect(true);
+                }
+              });
+            });
+            socket.use((packet, next2) => {
+              if (profile !== "low") {
+                const sanitize = (data) => {
+                  if (typeof data === "string") return (0, import_xss.default)(data);
+                  if (typeof data === "object") {
+                    for (const key in data) {
+                      data[key] = sanitize(data[key]);
+                    }
+                  }
+                  return data;
+                };
+                packet[1] = sanitize(packet[1]);
+              }
+              next2();
+            });
+          });
+        }).then(
+          CadenzaService.createMetaTask(
+            "Start SocketServer",
+            (ctx) => {
+              const server = ctx.__socketServer;
+              server.on("connection", (ws) => {
+                ws.on(
+                  "handshake",
+                  (ctx2) => CadenzaService.broker.emit("meta.socket.handshake", ctx2)
+                );
+                ws.on(
+                  "delegation",
+                  (ctx2, callback) => {
+                    CadenzaService.createEphemeralMetaTask(
+                      "Resolve delegation",
+                      callback,
+                      "Resolves a delegation request using the provided callback from the client (.emitWithAck())"
+                    ).doOn(
+                      `meta.node.ended_routine_execution:${ctx2.__routineExecId}`
+                    ).emitsAfter(
+                      `meta.socket.delegation_resolved:${ctx2.__routineExecId}`
+                    );
+                    CadenzaService.createEphemeralMetaTask(
+                      "Delegation progress update",
+                      (ctx3) => {
+                        if (ctx3.__progress !== void 0)
+                          ws.emit("delegation_progress", ctx3);
+                      },
+                      "Updates delegation progress",
+                      {
+                        once: false,
+                        destroyCondition: (ctx3) => ctx3.data.progress === 1
+                      }
+                    ).doOn(
+                      `meta.node.routine_execution_progress:${ctx2.__routineExecId}`,
+                      `meta.node.ended_routine_execution:${ctx2.__routineExecId}`
+                    ).emitsOnFail(
+                      `meta.socket.progress_failed:${ctx2.__routineExecId}`
+                    );
+                    CadenzaService.broker.emit(
+                      "meta.socket.delegation_requested",
+                      ctx2
+                    );
+                  }
+                );
+                ws.on(
+                  "signal",
+                  (ctx2, callback) => {
+                    if (CadenzaService.broker.listObservedSignals().includes(ctx2.__signalName)) {
+                      callback({
+                        __status: "success",
+                        __signalName: ctx2.__signalName
+                      });
+                      CadenzaService.broker.emit(ctx2.__signalName, ctx2);
+                    } else {
+                      callback({
+                        __status: "error",
+                        __error: "No such signal",
+                        errored: true
+                      });
+                    }
+                  }
+                );
+                ws.on(
+                  "status_check",
+                  (ctx2, callback) => {
+                    CadenzaService.createEphemeralMetaTask(
+                      "Resolve status check",
+                      callback,
+                      "Resolves a status check request"
+                    ).doAfter(CadenzaService.serviceRegistry.getStatusTask);
+                    CadenzaService.broker.emit(
+                      "meta.socket.status_check_requested",
+                      ctx2
+                    );
+                  }
+                );
+                ws.on("disconnect", () => {
+                  CadenzaService.broker.emit("meta.socket.disconnected", {
+                    __wsId: ws.id
+                  });
+                });
+                CadenzaService.broker.emit("meta.socket.connected", { __wsId: ws.id });
+              });
+              CadenzaService.createMetaTask(
+                "Broadcast status",
+                (ctx2) => server.emit("status_update", ctx2),
+                "Broadcasts the status of the server to all clients"
+              ).doOn("meta.service.updated");
+              CadenzaService.createMetaTask(
+                "Shutdown SocketServer",
+                () => server.close(),
+                "Shuts down the socket server"
+              ).doOn("meta.socket_server_shutdown_requested").emitsAfter("meta.socket.shutdown");
+              return true;
+            },
+            "Starts socket server and initiates meta-handling"
+          ).emitsOnFail("meta.socket.failed")
+        )
+      ],
+      "Bootstraps the socket server"
+    ).doOn("meta.rest.network_configured");
+    CadenzaService.createMetaTask(
+      "Connect to socket server",
+      (ctx) => {
+        const {
+          __serviceName,
+          __serviceInstanceId,
+          __serviceAddress,
+          __servicePort,
+          __protocol
+        } = ctx;
+        const socketProtocol = __protocol === "https" ? "wss" : "ws";
+        const port = __protocol === "https" ? 443 : __servicePort;
+        const socket = (0, import_socket2.io)(`${socketProtocol}://${__serviceAddress}:${port}`, {
+          reconnection: true,
+          reconnectionAttempts: 20,
+          reconnectionDelay: 1e3,
+          reconnectionDelayMax: 1e4,
+          randomizationFactor: 0.5,
+          retries: 5
+        });
+        socket.on("connect", () => {
+          CadenzaService.broker.emit("meta.socket_client.connected", ctx);
+          socket.emit("handshake", {
+            __serviceInstanceId: ctx.__serviceInstanceId
+          });
+        });
+        socket.on("delegation_progress", (ctx2) => {
+          CadenzaService.broker.emit(
+            `meta.socket_client.delegation_progress:${ctx2.__deputyExecId}`,
+            __spreadValues({ __serviceInstanceId }, ctx2)
+          );
+        });
+        socket.on("status_update", (status) => {
+          CadenzaService.broker.emit("meta.socket_client.status_received", status);
+        });
+        socket.on("disconnect", () => {
+          CadenzaService.broker.emit("meta.socket_client.disconnected", {
+            __serviceInstanceId
+          });
+        });
+        CadenzaService.createMetaTask(
+          `Delegate flow to ${__serviceInstanceId}`,
+          (ctx2, emit) => __async(null, null, function* () {
+            var _a;
+            if (ctx2.__remoteRoutineName === void 0) {
+              return;
+            }
+            let resultContext;
+            try {
+              resultContext = yield socket.timeout((_a = ctx2.__timeout) != null ? _a : 0).emitWithAck("delegation", ctx2);
+              emit(
+                `meta.socket_client.delegated:${ctx2.__deputyExecId}`,
+                resultContext
+              );
+            } catch (e) {
+              resultContext = __spreadValues(__spreadValues({
+                __error: `Timeout error: ${e}`,
+                errored: true
+              }, ctx2), ctx2.__metaData);
+            }
+            return resultContext;
+          }),
+          `Delegate flow to instance ${__serviceInstanceId} of service ${__serviceName} with address ${__serviceAddress}:${__servicePort}`
+        ).doOn(
+          `meta.service_registry.selected_instance_for_socket:${__serviceInstanceId}`
+        ).emitsOnFail(
+          `meta.socket_client.delegate_failed:${__serviceInstanceId}`
+        );
+        CadenzaService.createMetaTask(
+          `Transmit signal to ${__serviceInstanceId}`,
+          (ctx2, emit) => __async(null, null, function* () {
+            var _a;
+            if (ctx2.__signalName === void 0) {
+              return;
+            }
+            let response;
+            try {
+              response = yield socket.timeout((_a = ctx2.__timeout) != null ? _a : 0).emitWithAck("signal", ctx2);
+              if (ctx2.__routineExecId) {
+                emit(
+                  `meta.socket_client.transmitted:${ctx2.__routineExecId}`,
+                  response
+                );
+              }
+            } catch (e) {
+              response = __spreadValues(__spreadValues({
+                __error: `Timeout error: ${e}`,
+                errored: true
+              }, ctx2), ctx2.__metaData);
+            }
+            return response;
+          }),
+          `Transmits signal to instance ${__serviceInstanceId} of service ${__serviceName} with address ${__serviceAddress}:${__servicePort}`
+        ).doOn(
+          `meta.service_registry.selected_instance_for_socket:${__serviceInstanceId}`
+        ).emitsOnFail(
+          `meta.socket_client.signal_transmission_failed:${__serviceInstanceId}`
+        );
+        CadenzaService.createMetaTask(
+          "Shutdown SocketClient",
+          () => socket.close(),
+          "Shuts down the socket client"
+        ).doOn("meta.socket_shutdown_requested").emitsAfter("meta.socket_client_shutdown_complete");
+        return true;
+      },
+      "Connects to a specified socket server"
+    ).doOn("meta.service_registry.dependee_registered").emitsOnFail("meta.socket_client.connect_failed");
+  }
+};
+
+// src/signals/SignalController.ts
+var SignalController = class _SignalController {
+  static get instance() {
+    if (!this._instance) this._instance = new _SignalController();
+    return this._instance;
+  }
+  constructor() {
+    CadenzaService.createMetaTask(
+      "Handle Signal Registration",
+      (ctx, emit) => {
+        const { __signalName } = ctx;
+        const firstChar = __signalName.charAt(0);
+        const parts = __signalName.split(".");
+        const domain = parts[0] === "meta" ? parts[1] : parts[0];
+        const action = parts[parts.length - 1];
+        emit("meta.signal_controller.signal_added", {
+          data: {
+            name: __signalName,
+            domain,
+            action,
+            is_meta: parts[0] === "meta",
+            service_name: CadenzaService.serviceRegistry.serviceName
+          }
+        });
+        if (firstChar === firstChar.toUpperCase() && firstChar !== firstChar.toLowerCase() || firstChar === "*") {
+          const serviceName = __signalName.split(".")[0];
+          ctx.__listenerServiceName = CadenzaService.serviceRegistry.serviceName;
+          ctx.__emitterSignalName = __signalName.split(".").slice(1).join(".");
+          ctx.__signalName = "meta.signal_controller.foreign_signal_registered";
+          if (serviceName === "*") {
+            emit("meta.signal_controller.wildcard_signal_registered", ctx);
+          } else {
+            emit(
+              `meta.signal_controller.remote_signal_registered:${serviceName}`,
+              ctx
+            );
+          }
+        }
+        return ctx;
+      },
+      "Handles signal registration from a service instance"
+    ).doOn("meta.signal_broker.added");
+    CadenzaService.createMetaTask("Handle foreign signal registration", (ctx) => {
+      const { __emitterSignalName, __listenerServiceName } = ctx;
+      CadenzaService.createSignalTransmissionTask(
+        __emitterSignalName,
+        __listenerServiceName
+      ).doOn(__emitterSignalName);
+      return true;
+    }).doOn("meta.signal_controller.foreign_signal_registered");
+    CadenzaService.createMetaTask(
+      "Add data to signal emission",
+      (ctx) => {
+        const signalEmission = ctx.__signalEmission;
+        if (!signalEmission) {
+          return false;
+        }
+        return {
+          data: __spreadProps(__spreadValues({}, signalEmission), {
+            data: ctx,
+            service_name: CadenzaService.serviceRegistry.serviceName,
+            service_instance_id: CadenzaService.serviceRegistry.serviceInstanceId,
+            signal_id: {
+              subOperation: "query",
+              table: "signal_registry",
+              filter: {
+                name: ctx.__signalLog.signal_name,
+                service_name: CadenzaService.serviceRegistry.serviceName
+              },
+              fields: ["id"],
+              return: "id"
+            }
+          }),
+          transaction: true
+        };
+      },
+      "",
+      { isSubMeta: true, concurrency: 50 }
+    ).doOn(".*").emitsAfter("sub_meta.signal_controller.signal_emitted");
+    CadenzaService.createMetaTask(
+      "Add metadata to signal consumption",
+      (ctx) => {
+        return {
+          data: __spreadProps(__spreadValues({}, ctx.__data), {
+            serviceName: CadenzaService.serviceRegistry.serviceName,
+            serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId,
+            signalId: {
+              subOperation: "query",
+              table: "signal_registry",
+              filter: {
+                name: ctx.__data.signalName,
+                serviceName: CadenzaService.serviceRegistry.serviceName
+              },
+              fields: ["id"],
+              return: "id"
+            }
+          })
+        };
+      },
+      "",
+      { isSubMeta: true, concurrency: 50 }
+    ).doOn("meta.node.consumed_signal").emitsAfter("sub_meta.signal_controller.signal_consumed");
+  }
+};
+
+// src/graph/controllers/TaskController.ts
+var TaskController = class _TaskController {
+  static get instance() {
+    if (!this._instance) this._instance = new _TaskController();
+    return this._instance;
+  }
+  constructor() {
+    CadenzaService.createMetaTask("Add data to task creation", (ctx) => {
+      return __spreadProps(__spreadValues({}, ctx.__task), {
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
+    }).doOn("meta.task.created").emitsAfter("meta.task_controller.task_created");
+  }
+};
+
+// src/Cadenza.ts
+var CadenzaService = class {
+  static bootstrap() {
+    if (this.isBootstrapped) return;
+    this.isBootstrapped = true;
+    import_core3.default.bootstrap();
+    this.broker = import_core3.default.broker;
+    this.runner = import_core3.default.runner;
+    this.metaRunner = import_core3.default.metaRunner;
+    this.registry = import_core3.default.registry;
+    SignalController.instance;
+    TaskController.instance;
+    this.serviceRegistry = ServiceRegistry.instance;
+    RestController.instance;
+    SocketController.instance;
+    console.log("BOOTSTRAPPED");
+  }
+  static validateServiceName(serviceName) {
+    if (serviceName.length > 100) {
+      throw new Error("Service name must be less than 100 characters");
+    }
+    if (serviceName.includes(" ")) {
+      throw new Error("Service name must not contain spaces");
+    }
+    if (serviceName.includes(".")) {
+      throw new Error("Service name must not contain dots");
+    }
+    if (serviceName.includes("\\")) {
+      throw new Error("Service name must not contain backslashes");
+    }
+    if (serviceName.charAt(0) !== serviceName.charAt(0).toUpperCase() && serviceName.charAt(0) === serviceName.charAt(0).toLowerCase()) {
+      throw new Error("Service name must start with a capital letter");
+    }
+  }
+  static validateName(name) {
+    import_core3.default.validateName(name);
+  }
+  static get runStrategy() {
+    return import_core3.default.runStrategy;
+  }
+  static setMode(mode) {
+    import_core3.default.setMode(mode);
+  }
+  static createDeputyTask(routineName, serviceName = void 0, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    this.validateName(routineName);
+    const name = `Deputy task for "${routineName}"`;
+    return new DeputyTask(
+      name,
+      routineName,
+      serviceName,
+      `Referencing routine in service: ${routineName} on service: ${serviceName}.`,
+      options.concurrency,
+      options.timeout,
+      options.register,
+      options.isUnique,
+      options.isMeta,
+      options.isSubMeta,
+      options.isHidden,
+      options.getTagCallback,
+      options.inputSchema,
+      options.validateInputContext,
+      options.outputSchema,
+      options.validateOutputContext,
+      options.retryCount,
+      options.retryDelay,
+      options.retryDelayMax,
+      options.retryDelayFactor
+    );
+  }
+  static createMetaDeputyTask(routineName, serviceName = void 0, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: true,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    options.isMeta = true;
+    return this.createDeputyTask(routineName, serviceName, options);
+  }
+  static createUniqueDeputyTask(routineName, serviceName = void 0, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: true,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    options.isUnique = true;
+    return this.createDeputyTask(routineName, serviceName, options);
+  }
+  static createUniqueMetaDeputyTask(routineName, serviceName = void 0, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: true,
+    isMeta: true,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    options.isMeta = true;
+    return this.createUniqueDeputyTask(routineName, serviceName, options);
+  }
+  static createThrottledDeputyTask(routineName, serviceName = void 0, throttledIdGetter = () => "default", options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    options.getTagCallback = throttledIdGetter;
+    return this.createDeputyTask(routineName, serviceName, options);
+  }
+  static createMetaThrottledDeputyTask(routineName, serviceName = void 0, throttledIdGetter = () => "default", options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    options.isMeta = true;
+    return this.createThrottledDeputyTask(
+      routineName,
+      serviceName,
+      throttledIdGetter,
+      options
+    );
+  }
+  static createSignalTransmissionTask(signalName, serviceName, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: true,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 1,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    import_core3.default.validateName(signalName);
+    import_core3.default.validateName(serviceName);
+    options.isMeta = true;
+    const name = `SignalTransmission task for "${signalName}"`;
+    return new SignalTransmissionTask(
+      name,
+      signalName,
+      serviceName,
+      `Transmits signal "${signalName}" to service "${serviceName}"`,
+      options.concurrency,
+      options.timeout,
+      options.register,
+      options.isUnique,
+      options.isMeta,
+      options.isSubMeta,
+      options.isHidden,
+      options.getTagCallback,
+      options.inputSchema,
+      options.validateInputContext,
+      options.outputSchema,
+      options.validateOutputContext,
+      options.retryCount,
+      options.retryDelay,
+      options.retryDelayMax,
+      options.retryDelayFactor
+    );
+  }
+  static createDatabaseTask(tableName, operation, databaseServiceName = void 0, queryData, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 1,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    import_core3.default.validateName(tableName);
+    import_core3.default.validateName(operation);
+    const tableNameFormatted = tableName.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+    const name = `${operation} ${tableName} in ${databaseServiceName != null ? databaseServiceName : "default database service"}`;
+    const description = `Executes a database "${operation}" on table "${tableName}" in ${databaseServiceName != null ? databaseServiceName : "default database service"}`;
+    const taskName = `db${operation.charAt(0).toUpperCase() + operation.slice(1)}${tableNameFormatted}`;
+    return new DatabaseTask(
+      name,
+      taskName,
+      databaseServiceName,
+      description,
+      queryData,
+      options.concurrency,
+      options.timeout,
+      options.register,
+      options.isUnique,
+      options.isMeta,
+      options.isSubMeta,
+      options.isHidden,
+      options.getTagCallback,
+      options.inputSchema,
+      options.validateInputContext,
+      options.outputSchema,
+      options.validateOutputContext,
+      options.retryCount,
+      options.retryDelay,
+      options.retryDelayMax,
+      options.retryDelayFactor
+    );
+  }
+  static createDatabaseInertTask(tableName, databaseServiceName = void 0, queryData = {}, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 1,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    return this.createDatabaseTask(
+      tableName,
+      "insert",
+      databaseServiceName,
+      queryData,
+      options
+    );
+  }
+  static createDatabaseQueryTask(tableName, databaseServiceName = void 0, queryData, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 1,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    return this.createDatabaseTask(
+      tableName,
+      "query",
+      databaseServiceName,
+      queryData,
+      options
+    );
+  }
+  static createCadenzaDBTask(tableName, operation, queryData, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: true,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 1,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    options.isMeta = true;
+    return this.createDatabaseTask(
+      tableName,
+      operation,
+      "CadenzaDB",
+      queryData,
+      options
+    );
+  }
+  static createCadenzaDBInsertTask(tableName, queryData = {}, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: true,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 1,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    options.isMeta = true;
+    return this.createDatabaseInertTask(
+      tableName,
+      "CadenzaDB",
+      queryData,
+      options
+    );
+  }
+  static createCadenzaDBQueryTask(tableName, queryData, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: true,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 1,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    options.isMeta = true;
+    return this.createDatabaseQueryTask(
+      tableName,
+      "CadenzaDB",
+      queryData,
+      options
+    );
+  }
+  static createCadenzaService(serviceName, description, options = {
+    loadBalance: true,
+    useSocket: true,
+    displayName: void 0,
+    isMeta: false,
+    port: parseInt(((_a) => (_a = process.env.HTTP_PORT) != null ? _a : "3000")()),
+    securityProfile: ((_b) => (_b = process.env.SECURITY_PROFILE) != null ? _b : "medium")(),
+    networkMode: ((_c) => (_c = process.env.NETWORK_MODE) != null ? _c : "dev")(),
+    retryCount: 3,
+    cadenzaDB: {
+      address: ((_d) => (_d = process.env.CADENZA_DB_ADDRESS) != null ? _d : "localhost")(),
+      port: parseInt(((_e) => (_e = process.env.CADENZA_DB_PORT) != null ? _e : "5000")())
+    }
+  }) {
+    var _a2, _b2;
+    this.bootstrap();
+    import_core3.default.validateName(serviceName);
+    this.validateServiceName(serviceName);
+    import_core3.default.broker.emit("meta.initializing_service", {
+      // Seed the CadenzaDB
+      serviceInstance: {
+        id: "cadenza-db",
+        serviceName: "CadenzaDB",
+        address: (_a2 = options.cadenzaDB) == null ? void 0 : _a2.address,
+        port: (_b2 = options.cadenzaDB) == null ? void 0 : _b2.port,
+        exposed: options.networkMode !== "dev",
+        numberOfRunningGraphs: 0,
+        isActive: true,
+        // Assume it is deployed
+        isNonResponsive: false,
+        isBlocked: false,
+        health: {}
+      }
+    });
+    import_core3.default.broker.emit("meta.create_service_requested", {
+      data: {
+        name: serviceName,
+        description,
+        displayName: options.displayName,
+        isMeta: options.isMeta
+      },
+      __serviceName: serviceName,
+      __port: options.port,
+      __loadBalance: options.loadBalance,
+      __useSocket: options.useSocket,
+      __securityProfile: options.securityProfile,
+      __networkMode: options.networkMode,
+      __retryCount: options.retryCount
+    });
+  }
+  static createCadenzaMetaService(serviceName, description, options = {
+    loadBalance: false,
+    useSocket: false,
+    log: false,
+    displayName: void 0,
+    isMeta: true,
+    port: parseInt(((_f) => (_f = process.env.HTTP_PORT) != null ? _f : "3000")()),
+    securityProfile: ((_g) => (_g = process.env.SECURITY_PROFILE) != null ? _g : "medium")(),
+    networkMode: ((_h) => (_h = process.env.NETWORK_MODE) != null ? _h : "auto")(),
+    retryCount: 3
+  }) {
+    options.isMeta = true;
+    this.createCadenzaService(serviceName, description, options);
+  }
+  /**
+   * Creates a standard Task and registers it in the GraphRegistry.
+   * @param name Unique identifier for the task.
+   * @param func The function or async generator to execute.
+   * @param description Optional human-readable description for introspection.
+   * @param options Optional task options.
+   * @returns The created Task instance.
+   * @throws Error if name is invalid or duplicate in registry.
+   */
+  static createTask(name, func, description, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    return import_core3.default.createTask(name, func, description, options);
+  }
+  /**
+   * Creates a MetaTask (for meta-layer graphs) and registers it.
+   * MetaTasks suppress further meta-signal emissions to prevent loops.
+   * @param name Unique identifier for the meta-task.
+   * @param func The function or async generator to execute.
+   * @param description Optional description.
+   * @param options Optional task options.
+   * @returns The created MetaTask instance.
+   * @throws Error if name invalid or duplicate.
+   */
+  static createMetaTask(name, func, description, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: true,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    return import_core3.default.createMetaTask(name, func, description, options);
+  }
+  /**
+   * Creates a UniqueTask (executes once per execution ID, merging parents) and registers it.
+   * Use for fan-in/joins after parallel branches.
+   * @param name Unique identifier.
+   * @param func Function receiving joinedContexts.
+   * @param description Optional description.
+   * @param options Optional task options.
+   * @returns The created UniqueTask.
+   * @throws Error if invalid.
+   */
+  static createUniqueTask(name, func, description, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: true,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    return import_core3.default.createUniqueTask(name, func, description, options);
+  }
+  /**
+   * Creates a UniqueMetaTask for meta-layer joins.
+   * @param name Unique identifier.
+   * @param func Function.
+   * @param description Optional.
+   * @param options Optional task options.
+   * @returns The created UniqueMetaTask.
+   */
+  static createUniqueMetaTask(name, func, description, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: true,
+    isMeta: true,
+    isSubMeta: false,
+    isHidden: false,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    return import_core3.default.createUniqueMetaTask(name, func, description, options);
+  }
+  /**
+   * Creates a ThrottledTask (rate-limited by concurrency or custom groups) and registers it.
+   * @param name Unique identifier.
+   * @param func Function.
+   * @param throttledIdGetter Optional getter for dynamic grouping (e.g., per-user).
+   * @param description Optional.
+   * @param options Optional task options.
+   * @returns The created ThrottledTask.
+   * @edge If no getter, throttles per task ID; use for resource protection.
+   */
+  static createThrottledTask(name, func, throttledIdGetter = () => "default", description, options = {
+    concurrency: 1,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    return import_core3.default.createThrottledTask(
+      name,
+      func,
+      throttledIdGetter,
+      description,
+      options
+    );
+  }
+  /**
+   * Creates a ThrottledMetaTask for meta-layer throttling.
+   * @param name Identifier.
+   * @param func Function.
+   * @param throttledIdGetter Optional getter.
+   * @param description Optional.
+   * @param options Optional task options.
+   * @returns The created ThrottledMetaTask.
+   */
+  static createThrottledMetaTask(name, func, throttledIdGetter, description, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    isUnique: false,
+    isMeta: true,
+    isSubMeta: false,
+    isHidden: false,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    return import_core3.default.createThrottledMetaTask(
+      name,
+      func,
+      throttledIdGetter,
+      description,
+      options
+    );
+  }
+  /**
+   * Creates a DebounceTask (delays exec until quiet period) and registers it.
+   * @param name Identifier.
+   * @param func Function.
+   * @param description Optional.
+   * @param debounceTime Delay in ms (default 1000).
+   * @param options Optional task options plus optional debounce config (e.g., leading/trailing).
+   * @returns The created DebounceTask.
+   * @edge Multiple triggers within time collapse to one exec.
+   */
+  static createDebounceTask(name, func, description, debounceTime = 1e3, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    leading: false,
+    trailing: true,
+    maxWait: 0,
+    isUnique: false,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    return import_core3.default.createDebounceTask(
+      name,
+      func,
+      description,
+      debounceTime,
+      options
+    );
+  }
+  /**
+   * Creates a DebouncedMetaTask for meta-layer debouncing.
+   * @param name Identifier.
+   * @param func Function.
+   * @param description Optional.
+   * @param debounceTime Delay in ms.
+   * @param options Optional task options plus optional debounce config (e.g., leading/trailing).
+   * @returns The created DebouncedMetaTask.
+   */
+  static createDebounceMetaTask(name, func, description, debounceTime = 1e3, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: true,
+    leading: false,
+    trailing: true,
+    maxWait: 0,
+    isUnique: false,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    return import_core3.default.createDebounceMetaTask(
+      name,
+      func,
+      description,
+      debounceTime,
+      options
+    );
+  }
+  /**
+   * Creates an EphemeralTask (self-destructs after exec or condition) without default registration.
+   * Useful for transients; optionally register if needed.
+   * @param name Identifier (may not be unique if not registered).
+   * @param func Function.
+   * @param description Optional.
+   * @param options Optional task options.
+   * @returns The created EphemeralTask.
+   * @edge Destruction triggered post-exec via Node/Builder; emits meta-signal for cleanup.
+   */
+  static createEphemeralTask(name, func, description, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: false,
+    isUnique: false,
+    isMeta: false,
+    isSubMeta: false,
+    isHidden: false,
+    once: true,
+    destroyCondition: () => true,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    return import_core3.default.createEphemeralTask(name, func, description, options);
+  }
+  /**
+   * Creates an EphemeralMetaTask for meta-layer transients.
+   * @param name Identifier.
+   * @param func Function.
+   * @param description Optional.
+   * @param options Optional task options.
+   * @returns The created EphemeralMetaTask.
+   */
+  static createEphemeralMetaTask(name, func, description, options = {
+    concurrency: 0,
+    timeout: 0,
+    register: false,
+    isUnique: false,
+    isMeta: true,
+    isSubMeta: false,
+    isHidden: false,
+    once: true,
+    destroyCondition: () => true,
+    getTagCallback: void 0,
+    inputSchema: void 0,
+    validateInputContext: false,
+    outputSchema: void 0,
+    validateOutputContext: false,
+    retryCount: 0,
+    retryDelay: 0,
+    retryDelayMax: 0,
+    retryDelayFactor: 1
+  }) {
+    this.bootstrap();
+    return import_core3.default.createEphemeralMetaTask(name, func, description, options);
+  }
+  /**
+   * Creates a GraphRoutine (named entry to starting tasks) and registers it.
+   * @param name Unique identifier.
+   * @param tasks Starting tasks (can be empty, but warns as no-op).
+   * @param description Optional.
+   * @returns The created GraphRoutine.
+   * @edge If tasks empty, routine is valid but inert.
+   */
+  static createRoutine(name, tasks, description = "") {
+    this.bootstrap();
+    return import_core3.default.createRoutine(name, tasks, description);
+  }
+  /**
+   * Creates a MetaRoutine for meta-layer entry points.
+   * @param name Identifier.
+   * @param tasks Starting tasks.
+   * @param description Optional.
+   * @returns The created MetaRoutine.
+   */
+  static createMetaRoutine(name, tasks, description = "") {
+    this.bootstrap();
+    return import_core3.default.createMetaRoutine(name, tasks, description);
+  }
+  static reset() {
+    import_core3.default.reset();
+    this.serviceRegistry.reset();
+  }
+};
+CadenzaService.isBootstrapped = false;
+
+// src/index.ts
+var index_default = CadenzaService;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseTask,
+  DeputyTask,
+  RestController,
+  ServiceRegistry,
+  SignalController,
+  SignalTransmissionTask,
+  SocketController,
+  TaskController
+});
+//# sourceMappingURL=index.js.map