@suss/extractor 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1269 @@
+import { Effect, Predicate, TypeShape, RenderNode, CodeUnitKind, BoundaryBinding, BehavioralSummary, ConfidenceInfo, Transition, Gap, Input, Output } from '@suss/behavioral-ir';
+
+type DiscoveryMatch = {
+    type: "namedExport";
+    names: string[];
+} | {
+    type: "registrationCall";
+    importModule: string;
+    importName: string;
+    registrationChain: string[];
+} | {
+    type: "decorator";
+    decoratorModule: string;
+    decoratorName: string;
+} | {
+    type: "fileConvention";
+    filePattern: string;
+    exportNames: string[];
+} | {
+    type: "clientCall";
+    /** Module the client is imported from, or "global" for built-ins like fetch */
+    importModule: string;
+    /** Named export or identifier — e.g. "initClient", "fetch" */
+    importName: string;
+    /** If set, only match calls to these methods on the client (e.g. ["getUser"]).
+     *  Unset means any method call (or bare call for globals). */
+    methodFilter?: string[];
+    /**
+     * Method names on the import that produce a client-equivalent instance,
+     * so variables initialized from those calls also act as discovery
+     * subjects. axios uses `axios.create({...})` to build a baseURL-bound
+     * instance; declaring `factoryMethods: ["create"]` lets the adapter
+     * treat `api.get(...)` (where `api = axios.create(...)`) the same as
+     * `axios.get(...)`.
+     */
+    factoryMethods?: string[];
+} | {
+    /**
+     * A constructor or factory call that takes a configuration object
+     * containing a resolver map — the idiomatic GraphQL code-first
+     * shape. The map is two levels deep: outer keys are GraphQL type
+     * names (`Query`, `Mutation`, `Subscription`, or object-type
+     * names like `User`); inner keys are field names whose values
+     * are resolver functions.
+     *
+     * Example (Apollo Server v4):
+     * ```ts
+     * new ApolloServer({
+     *   typeDefs,
+     *   resolvers: {
+     *     Query:    { users: async () => {...} },
+     *     Mutation: { createUser: async (_, {input}) => {...} },
+     *     User:     { fullName: (parent) => `${parent.first} ${parent.last}` },
+     *   },
+     * });
+     * ```
+     *
+     * Each inner function becomes one discovered unit whose binding
+     * semantics is `graphql-resolver(typeName, fieldName)`. Matches
+     * both `new Ctor(cfg)` and `ctor(cfg)` — Apollo's standalone
+     * server uses `new`, yoga uses a bare call.
+     */
+    type: "resolverMap";
+    importModule: string;
+    importName: string;
+    /**
+     * Name of the property on the config object that holds the
+     * resolver map. Defaults to `"resolvers"` when unset, matching
+     * Apollo / yoga / graphql-tools convention.
+     */
+    mapProperty?: string;
+    /**
+     * GraphQL type names whose fields we DON'T treat as resolvers —
+     * opt-out for meta-types like `Subscription` that we may want
+     * to handle differently later. Unset means discover every type.
+     */
+    excludeTypes?: string[];
+} | {
+    /**
+     * Consumer-side GraphQL hook call — the canonical Apollo Client
+     * and urql shape. Each call to one of the listed hooks becomes
+     * a `client`-kind code unit whose binding semantics is
+     * `graphql-operation(operationType, operationName?)`.
+     *
+     * The document argument resolves through several shapes: an inline
+     * `gql`-tagged template, a const binding (same module or imported
+     * from another module), a `.graphql` / `.gql` file import, and a
+     * generated `TypedDocumentNode` object literal from graphql-codegen
+     * client-preset. When the document body isn't statically readable,
+     * the operation header falls back to the `TypedDocumentNode` type
+     * arguments; a still-unresolvable document surfaces on the summary
+     * as `metadata.graphql.unresolvedDocument` rather than dropping the
+     * boundary.
+     *
+     * Example:
+     * ```ts
+     * import { gql, useQuery } from "@apollo/client";
+     * const GET_USER = gql`query GetUser($id: ID!) { user(id: $id) { id } }`;
+     * function UserPage({ id }) {
+     *   const { data } = useQuery(GET_USER, { variables: { id } });
+     *   ...
+     * }
+     * ```
+     *
+     * The adapter records the operation name / type on the
+     * DiscoveredUnit's `operationInfo`; binding construction uses that
+     * to emit `graphql-operation(...)`. The per-hook `operationType`
+     * is authoritative when the document header can't be read (mirrors
+     * `graphqlImperativeCall.methods`).
+     */
+    type: "graphqlHookCall";
+    importModule: string;
+    /**
+     * Hooks to match on that import, each mapped to the operation
+     * type it performs (`useQuery` → query, `useMutation` → mutation,
+     * `useSubscription` → subscription). The mapping supplies the
+     * operation type when the document body isn't statically readable.
+     * Each hook is reported as `kind = "client"` by default; packs can
+     * override via the enclosing `DiscoveryPattern.kind`.
+     */
+    hooks: Array<{
+        hookName: string;
+        operationType: "query" | "mutation" | "subscription";
+    }>;
+} | {
+    /**
+     * Imperative Apollo-Client-style call — `client.query({ query })`,
+     * `client.mutate({ mutation })`, `client.subscribe({ query })`.
+     * Distinct from hook calls because the document lives on a
+     * config-object property rather than the first positional arg.
+     * Discovery is gated on an import of the named constructor
+     * (typically `ApolloClient`) to reduce false positives — any
+     * method-named "query" on a random object could look like this
+     * shape.
+     *
+     * Each entry in `methods` specifies the method name that gets
+     * called on the client (`"query"` / `"mutate"` / `"subscribe"`)
+     * and the config-object property that holds the gql document
+     * (`"query"` / `"mutation"` / `"query"` respectively). The
+     * method name drives the operation type (query / mutation /
+     * subscription) when the gql document's header is anonymous;
+     * a named document's header wins otherwise.
+     */
+    type: "graphqlImperativeCall";
+    importModule: string;
+    importName: string;
+    methods: Array<{
+        methodName: string;
+        documentKey: string;
+        operationType: "query" | "mutation" | "subscription";
+    }>;
+} | {
+    /**
+     * Treats a TypeScript package's public export surface as a
+     * boundary. The adapter reads `package.json` at
+     * `packageJsonPath`, resolves each reachable entry point
+     * (root `.` and any sub-path `exports`), follows barrel
+     * re-exports, and emits one discovered unit per exported
+     * function — provider side of an in-process `function-call`
+     * boundary.
+     *
+     * Produced bindings carry identity
+     * `{ transport: "in-process",
+     *    semantics: { name: "function-call",
+     *                 package: <pkg.name>,
+     *                 exportPath: [...] },
+     *    recognition: <pack.name> }`.
+     *
+     * Sub-path exports identify as e.g.
+     * `@suss/behavioral-ir/schemas::BehavioralSummarySchema` —
+     * `exportPath = ["schemas", "BehavioralSummarySchema"]`.
+     * Root exports omit the sub-path segment.
+     *
+     * v0 scope: resolves `types` / `default` / `import` conditions
+     * on `exports`, falls back to `types` + `main` + `module`
+     * when no `exports` field is set. Pattern exports (`./utils/*`)
+     * and `development`-conditional resolution are deferred.
+     */
+    type: "packageExports";
+    /** Absolute path to the package's `package.json`. */
+    packageJsonPath: string;
+    /**
+     * Restrict to these `exports` keys (without leading `./`).
+     * The root export is keyed `"."`. Unset means all resolvable
+     * sub-paths.
+     */
+    subPaths?: string[];
+    /**
+     * Export names to skip — typically `["default"]` when a pack
+     * wants to treat default exports separately or not at all.
+     */
+    excludeNames?: string[];
+} | {
+    /**
+     * Class methods that carry a specific decorator, on classes that
+     * carry a specific class-level decorator. Used by NestJS-style
+     * frameworks where resolvers / handlers / controllers are
+     * declared by decorator, not by registering a function in an
+     * object literal.
+     *
+     * Discovery gates on an `importModule` of `classDecorator` and
+     * each `methodDecorators` entry — random user-defined decorators
+     * with the same names won't trip the matcher.
+     *
+     * For a NestJS GraphQL pack:
+     * `{ importModule: "@nestjs/graphql",
+     *    classDecorator: "Resolver",
+     *    methodDecorators: ["Query", "Mutation", "ResolveField",
+     *                       "Subscription"] }`
+     *
+     * The adapter populates `DiscoveredUnit.resolverInfo` so the
+     * produced binding carries `graphql-resolver(typeName, fieldName)`.
+     * `typeName` resolves from the class decorator's first argument
+     * (`@Resolver(() => User)` → `"User"`); when the class decorator
+     * has no argument it defaults to the operation kind (`"Query"`,
+     * `"Mutation"`, `"Subscription"`). `fieldName` reads the method
+     * decorator's `{ name }` option override when present, otherwise
+     * the method name.
+     */
+    type: "decoratedMethod";
+    /**
+     * The module a pack-recognised decorator must be imported from
+     * for discovery to fire. Codebases sometimes wrap framework
+     * decorators in their own re-exports (NestJS apps frequently
+     * declare `MetadataResolver` / `CoreResolver` factories that
+     * compose `@Resolver()` with extra metadata). When that happens,
+     * the import-module gate would miss them; pass an array of
+     * accepted modules and any one match suffices.
+     */
+    importModule: string | string[];
+    /**
+     * Class decorator names to recognise. The first entry that
+     * appears on a class wins for typeName extraction (the rest are
+     * fallbacks for codebases with multiple wrapper styles).
+     */
+    classDecorators: string[];
+    methodDecorators: string[];
+} | {
+    /**
+     * NestJS-style REST controller discovery. Class decorated with
+     * `@Controller(pathPrefix?)`; methods decorated with
+     * `@Get(subpath?)` / `@Post` / `@Put` / `@Delete` / etc. The
+     * decorator NAME determines the HTTP method via
+     * `methodDecoratorRouteMap`; the route path is the class
+     * decorator's first arg + the method decorator's first arg
+     * (slash-joined, both optional).
+     *
+     * Same wrapper-decorator tolerance as `decoratedMethod`: the
+     * import-module gate fires on at least one method-route
+     * decorator from the framework module, but class decorators
+     * match by name only so project-internal wrappers
+     * (`@PublicController` / `@AuthedController` factories
+     * composing `@Controller()`) work without per-project pack
+     * config.
+     *
+     * The adapter populates `DiscoveredUnit.routeInfo` so the
+     * produced binding carries `rest(method, path)`.
+     */
+    type: "decoratedRoute";
+    importModule: string | string[];
+    classDecorators: string[];
+    /**
+     * Decorator name → HTTP method. NestJS uses one decorator per
+     * verb (`@Get` / `@Post` / `@Put` / `@Delete` / `@Patch` /
+     * `@Options` / `@Head` / `@All`); other frameworks may follow
+     * the same convention. The values become the `method` field on
+     * the produced REST binding; `"*"` is acceptable for catch-all
+     * decorators.
+     */
+    methodDecoratorRouteMap: Record<string, string>;
+} | {
+    /**
+     * Loop expansion: a `for-of` loop over a literal array of
+     * route specs is treated as if each element were an inline
+     * registration. Used for patterns like:
+     *
+     *   const routes = [
+     *     { method: "get", path: "/users", handler: getUsers },
+     *     ...
+     *   ];
+     *   for (const r of routes) app[r.method](r.path, r.handler);
+     *
+     * `elementShape` declares which keys on each element carry the
+     * method, path, and handler. The loop body is required to
+     * contain at least one call expression that references the
+     * loop variable (filters out unrelated loops); the call's
+     * shape itself is not checked beyond that.
+     *
+     * Iterables that resolve to an `ArrayLiteralExpression` (inline
+     * or single-hop `const`-bound) are expanded; cross-file or
+     * computed iterables are out of v0 scope.
+     *
+     * Pack-author docs: `docs/internal/proposals/dynamic-registration.md`.
+     */
+    type: "registrationLoop";
+    elementShape: {
+        methodKey: string;
+        pathKey: string;
+        handlerKey: string;
+    };
+} | {
+    /**
+     * Helper-call expansion: a single function call at the user
+     * site is treated as if it were N inline registrations, with
+     * arguments substituted into per-registration templates. Used
+     * for patterns like `registerCrud(app, 'users', userHandlers)`
+     * that today's `registrationCall` discovery can't see.
+     *
+     * Each entry in `registrations` describes one virtual route
+     * the helper produces. `pathTemplate` and `handlerArg` use
+     * `{N}` placeholders that resolve to the call's positional
+     * arguments. `{N}` substitutes the argument's literal value
+     * (for string-literal args) or its source text (for
+     * non-literal args, with the slot marked opaque). `{N}.prop`
+     * reads `prop` from the argument's resolved object.
+     *
+     * `importModule` optionally narrows matches to helpers
+     * imported from a specific module — useful when two packages
+     * happen to export a function with the same name.
+     *
+     * Pack-author docs: `docs/internal/proposals/dynamic-registration.md`.
+     */
+    type: "registrationTemplate";
+    helperName: string;
+    importModule?: string;
+    registrations: Array<{
+        method: string;
+        pathTemplate: string;
+        handlerArg: string;
+    }>;
+} | {
+    /**
+     * Consumer side of the package-export boundary. Scans source
+     * files for imports of the named packages and records every
+     * call site, emitting one `caller`-kind unit per enclosing
+     * function. Produced bindings carry
+     * `function-call { package, exportPath }` matching the
+     * provider summaries from `packageExports`.
+     *
+     * `packages` is a list of exact package names (possibly with a
+     * sub-path, e.g. `"@suss/behavioral-ir/schemas"`) whose imports
+     * to track. Pass multiple package names to track a family at
+     * once. Imports of any other package are ignored.
+     *
+     * v0 scope: named imports + default imports. Namespace imports
+     * (`import * as X from`) are not yet tracked. Re-imports within
+     * the consumer repo (consumer A imports from consumer B which
+     * re-exports from pkg) produce units against the intermediate,
+     * not the original — full symbol resolution is deferred.
+     */
+    type: "packageImport";
+    packages: string[];
+};
+type BindingExtraction = {
+    method: {
+        type: "fromRegistration";
+        position: "methodName" | number;
+    } | {
+        type: "fromExportName";
+    } | {
+        type: "fromContract";
+    } | {
+        type: "fromClientMethod";
+    } | {
+        type: "fromArgumentProperty";
+        position: number;
+        property: string;
+        default?: string;
+    } | {
+        type: "literal";
+        value: string;
+    };
+    path: {
+        type: "fromRegistration";
+        position: number;
+    } | {
+        type: "fromFilename";
+    } | {
+        type: "fromContract";
+    } | {
+        type: "fromClientMethod";
+    } | {
+        type: "fromArgumentLiteral";
+        position: number;
+    };
+};
+interface DiscoveryPattern {
+    /** The kind of code unit this discovers: "handler", "loader", "action", "component", etc. */
+    kind: string;
+    match: DiscoveryMatch;
+    bindingExtraction?: BindingExtraction;
+    /**
+     * Files whose import declarations include any of these module
+     * specifiers (or sub-paths of them) get this pattern's discovery
+     * dispatch. Empty array = no gate (pattern is dispatched against
+     * every file). Undefined = treated as no gate, but pack authors
+     * SHOULD declare it explicitly — the `[]` form is the deliberate
+     * "match every file" choice (typically because the pattern keys on
+     * something other than imports — e.g. the fetch runtime matching
+     * global `fetch(...)` calls).
+     *
+     * Match semantics: prefix on the import module specifier. An entry
+     * `"@nestjs/graphql"` matches `from "@nestjs/graphql"` AND
+     * `from "@nestjs/graphql/dist/foo"` AND any other sub-path.
+     *
+     * Pre-filter is purely a perf optimisation: the closure walk and
+     * other post-passes still have access to every loaded file via
+     * symbol resolution.
+     */
+    requiresImport?: string[];
+}
+type TerminalMatch = {
+    type: "returnShape";
+    requiredProperties?: string[];
+} | {
+    type: "returnStatement";
+    /**
+     * Skip ReturnStatements whose returned expression is a CallExpression
+     * (or NewExpression). For frameworks where `return reply.send(...)`
+     * also lands as a `parameterMethodCall` match on the inner call,
+     * this prevents the same `return reply.send(...)` from producing
+     * two terminals — one from the wrapping returnStatement, one from
+     * the inner method-call chain. Bare returns (`return user`,
+     * `return { id }`, `return await fn()`) still match.
+     */
+    excludeCallReturns?: boolean;
+} | {
+    type: "parameterMethodCall";
+    parameterPosition: number;
+    methodChain: string[];
+} | {
+    type: "throwExpression";
+    constructorPattern?: string;
+} | {
+    type: "functionCall";
+    functionName: string;
+    /**
+     * Only match when the name was imported from one of these modules.
+     * Same name, shape, and prefix semantics as a DiscoveryPattern's
+     * gate: "react-router" also matches "react-router/server".
+     *
+     * Set it whenever the function belongs to a library, because
+     * matching a bare name claims every same-named function in the
+     * user's project too. `json` is a common name for a project's own
+     * response helper, and reading a library's argument order into one
+     * of those produces a confident wrong answer.
+     *
+     * Leave it unset only when the function is not a library's at all.
+     * A pack should generally not name a project's own helper: declare
+     * the envelope shape instead, through a `returnShape` terminal, and
+     * the adapter follows a returned call into the project and reads
+     * the helper's parameters. That covers helpers whatever they are
+     * named and in whichever argument order they were written.
+     */
+    requiresImport?: string[];
+} | {
+    /**
+     * Return statement whose value is a JSX element or fragment. The
+     * root element/component name is recorded in RawTerminal.component.
+     * Used by React (and any other JSX-based framework pack) to
+     * classify component outputs as `render` terminals.
+     */
+    type: "jsxReturn";
+} | {
+    /**
+     * Synthetic terminal for the implicit fall-through at the end of a
+     * function body. Fires when the function has no explicit
+     * `ReturnStatement` / `ThrowStatement` as its last statement —
+     * covers the common case of handler / effect bodies that execute
+     * side-effects and return `undefined` implicitly. Without this,
+     * handler summaries come out with `transitions: []` because
+     * `findTerminals` has nothing to match. Packs that always expect
+     * explicit returns (HTTP handlers) shouldn't include this in
+     * their terminals; packs for callback bodies (React handlers,
+     * `useEffect` bodies, Node `.on(...)` callbacks) should.
+     */
+    type: "functionFallthrough";
+};
+interface TerminalExtraction {
+    statusCode?: {
+        from: "property";
+        name: string;
+    } | {
+        from: "argument";
+        position: number;
+        minArgs?: number;
+    } | {
+        from: "constructor";
+        codes: Record<string, number>;
+    } | {
+        from: "argumentConstructor";
+        position: number;
+        codes: Record<string, number>;
+    };
+    body?: {
+        from: "property";
+        name: string;
+        unwrapJsonStringify?: boolean;
+    } | {
+        from: "argument";
+        position: number;
+        minArgs?: number;
+    };
+    /** Fallback status code when none is extracted. e.g. Express res.json() defaults to 200. */
+    defaultStatusCode?: number;
+}
+interface TerminalPattern {
+    /** What kind of output this terminal produces: "response", "throw", "return", "render" */
+    kind: "response" | "throw" | "return" | "render";
+    match: TerminalMatch;
+    extraction: TerminalExtraction;
+}
+interface ContractPattern {
+    /** How to find the contract object. Contracts are data structures, not code units,
+     *  so this is a simpler shape than DiscoveryPattern. */
+    discovery: {
+        importModule: string;
+        importName: string;
+        registrationChain: string[];
+    };
+    responseExtraction: {
+        /** Property on the contract object that holds the responses map */
+        property: string;
+    };
+    paramsExtraction?: {
+        property: string;
+    };
+}
+type InputMappingPattern = {
+    /** Single object parameter, e.g. React Router LoaderFunctionArgs */
+    type: "singleObjectParam";
+    paramPosition: number;
+    /** Property name → role, e.g. { params: "pathParams", request: "request" } */
+    knownProperties: Record<string, string>;
+} | {
+    /** Positional parameters, e.g. Express (req, res, next) */
+    type: "positionalParams";
+    params: Array<{
+        position: number;
+        role: string;
+    }>;
+} | {
+    /** Destructured from framework call, e.g. ts-rest { params, body, query } */
+    type: "destructuredObject";
+    /** Property name → role, e.g. { params: "pathParams", body: "requestBody" } */
+    knownProperties: Record<string, string>;
+} | {
+    /**
+     * Component props, React / Vue / Svelte-style: one parameter that
+     * the caller destructures at will, with prop names only visible at
+     * the call site. When the parameter is destructured, each bound
+     * name becomes its own Input with role equal to the name. When
+     * it's not destructured (e.g. `function X(props) {...}`), one
+     * Input is emitted with `wholeParamRole` (default `"props"`).
+     *
+     * Differs from `destructuredObject` in that prop names are not
+     * declared by the pack up-front — they are whatever the component
+     * author wrote. Differs from `singleObjectParam` in that the
+     * destructuring pattern is honored when present.
+     */
+    type: "componentProps";
+    paramPosition: number;
+    /** Role for the single Input when the param is not destructured. Defaults to "props". */
+    wholeParamRole?: string;
+} | {
+    /**
+     * Emit one `Input` per declared parameter, in source order, with
+     * `role = param name` (or `defaultRole` when set). Used by the
+     * reachable-closure pass for internal library functions — there
+     * is no framework-declared role space, so the caller-visible
+     * name IS the role. Captures destructured-parameter bindings the
+     * same way `destructuredObject` does, so `(ctx, { userId })`
+     * reads as two inputs: `ctx` and `userId`.
+     */
+    type: "allPositional";
+    defaultRole?: string;
+} | {
+    /**
+     * Decorator-driven parameter mapping (NestJS-style). For each
+     * declared parameter, the adapter reads the parameter's first
+     * decorator and looks up its name in `decoratorRoleMap` —
+     * matched decorators map the parameter to that role; unmatched
+     * parameters fall back to `defaultRole` (or skip when unset).
+     *
+     * For `@nestjs/graphql` resolvers:
+     * `{ "Args": "args", "Parent": "parent",
+     *    "Context": "context", "Info": "info" }`.
+     *
+     * Decorator gating is by name only — multiple frameworks
+     * defining `@Args` would all map. Packs that need to
+     * disambiguate by import module add it later when the use case
+     * justifies the cost.
+     */
+    type: "decoratedParams";
+    decoratorRoleMap: Record<string, string>;
+    defaultRole?: string;
+};
+/**
+ * What a property on the API response object semantically represents.
+ * Declared in the pack so the adapter can resolve derived properties
+ * (e.g. `.ok` → status range 200–299) at extraction time.
+ */
+type ResponsePropertyMeaning = {
+    type: "statusCode";
+} | {
+    type: "statusRange";
+    min: number;
+    max: number;
+} | {
+    type: "body";
+} | {
+    type: "headers";
+};
+interface ResponsePropertyMapping {
+    /** Property or method name on the response (e.g. "ok", "status", "json") */
+    name: string;
+    /** How this member is accessed: property read or method call */
+    access: "property" | "method";
+    /** What the value semantically represents */
+    semantics: ResponsePropertyMeaning;
+}
+interface PatternPack {
+    name: string;
+    /**
+     * Pack version stamp — feeds the cache invalidation key. Bump on
+     * any change that affects discovered units / extracted summaries.
+     * Format is opaque to the adapter; semver is the obvious choice
+     * but a content hash, build SHA, or monotonic integer works too.
+     * Optional — packs that omit it use the literal string `"unset"`,
+     * which means cache entries from one process to the next aren't
+     * meaningfully versioned (suitable for development; production
+     * packs should declare a version).
+     */
+    version?: string;
+    languages: string[];
+    discovery: DiscoveryPattern[];
+    terminals: TerminalPattern[];
+    contractReading?: ContractPattern;
+    inputMapping: InputMappingPattern;
+    /**
+     * Transport (wire protocol) used in the `BoundaryBinding.transport`
+     * of discovered units. Every pack states its transport explicitly
+     * rather than leaning on a hardcoded HTTP default — "what transport
+     * does this pack cover?" is a question every pack should have to
+     * answer, and making the field required keeps future packs (React,
+     * GraphQL, Lambda-invoke, queues) from silently inheriting an
+     * HTTP-shaped default that doesn't fit.
+     *
+     * The pack's `name` separately populates `BoundaryBinding.recognition`
+     * on produced summaries — so `{ transport, recognition }` come from
+     * the pack directly, and `semantics` is derived by the adapter from
+     * the discovery pattern's binding-extraction rules.
+     */
+    protocol: string;
+    /**
+     * Semantics of properties on the API response object (consumer side).
+     * Tells the adapter how to resolve derived properties like `.ok` or
+     * `.json()` to structured IR constructs instead of leaving them opaque.
+     */
+    responseSemantics?: ResponsePropertyMapping[];
+    /**
+     * Synthesize additional code units from a parent unit's body —
+     * "one user-authored construct implicitly spawns multiple
+     * runtime-scheduled units." Used when a framework's runtime
+     * schedules callbacks that aren't visible as top-level declarations:
+     * React event handlers on JSX elements, React `useEffect` bodies,
+     * Node `emitter.on("event", handler)`, class-component lifecycle
+     * methods, and similar.
+     *
+     * `ctx` is typed `unknown` here because the extractor has no
+     * knowledge of which adapter is driving it; each language adapter
+     * defines its own context shape (e.g. `TsSubUnitContext` in
+     * `@suss/adapter-typescript`) with the primitives packs need to
+     * walk the parent's AST. Packs import and cast to the adapter
+     * context they're written against — the cast is the explicit
+     * "this pack requires the TypeScript adapter" contract.
+     *
+     * Returned units are fed through the adapter's extraction pipeline
+     * the same way top-level discovered units are, so each becomes its
+     * own `BehavioralSummary`. Carry per-unit `terminals` and
+     * `inputMapping` on the `DiscoveredUnit` if the sub-unit's shape
+     * differs from the parent pack's defaults.
+     */
+    subUnits?: (parent: DiscoveredSubUnitParent, ctx: unknown) => DiscoveredSubUnit[];
+    /**
+     * Pack-supplied top-level discovery callback. Sibling of `subUnits`
+     * for the discovery layer: when a framework's discovery convention
+     * doesn't fit one of the data-driven `DiscoveryMatch` variants (REST
+     * registration, decorator-based controllers, named-export shapes,
+     * etc.), the pack ships its own walker here. The adapter calls it
+     * once per source file alongside the data-driven dispatch.
+     *
+     * Use this for framework-specific shapes that don't generalize:
+     * React's component-export heuristic (PascalCase + JSX-return),
+     * Vue's `.vue` SFC slots, Solid's component conventions, Storybook's
+     * `.stories.tsx` file convention. These are real conventions but
+     * baking each into the central `DiscoveryMatch` union forces every
+     * unrelated pack to know about them. Callbacks keep the central
+     * union for the generic primitives and let packs own their own
+     * conventions.
+     *
+     * `ctx` is typed `unknown` for the same reason as `subUnits` — each
+     * adapter ships its own context primitive (`TsDiscoveryContext` in
+     * `@suss/adapter-typescript`) and packs cast to whichever they're
+     * written against. The cast is the "I require the TS adapter"
+     * contract.
+     *
+     * Returned units flow through the adapter's normal pipeline — they
+     * get terminals + effects extracted, sub-units synthesized, and
+     * summaries assembled exactly as units from data-driven discovery
+     * do. Per-unit `terminals` / `inputMapping` overrides on
+     * `DiscoveredUnit` work the same way.
+     *
+     * **Cross-pack dedup.** When this callback discovers a unit at the
+     * same `(func, kind)` as a unit from another pack's data-driven
+     * discovery, the cross-pack claim dedup in the adapter keeps the
+     * first claimant. Pack ordering in the framework list is the
+     * precedence signal.
+     */
+    discoverUnits?: (sourceFile: unknown, ctx: unknown) => DiscoveredCustomUnit[];
+    /**
+     * Per-call-site recognizers that emit typed `Effect`s alongside the
+     * generic `invocation` effect the adapter already captures.
+     *
+     * **Scope contract.** The adapter walks every CallExpression in
+     * the function body and dispatches to every registered recognizer
+     * for each call. Walking skips nested function bodies (those are
+     * their own units with their own recognizer dispatch). The walk is
+     * INDEPENDENT of the existing invocation-effect walker — the
+     * existing walker is intentionally narrow (only captures
+     * `invocation` effects from bare expression statements + container
+     * composition, to avoid double-counting calls that already become
+     * terminals). Recognizers don't have that concern; they fire on
+     * every call regardless of position, including
+     * `const x = await fn(...)` initializers and nested call args
+     * (which the invocation walker skips). This independence means
+     * recognizer authors can rely on seeing every call in scope.
+     *
+     * **Cross-pack visibility.** Recognizers fire regardless of which
+     * pack discovered the enclosing function — so
+     * `@suss/framework-prisma`'s recognizer can fire on Prisma calls
+     * inside an `@suss/framework-express` handler. Pack authors don't
+     * need to coordinate.
+     *
+     * **Emission contract.** Returning effects ADDS them to the
+     * enclosing default-branch transition; the generic `invocation`
+     * effect is preserved either way (typed effects coexist with raw
+     * call capture so inspect rendering keeps callee text + args while
+     * the checker pairs on the typed shape). Returning `null` / `[]`
+     * is the no-match path.
+     *
+     * **Dedup is the recognizer's responsibility.** The dispatcher
+     * doesn't dedupe across calls. A recognizer that wants to fire
+     * once per identifier (e.g., to dedupe reads bound to a const
+     * that's used N times) tracks its own state across invocations.
+     *
+     * **Exceptions are caught and logged.** A recognizer that throws
+     * is logged to stderr with file path + line number and skipped
+     * for that call; the extraction continues. Buggy recognizers
+     * don't crash the run.
+     *
+     * `call` is the language adapter's call-expression handle (opaque
+     * here; ts-morph `CallExpression` in `@suss/adapter-typescript`).
+     * `ctx` is the adapter's recognizer context (source file, an
+     * `extractArgs()` helper that reuses the adapter's own EffectArg
+     * builder). Recognizers cast both to the adapter context they're
+     * written against — same "this pack requires the TypeScript
+     * adapter" contract `subUnits` uses.
+     */
+    invocationRecognizers?: InvocationRecognizer[];
+    /**
+     * Optional pack-level import gate. When set, the adapter's
+     * pre-filter only considers this pack applicable to source files
+     * whose imports include at least one of the listed modules
+     * (prefix match — `"@aws-sdk/client-sqs"` matches that module
+     * AND any `"@aws-sdk/client-sqs/sub-path"`).
+     *
+     * Useful for recognizer-only packs that target a specific library:
+     * `@suss/framework-aws-sqs` declares `["@aws-sdk/client-sqs"]`,
+     * `@suss/framework-prisma` declares `["@prisma/client"]`. Without
+     * a gate, recognizer-only packs walk every file in the project —
+     * correct but wasted work on large monorepos where most files
+     * don't import the library.
+     *
+     * Discovery-pattern packs already have per-pattern `requiresImport`
+     * on `DiscoveryPattern`; this is the pack-level equivalent for
+     * packs whose ONLY mechanism is recognizers (no discovery).
+     *
+     * Empty / undefined means "no gate" — pack walks every file (the
+     * default for truly universal recognizers like `@suss/runtime-node`'s
+     * process-surface / env-var recognizers, since `process.*` is
+     * available without an import).
+     */
+    requiresImport?: string[];
+    /**
+     * Per-property-access recognizers — sister to
+     * `invocationRecognizers` but firing on `PropertyAccessExpression`
+     * nodes rather than `CallExpression` nodes. Use these for patterns
+     * that read a value through property access without invoking it:
+     * `process.env.X` env-var reads, `Date.now()`-style time reads
+     * (which is actually a call, see invocationRecognizers), bare
+     * `module.constant` reads, etc.
+     *
+     * Same scope rules as invocationRecognizers — fires on every
+     * PropertyAccessExpression in the function body, skipping nested
+     * function bodies. Same emission contract: returned effects land
+     * on the enclosing default-branch transition.
+     *
+     * Same reasoning as invocationRecognizers for the opaque-arg /
+     * adapter-narrows pattern.
+     */
+    accessRecognizers?: AccessRecognizer[];
+}
+/**
+ * Per-call-site recognizer hook. See `PatternPack.invocationRecognizers`
+ * for the contract and threading model.
+ */
+type InvocationRecognizer<TCtx = unknown> = (call: unknown, ctx: TCtx) => Effect[] | null;
+/**
+ * Per-property-access recognizer hook. See
+ * `PatternPack.accessRecognizers` for the contract and threading model.
+ */
+type AccessRecognizer<TCtx = unknown> = (access: unknown, ctx: TCtx) => Effect[] | null;
+/**
+ * Minimal handle-shaped description of the parent code unit that
+ * `subUnits` operates within. `func` is left opaque here — the
+ * language adapter brands its own FunctionRoot type. This interface
+ * lives in the extractor only so `PatternPack` can name it;
+ * adapter-level context types (`TsSubUnitContext`) narrow `func` to
+ * a concrete AST handle.
+ */
+interface DiscoveredSubUnitParent {
+    /** Handle to the parent's function body. Opaque at extractor level. */
+    func: unknown;
+    /** Discovered name of the parent (e.g. "Counter"). */
+    name: string;
+    /** Kind of the parent (usually "component", "handler", etc.). */
+    kind: string;
+}
+/**
+ * What a pack's `discoverUnits` hook returns per discovered top-level
+ * unit. Mirrors `DiscoveredSubUnit` for the discovery layer — the
+ * adapter widens these into its own internal `DiscoveredUnit` type
+ * (which carries adapter-specific fields like `routeInfo`,
+ * `packageExportInfo`, etc.) and pipes them through the normal
+ * extraction pipeline.
+ *
+ * Pack authors stay in opaque-handle land — `func` is whatever the
+ * adapter's primitive returns. Adapter-narrows this to its concrete
+ * function-root type (e.g. `FunctionRoot` in
+ * `@suss/adapter-typescript`).
+ */
+interface DiscoveredCustomUnit {
+    /** Function body handle, opaque here. */
+    func: unknown;
+    /** IR code-unit kind (e.g. "component", "handler"). */
+    kind: string;
+    /** Discovered name (e.g. "UserCard"). */
+    name: string;
+    /**
+     * Terminal patterns to extract from this unit's body. Defaults to
+     * the pack-level `terminals` when unset.
+     */
+    terminals?: TerminalPattern[];
+    /**
+     * Input mapping for this unit. Defaults to the pack-level
+     * `inputMapping` when unset.
+     */
+    inputMapping?: InputMappingPattern;
+    /**
+     * REST route identity for units a callback discovers against an
+     * external manifest (a SAM/CFN template's `Events` block, an infra
+     * routing declaration, etc.) rather than an in-code registration.
+     * When set, the adapter builds a `rest` binding from `(method, path)`
+     * — the same binding NestJS controllers get via decorator-derived
+     * `routeInfo`, without the discoverUnits callback needing to reach
+     * into the adapter's binding machinery.
+     *
+     * One function bound to several routes emits one DiscoveredCustomUnit
+     * per route; the adapter's per-file claim dedup keys on
+     * `(func, kind, method, path)` so the variants survive.
+     */
+    routeInfo?: {
+        method: string;
+        path: string;
+    };
+    /**
+     * Metadata merged onto the resulting summary's `metadata` field.
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * What a pack's `subUnits` hook returns per synthesized child. The
+ * adapter pipes each of these through the same extraction + assembly
+ * pipeline used for top-level-discovered units.
+ */
+interface DiscoveredSubUnit {
+    /** Function body handle, opaque here. */
+    func: unknown;
+    /** IR code-unit kind (e.g. "handler"). */
+    kind: string;
+    /** Qualified name (e.g. "Counter.button.onClick"). */
+    name: string;
+    /**
+     * Terminal patterns to extract from this sub-unit's body. Defaults
+     * to `return` + `throw` when unset — fits handlers / effects cleanly.
+     */
+    terminals?: TerminalPattern[];
+    /**
+     * Input mapping for this sub-unit. Defaults to an empty positional
+     * mapping when unset — event handlers with one arg should pass
+     * `{ type: "positionalParams", params: [{ position: 0, role: "event" }] }`.
+     */
+    inputMapping?: InputMappingPattern;
+    /**
+     * Metadata merged onto the resulting summary's `metadata` field.
+     * Packs use this to stamp provenance (`metadata.react = { kind: "handler", ... }`).
+     */
+    metadata?: Record<string, unknown>;
+}
+
+/**
+ * Build the `discovery` entries for an HTTP-server framework whose
+ * handlers are registered via `app.get(path, handler)` /
+ * `router.post(...)` / etc.
+ *
+ * Each `importNames` entry produces one DiscoveryPattern — libraries
+ * typically expose both a default export and a named export that both
+ * produce the routable instance (e.g. Express has `express()` and
+ * `Router()`; Fastify has `fastify()` and `Fastify`). The binding
+ * extraction (method from registration, path from position 0) is
+ * identical across every HTTP server framework we support.
+ *
+ * Callers still supply the `methods` list directly: different
+ * frameworks support different HTTP verbs (Fastify includes `.head` /
+ * `.options`, Express historically does not by default).
+ *
+ * @example
+ *   discovery: httpRouteDiscovery({
+ *     importModule: "express",
+ *     importNames: ["Router", "express"],
+ *     methods: [".get", ".post", ".put", ".delete", ".patch"],
+ *   })
+ */
+declare function httpRouteDiscovery(opts: {
+    importModule: string;
+    importNames: readonly string[];
+    methods: readonly string[];
+    /** Defaults to "handler". Override for packs that want a different kind. */
+    kind?: string;
+}): DiscoveryPattern[];
+
+interface RawParameter {
+    name: string;
+    position: number;
+    role: string;
+    typeText: string | null;
+}
+interface RawCondition {
+    sourceText: string;
+    structured: Predicate | null;
+    polarity: "positive" | "negative";
+    source: "explicit" | "earlyReturn" | "earlyThrow" | "catchBlock";
+}
+interface RawTerminal {
+    kind: "response" | "throw" | "return" | "render" | "delegate" | "emit" | "void";
+    statusCode: {
+        type: "literal";
+        value: number;
+    } | {
+        type: "dynamic";
+        sourceText: string;
+    } | null;
+    body: {
+        typeText: string | null;
+        shape: TypeShape | null;
+    } | null;
+    exceptionType: string | null;
+    message: string | null;
+    /** For render terminals: the component being rendered */
+    component: string | null;
+    /**
+     * For render terminals (JSX / component-tree output): the nested
+     * render tree if the pack's extractor can produce one. Flows
+     * through to `Output.render.root`. Absent when the extractor sees
+     * only the root element name or opted out of tree extraction.
+     */
+    renderTree: RenderNode | null;
+    /** For delegate terminals: where control is passed */
+    delegateTarget: string | null;
+    /** For emit terminals: the event/channel name */
+    emitEvent: string | null;
+    location: {
+        start: number;
+        end: number;
+    };
+}
+/**
+ * A structured capture of an invocation argument. Literal values
+ * (string, number, boolean), object/array literals, template literals,
+ * identifier references, and nested call expressions are all captured
+ * as structured variants so readers can see *what* was passed even when
+ * the runtime value isn't statically resolvable. `null` is reserved for
+ * the rare case where the argument shape doesn't match any variant
+ * (type assertions with computed operands, arithmetic, etc.) — the
+ * caller still knows how many arguments the call had.
+ *
+ * Useful for recognising literal-string discriminators like
+ * `findings.push({ kind: "scenarioCoverageGap" })` or
+ * `dispatch({ type: "USER_LOGGED_IN" })` at the summary level, and for
+ * preserving argument *shape* (`{ userId, count }`, `getUser(id)`) so
+ * downstream consumers (AI agents, error-taxonomy tooling,
+ * release-note generators) can reason about composition without
+ * re-reading source.
+ */
+type EffectArg = {
+    kind: "string";
+    value: string;
+} | {
+    kind: "number";
+    value: number;
+} | {
+    kind: "boolean";
+    value: boolean;
+} | {
+    kind: "object";
+    fields: Record<string, EffectArg>;
+} | {
+    kind: "array";
+    items: EffectArg[];
+}
+/**
+ * Template literal with interpolation (`` `Error: ${e.message}` ``).
+ * The resolved runtime value is unknown, but the source text is
+ * preserved so readers can see which variables compose it — useful
+ * for log messages, computed keys, and dedup-style key builders.
+ */
+ | {
+    kind: "template";
+    sourceText: string;
+}
+/**
+ * Identifier reference — a bare variable (`userId`), a property-access
+ * chain (`user.profile.email`, `process.env.DATABASE_URL`), or an
+ * element-access chain (`config["host"]`). `name` holds the full
+ * source text so readers can tell which binding flowed into the call
+ * without inferring it from context. Identifiers that resolve to a
+ * module-level `const` with a simple initializer (literal, process.env
+ * access, etc.) are inlined to the initializer's EffectArg form so
+ * closure-over-constants doesn't hide the actual value at call sites.
+ */
+ | {
+    kind: "identifier";
+    name: string;
+}
+/**
+ * Nested call expression passed as an argument — `log(formatError(e))`,
+ * `enqueue(buildPayload(ctx))`, inline composition. `callee` is the
+ * source text of the call target; `args` recurses with bounded depth,
+ * so `formatError(e)` reads as `{ callee: "formatError", args: [...] }`
+ * rather than an opaque null.
+ */
+ | {
+    kind: "call";
+    callee: string;
+    args: EffectArg[];
+} | null;
+type RawEffect = {
+    type: "mutation";
+    target: string;
+    operation: "create" | "update" | "delete";
+} | {
+    type: "invocation";
+    callee: string;
+    args: EffectArg[];
+    async: boolean;
+    /**
+     * Ancestor if/switch/ternary conditions that gate reaching this
+     * call. Populated for calls nested inside conditional blocks or
+     * loop bodies; empty for top-level (always-fires) calls.
+     * Converts to `Effect.preconditions: Predicate[]` in the IR —
+     * same RawCondition → Predicate pipeline transitions use.
+     */
+    preconditions?: RawCondition[];
+} | {
+    type: "emission";
+    event: string;
+} | {
+    type: "stateChange";
+    variable: string;
+};
+interface RawBranch {
+    conditions: RawCondition[];
+    terminal: RawTerminal;
+    effects: RawEffect[];
+    /**
+     * Pre-typed `Effect`s emitted by `PatternPack.invocationRecognizers`.
+     * Bypass the `RawEffect → Effect` conversion that `effects` runs
+     * through — recognizers have full structural knowledge of what
+     * they're emitting (e.g. `interaction(class: "storage-access")` with
+     * binding identity + per-class fields/selector)
+     * and there's no narrower extractor-side representation worth
+     * round-tripping through. Concatenated with converted `effects` at
+     * `assembleSummary` time.
+     */
+    extraEffects?: Effect[];
+    location: {
+        start: number;
+        end: number;
+    };
+    isDefault: boolean;
+    /**
+     * Shape of upstream data the code unit reads within this branch.
+     * Populated by the adapter for client/consumer code units: after
+     * branching on a response status, the consumer accesses fields on
+     * the response body — those accesses are collected into a TypeShape.
+     * The extractor copies this through to Transition.expectedInput.
+     */
+    expectedInput?: TypeShape | null;
+}
+interface RawDependencyCall {
+    name: string;
+    assignedTo: string | null;
+    async: boolean;
+    returnType: string | null;
+    location: {
+        start: number;
+        end: number;
+    };
+}
+interface RawDeclaredContract {
+    framework: string;
+    responses: Array<{
+        statusCode: number;
+        /**
+         * Structured body schema the contract declares for this status code.
+         * Populated when the adapter can statically resolve the response schema
+         * (e.g. `c.type<T>()`'s type argument). Null when the contract exists
+         * but no body was declared or the schema form isn't yet supported.
+         */
+        body?: TypeShape | null;
+    }>;
+    params?: Record<string, {
+        type: string;
+        required: boolean;
+    }>;
+    /**
+     * Relationship between this declared contract and the `transitions[]`
+     * on the same summary:
+     *
+     *   - "derived": both are extracted from the same source data, so
+     *     comparing them against each other is tautological. Example: an
+     *     OpenAPI stub's contract and its transitions both come from the
+     *     operation's `responses` block. The cross-boundary checker
+     *     skips per-summary contract-consistency for these.
+     *
+     *   - "independent": the contract is a separate statement from the
+     *     transitions. Example: a ts-rest handler whose router declares
+     *     `responses` and whose implementation is a separate function;
+     *     a CFN stub whose `MethodResponses` and integration config are
+     *     independent template fields. Contract-consistency comparison
+     *     is meaningful.
+     *
+     * Defaults to "independent" when a pack doesn't say — safer to
+     * surface a spurious-but-investigable finding than to silently drop
+     * a real one.
+     */
+    provenance?: "derived" | "independent";
+}
+interface RawCodeStructure {
+    identity: {
+        name: string;
+        kind: CodeUnitKind;
+        file: string;
+        range: {
+            start: number;
+            end: number;
+        };
+        exportName: string | null;
+        exportPath: string[] | null;
+    };
+    /**
+     * Three-layer boundary description (`transport`, `semantics`,
+     * `recognition`). See `@suss/behavioral-ir`'s `BoundaryBinding`.
+     * Null when the unit participates in no cross-unit boundary —
+     * helpers, pure utilities, and anything the adapter can't place.
+     */
+    boundaryBinding: BoundaryBinding | null;
+    parameters: RawParameter[];
+    branches: RawBranch[];
+    dependencyCalls: RawDependencyCall[];
+    declaredContract: RawDeclaredContract | null;
+    /**
+     * Names of pack-declared response properties whose semantics is `body`.
+     * For client units this records the accessor a consumer uses to reach the
+     * body (e.g. ["data"] for axios, ["body","json","text"] for fetch). Carried
+     * through to `summary.metadata.http.bodyAccessors` so the cross-boundary
+     * checker can unwrap consumer expectedInput correctly without knowing each
+     * pack. Flat here because this is the adapter→extractor plumbing contract;
+     * nesting under `http` happens when the summary is assembled.
+     */
+    bodyAccessors?: string[];
+    /**
+     * Names of pack-declared response properties whose semantics is
+     * `statusCode`. Same shape as `bodyAccessors` but for the status side —
+     * lets the checker recognise pack-specific names (e.g. fetch's `status`,
+     * axios's `status`, hypothetical `responseStatus`) when matching consumer
+     * branch conditions to provider transitions. Carried through to
+     * `summary.metadata.http.statusAccessors`.
+     */
+    statusAccessors?: string[];
+    /**
+     * Raw GraphQL document source attached to consumer-side graphql
+     * summaries (the inner text of a `useQuery(gql\`...\`)` call).
+     * Assembled into `summary.metadata.graphql.document` for the
+     * checker's pairing layer to parse. Deliberately untouched here —
+     * the extractor has no dependency on graphql-js; parsing happens
+     * at check time.
+     */
+    graphqlDocument?: string;
+    /**
+     * Raw GraphQL schema SDL attached to provider-side resolver
+     * summaries. For schema-first stubs (AppSync), the SDL IS the
+     * schema. For code-first frameworks (Apollo Server), the SDL
+     * comes from the `typeDefs` config option when statically
+     * resolvable. Surfaced as `summary.metadata.graphql.schemaSdl`
+     * so the checker can use the return-type field set when pairing
+     * nested consumer selections.
+     */
+    graphqlSchemaSdl?: string;
+    /**
+     * Declared contract derived from the SDL field for this resolver:
+     * `{ returnType, args, provenance, framework }`. Surfaced as
+     * `summary.metadata.graphql.declaredContract` so
+     * `checkGraphqlContractAgreement` can pair it against other
+     * sources declaring a contract for the same boundary.
+     *
+     * The extractor doesn't derive this — adapters that have the SDL
+     * AND know the (typeName, fieldName) of the resolver populate it.
+     * Today: the TS adapter does this for Apollo-style resolverMap
+     * discovery. NestJS GraphQL (decorator-based) is a follow-up.
+     */
+    graphqlDeclaredContract?: Record<string, unknown>;
+    /**
+     * Set on a consumer-side GraphQL summary whose document reference was
+     * recognized (an imported `TypedDocumentNode` from graphql-codegen,
+     * say) but whose body couldn't be read statically. Surfaced as
+     * `summary.metadata.graphql.unresolvedDocument` so the unreadable
+     * document is accounted for rather than silently dropped. `reference`
+     * is the identifier passed to the hook / imperative call; `reason`
+     * explains what defeated static resolution.
+     */
+    graphqlUnresolvedDocument?: {
+        reference: string;
+        reason: string;
+    };
+}
+interface ExtractorOptions {
+    gapHandling: "strict" | "permissive" | "silent";
+}
+declare function makeTransitionId(functionName: string, branch: RawBranch): string;
+declare function assembleSummary(raw: RawCodeStructure, options?: ExtractorOptions): BehavioralSummary;
+declare function detectGaps(raw: RawCodeStructure, transitions: Transition[], options: ExtractorOptions): Gap[];
+declare function assessConfidence(raw: RawCodeStructure): ConfidenceInfo;
+declare function terminalToOutput(terminal: RawTerminal): Output;
+declare function effectToIR(effect: RawEffect): Effect;
+declare function paramToInput(param: RawParameter): Input;
+
+export { type AccessRecognizer, type BindingExtraction, type ContractPattern, type DiscoveredCustomUnit, type DiscoveredSubUnit, type DiscoveredSubUnitParent, type DiscoveryMatch, type DiscoveryPattern, type EffectArg, type ExtractorOptions, type InputMappingPattern, type InvocationRecognizer, type PatternPack, type RawBranch, type RawCodeStructure, type RawCondition, type RawDeclaredContract, type RawDependencyCall, type RawEffect, type RawParameter, type RawTerminal, type ResponsePropertyMapping, type ResponsePropertyMeaning, type TerminalExtraction, type TerminalMatch, type TerminalPattern, assembleSummary, assessConfidence, detectGaps, effectToIR, httpRouteDiscovery, makeTransitionId, paramToInput, terminalToOutput };