@triggery/core 0.1.0

package/dist/index.js

@@ -0,0 +1,846 @@
+// src/check.ts
+function createCheck(conditions) {
+  return {
+    is(key, predicate) {
+      const value = conditions[key];
+      if (value === void 0 || value === null) return false;
+      return predicate(value);
+    },
+    all(map) {
+      for (const key of Object.keys(map)) {
+        const predicate = map[key];
+        if (!predicate) continue;
+        const value = conditions[key];
+        if (value === void 0 || value === null) return false;
+        if (!predicate(value)) return false;
+      }
+      return true;
+    },
+    any(map) {
+      for (const key of Object.keys(map)) {
+        const predicate = map[key];
+        if (!predicate) continue;
+        const value = conditions[key];
+        if (value === void 0 || value === null) continue;
+        if (predicate(value)) return true;
+      }
+      return false;
+    }
+  };
+}
+
+// src/cascadeContext.ts
+var current = null;
+function getCurrentDispatch() {
+  return current;
+}
+function withDispatch(ctx, fn) {
+  const prev = current;
+  current = ctx;
+  try {
+    return fn();
+  } finally {
+    current = prev;
+  }
+}
+function chainHas(ctx, triggerId) {
+  let cur = ctx ?? null;
+  while (cur) {
+    if (cur.triggerId === triggerId) return true;
+    cur = cur.parent;
+  }
+  return false;
+}
+
+// src/dispatch.ts
+var runIdCounter = 0;
+var genRunId = () => `run_${(++runIdCounter).toString(36)}`;
+function needsTiming(middleware) {
+  for (const mw of middleware) {
+    if (mw.onActionEnd || mw.onError || mw.onActionStart) return true;
+  }
+  return false;
+}
+var nowMs = () => Date.now();
+function cancelAllTimers(trigger) {
+  for (const entry of trigger.timers.values()) {
+    if (entry.kind === "debounce" || entry.kind === "defer") {
+      clearTimeout(entry.tid);
+    }
+  }
+  trigger.timers.clear();
+}
+function invokeAction(handler, ctx, middleware, trackTiming) {
+  const startedAt = trackTiming ? performance.now() : 0;
+  for (const mw of middleware) mw.onActionStart?.(ctx);
+  try {
+    const result = handler(ctx.payload);
+    if (result && typeof result.then === "function") {
+      result.then(
+        (value) => {
+          for (const mw of middleware) {
+            mw.onActionEnd?.({
+              ...ctx,
+              durationMs: trackTiming ? performance.now() - startedAt : 0,
+              result: value
+            });
+          }
+        },
+        (error) => {
+          for (const mw of middleware) mw.onError?.({ ...ctx, error });
+        }
+      );
+    } else {
+      for (const mw of middleware) {
+        mw.onActionEnd?.({
+          ...ctx,
+          durationMs: trackTiming ? performance.now() - startedAt : 0,
+          result
+        });
+      }
+    }
+  } catch (error) {
+    for (const mw of middleware) mw.onError?.({ ...ctx, error });
+  }
+}
+function executeTrigger(deps) {
+  const { trigger } = deps;
+  if (!trigger.enabled) return;
+  const concurrency = trigger.config.concurrency ?? "take-latest";
+  if (concurrency === "queue") {
+    trigger.queueTail = trigger.queueTail.then(() => runHandler(deps, concurrency)).catch(() => {
+    });
+    return;
+  }
+  return runHandler(deps, concurrency);
+}
+var EMPTY_STRING_ARRAY = Object.freeze([]);
+function runHandler(deps, concurrency) {
+  const {
+    trigger,
+    fireCtx,
+    inspector,
+    inspectorEnabled,
+    middleware,
+    hasMiddleware,
+    trackTiming,
+    runtimeId
+  } = deps;
+  if (!trigger.enabled) return;
+  if (hasMiddleware) {
+    const matchCtx = {
+      triggerId: trigger.config.id,
+      eventName: fireCtx.eventName,
+      payload: fireCtx.payload,
+      cascadeDepth: fireCtx.cascadeDepth
+    };
+    for (const mw of middleware) mw.onBeforeMatch?.(matchCtx);
+  }
+  if (concurrency === "take-first" || concurrency === "exhaust") {
+    if (trigger.inFlight.size > 0) {
+      const reason = `concurrency-${concurrency}`;
+      if (hasMiddleware) {
+        const skipCtx = {
+          triggerId: trigger.config.id,
+          eventName: fireCtx.eventName,
+          reason
+        };
+        for (const mw of middleware) mw.onSkip?.(skipCtx);
+      }
+      if (inspectorEnabled) {
+        inspector.record({
+          triggerId: trigger.config.id,
+          runId: genRunId(),
+          eventName: fireCtx.eventName,
+          status: "skipped",
+          reason,
+          durationMs: 0,
+          executedActions: EMPTY_STRING_ARRAY,
+          snapshotKeys: EMPTY_STRING_ARRAY
+        });
+      }
+      return;
+    }
+  }
+  if (concurrency === "take-latest" && trigger.inFlight.size > 0) {
+    for (const prev of trigger.inFlight) prev.abort("superseded-by-latest");
+    trigger.inFlight.clear();
+  }
+  const runId = genRunId();
+  const needDuration = inspectorEnabled || trackTiming;
+  const startedAt = needDuration ? performance.now() : 0;
+  const required = trigger.config.required;
+  if (required.length > 0) {
+    for (let i = 0; i < required.length; i++) {
+      const requiredName = required[i];
+      if (!trigger.conditions.has(requiredName)) {
+        const reason = `missing-required-condition:${requiredName}`;
+        if (hasMiddleware) {
+          const skipCtx = {
+            triggerId: trigger.config.id,
+            eventName: fireCtx.eventName,
+            reason
+          };
+          for (const mw of middleware) mw.onSkip?.(skipCtx);
+        }
+        if (inspectorEnabled) {
+          inspector.record({
+            triggerId: trigger.config.id,
+            runId,
+            eventName: fireCtx.eventName,
+            status: "skipped",
+            reason,
+            durationMs: needDuration ? performance.now() - startedAt : 0,
+            executedActions: EMPTY_STRING_ARRAY,
+            snapshotKeys: EMPTY_STRING_ARRAY
+          });
+        }
+        return;
+      }
+    }
+  }
+  const executedActions = inspectorEnabled ? [] : EMPTY_STRING_ARRAY;
+  const snapshotKeys = inspectorEnabled ? [] : EMPTY_STRING_ARRAY;
+  const snapshotCache = /* @__PURE__ */ new Map();
+  const conditionsProxy = new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop !== "string") return void 0;
+      if (snapshotCache.has(prop)) return snapshotCache.get(prop);
+      const getter = trigger.conditions.get(prop);
+      if (!getter) {
+        snapshotCache.set(prop, void 0);
+        return void 0;
+      }
+      const value = getter();
+      snapshotCache.set(prop, value);
+      if (inspectorEnabled) snapshotKeys.push(prop);
+      return value;
+    },
+    has(_target, prop) {
+      return typeof prop === "string" && trigger.conditions.has(prop);
+    },
+    ownKeys() {
+      return Array.from(trigger.conditions.keys());
+    },
+    getOwnPropertyDescriptor() {
+      return { enumerable: true, configurable: true };
+    }
+  });
+  const callActionImmediate = (name, payload) => {
+    const handler = trigger.actions.get(name);
+    if (!handler) return;
+    if (inspectorEnabled) executedActions.push(name);
+    invokeAction(
+      handler,
+      { triggerId: trigger.config.id, runId, actionName: name, payload },
+      middleware,
+      trackTiming
+    );
+  };
+  const callActionDeferred = (name, payload) => {
+    if (!trigger.enabled) return;
+    const handler = trigger.actions.get(name);
+    if (!handler) return;
+    invokeAction(
+      handler,
+      { triggerId: trigger.config.id, runId, actionName: name, payload },
+      middleware,
+      trackTiming
+    );
+  };
+  const buildTimedProxy = (kind, ms) => new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop !== "string") return void 0;
+      if (!trigger.actions.has(prop)) return void 0;
+      return (payload) => {
+        if (kind === "debounce") {
+          const key = `debounce:${prop}:${ms}`;
+          const existing = trigger.timers.get(key);
+          if (existing?.kind === "debounce") clearTimeout(existing.tid);
+          const tid = setTimeout(() => {
+            trigger.timers.delete(key);
+            callActionDeferred(prop, payload);
+          }, ms);
+          trigger.timers.set(key, { kind: "debounce", tid });
+        } else if (kind === "throttle") {
+          const key = `throttle:${prop}:${ms}`;
+          const existing = trigger.timers.get(key);
+          const now = nowMs();
+          if (existing?.kind === "throttle" && now - existing.lastFiredAt < ms) return;
+          trigger.timers.set(key, { kind: "throttle", lastFiredAt: now });
+          callActionDeferred(prop, payload);
+        } else {
+          const key = `defer:${prop}:${++trigger.deferCounter}`;
+          const tid = setTimeout(() => {
+            trigger.timers.delete(key);
+            callActionDeferred(prop, payload);
+          }, ms);
+          trigger.timers.set(key, { kind: "defer", tid });
+        }
+      };
+    },
+    has(_target, prop) {
+      return typeof prop === "string" && trigger.actions.has(prop);
+    }
+  });
+  const actionsProxy = new Proxy({}, {
+    get(_target, prop) {
+      if (prop === "debounce") return (ms) => buildTimedProxy("debounce", ms);
+      if (prop === "throttle") return (ms) => buildTimedProxy("throttle", ms);
+      if (prop === "defer") return (ms) => buildTimedProxy("defer", ms);
+      if (typeof prop !== "string") return void 0;
+      if (!trigger.actions.has(prop)) return void 0;
+      return (payload) => callActionImmediate(prop, payload);
+    },
+    has(_target, prop) {
+      return typeof prop === "string" && trigger.actions.has(prop);
+    }
+  });
+  const controller = new AbortController();
+  trigger.inFlight.add(controller);
+  const handlerCtx = {
+    event: { name: fireCtx.eventName, payload: fireCtx.payload },
+    conditions: conditionsProxy,
+    actions: actionsProxy,
+    check: createCheck(conditionsProxy),
+    meta: {
+      runId,
+      triggerId: trigger.config.id,
+      scheduledAt: startedAt,
+      cascadeDepth: fireCtx.cascadeDepth,
+      ...fireCtx.parentRunId !== void 0 && { parentRunId: fireCtx.parentRunId },
+      ...fireCtx.parentTriggerId !== void 0 && { parentTriggerId: fireCtx.parentTriggerId }
+    },
+    signal: controller.signal
+  };
+  const finalize = (status, reason) => {
+    trigger.inFlight.delete(controller);
+    if (!inspectorEnabled) return;
+    const snapshot = {
+      triggerId: trigger.config.id,
+      runId,
+      eventName: fireCtx.eventName,
+      status,
+      durationMs: needDuration ? performance.now() - startedAt : 0,
+      executedActions,
+      snapshotKeys
+    };
+    if (reason !== void 0) snapshot.reason = reason;
+    inspector.record(snapshot);
+  };
+  try {
+    const result = withDispatch(
+      {
+        runtimeId,
+        triggerId: trigger.config.id,
+        runId,
+        cascadeDepth: fireCtx.cascadeDepth,
+        parent: fireCtx.parentContext ?? null
+      },
+      () => trigger.config.handler(handlerCtx)
+    );
+    if (result && typeof result.then === "function") {
+      return result.then(
+        () => finalize("fired"),
+        (error) => {
+          if (controller.signal.aborted) {
+            finalize("aborted", String(controller.signal.reason ?? "aborted"));
+            return;
+          }
+          console.error(`[triggery] handler "${trigger.config.id}" failed:`, error);
+          finalize("errored", String(error));
+        }
+      );
+    }
+    finalize("fired");
+  } catch (error) {
+    console.error(`[triggery] handler "${trigger.config.id}" failed:`, error);
+    finalize("errored", String(error));
+  }
+  return void 0;
+}
+
+// src/inspector.ts
+var EMPTY_BUFFER = Object.freeze(
+  []
+);
+var NOOP_UNSUBSCRIBE = () => {
+};
+var NOOP_INSPECTOR = {
+  record() {
+  },
+  getBuffer() {
+    return EMPTY_BUFFER;
+  },
+  getLastForTrigger() {
+    return void 0;
+  },
+  subscribe() {
+    return NOOP_UNSUBSCRIBE;
+  },
+  clear() {
+  }
+};
+function createNoopInspector() {
+  return NOOP_INSPECTOR;
+}
+function createInspector(bufferSize) {
+  const size = Math.max(1, bufferSize);
+  const slots = new Array(size);
+  let head = 0;
+  let count = 0;
+  const lastByTrigger = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    record(snapshot) {
+      slots[head] = snapshot;
+      head = head + 1 === size ? 0 : head + 1;
+      if (count < size) count++;
+      lastByTrigger.set(snapshot.triggerId, snapshot);
+      if (listeners.size > 0) {
+        for (const listener of listeners) {
+          try {
+            listener(snapshot);
+          } catch {
+          }
+        }
+      }
+    },
+    getBuffer() {
+      if (count === 0) return [];
+      const out = new Array(count);
+      let idx = head === 0 ? size - 1 : head - 1;
+      for (let i = 0; i < count; i++) {
+        out[i] = slots[idx];
+        idx = idx === 0 ? size - 1 : idx - 1;
+      }
+      return out;
+    },
+    getLastForTrigger(triggerId) {
+      return lastByTrigger.get(triggerId);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    clear() {
+      for (let i = 0; i < size; i++) slots[i] = void 0;
+      head = 0;
+      count = 0;
+      lastByTrigger.clear();
+    }
+  };
+}
+
+// src/scheduler.ts
+function createMicrotaskScheduler() {
+  let queue = [];
+  let scheduled = false;
+  const flush = () => {
+    scheduled = false;
+    if (queue.length === 0) return;
+    const tasks = queue;
+    queue = [];
+    for (const task of tasks) {
+      try {
+        task();
+      } catch (error) {
+        console.error("[triggery] scheduler task failed:", error);
+      }
+    }
+  };
+  return {
+    enqueue(task) {
+      queue.push(task);
+      if (!scheduled) {
+        scheduled = true;
+        queueMicrotask(flush);
+      }
+    },
+    flush
+  };
+}
+function createSyncScheduler() {
+  return {
+    enqueue(task) {
+      task();
+    },
+    flush() {
+    }
+  };
+}
+function createScheduler(strategy) {
+  return strategy === "sync" ? createSyncScheduler() : createMicrotaskScheduler();
+}
+
+// src/runtime.ts
+var runtimeIdCounter = 0;
+var genRuntimeId = () => `runtime_${(++runtimeIdCounter).toString(36)}`;
+var isDev = () => {
+  const env = globalThis.process?.env?.NODE_ENV;
+  return env !== "production";
+};
+function resolveInspectorEnabled(option) {
+  if (option === true) return true;
+  if (option === false) return false;
+  const dev = isDev();
+  if (option === void 0) return dev;
+  if (dev) return option.dev ?? true;
+  return option.prod ?? false;
+}
+function createRuntime(options = {}) {
+  const id = genRuntimeId();
+  const triggers = /* @__PURE__ */ new Map();
+  const eventIndex = /* @__PURE__ */ new Map();
+  const middleware = options.middleware ?? [];
+  const hasMiddleware = middleware.length > 0;
+  const trackTiming = needsTiming(middleware);
+  const maxCascadeDepth = options.maxCascadeDepth ?? 3;
+  const inspectorEnabled = resolveInspectorEnabled(options.inspector);
+  const inspector = inspectorEnabled ? createInspector(options.inspectorBufferSize ?? 50) : createNoopInspector();
+  const microtaskScheduler = createScheduler("microtask");
+  const syncScheduler = createScheduler("sync");
+  const warnedCollisions = /* @__PURE__ */ new Set();
+  const indexEvent = (eventName, trigger) => {
+    let set = eventIndex.get(eventName);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      eventIndex.set(eventName, set);
+    }
+    set.add(trigger);
+  };
+  const deindexEvent = (eventName, trigger) => {
+    const set = eventIndex.get(eventName);
+    if (!set) return;
+    set.delete(trigger);
+    if (set.size === 0) eventIndex.delete(eventName);
+  };
+  const registerTrigger = (config) => {
+    if (triggers.has(config.id)) {
+      const existing = triggers.get(config.id);
+      if (existing) {
+        for (const eventName of existing.config.events) deindexEvent(eventName, existing);
+        cancelAllTimers(existing);
+        for (const prev of existing.inFlight) prev.abort("trigger-replaced");
+        existing.inFlight.clear();
+      }
+    }
+    const registered = {
+      config,
+      conditions: /* @__PURE__ */ new Map(),
+      actions: /* @__PURE__ */ new Map(),
+      conditionStacks: /* @__PURE__ */ new Map(),
+      actionStacks: /* @__PURE__ */ new Map(),
+      enabled: true,
+      inFlight: /* @__PURE__ */ new Set(),
+      queueTail: Promise.resolve(),
+      timers: /* @__PURE__ */ new Map(),
+      deferCounter: 0
+    };
+    triggers.set(config.id, registered);
+    for (const eventName of config.events) indexEvent(eventName, registered);
+    let unregistered = false;
+    return {
+      unregister() {
+        if (unregistered) return;
+        unregistered = true;
+        const current2 = triggers.get(config.id);
+        if (current2 !== registered) return;
+        for (const eventName of registered.config.events) deindexEvent(eventName, registered);
+        cancelAllTimers(registered);
+        for (const ctl of registered.inFlight) ctl.abort("trigger-disposed");
+        registered.inFlight.clear();
+        triggers.delete(config.id);
+      }
+    };
+  };
+  const registerStacked = (triggerId, name, fn, label, scope) => {
+    const trigger = triggers.get(triggerId);
+    if (!trigger) {
+      if (isDev()) {
+        console.warn(
+          `[triggery] register${label === "condition" ? "Condition" : "Action"}: trigger "${triggerId}" not found`
+        );
+      }
+      return { unregister() {
+      } };
+    }
+    if (trigger.config.scope !== scope) {
+      if (isDev()) {
+        const collisionKey = `scope-mismatch:${label}:${triggerId}:${scope}:${name}`;
+        if (!warnedCollisions.has(collisionKey)) {
+          warnedCollisions.add(collisionKey);
+          console.warn(
+            `[triggery] register${label === "condition" ? "Condition" : "Action"}: scope mismatch \u2014 trigger "${triggerId}" has scope "${trigger.config.scope || "(global)"}" but the registration came from scope "${scope || "(global)"}". The registration is ignored.`
+          );
+        }
+      }
+      return { unregister() {
+      } };
+    }
+    const stacks = label === "condition" ? trigger.conditionStacks : trigger.actionStacks;
+    const mirror = label === "condition" ? trigger.conditions : trigger.actions;
+    let stack = stacks.get(name);
+    if (!stack) {
+      stack = [];
+      stacks.set(name, stack);
+    }
+    if (isDev() && stack.length > 0) {
+      const collisionKey = `${label}:${triggerId}:${name}`;
+      if (!warnedCollisions.has(collisionKey)) {
+        warnedCollisions.add(collisionKey);
+        console.warn(
+          `[triggery] multiple ${label} registrations for "${name}" on trigger "${triggerId}" \u2014 last-mount-wins. To compose values from several sources, register through a single hook.`
+        );
+      }
+    }
+    stack.push(fn);
+    mirror.set(name, fn);
+    let unregistered = false;
+    return {
+      unregister() {
+        if (unregistered) return;
+        unregistered = true;
+        const t = triggers.get(triggerId);
+        if (!t) return;
+        const liveStacks = label === "condition" ? t.conditionStacks : t.actionStacks;
+        const liveMirror = label === "condition" ? t.conditions : t.actions;
+        const liveStack = liveStacks.get(name);
+        if (!liveStack) return;
+        for (let i = liveStack.length - 1; i >= 0; i--) {
+          if (liveStack[i] === fn) {
+            liveStack.splice(i, 1);
+            break;
+          }
+        }
+        if (liveStack.length === 0) {
+          liveStacks.delete(name);
+          liveMirror.delete(name);
+        } else {
+          liveMirror.set(name, liveStack[liveStack.length - 1]);
+        }
+      }
+    };
+  };
+  const registerCondition = (triggerId, name, getter, options2) => registerStacked(triggerId, name, getter, "condition", options2?.scope ?? "");
+  const registerAction = (triggerId, name, handler, options2) => registerStacked(triggerId, name, handler, "action", options2?.scope ?? "");
+  const emitCascade = (info) => {
+    for (const mw of middleware) mw.onCascade?.(info);
+  };
+  const buildFireContext = (eventName, payload) => {
+    const parent = getCurrentDispatch();
+    if (parent && parent.runtimeId === id) {
+      return {
+        eventName,
+        payload,
+        cascadeDepth: parent.cascadeDepth + 1,
+        parentRunId: parent.runId,
+        parentTriggerId: parent.triggerId,
+        parentContext: parent
+      };
+    }
+    return { eventName, payload, cascadeDepth: 0 };
+  };
+  const dispatch = (fireCtx, opts) => {
+    if (hasMiddleware) {
+      for (const mw of middleware) {
+        const result = mw.onFire?.(fireCtx);
+        if (result?.cancel) return;
+      }
+    }
+    if (fireCtx.cascadeDepth > maxCascadeDepth) {
+      emitCascade({
+        parentTriggerId: fireCtx.parentTriggerId ?? "",
+        parentRunId: fireCtx.parentRunId ?? "",
+        newEventName: fireCtx.eventName,
+        cascadeDepth: fireCtx.cascadeDepth,
+        kind: "overflow"
+      });
+      return;
+    }
+    const set = eventIndex.get(fireCtx.eventName);
+    if (!set || set.size === 0) return;
+    const triggersForEvent = set.size === 1 ? [set.values().next().value] : Array.from(set);
+    const parentCtx = fireCtx.parentContext;
+    for (const trigger of triggersForEvent) {
+      if (!trigger.enabled) continue;
+      if (parentCtx !== void 0 && chainHas(parentCtx, trigger.config.id)) {
+        emitCascade({
+          parentTriggerId: fireCtx.parentTriggerId ?? "",
+          parentRunId: fireCtx.parentRunId ?? "",
+          newEventName: fireCtx.eventName,
+          cascadeDepth: fireCtx.cascadeDepth,
+          kind: "cycle"
+        });
+        continue;
+      }
+      const run = () => {
+        executeTrigger({
+          trigger,
+          fireCtx,
+          inspector,
+          inspectorEnabled,
+          middleware,
+          hasMiddleware,
+          trackTiming,
+          runtimeId: id
+        });
+      };
+      if (opts.forceSync) {
+        run();
+        continue;
+      }
+      const scheduler = trigger.config.schedule === "sync" ? syncScheduler : microtaskScheduler;
+      scheduler.enqueue(run);
+    }
+  };
+  const fire = (eventName, payload) => {
+    dispatch(buildFireContext(eventName, payload), { forceSync: false });
+  };
+  const fireSync = (eventName, payload) => {
+    dispatch(buildFireContext(eventName, payload), { forceSync: true });
+  };
+  const subscribe = (listener) => {
+    const off = inspector.subscribe(listener);
+    let unregistered = false;
+    return {
+      unregister() {
+        if (unregistered) return;
+        unregistered = true;
+        off();
+      }
+    };
+  };
+  const getInspectorBuffer = () => inspector.getBuffer();
+  const getTrigger = (triggerId) => {
+    const trigger = triggers.get(triggerId);
+    if (!trigger) return void 0;
+    return buildPublicTrigger(trigger, inspector);
+  };
+  const graph = () => {
+    const nodes = [];
+    for (const t of triggers.values()) {
+      nodes.push({
+        id: t.config.id,
+        scope: t.config.scope,
+        events: t.config.events,
+        required: t.config.required,
+        schedule: t.config.schedule,
+        concurrency: t.config.concurrency,
+        enabled: t.enabled
+      });
+    }
+    const idx = {};
+    for (const [eventName, triggerSet] of eventIndex) {
+      idx[eventName] = Array.from(triggerSet).map((t) => t.config.id);
+    }
+    return { triggers: nodes, eventIndex: idx };
+  };
+  const dispose = () => {
+    for (const trigger of triggers.values()) {
+      for (const ctl of trigger.inFlight) ctl.abort("runtime-disposed");
+      trigger.inFlight.clear();
+      cancelAllTimers(trigger);
+      trigger.enabled = false;
+    }
+    triggers.clear();
+    eventIndex.clear();
+    inspector.clear();
+  };
+  return {
+    id,
+    inspectorEnabled,
+    registerTrigger,
+    registerCondition,
+    registerAction,
+    fire,
+    fireSync,
+    subscribe,
+    getInspectorBuffer,
+    getTrigger,
+    graph,
+    dispose
+  };
+}
+function buildPublicTrigger(internal, inspector) {
+  return {
+    id: internal.config.id,
+    schedule: internal.config.schedule,
+    enable() {
+      internal.enabled = true;
+    },
+    disable() {
+      internal.enabled = false;
+    },
+    isEnabled() {
+      return internal.enabled;
+    },
+    namedHooks() {
+      throw new Error("[triggery] namedHooks() can only be called on the original trigger object");
+    },
+    inspect() {
+      return inspector.getLastForTrigger(internal.config.id);
+    },
+    dispose() {
+      internal.enabled = false;
+      for (const ctl of internal.inFlight) ctl.abort("disposed");
+      internal.inFlight.clear();
+      cancelAllTimers(internal);
+    }
+  };
+}
+var _defaultRuntime;
+function getDefaultRuntime() {
+  if (!_defaultRuntime) _defaultRuntime = createRuntime();
+  return _defaultRuntime;
+}
+function setDefaultRuntime(runtime) {
+  _defaultRuntime = runtime;
+}
+
+// src/createTrigger.ts
+function createTrigger(config, runtime = getDefaultRuntime()) {
+  const internalHandler = (ctx) => config.handler(ctx);
+  const internalConfig = {
+    id: config.id,
+    schedule: config.schedule ?? "microtask",
+    concurrency: config.concurrency ?? "take-latest",
+    required: config.required ?? [],
+    events: config.events,
+    scope: config.scope ?? "",
+    handler: internalHandler
+  };
+  const token = runtime.registerTrigger(internalConfig);
+  return {
+    id: config.id,
+    schedule: internalConfig.schedule,
+    enable() {
+      runtime.getTrigger(config.id)?.enable();
+    },
+    disable() {
+      runtime.getTrigger(config.id)?.disable();
+    },
+    isEnabled() {
+      return runtime.getTrigger(config.id)?.isEnabled() ?? false;
+    },
+    inspect() {
+      return runtime.getTrigger(config.id)?.inspect();
+    },
+    dispose() {
+      token.unregister();
+    },
+    namedHooks() {
+      return new Proxy({}, {
+        get(_target, prop) {
+          throw new Error(
+            `[triggery] namedHooks().${String(prop)} requires @triggery/react. Use createNamedHooks(trigger) from '@triggery/react' instead.`
+          );
+        }
+      });
+    }
+  };
+}
+
+export { createCheck, createInspector, createRuntime, createScheduler, createTrigger, getDefaultRuntime, setDefaultRuntime };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map