agentfootprint 1.23.0 → 2.1.0

package/dist/esm/resilience/withFallback.js

@@ -0,0 +1,106 @@
+/**
+ * withFallback — provider decorator that falls back to a secondary
+ * on error.
+ *
+ * Pattern: Decorator (GoF) — composes two `LLMProvider`s into one.
+ * Role:    Outer ring (Hexagonal). Stacks with `withRetry`:
+ *          `withRetry(withFallback(primary, fallback))` first retries
+ *          the primary, then on exhaustion falls back to the secondary.
+ *
+ * Common pairings:
+ *   • Anthropic primary, OpenAI fallback (vendor outage tolerance)
+ *   • Real provider primary, Mock fallback (degrade gracefully in dev)
+ *   • Premium model primary, cheaper model fallback (cost ceiling)
+ *
+ * `stream()` falls back too — if the primary's stream errors before
+ * yielding any chunks, we restart on the fallback. Once the primary
+ * has yielded chunks the stream is committed — fallback would
+ * duplicate the partial output.
+ */
+/**
+ * Wrap a primary provider with a fallback. Tries primary first; on
+ * error matching the policy, calls the fallback.
+ *
+ * @example
+ *   const provider = withFallback(
+ *     anthropic({ apiKey: A }),
+ *     openai({ apiKey: O }),
+ *     { onFallback: (err) => console.warn('primary failed, falling back:', err) },
+ *   );
+ */
+export function withFallback(primary, fallback, options = {}) {
+    const shouldFallback = options.shouldFallback ?? defaultShouldFallback;
+    const onFallback = options.onFallback;
+    const wrapped = {
+        name: `${primary.name}|${fallback.name}`,
+        async complete(req) {
+            try {
+                return await primary.complete(req);
+            }
+            catch (err) {
+                if (!shouldFallback(err))
+                    throw err;
+                onFallback?.(err);
+                return fallback.complete(req);
+            }
+        },
+    };
+    // Stream fallback — only if the primary stream fails before any
+    // chunk yields. Once a chunk is consumed downstream, restarting
+    // would replay tokens. Yields from primary as long as it's working;
+    // catches errors in the iteration setup or first chunk only.
+    if (primary.stream || fallback.stream) {
+        wrapped.stream = async function* fallbackStream(req) {
+            // No primary stream support → fallback's stream (or its complete-only).
+            if (!primary.stream) {
+                if (fallback.stream)
+                    yield* fallback.stream(req);
+                else
+                    yield* completeAsStream(fallback, req);
+                return;
+            }
+            let yieldedAny = false;
+            try {
+                for await (const chunk of primary.stream(req)) {
+                    yieldedAny = true;
+                    yield chunk;
+                }
+            }
+            catch (err) {
+                if (yieldedAny || !shouldFallback(err))
+                    throw err;
+                onFallback?.(err);
+                if (fallback.stream)
+                    yield* fallback.stream(req);
+                else
+                    yield* completeAsStream(fallback, req);
+            }
+        };
+    }
+    return wrapped;
+}
+// ── Defaults ────────────────────────────────────────────────────────
+function defaultShouldFallback(err) {
+    if (!err || typeof err !== 'object')
+        return true;
+    const e = err;
+    if (e.name === 'AbortError' || e.code === 'ABORT_ERR')
+        return false;
+    return true;
+}
+/**
+ * Synthesize a stream from a non-streaming provider's `complete()`
+ * call: one terminal chunk carrying the whole response. Lets the
+ * fallback chain still satisfy a `stream()` request even when the
+ * fallback only implements `complete()`.
+ */
+async function* completeAsStream(provider, req) {
+    const response = await provider.complete(req);
+    yield {
+        tokenIndex: 0,
+        content: '',
+        done: true,
+        response,
+    };
+}
+//# sourceMappingURL=withFallback.js.map

package/dist/esm/resilience/withFallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withFallback.js","sourceRoot":"","sources":["../../../src/resilience/withFallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAkBH;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAC1B,OAAoB,EACpB,QAAqB,EACrB,UAA+B,EAAE;IAEjC,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,IAAI,qBAAqB,CAAC;IACvE,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAEtC,MAAM,OAAO,GAAgB;QAC3B,IAAI,EAAE,GAAG,OAAO,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,EAAE;QACxC,KAAK,CAAC,QAAQ,CAAC,GAAe;YAC5B,IAAI,CAAC;gBACH,OAAO,MAAM,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YACrC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;oBAAE,MAAM,GAAG,CAAC;gBACpC,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC;gBAClB,OAAO,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YAChC,CAAC;QACH,CAAC;KACF,CAAC;IAEF,gEAAgE;IAChE,gEAAgE;IAChE,oEAAoE;IACpE,6DAA6D;IAC7D,IAAI,OAAO,CAAC,MAAM,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;QACtC,OAAO,CAAC,MAAM,GAAG,KAAK,SAAS,CAAC,CAAC,cAAc,CAAC,GAAe;YAC7D,wEAAwE;YACxE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;gBACpB,IAAI,QAAQ,CAAC,MAAM;oBAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;;oBAC5C,KAAK,CAAC,CAAC,gBAAgB,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;gBAC5C,OAAO;YACT,CAAC;YACD,IAAI,UAAU,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC;gBACH,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;oBAC9C,UAAU,GAAG,IAAI,CAAC;oBAClB,MAAM,KAAK,CAAC;gBACd,CAAC;YACH,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,UAAU,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;oBAAE,MAAM,GAAG,CAAC;gBAClD,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC;gBAClB,IAAI,QAAQ,CAAC,MAAM;oBAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;;oBAC5C,KAAK,CAAC,CAAC,gBAAgB,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC,CAAC;IACJ,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,uEAAuE;AAEvE,SAAS,qBAAqB,CAAC,GAAY;IACzC,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IACjD,MAAM,CAAC,GAAG,GAAuC,CAAC;IAClD,IAAI,CAAC,CAAC,IAAI,KAAK,YAAY,IAAI,CAAC,CAAC,IAAI,KAAK,WAAW;QAAE,OAAO,KAAK,CAAC;IACpE,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,KAAK,SAAS,CAAC,CAAC,gBAAgB,CAAC,QAAqB,EAAE,GAAe;IACrE,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IAC9C,MAAM;QACJ,UAAU,EAAE,CAAC;QACb,OAAO,EAAE,EAAE;QACX,IAAI,EAAE,IAAI;QACV,QAAQ;KACT,CAAC;AACJ,CAAC"}

package/dist/esm/resilience/withRetry.js

@@ -0,0 +1,110 @@
+/**
+ * withRetry — provider decorator that retries failed calls.
+ *
+ * Pattern: Decorator (GoF) — wraps an `LLMProvider` and adds retry
+ *          policy without changing its interface.
+ * Role:    Outer ring (Hexagonal). Composable: `withRetry(withFallback(...))`.
+ *
+ * Retries `complete()` on transient failures with exponential backoff.
+ * `stream()` is delegated as-is — once tokens start flowing the
+ * pipeline is stateful and cannot safely be restarted. If you need
+ * retry semantics for streaming, fall back to `complete()` or
+ * implement custom resumability at the consumer.
+ *
+ * Default policy:
+ *   • maxAttempts: 3 (initial + 2 retries)
+ *   • backoff:     exponential — 200ms, 400ms, 800ms
+ *   • shouldRetry: rejects 4xx-class errors (client mistakes don't
+ *                  benefit from retry) and AbortError; retries 5xx,
+ *                  network errors, and unknown shapes.
+ */
+/**
+ * Wrap a provider so its `complete()` retries transient failures.
+ *
+ * @example
+ *   const robust = withRetry(anthropic({ apiKey }), {
+ *     maxAttempts: 5,
+ *     onRetry: (err, attempt, ms) => console.warn(`retry ${attempt} in ${ms}ms`, err),
+ *   });
+ */
+export function withRetry(provider, options = {}) {
+    const maxAttempts = Math.max(1, options.maxAttempts ?? 3);
+    const initialDelayMs = options.initialDelayMs ?? 200;
+    const backoffFactor = options.backoffFactor ?? 2;
+    const maxDelayMs = options.maxDelayMs ?? 10_000;
+    const shouldRetry = options.shouldRetry ?? defaultShouldRetry;
+    const onRetry = options.onRetry;
+    const wrapped = {
+        name: `${provider.name}+retry`,
+        async complete(req) {
+            let lastError;
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                try {
+                    return await provider.complete(req);
+                }
+                catch (err) {
+                    lastError = err;
+                    if (attempt >= maxAttempts || !shouldRetry(err, attempt)) {
+                        throw err;
+                    }
+                    const delay = Math.min(maxDelayMs, initialDelayMs * Math.pow(backoffFactor, attempt - 1));
+                    onRetry?.(err, attempt + 1, delay);
+                    await sleep(delay, req.signal);
+                }
+            }
+            // Unreachable — last attempt either returned or threw above.
+            throw lastError;
+        },
+    };
+    // Pass-through `stream()` if the underlying provider supports it.
+    // No retry on streams (mid-stream resumption is provider-specific).
+    if (provider.stream) {
+        wrapped.stream = (req) => provider.stream(req);
+    }
+    return wrapped;
+}
+// ── Defaults ────────────────────────────────────────────────────────
+/**
+ * Skip retry for AbortError + 4xx-class errors. Retry on everything
+ * else (network errors, 5xx, unknown shapes). Provider adapters that
+ * surface HTTP status should set `error.status` for this to work; the
+ * predicate falls back to retrying when status is unknown (better to
+ * retry once than to surface a flaky failure).
+ */
+function defaultShouldRetry(err, _attempt) {
+    if (isAbortError(err))
+        return false;
+    const status = err?.status ??
+        err?.statusCode;
+    if (typeof status === 'number' && status >= 400 && status < 500) {
+        // 429 Too Many Requests is the one 4xx that benefits from retry.
+        return status === 429;
+    }
+    return true;
+}
+function isAbortError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const e = err;
+    return e.name === 'AbortError' || e.code === 'ABORT_ERR';
+}
+function sleep(ms, signal) {
+    if (ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason ?? new Error('Aborted'));
+            return;
+        }
+        const id = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(id);
+            reject(signal?.reason ?? new Error('Aborted'));
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+//# sourceMappingURL=withRetry.js.map

package/dist/esm/resilience/withRetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withRetry.js","sourceRoot":"","sources":["../../../src/resilience/withRetry.ts"],"names":[],"mappings":"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"}

package/dist/esm/stream.js

@@ -0,0 +1,146 @@
+/**
+ * agentfootprint/stream — agent events → Server-Sent Events helpers.
+ *
+ * Pattern: Adapter (event stream → SSE wire format).
+ * Role:    Outer ring. Subscribes to a `Runner`'s `EventDispatcher`
+ *          and yields SSE-formatted strings. Drop into any HTTP
+ *          framework that accepts an async iterable response body
+ *          (Fetch Response, Express res.write, Hono streaming, etc.).
+ * Emits:   N/A — observes only.
+ *
+ * ─── 7-panel design review (2026-04-28) ─────────────────────────────
+ *
+ *   LLM-AI system design   ✓ One-line-per-event SSE format. Each
+ *                            event = one observation; each chunk
+ *                            includes the `runtimeStageId` for
+ *                            cross-view binding.
+ *   Performance            ✓ AsyncIterable<string> — no buffering;
+ *                            yields each event as it arrives. Stops
+ *                            naturally when the run completes.
+ *   Scalability            ✓ Per-run instance. No shared state;
+ *                            many concurrent SSE streams safe.
+ *   Research alignment     ✓ Standard SSE wire format
+ *                            (text/event-stream). Browsers'
+ *                            native EventSource API consumes directly.
+ *   Flexibility            ✓ `format` option for full event payload
+ *                            vs slim text-only mode (chat UIs that
+ *                            only want token deltas). `filter`
+ *                            predicate gates events.
+ *   Abstraction-modular    ✓ One function (`toSSE`) + one class
+ *                            (`SSEFormatter`); class is sugar for
+ *                            consumers who prefer .pipeTo() shape.
+ *   Software engineering   ✓ Pure observer. No global state. Tests
+ *                            cover unit + scenario + property +
+ *                            security + performance.
+ *
+ * ─── 7-pattern test coverage ────────────────────────────────────────
+ *
+ *   See `test/stream/unit/SSEFormatter.test.ts`.
+ */
+/**
+ * Subscribe to a runner's `EventDispatcher` and yield SSE-formatted
+ * strings until the run completes.
+ */
+export async function* toSSE(runner, options = {}) {
+    const filter = options.filter;
+    const format = options.format ?? 'full';
+    const eventName = options.eventName ?? ((e) => e.type);
+    const heartbeatMs = options.heartbeatMs ?? 0;
+    // Pull the dispatcher off the runner. RunnerBase exposes it as
+    // protected — we cast to access. No public dispatcher() method
+    // exists ; runners forward .on/.off via their public API.
+    const dispatcher = runner.dispatcher;
+    // Bounded queue: events drained as the consumer iterates.
+    const queue = [];
+    let waiter = null;
+    let done = false;
+    const wakeup = () => {
+        if (waiter) {
+            const w = waiter;
+            waiter = null;
+            w.resolve();
+        }
+    };
+    const unsub = dispatcher.on('*', (event) => {
+        if (filter && !filter(event))
+            return;
+        queue.push(event);
+        wakeup();
+        // `agent.turn_end` (or composition exit on the outermost runner)
+        // ends the stream naturally; the consumer's `for await` finishes
+        // when the iterator returns.
+        if (event.type === 'agentfootprint.agent.turn_end' ||
+            event.type === 'agentfootprint.error.fatal') {
+            done = true;
+            wakeup();
+        }
+    });
+    let heartbeat;
+    if (heartbeatMs > 0) {
+        heartbeat = setInterval(() => {
+            queue.push({ type: '__heartbeat' });
+            wakeup();
+        }, heartbeatMs);
+    }
+    try {
+        while (!done || queue.length > 0) {
+            while (queue.length > 0) {
+                const event = queue.shift();
+                if (event.type === '__heartbeat') {
+                    yield ': ping\n\n';
+                    continue;
+                }
+                if (format === 'text') {
+                    if (event.type === 'agentfootprint.stream.token') {
+                        const payload = event.payload;
+                        if (payload?.content)
+                            yield payload.content;
+                    }
+                }
+                else {
+                    yield encodeSSE(eventName(event), event);
+                }
+            }
+            if (done)
+                break;
+            await new Promise((resolve) => {
+                waiter = { resolve };
+            });
+        }
+    }
+    finally {
+        unsub();
+        if (heartbeat)
+            clearInterval(heartbeat);
+    }
+}
+/**
+ * Class form for consumers who prefer `new SSEFormatter(runner).stream()`.
+ * Identical behavior to `toSSE(runner)` — pick by preference.
+ */
+export class SSEFormatter {
+    runner;
+    options;
+    constructor(runner, options = {}) {
+        this.runner = runner;
+        this.options = options;
+    }
+    /** Async iterable of SSE chunks. Consume with `for await`. */
+    stream() {
+        return toSSE(this.runner, this.options);
+    }
+}
+/**
+ * Format any JSON-able payload as a single SSE event chunk.
+ *
+ * Useful for app-level events outside the runner's typed registry
+ * (auth/error frames, app-state echoes). Most consumers won't need this.
+ */
+export function encodeSSE(eventName, payload) {
+    const json = JSON.stringify(payload);
+    // Escape newlines inside JSON (rare with stringify) so the data field
+    // stays single-line. SSE's data: lines can be repeated, but the
+    // canonical encoder keeps it simple.
+    return `event: ${eventName}\ndata: ${json}\n\n`;
+}
+//# sourceMappingURL=stream.js.map

package/dist/esm/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../../src/stream.ts"],"names":[],"mappings":"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"}

package/dist/events/dispatcher.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * EventDispatcher — the central event bus (one per runner).
+ *
+ * Pattern: Observer (GoF) + Pub/Sub over a typed discriminated union.
+ * Role:    Single flat dispatcher for every event emitted during a run.
+ *          Replaces DOM-style bubbling — we have a central bus by
+ *          construction, so tree propagation is unnecessary.
+ * Emits:   N/A — this IS the emitter. It ROUTES events to listeners.
+ *
+ * Semantics:
+ *   - Observers are ALWAYS fire-and-forget (inherited from footprintjs's
+ *     recorder contract). Promise returns are never awaited.
+ *   - Listener errors are caught; they become `agentfootprint.error.fatal`
+ *     events with stage:'observer'. The run continues.
+ *   - Dispatch is O(1) hash lookup by event type.
+ *   - Zero allocation when no listener for an event type AND no wildcard.
+ *   - Dev-mode wraps listeners to warn on async listener Promise return.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventDispatcher = void 0;
+const footprintjs_1 = require("footprintjs");
+// ─── Dispatcher ──────────────────────────────────────────────────────
+/**
+ * Central event bus. One per executable runner.
+ *
+ * Zero-alloc fast path: if `hasListenersFor(type)` is false AND there are
+ * no wildcards, `dispatch` returns immediately without iteration.
+ */
+class EventDispatcher {
+    byType = new Map();
+    domainWildcards = new Map();
+    allWildcards = new Set();
+    // ─── Query ────────────────────────────────────────────────────────
+    /**
+     * Fast-path check. Returns true when at least one listener would fire
+     * for this type. Used by emitters to skip event-object allocation.
+     */
+    hasListenersFor(type) {
+        if (this.allWildcards.size > 0)
+            return true;
+        const typed = this.byType.get(type);
+        if (typed && typed.size > 0)
+            return true;
+        const domainKey = this.domainKey(type);
+        const domain = this.domainWildcards.get(domainKey);
+        return domain ? domain.size > 0 : false;
+    }
+    on(type, listener, options) {
+        if (options?.signal?.aborted) {
+            // Already aborted; register nothing.
+            return () => { };
+        }
+        const wrapped = {
+            fn: wrapForDev(listener, type),
+            once: options?.once === true,
+        };
+        const unsubscribe = this.addListener(type, wrapped);
+        if (options?.signal) {
+            options.signal.addEventListener('abort', unsubscribe, { once: true });
+        }
+        return unsubscribe;
+    }
+    once(type, listener) {
+        // Internal listener-add — the public `on()` overloads constrain `type`
+        // to either typed keys or wildcards, but internally the dispatcher's
+        // bucket logic accepts any string and classifies by shape.
+        const wrapped = { fn: wrapForDev(listener, type), once: true };
+        return this.addListener(type, wrapped);
+    }
+    off(type, listener) {
+        const bucket = this.bucketFor(type);
+        if (!bucket)
+            return;
+        const originalFn = originalsMap.get(listener) ?? listener;
+        for (const stored of bucket) {
+            const storedOriginal = originalsMap.get(stored.fn) ?? stored.fn;
+            if (storedOriginal === originalFn) {
+                bucket.delete(stored);
+                return;
+            }
+        }
+    }
+    // ─── Dispatch ─────────────────────────────────────────────────────
+    /**
+     * Route an event to all matching listeners (typed + domain-wildcard + all).
+     *
+     * Fire-and-forget: any returned Promise is IGNORED. Listener exceptions
+     * are caught and re-dispatched as `error.fatal` events with scope='observer'.
+     * The run continues regardless.
+     */
+    dispatch(event) {
+        this.fireBucket(this.byType.get(event.type), event);
+        this.fireBucket(this.domainWildcards.get(this.domainKey(event.type)), event);
+        this.fireBucket(this.allWildcards, event);
+    }
+    // ─── Internals ────────────────────────────────────────────────────
+    addListener(type, stored) {
+        const bucket = this.ensureBucket(type);
+        bucket.add(stored);
+        return () => {
+            bucket.delete(stored);
+        };
+    }
+    ensureBucket(type) {
+        if (type === '*')
+            return this.allWildcards;
+        if (type.endsWith('.*')) {
+            const key = type.slice(0, -2);
+            let bucket = this.domainWildcards.get(key);
+            if (!bucket) {
+                bucket = new Set();
+                this.domainWildcards.set(key, bucket);
+            }
+            return bucket;
+        }
+        let bucket = this.byType.get(type);
+        if (!bucket) {
+            bucket = new Set();
+            this.byType.set(type, bucket);
+        }
+        return bucket;
+    }
+    bucketFor(type) {
+        if (type === '*')
+            return this.allWildcards;
+        if (type.endsWith('.*'))
+            return this.domainWildcards.get(type.slice(0, -2));
+        return this.byType.get(type);
+    }
+    fireBucket(bucket, event) {
+        if (!bucket || bucket.size === 0)
+            return;
+        // Snapshot to allow self-removal during iteration (once-listeners).
+        const snapshot = [...bucket];
+        for (const stored of snapshot) {
+            if (stored.once)
+                bucket.delete(stored);
+            try {
+                stored.fn(event);
+            }
+            catch (err) {
+                // Error isolation — never let a listener break the run. We do not
+                // re-dispatch here to avoid infinite recursion if an error-listener
+                // itself throws. Errors are surfaced via console.error in dev mode.
+                if ((0, footprintjs_1.isDevMode)()) {
+                    // eslint-disable-next-line no-console
+                    console.error(`[agentfootprint] Listener for "${event.type}" threw:`, err);
+                }
+            }
+        }
+    }
+    domainKey(eventType) {
+        // 'agentfootprint.context.injected' → 'agentfootprint.context'
+        const lastDot = eventType.lastIndexOf('.');
+        return lastDot === -1 ? eventType : eventType.slice(0, lastDot);
+    }
+}
+exports.EventDispatcher = EventDispatcher;
+// ─── Dev-mode async-listener warning wrapper ─────────────────────────
+/**
+ * Original-function map — preserves consumer's function identity across
+ * dev-mode wrapping so `off(type, originalFn)` still finds and removes
+ * the stored listener.
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types -- WeakMap value preserves arbitrary listener identity; narrowing breaks identity equality.
+const originalsMap = new WeakMap();
+/**
+ * Wrap a listener in dev mode to warn if it returns a Promise.
+ * Production pass-through.
+ *
+ * Why: consumers occasionally write `on('x', async (e) => await ...)` and
+ * expect the dispatcher to wait. It does NOT — observers are always
+ * fire-and-forget. This warning catches the mistake loudly in dev.
+ */
+function wrapForDev(listener, type) {
+    if (!(0, footprintjs_1.isDevMode)())
+        return listener;
+    const wrapped = (event) => {
+        const result = listener(event);
+        if (result && typeof result === 'object' && 'then' in result) {
+            // eslint-disable-next-line no-console
+            console.warn(`[agentfootprint] Listener for "${type}" returned a Promise.\n` +
+                `Observers are NEVER awaited — your Promise will run in the background.\n` +
+                `If you need back-pressure, collect promises and await AFTER run().\n` +
+                `  See: https://agentfootprint.dev/docs/events/async-listeners`);
+            // Capture unhandled rejections so they don't vanish silently.
+            result.catch((err) => {
+                // eslint-disable-next-line no-console
+                console.error(`[agentfootprint] Listener Promise for "${type}" rejected:`, err);
+            });
+        }
+    };
+    originalsMap.set(wrapped, listener);
+    return wrapped;
+}
+//# sourceMappingURL=dispatcher.js.map

package/dist/events/dispatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatcher.js","sourceRoot":"","sources":["../../src/events/dispatcher.ts"],"names":[],"mappings":"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"}

package/dist/events/payloads.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Event payload types — the 45 typed event payloads across 13 domains.
+ *
+ * Pattern: Discriminated Union (Gang of Four inspired, TS-native).
+ * Role:    Contract layer of Event-Driven Hexagonal Architecture.
+ * Emits:   (types only).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=payloads.js.map

package/dist/events/payloads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payloads.js","sourceRoot":"","sources":["../../src/events/payloads.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG"}