metered-protocol 1.0.0

package/dist/src/meter.js

@@ -0,0 +1,100 @@
+/**
+ * SPEC.md §6 -- the meters, and resolving the one an Offer names.
+ *
+ * A METER TURNS DELIVERED CONTENT INTO A NUMBER BOTH SIDES CAN REACH INDEPENDENTLY. That is the
+ * whole of what the protocol needs from a unit: everything else -- the offer, the reservation, the
+ * reconciliation, the covenant -- works on integers and does not care what was counted.
+ *
+ * This file used to be `tokenizer.ts`, and the rename is a finding rather than tidying. Writing a
+ * second unit showed that `tokenizer` was a unit-SPECIFIC field sitting in a unit-AGNOSTIC message:
+ * it made sense for tokens and meant nothing for bytes. A protocol that claims its unit is
+ * pluggable should not name one unit's machinery in every Offer.
+ *
+ * EXACT AND INEXACT METERS ARE DIFFERENT ANIMALS, and the difference decides the tolerance.
+ *
+ *   A tokeniser is a LOSSY map from bytes to a count. Two correct implementations can agree on
+ *   every byte and still disagree by one token, because the boundaries are a property of the
+ *   tokeniser rather than of the content. Study A measured exactly that: three counter-examples
+ *   in 3,634 adversarial trials, each one token.
+ *
+ *   Counting octets is a DIRECT function of the bytes. Two parties who agree on `contentDigest`
+ *   cannot disagree on the length -- the digest already proves the bytes are identical. A
+ *   tolerance would not absorb honest divergence, because there is none; it would only widen the
+ *   room a counterparty can shave in.
+ *
+ * So `exact` is not a performance note. It is what makes `toleranceAbs` of 0 correct for one unit
+ * and wrong for another, and §3.1's floor comes from the meter rather than from the protocol.
+ */
+import { encode as encodeO200k } from 'gpt-tokenizer/encoding/o200k_base';
+export class MeterUnavailable extends Error {
+}
+/**
+ * `o200k_base` is GPT-4o's tokeniser, and the one every measured number in SPEC.md was taken with:
+ * Study A's symmetry results, Study C's residual baseline, and the provider agreement study.
+ */
+const o200k = {
+    name: 'o200k_base',
+    unit: 'llm.output_tokens.v1',
+    // A tokeniser measures TEXT, so this meter decodes first -- which is the honest statement of
+    // what it is: a text meter, usable only on content that is text. The decode is deliberately
+    // non-fatal, because a tokeniser's job is to count what it was given rather than to validate
+    // it, and a halt on malformed input belongs to the digest check in SPEC.md 5 rule 3.
+    count: (content) => encodeO200k(new TextDecoder().decode(content)).length,
+    exact: false,
+};
+/**
+ * Octets of the delivered content, UTF-8, exactly as `contentDigest` covers them.
+ *
+ * The strongest meter in the protocol, and the simplest: the parties already agree on the bytes by
+ * the time counting matters, because §5 rule 3 halts on a digest mismatch before any tolerance is
+ * consulted. Once the digests match, the lengths are the same number or one side is broken.
+ */
+const octets = {
+    name: 'octets',
+    unit: 'net.bytes_delivered.v1',
+    // Now that delivery is bytes, this is the whole meter. It used to encode a string to UTF-8
+    // first, which measured text correctly and could not measure a file at all.
+    count: (content) => content.length,
+    exact: true,
+};
+const REGISTRY = { o200k_base: o200k, octets };
+/**
+ * The meter an Offer names, or throw.
+ *
+ * NO FALLBACK, DELIBERATELY. Counting with a meter other than the one agreed produces a number
+ * that looks like a measurement, settles like one, and is not one. §3.1 requires an Offer whose
+ * meter cannot be obtained to be refused, and this is where that refusal happens.
+ */
+export function resolveMeter(name, unit) {
+    const meter = REGISTRY[name];
+    if (!meter) {
+        throw new MeterUnavailable(`cannot obtain meter "${name}" -- SPEC.md 3.1 requires refusing an Offer whose meter is ` +
+            `unresolvable, rather than counting with a different one. available: ${Object.keys(REGISTRY).join(', ')}`);
+    }
+    if (unit !== undefined && meter.unit !== unit) {
+        throw new MeterUnavailable(`meter "${name}" measures ${meter.unit}, but the Offer asks for ${unit}`);
+    }
+    return meter;
+}
+/**
+ * The smallest tolerance an Offer may carry for this meter.
+ *
+ * SPEC.md §3.1. An exact meter permits 0, and should use it: honest divergence is impossible, so
+ * any tolerance is pure shaving room. An inexact meter requires at least 1, because Study A
+ * measured a one-token disagreement between honest parties and a zero tolerance would halt them.
+ */
+export const minimumTolerance = (meter) => (meter.exact ? 0 : 1);
+/** A counting function for the named meter, for callers that want only the number. */
+export function meterFor(name, unit) {
+    const meter = resolveMeter(name, unit);
+    return (content) => meter.count(content);
+}
+/** Token ids, for the conformance comparison that pins boundaries rather than totals. */
+export function encodeWith(name, text) {
+    if (name !== 'o200k_base')
+        throw new MeterUnavailable(`${name} does not produce token ids`);
+    return encodeO200k(text);
+}
+/** Every meter this implementation can serve, for a provider building an Offer. */
+export const available = () => Object.keys(REGISTRY);
+//# sourceMappingURL=meter.js.map

package/dist/src/meter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meter.js","sourceRoot":"","sources":["../../src/meter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAAE,MAAM,IAAI,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAE1E,MAAM,OAAO,gBAAiB,SAAQ,KAAK;CAAG;AAiB9C;;;GAGG;AACH,MAAM,KAAK,GAAU;IACnB,IAAI,EAAE,YAAY;IAClB,IAAI,EAAE,sBAAsB;IAC5B,6FAA6F;IAC7F,4FAA4F;IAC5F,6FAA6F;IAC7F,qFAAqF;IACrF,KAAK,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM;IACzE,KAAK,EAAE,KAAK;CACb,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,GAAU;IACpB,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,wBAAwB;IAC9B,2FAA2F;IAC3F,4EAA4E;IAC5E,KAAK,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM;IAClC,KAAK,EAAE,IAAI;CACZ,CAAC;AAEF,MAAM,QAAQ,GAA0B,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY,EAAE,IAAa;IACtD,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC7B,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,gBAAgB,CACxB,wBAAwB,IAAI,6DAA6D;YACvF,uEAAuE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC5G,CAAC;IACJ,CAAC;IACD,IAAI,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QAC9C,MAAM,IAAI,gBAAgB,CACxB,UAAU,IAAI,cAAc,KAAK,CAAC,IAAI,4BAA4B,IAAI,EAAE,CACzE,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAY,EAAU,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAEhF,sFAAsF;AACtF,MAAM,UAAU,QAAQ,CAAC,IAAY,EAAE,IAAa;IAClD,MAAM,KAAK,GAAG,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACvC,OAAO,CAAC,OAAmB,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AACvD,CAAC;AAED,yFAAyF;AACzF,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,IAAY;IACnD,IAAI,IAAI,KAAK,YAAY;QAAE,MAAM,IAAI,gBAAgB,CAAC,GAAG,IAAI,6BAA6B,CAAC,CAAC;IAC5F,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC;AAC3B,CAAC;AAED,mFAAmF;AACnF,MAAM,CAAC,MAAM,SAAS,GAAG,GAAa,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC"}

package/dist/src/offer.d.ts

@@ -0,0 +1,6 @@
+import type { SessionHistory } from './history.js';
+import type { Offer } from './types.js';
+export declare class OfferRejected extends Error {
+}
+export declare function acceptOffer(offer: Offer, expectedNetwork?: string, history?: SessionHistory): Offer;
+//# sourceMappingURL=offer.d.ts.map

package/dist/src/offer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offer.d.ts","sourceRoot":"","sources":["../../src/offer.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAQxC,qBAAa,aAAc,SAAQ,KAAK;CAAG;AA2D3C,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,eAAe,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,KAAK,CAUnG"}

package/dist/src/offer.js

@@ -0,0 +1,92 @@
+/**
+ * SPEC.md §3.1 -- what a buyer MUST reject before spending anything.
+ *
+ * The Offer is the provider's signed commitment and every later message is bound to it, so this
+ * is the only moment a buyer can decline cheaply. After it accepts, the exposure bound, the
+ * tolerance and the response window are all fixed by terms it agreed to.
+ *
+ * Three of these rejections are named in §3.1 and the rest come from field constraints in the same
+ * table. They are enforced together because a buyer that checks some of them is not safer in any
+ * useful sense -- an Offer with `babelUnits` of zero is as unusable as one with no tokeniser.
+ */
+import { verify } from './encoding.js';
+import { resolveMeter, minimumTolerance } from './meter.js';
+/** §7.3: the window lowers to OpCheckSequenceVerify, whose low 32 bits carry the delay. */
+const MAX_RESPONSE_WINDOW = 4294967295;
+/** SPEC.md 3.1: 16 bytes. 128 bits of nonce -- see 3.1a for why more would not help. */
+const SESSION_ID = /^[0-9a-f]{32}$/;
+export class OfferRejected extends Error {
+}
+const reject = (why) => {
+    throw new OfferRejected(why);
+};
+/** The numeric floors from the §3.1 table, each of which makes the Offer unusable if breached. */
+function checkBounds(offer) {
+    if (offer.unitPriceSompi < 1)
+        reject('unitPriceSompi must be >= 1');
+    if (offer.babelUnits < 1)
+        reject('babelUnits must be >= 1');
+    if (offer.maxBabels < 1)
+        reject('maxBabels must be >= 1');
+    // THE FLOOR COMES FROM THE METER, NOT FROM THE PROTOCOL, and that only became visible when a
+    // second unit was added. A tokeniser is a lossy map from bytes to a count, so two honest parties
+    // can differ by one and a zero tolerance halts them -- Study A measured exactly that. Counting
+    // octets is a direct function of the bytes, so once §5 rule 3 has agreed the digest there is no
+    // honest divergence left to absorb, and a tolerance would be nothing but shaving room.
+    const floor = minimumTolerance(resolveMeter(offer.meter, offer.unit));
+    if (offer.toleranceAbs < floor) {
+        reject(`toleranceAbs must be >= ${floor} for meter ${offer.meter} -- see SPEC.md 6`);
+    }
+    if (offer.checkpointEvery < 0)
+        reject('checkpointEvery must be >= 0');
+}
+/**
+ * Accept an Offer, or throw. Returns the Offer so a caller can use it in an expression.
+ *
+ * `meter` is checked for presence only. Whether a given name RESOLVES is a property of the
+ * buyer's environment rather than of the message -- a buyer that cannot obtain it MUST refuse,
+ * but that refusal belongs where the meter is loaded (src/meter.ts), not here.
+ */
+/** The fields that must simply be what §3.1 says, before any of them are worth interpreting. */
+function checkShape(offer, expectedNetwork) {
+    if (offer.v !== 1)
+        reject(`unsupported version ${offer.v}`);
+    if (offer.scheme !== 'metered')
+        reject(`scheme is ${offer.scheme}, not metered`);
+    if (expectedNetwork && offer.network !== expectedNetwork) {
+        reject(`network is ${offer.network}, expected ${expectedNetwork}`);
+    }
+    if (!SESSION_ID.test(offer.sessionId))
+        reject('sessionId must be 16 hex bytes');
+    if (!offer.meter)
+        reject('meter is absent -- an unnamed meter is not usable');
+    if (offer.responseWindowDaa < 1 || offer.responseWindowDaa > MAX_RESPONSE_WINDOW) {
+        reject(`responseWindowDaa ${offer.responseWindowDaa} outside 1..=${MAX_RESPONSE_WINDOW}`);
+    }
+}
+/**
+ * SPEC.md §3.1a. `history.ts` says why the width of `sessionId` is not what does this job.
+ *
+ * Called LAST, after the signature has verified, so a malformed or unsigned Offer cannot burn an
+ * identifier the provider might go on to use honestly: an attacker who can hand the buyer junk
+ * must not be able to poison its history against the real provider.
+ */
+function checkNovelty(offer, history) {
+    if (!history)
+        return;
+    if (history.seen(offer.providerPubkey, offer.sessionId)) {
+        reject(`sessionId ${offer.sessionId} has been offered by this provider before -- see SPEC.md 3.1a`);
+    }
+    history.record(offer.providerPubkey, offer.sessionId);
+}
+export function acceptOffer(offer, expectedNetwork, history) {
+    checkShape(offer, expectedNetwork);
+    checkBounds(offer);
+    // Before novelty and after everything cheap: it is the most expensive check, and it is what
+    // makes `providerPubkey` mean anything, which the novelty history is keyed by.
+    if (!verify(offer, offer.providerPubkey))
+        reject('Offer signature does not verify');
+    checkNovelty(offer, history);
+    return offer;
+}
+//# sourceMappingURL=offer.js.map

package/dist/src/offer.js.map

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

package/dist/src/reconcile.d.ts

@@ -0,0 +1,18 @@
+import type { Halt, Measurement, Offer, Reconciled } from './types.js';
+/**
+ * SPEC.md §5 rule 4. The bound is ABSOLUTE, and does not scale with the size of the babel.
+ *
+ * `toleranceRel` was removed in this version because the evidence never supported it. Honest
+ * divergence between two correct implementations is a BOUNDARY effect: Study A found it three
+ * times in 3,634 adversarial trials, and every occurrence was exactly one token. Study C looked
+ * for it at seven babel sizes from 3 to 550 units, 4,000 boundaries each, and found none at any
+ * size -- so the magnitude does not grow with the babel, and a bound that grows with the babel is
+ * answering a problem nobody has measured.
+ *
+ * What such a bound WOULD do is widen the room a counterparty can shave in, which is the exact
+ * leak §5.1 exists to bound: at 0.2% of a 5,000-unit babel it is ten free tokens per babel,
+ * justified by nothing.
+ */
+export declare function toleranceBound(offer: Offer, providerUnits: number): number;
+export declare function reconcileBabel(offer: Offer, buyer: Measurement, provider: Measurement, seq: number): Reconciled | Halt;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/src/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../src/reconcile.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAIvE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAG1E;AAwDD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,WAAW,EACrB,GAAG,EAAE,MAAM,GACV,UAAU,GAAG,IAAI,CAkBnB"}

package/dist/src/reconcile.js

@@ -0,0 +1,101 @@
+/**
+ * SPEC.md §5 -- the reconciliation rule, in order, halting on the first failure.
+ *
+ * The order is normative and it is not arbitrary. Signatures come first because an unsigned
+ * Measurement is not evidence of anything; the content digest comes before the counts because if
+ * the two parties are describing different bytes then no amount of counting can reconcile them,
+ * and a tolerance comparison on mismatched content would silently succeed whenever the numbers
+ * happened to land close together.
+ *
+ * Rule 6 bills the LOWER count. That removes the provider's incentive to sit at the top of the
+ * tolerance band -- and hands the identical trick to the buyer, which is why §5.1's bias detector
+ * is normative and symmetric. See bias.ts.
+ */
+import { verify } from './encoding.js';
+const halt = (reason, detail) => ({ ok: false, reason, detail });
+/**
+ * SPEC.md §5 rule 4. The bound is ABSOLUTE, and does not scale with the size of the babel.
+ *
+ * `toleranceRel` was removed in this version because the evidence never supported it. Honest
+ * divergence between two correct implementations is a BOUNDARY effect: Study A found it three
+ * times in 3,634 adversarial trials, and every occurrence was exactly one token. Study C looked
+ * for it at seven babel sizes from 3 to 550 units, 4,000 boundaries each, and found none at any
+ * size -- so the magnitude does not grow with the babel, and a bound that grows with the babel is
+ * answering a problem nobody has measured.
+ *
+ * What such a bound WOULD do is widen the room a counterparty can shave in, which is the exact
+ * leak §5.1 exists to bound: at 0.2% of a 5,000-unit babel it is ten free tokens per babel,
+ * justified by nothing.
+ */
+export function toleranceBound(offer, providerUnits) {
+    void providerUnits;
+    return offer.toleranceAbs;
+}
+/**
+ * Rule 1. Each Measurement must verify against the key for the party it claims to be from.
+ *
+ * `by` is checked against the key that actually signed, not merely read -- otherwise a provider
+ * could sign a Measurement stamped `by: "buyer"` and supply both halves of the reconciliation.
+ */
+function signedByClaimedParty(m, offer) {
+    const key = m.by === 'buyer' ? offer.buyerPubkey : offer.providerPubkey;
+    return verify(m, key);
+}
+/**
+ * Reconcile one babel boundary. Returns what to bill, or the reason to stop.
+ *
+ * Idempotency (§3.3, `measurementId`) is the caller's job: a retransmitted Measurement MUST be a
+ * no-op, and that belongs to whatever holds session state, not to a pure rule.
+ */
+/** Rule 1. Both signatures verify, and each `by` matches the key that actually signed. */
+function checkAuthorship(offer, buyer, provider) {
+    if (buyer.by !== 'buyer' || provider.by !== 'provider') {
+        return halt('signature', `measurements are ${buyer.by}/${provider.by}, expected buyer/provider`);
+    }
+    if (!signedByClaimedParty(buyer, offer))
+        return halt('signature', 'buyer measurement does not verify');
+    if (!signedByClaimedParty(provider, offer))
+        return halt('signature', 'provider measurement does not verify');
+    return null;
+}
+/** Rule 2, plus X1: this session, this babel, both sides. */
+function checkPlacement(offer, buyer, provider, seq) {
+    if (buyer.sessionId !== offer.sessionId || provider.sessionId !== offer.sessionId) {
+        return halt('sequence', 'measurement sessionId does not match the Offer');
+    }
+    if (buyer.seq !== seq || provider.seq !== seq) {
+        return halt('sequence', `expected seq ${seq}, got buyer ${buyer.seq} / provider ${provider.seq}`);
+    }
+    return null;
+}
+/** Rules 4 and 5. Reached only once the parties are known to be describing the same bytes. */
+function checkTolerances(offer, buyer, provider) {
+    const bound = toleranceBound(offer, provider.units);
+    if (Math.abs(buyer.units - provider.units) > bound) {
+        return halt('tolerance-babel', `|${buyer.units} − ${provider.units}| exceeds ${bound}`);
+    }
+    const cumulativeBound = toleranceBound(offer, provider.cumulativeUnits);
+    if (Math.abs(buyer.cumulativeUnits - provider.cumulativeUnits) > cumulativeBound) {
+        return halt('tolerance-cumulative', `|${buyer.cumulativeUnits} − ${provider.cumulativeUnits}| exceeds ${cumulativeBound}`);
+    }
+    return null;
+}
+export function reconcileBabel(offer, buyer, provider, seq) {
+    // Rule 3 sits between the groups rather than inside one, because its ORDER is the point: it runs
+    // before any counting, so mismatched bytes can never pass on numbers that happen to land close.
+    const failure = checkAuthorship(offer, buyer, provider) ??
+        checkPlacement(offer, buyer, provider, seq) ??
+        (buyer.contentDigest !== provider.contentDigest
+            ? halt('content-digest', 'the parties are describing different bytes')
+            : null) ??
+        checkTolerances(offer, buyer, provider);
+    if (failure)
+        return failure;
+    return {
+        ok: true,
+        billedUnits: Math.min(buyer.units, provider.units),
+        billedCumulativeUnits: Math.min(buyer.cumulativeUnits, provider.cumulativeUnits),
+        residual: provider.units - buyer.units,
+    };
+}
+//# sourceMappingURL=reconcile.js.map

package/dist/src/reconcile.js.map

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

package/dist/src/reservation.d.ts

@@ -0,0 +1,51 @@
+import type { Offer, Reservation } from './types.js';
+export declare class ReservationRejected extends Error {
+}
+/**
+ * The Reservation did not come from the buyer named in the Offer -- unsigned, wrongly signed, or
+ * altered after signing.
+ *
+ * A SUBTYPE, because the difference matters to the caller and to nobody else. Every other
+ * ReservationRejected means an AUTHENTICATED buyer asked for something it had agreed not to ask
+ * for, which is a disagreement and stops the session. This one means the sender is not the buyer
+ * at all, so it is evidence about the sender and none about the session -- and since `sessionId`
+ * travels in clear, treating it as a disagreement would let any observer kill any session.
+ */
+export declare class ReservationUnauthenticated extends ReservationRejected {
+}
+/** What the previous chunk left behind. `null` means nothing has been reserved yet. */
+export interface BabelCursor {
+    seq: number;
+    cumulativeUnits: number;
+    cumulativeSompi: number;
+    stateDigest: string | null;
+}
+/** The amount a chunk costs, recomputed from the Offer's price rather than read off the wire. */
+export declare const priceOf: (offer: Offer, units: number) => number;
+/**
+ * The funding floor: the most a session can ever bill, plus the fee its close will cost.
+ *
+ * SPEC.md 7.4b. `expire` pays the provider EXACTLY `pendingSompi`, so if the parties agree a total
+ * the covenant cannot pay -- including the network fee for the transaction that pays it -- then no
+ * valid close transaction exists and the whole balance is stranded. The covenant cannot catch this
+ * itself: it would have to know the fee a future transaction will cost, which is not available to
+ * a script. The buyer can, because the buyer chooses the funding amount, and it can do so before
+ * spending anything.
+ */
+export declare function requiredFunding(offer: Offer, closeFeeSompi?: number): number;
+/**
+ * The smallest balance a covenant may hold, and it is not a dust rule -- it is a SHAPE rule.
+ *
+ * A two-output close needs both halves to clear KIP-9 together, and below roughly 0.068 KAS they
+ * cannot: tools/dust-map.ts finds claims with no legal close at all for balances between
+ * 5,700,000 and 6,800,000 sompi, whatever the dust constant is set to. Above 6,850,000 the
+ * problem disappears. 10,000,000 is the round number above that with margin.
+ */
+export declare const MIN_COVENANT_SOMPI = 10000000;
+/**
+ * The covenant's fee allowance, measured: `expire` performs two signature checks
+ * and is the costliest entry, needing ~313,800 -- 400,000 is what the contract reserves.
+ */
+export declare const CLOSE_FEE_SOMPI = 400000;
+export declare function acceptReservation(offer: Offer, reservation: Reservation, previous: BabelCursor | null): BabelCursor;
+//# sourceMappingURL=reservation.d.ts.map

package/dist/src/reservation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reservation.d.ts","sourceRoot":"","sources":["../../src/reservation.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAErD,qBAAa,mBAAoB,SAAQ,KAAK;CAAG;AAEjD;;;;;;;;;GASG;AACH,qBAAa,0BAA2B,SAAQ,mBAAmB;CAAG;AAMtE,uFAAuF;AACvF,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,iGAAiG;AACjG,eAAO,MAAM,OAAO,GAAI,OAAO,KAAK,EAAE,OAAO,MAAM,KAAG,MAAsC,CAAC;AA8C7F;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,aAAa,SAAkB,GAAG,MAAM,CAGrF;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,WAAa,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,eAAe,SAAU,CAAC;AAEvC,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,WAAW,GAAG,IAAI,GAC3B,WAAW,CA4Bb"}

package/dist/src/reservation.js

@@ -0,0 +1,124 @@
+/**
+ * SPEC.md §3.2 -- the Reservation. One babel, never the session.
+ *
+ * This is where the exposure bound is actually enforced. The buyer signs an authorisation for a
+ * single babel, and the mirror threat -- "take a babel, never sign its State" -- is the
+ * provider's matching exposure. Both are one chunk, deliberately and symmetrically: `babelUnits`
+ * is the whole trust model, which is why the checks here are not conveniences.
+ *
+ * "Recomputed and compared, never trusted" (§3.2) is the load-bearing sentence. A provider that
+ * reads `cumulativeSompi` off the wire and bills it has handed the buyer a free variable.
+ */
+import { verify } from './encoding.js';
+export class ReservationRejected extends Error {
+}
+/**
+ * The Reservation did not come from the buyer named in the Offer -- unsigned, wrongly signed, or
+ * altered after signing.
+ *
+ * A SUBTYPE, because the difference matters to the caller and to nobody else. Every other
+ * ReservationRejected means an AUTHENTICATED buyer asked for something it had agreed not to ask
+ * for, which is a disagreement and stops the session. This one means the sender is not the buyer
+ * at all, so it is evidence about the sender and none about the session -- and since `sessionId`
+ * travels in clear, treating it as a disagreement would let any observer kill any session.
+ */
+export class ReservationUnauthenticated extends ReservationRejected {
+}
+const refuse = (why) => {
+    throw new ReservationRejected(why);
+};
+/** The amount a chunk costs, recomputed from the Offer's price rather than read off the wire. */
+export const priceOf = (offer, units) => units * offer.unitPriceSompi;
+/**
+ * Check a Reservation against the Offer and the session so far. Throws, or returns the cursor the
+ * next chunk must build on.
+ */
+/**
+ * §3.2: "from 0, strictly incrementing by exactly 1". Exactly one, so B4 -- replaying an old
+ * Reservation -- cannot advance the session, and no chunk can be skipped past unbilled.
+ */
+function checkSequencing(offer, reservation, previous) {
+    if (reservation.v !== 1)
+        refuse(`unsupported version ${reservation.v}`);
+    if (reservation.sessionId !== offer.sessionId)
+        refuse('sessionId does not match the Offer');
+    const expectedSeq = previous === null ? 0 : previous.seq + 1;
+    if (reservation.seq !== expectedSeq)
+        refuse(`seq must be exactly ${expectedSeq}, got ${reservation.seq}`);
+    if (reservation.seq >= offer.maxBabels) {
+        refuse(`seq ${reservation.seq} reaches the session ceiling of ${offer.maxBabels} chunks`);
+    }
+}
+/** THE EXPOSURE BOUND. Everything else in this protocol is bookkeeping around these two lines. */
+function checkExposure(offer, reservation) {
+    if (reservation.units < 1)
+        refuse('units must be >= 1');
+    if (reservation.units > offer.babelUnits) {
+        refuse(`units ${reservation.units} exceeds babelUnits ${offer.babelUnits}`);
+    }
+}
+/** §3.2: recomputed and compared, never trusted. Returns the totals the caller should keep. */
+function recomputeTotals(offer, reservation, previous) {
+    const units = (previous?.cumulativeUnits ?? 0) + reservation.units;
+    const sompi = (previous?.cumulativeSompi ?? 0) + priceOf(offer, reservation.units);
+    if (reservation.cumulativeUnits !== units) {
+        refuse(`cumulativeUnits is ${reservation.cumulativeUnits}, recomputed ${units}`);
+    }
+    if (reservation.cumulativeSompi !== sompi) {
+        refuse(`cumulativeSompi is ${reservation.cumulativeSompi}, recomputed ${sompi}`);
+    }
+    return { units, sompi };
+}
+/**
+ * The funding floor: the most a session can ever bill, plus the fee its close will cost.
+ *
+ * SPEC.md 7.4b. `expire` pays the provider EXACTLY `pendingSompi`, so if the parties agree a total
+ * the covenant cannot pay -- including the network fee for the transaction that pays it -- then no
+ * valid close transaction exists and the whole balance is stranded. The covenant cannot catch this
+ * itself: it would have to know the fee a future transaction will cost, which is not available to
+ * a script. The buyer can, because the buyer chooses the funding amount, and it can do so before
+ * spending anything.
+ */
+export function requiredFunding(offer, closeFeeSompi = CLOSE_FEE_SOMPI) {
+    const maxBill = offer.maxBabels * offer.babelUnits * offer.unitPriceSompi;
+    return Math.max(maxBill + closeFeeSompi, MIN_COVENANT_SOMPI);
+}
+/**
+ * The smallest balance a covenant may hold, and it is not a dust rule -- it is a SHAPE rule.
+ *
+ * A two-output close needs both halves to clear KIP-9 together, and below roughly 0.068 KAS they
+ * cannot: tools/dust-map.ts finds claims with no legal close at all for balances between
+ * 5,700,000 and 6,800,000 sompi, whatever the dust constant is set to. Above 6,850,000 the
+ * problem disappears. 10,000,000 is the round number above that with margin.
+ */
+export const MIN_COVENANT_SOMPI = 10_000_000;
+/**
+ * The covenant's fee allowance, measured: `expire` performs two signature checks
+ * and is the costliest entry, needing ~313,800 -- 400,000 is what the contract reserves.
+ */
+export const CLOSE_FEE_SOMPI = 400_000;
+export function acceptReservation(offer, reservation, previous) {
+    // SPEC.md 3.2: "Signed by the buyer." Until 2026-09-10 nothing checked that, so the provider
+    // would deliver work to anyone who knew a sessionId, and held no evidence the buyer had ever
+    // authorised the babel it was about to bill for. FIRST, because every check below it is
+    // interpreting a document whose author is otherwise unknown.
+    if (!verify(reservation, offer.buyerPubkey)) {
+        throw new ReservationUnauthenticated('Reservation signature does not verify against the buyer named in the Offer');
+    }
+    checkSequencing(offer, reservation, previous);
+    checkExposure(offer, reservation);
+    const totals = recomputeTotals(offer, reservation, previous);
+    // §3.2: the digest of the previous DOUBLY-SIGNED State, null at seq 0. This is what stops a
+    // Reservation being lifted out of one history and dropped into another.
+    const expectedPrev = previous?.stateDigest ?? null;
+    if (reservation.prevState !== expectedPrev) {
+        refuse(`prevState ${reservation.prevState ?? 'null'} does not chain to ${expectedPrev ?? 'null'}`);
+    }
+    return {
+        seq: reservation.seq,
+        cumulativeUnits: totals.units,
+        cumulativeSompi: totals.sompi,
+        stateDigest: null, // filled in once the State for this chunk is doubly signed
+    };
+}
+//# sourceMappingURL=reservation.js.map

package/dist/src/reservation.js.map

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

package/dist/src/session.d.ts

@@ -0,0 +1,40 @@
+import { type BiasState } from './bias.js';
+import { type SignerStore } from './signer.js';
+import { Checkpointer } from './checkpoint.js';
+import type { Halt, Measurement, Offer, Reservation, State } from './types.js';
+export interface ChunkResult {
+    state: State;
+    buyerSig: string;
+    providerSig: string;
+    billedUnits: number;
+    checkpointed: boolean;
+}
+export declare class SessionHalted extends Error {
+    readonly halt: Halt;
+    constructor(halt: Halt);
+}
+/**
+ * Drives one session for BOTH parties, which is what a test needs and what a real deployment
+ * splits in half. Keeping them together here is the only way to assert that the two halves agree.
+ */
+export declare class Session {
+    private readonly offer;
+    private readonly buyerStore;
+    private readonly providerStore;
+    private readonly checkpointer;
+    private cursor;
+    private bias;
+    constructor(offer: Offer, buyerStore: SignerStore, providerStore: SignerStore, checkpointer: Checkpointer);
+    get residualState(): BiasState;
+    get cumulativeSompi(): number;
+    /**
+     * Run one chunk end to end: reserve, reconcile, bill, doubly sign, checkpoint.
+     *
+     * Throws SessionHalted on any rule failure. §1: "The only remedy for disagreement is to stop."
+     */
+    chunk(reservation: Reservation, buyerMeasurement: Measurement, providerMeasurement: Measurement, keys: {
+        buyerSk: string;
+        providerSk: string;
+    }): ChunkResult;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/src/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"AAiBA,OAAO,EAA4C,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AACrF,OAAO,EAA4B,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAE/E,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,qBAAa,aAAc,SAAQ,KAAK;IAC1B,QAAQ,CAAC,IAAI,EAAE,IAAI;gBAAV,IAAI,EAAE,IAAI;CAGhC;AAED;;;GAGG;AACH,qBAAa,OAAO;IAKhB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAP/B,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,IAAI,CAA6B;gBAGtB,KAAK,EAAE,KAAK,EACZ,UAAU,EAAE,WAAW,EACvB,aAAa,EAAE,WAAW,EAC1B,YAAY,EAAE,YAAY;IAG7C,IAAI,aAAa,IAAI,SAAS,CAE7B;IAED,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED;;;;OAIG;IACH,KAAK,CACH,WAAW,EAAE,WAAW,EACxB,gBAAgB,EAAE,WAAW,EAC7B,mBAAmB,EAAE,WAAW,EAChC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAC5C,WAAW;CA0Cf"}