@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-NS52ISWS.js

@@ -0,0 +1,355 @@
+import {
+  ERROR_CODES,
+  WrongStackError
+} from "./chunk-25LSLC3G.js";
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/kernel/run-controller.ts
+var RunController = class {
+  ctrl = new AbortController();
+  hooks = [];
+  disposed = false;
+  hooksDrained = false;
+  errorSink;
+  /**
+   * Shared promise for the in-flight `runHooks()` call. Set by the abort
+   * signal handler or by `dispose()`, whichever fires first. Both callers
+   * await the same promise so abort-triggered async cleanup (session flush,
+   * socket close) completes before `dispose()` resolves.
+   */
+  _hooksPromise = null;
+  constructor(opts = {}) {
+    this.errorSink = opts.errorSink ?? ((err, where) => {
+      console.warn(JSON.stringify({
+        level: "warn",
+        event: "run.cleanup_hook_failed",
+        where,
+        message: toErrorMessage(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+    });
+    if (opts.parentSignal) {
+      const parent = opts.parentSignal;
+      if (parent.aborted) {
+        this.ctrl.abort(parent.reason);
+        queueMicrotask(() => {
+          void this.runHooks();
+        });
+      } else {
+        const onParentAbort = () => this.ctrl.abort(parent.reason);
+        parent.addEventListener("abort", onParentAbort, { once: true });
+        this.onAbort(() => parent.removeEventListener("abort", onParentAbort));
+      }
+    }
+    this.ctrl.signal.addEventListener(
+      "abort",
+      () => {
+        this.ensureHooksRun();
+      },
+      { once: true }
+    );
+  }
+  get signal() {
+    return this.ctrl.signal;
+  }
+  get aborted() {
+    return this.ctrl.signal.aborted;
+  }
+  abort(reason) {
+    if (this.ctrl.signal.aborted) return;
+    this.ctrl.abort(reason);
+  }
+  /**
+   * Register a teardown hook. Returns an unsubscribe function so callers
+   * can opt out before the hook fires (e.g. when a tool finishes cleanly
+   * before abort happens).
+   *
+   * If the controller has already drained its hooks (a prior abort() or
+   * dispose() ran), the new hook is fired immediately on a best-effort
+   * basis — otherwise a hook registered after teardown would be silently
+   * dropped and the resource it cleans up would leak. The returned
+   * unsubscribe is a no-op in that case (the hook has already run). Errors
+   * from the immediate run are routed through `errorSink` like any other
+   * cleanup failure.
+   */
+  onAbort(fn) {
+    if (this.hooksDrained) {
+      void (async () => {
+        try {
+          await fn();
+        } catch (err) {
+          this.errorSink(err, "RunController.onAbort(post-drain)");
+        }
+      })();
+      return () => {
+      };
+    }
+    this.hooks.push(fn);
+    return () => {
+      const idx = this.hooks.indexOf(fn);
+      if (idx !== -1) this.hooks.splice(idx, 1);
+    };
+  }
+  /**
+   * Fire cleanup hooks and tear down listeners — called when the run
+   * ends *normally* so cleanup happens regardless of outcome. Subsequent
+   * aborts become no-ops.
+   */
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    await this.ensureHooksRun();
+  }
+  /**
+   * Start running hooks (or wait for an already-in-flight run) and return
+   * a promise that settles when all hooks complete. Both the abort signal
+   * handler and `dispose()` call this so they share the same underlying
+   * promise — abort-triggered async cleanup (session flush, socket close)
+   * is guaranteed to finish before `dispose()` resolves.
+   */
+  ensureHooksRun() {
+    if (!this._hooksPromise) {
+      this._hooksPromise = this.runHooks();
+    }
+    return this._hooksPromise;
+  }
+  async runHooks() {
+    if (this.hooksDrained) return;
+    this.hooksDrained = true;
+    const snapshot = this.hooks.splice(0, this.hooks.length).reverse();
+    if (snapshot.length === 0) return;
+    await Promise.allSettled(
+      snapshot.map(
+        (hook) => Promise.resolve().then(() => hook()).catch((err) => {
+          this.errorSink(err, "RunController.dispose");
+        })
+      )
+    );
+  }
+};
+
+// src/kernel/tokens.ts
+var t = (name) => /* @__PURE__ */ Symbol.for(`@wrongstack/core/kernel#${name}`);
+var TOKENS = {
+  Logger: t("Logger"),
+  TokenCounter: t("TokenCounter"),
+  SessionStore: t("SessionStore"),
+  /**
+   * @deprecated Token name retained for compatibility.
+   * The resolved value IS a `MemoryPort`, NOT the legacy `MemoryStore` interface.
+   * Callers that cast or destructure as `MemoryStore` will lose `getCapability`,
+   * `health`, `dispose`, and the narrowed `withTraceId(): MemoryPort` return type.
+   * Port implementations are opaque — query optional features via `getCapability`.
+   * Use `TOKENS.MemoryPort` instead.
+   */
+  MemoryStore: t("MemoryStore"),
+  /** Production memory backend. Use instead of the deprecated `MemoryStore` token. */
+  MemoryPort: t("MemoryPort"),
+  PermissionPolicy: t("PermissionPolicy"),
+  Compactor: t("Compactor"),
+  PathResolver: t("PathResolver"),
+  ConfigLoader: t("ConfigLoader"),
+  ConfigStore: t("ConfigStore"),
+  FallbackProfileManager: t("FallbackProfileManager"),
+  /** Shared (provider, model) health tracker; fallback extensions read/write it. */
+  ProviderModelStatusTracker: t("ProviderModelStatusTracker"),
+  Renderer: t("Renderer"),
+  InputReader: t("InputReader"),
+  ErrorHandler: t("ErrorHandler"),
+  RetryPolicy: t("RetryPolicy"),
+  SkillLoader: t("SkillLoader"),
+  PromptLoader: t("PromptLoader"),
+  SystemPromptBuilder: t("SystemPromptBuilder"),
+  SecretScrubber: t("SecretScrubber"),
+  ModelsRegistry: t("ModelsRegistry"),
+  ModeStore: t("ModeStore"),
+  /** Replaces the entire provider call layer — retry, streaming, tracing. */
+  ProviderRunner: t("ProviderRunner"),
+  /** Optional git-worktree lifecycle manager (per-phase isolation in Goal). */
+  WorktreeManager: t("WorktreeManager"),
+  /** Optional global Brain arbiter for policy/decision escalation. */
+  BrainArbiter: t("BrainArbiter"),
+  /** Lifecycle hook registry (shell + in-process hooks). */
+  HookRegistry: t("HookRegistry")
+};
+
+// src/kernel/pipeline.ts
+var Pipeline = class {
+  chain = [];
+  errorHandler;
+  /**
+   * Optional operational logger. When set, the `swallow` error-boundary path
+   * emits a structured warning so a swallowed middleware crash is never
+   * completely silent (P2 #7, before-release.md). Without a logger, the
+   * swallow path still works but the crash is invisible — host code should
+   * always wire one.
+   */
+  logger;
+  /**
+   * Install an error boundary. When a middleware throws or rejects, the
+   * handler is called and decides whether to swallow (continue with the
+   * pre-handler value) or rethrow. Without a handler, errors propagate.
+   *
+   * Wire one per pipeline at boot — the host CLI typically installs a
+   * single boundary that logs to the operational log and emits a
+   * `pipeline.error` event for /diag.
+   */
+  setErrorHandler(handler) {
+    this.errorHandler = handler;
+    return this;
+  }
+  /**
+   * Set the operational logger used by the swallow error-boundary path.
+   * Without this, a swallowed middleware crash is completely silent.
+   */
+  setLogger(logger) {
+    this.logger = logger;
+    return this;
+  }
+  use(mw) {
+    this.ensureUnique(mw.name);
+    this.chain.push(mw);
+    return this;
+  }
+  prepend(mw) {
+    this.ensureUnique(mw.name);
+    this.chain.unshift(mw);
+    return this;
+  }
+  /**
+   * Insert middleware at an explicit index. Out-of-range indices are clamped.
+   * Use this when insertBefore/insertAfter are insufficient (e.g. to place
+   * a middleware at a known position regardless of named targets).
+   */
+  insertAt(index, mw) {
+    this.ensureUnique(mw.name);
+    const idx = Math.max(0, Math.min(index, this.chain.length));
+    this.chain.splice(idx, 0, mw);
+    return this;
+  }
+  /**
+   * Insert mw immediately before the first occurrence of target.
+   * If called multiple times with the same target, each call inserts
+   * before the target's current position — so after insertBefore('B', X)
+   * then insertBefore('B', Y), the order is Y → X → B.
+   */
+  insertBefore(target, mw, opts) {
+    this.ensureUnique(mw.name);
+    const idx = this.indexOf(target, opts?.optional);
+    if (idx === -1) return this;
+    this.chain.splice(idx, 0, mw);
+    return this;
+  }
+  /**
+   * Insert mw immediately after the first occurrence of target.
+   * If called multiple times with the same target, each call inserts
+   * after the target's current position — so after insertAfter('B', X)
+   * then insertAfter('B', Y), the order is B → X → Y.
+   */
+  insertAfter(target, mw, opts) {
+    this.ensureUnique(mw.name);
+    const idx = this.indexOf(target, opts?.optional);
+    if (idx === -1) return this;
+    this.chain.splice(idx + 1, 0, mw);
+    return this;
+  }
+  replace(target, mw, opts) {
+    if (mw.name !== target) this.ensureUnique(mw.name);
+    const idx = this.indexOf(target, opts?.optional);
+    if (idx === -1) return this;
+    this.chain[idx] = mw;
+    return this;
+  }
+  remove(name, opts) {
+    const idx = this.indexOf(name, opts?.optional);
+    if (idx === -1) return this;
+    this.chain.splice(idx, 1);
+    return this;
+  }
+  list() {
+    return this.chain.map((m) => m.name);
+  }
+  size() {
+    return this.chain.length;
+  }
+  /** Return a read-only view suitable for passing to plugins. */
+  asReadonly() {
+    const self = this;
+    const view = Object.freeze({
+      get size() {
+        return self.chain.length;
+      },
+      list() {
+        return Object.freeze(self.chain.map((m) => m.name));
+      },
+      run(input) {
+        return self.run(input);
+      }
+    });
+    return view;
+  }
+  async run(input) {
+    let index = -1;
+    const chain = this.chain;
+    const errorHandler = this.errorHandler;
+    const dispatch = async (i, value) => {
+      if (i <= index) {
+        const offender = chain[index]?.name;
+        throw new WrongStackError({
+          message: `Pipeline: next() called multiple times in "${offender}"`,
+          code: ERROR_CODES.VALIDATION_ERROR,
+          subsystem: "container",
+          context: { middleware: offender }
+        });
+      }
+      index = i;
+      const mw = chain[i];
+      if (!mw) return value;
+      try {
+        return await mw.handler(value, (v) => dispatch(i + 1, v));
+      } catch (err) {
+        if (!errorHandler) throw err;
+        const policy = await errorHandler({ middleware: mw.name, owner: mw.owner, err });
+        if (policy === "rethrow") throw err;
+        this.logger?.warn("pipeline.error", {
+          middleware: mw.name,
+          owner: mw.owner,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return value;
+      }
+    };
+    return dispatch(0, input);
+  }
+  indexOf(name, optional = false) {
+    const idx = this.chain.findIndex((m) => m.name === name);
+    if (idx === -1 && !optional) {
+      throw new WrongStackError({
+        message: `Pipeline: middleware "${name}" not found`,
+        code: ERROR_CODES.REGISTRY_NOT_FOUND,
+        subsystem: "container",
+        context: { middleware: name }
+      });
+    }
+    return idx;
+  }
+  ensureUnique(name) {
+    if (this.chain.some((m) => m.name === name)) {
+      throw new WrongStackError({
+        message: `Pipeline: middleware "${name}" already registered`,
+        code: ERROR_CODES.REGISTRY_DUPLICATE,
+        subsystem: "container",
+        context: { middleware: name }
+      });
+    }
+  }
+};
+
+export {
+  RunController,
+  TOKENS,
+  Pipeline
+};
+//# sourceMappingURL=chunk-NS52ISWS.js.map