@nanobpm/urban 0.52.0 → 0.53.0

package/README.md

@@ -214,31 +214,57 @@ so this works out of the box.
 
 Deployables are discovered by convention: with **no `models`** block in the
 manifest, `@nanobpm/urban` deploys everything under `resources/` — walked
-**shallow, one level deep** (`resources/*` and `resources/<subdir>/*`, never
-deeper). Content type is by extension: `.bpmn`/`.dmn` → BPMN/DMN, `.form` →
-form-js form, anything else → a `GenericScript` resource (this is how agent
-prompts are deployed — see below).
+**recursively**, every file at any depth. Content type is inferred by extension:
+`.bpmn`/`.dmn` → BPMN/DMN, `.form` → form-js form, `.md` → `text/markdown`,
+`.json` → `application/json`, `.txt` → `text/plain`, and anything else → an
+`application/octet-stream` generic resource. Non-model files (`.md`, `.txt`,
+`.json`, unknown) deploy as **generic resources** (this is how agent prompts,
+RPA/script files, etc. are deployed — see below).
 
 ```
 resources/
-  processes/  order.bpmn        ← deployed as a BPMN process
-  decisions/  route.dmn         ← deployed as a DMN decision
-  forms/      approve.form      ← deployed as a form
-  prompts/    review.md         ← deployed as a GenericScript (an agent prompt)
+  processes/  order.bpmn         ← deployed as a BPMN process
+  decisions/  route.dmn          ← deployed as a DMN decision
+  forms/      approve.form       ← deployed as a form
+  prompts/    review.md          ← generic resource, resourceId "prompts/review.md"
+  prompts/pr/ summarize.md       ← generic resource, resourceId "prompts/pr/summarize.md"
 ```
 
 `resources/` is **deploy-only**: everything under it deploys, and nothing outside
 it ever does — so docs (`docs/`, `AGENTS.md`, top-level `*.md`) live **outside**
-`resources/` and are never swept into a deployment. Resources are keyed by their
-**basename** (filename), so two files with the same name in different sub-dirs are
-a **hard error** — rename or relocate one. `urban gen` follows the same
-convention: with no `models`, its `nano:shape`/code-first model scan defaults to a
-**shallow** `resources/` walk — `.bpmn`/`.dmn` directly under `resources/` and one
-level down in `resources/<subdir>/`, never deeper — and derived models are written to
-`resources/processes/`, exactly where the convention deploy then finds them.
+`resources/` and are never swept into a deployment.
+
+A convention resource's **`resourceId` is its path relative to `resources/`**
+(POSIX-normalised), *including the extension* — `resources/prompts/review.md` →
+`prompts/review.md`. Using the relative path (not the bare filename) preserves
+sub-directory structure, so `resources/a/x.md` and `resources/b/x.md` deploy as
+two **distinct** resources (`a/x.md`, `b/x.md`) rather than colliding. A service
+task links a generic resource by that exact id:
+
+```xml
+<zeebe:linkedResource linkName="prompt" resourceType="GenericScript"
+                      bindingType="latest" resourceId="prompts/review.md" />
+```
+
+Content is deployed **verbatim** — there is no deploy-time `{{token}}`
+substitution (removed in ADR 0062), so a prompt/script file's text is deployed
+as-is. The deploy pipeline is **UTF-8 text only**, end-to-end (`host.readTextFile()`
+→ `content: string`), so "verbatim" means the UTF-8 text is passed through
+unchanged — not a promise of byte-for-byte *binary* fidelity; a non-UTF-8/binary
+file swept into `resources/` is not a supported input (`application/octet-stream`
+is only a conservative MIME label for an unrecognised *text* resource).
+Re-deploying an **unchanged** file is a no-op (the engine's
+name+checksum duplicate rule skips it — no version bump); **changing** its
+content deploys a **new version** and the `bindingType:latest` pointer advances,
+so a running process picks up the new prompt on its next job activation with **no
+model redeploy**. `urban gen` follows the same convention: with no `models`, its
+`nano:shape`/code-first model scan also walks `resources/` recursively for
+`.bpmn`/`.dmn`, and derived models are written to `resources/processes/`, exactly
+where the convention deploy then finds them.
 
 To opt out of the convention, declare `models` globs — they are used verbatim and
-the `resources/` walk is skipped:
+the `resources/` walk is skipped (override resources are keyed by basename, so a
+basename collision across the declared globs is a hard error):
 
 ```jsonc
 {
@@ -253,13 +279,14 @@ the `resources/` walk is skipped:
 
 To keep a large agent prompt out of a model's XML, author it as its own file under
 `resources/prompts/` (deployed as a `GenericScript`) and **link** it into the
-service task with a `zeebe:linkedResource` bound to the latest deployed version;
-the runtime resolves it with the `appendPrompt` FEEL helper at execution time:
+service task with a `zeebe:linkedResource` bound to the latest deployed version by
+its relative-path `resourceId`; the runtime resolves it with the `appendPrompt`
+FEEL helper at execution time:
 
 ```xml
-<!-- resources/processes/agent.bpmn -->
+<!-- resources/processes/agent.bpmn, linking resources/prompts/review.md -->
 <zeebe:linkedResource linkName="prompt" resourceType="GenericScript"
-                      bindingType="latest" resourceId="review" />
+                      bindingType="latest" resourceId="prompts/review.md" />
 ```
 
 This is the **only** supported prompt-modularity mechanism — there is no

package/dist/runtime/core/events.d.ts

@@ -0,0 +1,135 @@
+/** Disposes a single registration (idempotent — safe to call more than once). */
+export type Disposer = () => void;
+/** The deliberate dispatch semantics a channel declares. */
+export type DispatchMode = "waterfall" | "serial" | "parallel" | "emit";
+/** A waterfall listener: around-middleware over `next`. Call `next(value)` to
+ *  continue the chain (optionally transforming `value` first), return without
+ *  calling it to short-circuit, or wrap `next(...)` in try/catch to recover. */
+export type Middleware<T, R> = (value: T, next: (value: T) => Promise<R>) => R | Promise<R>;
+/** A serial/parallel/emit listener: observes (and may act on) the payload. Typed
+ *  to return `void` (the DOM/Node listener convention): the void-return position
+ *  lets both an `async` handler (its `Promise<void>` is awaited by serial/parallel
+ *  dispatch) and a value-returning one-liner register without friction. */
+export type Listener<T> = (payload: T) => void;
+/** Where contained listener throws are reported. */
+export type ErrorSink = (err: unknown, info: {
+    event: string;
+    mode: DispatchMode;
+}) => void;
+export interface EventBusOptions {
+    /** Reports a contained listener throw. Defaults to `console.warn`. The runtime
+     *  injects `host.log("warn", …)` so contained throws land in structured logs. */
+    onError?: ErrorSink;
+}
+/** An ordered set of listeners plus the ladder bookkeeping shared by channels. A
+ *  channel owns one of these; the bus owns the global dispose ladder that every
+ *  channel pushes its per-listener disposers onto. */
+declare class ChannelBase<F> {
+    protected readonly listeners: Map<F, Disposer>;
+    readonly event: string;
+    readonly mode: DispatchMode;
+    private readonly ladder;
+    protected readonly onError: ErrorSink;
+    constructor(event: string, mode: DispatchMode, ladder: Set<Disposer>, onError: ErrorSink);
+    /** Register `listener` as an effect: it joins this channel AND the bus dispose
+     *  ladder. The returned disposer removes it from both and is idempotent.
+     *  Registration is itself idempotent per listener — registering the same
+     *  function twice coalesces to one ladder entry and hands back the *same*
+     *  disposer, so `listenerCount` never drifts from the actual listener set and
+     *  disposing one registration can't silently strand a phantom ladder entry. */
+    protected register(listener: F): Disposer;
+    /** Contain a listener throw at the pipeline boundary. */
+    protected contain(err: unknown): void;
+    /** How many listeners are currently registered (for leak assertions). */
+    get size(): number;
+}
+/** **emit** — synchronous fire-and-forget notifications. */
+export declare class EmitChannel<T> extends ChannelBase<Listener<T>> {
+    on(listener: Listener<T>): Disposer;
+    /** Notify every listener synchronously; a throw is contained, the rest still
+     *  run. A listener may return a promise, but `emit` does not await it — its
+     *  rejection is still contained (fire-and-forget `.catch`) so an `async`
+     *  listener can never surface as an unhandled rejection. Listeners are
+     *  snapshotted at dispatch start (as in `parallel`/`waterfall`), so a listener
+     *  registered mid-emission is not observed until the next `emit`. */
+    emit(payload: T): void;
+}
+/** **serial** — listeners awaited in registration order (ordered checkpoint). */
+export declare class SerialChannel<T> extends ChannelBase<Listener<T>> {
+    on(listener: Listener<T>): Disposer;
+    /** Run every listener in order, awaiting each. A throw is contained and the
+     *  next listener still runs — one failing checkpoint never strands the rest.
+     *  Listeners are snapshotted at dispatch start (as in `parallel`/`waterfall`),
+     *  so a listener registered mid-checkpoint is not observed until the next
+     *  `run`. */
+    run(payload: T): Promise<void>;
+}
+/** **parallel** — fan-out where every listener gets an independent chance. */
+export declare class ParallelChannel<T> extends ChannelBase<Listener<T>> {
+    on(listener: Listener<T>): Disposer;
+    /** Run every listener concurrently and await them all. Each is independently
+     *  contained, so one throw never denies another listener its turn (cf. the
+     *  `session/flush` durability checkpoint). */
+    run(payload: T): Promise<void>;
+}
+/** **waterfall** — around-middleware chain (transform / short-circuit / recover). */
+export declare class WaterfallChannel<T, R> extends ChannelBase<Middleware<T, R>> {
+    on(middleware: Middleware<T, R>): Disposer;
+    /** Compose the middlewares around `base`, outermost-first in registration
+     *  order. A middleware that never calls `next` short-circuits the chain; one
+     *  that throws *without* producing a result is contained and delegated past
+     *  (the chain continues with the unchanged value) so it never strands the
+     *  pipeline. */
+    run(seed: T, base: (value: T) => R | Promise<R>): Promise<R>;
+}
+/** The microkernel: a factory of typed channels sharing one dispose ladder. Each
+ *  channel is created directly (and typed at its call site), so the bus never has
+ *  to store — or cast back — a heterogeneous channel collection. Declare each seam
+ *  exactly once and hold the returned typed reference (see the Urban taxonomy in
+ *  `extensions.ts`); the bus guards against a name being declared twice under a
+ *  different mode. */
+export declare class EventBus {
+    private readonly ladder;
+    private readonly declared;
+    private readonly onError;
+    constructor(options?: EventBusOptions);
+    private reserve;
+    /** Declare an **emit** channel. */
+    emit<T>(event: string): EmitChannel<T>;
+    /** Declare a **serial** channel. */
+    serial<T>(event: string): SerialChannel<T>;
+    /** Declare a **parallel** channel. */
+    parallel<T>(event: string): ParallelChannel<T>;
+    /** Declare a **waterfall** channel. */
+    waterfall<T, R>(event: string): WaterfallChannel<T, R>;
+    /** Open a rollback point over the dispose ladder: returns a disposer that unwinds
+     *  every registration made *after* this call (LIFO), leaving earlier ones intact.
+     *  It makes a unit of work atomic — e.g. one extension's `setup()` — so a throw
+     *  after partial registration can roll back exactly what that unit added and
+     *  nothing else. Contained end-to-end, like `dispose()`; the ladder entries it
+     *  runs are idempotent, so a later `dispose()` won't double-run them. Keeps
+     *  unwinding until no registration made after the scope point remains, so an
+     *  effect a rolled-back disposer registers *during* rollback is still torn down
+     *  rather than stranded live (mirrors `dispose()`). */
+    scope(): Disposer;
+    /** Register an arbitrary disposable effect (a timer, a subscription, a
+     *  registration made elsewhere) directly onto the dispose ladder, so
+     *  `dispose()` unwinds it with everything else — the dispose-ladder contract is
+     *  not limited to channel listeners. Returns an idempotent disposer that detaches
+     *  it (and runs the cleanup) early; a throw from the cleanup is contained. */
+    effect(dispose: Disposer): Disposer;
+    /** Total live registrations on the dispose ladder — every channel listener AND
+     *  every `effect()` (arbitrary disposable), not only channel listeners. This is
+     *  the leak-assertion metric: it reads 0 exactly when the ladder is fully
+     *  unwound. */
+    get listenerCount(): number;
+    /** Unwind the whole dispose ladder LIFO: every registration made through this
+     *  bus is torn down. Contained end-to-end, so one bad disposer can't strand the
+     *  rest. Idempotent — a second call is a no-op. This is what makes a
+     *  `start → stop → start` cycle (and dev-server HMR) leak-free. Keeps unwinding
+     *  until the ladder is empty, so an effect a disposer registers *during*
+     *  teardown is still run rather than silently dropped. */
+    dispose(): void;
+    private contain;
+}
+export {};

package/dist/runtime/core/events.js

@@ -0,0 +1,329 @@
+// events — the Urban extension-event microkernel: a tiny, defensive, typed event
+// bus whose extension points are *typed channels* with a **deliberate dispatch
+// mode**. Cribbed from the DeepSeek Harness Cordis microkernel taxonomy (issue
+// #262): instead of wiring modules directly into `runtime.ts`, a seam is a named
+// channel, and *how* its listeners run is a property of the channel, not of each
+// call site.
+//
+// Four dispatch modes, each for a different kind of seam:
+//
+//   - **waterfall** (around-middleware): a listener wraps `next`, so it can
+//     transform the value, short-circuit (never call `next`), recover (catch a
+//     downstream throw), or wrap the result. For policy / permission / transform
+//     seams.
+//   - **serial**: listeners awaited in registration order — for ordered
+//     checkpoints (e.g. extension registration).
+//   - **parallel**: listeners awaited as a fan-out — every listener gets an
+//     *independent* chance to run (one throw never denies another its turn).
+//   - **emit**: synchronous fire-and-forget — for notifications (lifecycle,
+//     errors, observations).
+//
+// Two contracts make this HMR- and disposal-friendly (the payoff the issue steals
+// from `cordis`):
+//
+//   1. **Defensive dispatch.** A listener exception is *contained* at the pipeline
+//      boundary: the bus warns via `onError` and the pipeline continues — a
+//      throwing extension never strands app boot or a request.
+//   2. **Dispose ladder.** Every registration is an *effect*: `on()` returns a
+//      `Disposer` AND is pushed onto the bus's ladder. `bus.dispose()` unwinds the
+//      whole ladder LIFO, so a `start → stop → start` cycle (or a dev-server HMR
+//      reload) leaks no listeners.
+//
+// This file is runtime-agnostic (core purity): it takes an injected `onError`
+// sink so the host's structured logger, not `console`, reports contained throws.
+const defaultErrorSink = (err, info) => {
+    console.warn(`[urban events] listener for "${info.event}" (${info.mode}) threw and was contained`, err);
+};
+/** Whether a value is a thenable (any promise-like, including non-native / cross-realm
+ *  promises that are not `instanceof Promise`). `Promise.resolve` adopts such a value,
+ *  so routing it through `Promise.resolve(...).catch(...)` contains its rejection. */
+function isThenable(value) {
+    return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+/** An ordered set of listeners plus the ladder bookkeeping shared by channels. A
+ *  channel owns one of these; the bus owns the global dispose ladder that every
+ *  channel pushes its per-listener disposers onto. */
+class ChannelBase {
+    listeners = new Map();
+    event;
+    mode;
+    ladder;
+    onError;
+    constructor(event, mode, ladder, onError) {
+        this.event = event;
+        this.mode = mode;
+        this.ladder = ladder;
+        this.onError = onError;
+    }
+    /** Register `listener` as an effect: it joins this channel AND the bus dispose
+     *  ladder. The returned disposer removes it from both and is idempotent.
+     *  Registration is itself idempotent per listener — registering the same
+     *  function twice coalesces to one ladder entry and hands back the *same*
+     *  disposer, so `listenerCount` never drifts from the actual listener set and
+     *  disposing one registration can't silently strand a phantom ladder entry. */
+    register(listener) {
+        const existing = this.listeners.get(listener);
+        if (existing !== undefined)
+            return existing;
+        let disposed = false;
+        const dispose = () => {
+            if (disposed)
+                return;
+            disposed = true;
+            this.listeners.delete(listener);
+            this.ladder.delete(dispose);
+        };
+        this.listeners.set(listener, dispose);
+        this.ladder.add(dispose);
+        return dispose;
+    }
+    /** Contain a listener throw at the pipeline boundary. */
+    contain(err) {
+        try {
+            this.onError(err, { event: this.event, mode: this.mode });
+        }
+        catch {
+            // The error sink itself must never strand the pipeline.
+        }
+    }
+    /** How many listeners are currently registered (for leak assertions). */
+    get size() {
+        return this.listeners.size;
+    }
+}
+/** **emit** — synchronous fire-and-forget notifications. */
+export class EmitChannel extends ChannelBase {
+    on(listener) {
+        return this.register(listener);
+    }
+    /** Notify every listener synchronously; a throw is contained, the rest still
+     *  run. A listener may return a promise, but `emit` does not await it — its
+     *  rejection is still contained (fire-and-forget `.catch`) so an `async`
+     *  listener can never surface as an unhandled rejection. Listeners are
+     *  snapshotted at dispatch start (as in `parallel`/`waterfall`), so a listener
+     *  registered mid-emission is not observed until the next `emit`. */
+    emit(payload) {
+        for (const listener of [...this.listeners.keys()]) {
+            try {
+                const result = listener(payload);
+                if (isThenable(result)) {
+                    // `Promise.resolve` returns a native Promise unchanged and adopts any other
+                    // thenable, so a non-native promise's rejection is contained too.
+                    Promise.resolve(result).catch((err) => {
+                        this.contain(err);
+                    });
+                }
+            }
+            catch (err) {
+                this.contain(err);
+            }
+        }
+    }
+}
+/** **serial** — listeners awaited in registration order (ordered checkpoint). */
+export class SerialChannel extends ChannelBase {
+    on(listener) {
+        return this.register(listener);
+    }
+    /** Run every listener in order, awaiting each. A throw is contained and the
+     *  next listener still runs — one failing checkpoint never strands the rest.
+     *  Listeners are snapshotted at dispatch start (as in `parallel`/`waterfall`),
+     *  so a listener registered mid-checkpoint is not observed until the next
+     *  `run`. */
+    async run(payload) {
+        for (const listener of [...this.listeners.keys()]) {
+            try {
+                await listener(payload);
+            }
+            catch (err) {
+                this.contain(err);
+            }
+        }
+    }
+}
+/** **parallel** — fan-out where every listener gets an independent chance. */
+export class ParallelChannel extends ChannelBase {
+    on(listener) {
+        return this.register(listener);
+    }
+    /** Run every listener concurrently and await them all. Each is independently
+     *  contained, so one throw never denies another listener its turn (cf. the
+     *  `session/flush` durability checkpoint). */
+    async run(payload) {
+        await Promise.all([...this.listeners.keys()].map(async (listener) => {
+            try {
+                await listener(payload);
+            }
+            catch (err) {
+                this.contain(err);
+            }
+        }));
+    }
+}
+/** **waterfall** — around-middleware chain (transform / short-circuit / recover). */
+export class WaterfallChannel extends ChannelBase {
+    on(middleware) {
+        return this.register(middleware);
+    }
+    /** Compose the middlewares around `base`, outermost-first in registration
+     *  order. A middleware that never calls `next` short-circuits the chain; one
+     *  that throws *without* producing a result is contained and delegated past
+     *  (the chain continues with the unchanged value) so it never strands the
+     *  pipeline. */
+    async run(seed, base) {
+        const middlewares = [...this.listeners.keys()];
+        const dispatch = async (index, value) => {
+            if (index >= middlewares.length)
+                return base(value);
+            const middleware = middlewares[index];
+            let advanced;
+            const next = (forwarded) => {
+                // Advance the chain at most once per middleware invocation: a middleware
+                // that calls next() again gets the same downstream promise, so downstream
+                // side effects never run twice and the first promise is never orphaned.
+                if (advanced === undefined)
+                    advanced = dispatch(index + 1, forwarded);
+                return advanced;
+            };
+            try {
+                return await middleware(value, next);
+            }
+            catch (err) {
+                this.contain(err);
+                // Delegate: honor the downstream result if the middleware already
+                // advanced the chain, else continue past it with the unchanged value.
+                return advanced !== undefined ? advanced : dispatch(index + 1, value);
+            }
+        };
+        return dispatch(0, seed);
+    }
+}
+/** The microkernel: a factory of typed channels sharing one dispose ladder. Each
+ *  channel is created directly (and typed at its call site), so the bus never has
+ *  to store — or cast back — a heterogeneous channel collection. Declare each seam
+ *  exactly once and hold the returned typed reference (see the Urban taxonomy in
+ *  `extensions.ts`); the bus guards against a name being declared twice under a
+ *  different mode. */
+export class EventBus {
+    ladder = new Set();
+    declared = new Map();
+    onError;
+    constructor(options = {}) {
+        this.onError = options.onError ?? defaultErrorSink;
+    }
+    reserve(event, mode) {
+        const existing = this.declared.get(event);
+        if (existing !== undefined) {
+            throw new Error(existing === mode
+                ? `event "${event}" already declared; hold the channel returned by the first declaration`
+                : `event "${event}" already declared as "${existing}"; cannot redeclare as "${mode}"`);
+        }
+        this.declared.set(event, mode);
+    }
+    /** Declare an **emit** channel. */
+    emit(event) {
+        this.reserve(event, "emit");
+        return new EmitChannel(event, "emit", this.ladder, this.onError);
+    }
+    /** Declare a **serial** channel. */
+    serial(event) {
+        this.reserve(event, "serial");
+        return new SerialChannel(event, "serial", this.ladder, this.onError);
+    }
+    /** Declare a **parallel** channel. */
+    parallel(event) {
+        this.reserve(event, "parallel");
+        return new ParallelChannel(event, "parallel", this.ladder, this.onError);
+    }
+    /** Declare a **waterfall** channel. */
+    waterfall(event) {
+        this.reserve(event, "waterfall");
+        return new WaterfallChannel(event, "waterfall", this.ladder, this.onError);
+    }
+    /** Open a rollback point over the dispose ladder: returns a disposer that unwinds
+     *  every registration made *after* this call (LIFO), leaving earlier ones intact.
+     *  It makes a unit of work atomic — e.g. one extension's `setup()` — so a throw
+     *  after partial registration can roll back exactly what that unit added and
+     *  nothing else. Contained end-to-end, like `dispose()`; the ladder entries it
+     *  runs are idempotent, so a later `dispose()` won't double-run them. Keeps
+     *  unwinding until no registration made after the scope point remains, so an
+     *  effect a rolled-back disposer registers *during* rollback is still torn down
+     *  rather than stranded live (mirrors `dispose()`). */
+    scope() {
+        const before = new Set(this.ladder);
+        return () => {
+            for (;;) {
+                let entry;
+                for (const candidate of this.ladder) {
+                    if (!before.has(candidate))
+                        entry = candidate;
+                }
+                if (entry === undefined)
+                    return;
+                this.ladder.delete(entry);
+                try {
+                    entry();
+                }
+                catch (err) {
+                    this.contain(err);
+                }
+            }
+        };
+    }
+    /** Register an arbitrary disposable effect (a timer, a subscription, a
+     *  registration made elsewhere) directly onto the dispose ladder, so
+     *  `dispose()` unwinds it with everything else — the dispose-ladder contract is
+     *  not limited to channel listeners. Returns an idempotent disposer that detaches
+     *  it (and runs the cleanup) early; a throw from the cleanup is contained. */
+    effect(dispose) {
+        let disposed = false;
+        const entry = () => {
+            if (disposed)
+                return;
+            disposed = true;
+            this.ladder.delete(entry);
+            try {
+                dispose();
+            }
+            catch (err) {
+                this.contain(err);
+            }
+        };
+        this.ladder.add(entry);
+        return entry;
+    }
+    /** Total live registrations on the dispose ladder — every channel listener AND
+     *  every `effect()` (arbitrary disposable), not only channel listeners. This is
+     *  the leak-assertion metric: it reads 0 exactly when the ladder is fully
+     *  unwound. */
+    get listenerCount() {
+        return this.ladder.size;
+    }
+    /** Unwind the whole dispose ladder LIFO: every registration made through this
+     *  bus is torn down. Contained end-to-end, so one bad disposer can't strand the
+     *  rest. Idempotent — a second call is a no-op. This is what makes a
+     *  `start → stop → start` cycle (and dev-server HMR) leak-free. Keeps unwinding
+     *  until the ladder is empty, so an effect a disposer registers *during*
+     *  teardown is still run rather than silently dropped. */
+    dispose() {
+        while (this.ladder.size > 0) {
+            const remaining = [...this.ladder];
+            const dispose = remaining[remaining.length - 1];
+            this.ladder.delete(dispose);
+            try {
+                dispose();
+            }
+            catch (err) {
+                this.contain(err);
+            }
+        }
+    }
+    contain(err) {
+        try {
+            this.onError(err, { event: "(bus.dispose)", mode: "emit" });
+        }
+        catch {
+            // never strand teardown
+        }
+    }
+}