@wrongstack/core 0.275.0 → 0.276.2

package/dist/kernel/index.d.ts

@@ -1,21 +1,21 @@
-import { T as Token, a as Renderer, S as SystemPromptBuilder, H as HookRegistry } from '../pipeline-BYR-Vdau.js';
-export { d as BindOptions, C as Container, D as Decorator, F as Factory, b as Middleware, M as MiddlewareHandler, N as NextFn, P as Pipeline, e as PipelineOptions } from '../pipeline-BYR-Vdau.js';
-import { c as MemoryStore, B as BrainArbiter } from '../brain-DCkB5_e7.js';
-export { E as EventBus, m as EventLogger, n as EventMap, a as EventName, L as Listener, v as ScopedEventBus } from '../brain-DCkB5_e7.js';
-import { C as Compactor } from '../compactor-CzSvxM1g.js';
-import { j as ConfigLoader, l as ConfigStore, M as ModelsRegistry } from '../config-BzFRKkg7.js';
-import { E as ErrorHandler, R as RetryPolicy } from '../retry-policy-BmY5ooh3.js';
+import { T as Token, a as Renderer, S as SystemPromptBuilder, H as HookRegistry } from '../pipeline-Dl6XbfE7.js';
+export { d as BindOptions, C as Container, D as Decorator, F as Factory, b as Middleware, M as MiddlewareHandler, N as NextFn, P as Pipeline, e as PipelineOptions } from '../pipeline-Dl6XbfE7.js';
+import { c as MemoryStore, B as BrainArbiter } from '../brain-BLOyN5ZP.js';
+export { E as EventBus, m as EventLogger, n as EventMap, a as EventName, L as Listener, v as ScopedEventBus } from '../brain-BLOyN5ZP.js';
+import { C as Compactor } from '../compactor-DcBpaJsI.js';
+import { j as ConfigLoader, l as ConfigStore, M as ModelsRegistry } from '../config-Bf5mj-ad.js';
+import { E as ErrorHandler, R as RetryPolicy } from '../retry-policy-Dt3_z8Aj.js';
 import { I as InputReader } from '../input-reader-E-ffP2ee.js';
 import { L as Logger } from '../logger-B63L5bTg.js';
 import { M as ModeStore } from '../mode-CZlO9iU1.js';
 import { P as PathResolver } from '../path-resolver-CPRj4bFY.js';
-import { P as PermissionPolicy, S as SecretScrubber } from '../permission-CJR1qfOi.js';
-import { P as ProviderRunner } from '../provider-runner-i7SQXZuC.js';
-import { e as TokenCounter, k as SessionStore } from '../context-BrLe8pJy.js';
+import { P as PermissionPolicy, S as SecretScrubber } from '../permission-BCbQDR2s.js';
+import { P as ProviderRunner } from '../provider-runner-DZ808MSM.js';
+import { e as TokenCounter, k as SessionStore } from '../context-CLnUMW5g.js';
 import { P as PromptLoader } from '../prompt-DLd35n4Q.js';
 import { S as SkillLoader } from '../skill-DGIXCtdv.js';
-import { W as WorktreeManager } from '../worktree-manager-A1Efnvs0.js';
-import '../mailbox-types-_7gaY0Rl.js';
+import { W as WorktreeManager } from '../worktree-manager-DBdl_5rs.js';
+import '../mailbox-types-DTl7bRH3.js';
 import '../observability-D-HZN_mF.js';
 
 declare const TOKENS: {
@@ -84,6 +84,14 @@ declare class RunController {
      * 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: () => void | Promise<void>): () => void;
     /**

package/dist/kernel/index.js

@@ -8,7 +8,11 @@ var ERROR_CODES = {
   // Container / Registry
   CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
   CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
-  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY"};
+  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
+  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
+  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
+  // General
+  VALIDATION_ERROR: "VALIDATION_ERROR"};
 var WrongStackError = class extends Error {
   code;
   subsystem;
@@ -64,6 +68,7 @@ var Container = class {
       factory,
       singleton: opts.singleton ?? true,
       decorators: [],
+      hasCache: false,
       owner: opts.owner ?? "core"
     });
   }
@@ -81,6 +86,7 @@ var Container = class {
       factory,
       singleton: opts.singleton ?? existing.singleton,
       decorators: existing.decorators,
+      hasCache: false,
       owner: opts.owner ?? existing.owner
     });
   }
@@ -96,6 +102,7 @@ var Container = class {
     }
     existing.decorators.push(decorator);
     existing.cache = void 0;
+    existing.hasCache = false;
     existing.owner = `${existing.owner}+${owner}`;
   }
   resolve(token) {
@@ -108,7 +115,7 @@ var Container = class {
         context: { token: token.description }
       });
     }
-    if (entry.singleton && entry.cache !== void 0) {
+    if (entry.singleton && entry.hasCache) {
       return entry.cache;
     }
     if (this.resolving.has(token)) {
@@ -128,6 +135,7 @@ var Container = class {
       }
       if (entry.singleton) {
         entry.cache = value;
+        entry.hasCache = true;
       }
       return value;
     } finally {
@@ -198,7 +206,7 @@ var Container = class {
       owner: entry.owner,
       singleton: entry.singleton,
       decoratorCount: entry.decorators.length,
-      cached: entry.cache !== void 0
+      cached: entry.hasCache
     };
   }
 };
@@ -323,7 +331,12 @@ var Pipeline = class {
     const errorHandler = this.errorHandler;
     const dispatch = async (i, value) => {
       if (i <= index) {
-        throw new Error(`Pipeline: next() called multiple times in "${chain[index]?.name}"`);
+        throw new WrongStackError({
+          message: `Pipeline: next() called multiple times in "${chain[index]?.name}"`,
+          code: ERROR_CODES.VALIDATION_ERROR,
+          subsystem: "container",
+          context: { middleware: chain[index]?.name }
+        });
       }
       index = i;
       const mw = chain[i];
@@ -347,13 +360,23 @@ var Pipeline = class {
   indexOf(name, optional = false) {
     const idx = this.chain.findIndex((m) => m.name === name);
     if (idx === -1 && !optional) {
-      throw new Error(`Pipeline: middleware "${name}" not found`);
+      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 Error(`Pipeline: middleware "${name}" already registered`);
+      throw new WrongStackError({
+        message: `Pipeline: middleware "${name}" already registered`,
+        code: ERROR_CODES.REGISTRY_DUPLICATE,
+        subsystem: "container",
+        context: { middleware: name }
+      });
     }
   }
 };
@@ -376,7 +399,10 @@ var EventBus = class {
     return () => this.off(event, fn);
   }
   off(event, fn) {
-    this.listeners.get(event)?.delete(fn);
+    const set = this.listeners.get(event);
+    if (!set) return;
+    set.delete(fn);
+    if (set.size === 0) this.listeners.delete(event);
   }
   once(event, fn) {
     const wrapper = (payload) => {
@@ -435,8 +461,9 @@ var EventBus = class {
   }
   emit(event, payload) {
     const set = this.listeners.get(event);
-    if (set) {
-      for (const fn of set) {
+    if (set && set.size > 0) {
+      const snapshot = [...set];
+      for (const fn of snapshot) {
         try {
           fn(payload);
         } catch (err) {
@@ -717,8 +744,27 @@ var RunController = class {
    * 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);