metered-protocol 1.0.0

package/dist/src/http/client.js.map

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

package/dist/src/http/harness.d.ts

@@ -0,0 +1,18 @@
+/**
+ * One metered server, started and stopped around a test.
+ *
+ * Shared rather than copied. Two files needed the same three lines -- start a service, listen on
+ * an ephemeral port, close it afterwards -- and a copy of a fixture drifts exactly as readily as
+ * a copy of anything else: the moment one file's terms change and the other's do not, two tests
+ * claiming to exercise "the server" are exercising different servers.
+ */
+import type { Server } from 'node:http';
+import { MeteredService, type ServiceOptions } from './service.js';
+export interface Harness {
+    base: string;
+    service: MeteredService;
+    server: Server;
+}
+/** Start a server around `opts`, run `body`, and close it however `body` ends. */
+export declare function withMeteredServer(opts: ServiceOptions, body: (h: Harness) => Promise<void>): Promise<void>;
+//# sourceMappingURL=harness.d.ts.map

package/dist/src/http/harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../../../src/http/harness.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGxC,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnE,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,cAAc,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,kFAAkF;AAClF,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAClC,OAAO,CAAC,IAAI,CAAC,CAUf"}

package/dist/src/http/harness.js

@@ -0,0 +1,16 @@
+import { serveMetered } from './serve.js';
+import { MeteredService } from './service.js';
+/** Start a server around `opts`, run `body`, and close it however `body` ends. */
+export async function withMeteredServer(opts, body) {
+    const service = new MeteredService(opts);
+    const server = serveMetered({ service });
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const base = `http://127.0.0.1:${server.address().port}`;
+    try {
+        await body({ base, service, server });
+    }
+    finally {
+        await new Promise((resolve) => server.close(() => resolve()));
+    }
+}
+//# sourceMappingURL=harness.js.map

package/dist/src/http/harness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.js","sourceRoot":"","sources":["../../../src/http/harness.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAuB,MAAM,cAAc,CAAC;AAQnE,kFAAkF;AAClF,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,IAAoB,EACpB,IAAmC;IAEnC,MAAM,OAAO,GAAG,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC;IACzC,MAAM,MAAM,GAAG,YAAY,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IACzC,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7E,MAAM,IAAI,GAAG,oBAAqB,MAAM,CAAC,OAAO,EAAkB,CAAC,IAAI,EAAE,CAAC;IAC1E,IAAI,CAAC;QACH,MAAM,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IACxC,CAAC;YAAS,CAAC;QACT,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACtE,CAAC;AACH,CAAC"}

package/dist/src/http/protocol.d.ts

@@ -0,0 +1,84 @@
+/**
+ * `metered` as an x402 scheme over HTTP.
+ *
+ * x402 ships `exact` and `upto`, and the `upto` specification lists multi-settlement, streaming
+ * and pay-per-chunk as out of scope. This is the transport for the scheme that fills that gap, so
+ * it deliberately follows x402's v2 envelope rather than inventing one: an unpaid request gets a
+ * 402 whose body carries `x402Version`, a `resource` block and an `accepts` array. A client that
+ * already speaks x402 can read the shape even if it does not know this scheme, and will see
+ * `scheme: "metered"` and decline rather than misread it.
+ *
+ * A CHUNK IS TWO ROUND TRIPS, and that is not an accident of design. The buyer cannot measure
+ * content it has not received, so it cannot sign a Measurement in the same request that asks for
+ * the chunk. Collapsing them would mean the buyer signing a count it took on trust, which is
+ * exactly the one-sidedness SPEC.md 0 exists to remove.
+ *
+ *   POST /metered/open    -> 402 + Offer, or 200 once the covenant is funded
+ *   POST /metered/babel   -> content + the PROVIDER's Measurement
+ *   POST /metered/state   -> reconciles both Measurements, returns the State + provider signature
+ */
+import type { Measurement, Offer, Reservation, State } from '../types.js';
+export declare const X402_VERSION = 2;
+/** The x402 v2 body an unpaid request gets back. */
+export interface PaymentRequiredBody {
+    x402Version: number;
+    error: string;
+    resource: {
+        url: string;
+        description?: string;
+        mimeType?: string;
+    };
+    accepts: Offer[];
+}
+export declare function toPaymentRequired(offer: Offer, resource: string, error: string): PaymentRequiredBody;
+/** `POST /metered/babel` -- the buyer authorises exactly one chunk and asks for it. */
+export interface ChunkRequest {
+    reservation: Reservation;
+    prompt: string;
+}
+/**
+ * What comes back. `contentB64` is the delivered bytes; `measurement` is the PROVIDER's count of
+ * them. The buyer counts the same bytes itself and does not have to believe this.
+ *
+ * BASE64 IS TRANSIT ONLY, and the field is named so that nothing can forget it. JSON has no way
+ * to carry arbitrary bytes, so they are encoded to cross the wire and decoded on arrival -- but
+ * the digest and the unit count are taken over the DECODED bytes at both ends. Metering the
+ * encoded form would bill the buyer for roughly a third more than it asked for, and would agree
+ * a digest over the encoding rather than over the content.
+ */
+export interface BabelResponse {
+    contentB64: string;
+    measurement: Measurement;
+}
+/** Bytes -> the wire. */
+export declare const toBase64: (bytes: Uint8Array) => string;
+/**
+ * The wire -> bytes.
+ *
+ * Node's base64 decoder is LENIENT: it discards anything outside the alphabet rather than
+ * refusing, so a corrupted field decodes to plausible-looking bytes instead of an error. That is
+ * survivable here only because it cannot be silent -- different bytes produce a different digest,
+ * and SPEC.md 5 rule 3 halts the session on a digest mismatch before any count is consulted.
+ */
+export declare const fromBase64: (b64: string) => Uint8Array;
+/** `POST /metered/state` -- the buyer's count, after it has seen the content. */
+export interface StateRequest {
+    measurement: Measurement;
+}
+/**
+ * The reconciled State and the provider's signature over it. The buyer verifies and countersigns;
+ * a State with one signature is not a State (SPEC.md 3.4).
+ */
+export interface StateResponse {
+    state: State;
+    providerSig: string;
+    billedUnits: number;
+}
+/** Every failure this transport can report, as an x402-shaped error body. */
+export interface ErrorBody {
+    x402Version: number;
+    error: string;
+    reason?: string | undefined;
+}
+export declare const errorBody: (error: string, reason?: string) => ErrorBody;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/src/http/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../src/http/protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAE1E,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,oDAAoD;AACpD,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnE,OAAO,EAAE,KAAK,EAAE,CAAC;CAClB;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,mBAAmB,CAOpG;AAED,uFAAuF;AACvF,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,WAAW,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,yBAAyB;AACzB,eAAO,MAAM,QAAQ,GAAI,OAAO,UAAU,KAAG,MAA+C,CAAC;AAE7F;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,UAAwD,CAAC;AAElG,iFAAiF;AACjF,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,KAAK,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,6EAA6E;AAC7E,MAAM,WAAW,SAAS;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B;AAED,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,EAAE,SAAS,MAAM,KAAG,SACX,CAAC"}

package/dist/src/http/protocol.js

@@ -0,0 +1,22 @@
+export const X402_VERSION = 2;
+export function toPaymentRequired(offer, resource, error) {
+    return {
+        x402Version: X402_VERSION,
+        error,
+        resource: { url: resource, description: `metered session, ${offer.babelUnits} ${offer.unit} per chunk` },
+        accepts: [offer],
+    };
+}
+/** Bytes -> the wire. */
+export const toBase64 = (bytes) => Buffer.from(bytes).toString('base64');
+/**
+ * The wire -> bytes.
+ *
+ * Node's base64 decoder is LENIENT: it discards anything outside the alphabet rather than
+ * refusing, so a corrupted field decodes to plausible-looking bytes instead of an error. That is
+ * survivable here only because it cannot be silent -- different bytes produce a different digest,
+ * and SPEC.md 5 rule 3 halts the session on a digest mismatch before any count is consulted.
+ */
+export const fromBase64 = (b64) => new Uint8Array(Buffer.from(b64, 'base64'));
+export const errorBody = (error, reason) => ({ x402Version: X402_VERSION, error, reason });
+//# sourceMappingURL=protocol.js.map

package/dist/src/http/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../../src/http/protocol.ts"],"names":[],"mappings":"AAqBA,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC;AAU9B,MAAM,UAAU,iBAAiB,CAAC,KAAY,EAAE,QAAgB,EAAE,KAAa;IAC7E,OAAO;QACL,WAAW,EAAE,YAAY;QACzB,KAAK;QACL,QAAQ,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,WAAW,EAAE,oBAAoB,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,IAAI,YAAY,EAAE;QACxG,OAAO,EAAE,CAAC,KAAK,CAAC;KACjB,CAAC;AACJ,CAAC;AAuBD,yBAAyB;AACzB,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAiB,EAAU,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;AAE7F;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,GAAW,EAAc,EAAE,CAAC,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC;AAwBlG,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAa,EAAE,MAAe,EAAa,EAAE,CACrE,CAAC,EAAE,WAAW,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC"}

package/dist/src/http/provider.d.ts

@@ -0,0 +1,123 @@
+import { type SignerStore } from '../signer.js';
+import type { Checkpointer } from '../checkpoint.js';
+import { type BabelCursor } from '../reservation.js';
+import { type BiasState } from '../bias.js';
+import type { Halt, Measurement, Offer, Reservation, State } from '../types.js';
+/** Counts the units in delivered content. Injected, because SPEC.md 6 makes it the Offer's choice. */
+export type Meter = (content: Uint8Array) => number;
+/**
+ * Produces the content for a chunk. This is the thing actually being sold.
+ *
+ * BYTES, NOT TEXT. Everything the protocol does to delivered content -- digest it, count it,
+ * agree on it -- is defined over bytes, and this signature used to say `string`, which quietly
+ * restricted the whole scheme to things expressible as text. A file is not, so a unit called
+ * `net.bytes_delivered.v1` could be declared and never actually served.
+ */
+export type Deliver = (prompt: string, maxUnits: number) => Uint8Array;
+export declare class SessionRejected extends Error {
+    readonly halt?: Halt | undefined;
+    constructor(halt?: Halt | undefined);
+}
+interface Pending {
+    seq: number;
+    content: Uint8Array;
+    units: number;
+    contentDigest: string;
+}
+/**
+ * Everything a session needs to be rebuilt after a restart.
+ *
+ * NOTE WHAT IS ABSENT: the delivered CONTENT. `settle` works from the babel's digest, its unit
+ * count and its seq, and never reads the text again -- so a provider that persists sessions is
+ * not thereby keeping a copy of everything it has ever said to anyone. That is a property of the
+ * protocol rather than a precaution taken here: the digest is what the parties agreed about.
+ */
+export interface SessionSnapshot {
+    offer: Offer;
+    cursor: BabelCursor | null;
+    pending: Omit<Pending, 'content'> | null;
+    lastStateDigest: string | null;
+    bias: BiasState;
+    settled: [string, {
+        state: State;
+        providerSig: string;
+        billedUnits: number;
+    }][];
+}
+export declare class ProviderSession {
+    readonly offer: Offer;
+    private readonly providerSk;
+    private readonly meter;
+    private readonly deliver;
+    /** SPEC.md 8. Optional: a session with `checkpointEvery: 0` anchors nothing. */
+    private readonly checkpointer?;
+    /**
+     * SPEC.md 4. Defaults to a store that forgets on restart, which is fine for a test and is
+     * NOT fine for a provider holding money: 4.4's restart rule is only as good as the store.
+     * src/store.ts has one that survives a power cut.
+     */
+    private readonly store;
+    private cursor;
+    private bias;
+    private pending;
+    private lastStateDigest;
+    private lastState;
+    /**
+     * Settled results by the buyer's `measurementId`, so SPEC.md 3.3's idempotency rule holds.
+     * Bounded by `maxBabels`, which the Offer fixes, so it cannot grow without limit.
+     */
+    private readonly settled;
+    constructor(offer: Offer, providerSk: string, meter: Meter, deliver: Deliver, 
+    /** SPEC.md 8. Optional: a session with `checkpointEvery: 0` anchors nothing. */
+    checkpointer?: Checkpointer | undefined, 
+    /**
+     * SPEC.md 4. Defaults to a store that forgets on restart, which is fine for a test and is
+     * NOT fine for a provider holding money: 4.4's restart rule is only as good as the store.
+     * src/store.ts has one that survives a power cut.
+     */
+    store?: SignerStore);
+    /** State that must outlive the process. See SessionSnapshot. */
+    snapshot(): SessionSnapshot;
+    /** Rebuild a session from a snapshot. The counterparty cannot tell this from a long-lived one. */
+    static restore(snap: SessionSnapshot, providerSk: string, meter: Meter, deliver: Deliver, checkpointer?: Checkpointer, store?: SignerStore): ProviderSession;
+    get pendingSeq(): number;
+    /**
+     * Accept a Reservation and deliver one chunk, with the provider's own count of it.
+     *
+     * The Reservation is checked BEFORE anything is delivered -- units above `babelUnits`, a seq
+     * that does not advance by exactly one, or totals that do not recompute all mean the buyer has
+     * not authorised what it is asking for, and delivering first would be giving work away.
+     */
+    chunk(reservation: Reservation, prompt: string): {
+        content: Uint8Array;
+        measurement: Measurement;
+    };
+    /**
+     * Reconcile the buyer's count against the provider's and produce the State to be countersigned.
+     *
+     * The residual is fed to the bias detector BEFORE the State is signed, so a chunk that trips the
+     * alarm is never settled -- signing first and halting after would hand the buyer a State it
+     * could close on (SPEC.md 5.1.1).
+     */
+    settle(buyerMeasurement: Measurement): {
+        state: State;
+        providerSig: string;
+        billedUnits: number;
+    };
+    /**
+     * Record the digest of a State once both parties have signed it, so the chain can continue --
+     * and checkpoint it if this chunk calls for one.
+     *
+     * THE CHECKPOINT HAPPENS HERE, not in `settle`, and the difference is the whole point of a
+     * checkpoint. SPEC.md 8 anchors `digest(State)` as EVIDENCE that a State existed before a given
+     * block. A State with one signature is not a State (SPEC.md 3.4), so anchoring at `settle` would
+     * be publishing a claim the buyer had not yet agreed to -- evidence of nothing.
+     *
+     * It does not await. SPEC.md 8 requires checkpointing to be NON-BLOCKING because Study B
+     * measured p90 confirmation at 1,879 ms, and a session that stalled two seconds every few chunks
+     * would be unusable for a streamed response.
+     */
+    chainTo(digest: string): void;
+}
+export {};
+//# sourceMappingURL=provider.d.ts.map

package/dist/src/http/provider.d.ts.map

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

package/dist/src/http/provider.js

@@ -0,0 +1,197 @@
+/**
+ * The provider's half of a metered session, as a transport-agnostic state machine.
+ *
+ * No HTTP in here on purpose. The rules are the interesting part and they are testable without a
+ * socket; `serve.ts` is the thin layer that maps them onto requests. That split is the same one
+ * the rest of this project uses -- the part with rules is tested against fixtures, the part with
+ * I/O is proven live.
+ *
+ * WHAT THE PROVIDER IS TRUSTED FOR: nothing (SPEC.md 1). It counts its own delivery and says so,
+ * and the buyer's count is an equal input to what settles. This class never sees the buyer's key
+ * and cannot produce a State on its own.
+ */
+import { blake3Hex, signEnvelope } from '../encoding.js';
+import { signStateWithObligations, memoryStore } from '../signer.js';
+import { acceptReservation } from '../reservation.js';
+import { reconcileBabel } from '../reconcile.js';
+import { newBiasState, observeResidual, biasAlarm } from '../bias.js';
+/** The stand-in for content a restored session deliberately no longer holds. */
+const EMPTY = new Uint8Array(0);
+export class SessionRejected extends Error {
+    halt;
+    constructor(halt) {
+        super(halt ? `${halt.reason}: ${halt.detail}` : 'session rejected');
+        this.halt = halt;
+    }
+}
+export class ProviderSession {
+    offer;
+    providerSk;
+    meter;
+    deliver;
+    checkpointer;
+    store;
+    cursor = null;
+    bias = newBiasState();
+    pending = null;
+    lastStateDigest = null;
+    lastState = null;
+    /**
+     * Settled results by the buyer's `measurementId`, so SPEC.md 3.3's idempotency rule holds.
+     * Bounded by `maxBabels`, which the Offer fixes, so it cannot grow without limit.
+     */
+    settled = new Map();
+    constructor(offer, providerSk, meter, deliver, 
+    /** SPEC.md 8. Optional: a session with `checkpointEvery: 0` anchors nothing. */
+    checkpointer, 
+    /**
+     * SPEC.md 4. Defaults to a store that forgets on restart, which is fine for a test and is
+     * NOT fine for a provider holding money: 4.4's restart rule is only as good as the store.
+     * src/store.ts has one that survives a power cut.
+     */
+    store = memoryStore()) {
+        this.offer = offer;
+        this.providerSk = providerSk;
+        this.meter = meter;
+        this.deliver = deliver;
+        this.checkpointer = checkpointer;
+        this.store = store;
+    }
+    /** State that must outlive the process. See SessionSnapshot. */
+    snapshot() {
+        const { content, ...pending } = this.pending ?? { content: EMPTY, seq: -1, units: 0, contentDigest: '' };
+        void content;
+        return {
+            offer: this.offer,
+            cursor: this.cursor,
+            pending: this.pending ? pending : null,
+            lastStateDigest: this.lastStateDigest,
+            bias: this.bias,
+            settled: [...this.settled.entries()],
+        };
+    }
+    /** Rebuild a session from a snapshot. The counterparty cannot tell this from a long-lived one. */
+    static restore(snap, providerSk, meter, deliver, checkpointer, store) {
+        const session = new ProviderSession(snap.offer, providerSk, meter, deliver, checkpointer, store);
+        session.cursor = snap.cursor;
+        session.lastStateDigest = snap.lastStateDigest;
+        session.bias = snap.bias;
+        session.pending = snap.pending ? { ...snap.pending, content: EMPTY } : null;
+        for (const [id, result] of snap.settled)
+            session.settled.set(id, result);
+        return session;
+    }
+    get pendingSeq() {
+        return this.cursor?.seq ?? -1;
+    }
+    /**
+     * Accept a Reservation and deliver one chunk, with the provider's own count of it.
+     *
+     * The Reservation is checked BEFORE anything is delivered -- units above `babelUnits`, a seq
+     * that does not advance by exactly one, or totals that do not recompute all mean the buyer has
+     * not authorised what it is asking for, and delivering first would be giving work away.
+     */
+    chunk(reservation, prompt) {
+        acceptReservation(this.offer, reservation, this.cursor);
+        const content = this.deliver(prompt, reservation.units);
+        const units = this.meter(content);
+        const contentDigest = blake3Hex(content);
+        this.pending = { seq: reservation.seq, content, units, contentDigest };
+        const measurement = {
+            v: 1,
+            sessionId: this.offer.sessionId,
+            seq: reservation.seq,
+            by: 'provider',
+            units,
+            cumulativeUnits: (this.cursor?.cumulativeUnits ?? 0) + units,
+            contentDigest,
+            measurementId: blake3Hex(`${this.offer.sessionId}/${reservation.seq}/provider`).slice(0, 32),
+        };
+        return { content, measurement: signEnvelope(measurement, this.providerSk) };
+    }
+    /**
+     * Reconcile the buyer's count against the provider's and produce the State to be countersigned.
+     *
+     * The residual is fed to the bias detector BEFORE the State is signed, so a chunk that trips the
+     * alarm is never settled -- signing first and halting after would hand the buyer a State it
+     * could close on (SPEC.md 5.1.1).
+     */
+    settle(buyerMeasurement) {
+        // SPEC.md 3.3: `measurementId` is an idempotency key, and "a retransmission MUST be a no-op".
+        // Without this a client that times out and retries -- which is ordinary HTTP behaviour, not
+        // an attack -- finds `pending` already consumed, gets a SessionRejected, and kills its own
+        // session. The settled result is returned again instead, unchanged.
+        const replay = this.settled.get(buyerMeasurement.measurementId);
+        if (replay)
+            return replay;
+        const pending = this.pending;
+        if (!pending)
+            throw new SessionRejected();
+        const providerMeasurement = {
+            v: 1,
+            sessionId: this.offer.sessionId,
+            seq: pending.seq,
+            by: 'provider',
+            units: pending.units,
+            cumulativeUnits: (this.cursor?.cumulativeUnits ?? 0) + pending.units,
+            contentDigest: pending.contentDigest,
+            measurementId: blake3Hex(`${this.offer.sessionId}/${pending.seq}/provider`).slice(0, 32),
+        };
+        const signedProvider = signEnvelope(providerMeasurement, this.providerSk);
+        const outcome = reconcileBabel(this.offer, buyerMeasurement, signedProvider, pending.seq);
+        if (!outcome.ok)
+            throw new SessionRejected(outcome);
+        this.bias = observeResidual(this.bias, outcome.residual);
+        if (biasAlarm(this.bias)) {
+            throw new SessionRejected({
+                ok: false,
+                reason: 'bias',
+                detail: `CUSUM reached ${this.bias.sum} after ${this.bias.babels} chunks`,
+            });
+        }
+        const state = {
+            v: 1,
+            sessionId: this.offer.sessionId,
+            seq: pending.seq,
+            cumulativeUnits: outcome.billedCumulativeUnits,
+            cumulativeSompi: outcome.billedCumulativeUnits * this.offer.unitPriceSompi,
+            prevState: this.lastStateDigest,
+        };
+        this.cursor = {
+            seq: state.seq,
+            cumulativeUnits: state.cumulativeUnits,
+            cumulativeSompi: state.cumulativeSompi,
+            stateDigest: null,
+        };
+        this.pending = null;
+        this.lastState = state;
+        // SPEC.md 4, THROUGH THE STORE. Never `signState` directly: 4.1 (one State per seq), 4.3 (the
+        // chain is unbroken) and 4.2 (record BEFORE the signature escapes) are the rules that lose
+        // money without any message being malformed, and none of them is checkable by a counterparty.
+        const providerSig = signStateWithObligations(this.store, state, this.providerSk);
+        const result = { state, providerSig, billedUnits: outcome.billedUnits };
+        this.settled.set(buyerMeasurement.measurementId, result);
+        return result;
+    }
+    /**
+     * Record the digest of a State once both parties have signed it, so the chain can continue --
+     * and checkpoint it if this chunk calls for one.
+     *
+     * THE CHECKPOINT HAPPENS HERE, not in `settle`, and the difference is the whole point of a
+     * checkpoint. SPEC.md 8 anchors `digest(State)` as EVIDENCE that a State existed before a given
+     * block. A State with one signature is not a State (SPEC.md 3.4), so anchoring at `settle` would
+     * be publishing a claim the buyer had not yet agreed to -- evidence of nothing.
+     *
+     * It does not await. SPEC.md 8 requires checkpointing to be NON-BLOCKING because Study B
+     * measured p90 confirmation at 1,879 ms, and a session that stalled two seconds every few chunks
+     * would be unusable for a streamed response.
+     */
+    chainTo(digest) {
+        this.lastStateDigest = digest;
+        if (this.cursor)
+            this.cursor = { ...this.cursor, stateDigest: digest };
+        if (this.checkpointer && this.lastState)
+            this.checkpointer.record(this.offer, this.lastState);
+    }
+}
+//# sourceMappingURL=provider.js.map

package/dist/src/http/provider.js.map

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

package/dist/src/http/serve.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The HTTP glue. Thin on purpose: every rule lives in provider.ts and service.ts, and this only
+ * maps them onto requests and status codes.
+ *
+ * ROUTING IS BY sessionId, AND IT COSTS NOTHING EXTRA. Every message in SPEC.md 3 already carries
+ * one, because the specification needed it to stop a Reservation or Measurement being lifted from
+ * one session into another -- threat X1. A field that exists for a security reason turns
+ * out to be exactly the routing key a multi-session server needs, so there is no session cookie,
+ * no header, and no server-side handle to leak or confuse.
+ *
+ * An unpaid request gets x402's 402 with the signed Offer in `accepts`. A client that speaks x402
+ * but not this scheme reads the envelope, sees `scheme: "metered"` and declines cleanly.
+ */
+import { type IncomingMessage, type ServerResponse, type Server } from 'node:http';
+import { MeteredService } from './service.js';
+/**
+ * The largest request this server will read. A Reservation, a Measurement and a State are all a
+ * few hundred bytes; a prompt is the only field with any size to it.
+ *
+ * BOUNDED ON PURPOSE. Reading an unbounded body means an unauthenticated client can hold the
+ * process open and grow a buffer until it dies -- which costs the attacker nothing and does not
+ * require knowing any session. This is the cheapest denial of service there is, and the only
+ * defence is to refuse to read past a limit.
+ */
+export declare const MAX_BODY_BYTES: number;
+export declare class BodyTooLarge extends Error {
+}
+export interface ServeOptions {
+    service: MeteredService;
+    resource?: string;
+}
+export declare function meteredHandler(opts: ServeOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+export declare function serveMetered(opts: ServeOptions): Server;
+//# sourceMappingURL=serve.d.ts.map

package/dist/src/http/serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../../src/http/serve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAgB,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AAIjG,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAK9C;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,QAAa,CAAC;AAEzC,qBAAa,YAAa,SAAQ,KAAK;CAAG;AA6B1C,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,cAAc,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAmFD,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,IAGjC,KAAK,eAAe,EAAE,KAAK,cAAc,KAAG,OAAO,CAAC,IAAI,CAAC,CAoBxE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAKvD"}