@suss/extractor 0.35.1 → 0.37.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Effect, MessageBusSemantics, DeployableUnit, CodeUnitKind, RequestSpellingMetadata, BehavioralSummary, TypeShape, Predicate, ValueRef, RenderNode, ProvenanceSlot, BoundaryBinding, WrapperReference, TestMetadata, GraphqlDeclaredContract, ConfidenceInfo, Transition, Gap, Input, Output } from '@suss/behavioral-ir';
+import { BehavioralSummary, Effect, MessageBusSemantics, DeployableUnit, CodeUnitKind, RequestSpellingMetadata, TypeShape, Predicate, ValueRef, BoundaryBinding, RenderNode, ProvenanceSlot, WrapperReference, TestMetadata, GraphqlDeclaredContract, GraphqlMetadata, ConfidenceInfo, Transition, Gap, Input, Output } from '@suss/behavioral-ir';
 import { z } from 'zod';
 
 /**
@@ -22,6 +22,26 @@ interface InputRead {
     path: string[];
 }
 
+/**
+ * Environment variables a library reads from its own installed code,
+ * where no walk over the project goes. Without them the checker would
+ * call a variable in a template unused when the library reads it on
+ * every invocation. An adapter writes one marker summary per declared
+ * library that some project file imports, and runtime-config pairing
+ * checks the markers before it reports a variable as unused.
+ */
+
+interface LibraryEnvVars {
+    /** What the library's import starts with: `@aws-lambda-powertools/`, `aws_lambda_powertools`. */
+    module: string;
+    /** Prefixes of the variables the library reads, such as `POWERTOOLS_`. */
+    prefixes?: string[];
+    /** Exact names of the variables the library reads. */
+    names?: string[];
+}
+/** The marker for one library, placed at the first project file found importing it. */
+declare function libraryEnvReadMarker(recognition: string, declared: LibraryEnvVars, importer: string): BehavioralSummary;
+
 /**
  * Reading a function the project wrote in front of a library, before
  * anything is extracted.
@@ -240,6 +260,11 @@ type DiscoveryMatch = {
         hookName: string;
         operationType: "query" | "mutation" | "subscription";
     }>;
+    /** Where a call passes a client of its own instead of the app's: the options argument and the option. */
+    clientOption?: {
+        argument: number;
+        property: string;
+    };
 } | {
     /**
      * An imperative Apollo Client call: `client.query({ query })`,
@@ -565,7 +590,26 @@ type DiscoveryMatch = {
      * side of the package-export boundary, whichever two they are.
      */
     workspaces?: true;
-} | TestCaseMatch;
+} | CallbackArgumentMatch | TestCaseMatch;
+/**
+ * A function handed to a call or construction of a library export, which
+ * the library then calls with work of its own. BullMQ's
+ * `new Worker("emails", async (job) => {...})` is the case it was written
+ * for: the processor becomes a unit, and a binding the pattern declares
+ * can read its channel off the same call with `callArgument`.
+ *
+ * `new X(...)` and `x(...)` both match. The function is followed the way
+ * any value is, so a processor written in another module and passed by
+ * name is found too. A function the run cannot settle to one body, such
+ * as a parameter or a file path the library loads itself, gives no unit.
+ */
+interface CallbackArgumentMatch {
+    type: "callbackArgument";
+    importModule: string;
+    importName: string;
+    /** Which argument is the function. */
+    callbackPosition: number;
+}
 /**
  * Test cases written as nested calls, the way vitest, jest and mocha
  * write them: `describe("orders", () => { it("cancels", () => ...) })`.
@@ -710,13 +754,18 @@ type BindingExtraction = {
  *
  * `decoratorArgument` reads the argument off the same decorator the
  * match selected the handler by, so `@EventPattern("order.placed")`
- * gives "order.placed". `literal` is for a wire whose channel the
- * library fixes. `unstated` means the wire is known and the channel is
- * not, and it pairs the same as a null channel.
+ * gives "order.placed". `callArgument` reads an argument of the call a
+ * `callbackArgument` match found the function in, so
+ * `new Worker("emails", fn)` gives "emails". `literal` is for a wire
+ * whose channel the library fixes. `unstated` means the wire is known
+ * and the channel is not, and it pairs the same as a null channel.
  */
 type ChannelSource = {
     from: "decoratorArgument";
     position: number;
+} | {
+    from: "callArgument";
+    position: number;
 } | {
     from: "literal";
     value: string;
@@ -1422,14 +1471,7 @@ interface PatternPack {
      * before reporting. `module` matches as a prefix, so one entry covers a
      * family like `@aws-lambda-powertools/`.
      */
-    libraryEnvVars?: Array<{
-        /** Module-specifier prefix the library's imports start with. */
-        module: string;
-        /** Env-var name prefixes the library reads, e.g. "POWERTOOLS_". */
-        prefixes?: string[];
-        /** Exact env-var names the library reads. */
-        names?: string[];
-    }>;
+    libraryEnvVars?: LibraryEnvVars[];
     /**
      * Library wrappers that return the function they were handed. A call to
      * the `name` that `module` exports resolves to its `argument`-th
@@ -1479,13 +1521,14 @@ interface PatternPack {
      * `uriProperty` the option key whose value is the endpoint. The
      * adapter reads every construction in the project and stamps the
      * client on each operation summary when exactly one distinct client
-     * exists; two or more distinct clients abstain, since a hook call
-     * does not say which one it goes through.
+     * exists; two or more abstain, unless a call passes its own client.
      */
     graphqlClients?: Array<{
         importModule: string;
         importName: string;
         uriProperty: string;
+        /** On a client a call can pass, the option its transport goes in. */
+        linkProperty?: string;
         /**
          * How this constructor's cache option installs a fragment
          * registry, for the library whose client can supply fragment
@@ -1510,8 +1553,9 @@ interface PatternPack {
      * Which service a client talks to, keyed by the endpoint the
      * construction was read with: the uri literal, or the written
      * expression when the value is computed. The value is the provider
-     * workspace name. This is deployment knowledge, so it comes from the
-     * pack's own per-project config rather than from the library.
+     * workspace name, or the schema file the provider was read from.
+     * This is deployment knowledge, so it comes from the pack's own
+     * per-project config rather than from the library.
      */
     graphqlClientBindings?: Record<string, string>;
     /**
@@ -1525,6 +1569,14 @@ interface PatternPack {
         files: string[];
         workspace: string;
     }>;
+    /**
+     * What happens to an operation whose client no binding or scope ties
+     * to a service, in a project with clients for more than one endpoint.
+     * `unchecked`, the default, lists it as not checked. `pairWithAll`
+     * pairs it with every resolver that serves its fields, and warns that
+     * the match is ambiguous.
+     */
+    graphqlUnboundClients?: "unchecked" | "pairWithAll";
     /**
      * Per-access recognizers, the counterpart to `invocationRecognizers` for
      * values read without a call, such as `process.env.X`. A recognizer is
@@ -1759,6 +1811,8 @@ interface CaseGroup<Cond> {
  *
  * The lowering works `exitKind` out by scanning the statement's own
  * subtree for a return or a throw, skipping every nested function body.
+ * The engine reads `lines` only to say which loop or try each terminal
+ * is written in.
  *
  * `callbacks` is the bodies of the functions this statement passes to
  * calls it makes, when the language treats those as running for the
@@ -1771,6 +1825,15 @@ interface CaseGroup<Cond> {
 interface LoweredStatementParts<Cond> {
     readonly exitKind: ExitKind;
     readonly callbacks?: readonly StatementBlock<Cond>[];
+    /**
+     * The lines a loop or a try is written on, from its first line to the
+     * end of its body. Without them, a branch cannot say which calls in a
+     * loop may have run before its terminal.
+     */
+    readonly lines?: {
+        readonly start: number;
+        readonly end: number;
+    };
 }
 /**
  * One statement in the unit's control flow, already lowered out of the
@@ -1950,6 +2013,31 @@ declare function firstWrittenReading<T>(readings: readonly Reading<T>[]): Chosen
  */
 declare function valueToReadFurtherFrom<T>(reading: Reading<T>): T | null;
 
+/**
+ * The `groupId` an effect has, which says which call site in its unit
+ * produced it.
+ *
+ * The id says what the effect is and never where its call is written:
+ * the callee, then a hash of everything else the effect records, such as
+ * its class and the shape of what the call passed. Code that moves or is
+ * reformatted keeps its ids, so `inspect --diff` and `check --base` do
+ * not report it as changed. Two call sites in one unit with the same
+ * effect get the same key, so the ones after the first, in source order,
+ * take `#2`, `#3` and so on. The lines stay in the effect's `location`,
+ * which the key leaves out.
+ */
+
+/** The key for an effect, which has no `groupId` yet. */
+declare function callSiteKey(effect: Effect): string;
+/**
+ * The effects of one unit's call sites, given in source order with one
+ * list per site, with each `groupId` a later site repeats numbered. An
+ * entry keeps whatever else an adapter records beside its effect.
+ */
+declare function numberRepeatedCallSites<T extends {
+    effect: Effect;
+}>(sites: readonly (readonly T[])[]): T[][];
+
 /**
  * Folds the code registered around a unit, such as middleware, into what
  * the unit does.
@@ -2033,16 +2121,46 @@ declare function stampModules(summaries: readonly BehavioralSummary[], modules:
  * Which branch an effect belongs to.
  *
  * An adapter finds the calls a body makes once, then has to say which
- * of the branches it also found each call runs on. Two facts settle it,
- * and both are already extracted: the guards the call is written under,
- * and where the branch's terminal is in the file. Every adapter that
- * attributes effects to branches reads from here, so they all decide
- * it the same way.
+ * of the branches it also found each call runs on. `firesOn` settles it
+ * from what is already extracted: the guards the call is written under,
+ * the line it is written on, and where the branch's terminal is. Every
+ * adapter attributes effects to branches through it, so they all decide
+ * it the same way, for a plain call and for one a pack recognized.
  *
- * Neither test is enough alone. This package's DESIGN.md shows the two
- * cases where one test on its own gets the branch wrong.
+ * This package's DESIGN.md shows why each test is there, with the cases
+ * where leaving one out puts an effect on the wrong branch.
  */
 
+/** Where the call or read behind an effect is written. */
+interface EffectSite {
+    /** The line the statement the call is written in starts on. */
+    line: number;
+    /** The guards the call is written under, spelled the way a branch records its conditions. */
+    preconditions?: readonly RawCondition[] | undefined;
+    /**
+     * For a call in a `finally` or `ensure` body, the first line of the
+     * try it cleans up after. The call runs on every path that entered
+     * that try, including one that returned or threw before reaching it.
+     */
+    cleansUpFrom?: number | undefined;
+}
+/** An effect, and where it was written. */
+interface PlacedEffect<E> {
+    effect: E;
+    site: EffectSite;
+}
+/** What the branch test reads off a branch. */
+type BranchEnding = Pick<RawBranch, "conditions" | "terminal" | "loopAround">;
+/**
+ * Whether the effect written at `site` can run before `branch` reaches its
+ * terminal. A call in the loop around the terminal may have run on an
+ * earlier pass, whatever its guards say about the last one, so it stays.
+ * Anything else needs a branch that does not contradict its guards, and
+ * has to be written no later than the terminal ends.
+ */
+declare function firesOn(site: EffectSite, branch: BranchEnding): boolean;
+/** The effects that can run before the branch reaches its terminal, in the order given. */
+declare function effectsFiringOn<E>(placed: readonly PlacedEffect<E>[], branch: BranchEnding): E[];
 /**
  * Whether the branch leaves room for every guard on the effect. A guard
  * the branch wrote down the other way around rules the effect out. A
@@ -2111,20 +2229,19 @@ declare function throughHelper(branch: RawBranch, at: {
  * records of field names a branch's `expectedInput` lists.
  */
 declare function mergeReadShapes(a: TypeShape | null, b: TypeShape | null): TypeShape | null;
-/** One call in a caller's body that hands a helper the response, in source order. */
-interface HandOffSite {
+/**
+ * One call in a caller's body that hands a helper the response, in
+ * source order. A branch reaches it when an effect written there would
+ * fire on the branch.
+ */
+interface HandOffSite extends EffectSite {
     /** The helper's paths, in the caller's terms. */
     helper: readonly RawBranch[];
-    preconditions?: readonly RawCondition[] | undefined;
-    /** The line the statement holding the call starts on, which decides whether a branch reaches it. */
-    line: number;
     /** The lines the call is written on. */
     at: {
         start: number;
         end: number;
     };
-    /** A call in a `finally` runs on every path, even one that left before it. */
-    alwaysRuns?: boolean;
 }
 /**
  * The branch split at each hand-off on it, in source order. A path that
@@ -2392,7 +2509,32 @@ interface StructuredPathConditionsResult<Cond, Terminal> {
     byTerminal: Map<Terminal, ConditionInfo<Cond>[][]>;
     /** Condition lists for paths that fall through the end of the body. */
     fallthrough: ConditionInfo<Cond>[][];
+    /** Where each terminal is written, for the terminals inside a loop or a cleanup body. */
+    placement: Map<Terminal, TerminalPlacement>;
+}
+/** Which loop and which try a terminal is written in, as effect placement reads them. */
+interface TerminalPlacement {
+    /**
+     * The lines of the outermost loop the terminal is in. Anything else
+     * written in those lines may have run on an earlier pass.
+     */
+    loopAround?: {
+        start: number;
+        end: number;
+    };
+    /**
+     * For a terminal in a `finally` or `ensure` body, the first line of the
+     * outermost try it cleans up after. It runs on every path that got
+     * that far, including one that left the try early.
+     */
+    cleansUpFrom?: number;
 }
+type ParentMap<Cond> = ReadonlyMap<StructuredStatement<Cond>, StructuredStatement<Cond> | null>;
+/**
+ * Which loop and which try each terminal is written in. A lowering that
+ * gave its loops and tries no `lines` gets no placement for them.
+ */
+declare function placeTerminals<Cond, Terminal>(input: Pick<StructuredPathConditionsInput<Cond, Terminal>, "statements" | "terminalsByStmt">, parentOf?: ParentMap<Cond>): Map<Terminal, TerminalPlacement>;
 /**
  * Work out the conditions on each path, for every StructuredStatement
  * reachable from `input.statements`. Throws `PathBudgetExceeded` when the
@@ -2518,6 +2660,36 @@ type ChildrenOf<T> = (node: T) => readonly T[];
  */
 declare function walkDescendants<T, C>(root: T, carried: C, childrenOf: ChildrenOf<T>, visitor: NodeVisitor<T, C>): void;
 
+/**
+ * Where each of a body's calls is written, in the terms the branch test
+ * reads: the paths to the statement the call is in, the line that
+ * statement starts on, and the try whose cleanup body it is in.
+ *
+ * The Python and the Ruby adapter ask here once per body. The statements
+ * stand in as the engine's terminals, so one enumeration covers every
+ * call in the body. tree-sitter hands back a new wrapper for a node each
+ * time one is read, so statements are matched by id.
+ */
+
+/** What an adapter says about its own language for `statementSites`. */
+interface StatementReading<N extends Identified, Cond> {
+    /** The statement a node is written in, which is what the lowering keys a path on. */
+    statementOf: (node: N) => N | null;
+    /** The body lowered with these statements as its terminals. */
+    lower: (statements: readonly N[]) => Pick<StructuredPathConditionsInput<Cond, N>, "statements" | "terminalsByStmt">;
+    /** The one-based line a node starts on. */
+    firstLine: (node: N) => number;
+}
+/** The paths to each node's statement, and the site an effect at the node has. */
+interface StatementSites<N, Cond> {
+    pathsTo: (node: N) => readonly ConditionInfo<Cond>[][] | undefined;
+    /** The site for an effect at the node, with the guards the caller read for it. */
+    siteOf: (node: N, preconditions: readonly RawCondition[]) => EffectSite;
+    /** The site for an effect at the node, with the guards every path to its statement passes. */
+    plainSiteOf: (node: N) => EffectSite;
+}
+declare function statementSites<N extends Identified, Cond>(nodes: readonly N[], reading: StatementReading<N, Cond>): StatementSites<N, Cond>;
+
 /**
  * The project root when nothing declares one.
  *
@@ -2591,6 +2763,39 @@ interface SourceSpelling<L extends WalkEnd> {
 /** Every place a value's walk ended, as distinct value references. */
 declare function sourceRefsOf<L extends WalkEnd>(leaves: readonly L[], spelling: SourceSpelling<L>): ValueRef[];
 
+/**
+ * Functions a deploy manifest says the platform calls, as a pack finds
+ * them for one source file. A Lambda's `Handler` is one: the template
+ * says which file and which function, and nothing in the code calls it.
+ *
+ * The pack reads the manifest, which is the library's business, and
+ * decides which units the function gets. The adapter finds the
+ * definition by `name`, which is a language rule, and builds each unit
+ * on it, so the call walk starts there. Python and Ruby take packs as
+ * data and use this shape; a TypeScript pack has `discoverUnits` and
+ * finds the function itself.
+ */
+
+interface DeclaredEntryPoint {
+    /**
+     * The function as the manifest writes it, in the language's own
+     * spelling: `handler` for a function at the top of the file, or
+     * `Billing::Handler.process` for a Ruby class method.
+     */
+    name: string;
+    /** The units to build on that function. One function can be several deployed units. */
+    units: DeclaredEntryUnit[];
+}
+interface DeclaredEntryUnit {
+    kind: CodeUnitKind;
+    /** The summary's name. */
+    name: string;
+    binding: BoundaryBinding;
+    deployableUnit: DeployableUnit;
+    /** Merged onto the summary's `metadata`. */
+    metadata?: Record<string, unknown>;
+}
+
 /**
  * The small surface every language adapter implements, whatever that
  * language's own tooling looks like underneath.
@@ -2951,6 +3156,11 @@ declare const CACHE_DIR_ENV = "SUSS_CACHE_DIR";
 declare function chosenCacheRoot(): string | null;
 /** The extraction cache for the files read under `projectDir`. */
 declare function extractionCacheDirFor(projectDir: string): string;
+/**
+ * The folder `suss map` writes its page and the summaries behind it to:
+ * `.suss` in the project, or a folder of its own under the chosen root.
+ */
+declare function mapFolderFor(projectDir: string): string;
 /** The file where the server for `projectDir` says how to reach it. */
 declare function liveRecordFor(projectDir: string): string;
 
@@ -3297,6 +3507,35 @@ interface PackConfigNeed {
  * since it never ran, so the caller passes these in.
  */
 declare function packConfigCheck(needs: ReadonlyArray<PackConfigNeed>): HealthCheck;
+/**
+ * A path in a pack's config file where nothing exists. `resolved` is the
+ * path the pack was given. `inProject` is the same value read against the
+ * project instead, set only when something exists there, since that is
+ * the path the user most likely meant.
+ */
+interface PackPathMissing {
+    pack: string;
+    option: string;
+    /** The value as the config file wrote it, or one entry of a list. */
+    value: string;
+    configFile: string;
+    resolved: string;
+    inProject?: string;
+}
+/**
+ * What went wrong with a path option and what to do about it, worded
+ * once for the health block and for the run finding `check` reports.
+ */
+declare function describeMissingPath(missing: PackPathMissing): {
+    problem: string;
+    fix: string;
+};
+/**
+ * Path options in a config file that point at nothing. The pack still
+ * runs, and every lookup under such a path comes back empty, so the
+ * summaries look like a project with less in it.
+ */
+declare function packPathCheck(missing: ReadonlyArray<PackPathMissing>): HealthCheck;
 /**
  * Run every health check over one extraction report and return what
  * fired, grouped by which check caught it.
@@ -3708,6 +3947,8 @@ interface RawTerminal {
  * An invocation argument as the adapter read it. An argument that fits none of
  * these variants, arithmetic for instance, comes through as null instead of
  * being dropped, so a reader still knows how many arguments the call had.
+ * JSON null therefore means the adapter could not read the argument, and a
+ * caller that wrote `null` gets `{ kind: "null" }` instead.
  */
 type EffectArg = {
     kind: "string";
@@ -3718,6 +3959,14 @@ type EffectArg = {
 } | {
     kind: "boolean";
     value: boolean;
+}
+/** A literal `null`, Python's `None` or Ruby's `nil`, which a caller passed on purpose. */
+ | {
+    kind: "null";
+}
+/** JavaScript's `undefined`, kept apart from `null` because a parameter default replaces only this one. */
+ | {
+    kind: "undefined";
 } | {
     kind: "object";
     fields: Record<string, EffectArg>;
@@ -3749,6 +3998,11 @@ type EffectArg = {
     args: EffectArg[];
 } | null;
 type RawEffect = {
+    location?: {
+        start: number;
+        end: number;
+    };
+} & ({
     type: "mutation";
     target: string;
     operation: "create" | "update" | "delete";
@@ -3765,7 +4019,7 @@ type RawEffect = {
 } | {
     type: "stateChange";
     variable: string;
-};
+});
 interface RawBranch {
     conditions: RawCondition[];
     terminal: RawTerminal;
@@ -3781,6 +4035,15 @@ interface RawBranch {
         start: number;
         end: number;
     };
+    /**
+     * The lines of the outermost loop the terminal is written in, when it
+     * is in one. A call anywhere in those lines may have run on an earlier
+     * pass before this path reached the terminal.
+     */
+    loopAround?: {
+        start: number;
+        end: number;
+    };
     isDefault: boolean;
     /** The fields a consumer reads off a response inside this branch. */
     expectedInput?: TypeShape | null;
@@ -3925,6 +4188,8 @@ interface RawCodeStructure {
     requestSpelling?: RequestSpellingMetadata;
     /** What a test pack found about a `test` unit: whether it is skipped, and what it replaces with a mock. */
     test?: TestMetadata;
+    /** A pack's own metadata namespaces, merged onto the summary's `metadata` as given. */
+    packMetadata?: Record<string, unknown>;
     /** The extractor cannot derive this. An adapter that has the SDL and knows
      * which field the resolver serves fills it in. */
     graphqlDeclaredContract?: GraphqlDeclaredContract;
@@ -3940,6 +4205,13 @@ interface RawCodeStructure {
         reference: string;
         reason: string;
     };
+    /** The client the operation's own call passes, when one settled. */
+    graphqlClient?: GraphqlMetadata["client"];
+    /** Why the client the operation's call passes could not be settled. */
+    graphqlUnresolvedClient?: {
+        reference: string;
+        reason: string;
+    };
     /**
      * Which part of the boundary the source does not state, and why. The binding
      * still goes out with that part empty, so the unit pairs with nothing rather
@@ -3989,4 +4261,4 @@ declare function rawConditionToPredicate(c: RawCondition): Predicate;
 declare function effectToIR(effect: RawEffect): Effect;
 declare function paramToInput(param: RawParameter): Input;
 
-export { type AccessRecognizer, type AdapterCodeStamp, type AdapterStamp, type ArgumentParser, type AstCapableOps, type BindingExtraction, type BodyContent, CACHE_DIR_ENV, type CacheAttribution, type CacheDiagnostic, type CacheInput, type CacheLayer, type CacheLookup, type CallOps, type CaseGroup, type ChannelSource, type ChildrenOf, type ChosenReading, type ClassOps, type CodeHasher, type ConditionHandle, type ConditionInfo, type ConditionSource, type ConstructedFrom, type ContractPattern, type DeclaredBinding, type DeclaredBy, type DeclaredMatch, type DeclaredModule, type DeclaredStatusDecorators, type DefaultedReading, type DiscoveredCustomUnit, type DiscoveredSubUnit, type DiscoveredSubUnitParent, type DiscoveryMatch, type DiscoveryPattern, type EffectArg, type EmptyStage, EnclosingNodes, type ExitKind, type ExtractionConfig, type ExtractionReport, type ExtractorOptions, type FailureDelivery, type GlobalPrefixCall, type HandOffSite, type HealthCheck, type HealthViolation, type HelperDeclarations, type HelperSearch, type HelperSink, type HelperValue, IdMap, IdSet, type Identified, type InputMappingPattern, type InputRead, type InvocationRecognizer, type KeepsArms, KeptParses, type LanguageAdapter, type LoweredStatementParts, MAX_ENTRIES, MAX_HELPER_PATHS, MAX_PATHS, MODULE_SURFACE_RECOGNITION, type ModuleInitOptions, type NodeVisitor, type OpsCarrier, type PackConfigNeed, type PackDeclarations, type PackFailure, type PackFunnel, type PackGradient, type PackTally, type ParameterSupplier, type ParsedNode, type PartialPlan, PathBudgetExceeded, type PatternPack, type ProjectHelper, type ProjectHelpers, type RawBranch, type RawCodeStructure, type RawCondition, type RawDeclaredContract, type RawDependencyCall, type RawEffect, type RawParameter, type RawProvenance, type RawTerminal, type Reading, type ReceiverOrigin, type RedirectDelivery, type RedirectOption, type RegistrationHelper, type ResponsePropertyMapping, type ResponsePropertyMeaning, type RootRecord, type RouteVersioning, SKIP_CHILDREN, type SettledModule, type SourceRange, type SourceSpelling, type StatedSlot, type StatementBlock, type StructuredPathConditionsInput, type StructuredPathConditionsResult, type StructuredStatement, type TerminalExtraction, type TerminalMatch, type TerminalPattern, type TestCaseMatch, type Timer, type TimingReport, type TransparentWrapper, type UnitRecord, UnmodeledFlow, type UnsettledName, type ValueEntry, type ValueOps, type VersionPlacement, type WalkEnd, type WrapperMethodRegistration, type WrapperOptionRegistration, type WrapperRegistration, absentReading, ambiguousReading, andThenReading, assembleSummary, assessConfidence, buildUngatedExtractionReport, chosenCacheRoot, commonDirectoryOf, composeWrappers, computeContentHash, computeDistHashFrom, configuredCallOption, createAdapterStamp, createCacheLayer, createCodeHasher, createPackTallies, createTimer, detectGaps, effectToIR, emptyTally, enumerateOrDegrade, enumerateStructuredPaths, evaluatePackHealth, extractionCacheDirFor, extractionConfigStamp, firstWrittenReading, formatPackHealth, guardsHoldOn, helperPathsOnVariables, httpRouteDiscovery, isListedTestFile, liveRecordFor, makeIgnoredDirectory, makeTransitionId, mapReading, markReturnsAsExitCode, matchesTestFileName, mergeReadShapes, moduleInitStructure, moduleOfFile, noopTimer, ownersWhereWritten, packConfigCheck, packGradients, paramToInput, processCodeHasher, projectFileStamp, rawConditionToPredicate, recordPackFailure, redirectDeliveryWhenSet, registrationHelperDiscovery, routeHelperIndex, runDigest, runsBefore, scopeOption, settleModules, sharedGatingConditions, sourceRefsOf, splitAtHandOffs, stampMayMissAWrite, stampModuleImports, stampModules, storageSystemOption, summaryCountsByPack, tallyUnit, terminalToOutput, throughHelper, unreadableReading, unwrapJsonStringify, valueToReadFurtherFrom, walkDescendants, wrapperDiscovery, writtenReading };
+export { type AccessRecognizer, type AdapterCodeStamp, type AdapterStamp, type ArgumentParser, type AstCapableOps, type BindingExtraction, type BodyContent, type BranchEnding, CACHE_DIR_ENV, type CacheAttribution, type CacheDiagnostic, type CacheInput, type CacheLayer, type CacheLookup, type CallOps, type CallbackArgumentMatch, type CaseGroup, type ChannelSource, type ChildrenOf, type ChosenReading, type ClassOps, type CodeHasher, type ConditionHandle, type ConditionInfo, type ConditionSource, type ConstructedFrom, type ContractPattern, type DeclaredBinding, type DeclaredBy, type DeclaredEntryPoint, type DeclaredEntryUnit, type DeclaredMatch, type DeclaredModule, type DeclaredStatusDecorators, type DefaultedReading, type DiscoveredCustomUnit, type DiscoveredSubUnit, type DiscoveredSubUnitParent, type DiscoveryMatch, type DiscoveryPattern, type EffectArg, type EffectSite, type EmptyStage, EnclosingNodes, type ExitKind, type ExtractionConfig, type ExtractionReport, type ExtractorOptions, type FailureDelivery, type GlobalPrefixCall, type HandOffSite, type HealthCheck, type HealthViolation, type HelperDeclarations, type HelperSearch, type HelperSink, type HelperValue, IdMap, IdSet, type Identified, type InputMappingPattern, type InputRead, type InvocationRecognizer, type KeepsArms, KeptParses, type LanguageAdapter, type LibraryEnvVars, type LoweredStatementParts, MAX_ENTRIES, MAX_HELPER_PATHS, MAX_PATHS, MODULE_SURFACE_RECOGNITION, type ModuleInitOptions, type NodeVisitor, type OpsCarrier, type PackConfigNeed, type PackDeclarations, type PackFailure, type PackFunnel, type PackGradient, type PackPathMissing, type PackTally, type ParameterSupplier, type ParsedNode, type PartialPlan, PathBudgetExceeded, type PatternPack, type PlacedEffect, type ProjectHelper, type ProjectHelpers, type RawBranch, type RawCodeStructure, type RawCondition, type RawDeclaredContract, type RawDependencyCall, type RawEffect, type RawParameter, type RawProvenance, type RawTerminal, type Reading, type ReceiverOrigin, type RedirectDelivery, type RedirectOption, type RegistrationHelper, type ResponsePropertyMapping, type ResponsePropertyMeaning, type RootRecord, type RouteVersioning, SKIP_CHILDREN, type SettledModule, type SourceRange, type SourceSpelling, type StatedSlot, type StatementBlock, type StatementReading, type StatementSites, type StructuredPathConditionsInput, type StructuredPathConditionsResult, type StructuredStatement, type TerminalExtraction, type TerminalMatch, type TerminalPattern, type TerminalPlacement, type TestCaseMatch, type Timer, type TimingReport, type TransparentWrapper, type UnitRecord, UnmodeledFlow, type UnsettledName, type ValueEntry, type ValueOps, type VersionPlacement, type WalkEnd, type WrapperMethodRegistration, type WrapperOptionRegistration, type WrapperRegistration, absentReading, ambiguousReading, andThenReading, assembleSummary, assessConfidence, buildUngatedExtractionReport, callSiteKey, chosenCacheRoot, commonDirectoryOf, composeWrappers, computeContentHash, computeDistHashFrom, configuredCallOption, createAdapterStamp, createCacheLayer, createCodeHasher, createPackTallies, createTimer, describeMissingPath, detectGaps, effectToIR, effectsFiringOn, emptyTally, enumerateOrDegrade, enumerateStructuredPaths, evaluatePackHealth, extractionCacheDirFor, extractionConfigStamp, firesOn, firstWrittenReading, formatPackHealth, guardsHoldOn, helperPathsOnVariables, httpRouteDiscovery, isListedTestFile, libraryEnvReadMarker, liveRecordFor, makeIgnoredDirectory, makeTransitionId, mapFolderFor, mapReading, markReturnsAsExitCode, matchesTestFileName, mergeReadShapes, moduleInitStructure, moduleOfFile, noopTimer, numberRepeatedCallSites, ownersWhereWritten, packConfigCheck, packGradients, packPathCheck, paramToInput, placeTerminals, processCodeHasher, projectFileStamp, rawConditionToPredicate, recordPackFailure, redirectDeliveryWhenSet, registrationHelperDiscovery, routeHelperIndex, runDigest, runsBefore, scopeOption, settleModules, sharedGatingConditions, sourceRefsOf, splitAtHandOffs, stampMayMissAWrite, stampModuleImports, stampModules, statementSites, storageSystemOption, summaryCountsByPack, tallyUnit, terminalToOutput, throughHelper, unreadableReading, unwrapJsonStringify, valueToReadFurtherFrom, walkDescendants, wrapperDiscovery, writtenReading };