@esportsplus/typescript 0.32.0 → 0.33.1

package/README.md

@@ -83,65 +83,38 @@ The CLI detects plugins in `tsconfig.json` `compilerOptions.plugins`, loads them
 - **`resources`** — acquired resources (timers, event listeners, file handles, sockets, `Disposable`s, …) that can leak: not released, transferred, or `using`-bound on every path — including throwing paths, which it derives from the `exceptions` channel's summaries.
 - **`async`** — unbounded `Promise.all(…)`-style fan-out, orphaned promises whose rejections go unhandled, and awaited cancellable calls that drop an `AbortSignal` the function holds.
 
-Only `exceptions` is on by default; enable the others per project. It rides the `tsc` passthrough (build/CI), and ships an LSP server so editors can render the same findings.
+Only channels you configure run; a channel is otherwise off. It rides the `tsc` passthrough (build/CI), and ships an LSP server so editors can render the same findings.
 
 ### Enable
 
-Add an `analyze` entry to `compilerOptions.plugins`. Analysis covers every file the tsconfig includes (ignoring excludes); no config beyond the entry is required.
+Add a top-level `tsc-guard` key to `tsconfig.json` (a sibling of `compilerOptions`, like `tsc-alias`). Analysis is always whole-project and covers every file the tsconfig includes (ignoring excludes). Its only root keys are the channel names — `exceptions`, `resources`, and `async` — with no `channels` wrapper. An absent channel is off; a present channel with no `severity` is `error`. Consequently, a bare `"tsc-guard": {}` analyzes nothing: the minimum useful config is the three-line per-channel shape below.
+
+Unlike `compilerOptions.plugins` — which `extends` **replaces** wholesale — `tsc-guard` is **deep-merged down the `extends` chain**: a shared base can carry the defaults and a package override a single channel key (e.g. `tsc-guard.exceptions.report`) without restating the rest. Set an inherited key to `null` to delete it.
+
+`enabled`, top-level `severity`/`failOnFindings`, `presets`, `overlays`, `sinks`, `handlerBoundaries`, `entryPoints`, and the `channels` wrapper are removed; leaving one in the config fails the build with a diagnostic naming its replacement. Platform effect models (Node/DOM globals, `node:fs`, and so on) are built in, so there is nothing to select. `dispatch` is recognised on every channel.
 
 ```jsonc
 {
-    "compilerOptions": {
-        "plugins": [
-            {
-                "name": "ts-probe",
-                // Editor squiggle color; "warn" opts down. CLI/build ignore this.
-                "severity": "error",
-                // Fail the tsc/build run when there are findings.
-                "failOnFindings": true,
-                // Per-channel config. `enabled` and `dispatch` are recognised on
-                // every channel; other keys are that channel's own options.
-                "channels": {
-                    "exceptions": {
-                        "enabled": true,
-                        // "consumers" (default): uncaught calls only, and only when
-                        //   the throwing callee is in another PACKAGE — a throw within
-                        //   this package is its own contract, seen only where an
-                        //   external consumer calls in.
-                        // "cross-module": like "consumers" but the boundary is the
-                        //   FILE — a callee thrown from the caller's own file stays
-                        //   silent; a call from another file reports.
-                        // "all": throws AND every uncaught call.
-                        "report": "consumers",
-                        // Flag `throw`s inside `catch` that drop the caught error's cause.
-                        "errorCause": true
-                    },
-                    "resources": {
-                        "enabled": true,
-                        // Untrackable handling when a resource escapes local analysis:
-                        // "optimist" assumes transfer (silent), "pessimist" reports it.
-                        "dispatch": "optimist",
-                        // Calls that take ownership of a passed resource argument.
-                        "ownership": [{ "callee": "registerCleanup", "params": [0] }]
-                    },
-                    "async": {
-                        "enabled": true,
-                        "fanOut": "warn",                     // "off" | "warn" | "error"
-                        "fanOutAllowLiteralUpTo": 16,         // inline array/tuple size that is fine
-                        "poolFunctions": ["p-limit", "p-map"] // sanctioned concurrency wrappers
-                    }
-                },
-                // Model third-party throw behavior: "node", "express".
-                "presets": ["node"]
-            }
-        ]
+    "compilerOptions": { /* … */ },
+    "tsc-guard": {
+        "exceptions": {
+            "severity": "error",            // "error" reports + fails the build; "warn"/"info" report only; "off" skips
+            // "consumers": uncaught calls only, when the throwing callee is in another PACKAGE.
+            // "cross-module": like "consumers" but the boundary is the FILE.
+            // "all": throws AND every uncaught call.
+            "report": "cross-module"         // "consumers" | "cross-module" | "all"
+        },
+        "resources": { "severity": "error" },
+        "async":     { "severity": "warn" }
     }
 }
 ```
 
+Each channel's `severity` is `"error"`, `"warn"`, `"info"`, or `"off"` — `error` reports and fails the build; `warn`/`info` report without gating (a `warn` squiggle vs a subtler `info` one in the editor); `off` skips the channel. The only remaining channel option is `exceptions.report` (`"consumers"` | `"cross-module"` | `"all"`, default `"consumers"`). Everything else is inferred from the code and unconditional: the exceptions channel traces third-party throws from the installed `.js` and flags the catch-`{ cause }` smell; the resources channel infers ownership by tracing releases/transfers and reports any resource that escapes somewhere untrackable; the async channel flags orphaned promises, dropped `AbortSignal`s, and `Promise.all`/`race`/… over a **dynamically-sized** input (a statically-sized array literal or fixed tuple is always fine).
+
 ### CLI / build
 
-The `tsc` passthrough runs analyze after a successful compile and prints findings to stderr. With `failOnFindings: true`, a run with findings exits non-zero — drop it into CI as a gate.
+The `tsc` passthrough runs analyze after a successful compile and prints findings to stderr. It exits non-zero (`1`) when any finding is in a channel whose `severity` is `"error"`; `warn` channels never fail the build. A rejected or removed config key is a hard error and also exits `1`.
 
 ```bash
 tsc   # compiles, resolves aliases, then reports analyze findings
@@ -149,7 +122,12 @@ tsc   # compiles, resolves aliases, then reports analyze findings
 
 ### Editor (LSP)
 
-The package ships a standalone language server (`esportsplus-tsc-lsp` bin, or the `@esportsplus/typescript/lsp` export) that publishes analyze findings over LSP. A client spawns it beside the native TypeScript server and merges both diagnostic streams; `severity` drives the squiggle color. Analysis runs against saved files on open and save. Beyond diagnostics it serves **hovers** (the finding plus its origin→boundary chain) and **quick-fixes** — `void`/`await` an orphaned promise, forward an `AbortSignal`, or fix a leaked handle by converting it to `using` or wrapping the region in `try/finally`.
+The package ships a standalone language server (`esportsplus-tsc-lsp` bin, or the `@esportsplus/typescript/lsp` export) that publishes analyze findings over LSP. It runs as a *second* server **beside** the TypeScript language server — it is not a tsserver plugin — and the editor merges both diagnostic streams; each finding's squiggle color comes from its own channel's `severity`. Analysis runs against saved files on open and save. Beyond diagnostics it serves **hovers** (the finding plus its origin→boundary chain) and **quick-fixes** — `void`/`await` an orphaned promise, forward an `AbortSignal`, or fix a leaked handle by converting it to `using` or wrapping the region in `try/finally`.
+
+Wiring it up:
+
+- **Config-driven LSP editors** (Neovim, Emacs, Helix, Zed, Sublime LSP): register `esportsplus-tsc-lsp` as an additional server for `typescript`/`typescriptreact`. It attaches to the same buffers as the TypeScript server; no tsconfig change.
+- **VS Code**: install the client extension under [`editor/vscode`](editor/vscode) — it resolves and spawns the server from the workspace's own install.
 
 ```typescript
 import { startServer } from '@esportsplus/typescript/lsp';
@@ -157,6 +135,13 @@ import { startServer } from '@esportsplus/typescript/lsp';
 startServer(); // stdio LSP server
 ```
 
+### Accepted false negatives
+
+- A library function that returns a resource the caller must release (for example, `db.connect()` → `.close()`) is not modeled unless it is in the built-in table.
+- Third-party throws are derived by syntactically reading installed `.js`; cross-file/transitive throws beyond a small depth, dynamically dispatched calls, and non-standard export shapes are missed (optimistically, without false positives).
+- Backing `.js` files that are minified or larger than 512 KiB are skipped.
+- A bare `"tsc-guard": {}` is inert.
+
 ## API
 
 ### `@esportsplus/typescript`
@@ -242,4 +227,4 @@ This package targets `typescript@^7`, shipped as a regular `dependencies` entry.
 pnpm build       # tsc && tsc-alias
 pnpm test        # vitest run
 pnpm bench:run   # vitest bench --run
-```
+```

package/build/cli/tsc.d.ts

@@ -1,5 +1,5 @@
 import type { Plugin } from '../compiler/types.js';
-import { API } from 'typescript/unstable/sync';
+import { API, type Checker, type Program } from 'typescript/unstable/sync';
 import { stripJsonc } from '../jsonc.js';
 type PluginConfig = {
     transform: string;
@@ -15,6 +15,7 @@ declare function loadPlugins(configs: PluginConfig[], root: string): Promise<Plu
 declare function main(): void;
 declare function normalizePath(fileName: string): string;
 declare function projectPath(args: string[]): string | null;
+declare function runAnalyze(tsconfig: string, program?: Program, checker?: Checker): void;
 declare function resolvePluginConfigs(tsconfig: string): PluginConfig[];
 declare function runTscAlias(args: string[]): Promise<number>;
-export { build, classifyFlags, isPlugin, loadPlugins, main, normalizePath, projectPath, resolvePluginConfigs, runTscAlias, stripJsonc };
+export { build, classifyFlags, isPlugin, loadPlugins, main, normalizePath, projectPath, resolvePluginConfigs, runAnalyze, runTscAlias, stripJsonc };

package/build/cli/tsc.js

@@ -9,9 +9,9 @@ import fs from 'fs';
 import languageService from '../compiler/language-service.js';
 import path from 'path';
 import sourcemap from '../compiler/sourcemap.js';
-import { analyze, analyzeProgram } from '../probe/kernel/analyze.js';
-import { formatDiagnostics } from '../probe/kernel/format.js';
-import { loadConfigFromTsconfig } from '../probe/kernel/config.js';
+import { analyze, analyzeProgram } from '../guard/kernel/analyze.js';
+import { formatDiagnostics } from '../guard/kernel/format.js';
+import { loadConfigFromTsconfig } from '../guard/kernel/config.js';
 import { stripJsonc } from '../jsonc.js';
 import { readPlugins } from '../tsconfig.js';
 const BACKSLASH_REGEX = /\\/g;
@@ -282,22 +282,25 @@ function runAnalyze(tsconfig, program, checker) {
     }
     catch (error) {
         console.error(`${PACKAGE_NAME}: analyze config error: ${error instanceof Error ? error.message : String(error)}`);
-        return;
+        process.exit(1);
     }
     if (!config) {
         return;
     }
+    let result;
     try {
-        let result = program && checker ? analyzeProgram(program, checker, config) : analyze(config);
-        if (result.diagnostics.length > 0) {
-            console.error(formatDiagnostics(result.diagnostics, config.projectRoot));
-            if (config.failOnFindings) {
-                process.exit(1);
-            }
-        }
+        result = program && checker ? analyzeProgram(program, checker, config) : analyze(config);
     }
     catch (error) {
         console.error(`${PACKAGE_NAME}: analyze failed: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+    }
+    if (result.diagnostics.length === 0) {
+        return;
+    }
+    console.error(formatDiagnostics(result.diagnostics, config.projectRoot));
+    if (result.diagnostics.some((diagnostic) => config.channels[diagnostic.channel]?.severity === 'error')) {
+        process.exit(1);
     }
 }
 function passthrough() {
@@ -334,91 +337,6 @@ function spawnTsc(tscJs, args) {
         child.on('exit', (code) => resolve(code ?? 0));
     });
 }
-function legacyStripJsonc(text) {
-    let escaped = false, inBlockComment = false, inLineComment = false, inString = false, stripped = '';
-    for (let i = 0, n = text.length; i < n; i++) {
-        let char = text[i], next = text[i + 1];
-        if (inLineComment) {
-            if (char === '\n') {
-                inLineComment = false;
-                stripped += char;
-            }
-            continue;
-        }
-        if (inBlockComment) {
-            if (char === '*' && next === '/') {
-                inBlockComment = false;
-                i++;
-            }
-            continue;
-        }
-        if (inString) {
-            stripped += char;
-            if (escaped) {
-                escaped = false;
-            }
-            else if (char === '\\') {
-                escaped = true;
-            }
-            else if (char === '"') {
-                inString = false;
-            }
-            continue;
-        }
-        if (char === '"') {
-            inString = true;
-            stripped += char;
-            continue;
-        }
-        if (char === '/' && next === '/') {
-            inLineComment = true;
-            i++;
-            continue;
-        }
-        if (char === '/' && next === '*') {
-            inBlockComment = true;
-            i++;
-            continue;
-        }
-        stripped += char;
-    }
-    escaped = false;
-    inString = false;
-    let result = '';
-    for (let i = 0, n = stripped.length; i < n; i++) {
-        let char = stripped[i];
-        if (inString) {
-            result += char;
-            if (escaped) {
-                escaped = false;
-            }
-            else if (char === '\\') {
-                escaped = true;
-            }
-            else if (char === '"') {
-                inString = false;
-            }
-            continue;
-        }
-        if (char === '"') {
-            inString = true;
-            result += char;
-            continue;
-        }
-        if (char === ',') {
-            let j = i + 1;
-            while (j < n && (stripped[j] === ' ' || stripped[j] === '\n' || stripped[j] === '\r' || stripped[j] === '\t')) {
-                j++;
-            }
-            if (stripped[j] === ']' || stripped[j] === '}') {
-                continue;
-            }
-        }
-        result += char;
-    }
-    return result;
-}
-void legacyStripJsonc;
 function teardown(snapshot, configPath, owned) {
     if (owned) {
         languageService.dispose(configPath);
@@ -431,4 +349,4 @@ function teardown(snapshot, configPath, owned) {
 if (process.env.VITEST === undefined) {
     main();
 }
-export { build, classifyFlags, isPlugin, loadPlugins, main, normalizePath, projectPath, resolvePluginConfigs, runTscAlias, stripJsonc };
+export { build, classifyFlags, isPlugin, loadPlugins, main, normalizePath, projectPath, resolvePluginConfigs, runAnalyze, runTscAlias, stripJsonc };

package/build/{probe → guard}/adapter.d.ts

@@ -9,6 +9,5 @@ declare function forEachChild<T>(node: Node, cb: (child: Node) => T | undefined)
 declare function isClassLike(node: Node): boolean;
 declare function getSourceFiles(program: Program): SourceFile[];
 declare function symbolDeclarations(symbol: Symbol): Node[];
-declare function symbolValueDeclaration(symbol: Symbol): Node | undefined;
 declare function unionTypes(type: Type): readonly Type[] | undefined;
-export { forEachChild, getSourceFiles, isClassLike, symbolDeclarations, symbolValueDeclaration, unionTypes };
+export { forEachChild, getSourceFiles, isClassLike, symbolDeclarations, unionTypes };

package/build/{probe → guard}/adapter.js

@@ -31,12 +31,9 @@ function symbolDeclarations(symbol) {
     }
     return out;
 }
-function symbolValueDeclaration(symbol) {
-    return symbol.valueDeclaration?.resolve();
-}
 function unionTypes(type) {
     return (type.flags & TypeFlags.Union) !== 0
         ? type.getTypes()
         : undefined;
 }
-export { forEachChild, getSourceFiles, isClassLike, symbolDeclarations, symbolValueDeclaration, unionTypes };
+export { forEachChild, getSourceFiles, isClassLike, symbolDeclarations, unionTypes };

package/build/{probe → guard}/async/channel.d.ts

@@ -1,4 +1,4 @@
 import type { Channel } from '../kernel/types.js';
 import { type AsyncValue } from './value.js';
-declare function createAsyncChannel(channelConfig: unknown): Channel<AsyncValue>;
+declare function createAsyncChannel(): Channel<AsyncValue>;
 export { createAsyncChannel };

package/build/{probe → guard}/async/channel.js

@@ -1,48 +1,10 @@
 import * as ts from '../adapter.js';
-import { bodyOf, calleeSelectors, unwrap } from '../kernel/ast.js';
+import { bodyOf, constituents, hasModifier, isAwaited, unwrap } from '../kernel/ast.js';
 import { isFunctionLike, locationOf } from '../kernel/ids.js';
 import { bottom, equals, promise, widen } from './value.js';
 const AGGREGATORS = new Set(['all', 'allSettled', 'race', 'any']);
 const CHAIN_METHODS = new Set(['catch', 'finally', 'then']);
-const OPAQUE_SINKS = new Set(['add', 'push', 'set', 'unshift']);
 const UNBOUNDED_TUPLE_FLAGS = 12;
-function fail(message) {
-    throw new Error(`async: ${message}`);
-}
-function parseOptions(raw) {
-    const obj = typeof raw === 'object' && raw !== null
-        ? raw
-        : {};
-    let fanOut = 'warn';
-    if (obj['fanOut'] !== undefined) {
-        if (obj['fanOut'] !== 'off' &&
-            obj['fanOut'] !== 'warn' &&
-            obj['fanOut'] !== 'error') {
-            fail(`"fanOut" must be "off", "warn", or "error"`);
-        }
-        fanOut = obj['fanOut'];
-    }
-    let allow = 16;
-    if (obj['fanOutAllowLiteralUpTo'] !== undefined) {
-        const n = obj['fanOutAllowLiteralUpTo'];
-        if (typeof n !== 'number' || !Number.isInteger(n) || n < 0) {
-            fail(`"fanOutAllowLiteralUpTo" must be a non-negative integer`);
-        }
-        allow = n;
-    }
-    let poolFunctions = [];
-    if (obj['poolFunctions'] !== undefined) {
-        const p = obj['poolFunctions'];
-        if (!Array.isArray(p) || p.some((v) => typeof v !== 'string')) {
-            fail(`"poolFunctions" must be an array of strings`);
-        }
-        poolFunctions = p;
-    }
-    return { fanOut, fanOutAllowLiteralUpTo: allow, poolFunctions };
-}
-function constituents(type) {
-    return ts.unionTypes(type) ?? [type];
-}
 function isPromiseType(checker, type) {
     if (!type) {
         return false;
@@ -59,22 +21,18 @@ function isPromiseType(checker, type) {
     }
     return false;
 }
-function hasAsyncModifier(node) {
-    const mods = node.modifiers;
-    return mods?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-}
 function enclosingAsync(node) {
     let p = node.parent;
     while (p) {
         if (isFunctionLike(p)) {
-            return hasAsyncModifier(p);
+            return hasModifier(p, ts.SyntaxKind.AsyncKeyword);
         }
         p = p.parent;
     }
     return false;
 }
 function returnsPromise(checker, node) {
-    if (hasAsyncModifier(node)) {
+    if (hasModifier(node, ts.SyntaxKind.AsyncKeyword)) {
         return true;
     }
     const fnType = checker.getTypeAtLocation(node);
@@ -106,9 +64,6 @@ function aggregatorOf(call) {
     }
     return callee.name.text;
 }
-function isAggregatorCall(node) {
-    return ts.isCallExpression(node) && aggregatorOf(node) !== undefined;
-}
 function chainRoot(call) {
     let cur = call;
     while (ts.isPropertyAccessExpression(cur.expression) &&
@@ -174,130 +129,28 @@ function isValueTransparent(node, child) {
     }
     return false;
 }
-function classifyOwnership(node) {
+function isOrphan(node) {
     let child = node;
     let parent = node.parent;
     while (parent && isValueTransparent(parent, child)) {
         child = parent;
         parent = parent.parent;
     }
-    if (!parent) {
-        return 'opaque';
-    }
-    if (ts.isAwaitExpression(parent) || ts.isVoidExpression(parent)) {
-        return 'owned';
-    }
-    if (ts.isReturnStatement(parent) || ts.isYieldExpression(parent)) {
-        return 'owned';
-    }
-    if (ts.isArrowFunction(parent) && parent.body === child) {
-        return 'owned';
-    }
-    if (ts.isVariableDeclaration(parent) && parent.initializer === child) {
-        return 'owned';
-    }
-    if (ts.isPropertyDeclaration(parent) && parent.initializer === child) {
-        return 'owned';
-    }
-    if (ts.isBinaryExpression(parent) &&
-        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-        parent.right === child) {
-        return 'owned';
-    }
-    if (ts.isExpressionStatement(parent)) {
-        return 'orphan';
-    }
-    if (ts.isCallExpression(parent) || ts.isNewExpression(parent)) {
-        if (isAggregatorCall(parent)) {
-            return 'owned';
-        }
-        const callee = parent.expression;
-        if (ts.isPropertyAccessExpression(callee) &&
-            OPAQUE_SINKS.has(callee.name.text)) {
-            return 'opaque';
-        }
-        return 'owned';
-    }
-    if (ts.isArrayLiteralExpression(parent)) {
-        const gp = parent.parent;
-        if (gp && isAggregatorCall(gp)) {
-            return 'owned';
-        }
-        return 'opaque';
-    }
-    return 'opaque';
+    return parent !== undefined && ts.isExpressionStatement(parent);
 }
 function isBoundedInput(env, arg) {
     const e = unwrap(arg);
     if (ts.isArrayLiteralExpression(e)) {
-        if (e.elements.some((el) => ts.isSpreadElement(el))) {
-            return false;
-        }
-        return e.elements.length <= env.options.fanOutAllowLiteralUpTo;
+        return !e.elements.some((el) => ts.isSpreadElement(el));
     }
     const type = env.checker.getTypeAtLocation(e);
     if (type && type.isTupleType()) {
         const flags = type.elementFlags ??
             [];
-        if (flags.some((f) => (f & UNBOUNDED_TUPLE_FLAGS) !== 0)) {
-            return false;
-        }
-        const len = type.fixedLength;
-        return (typeof len === 'number' && len <= env.options.fanOutAllowLiteralUpTo);
-    }
-    return false;
-}
-function moduleMatches(env, call, pkg) {
-    let sym = env.checker.getSymbolAtLocation(call.expression);
-    if (sym && sym.flags & ts.SymbolFlags.Alias) {
-        sym = env.checker.getAliasedSymbol(sym);
-    }
-    if (!sym) {
-        return false;
-    }
-    for (const decl of ts.symbolDeclarations(sym)) {
-        const path = decl.getSourceFile().fileName.replace(/\\/g, '/');
-        if (path.includes(`node_modules/${pkg}/`)) {
-            return true;
-        }
+        return !flags.some((f) => (f & UNBOUNDED_TUPLE_FLAGS) !== 0);
     }
     return false;
 }
-function poolMatches(env, call) {
-    const names = calleeSelectors(call.expression);
-    for (const sel of env.options.poolFunctions) {
-        const hash = sel.indexOf('#');
-        if (hash >= 0) {
-            const obj = sel.slice(0, hash);
-            const method = sel.slice(hash + 1);
-            if (names.has(method) ||
-                names.has(`${obj}.${method}`) ||
-                names.has(`${obj}#${method}`)) {
-                return true;
-            }
-            continue;
-        }
-        if (names.has(sel) || moduleMatches(env, call, sel)) {
-            return true;
-        }
-    }
-    return false;
-}
-function routedThroughPool(env, arg) {
-    let found = false;
-    const visit = (n) => {
-        if (found) {
-            return;
-        }
-        if (ts.isCallExpression(n) && poolMatches(env, n)) {
-            found = true;
-            return;
-        }
-        ts.forEachChild(n, visit);
-    };
-    visit(arg);
-    return found;
-}
 function isAbortSignalType(type) {
     if (!type) {
         return false;
@@ -346,19 +199,6 @@ function callRequiresSignal(env, call) {
         .resolveCall(call)
         .targets.some((t) => env.heldSignalNames(t).size > 0);
 }
-function isAwaited(call) {
-    let child = call;
-    let parent = call.parent;
-    while (parent &&
-        (ts.isParenthesizedExpression(parent) ||
-            ts.isAsExpression(parent) ||
-            ts.isNonNullExpression(parent)) &&
-        parent.expression === child) {
-        child = parent;
-        parent = parent.parent;
-    }
-    return parent !== undefined && ts.isAwaitExpression(parent);
-}
 function forwardsSignal(call, held) {
     let found = false;
     const visit = (n) => {
@@ -404,14 +244,6 @@ function orphanDiagnostic(call) {
         fixes: orphanFixes(call),
     };
 }
-function degradedDiagnostic(call) {
-    return {
-        channel: 'async',
-        message: `result of \`${calleeText(call)}()\` flows into an untracked structure — ownership cannot be verified`,
-        location: locationOf(call, call.getSourceFile()),
-        related: [],
-    };
-}
 function fanOutDiagnostic(call, aggregator) {
     return {
         channel: 'async',
@@ -462,15 +294,12 @@ function cancellationDiagnostic(call, fixes) {
     };
 }
 function checkFanOut(env, call, out) {
-    if (env.options.fanOut === 'off') {
-        return;
-    }
     const aggregator = aggregatorOf(call);
     if (!aggregator) {
         return;
     }
     const arg = call.arguments[0];
-    if (!arg || isBoundedInput(env, arg) || routedThroughPool(env, arg)) {
+    if (!arg || isBoundedInput(env, arg)) {
         return;
     }
     out.push(fanOutDiagnostic(call, aggregator));
@@ -479,14 +308,8 @@ function checkOwnership(env, call, out) {
     if (isChainContinuation(call) || !producesPromise(env, call)) {
         return;
     }
-    const ownership = classifyOwnership(call);
-    if (ownership === 'orphan') {
-        if (!chainHandlesRejection(call)) {
-            out.push(orphanDiagnostic(call));
-        }
-    }
-    else if (ownership === 'opaque' && env.dispatch === 'pessimist') {
-        out.push(degradedDiagnostic(call));
+    if (isOrphan(call) && !chainHandlesRejection(call)) {
+        out.push(orphanDiagnostic(call));
     }
 }
 function checkCancellation(env, call, out) {
@@ -515,8 +338,7 @@ function walk(env, body, out) {
     };
     ts.forEachChild(body, visit);
 }
-function createAsyncChannel(channelConfig) {
-    const options = parseOptions(channelConfig);
+function createAsyncChannel() {
     const heldByFunction = new Map();
     const getHeldSignalNames = (checker, fn) => {
         let held = heldByFunction.get(fn);
@@ -544,8 +366,6 @@ function createAsyncChannel(channelConfig) {
             }
             const env = {
                 checker: ctx.checker,
-                dispatch: ctx.dispatch,
-                options,
                 summaryOf: ctx.summaryOf,
                 resolveCall: ctx.resolveCall,
                 heldSignalNames: (fn) => getHeldSignalNames(ctx.checker, fn),

package/build/{probe → guard}/async/value.d.ts

@@ -3,7 +3,6 @@ type AsyncValue = {
 };
 declare function bottom(): AsyncValue;
 declare function promise(): AsyncValue;
-declare function join(a: AsyncValue, b: AsyncValue): AsyncValue;
 declare function equals(a: AsyncValue, b: AsyncValue): boolean;
 declare function widen(_prev: AsyncValue, next: AsyncValue, _round: number): AsyncValue;
-export { bottom, equals, join, promise, type AsyncValue, widen };
+export { bottom, equals, promise, type AsyncValue, widen };

package/build/{probe → guard}/async/value.js

@@ -4,13 +4,10 @@ function bottom() {
 function promise() {
     return { returnsPromise: true };
 }
-function join(a, b) {
-    return { returnsPromise: a.returnsPromise || b.returnsPromise };
-}
 function equals(a, b) {
     return a.returnsPromise === b.returnsPromise;
 }
 function widen(_prev, next, _round) {
     return next;
 }
-export { bottom, equals, join, promise, widen };
+export { bottom, equals, promise, widen };

package/build/guard/channels.d.ts

@@ -0,0 +1,4 @@
+import type { Channel } from './kernel/types.js';
+import type { ThrowIndex } from './exceptions/derive.js';
+declare function channelFor(name: string, throwIndex: ThrowIndex): Channel<unknown> | undefined;
+export { channelFor };

package/build/guard/channels.js

@@ -0,0 +1,13 @@
+import { createAsyncChannel } from './async/channel.js';
+import { createExceptionsChannel } from './exceptions/channel.js';
+import { createResourcesChannel } from './resources/channel.js';
+const FACTORIES = {
+    async: () => createAsyncChannel(),
+    exceptions: (throwIndex) => createExceptionsChannel(throwIndex),
+    resources: () => createResourcesChannel(),
+};
+function channelFor(name, throwIndex) {
+    const factory = FACTORIES[name];
+    return factory ? factory(throwIndex) : undefined;
+}
+export { channelFor };