@suss/recognize 0.13.1 → 0.13.2

package/dist/ast.d.cts

@@ -1,4 +1,6 @@
-import { C as CallOps, L as LinkFunction } from './chain-BaxjT_-k.cjs';
+import { CallOps } from '@suss/extractor';
+import { L as LinkFunction } from './chain-58V6lcel.cjs';
+import '@suss/behavioral-ir';
 
 /**
  * The floor: a link that reads the adapter's own syntax tree.
@@ -14,19 +16,10 @@ import { C as CallOps, L as LinkFunction } from './chain-BaxjT_-k.cjs';
  * 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 };
+export { astLink };

package/dist/ast.d.ts

@@ -1,4 +1,6 @@
-import { C as CallOps, L as LinkFunction } from './chain-BaxjT_-k.js';
+import { CallOps } from '@suss/extractor';
+import { L as LinkFunction } from './chain-58V6lcel.js';
+import '@suss/behavioral-ir';
 
 /**
  * The floor: a link that reads the adapter's own syntax tree.
@@ -14,19 +16,10 @@ import { C as CallOps, L as LinkFunction } from './chain-BaxjT_-k.js';
  * 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 };
+export { astLink };

package/dist/{chain-BaxjT_-k.d.cts → chain-58V6lcel.d.cts}

@@ -1,196 +1,5 @@
-/**
- * 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. A call that reaches for no
- * receiver, `new GetObjectCommand(...)`, is made by its own callee.
- */
-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 value a call states, as the questions a pack can ask about it.
- *
- * `CallOps` reaches a call beside the one in hand, and this reaches the
- * values that are not calls. A library that takes one request object
- * puts everything the call is doing inside it, sometimes as a list and
- * sometimes as a string in a little language of the library's own, and
- * a pack that reads those is handed this rather than the adapter's own
- * node. So the rule it writes runs wherever the ops do.
- */
-interface ValueOps {
-    /** The text of the string the source wrote, or null for anything else. */
-    text(): string | null;
-    /**
-     * The yes or no the source wrote here, or null for anything else. A
-     * library that asks which fields a call wants states them as a map of
-     * flags, `{ name: 1, password: 0 }`, and a number and a boolean mean
-     * the same thing in one of those.
-     */
-    flag(): boolean | null;
-    /** What this object states, entry by entry. Empty for anything else. */
-    entries(unsettled: UnsettledName): readonly ValueEntry[];
-    /** What this list states, item by item. Empty for anything else. */
-    items(): readonly ValueOps[];
-    /** What one named property of this object states, or null for none. */
-    property(name: string): ValueOps | null;
-    /**
-     * The pieces of text the source wrote here, in order, with whatever
-     * it interpolated between them left out. A string is one piece and a
-     * template is one piece per hole plus one, so a reader that means to
-     * put its own placeholders in the holes can. Null when the source
-     * wrote neither.
-     */
-    parts(): readonly string[] | null;
-    /**
-     * What the source interpolated between those pieces, in order, each
-     * as the call it was written as. There is one per gap, one fewer than
-     * `parts` gives, and a hole the source wrote as something other than
-     * a call is null rather than being dropped, so the two lists stay in
-     * step.
-     *
-     * What a hole comes to is the pack's to say. This says what was
-     * there, so a query that hands over a table object can still be read.
-     */
-    holes(): readonly (CallOps | null)[];
-}
-/** One entry of an object a call states. */
-interface ValueEntry {
-    /**
-     * What the entry is called. A key the source computes,
-     * `{ [table]: ... }`, is read the way any other name is.
-     */
-    readonly key: string | null;
-    /** What the entry says. */
-    readonly value: ValueOps;
-}
-/**
- * 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.
- *
- * Two members give back another `CallOps`, which is how these questions
- * reach a call next to this one. A chain of calls and a command object
- * are both these same questions asked one step along, so neither needed
- * a question of its own.
- */
-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;
-    /**
-     * Whether the call itself came from where the origin says, which is
-     * the same question asked of the callee rather than of what it was
-     * called on. `new GetCommand(...)` is the case: a pack that steps to
-     * an argument asks this of it before reading anything, so it never
-     * reads an argument that was never the one.
-     */
-    isFrom(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 call the receiver is, or null when the receiver is not a call.
-     * A receiver the source wrote into a variable comes back as the call
-     * it was written as.
-     */
-    receiver(): CallOps | null;
-    /**
-     * The call the argument in this position is, or null when that
-     * argument is neither a call nor a construction. `new
-     * GetObjectCommand(...)` comes back as a call whose callee is the
-     * class, the same as any other call.
-     */
-    argument(index: number): CallOps | null;
-    /**
-     * The call the callee itself was written as, or null when nothing
-     * wrote it as one. A class a factory made is the case: `new
-     * User({...})` says nothing about what `User` is, and the
-     * `model("User", schema)` call it was declared as says everything.
-     */
-    callee(): CallOps | null;
-    /**
-     * What a named property of the object an argument states says. A
-     * property bag is not a call, so nothing else here reaches into one.
-     */
-    propertyAt(index: number, property: string, unsettled: UnsettledName): string | null;
-    /**
-     * The value the argument in this position states, or null when the
-     * call passes none. `propertyAt` reads one name out of a property
-     * bag, which covers a pack that wants one; this hands the bag over
-     * for a pack whose rule has to walk it.
-     */
-    valueAt(index: number): ValueOps | null;
-}
-/**
- * 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;
+import { MessageBusSemantics } from '@suss/behavioral-ir';
+import { ReceiverOrigin, ValueOps, CallOps, UnsettledName } from '@suss/extractor';
 
 /**
  * The spine every pack shares, as a chain of links.
@@ -475,9 +284,14 @@ interface SqlMethod {
     readonly statement: OneArgument;
 }
 /** What one method table can say a method does. */
-type MethodMeaning = StorageMethod | SqlMethod;
+/** What one send method does, as the message-send ending reads it. */
+interface MessageSendMethod {
+    /** Where the call states the message, or the collection of them. */
+    readonly input: OneArgument;
+}
+type MethodMeaning = StorageMethod | SqlMethod | MessageSendMethod;
 /** What a chain produces when every link matches. */
-type Ending = StorageEnding | SqlEnding;
+type Ending = StorageEnding | SqlEnding | MessageSendEnding;
 /** A storage access: one call, one thing it read or wrote. */
 interface StorageEnding {
     readonly yields: "storageAccess";
@@ -516,6 +330,61 @@ interface SqlEnding {
      */
     readonly dialect: string;
 }
+/**
+ * Where the messages a call sends are written.
+ *
+ * A library either takes one message as the call's input or takes a
+ * collection of them under a property. Which of the two is a fact about
+ * the command, so a library offering both spells them as two
+ * declarations rather than one with a setting on it: SQS has
+ * `SendMessageCommand` and `SendMessageBatchCommand`, and they are
+ * different shapes.
+ */
+type MessageLocation = OneMessage | ManyIn;
+/** The call's input is the message. */
+interface OneMessage {
+    readonly each: "theInput";
+}
+/** A property of the call's input contains the messages, one each. */
+interface ManyIn {
+    readonly each: "in";
+    /** The property the collection is written on. */
+    readonly property: string;
+}
+/**
+ * One part of the channel a message goes to, read off the message.
+ *
+ * A channel is one name on some wires and several on others. SQS has a
+ * queue, EventBridge has a bus and a subject on it, and both are read
+ * the same way, so a pack states the parts in the order they join.
+ */
+interface ChannelPart {
+    /** The property the message states this part on. */
+    readonly property: string;
+    /** What the library uses when the message leaves this part out. */
+    readonly whenAbsent?: string;
+}
+/** A message sent on a wire, which pairs with whatever consumes that channel. */
+interface MessageSendEnding {
+    readonly yields: "messageSend";
+    /** The wire, in the words the IR's message-bus semantics use. */
+    readonly wire: MessageBusSemantics["messageBus"];
+    /** Where the messages are. */
+    readonly messages: MessageLocation;
+    /** The parts of the channel, joined in the order they are written. */
+    readonly channel: readonly ChannelPart[];
+    /** What joins the parts, when there is more than one. */
+    readonly channelSeparator?: string;
+    /** The property the message states its body on, when the pack can say. */
+    readonly body?: string;
+    /**
+     * What a reader gives back for a channel nothing in the source
+     * settles. A queue URL only exists at deploy time, so the code writes
+     * `process.env.ORDERS_QUEUE_URL` and the env var's name is what both
+     * sides of the boundary agree on. `"reference"` keeps that name.
+     */
+    readonly unsettledName: UnsettledName;
+}
 /**
  * A pack's declaration for one kind of call: the links, the ending, and
  * a line of code it matches.
@@ -527,4 +396,4 @@ interface Chain<TMeaning = MethodMeaning> {
     readonly example: string | null;
 }
 
-export { type ArgumentPick as A, declaredBy as B, type CallOps as C, type DeclaredBy as D, type Ending as E, type FromReceiver as F, opsIn as G, type InterpolatesLink as I, type KindAsAsked as K, type LinkFunction as L, type MethodMeaning as M, type OneArgument as O, type ReceiverOrigin as R, type SqlMethod as S, type ToArgument as T, type UnsettledName as U, type ValueEntry as V, type Chain as a, type CallStep as b, type StorageMethod as c, type AccessKind as d, type AccessPathLink as e, type ArgumentsFrom as f, type ConstructedFrom as g, type ContainerArgument as h, type ContainerLink as i, type ContainerRule as j, type ContainersLink as k, type InputLink as l, type InputRule as m, type Link as n, type MatchStart as o, type MethodsLink as p, type OpsCarrier as q, type SqlEnding as r, type StartLink as s, type StatedInputs as t, type StatedRule as u, type StorageEnding as v, type SubjectLink as w, type ToReceiver as x, type ValueOps as y, constructedFrom as z };
+export type { ArgumentPick as A, ToReceiver as B, Chain as C, Ending as E, FromReceiver as F, InterpolatesLink as I, KindAsAsked as K, LinkFunction as L, MethodMeaning as M, OneArgument as O, SqlMethod as S, ToArgument as T, MessageSendMethod as a, MessageLocation as b, ChannelPart as c, CallStep as d, StorageMethod as e, AccessKind as f, AccessPathLink as g, ArgumentsFrom as h, ContainerArgument as i, ContainerLink as j, ContainerRule as k, ContainersLink as l, InputLink as m, InputRule as n, Link as o, ManyIn as p, MatchStart as q, MessageSendEnding as r, MethodsLink as s, OneMessage as t, SqlEnding as u, StartLink as v, StatedInputs as w, StatedRule as x, StorageEnding as y, SubjectLink as z };

package/dist/{chain-BaxjT_-k.d.ts → chain-58V6lcel.d.ts}

@@ -1,196 +1,5 @@
-/**
- * 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. A call that reaches for no
- * receiver, `new GetObjectCommand(...)`, is made by its own callee.
- */
-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 value a call states, as the questions a pack can ask about it.
- *
- * `CallOps` reaches a call beside the one in hand, and this reaches the
- * values that are not calls. A library that takes one request object
- * puts everything the call is doing inside it, sometimes as a list and
- * sometimes as a string in a little language of the library's own, and
- * a pack that reads those is handed this rather than the adapter's own
- * node. So the rule it writes runs wherever the ops do.
- */
-interface ValueOps {
-    /** The text of the string the source wrote, or null for anything else. */
-    text(): string | null;
-    /**
-     * The yes or no the source wrote here, or null for anything else. A
-     * library that asks which fields a call wants states them as a map of
-     * flags, `{ name: 1, password: 0 }`, and a number and a boolean mean
-     * the same thing in one of those.
-     */
-    flag(): boolean | null;
-    /** What this object states, entry by entry. Empty for anything else. */
-    entries(unsettled: UnsettledName): readonly ValueEntry[];
-    /** What this list states, item by item. Empty for anything else. */
-    items(): readonly ValueOps[];
-    /** What one named property of this object states, or null for none. */
-    property(name: string): ValueOps | null;
-    /**
-     * The pieces of text the source wrote here, in order, with whatever
-     * it interpolated between them left out. A string is one piece and a
-     * template is one piece per hole plus one, so a reader that means to
-     * put its own placeholders in the holes can. Null when the source
-     * wrote neither.
-     */
-    parts(): readonly string[] | null;
-    /**
-     * What the source interpolated between those pieces, in order, each
-     * as the call it was written as. There is one per gap, one fewer than
-     * `parts` gives, and a hole the source wrote as something other than
-     * a call is null rather than being dropped, so the two lists stay in
-     * step.
-     *
-     * What a hole comes to is the pack's to say. This says what was
-     * there, so a query that hands over a table object can still be read.
-     */
-    holes(): readonly (CallOps | null)[];
-}
-/** One entry of an object a call states. */
-interface ValueEntry {
-    /**
-     * What the entry is called. A key the source computes,
-     * `{ [table]: ... }`, is read the way any other name is.
-     */
-    readonly key: string | null;
-    /** What the entry says. */
-    readonly value: ValueOps;
-}
-/**
- * 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.
- *
- * Two members give back another `CallOps`, which is how these questions
- * reach a call next to this one. A chain of calls and a command object
- * are both these same questions asked one step along, so neither needed
- * a question of its own.
- */
-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;
-    /**
-     * Whether the call itself came from where the origin says, which is
-     * the same question asked of the callee rather than of what it was
-     * called on. `new GetCommand(...)` is the case: a pack that steps to
-     * an argument asks this of it before reading anything, so it never
-     * reads an argument that was never the one.
-     */
-    isFrom(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 call the receiver is, or null when the receiver is not a call.
-     * A receiver the source wrote into a variable comes back as the call
-     * it was written as.
-     */
-    receiver(): CallOps | null;
-    /**
-     * The call the argument in this position is, or null when that
-     * argument is neither a call nor a construction. `new
-     * GetObjectCommand(...)` comes back as a call whose callee is the
-     * class, the same as any other call.
-     */
-    argument(index: number): CallOps | null;
-    /**
-     * The call the callee itself was written as, or null when nothing
-     * wrote it as one. A class a factory made is the case: `new
-     * User({...})` says nothing about what `User` is, and the
-     * `model("User", schema)` call it was declared as says everything.
-     */
-    callee(): CallOps | null;
-    /**
-     * What a named property of the object an argument states says. A
-     * property bag is not a call, so nothing else here reaches into one.
-     */
-    propertyAt(index: number, property: string, unsettled: UnsettledName): string | null;
-    /**
-     * The value the argument in this position states, or null when the
-     * call passes none. `propertyAt` reads one name out of a property
-     * bag, which covers a pack that wants one; this hands the bag over
-     * for a pack whose rule has to walk it.
-     */
-    valueAt(index: number): ValueOps | null;
-}
-/**
- * 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;
+import { MessageBusSemantics } from '@suss/behavioral-ir';
+import { ReceiverOrigin, ValueOps, CallOps, UnsettledName } from '@suss/extractor';
 
 /**
  * The spine every pack shares, as a chain of links.
@@ -475,9 +284,14 @@ interface SqlMethod {
     readonly statement: OneArgument;
 }
 /** What one method table can say a method does. */
-type MethodMeaning = StorageMethod | SqlMethod;
+/** What one send method does, as the message-send ending reads it. */
+interface MessageSendMethod {
+    /** Where the call states the message, or the collection of them. */
+    readonly input: OneArgument;
+}
+type MethodMeaning = StorageMethod | SqlMethod | MessageSendMethod;
 /** What a chain produces when every link matches. */
-type Ending = StorageEnding | SqlEnding;
+type Ending = StorageEnding | SqlEnding | MessageSendEnding;
 /** A storage access: one call, one thing it read or wrote. */
 interface StorageEnding {
     readonly yields: "storageAccess";
@@ -516,6 +330,61 @@ interface SqlEnding {
      */
     readonly dialect: string;
 }
+/**
+ * Where the messages a call sends are written.
+ *
+ * A library either takes one message as the call's input or takes a
+ * collection of them under a property. Which of the two is a fact about
+ * the command, so a library offering both spells them as two
+ * declarations rather than one with a setting on it: SQS has
+ * `SendMessageCommand` and `SendMessageBatchCommand`, and they are
+ * different shapes.
+ */
+type MessageLocation = OneMessage | ManyIn;
+/** The call's input is the message. */
+interface OneMessage {
+    readonly each: "theInput";
+}
+/** A property of the call's input contains the messages, one each. */
+interface ManyIn {
+    readonly each: "in";
+    /** The property the collection is written on. */
+    readonly property: string;
+}
+/**
+ * One part of the channel a message goes to, read off the message.
+ *
+ * A channel is one name on some wires and several on others. SQS has a
+ * queue, EventBridge has a bus and a subject on it, and both are read
+ * the same way, so a pack states the parts in the order they join.
+ */
+interface ChannelPart {
+    /** The property the message states this part on. */
+    readonly property: string;
+    /** What the library uses when the message leaves this part out. */
+    readonly whenAbsent?: string;
+}
+/** A message sent on a wire, which pairs with whatever consumes that channel. */
+interface MessageSendEnding {
+    readonly yields: "messageSend";
+    /** The wire, in the words the IR's message-bus semantics use. */
+    readonly wire: MessageBusSemantics["messageBus"];
+    /** Where the messages are. */
+    readonly messages: MessageLocation;
+    /** The parts of the channel, joined in the order they are written. */
+    readonly channel: readonly ChannelPart[];
+    /** What joins the parts, when there is more than one. */
+    readonly channelSeparator?: string;
+    /** The property the message states its body on, when the pack can say. */
+    readonly body?: string;
+    /**
+     * What a reader gives back for a channel nothing in the source
+     * settles. A queue URL only exists at deploy time, so the code writes
+     * `process.env.ORDERS_QUEUE_URL` and the env var's name is what both
+     * sides of the boundary agree on. `"reference"` keeps that name.
+     */
+    readonly unsettledName: UnsettledName;
+}
 /**
  * A pack's declaration for one kind of call: the links, the ending, and
  * a line of code it matches.
@@ -527,4 +396,4 @@ interface Chain<TMeaning = MethodMeaning> {
     readonly example: string | null;
 }
 
-export { type ArgumentPick as A, declaredBy as B, type CallOps as C, type DeclaredBy as D, type Ending as E, type FromReceiver as F, opsIn as G, type InterpolatesLink as I, type KindAsAsked as K, type LinkFunction as L, type MethodMeaning as M, type OneArgument as O, type ReceiverOrigin as R, type SqlMethod as S, type ToArgument as T, type UnsettledName as U, type ValueEntry as V, type Chain as a, type CallStep as b, type StorageMethod as c, type AccessKind as d, type AccessPathLink as e, type ArgumentsFrom as f, type ConstructedFrom as g, type ContainerArgument as h, type ContainerLink as i, type ContainerRule as j, type ContainersLink as k, type InputLink as l, type InputRule as m, type Link as n, type MatchStart as o, type MethodsLink as p, type OpsCarrier as q, type SqlEnding as r, type StartLink as s, type StatedInputs as t, type StatedRule as u, type StorageEnding as v, type SubjectLink as w, type ToReceiver as x, type ValueOps as y, constructedFrom as z };
+export type { ArgumentPick as A, ToReceiver as B, Chain as C, Ending as E, FromReceiver as F, InterpolatesLink as I, KindAsAsked as K, LinkFunction as L, MethodMeaning as M, OneArgument as O, SqlMethod as S, ToArgument as T, MessageSendMethod as a, MessageLocation as b, ChannelPart as c, CallStep as d, StorageMethod as e, AccessKind as f, AccessPathLink as g, ArgumentsFrom as h, ContainerArgument as i, ContainerLink as j, ContainerRule as k, ContainersLink as l, InputLink as m, InputRule as n, Link as o, ManyIn as p, MatchStart as q, MessageSendEnding as r, MethodsLink as s, OneMessage as t, SqlEnding as u, StartLink as v, StatedInputs as w, StatedRule as x, StorageEnding as y, SubjectLink as z };

package/dist/index.cjs

@@ -25,6 +25,7 @@ __export(index_exports, {
   declarationsIn: () => declarationsIn,
   declaredBy: () => declaredBy,
   examplesMissing: () => examplesMissing,
+  messageSends: () => messageSends,
   opsIn: () => opsIn,
   pack: () => pack,
   runExamples: () => runExamples,
@@ -41,8 +42,16 @@ var import_sql = require("@suss/sql");
 function declaredBy(...importedFrom) {
   return { origin: "declaredBy", importedFrom };
 }
-function constructedFrom(...importedFrom) {
-  return { origin: "constructed", importedFrom };
+function constructedFrom(...args) {
+  const [first] = args;
+  if (typeof first === "object") {
+    return {
+      origin: "constructed",
+      importedFrom: first.from,
+      named: first.named
+    };
+  }
+  return { origin: "constructed", importedFrom: args };
 }
 function opsIn(ctx) {
   const carrier = ctx;
@@ -152,7 +161,8 @@ function startsHere(chain, subject) {
 }
 var YIELD = {
   storageAccess,
-  sqlAccess
+  sqlAccess,
+  messageSend
 };
 function storageAccess(matched) {
   const { subject, chain } = matched;
@@ -247,6 +257,7 @@ function statedValue(subject, pick) {
 }
 var NOTHING_STATED = {
   text: () => null,
+  name: () => null,
   flag: () => null,
   entries: () => [],
   items: () => [],
@@ -299,6 +310,57 @@ function nameOf(ops, pick, index, unsettled) {
   }
   return null;
 }
+function messageSend(matched) {
+  const { ops, subject, chain, recognition } = matched;
+  const ending = chain.ending;
+  const input = statedValue(
+    subject,
+    matched.meaning.input
+  );
+  if (input === null) {
+    return null;
+  }
+  const messages = messagesIn(input, ending.messages);
+  return messages.length === 0 ? null : messages.map((message) => ({
+    type: "interaction",
+    binding: (0, import_behavioral_ir.messageBusBinding)({
+      recognition,
+      messageBus: ending.wire,
+      channel: channelOf(message, ending)
+    }),
+    callee: ops.calleeText(),
+    interaction: {
+      class: "message-send",
+      ...bodyOf(message, ending)
+    }
+  }));
+}
+function messagesIn(input, location) {
+  if (location.each === "theInput") {
+    return [input];
+  }
+  const collection = input.property(location.property);
+  return collection === null ? [] : collection.items();
+}
+function channelOf(message, ending) {
+  const parts = [];
+  for (const part of ending.channel) {
+    const stated = message.property(part.property)?.name(ending.unsettledName) ?? null;
+    const value = stated === null || stated === "" ? part.whenAbsent : stated;
+    if (value === void 0) {
+      return null;
+    }
+    parts.push(value);
+  }
+  return parts.join(ending.channelSeparator ?? "#");
+}
+function bodyOf(message, ending) {
+  if (ending.body === void 0) {
+    return {};
+  }
+  const stated = message.property(ending.body)?.text() ?? null;
+  return stated === null ? {} : { body: stated };
+}
 function sqlAccess(matched) {
   const { ops, subject, method, chain, recognition } = matched;
   const ending = chain.ending;
@@ -362,10 +424,46 @@ function examplesMissing(pack2) {
   return (pack2.declarations?.declarations ?? []).filter((declaration) => declaration.example === null).map((declaration) => declaration.name);
 }
 
+// src/chain.ts
+function chainStart(client) {
+  return client === void 0 ? [] : [{ asks: "start", at: { starts: "receiver", origin: client } }];
+}
+
+// src/messageSends.ts
+function messageSends(spec) {
+  const ending = {
+    yields: "messageSend",
+    wire: spec.wire,
+    messages: spec.messages,
+    channel: spec.channel,
+    ...spec.channelSeparator === void 0 ? {} : { channelSeparator: spec.channelSeparator },
+    ...spec.body === void 0 ? {} : { body: spec.body },
+    unsettledName: spec.unsettledName ?? "reference"
+  };
+  return chainFrom({
+    links: chainStart(spec.client),
+    ending,
+    example: null
+  });
+}
+function chainFrom(declared) {
+  const adding = (link) => chainFrom({ ...declared, links: [...declared.links, link] });
+  return {
+    declared,
+    methods: (table, options) => adding({
+      asks: "methods",
+      table,
+      ignoringCase: options?.ignoringCase ?? false
+    }),
+    example: (code) => chainFrom({ ...declared, example: code })
+  };
+}
+
 // src/pack.ts
 var DISPATCHED_ON = {
   storageAccess: "invocation",
-  sqlAccess: "access"
+  sqlAccess: "access",
+  messageSend: "invocation"
 };
 function walkedBy(chains, walk2, recognizedAs) {
   return chains.filter((chain) => DISPATCHED_ON[chain.ending.yields] === walk2).map((chain) => compile(chain, recognizedAs));
@@ -392,10 +490,17 @@ function pack(name, matches, spec) {
 function declarationsIn(matches) {
   return { declarations: matches.map((match) => describe(match.declared)) };
 }
+function wireOf(ending) {
+  if (ending.yields === "messageSend") {
+    return ending.wire;
+  }
+  return ending.transport ?? ending.system;
+}
+function declaredName(ending) {
+  return ending.yields === "messageSend" ? ending.wire : ending.system;
+}
 function protocolOf(chains) {
-  const wires = new Set(
-    chains.map((chain) => chain.ending.transport ?? chain.ending.system)
-  );
+  const wires = new Set(chains.map((chain) => wireOf(chain.ending)));
   const [only] = [...wires];
   if (wires.size !== 1 || only === void 0) {
     throw new Error(
@@ -445,7 +550,7 @@ function describe(chain) {
     ...rulesIn(chain)
   ];
   return {
-    name: chain.ending.system,
+    name: declaredName(chain.ending),
     // A method table with a rule inside it is still a table, so that
     // link stays counted as data and the rule is priced beside it.
     dataLinks: chain.links.length - links.length,
@@ -496,14 +601,14 @@ function sqlStatements(spec) {
     dialect: spec.dialect
   };
   const client = spec.client;
-  return chainFrom({
-    links: client === void 0 ? [] : [{ asks: "start", at: { starts: "receiver", origin: client } }],
+  return chainFrom2({
+    links: chainStart(client),
     ending,
     example: null
   });
 }
-function chainFrom(declared) {
-  const adding = (link) => chainFrom({ ...declared, links: [...declared.links, link] });
+function chainFrom2(declared) {
+  const adding = (link) => chainFrom2({ ...declared, links: [...declared.links, link] });
   return {
     declared,
     methods: (table, options) => adding({
@@ -512,7 +617,7 @@ function chainFrom(declared) {
       ignoringCase: options?.ignoringCase ?? false
     }),
     interpolating: (says) => adding({ asks: "interpolates", ...says }),
-    example: (code) => chainFrom({ ...declared, example: code })
+    example: (code) => chainFrom2({ ...declared, example: code })
   };
 }
 
@@ -526,14 +631,14 @@ function storageCalls(spec) {
     unsettledName: spec.unsettledName ?? "reference"
   };
   const client = spec.client;
-  return chainFrom2({
-    links: client === void 0 ? [] : [{ asks: "start", at: { starts: "receiver", origin: client } }],
+  return chainFrom3({
+    links: chainStart(client),
     ending,
     example: null
   });
 }
-function chainFrom2(declared) {
-  const adding = (link) => chainFrom2({ ...declared, links: [...declared.links, link] });
+function chainFrom3(declared) {
+  const adding = (link) => chainFrom3({ ...declared, links: [...declared.links, link] });
   return {
     declared,
     about: (...of) => adding({ asks: "subject", of }),
@@ -548,7 +653,7 @@ function chainFrom2(declared) {
     accessPath: (says) => adding({ asks: "accessPath", argument: says }),
     containersIn: (says) => adding({ asks: "containers", in: says }),
     input: (says) => adding({ asks: "input", at: says }),
-    example: (code) => chainFrom2({ ...declared, example: code })
+    example: (code) => chainFrom3({ ...declared, example: code })
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -558,6 +663,7 @@ function chainFrom2(declared) {
   declarationsIn,
   declaredBy,
   examplesMissing,
+  messageSends,
   opsIn,
   pack,
   runExamples,

package/dist/index.d.cts

@@ -1,8 +1,33 @@
-import { InvocationRecognizer, PatternPack, PackDeclarations } from '@suss/extractor';
-export { DeclaredMatch, PackDeclarations, PatternPack } from '@suss/extractor';
-import { a as Chain, M as MethodMeaning, S as SqlMethod, I as InterpolatesLink, R as ReceiverOrigin, b as CallStep, c as StorageMethod, A as ArgumentPick, L as LinkFunction, C as CallOps, O as OneArgument } from './chain-BaxjT_-k.cjs';
-export { d as AccessKind, e as AccessPathLink, f as ArgumentsFrom, g as ConstructedFrom, h as ContainerArgument, i as ContainerLink, j as ContainerRule, k as ContainersLink, D as DeclaredBy, E as Ending, F as FromReceiver, l as InputLink, m as InputRule, K as KindAsAsked, n as Link, o as MatchStart, p as MethodsLink, q as OpsCarrier, r as SqlEnding, s as StartLink, t as StatedInputs, u as StatedRule, v as StorageEnding, w as SubjectLink, T as ToArgument, x as ToReceiver, U as UnsettledName, V as ValueEntry, y as ValueOps, z as constructedFrom, B as declaredBy, G as opsIn } from './chain-BaxjT_-k.cjs';
-import { Effect } from '@suss/behavioral-ir';
+import { ConstructedFrom, DeclaredBy, CallOps, InvocationRecognizer, PatternPack, UnsettledName, ReceiverOrigin, PackDeclarations } from '@suss/extractor';
+export { CallOps, ConstructedFrom, DeclaredBy, DeclaredMatch, OpsCarrier, PackDeclarations, PatternPack, ReceiverOrigin, UnsettledName, ValueEntry, ValueOps } from '@suss/extractor';
+import { C as Chain, M as MethodMeaning, a as MessageSendMethod, b as MessageLocation, c as ChannelPart, S as SqlMethod, I as InterpolatesLink, d as CallStep, e as StorageMethod, A as ArgumentPick, L as LinkFunction, O as OneArgument } from './chain-58V6lcel.cjs';
+export { f as AccessKind, g as AccessPathLink, h as ArgumentsFrom, i as ContainerArgument, j as ContainerLink, k as ContainerRule, l as ContainersLink, E as Ending, F as FromReceiver, m as InputLink, n as InputRule, K as KindAsAsked, o as Link, p as ManyIn, q as MatchStart, r as MessageSendEnding, s as MethodsLink, t as OneMessage, u as SqlEnding, v as StartLink, w as StatedInputs, x as StatedRule, y as StorageEnding, z as SubjectLink, T as ToArgument, B as ToReceiver } from './chain-58V6lcel.cjs';
+import { Effect, MessageBusSemantics } from '@suss/behavioral-ir';
+
+/**
+ * The small builders a pack writes its origins with, and the vocabulary
+ * they produce.
+ *
+ * The types live in `@suss/extractor` because an adapter implements them
+ * and never calls any of this. They are re-exported here so a pack
+ * author has one import.
+ */
+
+/**
+ * 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;
+/** A client made from named exports of those modules. */
+declare function constructedFrom(spec: {
+    from: readonly string[];
+    named: readonly string[];
+}): ConstructedFrom;
+/** The ops in a recognizer context, or null when the adapter has none. */
+declare function opsIn(ctx: unknown): CallOps | null;
 
 /**
  * Turning a chain into the recognizer hook the adapters already call.
@@ -53,6 +78,57 @@ declare function runExamples(pack: PatternPack, run: RunOverCode): RanExample[];
 /** The declarations a pack shipped without a line of code to run. */
 declare function examplesMissing(pack: PatternPack): string[];
 
+/**
+ * messageSends.ts: a pack that recognizes a call putting a message on a
+ * wire.
+ *
+ * The AWS SDK shape is the one this was written against. An operation
+ * is a command class and its arguments are one object, so the pack says
+ * which command, where the message is inside it, and which of the
+ * message's properties name the channel:
+ *
+ *   client.send(new SendMessageCommand({ QueueUrl, MessageBody }))
+ *   client.send(new PutEventsCommand({ Entries: [{ EventBusName, DetailType }] }))
+ *
+ * A library taking one message and a batch of them offers two commands,
+ * so a pack writes two declarations. Which of the two a command is
+ * belongs to the command rather than to a setting on one declaration.
+ */
+
+interface MessageSendsSpec {
+    /** The wire, in the words the IR's message-bus semantics use. */
+    wire: MessageBusSemantics["messageBus"];
+    /** Where the messages are: the call's input, or a property holding many. */
+    messages: MessageLocation;
+    /** The parts of the channel, joined in the order they are written. */
+    channel: readonly ChannelPart[];
+    /** What joins the parts. Defaults to "#", which is what a bus and a subject use. */
+    channelSeparator?: string;
+    /** The property a message states its body on. */
+    body?: string;
+    /**
+     * What a reader gives back for a channel nothing in the source
+     * settles. Defaults to keeping the reference, since a queue named
+     * only at deploy time is the common case rather than the exception.
+     */
+    unsettledName?: UnsettledName;
+    /** How the pack pins down the client its calls are on. */
+    client?: ReceiverOrigin;
+}
+/** A chain over sends, and the links that can still be added. */
+interface MessageSends {
+    /** Which methods send, and where each one states the message. */
+    methods(table: Readonly<Record<string, MessageSendMethod>>, options?: {
+        ignoringCase?: boolean;
+    }): MessageSends;
+    /** A line of code this matches, which the pack's tests run. */
+    example(code: string): MessageSends;
+    /** The links and the ending, as data. */
+    readonly declared: Chain<MessageSendMethod>;
+}
+/** A pack that recognizes a call sending a message. */
+declare function messageSends(spec: MessageSendsSpec): MessageSends;
+
 /**
  * Assembling declared chains into the pack the adapters load.
  *
@@ -225,4 +301,4 @@ interface StorageCalls {
 /** A pack that recognizes calls against a store. */
 declare function storageCalls(spec: StorageCallsSpec): StorageCalls;
 
-export { ArgumentPick, CallOps, CallStep, Chain, InterpolatesLink, LinkFunction, type Match, MethodMeaning, OneArgument, type PackSpec, type RanExample, ReceiverOrigin, type RunOverCode, SqlMethod, type SqlStatements, type SqlStatementsSpec, type StorageCalls, type StorageCallsSpec, StorageMethod, compile, declarationsIn, examplesMissing, pack, runExamples, sqlStatements, storageCalls };
+export { ArgumentPick, CallStep, Chain, ChannelPart, InterpolatesLink, LinkFunction, type Match, MessageLocation, MessageSendMethod, type MessageSends, type MessageSendsSpec, MethodMeaning, OneArgument, type PackSpec, type RanExample, type RunOverCode, SqlMethod, type SqlStatements, type SqlStatementsSpec, type StorageCalls, type StorageCallsSpec, StorageMethod, compile, constructedFrom, declarationsIn, declaredBy, examplesMissing, messageSends, opsIn, pack, runExamples, sqlStatements, storageCalls };

package/dist/index.d.ts

@@ -1,8 +1,33 @@
-import { InvocationRecognizer, PatternPack, PackDeclarations } from '@suss/extractor';
-export { DeclaredMatch, PackDeclarations, PatternPack } from '@suss/extractor';
-import { a as Chain, M as MethodMeaning, S as SqlMethod, I as InterpolatesLink, R as ReceiverOrigin, b as CallStep, c as StorageMethod, A as ArgumentPick, L as LinkFunction, C as CallOps, O as OneArgument } from './chain-BaxjT_-k.js';
-export { d as AccessKind, e as AccessPathLink, f as ArgumentsFrom, g as ConstructedFrom, h as ContainerArgument, i as ContainerLink, j as ContainerRule, k as ContainersLink, D as DeclaredBy, E as Ending, F as FromReceiver, l as InputLink, m as InputRule, K as KindAsAsked, n as Link, o as MatchStart, p as MethodsLink, q as OpsCarrier, r as SqlEnding, s as StartLink, t as StatedInputs, u as StatedRule, v as StorageEnding, w as SubjectLink, T as ToArgument, x as ToReceiver, U as UnsettledName, V as ValueEntry, y as ValueOps, z as constructedFrom, B as declaredBy, G as opsIn } from './chain-BaxjT_-k.js';
-import { Effect } from '@suss/behavioral-ir';
+import { ConstructedFrom, DeclaredBy, CallOps, InvocationRecognizer, PatternPack, UnsettledName, ReceiverOrigin, PackDeclarations } from '@suss/extractor';
+export { CallOps, ConstructedFrom, DeclaredBy, DeclaredMatch, OpsCarrier, PackDeclarations, PatternPack, ReceiverOrigin, UnsettledName, ValueEntry, ValueOps } from '@suss/extractor';
+import { C as Chain, M as MethodMeaning, a as MessageSendMethod, b as MessageLocation, c as ChannelPart, S as SqlMethod, I as InterpolatesLink, d as CallStep, e as StorageMethod, A as ArgumentPick, L as LinkFunction, O as OneArgument } from './chain-58V6lcel.js';
+export { f as AccessKind, g as AccessPathLink, h as ArgumentsFrom, i as ContainerArgument, j as ContainerLink, k as ContainerRule, l as ContainersLink, E as Ending, F as FromReceiver, m as InputLink, n as InputRule, K as KindAsAsked, o as Link, p as ManyIn, q as MatchStart, r as MessageSendEnding, s as MethodsLink, t as OneMessage, u as SqlEnding, v as StartLink, w as StatedInputs, x as StatedRule, y as StorageEnding, z as SubjectLink, T as ToArgument, B as ToReceiver } from './chain-58V6lcel.js';
+import { Effect, MessageBusSemantics } from '@suss/behavioral-ir';
+
+/**
+ * The small builders a pack writes its origins with, and the vocabulary
+ * they produce.
+ *
+ * The types live in `@suss/extractor` because an adapter implements them
+ * and never calls any of this. They are re-exported here so a pack
+ * author has one import.
+ */
+
+/**
+ * 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;
+/** A client made from named exports of those modules. */
+declare function constructedFrom(spec: {
+    from: readonly string[];
+    named: readonly string[];
+}): ConstructedFrom;
+/** The ops in a recognizer context, or null when the adapter has none. */
+declare function opsIn(ctx: unknown): CallOps | null;
 
 /**
  * Turning a chain into the recognizer hook the adapters already call.
@@ -53,6 +78,57 @@ declare function runExamples(pack: PatternPack, run: RunOverCode): RanExample[];
 /** The declarations a pack shipped without a line of code to run. */
 declare function examplesMissing(pack: PatternPack): string[];
 
+/**
+ * messageSends.ts: a pack that recognizes a call putting a message on a
+ * wire.
+ *
+ * The AWS SDK shape is the one this was written against. An operation
+ * is a command class and its arguments are one object, so the pack says
+ * which command, where the message is inside it, and which of the
+ * message's properties name the channel:
+ *
+ *   client.send(new SendMessageCommand({ QueueUrl, MessageBody }))
+ *   client.send(new PutEventsCommand({ Entries: [{ EventBusName, DetailType }] }))
+ *
+ * A library taking one message and a batch of them offers two commands,
+ * so a pack writes two declarations. Which of the two a command is
+ * belongs to the command rather than to a setting on one declaration.
+ */
+
+interface MessageSendsSpec {
+    /** The wire, in the words the IR's message-bus semantics use. */
+    wire: MessageBusSemantics["messageBus"];
+    /** Where the messages are: the call's input, or a property holding many. */
+    messages: MessageLocation;
+    /** The parts of the channel, joined in the order they are written. */
+    channel: readonly ChannelPart[];
+    /** What joins the parts. Defaults to "#", which is what a bus and a subject use. */
+    channelSeparator?: string;
+    /** The property a message states its body on. */
+    body?: string;
+    /**
+     * What a reader gives back for a channel nothing in the source
+     * settles. Defaults to keeping the reference, since a queue named
+     * only at deploy time is the common case rather than the exception.
+     */
+    unsettledName?: UnsettledName;
+    /** How the pack pins down the client its calls are on. */
+    client?: ReceiverOrigin;
+}
+/** A chain over sends, and the links that can still be added. */
+interface MessageSends {
+    /** Which methods send, and where each one states the message. */
+    methods(table: Readonly<Record<string, MessageSendMethod>>, options?: {
+        ignoringCase?: boolean;
+    }): MessageSends;
+    /** A line of code this matches, which the pack's tests run. */
+    example(code: string): MessageSends;
+    /** The links and the ending, as data. */
+    readonly declared: Chain<MessageSendMethod>;
+}
+/** A pack that recognizes a call sending a message. */
+declare function messageSends(spec: MessageSendsSpec): MessageSends;
+
 /**
  * Assembling declared chains into the pack the adapters load.
  *
@@ -225,4 +301,4 @@ interface StorageCalls {
 /** A pack that recognizes calls against a store. */
 declare function storageCalls(spec: StorageCallsSpec): StorageCalls;
 
-export { ArgumentPick, CallOps, CallStep, Chain, InterpolatesLink, LinkFunction, type Match, MethodMeaning, OneArgument, type PackSpec, type RanExample, ReceiverOrigin, type RunOverCode, SqlMethod, type SqlStatements, type SqlStatementsSpec, type StorageCalls, type StorageCallsSpec, StorageMethod, compile, declarationsIn, examplesMissing, pack, runExamples, sqlStatements, storageCalls };
+export { ArgumentPick, CallStep, Chain, ChannelPart, InterpolatesLink, LinkFunction, type Match, MessageLocation, MessageSendMethod, type MessageSends, type MessageSendsSpec, MethodMeaning, OneArgument, type PackSpec, type RanExample, type RunOverCode, SqlMethod, type SqlStatements, type SqlStatementsSpec, type StorageCalls, type StorageCallsSpec, StorageMethod, compile, constructedFrom, declarationsIn, declaredBy, examplesMissing, messageSends, opsIn, pack, runExamples, sqlStatements, storageCalls };

package/dist/index.js

@@ -1,13 +1,21 @@
 // src/compile.ts
-import { storageBinding } from "@suss/behavioral-ir";
+import { messageBusBinding, storageBinding } from "@suss/behavioral-ir";
 import { readSqlAccess, sqlFromParts } from "@suss/sql";
 
 // src/ops.ts
 function declaredBy(...importedFrom) {
   return { origin: "declaredBy", importedFrom };
 }
-function constructedFrom(...importedFrom) {
-  return { origin: "constructed", importedFrom };
+function constructedFrom(...args) {
+  const [first] = args;
+  if (typeof first === "object") {
+    return {
+      origin: "constructed",
+      importedFrom: first.from,
+      named: first.named
+    };
+  }
+  return { origin: "constructed", importedFrom: args };
 }
 function opsIn(ctx) {
   const carrier = ctx;
@@ -117,7 +125,8 @@ function startsHere(chain, subject) {
 }
 var YIELD = {
   storageAccess,
-  sqlAccess
+  sqlAccess,
+  messageSend
 };
 function storageAccess(matched) {
   const { subject, chain } = matched;
@@ -212,6 +221,7 @@ function statedValue(subject, pick) {
 }
 var NOTHING_STATED = {
   text: () => null,
+  name: () => null,
   flag: () => null,
   entries: () => [],
   items: () => [],
@@ -264,6 +274,57 @@ function nameOf(ops, pick, index, unsettled) {
   }
   return null;
 }
+function messageSend(matched) {
+  const { ops, subject, chain, recognition } = matched;
+  const ending = chain.ending;
+  const input = statedValue(
+    subject,
+    matched.meaning.input
+  );
+  if (input === null) {
+    return null;
+  }
+  const messages = messagesIn(input, ending.messages);
+  return messages.length === 0 ? null : messages.map((message) => ({
+    type: "interaction",
+    binding: messageBusBinding({
+      recognition,
+      messageBus: ending.wire,
+      channel: channelOf(message, ending)
+    }),
+    callee: ops.calleeText(),
+    interaction: {
+      class: "message-send",
+      ...bodyOf(message, ending)
+    }
+  }));
+}
+function messagesIn(input, location) {
+  if (location.each === "theInput") {
+    return [input];
+  }
+  const collection = input.property(location.property);
+  return collection === null ? [] : collection.items();
+}
+function channelOf(message, ending) {
+  const parts = [];
+  for (const part of ending.channel) {
+    const stated = message.property(part.property)?.name(ending.unsettledName) ?? null;
+    const value = stated === null || stated === "" ? part.whenAbsent : stated;
+    if (value === void 0) {
+      return null;
+    }
+    parts.push(value);
+  }
+  return parts.join(ending.channelSeparator ?? "#");
+}
+function bodyOf(message, ending) {
+  if (ending.body === void 0) {
+    return {};
+  }
+  const stated = message.property(ending.body)?.text() ?? null;
+  return stated === null ? {} : { body: stated };
+}
 function sqlAccess(matched) {
   const { ops, subject, method, chain, recognition } = matched;
   const ending = chain.ending;
@@ -327,10 +388,46 @@ function examplesMissing(pack2) {
   return (pack2.declarations?.declarations ?? []).filter((declaration) => declaration.example === null).map((declaration) => declaration.name);
 }
 
+// src/chain.ts
+function chainStart(client) {
+  return client === void 0 ? [] : [{ asks: "start", at: { starts: "receiver", origin: client } }];
+}
+
+// src/messageSends.ts
+function messageSends(spec) {
+  const ending = {
+    yields: "messageSend",
+    wire: spec.wire,
+    messages: spec.messages,
+    channel: spec.channel,
+    ...spec.channelSeparator === void 0 ? {} : { channelSeparator: spec.channelSeparator },
+    ...spec.body === void 0 ? {} : { body: spec.body },
+    unsettledName: spec.unsettledName ?? "reference"
+  };
+  return chainFrom({
+    links: chainStart(spec.client),
+    ending,
+    example: null
+  });
+}
+function chainFrom(declared) {
+  const adding = (link) => chainFrom({ ...declared, links: [...declared.links, link] });
+  return {
+    declared,
+    methods: (table, options) => adding({
+      asks: "methods",
+      table,
+      ignoringCase: options?.ignoringCase ?? false
+    }),
+    example: (code) => chainFrom({ ...declared, example: code })
+  };
+}
+
 // src/pack.ts
 var DISPATCHED_ON = {
   storageAccess: "invocation",
-  sqlAccess: "access"
+  sqlAccess: "access",
+  messageSend: "invocation"
 };
 function walkedBy(chains, walk2, recognizedAs) {
   return chains.filter((chain) => DISPATCHED_ON[chain.ending.yields] === walk2).map((chain) => compile(chain, recognizedAs));
@@ -357,10 +454,17 @@ function pack(name, matches, spec) {
 function declarationsIn(matches) {
   return { declarations: matches.map((match) => describe(match.declared)) };
 }
+function wireOf(ending) {
+  if (ending.yields === "messageSend") {
+    return ending.wire;
+  }
+  return ending.transport ?? ending.system;
+}
+function declaredName(ending) {
+  return ending.yields === "messageSend" ? ending.wire : ending.system;
+}
 function protocolOf(chains) {
-  const wires = new Set(
-    chains.map((chain) => chain.ending.transport ?? chain.ending.system)
-  );
+  const wires = new Set(chains.map((chain) => wireOf(chain.ending)));
   const [only] = [...wires];
   if (wires.size !== 1 || only === void 0) {
     throw new Error(
@@ -410,7 +514,7 @@ function describe(chain) {
     ...rulesIn(chain)
   ];
   return {
-    name: chain.ending.system,
+    name: declaredName(chain.ending),
     // A method table with a rule inside it is still a table, so that
     // link stays counted as data and the rule is priced beside it.
     dataLinks: chain.links.length - links.length,
@@ -461,14 +565,14 @@ function sqlStatements(spec) {
     dialect: spec.dialect
   };
   const client = spec.client;
-  return chainFrom({
-    links: client === void 0 ? [] : [{ asks: "start", at: { starts: "receiver", origin: client } }],
+  return chainFrom2({
+    links: chainStart(client),
     ending,
     example: null
   });
 }
-function chainFrom(declared) {
-  const adding = (link) => chainFrom({ ...declared, links: [...declared.links, link] });
+function chainFrom2(declared) {
+  const adding = (link) => chainFrom2({ ...declared, links: [...declared.links, link] });
   return {
     declared,
     methods: (table, options) => adding({
@@ -477,7 +581,7 @@ function chainFrom(declared) {
       ignoringCase: options?.ignoringCase ?? false
     }),
     interpolating: (says) => adding({ asks: "interpolates", ...says }),
-    example: (code) => chainFrom({ ...declared, example: code })
+    example: (code) => chainFrom2({ ...declared, example: code })
   };
 }
 
@@ -491,14 +595,14 @@ function storageCalls(spec) {
     unsettledName: spec.unsettledName ?? "reference"
   };
   const client = spec.client;
-  return chainFrom2({
-    links: client === void 0 ? [] : [{ asks: "start", at: { starts: "receiver", origin: client } }],
+  return chainFrom3({
+    links: chainStart(client),
     ending,
     example: null
   });
 }
-function chainFrom2(declared) {
-  const adding = (link) => chainFrom2({ ...declared, links: [...declared.links, link] });
+function chainFrom3(declared) {
+  const adding = (link) => chainFrom3({ ...declared, links: [...declared.links, link] });
   return {
     declared,
     about: (...of) => adding({ asks: "subject", of }),
@@ -513,7 +617,7 @@ function chainFrom2(declared) {
     accessPath: (says) => adding({ asks: "accessPath", argument: says }),
     containersIn: (says) => adding({ asks: "containers", in: says }),
     input: (says) => adding({ asks: "input", at: says }),
-    example: (code) => chainFrom2({ ...declared, example: code })
+    example: (code) => chainFrom3({ ...declared, example: code })
   };
 }
 export {
@@ -522,6 +626,7 @@ export {
   declarationsIn,
   declaredBy,
   examplesMissing,
+  messageSends,
   opsIn,
   pack,
   runExamples,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/recognize",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "type": "module",
   "description": "Write a pack as data: a chain of named links that any language adapter with the executor ops can run.",
   "keywords": [
@@ -49,9 +49,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@suss/behavioral-ir": "0.13.1",
-    "@suss/extractor": "0.13.1",
-    "@suss/sql": "0.13.1"
+    "@suss/behavioral-ir": "0.13.2",
+    "@suss/extractor": "0.13.2",
+    "@suss/sql": "0.13.2"
   },
   "devDependencies": {
     "tsup": "*",