@interactive-inc/claude-funnel 0.8.1 → 0.10.1

package/dist/gateway/routes/validator.d.ts

@@ -1,19 +0,0 @@
-import type { ZodType } from "zod";
-/**
- * Path-param validator for gateway routes. On failure it answers with the same
- * `{ ok: false, reason }` shape the listener routes already use, so
- * `FunnelListenersClient` can surface the message without special-casing.
- */
-export declare const zParam: <T extends ZodType>(schema: T) => import("hono").MiddlewareHandler<import("hono").Env, string, {
-    in: (undefined extends (T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never) ? true : false) extends true ? {
-        param?: ([T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never] extends [Record<string, string>] ? Record<string, string> & (T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never) : [Exclude<T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never, undefined>] extends [never] ? {} : [Exclude<T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never, undefined>] extends [object] ? undefined extends (T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never) ? ((T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never) & undefined) | (((Exclude<T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never, (T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never) & undefined> extends infer T_3 ? { [K_2 in keyof T_3]: ([Exclude<T_3[K_2], undefined>] extends [string] ? [string & Exclude<T_3[K_2], undefined>] extends [import("hono/utils/types").UnionToIntersection<string & Exclude<T_3[K_2], undefined>>] ? false : true : false) extends true ? T_3[K_2] : ([unknown] extends [T_3[K_2]] ? false : undefined extends T_3[K_2] ? true : false) extends true ? T_3[K_2] : Target extends "form" ? T$1 | T$1[] : Target extends "query" ? string | string[] : Target extends "param" ? string : Target extends "header" ? string : Target extends "cookie" ? string : unknown; } : never) extends infer T_2 ? { [K_1 in keyof T_2]: T_2[K_1]; } : never) extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never) : (((T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never) extends infer T_6 ? { [K_5 in keyof T_6]: ([Exclude<T_6[K_5], undefined>] extends [string] ? [string & Exclude<T_6[K_5], undefined>] extends [import("hono/utils/types").UnionToIntersection<string & Exclude<T_6[K_5], undefined>>] ? false : true : false) extends true ? T_6[K_5] : ([unknown] extends [T_6[K_5]] ? false : undefined extends T_6[K_5] ? true : false) extends true ? T_6[K_5] : Target extends "form" ? T$1 | T$1[] : Target extends "query" ? string | string[] : Target extends "param" ? string : Target extends "header" ? string : Target extends "cookie" ? string : unknown; } : never) extends infer T_5 ? { [K_4 in keyof T_5]: T_5[K_4]; } : never) extends infer T_4 ? { [K_3 in keyof T_4]: T_4[K_3]; } : never : {}) | undefined;
-    } : {
-        param: [T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never] extends [Record<string, string>] ? Record<string, string> & (T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never) : [Exclude<T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never, undefined>] extends [never] ? {} : [Exclude<T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never, undefined>] extends [object] ? undefined extends (T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never) ? ((T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never) & undefined) | (((Exclude<T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never, (T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never) & undefined> extends infer T_9 ? { [K_2 in keyof T_9]: ([Exclude<T_9[K_2], undefined>] extends [string] ? [string & Exclude<T_9[K_2], undefined>] extends [import("hono/utils/types").UnionToIntersection<string & Exclude<T_9[K_2], undefined>>] ? false : true : false) extends true ? T_9[K_2] : ([unknown] extends [T_9[K_2]] ? false : undefined extends T_9[K_2] ? true : false) extends true ? T_9[K_2] : Target extends "form" ? T$1 | T$1[] : Target extends "query" ? string | string[] : Target extends "param" ? string : Target extends "header" ? string : Target extends "cookie" ? string : unknown; } : never) extends infer T_8 ? { [K_1 in keyof T_8]: T_8[K_1]; } : never) extends infer T_7 ? { [K in keyof T_7]: T_7[K]; } : never) : (((T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never) extends infer T_12 ? { [K_5 in keyof T_12]: ([Exclude<T_12[K_5], undefined>] extends [string] ? [string & Exclude<T_12[K_5], undefined>] extends [import("hono/utils/types").UnionToIntersection<string & Exclude<T_12[K_5], undefined>>] ? false : true : false) extends true ? T_12[K_5] : ([unknown] extends [T_12[K_5]] ? false : undefined extends T_12[K_5] ? true : false) extends true ? T_12[K_5] : Target extends "form" ? T$1 | T$1[] : Target extends "query" ? string | string[] : Target extends "param" ? string : Target extends "header" ? string : Target extends "cookie" ? string : unknown; } : never) extends infer T_11 ? { [K_4 in keyof T_11]: T_11[K_4]; } : never) extends infer T_10 ? { [K_3 in keyof T_10]: T_10[K_3]; } : never : {};
-    };
-    out: {
-        param: T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").output<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").infer<T> : never;
-    };
-}, import("hono").TypedResponse<{
-    ok: boolean;
-    reason: string;
-}, 400, "json">>;

package/dist/logger/leuco-human-file-writer.d.ts

@@ -1,33 +0,0 @@
-import type { LeucoHumanRecord } from "./leuco-human-record";
-import type { LeucoHumanWriter } from "./leuco-human-writer";
-type Props = {
-    /** Filesystem path. Parent directory is created on construct. */
-    path: string;
-    /**
-     * Optional size cap in bytes. When the next write would push the file
-     * over the cap, the existing file becomes `<path>.1` (replacing any
-     * prior `.1`) and a fresh file takes its place. Single-keep rotation —
-     * a second cycle drops the previous `.1`.
-     */
-    maxBytes?: number;
-};
-/**
- * Appends one JSON line per record to a file. Optional one-keep size
- * rotation. Designed for diagnostic logs a human tails (`tail -f file |
- * jq`); not for replay or queries — use `LeucoLoggerSqliteSink` if you
- * need indexed lookups.
- *
- * Writes are synchronous (`appendFileSync`), so each line is durable
- * before `write` returns. Throughput matches the OS file cache; for
- * high-volume logging consider buffering at the call site or using a
- * different writer.
- */
-export declare class LeucoHumanFileWriter implements LeucoHumanWriter {
-    private readonly path;
-    private readonly maxBytes;
-    constructor(props: Props);
-    write(record: LeucoHumanRecord): void | Error;
-    private ensureDir;
-    private rotateIfNeeded;
-}
-export {};

package/dist/logger/leuco-human-logger.d.ts

@@ -1,46 +0,0 @@
-import type { LeucoHumanLevel, LeucoHumanRecord } from "./leuco-human-record";
-import type { LeucoHumanWriter } from "./leuco-human-writer";
-type WriteErrorHandler = (error: Error, record: LeucoHumanRecord) => void;
-type Props = {
-    /** Where records go. Use `LeucoHumanStdoutWriter`, `LeucoHumanFileWriter`, or your own. */
-    writer: LeucoHumanWriter;
-    /** Minimum level to emit. Lower-rank records are dropped. Default: "info". */
-    level?: LeucoHumanLevel;
-    /** Override for tests. Defaults to `Date.now`. */
-    now?: () => number;
-    /** Observer for writer failures. Default: silently swallow. */
-    onWriteError?: WriteErrorHandler;
-};
-/**
- * Human-facing diagnostic logger. The companion to `LeucoLogger`: where
- * `LeucoLogger` is for schema-validated, replayable domain events,
- * `LeucoHumanLogger` is for free-form info/warn/error messages destined
- * for a human tailing a log or skimming during incident response.
- *
- * Keeping the two separate matters operationally:
- *   - Diagnostics typically out-volume domain events 10–1000x; mixing
- *     them in the same store would push events out under retention.
- *   - Diagnostics are unstructured by design; mixing them in would defeat
- *     the schema-first guarantee that makes domain events replayable.
- *   - Different audiences and queries (humans grep `tail -f` vs. tools
- *     query `WHERE seq > ?`).
- *
- * The writer is a port. Level gating happens here so writers receive only
- * what is worth persisting. Failure isolation matches `LeucoLogger`: a
- * writer that throws or returns Error is contained, surfaced via
- * `onWriteError`, and never blocks the caller.
- */
-export declare class LeucoHumanLogger {
-    private readonly writer;
-    private readonly minRank;
-    private readonly now;
-    private readonly onWriteError;
-    constructor(props: Props);
-    info(message: string, meta?: Record<string, unknown>): void;
-    warn(message: string, meta?: Record<string, unknown>): void;
-    error(message: string, meta?: Record<string, unknown>): void;
-    close(): void;
-    private emit;
-    private callWriter;
-}
-export {};

package/dist/logger/leuco-human-record.d.ts

@@ -1,15 +0,0 @@
-export type LeucoHumanLevel = "info" | "warn" | "error";
-/**
- * One human-facing diagnostic log entry. Distinct from `LeucoLoggerRecord`
- * (which wraps a schema-validated domain event) — this is the free-form,
- * for-humans-tailing-a-log shape: a level, a message, and optional meta.
- *
- * `meta` is `null` rather than `undefined` when absent so writers can
- * persist a uniform shape (no missing-key ambiguity in JSON Lines).
- */
-export type LeucoHumanRecord = {
-    ts: number;
-    level: LeucoHumanLevel;
-    message: string;
-    meta: Record<string, unknown> | null;
-};

package/dist/logger/leuco-human-stdout-writer.d.ts

@@ -1,20 +0,0 @@
-import type { LeucoHumanRecord } from "./leuco-human-record";
-import type { LeucoHumanWriter } from "./leuco-human-writer";
-type Stream = {
-    write(s: string): void;
-};
-type Props = {
-    /** Override for tests. Defaults to `process.stdout`. */
-    out?: Stream;
-};
-/**
- * Writes one JSON line per record to stdout. Useful as the default writer
- * for foreground daemons, dev runs, and short-lived processes where a
- * file-backed log would be overkill.
- */
-export declare class LeucoHumanStdoutWriter implements LeucoHumanWriter {
-    private readonly out;
-    constructor(props?: Props);
-    write(record: LeucoHumanRecord): void;
-}
-export {};

package/dist/logger/leuco-human-writer.d.ts

@@ -1,13 +0,0 @@
-import type { LeucoHumanRecord } from "./leuco-human-record";
-/**
- * Plugin port for `LeucoHumanLogger`. Writers decide where diagnostic
- * records land — stdout, JSONL file, syslog, network, etc. — without the
- * logger having to know about persistence shape.
- *
- * `write` returns `void` on success or an `Error` the logger surfaces via
- * `onWriteError`. Throwing is also tolerated; the logger catches.
- */
-export type LeucoHumanWriter = {
-    write(record: LeucoHumanRecord): void | Error;
-    close?(): void;
-};

package/dist/logger/leuco-logger-memory-sink.d.ts

@@ -1,33 +0,0 @@
-import type { LeucoLoggerRecord } from "./leuco-logger-record";
-import type { LeucoLoggerPrimarySink, LeucoLoggerSink } from "./leuco-logger-sink";
-type Props = {
-    /** Hard cap on retained records. The oldest is evicted on overflow. 0 disables retention. */
-    capacity?: number;
-};
-/**
- * In-memory ring buffer that doubles as primary or relay. As primary it
- * owns its own seq counter (single-process only — for multi-process
- * safety, use `LeucoLoggerSqliteSink` as primary and place this as a
- * relay). As relay it accepts whatever seq the primary assigned and
- * advances its own counter to match, so `getMaxSeq` stays meaningful.
- *
- * Useful as a test double, as a short-window replay buffer paired with a
- * persistent primary (covering reconnects without round-tripping disk),
- * or as a backing store for live subscribers.
- */
-export declare class LeucoLoggerMemorySink<E> implements LeucoLoggerPrimarySink<E>, LeucoLoggerSink<E> {
-    private readonly capacity;
-    private readonly buffer;
-    private seq;
-    constructor(props?: Props);
-    insert(input: {
-        ts: number;
-        event: E;
-    }): LeucoLoggerRecord<E>;
-    write(record: LeucoLoggerRecord<E>): void;
-    getMaxSeq(): number;
-    getRecords(): ReadonlyArray<LeucoLoggerRecord<E>>;
-    clear(): void;
-    private append;
-}
-export {};

package/dist/logger/leuco-logger-record.d.ts

@@ -1,13 +0,0 @@
-/**
- * Wrapper that `LeucoLogger.emit` puts around every event before handing it
- * to a sink. `seq` is monotonic across the lifetime of the underlying store —
- * sinks persist it as the primary key so replay (and broadcaster seeding
- * after restart) is an indexed range scan, not a full table walk. `ts` is
- * epoch milliseconds. `event` is the caller-defined payload validated by the
- * Zod schema passed to the bus.
- */
-export type LeucoLoggerRecord<E> = {
-    seq: number;
-    ts: number;
-    event: E;
-};

package/dist/logger/leuco-logger-sink.d.ts

@@ -1,34 +0,0 @@
-import type { LeucoLoggerRecord } from "./leuco-logger-record";
-/**
- * Relay sink. Receives records that already have a `seq` assigned by the
- * primary and stores or forwards them — memory ring, stdout, network push,
- * a second SQLite mirror, etc. Does not generate seq itself, so any number
- * can be attached and they all observe the same monotonic stream.
- *
- * `write` returns `void` on success or an `Error` the bus surfaces via
- * `onSinkError`. Throwing is also tolerated (the bus catches), but
- * returning is preferred so the failure path is part of the type.
- */
-export type LeucoLoggerSink<E> = {
-    write(record: LeucoLoggerRecord<E>): void | Error;
-    close?(): void;
-};
-/**
- * Primary sink. Owns the canonical seq sequence for the bus. `insert` is
- * the atomic boundary — it assigns a seq strictly greater than every
- * previously assigned one, persists the record, and returns it. SQLite
- * implementations get atomicity for free by delegating to `INTEGER PRIMARY
- * KEY` so two processes sharing one database file see one monotonic
- * stream without bus-level coordination.
- *
- * `getMaxSeq` is the highest seq currently in the sink — used for
- * observability and for replay seeding by clients reading the store.
- */
-export type LeucoLoggerPrimarySink<E> = {
-    insert(input: {
-        ts: number;
-        event: E;
-    }): LeucoLoggerRecord<E> | Error;
-    getMaxSeq(): number;
-    close?(): void;
-};

package/dist/logger/leuco-logger-sqlite-sink.d.ts

@@ -1,102 +0,0 @@
-import type { LeucoLoggerRecord } from "./leuco-logger-record";
-import type { LeucoLoggerPrimarySink, LeucoLoggerSink } from "./leuco-logger-sink";
-type IndexValues<I extends ReadonlyArray<string>> = Record<I[number], string | null>;
-/**
- * Constructor props. The shape narrows on `I`: when no indexes are
- * declared (the default), `extractIndexes` is forbidden; when indexes
- * are declared, both `indexes` and `extractIndexes` are required and
- * `extractIndexes` is type-checked against the index keys.
- */
-type Props<E, I extends ReadonlyArray<string>> = I extends readonly [] ? {
-    path: string;
-    maxRows?: number;
-    maxAgeMs?: number;
-    now?: () => number;
-    indexes?: I;
-    extractIndexes?: never;
-} : {
-    path: string;
-    maxRows?: number;
-    maxAgeMs?: number;
-    now?: () => number;
-    indexes: I;
-    extractIndexes: (event: E) => IndexValues<I>;
-};
-type GetRecordsProps<I extends ReadonlyArray<string>> = {
-    /** Return only records with seq strictly greater than this. */
-    sinceSeq?: number;
-    /** Filter by the top-level `event.type` discriminator. */
-    type?: string;
-    /** Filter by indexed columns. Keys are constrained to the declared `indexes`. */
-    where?: Partial<IndexValues<I>>;
-    /** Maximum rows returned. Default 1000. */
-    limit?: number;
-};
-/**
- * SQLite-backed sink built on `bun:sqlite`. Implements both primary and
- * relay roles so the same instance can own seq generation for one bus and
- * mirror records from another (e.g. cross-process replication, restore
- * from a backup stream).
- *
- * Concurrency model: seq is `INTEGER PRIMARY KEY`, so SQLite assigns it
- * atomically via `lastInsertRowid`. Two `LeucoLogger` instances pointed
- * at the same database file therefore see one monotonically increasing
- * seq stream without any bus-level coordination — the database itself is
- * the synchronization point.
- *
- * Schema is version-managed via `PRAGMA user_version`. Migrations are
- * append-only and run in a transaction on every construct so a partial
- * upgrade rolls back cleanly. Caller-defined `indexes` are layered on top
- * via `ALTER TABLE ADD COLUMN` + `CREATE INDEX IF NOT EXISTS`, so adding
- * a new index to an existing database is a no-downtime operation.
- *
- * Type safety: the second generic parameter `I` is the literal tuple of
- * index column names. `extractIndexes` and `getRecords({ where })` are
- * both type-checked against this tuple, so a typo at the call site is a
- * compile-time error rather than a silent miss at runtime.
- *
- * Retention is bounded by `maxRows` and/or `maxAgeMs`. Both run on every
- * insert as a single indexed DELETE that no-ops below the cap.
- *
- * Bulk inserts use `insertMany`, which wraps the batch in one transaction
- * for ~10–100x throughput at the cost of one fsync per batch instead of
- * one per row.
- */
-export declare class LeucoLoggerSqliteSink<E, const I extends ReadonlyArray<string> = readonly []> implements LeucoLoggerPrimarySink<E>, LeucoLoggerSink<E> {
-    private readonly db;
-    private readonly maxRows;
-    private readonly maxAgeMs;
-    private readonly now;
-    private readonly indexes;
-    private readonly extractIndexes;
-    private readonly insertStmt;
-    private readonly insertWithSeqStmt;
-    private readonly maxSeqStmt;
-    private readonly countStmt;
-    private readonly trimRowsStmt;
-    private readonly trimAgeStmt;
-    constructor(props: Props<E, I>);
-    insert(input: {
-        ts: number;
-        event: E;
-    }): LeucoLoggerRecord<E> | Error;
-    insertMany(inputs: ReadonlyArray<{
-        ts: number;
-        event: E;
-    }>): LeucoLoggerRecord<E>[] | Error;
-    write(record: LeucoLoggerRecord<E>): void | Error;
-    getMaxSeq(): number;
-    getRecords(props?: GetRecordsProps<I>): LeucoLoggerRecord<E>[];
-    /**
-     * Current schema version. Useful for diagnostics and for tests that want
-     * to verify migrations ran. Reads `PRAGMA user_version` once per call.
-     */
-    getSchemaVersion(): number;
-    close(): void;
-    private buildInsertParams;
-    private appendWhereConditions;
-    private trim;
-    private syncIndexColumns;
-    private migrate;
-}
-export {};

package/dist/logger/leuco-logger.d.ts

@@ -1,56 +0,0 @@
-import type { ZodType } from "zod";
-import type { LeucoLoggerRecord } from "./leuco-logger-record";
-import type { LeucoLoggerPrimarySink, LeucoLoggerSink } from "./leuco-logger-sink";
-type Listener<E> = (record: LeucoLoggerRecord<E>) => void;
-type SinkErrorHandler<E> = (error: Error, record: LeucoLoggerRecord<E>, sink: LeucoLoggerSink<E>) => void;
-type Props<E> = {
-    /** Zod schema for the event union. Validated on every `emit`. */
-    schema: ZodType<E>;
-    /** Owns seq assignment + durability. Use `LeucoLoggerSqliteSink` for multi-process safety. */
-    primary: LeucoLoggerPrimarySink<E>;
-    /** Optional fanout for already-sequenced records (memory ring, stdout, network mirror). */
-    relays?: ReadonlyArray<LeucoLoggerSink<E>>;
-    /** Override for tests. Defaults to `Date.now`. */
-    now?: () => number;
-    /** Observer for relay failures. Default: silently swallow. */
-    onSinkError?: SinkErrorHandler<E>;
-};
-/**
- * Schema-validated event log bus. Three responsibilities and nothing else:
- * validate the event, delegate seq + persistence to the primary sink, and
- * fan the resulting record out to relays and live subscribers.
- *
- * Splitting "primary" from "relays" makes the seq invariant honest: there
- * is exactly one source of truth (the primary's atomic insert). Two
- * `LeucoLogger` instances pointed at the same SQLite file therefore see
- * one monotonic stream without bus-level coordination. Relays mirror
- * already-sequenced records, so they can be added or removed without
- * affecting correctness.
- *
- * Failure isolation:
- *   - Primary failure short-circuits emit and is returned to the caller.
- *   - Relay failures never block the primary path — they surface via the
- *     optional `onSinkError` callback so the caller can observe without
- *     being interrupted.
- *   - A subscriber that throws is contained; the rest of the fanout
- *     completes normally.
- */
-export declare class LeucoLogger<E> {
-    private readonly schema;
-    private readonly primary;
-    private readonly relays;
-    private readonly now;
-    private readonly onSinkError;
-    private readonly listeners;
-    constructor(props: Props<E>);
-    emit(event: E): LeucoLoggerRecord<E> | Error;
-    subscribe(listener: Listener<E>): () => void;
-    getMaxSeq(): number;
-    close(): void;
-    private callPrimary;
-    private fanOutToRelays;
-    private callRelay;
-    private fanOutToListeners;
-    private callClose;
-}
-export {};

package/lib/bin.ts

@@ -1,78 +0,0 @@
-#!/usr/bin/env bun
-import pkg from "../package.json" with { type: "json" }
-import { startChannelServer } from "@/engine/mcp/channel-server"
-import { toRequest } from "@/cli/router/to-request"
-import { launchTui } from "@/tui/tui"
-import { app } from "@/cli/routes"
-import { Funnel } from "@/funnel"
-
-process.title = "funnel"
-
-const HELP = `funnel — Open Claude Funnel
-
-usage: funnel [command]
-
-commands:
-  (none)                launch TUI
-  claude                launch Claude Code (default profile or --profile)
-  channels              manage subscription boxes (and their nested connectors)
-  profiles              manage launch profiles
-  gateway               manage the gateway daemon (HTTP + WS)
-  status                show overall connection status
-  update                update funnel to the latest version
-  mcp                   run as an MCP server (invoked from .mcp.json)
-
-options:
-  --help, -h            show help
-  --version, -v         show version
-
-more: funnel <command> --help`
-
-const args = process.argv.slice(2)
-
-if (args.length === 0) {
-  await launchTui(new Funnel())
-  process.exit(0)
-}
-
-if (args[0] === "--version" || args[0] === "-v") {
-  process.stdout.write(`${pkg.version}\n`)
-  process.exit(0)
-}
-
-if (args[0] === "mcp") {
-  await startChannelServer()
-} else {
-  const { method, url } = toRequest(args)
-  const parsed = new URL(url)
-  const wantsHelp = parsed.searchParams.has("help")
-
-  if (wantsHelp && parsed.pathname === "/") {
-    process.stdout.write(`${HELP}\n`)
-    process.exit(0)
-  }
-
-  const res = await app.request(url, { method })
-
-  if (res.ok) {
-    const body = await res.text()
-    if (body) process.stdout.write(`${body}\n`)
-    process.exit(0)
-  }
-
-  if (wantsHelp) {
-    const segments = parsed.pathname.split("/").filter(Boolean)
-    const group = segments[0]
-    const fallback = group
-      ? await app.request(`http://localhost/${group}?help=true`, { method: "GET" })
-      : null
-
-    const text = fallback?.ok ? await fallback.text() : HELP
-    process.stdout.write(`${text}\n`)
-    process.exit(0)
-  }
-
-  const text = await res.text()
-  if (text) process.stderr.write(`${text}\n`)
-  process.exit(1)
-}

package/lib/cli/factory.ts

@@ -1,10 +0,0 @@
-import { createFactory } from "hono/factory"
-import type { Funnel } from "@/funnel"
-
-export type Env = {
-  Variables: {
-    funnel: Funnel
-  }
-}
-
-export const factory = createFactory<Env>()

package/lib/cli/router/query-to-cli-args.ts

@@ -1,20 +0,0 @@
-const BUILTIN_SKIP = new Set(["help"])
-
-export const queryToCliArgs = (url: string, reservedKeys: string[] = []): string[] => {
-  const skipped = new Set([...BUILTIN_SKIP, ...reservedKeys])
-  const args: string[] = []
-  const searchParams = new URL(url).searchParams
-
-  for (const entry of searchParams.entries()) {
-    const key = entry[0]
-    const value = entry[1]
-
-    if (skipped.has(key)) continue
-
-    args.push(`--${key}`)
-
-    if (value !== "true") args.push(value)
-  }
-
-  return args
-}

package/lib/cli/router/to-request.ts

@@ -1,112 +0,0 @@
-const SHORT_FLAGS: Record<string, string> = {
-  h: "help",
-  n: "name",
-  p: "profile",
-}
-
-// All CLI verbs map to POST and stay in the URL (no method-stripping).
-// Hono routes disambiguate by URL segment (e.g. /channels/add/:channel vs /channels/remove/:channel).
-const METHOD_KEYWORDS = new Set([
-  "add",
-  "set",
-  "remove",
-  "rename",
-  "as-default",
-  "request",
-])
-
-const API_CALL_METHODS = new Set(["get", "post", "put", "patch", "delete", "head", "options"])
-
-const isValue = (arg: string | undefined): arg is string => {
-  return typeof arg === "string" && !arg.startsWith("-")
-}
-
-const consumeApiCall = (args: string[], i: number, params: URLSearchParams): number => {
-  const nextPath = args[i + 1]
-
-  if (!isValue(nextPath)) return 1
-
-  params.set("path", nextPath)
-
-  const nextBody = args[i + 2]
-
-  if (!isValue(nextBody)) return 2
-
-  params.set("body", nextBody)
-
-  return 3
-}
-
-export const toRequest = (args: string[]) => {
-  const segments: string[] = []
-  const params = new URLSearchParams()
-  let method = "GET"
-
-  let i = 0
-  while (i < args.length) {
-    const arg = args[i]!
-
-    if (arg.startsWith("--")) {
-      const key = arg.slice(2)
-      const next = args[i + 1]
-
-      if (isValue(next)) {
-        params.set(key, next)
-        i += 2
-      } else {
-        params.set(key, "true")
-        i++
-      }
-
-      continue
-    }
-
-    if (arg.startsWith("-") && arg.length === 2) {
-      const long = SHORT_FLAGS[arg[1]!]
-
-      if (!long) {
-        i++
-        continue
-      }
-
-      const next = args[i + 1]
-
-      if (isValue(next)) {
-        params.set(long, next)
-        i += 2
-      } else {
-        params.set(long, "true")
-        i++
-      }
-
-      continue
-    }
-
-    if (METHOD_KEYWORDS.has(arg)) {
-      method = "POST"
-      segments.push(arg)
-      i++
-      continue
-    }
-
-    if (API_CALL_METHODS.has(arg) && !params.has("path")) {
-      segments.push(arg)
-      i += consumeApiCall(args, i, params)
-      continue
-    }
-
-    if (arg.includes("/") && !params.has("path")) {
-      params.set("path", arg)
-      i++
-      continue
-    }
-
-    segments.push(arg)
-    i++
-  }
-
-  const path = segments.length > 0 ? `/${segments.join("/")}` : "/"
-  const query = params.size > 0 ? `?${params}` : ""
-
-  return { method, path, url: `http://localhost${path}${query}` }
-}

package/lib/cli/router/validator.ts

@@ -1,27 +0,0 @@
-import { zValidator as zv } from "@hono/zod-validator"
-import { HTTPException } from "hono/http-exception"
-import type { ZodType } from "zod"
-
-export const zValidator = <Target extends "param" | "query" | "json", T extends ZodType>(
-  target: Target,
-  schema: T,
-  helpText?: string,
-) =>
-  zv(target, schema, (result, c) => {
-    if (helpText && c.req.query("help")) {
-      return c.text(helpText)
-    }
-
-    if (result.success) return
-
-    const issue = result.error.issues[0]
-
-    if (!issue) {
-      throw new HTTPException(400, { message: "invalid request" })
-    }
-
-    const path = issue.path.join(".")
-    const message = path ? `${path}: ${issue.message}` : issue.message
-
-    throw new HTTPException(400, { message })
-  })