@intentius/chant 0.65.0 → 0.66.0

package/dist/behaviour-delta.d.ts

@@ -0,0 +1,181 @@
+/**
+ * The predicted delta between two behaviour results, and how it is shown
+ * (#2358, contract #2356).
+ *
+ * `behaviour.ts` ships the invariant and deliberately not the presentation:
+ * {@link compareFigures} says on which axes two figures fail to be a delta of
+ * like things, and binds every consumer to mark such a pair wherever it is
+ * shown. This module is the consumer. It takes the base side and the head
+ * side of a pull request as two {@link BehaviourResult}s and produces one
+ * finding, under four rules that are the contract's and #2358's rather than
+ * this file's:
+ *
+ *  1. A whole-run refusal on either side is a finding that says **no
+ *     prediction**, with the refusal's own text and remedy. Never a delta and
+ *     never a partial one: the five refusal causes are the engine being
+ *     absent, unreachable, out of credit, over quota, or a credential in the
+ *     request, and none of them is a statement about the estate.
+ *  2. A delta is computed only over entities predicted on **both** sides. An
+ *     entity declined on either side — `unpredicted`, whatever the reason —
+ *     is a row in the finding saying so, not an absent row and not a zero. An
+ *     estate that gained an unmapped kind between the two runs did not gain a
+ *     cost, and a finding that read it as one would be the faked number the
+ *     epic forbids.
+ *  3. Before any two figures are differenced, {@link compareFigures} runs. A
+ *     non-empty mismatch set means the pair is **marked** with every label in
+ *     it, in {@link FIGURE_MISMATCHES}' display order, and no number is
+ *     subtracted. `modeled` minus `validated` is not a change in the estate.
+ *  4. Every figure shown carries its provenance — engine, version, tolerance,
+ *     basis — and a rate is rendered as a rate: so much per hour, at the
+ *     stated traffic level, never an amount.
+ *
+ * Resilience has a fifth rule, from #2360's third comment: a verdict is
+ * computed over the graph the engine was handed, and the declared path hands
+ * over reference edges with no containment. When either side's
+ * `meta.edgeCoverage` is `partial` or `unknown`, the two verdicts were reached
+ * over graphs of different completeness, and the finding shows each side's
+ * verdict and says why they are not compared rather than drawing an arrow
+ * between them.
+ *
+ * Pure: no I/O, no clock, no environment. The Op activity that posts the
+ * result (`./op/activities/predict-behaviour.ts`) is where the sides come
+ * from.
+ */
+import { type BehaviourProvenance, type BehaviourRefusal, type BehaviourReportMeta, type BehaviourResult, type FigureMismatch, type PredictedBehaviour, type PredictedRate, type UnpredictedEntity } from "./behaviour.js";
+/**
+ * Hold a {@link BehaviourResult} to the contract, on arrival.
+ *
+ * `behaviourReport` checks a report as the ordinary route builds it, and its
+ * own doc says plainly that this is a check and not a proof: the report type
+ * is a plain interface, `isBehaviourResult` accepts a hand-built one, and a
+ * lexicon calling the builder with `entityNames: Object.keys(entities)`
+ * self-certifies. A consumer that needs the guarantee runs this instead, with
+ * the names it asked about, and the two consumers that need it are the delta
+ * (each side arrives from a plugin) and a scenario's fixture (the block
+ * arrives from JSON on disk).
+ *
+ * Throws, naming what is wrong. The refusals are the builder's, applied to a
+ * result rather than to its parts: an entity in neither map or in both, a
+ * figure for a name nobody asked about, a block priced at a level the run did
+ * not ask for, an unpredicted reason outside the closed set, an edge-coverage
+ * claim that names no gap, and any block failing `validateBehaviourBlock`. A
+ * refusal arm is held to having a legal cause and a non-empty reason and
+ * remedy, since those two strings are what a consumer prints.
+ */
+export declare function validateBehaviourResult(result: unknown, askedFor: readonly string[]): BehaviourResult;
+/** One side of the delta: the result, and what to call it in the finding. */
+export interface BehaviourDeltaSide {
+    /** `base` or `head`, or whatever the caller calls the two sides. */
+    label: string;
+    /** What the side was predicted from — a branch, a ref, a pull request. Free text. */
+    ref?: string;
+    result: BehaviourResult;
+}
+/** Why a row carries no plain difference. */
+export type BehaviourDeltaRowKind = 
+/** Predicted on both sides and comparable: `deltaPerHour` is a difference in the estate. */
+"comparable"
+/** Predicted on both sides and not a delta of like things: `mismatches` says on which axes. */
+ | "marked"
+/** Declined on one side or both: `baseDeclined`/`headDeclined` say why. */
+ | "declined"
+/** Present on the base side only — removed by the change. */
+ | "only-base"
+/** Present on the head side only — added by the change. */
+ | "only-head";
+/** One entity's row in the finding. */
+export interface BehaviourDeltaRow {
+    name: string;
+    /** Declared entity type, when either side knows it. */
+    type?: string;
+    kind: BehaviourDeltaRowKind;
+    base?: PredictedBehaviour;
+    head?: PredictedBehaviour;
+    baseDeclined?: UnpredictedEntity;
+    headDeclined?: UnpredictedEntity;
+    /** Every axis the pair disagrees on, in display order. Non-empty exactly when `kind` is `marked`. */
+    mismatches?: FigureMismatch[];
+    /** `head.cost.perHour - base.cost.perHour`, present exactly when `kind` is `comparable`. */
+    deltaPerHour?: number;
+    /** The currency both comparable figures share. */
+    currency?: string;
+}
+/** chant's own sum of the comparable rows' deltas, per currency, labelled as such wherever it is shown. */
+export interface ComparableDeltaSum {
+    currency: string;
+    perHour: number;
+    /** How many comparable pairs the sum is over. */
+    pairs: number;
+}
+/** A finding with figures on both sides. */
+export interface BehaviourDeltaReport {
+    kind: "delta";
+    base: {
+        label: string;
+        ref?: string;
+        meta: BehaviourReportMeta;
+    };
+    head: {
+        label: string;
+        ref?: string;
+        meta: BehaviourReportMeta;
+    };
+    /** Every entity either side named, one row each, sorted by name. */
+    rows: BehaviourDeltaRow[];
+    /** The comparable rows' deltas summed by chant, per currency. Empty when no row is comparable. */
+    sums: ComparableDeltaSum[];
+    /**
+     * Whether the two sides' resilience verdicts were reached over graphs of the
+     * same completeness — both `meta.edgeCoverage.verdict === "complete"`. When
+     * false the finding shows each verdict and does not compare them.
+     */
+    resilienceComparable: boolean;
+}
+/** A finding with no figures, because one side or both refused. */
+export interface BehaviourDeltaRefused {
+    kind: "no-prediction";
+    base: {
+        label: string;
+        ref?: string;
+        refusal?: BehaviourRefusal;
+    };
+    head: {
+        label: string;
+        ref?: string;
+        refusal?: BehaviourRefusal;
+    };
+}
+export type BehaviourDelta = BehaviourDeltaReport | BehaviourDeltaRefused;
+/**
+ * Compute the delta. Pure, and never subtracts two figures it has not first
+ * put through {@link compareFigures}.
+ */
+export declare function behaviourDelta(base: BehaviourDeltaSide, head: BehaviourDeltaSide): BehaviourDelta;
+/** What the rendered finding is about — the words in its heading. */
+export interface BehaviourFindingContext {
+    /** The environment the prediction is for. */
+    env: string;
+    /** The Op that produced it, named in the heading so two Ops' findings read apart. */
+    op: string;
+}
+/**
+ * Four significant fractional digits at most, trailing zeros dropped. A rate
+ * of `0.272` renders as `0.272`, of `3` as `3`, and of `0.00230000001` as
+ * `0.0023`. No locale: the finding is the same bytes on every runner.
+ */
+export declare function formatPerHour(n: number): string;
+/** A rate as a rate: `0.272 USD/hour`, never an amount. */
+export declare function renderRate(rate: PredictedRate): string;
+/** `acme-sim 1.4.2 · ±15% · modeled` — the four provenance fields, always together. */
+export declare function renderProvenance(p: BehaviourProvenance): string;
+/**
+ * The finding as Markdown, for a pull-request comment or a merge-request
+ * note. Deterministic for a given delta.
+ *
+ * The first paragraph says what the numbers are, before any of them appear:
+ * a modeled rate for one hypothetical hour, at the level the run was asked
+ * for, from a named engine at a stated tolerance. The paragraph is not
+ * decoration; it is rule 1 of the contract applied to prose.
+ */
+export declare function renderBehaviourFinding(delta: BehaviourDelta, ctx: BehaviourFindingContext): string;
+//# sourceMappingURL=behaviour-delta.d.ts.map

package/dist/behaviour-delta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"behaviour-delta.d.ts","sourceRoot":"","sources":["../src/behaviour-delta.ts"],"names":[],"mappings":"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"}

package/dist/behaviour-http.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The first engine adapter (#2359): a {@link BehaviourTransport} that dials a
+ * URL with a bearer token, and maps what the wire says onto the contract's
+ * refusals.
+ *
+ * Unnamed on purpose. Nothing here is a vendor's API; it is the shape any
+ * metered HTTP engine has — an address, an account, a request body, and four
+ * ways the account or the wire can say no — so a second engine behind the
+ * same shape is a second address and a second token, not a second adapter.
+ * What this file knows about the engine is that it accepts a JSON body by
+ * `POST`, answers with a JSON body, and uses the HTTP status the way HTTP
+ * says to: `402` for an account with nothing left on it, `429` for a limit
+ * that is spent, `401`/`403` for a token it does not accept.
+ *
+ * ## The token is on the wire and nowhere else
+ *
+ * Rule 3 of the contract — the engine is never handed a credential — is about
+ * the request body, and `screenBehaviourRequest` has already walked the body
+ * by the time a transport exists. The bearer token here is a different thing:
+ * it is how the engine knows whose account to bill, it travels in the
+ * `authorization` header, and this module is the only code that holds its
+ * value. Four things follow, and each has a test:
+ *
+ *   - it is resolved from {@link behaviourTokenFrom}'s chain, never from the
+ *     address chain, so no message that prints the address can print it;
+ *   - it is never interpolated into a refusal, a `detail`, or an error — the
+ *     variable's *name* is what a refusal carries;
+ *   - whatever the engine writes back is passed through {@link concealing}
+ *     before it becomes a `detail`, because an engine that echoes its request
+ *     headers into an error page would otherwise put the token in a
+ *     merge-request comment (#2358 posts refusals publicly);
+ *   - the request is sent with `redirect: "error"`, so a `3xx` from the
+ *     address named is a refusal rather than a second request carrying the
+ *     header to whatever host the redirect names.
+ *
+ * ## No token, nothing sent
+ *
+ * This adapter is for an engine that bills an account: `engine-out-of-credit`
+ * and `engine-over-quota` are statements about an account, and an engine
+ * with no account has neither. So a token is required, and a missing one is
+ * refused before anything is sent — {@link noBehaviourTokenRefusal}, naming
+ * the chain — rather than sent bare and reported as whatever the engine's
+ * 401 page said. An engine that needs no token is not this adapter's, and
+ * the address chain still reaches it through a command on `PATH`.
+ *
+ * ## What the wire says, and what it becomes
+ *
+ * | Wire | Cause | Why |
+ * |---|---|---|
+ * | `2xx` | — | the body is the answer; the lexicon validates it |
+ * | `401`, `403` | `no-engine` | the token was rejected; the remedy is to set the variable |
+ * | `402` | `engine-out-of-credit` | the address answered; the account is empty |
+ * | `429` | `engine-over-quota` | the address answered; a limit is spent; `retry-after` is echoed |
+ * | any other status | `engine-unreachable` | the engine did not answer the question — a `5xx`, a `404`, a `3xx` |
+ * | `fetch` threw | `engine-unreachable` | connection refused, no such host, TLS, or the timeout |
+ *
+ * `4xx` outside the three named is deliberately `engine-unreachable` rather
+ * than a fifth cause. The contract's four causes are four remedies, and "the
+ * engine rejected this request as malformed" has no remedy an operator can
+ * apply — it is a bug on one side of the wire or the other, and the detail
+ * names the status so whoever reads it can tell which side.
+ */
+import { type BehaviourEngineEndpoint, type BehaviourEngineToken, type BehaviourRefusalReport, type BehaviourTransport } from "./behaviour.js";
+/** What {@link httpBehaviourTransport} can be handed instead of the process's own. */
+export interface HttpBehaviourTransportDeps {
+    /** The `fetch` to send with. Defaults to the global, and a test hands in a fake. */
+    fetch?: typeof fetch;
+    /** How long the engine has before it is treated as unreachable. */
+    timeoutMs?: number;
+}
+/** The default deadline: the same one augur's command transport gives a child. */
+export declare const HTTP_BEHAVIOUR_TIMEOUT_MS = 30000;
+/** True when an address is one this adapter dials. `grpc://` and friends are not. */
+export declare function isHttpBehaviourAddress(value: string): boolean;
+/**
+ * Every occurrence of the token's value replaced, in text that came from the
+ * engine or from an error. Exported so a test can assert on the one function
+ * every `detail` passes through.
+ *
+ * `split`/`join` rather than a `RegExp`, so a token containing `.` or `+` is
+ * matched as itself. Nothing shorter than four characters is concealed: a
+ * one-letter "token" would blank every occurrence of that letter, which is a
+ * detail nobody can read and a false sense that something was protected.
+ */
+export declare function concealing(token: BehaviourEngineToken, text: string): string;
+/**
+ * The refusal an HTTP status earns, or `undefined` for a status that carries
+ * an answer. Pure and exported so the whole table in the module doc is one
+ * function a test can walk.
+ *
+ * `detail` is the first non-empty line of the response body, already
+ * concealed; this adds the status in front of it so a `detail` never reads as
+ * the engine's prose alone.
+ */
+export declare function httpStatusRefusal(lexicon: string, endpoint: BehaviourEngineEndpoint, token: BehaviourEngineToken, status: number, detail: string, retryAfter?: string): BehaviourRefusalReport | undefined;
+/**
+ * Build the transport for one lexicon against one URL.
+ *
+ * The token is resolved here, once, from `env` — never from `process.env`
+ * unless that is what was passed — so a test can drive the whole wire with an
+ * environment of its own. A missing token makes a transport whose every
+ * `send` refuses by name and sends nothing; see the module doc for why that is
+ * the honest shape for an adapter whose engine bills an account.
+ */
+export declare function httpBehaviourTransport(lexicon: string, endpoint: BehaviourEngineEndpoint, env: Record<string, string | undefined>, deps?: HttpBehaviourTransportDeps): BehaviourTransport;
+//# sourceMappingURL=behaviour-http.d.ts.map

package/dist/behaviour-http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"behaviour-http.d.ts","sourceRoot":"","sources":["../src/behaviour-http.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,OAAO,EAKL,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EAExB,MAAM,aAAa,CAAC;AAGrB,sFAAsF;AACtF,MAAM,WAAW,0BAA0B;IACzC,oFAAoF;IACpF,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,kFAAkF;AAClF,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAKhD,qFAAqF;AACrF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,oBAAoB,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,uBAAuB,EACjC,KAAK,EAAE,oBAAoB,EAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,GAClB,sBAAsB,GAAG,SAAS,CAgCpC;AAQD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,uBAAuB,EACjC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACvC,IAAI,GAAE,0BAA+B,GACpC,kBAAkB,CAoDpB"}

package/dist/behaviour-overlay.d.ts

@@ -0,0 +1,61 @@
+/**
+ * A behaviour result, in the shape the overlay carries it (#2360, epic #2355).
+ *
+ * behold reads a prediction off `chant graph --live --overlay`'s IR and never
+ * calls an engine itself: one block per entity on `attrs._behaviour`, the
+ * channel every other live fact rides on (`_status`, `_release`, `_carve`),
+ * and the graph-level half on `meta._behaviour`. Its reader
+ * (`behold/src/behaviour.ts`, `validateBehaviourMeta`) takes `meta._behaviour`
+ * as `{ engine?, version?, at?, total?, refusal? }` and short-circuits on
+ * `refusal`: a refusal is present *instead of* the engine, and a meta with
+ * neither is dropped as "meta.engine missing".
+ *
+ * That last sentence is the whole reason this module exists. What goes on
+ * `meta._behaviour` for a refusal is the **entire** {@link BehaviourRefusalReport}
+ * — `{ behaviour: "v1", refusal: { cause, reason, remedy, source? } }` — and
+ * not the bare {@link BehaviourRefusal} inside it. A bare refusal has `reason`
+ * and `remedy` at its top level and no `refusal` key, so behold's reader finds
+ * no refusal, then finds no engine, and drops the meta with a diagnostic that
+ * names the wrong thing. The contract doc said the wrong type once
+ * (#2360's second review comment); this is written against the reader.
+ *
+ * For a report, `meta._behaviour` is the report's own `meta`: engine, version,
+ * `at`, an optional `total`, and `edgeCoverage`, which behold's reader ignores
+ * and a consumer that wants to know what a resilience verdict was computed
+ * over reads. Each entity's block goes on its node verbatim — the contract's
+ * {@link PredictedBehaviour} is field for field the block behold validates.
+ *
+ * Pure. Nothing here calls an engine; the result is whatever a lexicon's
+ * `predictBehaviour` returned.
+ */
+import { type BehaviourRefusalReport, type BehaviourReportMeta, type BehaviourResult, type PredictedBehaviour } from "./behaviour.js";
+/** The attribute a behaviour block rides on, on a node and on the graph's meta. */
+export declare const BEHAVIOUR_OVERLAY_ATTR = "_behaviour";
+/** What `meta._behaviour` holds: the report's meta, or the whole refusal report. */
+export type BehaviourOverlayMeta = BehaviourReportMeta | BehaviourRefusalReport;
+/** A behaviour result projected onto the overlay's two channels. */
+export interface BehaviourOverlay {
+    /** Goes on the IR's `meta`, keyed {@link BEHAVIOUR_OVERLAY_ATTR}. */
+    meta: {
+        [BEHAVIOUR_OVERLAY_ATTR]: BehaviourOverlayMeta;
+    };
+    /**
+     * One entry per priced entity, keyed by entity name: what goes on that
+     * node's `attrs`, keyed {@link BEHAVIOUR_OVERLAY_ATTR}. Empty for a refusal,
+     * because a refusal is present instead of every figure, and empty for an
+     * entity that was `unpredicted` — an unpriced node carries no block rather
+     * than a block full of zeroes.
+     */
+    attrs: Record<string, {
+        [BEHAVIOUR_OVERLAY_ATTR]: PredictedBehaviour;
+    }>;
+}
+/**
+ * Project a result onto the overlay's channels.
+ *
+ * A refusal keeps its envelope. behold reads `meta._behaviour.refusal`, and
+ * the envelope is also what makes the value self-describing to anything else
+ * reading the IR: `behaviour: "v1"` says which contract the refusal is in.
+ */
+export declare function behaviourOverlay(result: BehaviourResult): BehaviourOverlay;
+//# sourceMappingURL=behaviour-overlay.d.ts.map

package/dist/behaviour-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"behaviour-overlay.d.ts","sourceRoot":"","sources":["../src/behaviour-overlay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACxB,MAAM,aAAa,CAAC;AAErB,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,eAAe,CAAC;AAEnD,oFAAoF;AACpF,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,GAAG,sBAAsB,CAAC;AAEhF,oEAAoE;AACpE,MAAM,WAAW,gBAAgB;IAC/B,qEAAqE;IACrE,IAAI,EAAE;QAAE,CAAC,sBAAsB,CAAC,EAAE,oBAAoB,CAAA;KAAE,CAAC;IACzD;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,CAAC,sBAAsB,CAAC,EAAE,kBAAkB,CAAA;KAAE,CAAC,CAAC;CACzE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,gBAAgB,CAS1E"}

package/dist/behaviour.d.ts

@@ -142,6 +142,54 @@
  * behold reads those keys and does arithmetic on the engine's figures; it never
  * produces one of its own. Fields beyond what it reads (`cause` and `source` on
  * a refusal, `edgeCoverage` on the meta) are additive and ignorable.
+ *
+ * ## The transport is part of the contract (#2373, decided in #2359)
+ *
+ * The first version of this module named the address chain, said the address
+ * may be a URL, a socket path or a command on `PATH`, and stopped. augur
+ * (#2357) then declared a private `BehaviourEngine` and its own mapping from
+ * what the wire said to which of the three engine-answered refusals to build.
+ * With a second implementation to generalise from, the seam is here:
+ * {@link BehaviourTransport} is one method, `send(body)`, taking the request
+ * as the lexicon rendered it and returning either the engine's answer as text
+ * or a {@link BehaviourRefusalReport} ready to return.
+ *
+ * Two things about that shape are decisions rather than defaults.
+ *
+ *   - **The transport returns text, not a report.** #2373 proposed
+ *     `send(request) → Promise<BehaviourResult>`. A report cannot be built
+ *     without the request's `entityNames`, `traffic` and `edgeCoverage`, and
+ *     what an answer's fields *mean* is the lexicon's wire version, not the
+ *     contract's. A transport that built reports would have to know both, and
+ *     every lexicon would need its own. One that carries bytes is one HTTP
+ *     client and one subprocess spawner for every lexicon there will ever be.
+ *   - **The failure arm is a finished refusal, not a `{cause, detail}` pair.**
+ *     The transport is the one party that saw the wire condition and holds the
+ *     lexicon name and the endpoint, so it is the one party that can name the
+ *     condition, the address and the variable together. Handing back a cause
+ *     for the lexicon to translate would put the same three-way switch in
+ *     every lexicon, and one of them would fold `engine-over-quota` into
+ *     `engine-unreachable` on a bad afternoon. {@link behaviourWireRefusal}
+ *     is that switch, written once.
+ *
+ * What the wire says maps to the causes above as follows, and
+ * `./behaviour-http.ts` (the first adapter) and augur's command transport both
+ * hold to it: an HTTP 402 is `engine-out-of-credit`; a 429 is
+ * `engine-over-quota`; a connection refused, a timeout, a 5xx, a redirect, or
+ * an answer that is not JSON is `engine-unreachable`; an unset address is
+ * `no-engine` before any transport is built; and an unset or rejected bearer
+ * token is `no-engine` too, because its remedy is the same kind — set a
+ * variable — and the reason says which. A transport that spawns a child hands
+ * it {@link behaviourEngineChildEnvironment} and nothing more, for the reason
+ * given on that function.
+ *
+ * A bearer token on the wire is the transport's, and is not the credential
+ * rule 3 is about. "The engine is never handed a credential" is a statement
+ * about the *request body* — the graph — which {@link screenBehaviourRequest}
+ * still walks first. {@link behaviourTokenFrom} resolves the token an engine
+ * authenticates chant with, on a chain parallel to the address chain, and the
+ * token goes in a header the engine reads and nowhere else: never in the body,
+ * never in a refusal, never in a `detail`.
  */
 import type { UnobservedReason } from "./observation.js";
 import type { IREdge } from "./graph-ir.js";
@@ -285,8 +333,10 @@ export interface PredictedBehaviour {
  * `no-credentials` is excluded on purpose: the engine is never handed one, so
  * it can never be missing one. Two reasons are added for the predictor itself:
  *
- * - `no-engine` — no variable in the chain named an engine. Nothing is
- *   configured; this is a setup state, not a failure.
+ * - `no-engine` — no variable in the chain named an engine, or — for a
+ *   transport that authenticates — no variable in the token chain named a
+ *   token the engine accepts. Nothing usable is configured; this is a setup
+ *   state, not a failure, and the reason says which variable.
  * - `engine-unreachable` — a variable named an engine and it did not answer.
  * - `engine-out-of-credit` — the engine answered, and refused because the
  *   account behind it has no balance left (#2359).
@@ -385,7 +435,11 @@ export interface BehaviourRefusal {
     reason: string;
     /** How to fix it. Names the variable and how to set it. */
     remedy: string;
-    /** Which variable in the chain answered, when one did. Absent for `no-engine`. */
+    /**
+     * Which variable answered, when one did: the address variable for a refusal
+     * about the engine, the token variable for a refusal about a rejected
+     * token. Absent when no variable answered at all.
+     */
     source?: string;
 }
 /**
@@ -599,6 +653,65 @@ export declare function behaviourEngineVariables(lexicon: string): string[];
 export declare function behaviourEngineFrom(lexicon: string, env: Record<string, string | undefined>): BehaviourEngineEndpoint | undefined;
 /** What a lexicon says when no variable in the chain names an engine. */
 export declare function noBehaviourEngineMessage(lexicon: string): string;
+/**
+ * The bearer token a transport authenticates chant to an engine with, and the
+ * variable that named it. The counterpart of {@link BehaviourEngineEndpoint}
+ * for the second thing a metered engine needs to know: whose account this is.
+ *
+ * This is **not** the credential rule 3 forbids. That rule is about the
+ * request body, and {@link screenBehaviourRequest} enforces it on every
+ * request before any transport is reached. The token here never enters the
+ * body; it goes in a header the engine reads, and the transport that sends it
+ * is the only code that ever holds it.
+ */
+export interface BehaviourEngineToken {
+    value: string;
+    /** The variable it came from, so a refusal or a log line can name it — never the value. */
+    source: string;
+}
+/**
+ * The variables that can hold a behaviour engine's token, most specific first.
+ * Parallel to {@link behaviourEngineVariables} and deliberately not the same
+ * chain: `CHANT_BEHAVIOUR_ENGINE` is an address, and an address is printed in
+ * refusals, while a token is never printed anywhere. Reusing one chain for
+ * both would put the token in every message that names the address.
+ */
+export declare function behaviourTokenVariables(lexicon: string): string[];
+/**
+ * Resolve the token one lexicon's transport authenticates with, most specific
+ * first. Pure — exported for testing. The same shape as `gitlabNoteTokenFrom`
+ * (`./op/activities/reconcile.ts`): a chain, the first non-empty value wins,
+ * and the result names the variable so a refusal can say which one it read.
+ *
+ * Returns `undefined` when nothing in the chain answered. A transport whose
+ * engine bills an account turns that into {@link noBehaviourTokenRefusal}
+ * before sending anything: a request sent without the token is a request the
+ * engine will reject, and the refusal should name the variable rather than
+ * quote the engine's 401.
+ */
+export declare function behaviourTokenFrom(lexicon: string, env: Record<string, string | undefined>): BehaviourEngineToken | undefined;
+/** What a transport says when the engine bills an account and no variable named a token. */
+export declare function noBehaviourTokenMessage(lexicon: string, endpoint: BehaviourEngineEndpoint): string;
+/**
+ * The refusal for a metered engine with no token configured. `no-engine`,
+ * because that is the cause whose remedy is "set a variable" — the engine is
+ * named, reachable for all anyone knows, and unusable until one more variable
+ * is set. No `source`: the token chain is the chain this refusal is about, and
+ * nothing in it answered.
+ */
+export declare function noBehaviourTokenRefusal(lexicon: string, endpoint: BehaviourEngineEndpoint): BehaviourRefusalReport;
+/**
+ * The refusal for an engine that answered and rejected the token it was sent.
+ * Also `no-engine`: the address is fine, the account is not the problem, and
+ * the one action is to set the named variable to a token the engine accepts.
+ * `source` is the token variable, not the address variable, because that is
+ * the one a consumer would tell somebody to change.
+ *
+ * `detail` is whatever the engine said, and it goes through
+ * {@link scrubEngineDetail}. The token's own value is never in a message: a
+ * transport passes the variable's name here and keeps the value to itself.
+ */
+export declare function rejectedBehaviourTokenRefusal(lexicon: string, endpoint: BehaviourEngineEndpoint, token: BehaviourEngineToken, detail: string): BehaviourRefusalReport;
 /** What a lexicon says when a variable named an engine and the engine did not answer. */
 export declare function unreachableBehaviourEngineMessage(lexicon: string, endpoint: BehaviourEngineEndpoint, detail: string): string;
 /**
@@ -621,6 +734,68 @@ export declare function overQuotaBehaviourEngineMessage(lexicon: string, endpoin
 export declare function outOfCreditBehaviourEngineRefusal(lexicon: string, endpoint: BehaviourEngineEndpoint, detail: string): BehaviourRefusalReport;
 /** The refusal for an engine that answered and said a limit is spent (#2359). */
 export declare function overQuotaBehaviourEngineRefusal(lexicon: string, endpoint: BehaviourEngineEndpoint, detail: string): BehaviourRefusalReport;
+/**
+ * What a transport brings back: the engine's answer as the text it wrote, or a
+ * refusal ready to be returned from `predictBehaviour` as it stands.
+ *
+ * The answer is text rather than a parsed object because what the text means
+ * is the lexicon's wire version (`augur/v1`), and the lexicon is the one that
+ * validates it — an answer that fails that validation is
+ * {@link unreachableBehaviourEngineRefusal} with a detail naming the field,
+ * built by the lexicon, since the transport has nothing to say about it.
+ */
+export type BehaviourTransportOutcome = {
+    ok: true;
+    body: string;
+} | {
+    ok: false;
+    refusal: BehaviourRefusalReport;
+};
+/**
+ * The seam between a lexicon and whatever answers its request (#2373).
+ *
+ * One method. `body` is the request as the lexicon rendered it — augur's
+ * canonical JSON, say — and the transport carries it to the address it was
+ * built for and brings back what came out, or a refusal naming why nothing
+ * did. A transport is built knowing the lexicon and the endpoint, which is
+ * what lets it build the refusal itself; see the module doc for why that is
+ * better than returning a cause.
+ *
+ * Two ship today: `./behaviour-http.ts` dials a URL with a bearer token, and
+ * augur's `commandTransport` spawns a command on `PATH` with
+ * {@link behaviourEngineChildEnvironment}. A lexicon picks one by the shape of
+ * the address and does not otherwise know which it got.
+ */
+export interface BehaviourTransport {
+    send(body: string): Promise<BehaviourTransportOutcome>;
+}
+/**
+ * The three things a wire can say that are the engine's to answer for, and
+ * that each want a different refusal. `no-engine` is not here: it is decided
+ * before a transport exists (an unset address) or by the transport's own
+ * constructor (an unset token), never by the wire.
+ */
+export type BehaviourWireCause = "engine-unreachable" | "engine-out-of-credit" | "engine-over-quota";
+/**
+ * One wire cause onto the refusal builder that names it. The whole of the
+ * mapping every transport applies, so it is written once: a transport that
+ * classified the wire correctly and then reached for the wrong builder would
+ * send an operator to check a network that is answering.
+ */
+export declare function behaviourWireRefusal(lexicon: string, endpoint: BehaviourEngineEndpoint, cause: BehaviourWireCause, detail: string): BehaviourRefusalReport;
+/**
+ * The environment a transport hands a child process: `PATH`, and nothing else.
+ *
+ * Rule 3 says the engine never sees a credential, and
+ * {@link screenBehaviourRequest} enforces it on the request. A child that
+ * inherits `process.env` walks straight around that: the request is spotless
+ * and the child holds `AWS_SECRET_ACCESS_KEY` anyway. So a transport that
+ * spawns builds the environment from this and nothing more — `PATH` because
+ * the address is resolved against it, and no allowlist beyond that, because
+ * every name added is a name a credential could be sitting under. augur's
+ * command transport pins this by test (#2372); this is the rule it pins.
+ */
+export declare function behaviourEngineChildEnvironment(env?: Record<string, string | undefined>): Record<string, string>;
 /**
  * Render a refusal for a terminal, in red.
  *

package/dist/behaviour.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"behaviour.d.ts","sourceRoot":"","sources":["../src/behaviour.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"behaviour.d.ts","sourceRoot":"","sources":["../src/behaviour.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgMG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAShD;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,WAAW,CAAC;AAqBrD,eAAO,MAAM,eAAe,EAAE,SAAS,cAAc,EAEhC,CAAC;AAEtB,2DAA2D;AAC3D,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAExE;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,KAAK,EAAE,cAAc,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,yFAAyF;IACzF,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qGAAqG;AACrG,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,CAE9E;AAED;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GACzB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtC,kEAAkE;AAClE,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC;AAQlE,oFAAoF;AACpF,eAAO,MAAM,mBAAmB,EAAE,SAAS,iBAAiB,EAEpC,CAAC;AAEzB,8DAA8D;AAC9D,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,iBAAiB,CAE9E;AAED,oFAAoF;AACpF,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,2EAA2E;IAC3E,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,+EAA+E;AAC/E,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,mDAAmD;IACnD,EAAE,EAAE,qBAAqB,CAAC;IAC1B,6BAA6B;IAC7B,IAAI,EAAE,aAAa,CAAC;IACpB,+FAA+F;IAC/F,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,UAAU,EAAE,mBAAmB,CAAC;IAChC,oDAAoD;IACpD,SAAS,CAAC,EAAE,kBAAkB,CAAC;IAC/B,kEAAkE;IAClE,UAAU,EAAE,mBAAmB,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,MAAM,0BAA0B,GAClC,OAAO,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,GAC3C,WAAW,GACX,oBAAoB,GACpB,sBAAsB,GACtB,mBAAmB,GACnB,uBAAuB,CAAC;AAyB5B,6FAA6F;AAC7F,eAAO,MAAM,6BAA6B,EAAE,SAAS,0BAA0B,EAE9C,CAAC;AAElC,uEAAuE;AACvE,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,0BAA0B,CAKrC;AAED,2DAA2D;AAC3D,MAAM,WAAW,iBAAiB;IAChC,kGAAkG;IAClG,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qBAAqB;IACrB,MAAM,EAAE,0BAA0B,CAAC;IACnC,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,EAAE,EAAE,qBAAqB,CAAC;IAC1B;;;;OAIG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB;;;;;;;;;;;;;OAaG;IACH,YAAY,EAAE,qBAAqB,CAAC;CACrC;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,mCAAmC;IACnC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,+CAA+C;IAC/C,IAAI,EAAE,mBAAmB,CAAC;IAC1B,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC7C;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;CACjD;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iCAAiC;IACjC,KAAK,EAAE,0BAA0B,CAAC;IAClC,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,sBAAsB;IACrC,wEAAwE;IACxE,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,2EAA2E;IAC3E,OAAO,EAAE,gBAAgB,CAAC;CAC3B;AAED,iGAAiG;AACjG,MAAM,MAAM,eAAe,GAAG,eAAe,GAAG,sBAAsB,CAAC;AAEvE,4DAA4D;AAC5D,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,eAAe,GACrB,KAAK,IAAI,sBAAsB,CAEjC;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAQ1E;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI,CA6DpF;AAED,0GAA0G;AAC1G,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,IAAI,CAAC,uBAAuB,EAAE,aAAa,GAAG,SAAS,GAAG,cAAc,CAAC,EAClF,KAAK,EAAE,oBAAoB,EAC3B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC5C,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAC9C,eAAe,CA6EjB;AAED,8CAA8C;AAC9C,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,GAAG,sBAAsB,CAElF;AAMD;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,uBAAuB,GAAG,YAAY,GAAG,aAAa,GAAG,cAAc,CAAC;AAEpF;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,mBAAmB,EACtB,CAAC,EAAE,mBAAmB,GACrB,uBAAuB,CAKzB;AAED,uEAAuE;AACvE,MAAM,MAAM,cAAc,GACtB,cAAc,GACd,aAAa,GACb,aAAa,GACb,gBAAgB,GAChB,eAAe,CAAC;AAuBpB;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,cAAc,EAEkB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,kBAAkB,EACrB,CAAC,EAAE,kBAAkB,GACpB,WAAW,CAAC,cAAc,CAAC,CAQ7B;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,kBAAkB,EAAE,CAAC,EAAE,kBAAkB,GAAG,cAAc,EAAE,CAG/F;AAED,oFAAoF;AACpF,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,kBAAkB,EAAE,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAExF;AAED,iHAAiH;AACjH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAE9F;AAMD;;;;;;;;GAQG;AACH,MAAM,WAAW,uBAAuB;IACtC,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAGlE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GACtC,uBAAuB,GAAG,SAAS,CAMrC;AAED,yEAAyE;AACzE,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAShE;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,2FAA2F;IAC3F,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAGjE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GACtC,oBAAoB,GAAG,SAAS,CAMlC;AAED,4FAA4F;AAC5F,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,uBAAuB,GAAG,MAAM,CAUlG;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,uBAAuB,GAChC,sBAAsB,CAOxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,uBAAuB,EACjC,KAAK,EAAE,oBAAoB,EAC3B,MAAM,EAAE,MAAM,GACb,sBAAsB,CAWxB;AAED,yFAAyF;AACzF,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,uBAAuB,EACjC,MAAM,EAAE,MAAM,GACb,MAAM,CAOR;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,sBAAsB,CAOhF;AAED,+DAA+D;AAC/D,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,uBAAuB,EACjC,MAAM,EAAE,MAAM,GACb,sBAAsB,CAOxB;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,uBAAuB,EACjC,MAAM,EAAE,MAAM,GACb,MAAM,CAQR;AAED,0FAA0F;AAC1F,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,uBAAuB,EACjC,MAAM,EAAE,MAAM,GACb,MAAM,CAQR;AAED,2FAA2F;AAC3F,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,uBAAuB,EACjC,MAAM,EAAE,MAAM,GACb,sBAAsB,CAOxB;AAED,iFAAiF;AACjF,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,uBAAuB,EACjC,MAAM,EAAE,MAAM,GACb,sBAAsB,CAOxB;AAMD;;;;;;;;;GASG;AACH,MAAM,MAAM,yBAAyB,GACjC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC1B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,sBAAsB,CAAA;CAAE,CAAC;AAEnD;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAAC;CACxD;AAED;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,GAAG,sBAAsB,GAAG,mBAAmB,CAAC;AAErG;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,uBAAuB,EACjC,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,MAAM,GACb,sBAAsB,CASxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAC7C,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAExB;AASD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAChC,MAAM,CAIR;AAMD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAenD,CAAC;AA8MF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,MAAM,CAER;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,MAAM,CAUR;AAKD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;AAQrE,+CAA+C;AAC/C,eAAO,MAAM,sBAAsB,EAAE,SAAS,mBAAmB,EAEvC,CAAC;AAE3B,gEAAgE;AAChE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAElF;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,mBAAmB,CAAC;IAC7B;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAClC;;;;OAIG;IACH,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED;;;;;;;GAOG;AACH;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,qBAAqB,CAUvF;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,IAAI,CAkB1E;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IAC9E,+FAA+F;IAC/F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2GAA2G;IAC3G,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mGAAmG;IACnG,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;;;;;OAQG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB;;;;;;;;;;;;;;;OAeG;IACH,YAAY,EAAE,qBAAqB,CAAC;IAEpC,yDAAyD;IACzD,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,qBAAqB;IACrB,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB,qBAAqB;IACrB,WAAW,CAAC,EAAE,KAAK,CAAC;IACpB,qBAAqB;IACrB,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,qBAAqB;IACrB,OAAO,CAAC,EAAE,KAAK,CAAC;IAChB,qBAAqB;IACrB,QAAQ,CAAC,EAAE,KAAK,CAAC;IACjB,qBAAqB;IACrB,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,qBAAqB;IACrB,SAAS,CAAC,EAAE,KAAK,CAAC;IAClB,qBAAqB;IACrB,SAAS,CAAC,EAAE,KAAK,CAAC;IAClB,qBAAqB;IACrB,YAAY,CAAC,EAAE,KAAK,CAAC;IACrB,qBAAqB;IACrB,IAAI,CAAC,EAAE,KAAK,CAAC;IACb,qBAAqB;IACrB,aAAa,CAAC,EAAE,KAAK,CAAC;IACtB,qBAAqB;IACrB,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,qBAAqB;IACrB,UAAU,CAAC,EAAE,KAAK,CAAC;CACpB;AAgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,UAAU,GAAG,YAAY,CAAC;AAEvE,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,uFAAuF;IACvF,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,cAAc,CAAC;IACrB,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAoE7E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAUjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,sBAAsB,GAAG,SAAS,CAgBpC"}

package/dist/cli/handlers/scenario.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scenario.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/scenario.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAwE3E;AA6LD,0FAA0F;AAC1F,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAM7E"}
+{"version":3,"file":"scenario.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/scenario.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAwE3E;AA2OD,0FAA0F;AAC1F,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAM7E"}

package/dist/index.d.ts

@@ -58,6 +58,8 @@ export * from "./identity.js";
 export * from "./apply.js";
 export * from "./deep-observation.js";
 export * from "./behaviour.js";
+export * from "./behaviour-http.js";
+export * from "./behaviour-delta.js";
 export * from "./claimed-fields.js";
 export * from "./fold-provenance.js";
 export * from "./owner-chain.js";