@cadenza.io/core 1.2.0 → 1.4.0

package/dist/index.js

@@ -21,22 +21,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   DebounceTask: () => DebounceTask,
-  DebouncedMetaTask: () => DebouncedMetaTask,
-  EphemeralMetaTask: () => EphemeralMetaTask,
   EphemeralTask: () => EphemeralTask,
   GraphContext: () => GraphContext,
   GraphRegistry: () => GraphRegistry,
   GraphRoutine: () => GraphRoutine,
-  MetaRoutine: () => MetaRoutine,
-  MetaTask: () => MetaTask,
+  GraphRun: () => GraphRun,
   SignalEmitter: () => SignalEmitter,
-  SignalMetaTask: () => SignalMetaTask,
   SignalParticipant: () => SignalParticipant,
   SignalTask: () => SignalTask,
   Task: () => Task,
-  ThrottledMetaTask: () => ThrottledMetaTask,
   ThrottledTask: () => ThrottledTask,
-  UniqueMetaTask: () => UniqueMetaTask,
   UniqueTask: () => UniqueTask,
   default: () => index_default
 });
@@ -47,8 +41,8 @@ var SignalBroker = class _SignalBroker {
   // execId -> emitted signals
   constructor() {
     this.signalObservers = /* @__PURE__ */ new Map();
-    // For loop prevention: Per-execId recent emits (cleared post-run or TTL)
     this.emitStacks = /* @__PURE__ */ new Map();
+    this.addSignal("meta.signal.added");
   }
   /**
    * Singleton instance for signal management.
@@ -65,10 +59,32 @@ var SignalBroker = class _SignalBroker {
    * @param runner Standard runner for user signals.
    * @param metaRunner Meta runner for 'meta.' signals (suppresses further meta-emits).
    */
-  init(runner, metaRunner) {
+  bootstrap(runner, metaRunner) {
     this.runner = runner;
     this.metaRunner = metaRunner;
   }
+  init() {
+    Cadenza.createMetaTask(
+      "Execute and clear queued signals",
+      () => {
+        for (const [id, signals] of this.emitStacks.entries()) {
+          signals.forEach((context, signal) => {
+            this.execute(signal, context);
+            signals.delete(signal);
+          });
+          this.emitStacks.delete(id);
+        }
+        return true;
+      },
+      "Executes queued signals and clears the stack"
+    ).doOn("meta.clear_signal_queue_requested");
+    this.getSignalsTask = Cadenza.createMetaTask("Get signals", (ctx) => {
+      return {
+        __signals: Array.from(this.signalObservers.keys()),
+        ...ctx
+      };
+    });
+  }
   /**
    * Observes a signal with a routine/task.
    * @param signal The signal (e.g., 'domain.action', 'domain.*' for wildcards).
@@ -104,30 +120,34 @@ var SignalBroker = class _SignalBroker {
    */
   emit(signal, context = {}) {
     const execId = context.__graphExecId || "global";
-    if (!this.emitStacks.has(execId)) this.emitStacks.set(execId, /* @__PURE__ */ new Set());
+    if (!this.emitStacks.has(execId)) this.emitStacks.set(execId, /* @__PURE__ */ new Map());
     const stack = this.emitStacks.get(execId);
-    if (stack.has(signal)) {
-      throw new Error(`Signal loop detected for ${signal} in exec ${execId}`);
-    }
-    stack.add(signal);
-    this.executeListener(signal, context);
+    stack.set(signal, context);
+    let executed = false;
     try {
-      const parts = signal.slice(0, Math.max(signal.lastIndexOf(":"), signal.lastIndexOf("."))).split(".");
-      for (let i = parts.length; i > 0; i--) {
-        const parent = parts.slice(0, i).join(".");
-        this.executeListener(parent, context);
-        this.executeListener(parent + ".*", context);
-      }
+      executed = this.execute(signal, context);
     } finally {
-      stack.delete(signal);
+      if (executed) stack.delete(signal);
+    }
+  }
+  execute(signal, context) {
+    let executed;
+    executed = this.executeListener(signal, context);
+    const parts = signal.slice(0, Math.max(signal.lastIndexOf(":"), signal.lastIndexOf("."))).split(".");
+    for (let i = parts.length; i > 0; i--) {
+      const parent = parts.slice(0, i).join(".");
+      executed = executed || this.executeListener(parent + ".*", context);
     }
+    return executed;
   }
   executeListener(signal, context) {
     const obs = this.signalObservers.get(signal);
     const runner = this.getRunner(signal);
     if (obs && runner) {
       obs.fn(runner, Array.from(obs.tasks), context);
+      return true;
     }
+    return false;
   }
   addSignal(signal) {
     if (!this.signalObservers.has(signal)) {
@@ -135,6 +155,7 @@ var SignalBroker = class _SignalBroker {
         fn: (runner, tasks, context) => runner.run(tasks, context),
         tasks: /* @__PURE__ */ new Set()
       });
+      this.emit("meta.signal.added", { __signal: signal });
     }
   }
   /**
@@ -1073,13 +1094,14 @@ var SignalParticipant = class extends SignalEmitter {
 
 // src/graph/definition/GraphRoutine.ts
 var GraphRoutine = class extends SignalParticipant {
-  constructor(name, tasks, description) {
+  constructor(name, tasks, description, isMeta = false) {
     super();
     this.isMeta = false;
     this.tasks = /* @__PURE__ */ new Set();
     this.id = (0, import_uuid4.v4)();
     this.name = name;
     this.description = description;
+    this.isMeta = isMeta;
     tasks.forEach((t) => this.tasks.add(t));
     this.emit("meta.routine.created", { __routine: this });
   }
@@ -1159,14 +1181,16 @@ var Task = class extends SignalParticipant {
    * @param concurrency Limit.
    * @param timeout ms.
    * @param register Register via signal (default true).
+   * @param isUnique
+   * @param isMeta
    * @edge Emits 'meta.task.created' with { __task: this } for seed.
    */
-  constructor(name, task, description = "", concurrency = 0, timeout = 0, register = true) {
+  constructor(name, task, description = "", concurrency = 0, timeout = 0, register = true, isUnique = false, isMeta = false) {
     super();
+    this.isMeta = false;
     this.isUnique = false;
     this.throttled = false;
     this.isSignal = false;
-    this.isMeta = false;
     this.isDeputy = false;
     this.isEphemeral = false;
     this.layerIndex = 0;
@@ -1181,6 +1205,8 @@ var Task = class extends SignalParticipant {
     this.description = description;
     this.concurrency = concurrency;
     this.timeout = timeout;
+    this.isUnique = isUnique;
+    this.isMeta = isMeta;
     if (register) {
       this.emit("meta.task.created", { __task: this });
     }
@@ -1348,6 +1374,7 @@ var Task = class extends SignalParticipant {
       __concurrency: this.concurrency,
       __timeout: this.timeout,
       __functionString: this.taskFunction.toString(),
+      __getTagCallback: this.getTag.toString(),
       __nextTasks: Array.from(this.nextTasks).map((t) => t.id),
       __onFailTasks: Array.from(this.onFailTasks).map((t) => t.id),
       __previousTasks: Array.from(this.predecessorTasks).map((t) => t.id)
@@ -1364,20 +1391,12 @@ var Task = class extends SignalParticipant {
   }
 };
 
-// src/graph/definition/meta/MetaTask.ts
-var MetaTask = class extends Task {
-  constructor() {
-    super(...arguments);
-    this.isMeta = true;
-  }
-};
-
 // src/registry/GraphRegistry.ts
 var GraphRegistry = class _GraphRegistry {
   constructor() {
     this.tasks = /* @__PURE__ */ new Map();
     this.routines = /* @__PURE__ */ new Map();
-    this.registerTask = new MetaTask(
+    this.registerTask = new Task(
       "Registry Seed",
       (context) => {
         const { __task } = context;
@@ -1387,7 +1406,12 @@ var GraphRegistry = class _GraphRegistry {
         }
         return true;
       },
-      "Registers tasks. Seed for meta.taskCreated"
+      "Registers tasks. Seed for meta.taskCreated",
+      0,
+      0,
+      true,
+      false,
+      true
     ).doOn("meta.task.created");
     this.tasks.set(this.registerTask.id, this.registerTask);
     this.updateTaskId = Cadenza.createMetaTask(
@@ -1684,49 +1708,37 @@ var GraphRunner = class extends SignalEmitter {
   }
 };
 
-// src/graph/definition/UniqueTask.ts
-var UniqueTask = class extends Task {
-  constructor() {
-    super(...arguments);
-    this.isUnique = true;
-  }
-};
-
-// src/graph/definition/meta/UniqueMetaTask.ts
-var UniqueMetaTask = class extends UniqueTask {
-  constructor() {
-    super(...arguments);
-    this.isMeta = true;
-  }
-};
-
 // src/graph/definition/ThrottledTask.ts
 var ThrottledTask = class extends Task {
-  constructor(name, task, description = "", getTagCallback = (context, task2) => "default", concurrency = 1, timeout = 0, register = true) {
-    super(name, task, description, concurrency, timeout, register);
+  constructor(name, task, description = "", getTagCallback = (context, task2) => "default", concurrency = 1, timeout = 0, register = true, isUnique = false, isMeta = false) {
+    super(
+      name,
+      task,
+      description,
+      concurrency,
+      timeout,
+      register,
+      isUnique,
+      isMeta
+    );
     this.throttled = true;
     this.getTag = (context) => getTagCallback(context, this);
   }
-  export() {
-    return {
-      ...super.export(),
-      __getTagCallback: this.getTag.toString()
-    };
-  }
-};
-
-// src/graph/definition/meta/ThrottledMetaTask.ts
-var ThrottledMetaTask = class extends ThrottledTask {
-  constructor() {
-    super(...arguments);
-    this.isMeta = true;
-  }
 };
 
 // src/graph/definition/DebounceTask.ts
 var DebounceTask = class extends Task {
-  constructor(name, task, description = "", debounceTime = 1e3, leading = false, trailing = true, concurrency = 0, timeout = 0, register = true) {
-    super(name, task, description, concurrency, timeout, register);
+  constructor(name, task, description = "", debounceTime = 1e3, leading = false, trailing = true, concurrency = 0, timeout = 0, register = true, isUnique = false, isMeta = false) {
+    super(
+      name,
+      task,
+      description,
+      concurrency,
+      timeout,
+      register,
+      isUnique,
+      isMeta
+    );
     this.timer = null;
     this.lastResolve = null;
     this.lastReject = null;
@@ -1795,18 +1807,19 @@ var DebounceTask = class extends Task {
   }
 };
 
-// src/graph/definition/meta/DebouncedMetaTask.ts
-var DebouncedMetaTask = class extends DebounceTask {
-  constructor() {
-    super(...arguments);
-    this.isMeta = true;
-  }
-};
-
 // src/graph/definition/EphemeralTask.ts
 var EphemeralTask = class extends Task {
-  constructor(name, task, description = "", once = true, condition = () => true, concurrency = 0, timeout = 0, register = false) {
-    super(name, task, description, concurrency, timeout, register);
+  constructor(name, task, description = "", once = true, condition = () => true, concurrency = 0, timeout = 0, register = false, isUnique = false, isMeta = false) {
+    super(
+      name,
+      task,
+      description,
+      concurrency,
+      timeout,
+      register,
+      isUnique,
+      isMeta
+    );
     this.isEphemeral = true;
     this.once = once;
     this.condition = condition;
@@ -1821,22 +1834,6 @@ var EphemeralTask = class extends Task {
   }
 };
 
-// src/graph/definition/meta/EphemeralMetaTask.ts
-var EphemeralMetaTask = class extends EphemeralTask {
-  constructor() {
-    super(...arguments);
-    this.isMeta = true;
-  }
-};
-
-// src/graph/definition/meta/MetaRoutine.ts
-var MetaRoutine = class extends GraphRoutine {
-  constructor() {
-    super(...arguments);
-    this.isMeta = true;
-  }
-};
-
 // src/interfaces/ExecutionChain.ts
 var ExecutionChain = class {
   setNext(next) {
@@ -2351,8 +2348,9 @@ var Cadenza = class {
     this.broker = SignalBroker.instance;
     this.runner = new GraphRunner();
     this.metaRunner = new GraphRunner(true);
-    this.broker.init(this.runner, this.metaRunner);
+    this.broker.bootstrap(this.runner, this.metaRunner);
     this.registry = GraphRegistry.instance;
+    this.broker.init();
     this.runner.init();
     this.metaRunner.init();
   }
@@ -2384,7 +2382,9 @@ var Cadenza = class {
   static createTask(name, func, description, options = {
     concurrency: 0,
     timeout: 0,
-    register: true
+    register: true,
+    isUnique: false,
+    isMeta: false
   }) {
     this.bootstrap();
     this.validateName(name);
@@ -2394,7 +2394,9 @@ var Cadenza = class {
       description,
       options.concurrency,
       options.timeout,
-      options.register
+      options.register,
+      options.isUnique,
+      options.isMeta
     );
   }
   /**
@@ -2410,18 +2412,12 @@ var Cadenza = class {
   static createMetaTask(name, func, description, options = {
     concurrency: 0,
     timeout: 0,
-    register: true
+    register: true,
+    isUnique: false,
+    isMeta: true
   }) {
-    this.bootstrap();
-    this.validateName(name);
-    return new MetaTask(
-      name,
-      func,
-      description,
-      options.concurrency,
-      options.timeout,
-      options.register
-    );
+    options.isMeta = true;
+    return this.createTask(name, func, description, options);
   }
   /**
    * Creates a UniqueTask (executes once per execution ID, merging parents) and registers it.
@@ -2436,18 +2432,12 @@ var Cadenza = class {
   static createUniqueTask(name, func, description, options = {
     concurrency: 0,
     timeout: 0,
-    register: true
+    register: true,
+    isUnique: true,
+    isMeta: false
   }) {
-    this.bootstrap();
-    this.validateName(name);
-    return new UniqueTask(
-      name,
-      func,
-      description,
-      options.concurrency,
-      options.timeout,
-      options.register
-    );
+    options.isUnique = true;
+    return this.createTask(name, func, description, options);
   }
   /**
    * Creates a UniqueMetaTask for meta-layer joins.
@@ -2460,18 +2450,12 @@ var Cadenza = class {
   static createUniqueMetaTask(name, func, description, options = {
     concurrency: 0,
     timeout: 0,
-    register: true
+    register: true,
+    isUnique: true,
+    isMeta: true
   }) {
-    this.bootstrap();
-    this.validateName(name);
-    return new UniqueMetaTask(
-      name,
-      func,
-      description,
-      options.concurrency,
-      options.timeout,
-      options.register
-    );
+    options.isMeta = true;
+    return this.createUniqueTask(name, func, description, options);
   }
   /**
    * Creates a ThrottledTask (rate-limited by concurrency or custom groups) and registers it.
@@ -2486,7 +2470,9 @@ var Cadenza = class {
   static createThrottledTask(name, func, throttledIdGetter, description, options = {
     concurrency: 1,
     timeout: 0,
-    register: true
+    register: true,
+    isUnique: false,
+    isMeta: false
   }) {
     this.bootstrap();
     this.validateName(name);
@@ -2497,7 +2483,9 @@ var Cadenza = class {
       throttledIdGetter,
       options.concurrency,
       options.timeout,
-      options.register
+      options.register,
+      options.isUnique,
+      options.isMeta
     );
   }
   /**
@@ -2512,18 +2500,17 @@ var Cadenza = class {
   static createThrottledMetaTask(name, func, throttledIdGetter, description, options = {
     concurrency: 0,
     timeout: 0,
-    register: true
+    register: true,
+    isUnique: false,
+    isMeta: true
   }) {
-    this.bootstrap();
-    this.validateName(name);
-    return new ThrottledMetaTask(
+    options.isMeta = true;
+    return this.createThrottledTask(
       name,
       func,
-      description,
       throttledIdGetter,
-      options.concurrency,
-      options.timeout,
-      options.register
+      description,
+      options
     );
   }
   /**
@@ -2541,7 +2528,9 @@ var Cadenza = class {
     timeout: 0,
     register: true,
     leading: false,
-    trailing: true
+    trailing: true,
+    isUnique: false,
+    isMeta: false
   }) {
     this.bootstrap();
     this.validateName(name);
@@ -2554,7 +2543,9 @@ var Cadenza = class {
       options.trailing,
       options.concurrency,
       options.timeout,
-      options.register
+      options.register,
+      options.isUnique,
+      options.isMeta
     );
   }
   /**
@@ -2571,20 +2562,17 @@ var Cadenza = class {
     timeout: 0,
     register: true,
     leading: false,
-    trailing: true
+    trailing: true,
+    isUnique: false,
+    isMeta: false
   }) {
-    this.bootstrap();
-    this.validateName(name);
-    return new DebouncedMetaTask(
+    options.isMeta = true;
+    return this.createDebounceTask(
       name,
       func,
       description,
       debounceTime,
-      options.leading,
-      options.trailing,
-      options.concurrency,
-      options.timeout,
-      options.register
+      options
     );
   }
   /**
@@ -2602,7 +2590,9 @@ var Cadenza = class {
   static createEphemeralTask(name, func, description, once = true, destroyCondition = () => true, options = {
     concurrency: 0,
     timeout: 0,
-    register: true
+    register: true,
+    isUnique: false,
+    isMeta: false
   }) {
     this.bootstrap();
     this.validateName(name);
@@ -2614,7 +2604,9 @@ var Cadenza = class {
       destroyCondition,
       options.concurrency,
       options.timeout,
-      options.register
+      options.register,
+      options.isUnique,
+      options.isMeta
     );
   }
   /**
@@ -2632,17 +2624,14 @@ var Cadenza = class {
     timeout: 0,
     register: true
   }) {
-    this.bootstrap();
-    this.validateName(name);
-    return new EphemeralMetaTask(
+    options.isMeta = true;
+    return this.createEphemeralTask(
       name,
       func,
       description,
       once,
       destroyCondition,
-      options.concurrency,
-      options.timeout,
-      options.register
+      options
     );
   }
   /**
@@ -2672,9 +2661,9 @@ var Cadenza = class {
     this.bootstrap();
     this.validateName(name);
     if (tasks.length === 0) {
-      console.warn(`MetaRoutine '${name}' created with no starting tasks.`);
+      console.warn(`Routine '${name}' created with no starting tasks (no-op).`);
     }
-    return new MetaRoutine(name, tasks, description);
+    return new GraphRoutine(name, tasks, description, true);
   }
   static reset() {
     var _a, _b;
@@ -2692,11 +2681,11 @@ var SignalTask = class extends Task {
   }
 };
 
-// src/graph/definition/meta/SignalMetaTask.ts
-var SignalMetaTask = class extends SignalTask {
+// src/graph/definition/UniqueTask.ts
+var UniqueTask = class extends Task {
   constructor() {
     super(...arguments);
-    this.isMeta = true;
+    this.isUnique = true;
   }
 };
 
@@ -2705,22 +2694,16 @@ var index_default = Cadenza;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DebounceTask,
-  DebouncedMetaTask,
-  EphemeralMetaTask,
   EphemeralTask,
   GraphContext,
   GraphRegistry,
   GraphRoutine,
-  MetaRoutine,
-  MetaTask,
+  GraphRun,
   SignalEmitter,
-  SignalMetaTask,
   SignalParticipant,
   SignalTask,
   Task,
-  ThrottledMetaTask,
   ThrottledTask,
-  UniqueMetaTask,
   UniqueTask
 });
 //# sourceMappingURL=index.js.map