@suss/recognize 0.11.0

package/LICENSE

@@ -0,0 +1,205 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable by
+      such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and do not
+          modify the License. You may add Your own attribution notices
+          within Derivative Works that You distribute, alongside or as an
+          addendum to the NOTICE text from the Work, provided that such
+          additional attribution notices cannot be construed as modifying
+          the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor has
+      been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format please. Also add information on
+      how to contact you by electronic and paper mail.
+
+      If the program does not interact with users remotely through a computer
+      network, then your name and employer's name (e.g., your institution)
+      is sufficient to fill in the "name of copyright owner" field. Feel
+      free to omit the "name of employer" line if you are in no way affiliated
+      with any institution.
+
+      Copyright 2026 Nimbus Cloud AI LLC
+
+      Licensed under the Apache License, Version 2.0 (the "License");
+      you may not use this file except in compliance with the License.
+      You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+      Unless required by applicable law or agreed to in writing, software
+      distributed under the License is distributed on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+      See the License for the specific language governing permissions and
+      limitations under the License.

package/README.md

@@ -0,0 +1,131 @@
+# @suss/recognize
+
+Write a pack as data. A pack states where a match starts, which methods
+count, and what each one reads or writes; this package compiles that
+into the recognizer hooks the adapters already call, and any adapter
+that implements the executor ops can run it.
+
+```ts
+import { declaredBy, pack, storageCalls } from "@suss/recognize";
+
+const COMMANDS = {
+  get: { kind: "read", selector: { at: 0 } },
+  hset: { kind: "write", selector: { at: 0 }, fields: { at: 1 } },
+} as const;
+
+const calls = storageCalls({
+  system: "redis",
+  client: declaredBy("ioredis", "redis", "iovalkey"),
+})
+  .methods(COMMANDS, { ignoringCase: true })
+  .container(namespaceOf)
+  .example('redis.get("user_online:42")');
+
+export default pack("redis", [calls], {
+  languages: ["typescript", "javascript"],
+  recognizedAs: "@suss/framework-redis",
+});
+```
+
+Nothing here imports a syntax tree, so the same declaration drives the
+TypeScript adapter today and the Python and Ruby adapters once they
+implement the ops.
+
+## The spine
+
+A pack does four jobs: it discovers units, it recognizes calls inside
+them, it declares terminals, and it claims sub-units. They share one
+spine and differ in what the ending yields.
+
+```
+where the match starts -> which method -> read the arguments -> yield
+                                                                effects
+                                                                a unit
+                                                                a terminal
+                                                                a sub-unit
+```
+
+Only the effects ending is built. The other three are further members of
+`Ending` with an entry in the compile table.
+
+### Where a match starts
+
+The start is its own axis, and a receiver is one value on it. Across the
+29 shipped packs a match starts from at least thirteen places, and most
+of them are not receivers at all: an exported name, a file path, a
+decorator, a parameter's type, a template file beside the module, a
+function's return type. `MatchStart` is where those arrive.
+
+The receiver-shaped starts are their own union, `ReceiverOrigin`:
+
+| origin | what it matches | built |
+|---|---|---|
+| `declaredBy` | a receiver whose method one of these modules declared | yes |
+| `constructed` | a client made from one of these modules' exports | yes |
+| `factoryMade` | `app = express()` | no |
+| `imported` | a function the file imports | no |
+| `anchored` | a chain read from its anchor call | no |
+| `inherits` | a Ruby or Python receiver matched by ancestry | no |
+| `global` | `process.env`, bare `fetch` | no |
+
+`declaredBy` is what a pack wants when the source never spells the
+client out: `const redis = await this.getClient()` says nothing about
+ioredis, and the declaration behind `redis.get` says everything.
+`constructed` asks the receiver itself, so it still works where the
+method is untyped.
+
+## The gradient
+
+Expressiveness is bought link by link, and the price is printed.
+
+1. A chain of data links. Serializable, inspectable, and it runs
+   wherever the ops do.
+2. A link written as a function. That link is code, the rest stay data,
+   and pack health says which ones are opaque.
+3. `astLink` from `@suss/recognize/ast`, which hands the function the
+   adapter's own node. Behind its own import, so reaching for it shows
+   up in the diff, and pack health reports it the way it reports a pack
+   that declares no version.
+
+`packGradients` in `@suss/adapter-typescript` reads the counts off a
+run, and three health checks fire on them: a link written as a function,
+a link that reads the syntax tree, and a declaration with no example.
+
+## The executor ops
+
+`CallOps` is the whole of what a chain asks about one call site. An
+adapter implements it once. Today `callOpsFor` in
+`@suss/adapter-typescript` is the only implementation, and it puts the
+result on the recognizer context under `ops`.
+
+| op | what it gives back |
+|---|---|
+| `method()` | which method the call reaches for, as the source spells it |
+| `receiverIsFrom(origin)` | whether the receiver came from where the origin says |
+| `argumentCount()` | how many arguments the call passes |
+| `nameAt(index, unsettled)` | the name that argument gives, with the hole policy applied |
+| `calleeText()` | the callee, as the source writes it |
+
+A chain running on an adapter with no ops matches nothing rather than
+throwing, since a pack loaded into the wrong adapter is a configuration
+mistake and not a crash.
+
+## The example every declaration states
+
+```ts
+.example('redis.get("user_online:42")')
+```
+
+`runExamples(pack, run)` takes each declaration's example, hands it to
+the compiler the caller supplied, and gives back what came out. A pack's
+test asserts the stated effect, so the day the example stops matching
+the pack fails rather than the documentation quietly lying.
+`examplesMissing(pack)` lists the declarations that state none.
+
+## Ordering
+
+The links are guards, so the compiled hook checks the cheap one first:
+looking a method up in a table costs nothing, while following a receiver
+to the library that made it walks declarations. A link that changes what
+the receiver is, the way Prisma's model property will, needs the
+declared order back, and `compile.ts` is where that goes.

package/dist/ast.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ast.ts
+var ast_exports = {};
+__export(ast_exports, {
+  astLink: () => astLink
+});
+module.exports = __toCommonJS(ast_exports);
+function astLink(read) {
+  const link = (...args) => {
+    const ops = args[args.length - 1];
+    const given = args.slice(0, -1);
+    return read(ops.ast(), ...given);
+  };
+  return Object.assign(link, { reachesAst: true });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  astLink
+});

package/dist/ast.d.cts

@@ -0,0 +1,32 @@
+import { C as CallOps, L as LinkFunction } from './chain-DTSij2Mn.cjs';
+
+/**
+ * The floor: a link that reads the adapter's own syntax tree.
+ *
+ * A pack that outgrows the ops still gets the tree, and this is the
+ * only door to it. Going through a separate import puts the decision in
+ * the diff, and `astLink` marks the link so the pack health report says
+ * which packs went through, the way it says which declare no version.
+ * Allowed, observable, and slightly inconvenient.
+ *
+ * The node comes back as `unknown` because this package does not read
+ * any one language. A pack casts it to the adapter it was written
+ * against, and that cast is how the pack says which adapter it needs.
+ */
+
+/**
+ * The ops an adapter implements when it can hand out its own nodes. The
+ * extra member is here rather than on `CallOps` so that a pack reaching
+ * for a node has to import this module first.
+ */
+interface AstCapableOps extends CallOps {
+    /** The adapter's own node for the call in hand. */
+    ast(): unknown;
+}
+/**
+ * A link answered by reading the call's own node. `read` is handed the
+ * node and whatever the link would have been handed anyway.
+ */
+declare function astLink<A extends unknown[], R>(read: (node: unknown, ...given: A) => R): LinkFunction<[...A, CallOps], R>;
+
+export { type AstCapableOps, astLink };

package/dist/ast.d.ts

@@ -0,0 +1,32 @@
+import { C as CallOps, L as LinkFunction } from './chain-DTSij2Mn.js';
+
+/**
+ * The floor: a link that reads the adapter's own syntax tree.
+ *
+ * A pack that outgrows the ops still gets the tree, and this is the
+ * only door to it. Going through a separate import puts the decision in
+ * the diff, and `astLink` marks the link so the pack health report says
+ * which packs went through, the way it says which declare no version.
+ * Allowed, observable, and slightly inconvenient.
+ *
+ * The node comes back as `unknown` because this package does not read
+ * any one language. A pack casts it to the adapter it was written
+ * against, and that cast is how the pack says which adapter it needs.
+ */
+
+/**
+ * The ops an adapter implements when it can hand out its own nodes. The
+ * extra member is here rather than on `CallOps` so that a pack reaching
+ * for a node has to import this module first.
+ */
+interface AstCapableOps extends CallOps {
+    /** The adapter's own node for the call in hand. */
+    ast(): unknown;
+}
+/**
+ * A link answered by reading the call's own node. `read` is handed the
+ * node and whatever the link would have been handed anyway.
+ */
+declare function astLink<A extends unknown[], R>(read: (node: unknown, ...given: A) => R): LinkFunction<[...A, CallOps], R>;
+
+export { type AstCapableOps, astLink };

package/dist/ast.js

@@ -0,0 +1,12 @@
+// src/ast.ts
+function astLink(read) {
+  const link = (...args) => {
+    const ops = args[args.length - 1];
+    const given = args.slice(0, -1);
+    return read(ops.ast(), ...given);
+  };
+  return Object.assign(link, { reachesAst: true });
+}
+export {
+  astLink
+};

package/dist/chain-DTSij2Mn.d.cts

@@ -0,0 +1,197 @@
+/**
+ * The operations a chain performs at one call site, and what a language
+ * adapter has to be able to work out for it.
+ *
+ * A chain is data, so something has to turn "did this module declare
+ * the method" into a yes or no about a particular program. That is the
+ * adapter's job, and this interface is the whole of what a chain asks
+ * for. An adapter implements it once and every declared pack runs
+ * there, which is what lets one pack drive several languages.
+ *
+ * Nothing here mentions a syntax tree. A link that needs the tree goes
+ * through `@suss/recognize/ast`, a separate import so that reaching for
+ * it shows up in a diff and in the pack health report.
+ */
+/**
+ * How a pack pins down the receiver a call is on.
+ *
+ * The migration plan for #542 lists four more: `factoryMade` (`app =
+ * express()`), `imported`, `anchored` (a chain read from its anchor
+ * call), `inherits` (a Ruby or Python receiver matched by ancestry) and
+ * `global` (`process.env`, bare `fetch`). Each arrives as a member here
+ * with an entry in every adapter's dispatch table. The README beside
+ * this file says which starts are not receiver-shaped at all.
+ */
+type ReceiverOrigin = DeclaredBy | ConstructedFrom;
+/**
+ * A receiver whose method one of these modules declared.
+ *
+ * This is the origin for a client the source never spells out. `const
+ * redis = await this.getClient()` says nothing about ioredis, and the
+ * declaration behind `redis.get` says everything.
+ */
+interface DeclaredBy {
+    readonly origin: "declaredBy";
+    /** The modules whose declarations settle the call. */
+    readonly importedFrom: readonly string[];
+}
+/**
+ * A client made from a module's export, however the program caches it.
+ * Asked of the receiver itself, so it still works where the method is untyped
+ * and `declaredBy` finds nothing to read.
+ */
+interface ConstructedFrom {
+    readonly origin: "constructed";
+    /** The modules whose export the client was made from. */
+    readonly importedFrom: readonly string[];
+}
+/**
+ * A receiver whose method one of these modules declared. Pass every
+ * module that ships the same client, the way three packages all speak
+ * one wire protocol.
+ */
+declare function declaredBy(...importedFrom: readonly string[]): DeclaredBy;
+/** A client made from one of these modules' exports. */
+declare function constructedFrom(...importedFrom: readonly string[]): ConstructedFrom;
+/**
+ * What a reader gives back for a name nothing in the source settles.
+ * `"nothing"` gives null, `"reference"` gives the value to go and ask
+ * about instead.
+ */
+type UnsettledName = "nothing" | "reference";
+/**
+ * One call site, as the questions a chain asks about it.
+ *
+ * An adapter builds one of these per call and hands it to the
+ * recognizer through its context. Every member is about the call in
+ * hand, so there is no node to pass around and no place for a pack to
+ * reach past what it declared.
+ */
+interface CallOps {
+    /** Which method the call reaches for, spelled as the source spells it. */
+    method(): string | null;
+    /** Whether the receiver came from where the origin says. */
+    receiverIsFrom(origin: ReceiverOrigin): boolean;
+    /** How many arguments the call passes. */
+    argumentCount(): number;
+    /** The name the argument in this position gives. */
+    nameAt(index: number, unsettled: UnsettledName): string | null;
+    /** The callee, as the source writes it. */
+    calleeText(): string;
+}
+/**
+ * The property an adapter puts its ops on, in the context it hands a
+ * recognizer. A context without it belongs to an adapter that has not
+ * implemented the ops, and a declared pack matches nothing there.
+ */
+interface OpsCarrier {
+    ops?: CallOps;
+}
+/** The ops in a recognizer context, or null when the adapter has none. */
+declare function opsIn(ctx: unknown): CallOps | null;
+
+/**
+ * The spine every pack shares, as a chain of links.
+ *
+ * A pack does four jobs, and all four start the same way: match the
+ * receiver, match the method, read the arguments, then yield. What
+ * differs is the ending. Recognition yields effects, discovery yields a
+ * unit, a terminal yields a response write, and a claimed callback
+ * yields a sub-unit. Only the effects ending is built; the others are
+ * further members of `Ending` with an entry in the compile table.
+ *
+ * A link's answer is data wherever it can be. A link given a function
+ * instead is code, that link alone, and pack health says which ones.
+ */
+
+/** A link whose answer a pack wrote as code rather than as data. */
+interface LinkFunction<A extends unknown[], R> {
+    (...args: A): R;
+    /** Set when the function was built through `@suss/recognize/ast`. */
+    readonly reachesAst?: boolean;
+}
+/**
+ * What a match starts from.
+ *
+ * Most of what the shipped packs match starts from a receiver, and none
+ * of what discovery matches does: an exported name, a file path, a
+ * decorator, a parameter's type, a template file beside the module and
+ * a function's return type each start somewhere else. So the start is
+ * its own axis, and a receiver origin is one value on it.
+ */
+type MatchStart = FromReceiver;
+/** A match that starts from the receiver a call is on. */
+interface FromReceiver {
+    readonly starts: "receiver";
+    readonly origin: ReceiverOrigin;
+}
+/** Where the match begins. */
+interface StartLink {
+    readonly asks: "start";
+    readonly at: MatchStart;
+}
+/** Which methods count, and what each one does. */
+interface MethodsLink<TMeaning> {
+    readonly asks: "methods";
+    readonly table: Readonly<Record<string, TMeaning>>;
+    /**
+     * Whether two spellings of one method name are the same method. One
+     * client library lower-cases where another camel-cases, and both are
+     * sending the same command.
+     */
+    readonly ignoringCase: boolean;
+}
+/**
+ * Which container a call's selector belongs to.
+ *
+ * The call in hand comes second so that a rule written over the
+ * selector alone, which is most of them, ignores it. A rule that has to
+ * read the syntax tree goes through `astLink`, which is what puts the
+ * call to use.
+ */
+interface ContainerLink {
+    readonly asks: "container";
+    readonly from: LinkFunction<[readonly string[], CallOps], string | null>;
+}
+/** One question in a chain, and the answer the pack gave for it. */
+type Link<TMeaning> = StartLink | MethodsLink<TMeaning> | ContainerLink;
+/** Which argument or arguments say what a call reached. */
+type ArgumentPick = {
+    readonly at: number;
+} | {
+    readonly from: number;
+};
+/** What one method of a storage client does. */
+interface StorageMethod {
+    readonly kind: "read" | "write";
+    /** Which argument or arguments say what the call reached. */
+    readonly selector?: ArgumentPick;
+    /** Which argument says which field inside it, when the method takes one. */
+    readonly fields?: ArgumentPick;
+}
+/** What a chain produces when every link matches. */
+type Ending = StorageEnding;
+/** A storage access: one call, one thing it read or wrote. */
+interface StorageEnding {
+    readonly yields: "storageAccess";
+    /** The store, in the words OpenTelemetry's semantic conventions use. */
+    readonly system: string;
+    /** The wire, when it differs from the store's own name. */
+    readonly transport?: string;
+    /** Which of the store's namespaces the call reached. */
+    readonly scope: string;
+    /** What a reader gives back for a name nothing in the source settles. */
+    readonly unsettledName: "nothing" | "reference";
+}
+/**
+ * A pack's declaration for one kind of call: the links, the ending, and
+ * a line of code it matches.
+ */
+interface Chain<TMeaning = StorageMethod> {
+    readonly links: readonly Link<TMeaning>[];
+    readonly ending: Ending;
+    /** A line of code this matches, which the pack's tests run. */
+    readonly example: string | null;
+}
+
+export { type ArgumentPick as A, type CallOps as C, type DeclaredBy as D, type Ending as E, type FromReceiver as F, type LinkFunction as L, type MatchStart as M, type OpsCarrier as O, type ReceiverOrigin as R, type StorageMethod as S, type UnsettledName as U, type Chain as a, type ConstructedFrom as b, type ContainerLink as c, type Link as d, type MethodsLink as e, type StartLink as f, type StorageEnding as g, constructedFrom as h, declaredBy as i, opsIn as o };