@naulon/shared 0.0.1

package/dist/networks.d.ts

@@ -0,0 +1,63 @@
+/** The chains this gate can settle on — each a SupportedChainName in the SDK. */
+export type NetworkName = "arcTestnet" | "baseSepolia" | "base";
+export interface SettlementNetwork {
+    /** GatewayClient `chain` key — must match a SupportedChainName in the SDK. */
+    chainName: NetworkName;
+    /** x402 network id. MUST be `eip155:<chainId>` — the SDK's BatchEvmScheme
+     *  rejects any other format (verify compares against `eip155:${chain.id}`). */
+    network: string;
+    chainId: number;
+    /** Native USDC token (ERC-20). */
+    usdc: `0x${string}`;
+    /** USDC EIP-712 domain `name`/`version` for RAW EIP-3009 signing (the memo
+     *  self-relay rail). VERIFIED per-network, never assumed: Arc testnet's USDC names
+     *  itself "USDC"/"2" on-chain (NOT the mainnet FiatToken "USD Coin") — a mismatch
+     *  silently rejects every signature (recovers signer != from). Only the memo rail
+     *  reads these (the Gateway path signs the GatewayWallet domain via `gatewayExtra`),
+     *  so they are optional and set only where a memo settle runs. The `USDC_EIP712_NAME`
+     *  env var overrides `name` for a deploy that hits an unexpected on-chain value. */
+    usdcName?: string;
+    usdcVersion?: string;
+    /** GatewayWallet contract — the x402 `extra.verifyingContract`. Differs between
+     *  Circle's testnet and mainnet deployments, so it lives per-network. */
+    gatewayWallet: `0x${string}`;
+    /** Circle Gateway facilitator endpoint. The SDK 3.x defaults to mainnet, so a
+     *  testnet network must point the seller-side BatchFacilitatorClient here. */
+    gatewayApiUrl: string;
+    rpcUrl: string;
+    /** false only for a real-money mainnet — the guard behind the safe default. */
+    testnet: boolean;
+    /** Arc-only transaction-extension capability. Present ONLY on chains that ship the
+     *  Memo predeploy (Arc); ABSENT on Base / Base Sepolia (they have no equivalent).
+     *  The settle path gates memo emission on the PRESENCE of this field, NEVER on
+     *  chainName — so a chain swap to Base omits memos automatically (illegal state
+     *  unrepresentable). The memo wraps the buyer→author transfer via a self-relay,
+     *  which stays custody-free (the relayer pays gas, never touches the USDC). */
+    memo?: {
+        /** The Memo predeploy. `memo(target,data,memoId,memoData)` executes the subcall
+         *  through the CALL_FROM precompile (preserving the relayer as caller) AND emits
+         *  an indexed `Memo(sender,target,callDataHash,memoId,memo,memoIndex)` event.
+         *  Verified on testnet.arcscan.app (Blockscout). Arc-testnet-only. */
+        contract: `0x${string}`;
+    };
+}
+/** Field-presence capability gate — true iff this network ships the Memo predeploy.
+ *  The settle path narrows on THIS, never on `chainName`, so adding a memo-capable
+ *  chain (or swapping to a memo-less one) needs no settle-path edit. */
+export declare function supportsMemo(net: SettlementNetwork): net is SettlementNetwork & {
+    memo: NonNullable<SettlementNetwork["memo"]>;
+};
+export declare const NETWORKS: Record<NetworkName, SettlementNetwork>;
+/** Back-compat alias for the original single-network export + interface. */
+export declare const ARC_TESTNET: SettlementNetwork;
+/** @deprecated use {@link SettlementNetwork}. */
+export type ArcNetwork = SettlementNetwork;
+/** Look up a network by name. */
+export declare function getNetwork(name: NetworkName): SettlementNetwork;
+/** The network the gate is configured to settle on (`SETTLEMENT_NETWORK`). */
+export declare function activeNetwork(): SettlementNetwork;
+/** The Gateway batching x402 `extra` block, naming the verifying contract. */
+export declare function gatewayExtra(net?: SettlementNetwork): Record<string, unknown>;
+/** Convert a decimal USDC string/number to atomic units (6 decimals). */
+export declare function toAtomicUsdc(amount: number | string): string;
+//# sourceMappingURL=networks.d.ts.map

package/dist/networks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networks.d.ts","sourceRoot":"","sources":["../src/networks.ts"],"names":[],"mappings":"AAiBA,iFAAiF;AACjF,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,aAAa,GAAG,MAAM,CAAC;AAEhE,MAAM,WAAW,iBAAiB;IAChC,8EAA8E;IAC9E,SAAS,EAAE,WAAW,CAAC;IACvB;mFAC+E;IAC/E,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,IAAI,EAAE,KAAK,MAAM,EAAE,CAAC;IACpB;;;;;;wFAMoF;IACpF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;6EACyE;IACzE,aAAa,EAAE,KAAK,MAAM,EAAE,CAAC;IAC7B;kFAC8E;IAC9E,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,+EAA+E;IAC/E,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;mFAK+E;IAC/E,IAAI,CAAC,EAAE;QACL;;;8EAGsE;QACtE,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;KACzB,CAAC;CACH;AAED;;wEAEwE;AACxE,wBAAgB,YAAY,CAC1B,GAAG,EAAE,iBAAiB,GACrB,GAAG,IAAI,iBAAiB,GAAG;IAAE,IAAI,EAAE,WAAW,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAA;CAAE,CAE7E;AAKD,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,WAAW,EAAE,iBAAiB,CAuC3D,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,WAAW,EAAE,iBAAuC,CAAC;AAClE,iDAAiD;AACjD,MAAM,MAAM,UAAU,GAAG,iBAAiB,CAAC;AAE3C,iCAAiC;AACjC,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,iBAAiB,CAE/D;AAED,8EAA8E;AAC9E,wBAAgB,aAAa,IAAI,iBAAiB,CAEjD;AAED,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,GAAG,GAAE,iBAAmC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE9F;AAED,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAG5D"}

package/dist/networks.js

@@ -0,0 +1,84 @@
+/**
+ * Settlement network registry. One switch (`SETTLEMENT_NETWORK`) selects the chain
+ * the whole rail tolls on — the x402 quote, the settlement body, the discovery
+ * manifest, and the buyer client all read the active network from here, so moving
+ * between Arc testnet, Base Sepolia, and Base mainnet is an env change, not a code
+ * change.
+ *
+ * Source of truth for every constant: the @circle-fin/x402-batching SDK
+ * (dist/client chain configs) and circlefin/arc-nanopayments. Kept here, not
+ * imported from the SDK, so `shared` carries no dependency on it — the SDK is
+ * lazy-loaded only in gateway mode (see tollgate/x402.ts, wayfarer/gateway.ts).
+ *
+ * NOTE: the rail is Circle Gateway on every entry. "Swappable" here means swappable
+ * across Circle's chains, NOT across facilitators — there is deliberately one rail.
+ */
+import { getConfig } from "./config.js";
+/** Field-presence capability gate — true iff this network ships the Memo predeploy.
+ *  The settle path narrows on THIS, never on `chainName`, so adding a memo-capable
+ *  chain (or swapping to a memo-less one) needs no settle-path edit. */
+export function supportsMemo(net) {
+    return net.memo !== undefined;
+}
+const TESTNET_FACILITATOR = "https://gateway-api-testnet.circle.com";
+const MAINNET_FACILITATOR = "https://gateway-api.circle.com";
+export const NETWORKS = {
+    arcTestnet: {
+        chainName: "arcTestnet",
+        network: "eip155:5042002",
+        chainId: 5042002,
+        usdc: "0x3600000000000000000000000000000000000000",
+        // Verified on-chain 2026-06-19 (live Arc memo settle): the Arc-testnet USDC
+        // names itself "USDC"/"2", NOT the mainnet FiatToken "USD Coin". This is the
+        // EIP-712 domain the buyer's raw EIP-3009 authorization is signed against.
+        usdcName: "USDC",
+        usdcVersion: "2",
+        gatewayWallet: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+        gatewayApiUrl: TESTNET_FACILITATOR,
+        rpcUrl: "https://rpc.testnet.arc.network",
+        testnet: true,
+        // Arc ships the Memo + CallFrom predeploys; Base does not. Set here, gated on
+        // presence at settle time → a swap to Base drops memos with no settle-path edit.
+        memo: { contract: "0x5294E9927c3306DcBaDb03fe70b92e01cCede505" },
+    },
+    baseSepolia: {
+        chainName: "baseSepolia",
+        network: "eip155:84532",
+        chainId: 84532,
+        usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+        gatewayWallet: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+        gatewayApiUrl: TESTNET_FACILITATOR,
+        rpcUrl: "https://sepolia-preconf.base.org",
+        testnet: true,
+    },
+    base: {
+        chainName: "base",
+        network: "eip155:8453",
+        chainId: 8453,
+        usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        gatewayWallet: "0x77777777Dcc4d5A8B6E418Fd04D8997ef11000eE",
+        gatewayApiUrl: MAINNET_FACILITATOR,
+        rpcUrl: "https://mainnet.base.org",
+        testnet: false,
+    },
+};
+/** Back-compat alias for the original single-network export + interface. */
+export const ARC_TESTNET = NETWORKS.arcTestnet;
+/** Look up a network by name. */
+export function getNetwork(name) {
+    return NETWORKS[name];
+}
+/** The network the gate is configured to settle on (`SETTLEMENT_NETWORK`). */
+export function activeNetwork() {
+    return NETWORKS[getConfig().SETTLEMENT_NETWORK];
+}
+/** The Gateway batching x402 `extra` block, naming the verifying contract. */
+export function gatewayExtra(net = activeNetwork()) {
+    return { name: "GatewayWalletBatched", version: "1", verifyingContract: net.gatewayWallet };
+}
+/** Convert a decimal USDC string/number to atomic units (6 decimals). */
+export function toAtomicUsdc(amount) {
+    const n = typeof amount === "string" ? parseFloat(amount.replace("$", "")) : amount;
+    return Math.round(n * 1_000_000).toString();
+}
+//# sourceMappingURL=networks.js.map

package/dist/networks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"networks.js","sourceRoot":"","sources":["../src/networks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AA+CxC;;wEAEwE;AACxE,MAAM,UAAU,YAAY,CAC1B,GAAsB;IAEtB,OAAO,GAAG,CAAC,IAAI,KAAK,SAAS,CAAC;AAChC,CAAC;AAED,MAAM,mBAAmB,GAAG,wCAAwC,CAAC;AACrE,MAAM,mBAAmB,GAAG,gCAAgC,CAAC;AAE7D,MAAM,CAAC,MAAM,QAAQ,GAA2C;IAC9D,UAAU,EAAE;QACV,SAAS,EAAE,YAAY;QACvB,OAAO,EAAE,gBAAgB;QACzB,OAAO,EAAE,OAAO;QAChB,IAAI,EAAE,4CAA4C;QAClD,4EAA4E;QAC5E,6EAA6E;QAC7E,2EAA2E;QAC3E,QAAQ,EAAE,MAAM;QAChB,WAAW,EAAE,GAAG;QAChB,aAAa,EAAE,4CAA4C;QAC3D,aAAa,EAAE,mBAAmB;QAClC,MAAM,EAAE,iCAAiC;QACzC,OAAO,EAAE,IAAI;QACb,8EAA8E;QAC9E,iFAAiF;QACjF,IAAI,EAAE,EAAE,QAAQ,EAAE,4CAA4C,EAAE;KACjE;IACD,WAAW,EAAE;QACX,SAAS,EAAE,aAAa;QACxB,OAAO,EAAE,cAAc;QACvB,OAAO,EAAE,KAAK;QACd,IAAI,EAAE,4CAA4C;QAClD,aAAa,EAAE,4CAA4C;QAC3D,aAAa,EAAE,mBAAmB;QAClC,MAAM,EAAE,kCAAkC;QAC1C,OAAO,EAAE,IAAI;KACd;IACD,IAAI,EAAE;QACJ,SAAS,EAAE,MAAM;QACjB,OAAO,EAAE,aAAa;QACtB,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,4CAA4C;QAClD,aAAa,EAAE,4CAA4C;QAC3D,aAAa,EAAE,mBAAmB;QAClC,MAAM,EAAE,0BAA0B;QAClC,OAAO,EAAE,KAAK;KACf;CACF,CAAC;AAEF,4EAA4E;AAC5E,MAAM,CAAC,MAAM,WAAW,GAAsB,QAAQ,CAAC,UAAU,CAAC;AAIlE,iCAAiC;AACjC,MAAM,UAAU,UAAU,CAAC,IAAiB;IAC1C,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;AACxB,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,aAAa;IAC3B,OAAO,QAAQ,CAAC,SAAS,EAAE,CAAC,kBAAkB,CAAC,CAAC;AAClD,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,YAAY,CAAC,MAAyB,aAAa,EAAE;IACnE,OAAO,EAAE,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,EAAE,GAAG,CAAC,aAAa,EAAE,CAAC;AAC9F,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,YAAY,CAAC,MAAuB;IAClD,MAAM,CAAC,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IACpF,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,QAAQ,EAAE,CAAC;AAC9C,CAAC"}

package/dist/observationsink.d.ts

@@ -0,0 +1,22 @@
+import type { ObservationEvent, ObservationSink } from "./types.ts";
+/** Records nothing. The default — observability is opt-in. */
+export declare function noopObservationSink(): ObservationSink;
+/** Append-only JSONL file (dev / single-box). Mirrors `jsonlSink`. */
+export declare function jsonlObservationSink(path?: string): ObservationSink;
+/**
+ * Supabase-backed sink. One row per observation: `id` (primary key, idempotent
+ * retry), `at` (indexed, for ordering + TTL sweeps), `publisher` (top-level so the
+ * audit BFF filters server-side), and the whole `ObservationEvent` as jsonb `data`.
+ * The downstream owns the table + its retention policy; this only writes.
+ */
+export declare function supabaseObservationSink(): ObservationSink;
+/**
+ * Pick the ObservationSink the config asks for. `off` (default) → no-op; `jsonl`
+ * → local file; `supabase` → the shared table. One env var, like `getSink`.
+ */
+export declare function getObservationSink(): ObservationSink;
+/** In-memory sink, handy for tests — exposes what was recorded. */
+export declare function memoryObservationSink(seed?: ObservationEvent[]): ObservationSink & {
+    readonly recorded: ObservationEvent[];
+};
+//# sourceMappingURL=observationsink.d.ts.map

package/dist/observationsink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observationsink.d.ts","sourceRoot":"","sources":["../src/observationsink.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAEpE,8DAA8D;AAC9D,wBAAgB,mBAAmB,IAAI,eAAe,CAMrD;AAED,sEAAsE;AACtE,wBAAgB,oBAAoB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,eAAe,CAQnE;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,IAAI,eAAe,CAkBzD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CASpD;AAED,mEAAmE;AACnE,wBAAgB,qBAAqB,CAAC,IAAI,GAAE,gBAAgB,EAAO,GAAG,eAAe,GAAG;IACtF,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CACvC,CAQA"}

package/dist/observationsink.js

@@ -0,0 +1,83 @@
+/**
+ * ObservationSink implementations — the audit/observability plane's write side.
+ * A sibling of `eventsink.ts`, but for the *negative space* the settlement ledger
+ * never sees: crawlers served free, agents denied at the 402, agents that paid.
+ *
+ * The default is `off` (a no-op): the open core emits nothing unless a deploy
+ * opts in, so the gate's "humans read free at zero added cost" promise holds and
+ * no observation data accumulates without intent. A multi-tenant embedder
+ * (the control plane) sets OBSERVATIONS_BACKEND=supabase to stream observations into
+ * its own audit table — exactly how settlement events already flow gate → cloud.
+ */
+import { appendFile, mkdir } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { getConfig } from "./config.js";
+import { supabaseRest } from "./supabase.js";
+/** Records nothing. The default — observability is opt-in. */
+export function noopObservationSink() {
+    return {
+        async record() {
+            /* intentionally empty */
+        },
+    };
+}
+/** Append-only JSONL file (dev / single-box). Mirrors `jsonlSink`. */
+export function jsonlObservationSink(path) {
+    const file = resolve(path ?? getConfig().OBSERVATIONS_PATH);
+    return {
+        async record(observation) {
+            await mkdir(dirname(file), { recursive: true });
+            await appendFile(file, JSON.stringify(observation) + "\n", "utf8");
+        },
+    };
+}
+/**
+ * Supabase-backed sink. One row per observation: `id` (primary key, idempotent
+ * retry), `at` (indexed, for ordering + TTL sweeps), `publisher` (top-level so the
+ * audit BFF filters server-side), and the whole `ObservationEvent` as jsonb `data`.
+ * The downstream owns the table + its retention policy; this only writes.
+ */
+export function supabaseObservationSink() {
+    const table = getConfig().SUPABASE_OBSERVATIONS_TABLE;
+    return {
+        async record(observation) {
+            await supabaseRest(`/rest/v1/${table}?on_conflict=id`, {
+                method: "POST",
+                headers: { Prefer: "resolution=ignore-duplicates" },
+                body: JSON.stringify([
+                    {
+                        id: observation.id,
+                        at: observation.at,
+                        publisher: observation.publisherId ?? null,
+                        data: observation,
+                    },
+                ]),
+            });
+        },
+    };
+}
+/**
+ * Pick the ObservationSink the config asks for. `off` (default) → no-op; `jsonl`
+ * → local file; `supabase` → the shared table. One env var, like `getSink`.
+ */
+export function getObservationSink() {
+    switch (getConfig().OBSERVATIONS_BACKEND) {
+        case "supabase":
+            return supabaseObservationSink();
+        case "jsonl":
+            return jsonlObservationSink();
+        default:
+            return noopObservationSink();
+    }
+}
+/** In-memory sink, handy for tests — exposes what was recorded. */
+export function memoryObservationSink(seed = []) {
+    const recorded = [...seed];
+    return {
+        recorded,
+        async record(observation) {
+            recorded.push(observation);
+        },
+    };
+}
+//# sourceMappingURL=observationsink.js.map

package/dist/observationsink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observationsink.js","sourceRoot":"","sources":["../src/observationsink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAG7C,8DAA8D;AAC9D,MAAM,UAAU,mBAAmB;IACjC,OAAO;QACL,KAAK,CAAC,MAAM;YACV,yBAAyB;QAC3B,CAAC;KACF,CAAC;AACJ,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,oBAAoB,CAAC,IAAa;IAChD,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,SAAS,EAAE,CAAC,iBAAiB,CAAC,CAAC;IAC5D,OAAO;QACL,KAAK,CAAC,MAAM,CAAC,WAAW;YACtB,MAAM,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAChD,MAAM,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC;QACrE,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB;IACrC,MAAM,KAAK,GAAG,SAAS,EAAE,CAAC,2BAA2B,CAAC;IACtD,OAAO;QACL,KAAK,CAAC,MAAM,CAAC,WAAW;YACtB,MAAM,YAAY,CAAC,YAAY,KAAK,iBAAiB,EAAE;gBACrD,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE,EAAE,MAAM,EAAE,8BAA8B,EAAE;gBACnD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;oBACnB;wBACE,EAAE,EAAE,WAAW,CAAC,EAAE;wBAClB,EAAE,EAAE,WAAW,CAAC,EAAE;wBAClB,SAAS,EAAE,WAAW,CAAC,WAAW,IAAI,IAAI;wBAC1C,IAAI,EAAE,WAAW;qBAClB;iBACF,CAAC;aACH,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB;IAChC,QAAQ,SAAS,EAAE,CAAC,oBAAoB,EAAE,CAAC;QACzC,KAAK,UAAU;YACb,OAAO,uBAAuB,EAAE,CAAC;QACnC,KAAK,OAAO;YACV,OAAO,oBAAoB,EAAE,CAAC;QAChC;YACE,OAAO,mBAAmB,EAAE,CAAC;IACjC,CAAC;AACH,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,qBAAqB,CAAC,OAA2B,EAAE;IAGjE,MAAM,QAAQ,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;IAC3B,OAAO;QACL,QAAQ;QACR,KAAK,CAAC,MAAM,CAAC,WAAW;YACtB,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC7B,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/publisher.d.ts

@@ -0,0 +1,209 @@
+/**
+ * The publisher-resolution seam.
+ *
+ * One `PublisherConfig` is everything the gate needs to serve a request for the
+ * protected publisher: where to proxy, what to charge, who to pay, how to identify
+ * itself when it signs receipts, and the secret it uses to report earnings back.
+ *
+ * A `PublisherResolver` maps the gate's inbound `Host` to that config. The gate core
+ * is single-tenant: the reference resolver (`envPublisherResolver`, in the tollgate
+ * package) builds one publisher from env and answers EVERY host with it. The
+ * resolver is an interface only so a downstream service can front a different
+ * publisher by injecting its own — without forking this core. Dependency points
+ * one way: a resolver impl may depend on this interface; this interface depends on
+ * nothing about how the config is sourced.
+ */
+import type { CreditsResolver, TollKind, Usdc, WalletAddress } from "./types.ts";
+/**
+ * A settlement leg beyond the primary author payment — a secondary, direct
+ * buyer→recipient transfer attached to a toll. Each leg settles as its OWN x402
+ * authorization (its own `payTo`, `amount`, nonce): never pooled, never routed
+ * through a gate-held wallet, and **additive** — attaching a leg never reduces the
+ * author's amount. The protocol assigns `role` no meaning; it is an opaque label
+ * the ledger and dashboards group by (e.g. a co-author split, or a downstream
+ * resolver's own secondary payee). The single-tenant core attaches none.
+ */
+export interface PayoutLeg {
+    /** Opaque grouping label for the ledger/dashboard. No protocol meaning. */
+    role: string;
+    /** Direct recipient of this leg — a distinct buyer→payTo transfer. */
+    payTo: WalletAddress;
+    /** Atomic micro-USDC, integer string. Added on top of the author price. */
+    amount: string;
+}
+/**
+ * Per-publisher crawler policy — the tri-state surface a control plane stores.
+ * UA fragments, matched case-insensitively as substrings (same mechanics as
+ * `seoAllowlist`). Everything unlisted is CHARGED (the stock toll — absence of
+ * this field is byte-identical to today). Fragments are spoofable; verified
+ * crawler identity (Web Bot Auth) is a later hardening that swaps the matcher,
+ * not this shape.
+ */
+export interface CrawlerPolicy {
+    /** Fragments that read FREE. Merged with the deprecated `seoAllowlist`. */
+    allow: string[];
+    /**
+     * Fragments REFUSED outright on gateable routes — 403 even if the caller
+     * presents payment. Checked before classification, so payment intent can
+     * never buy past a block. Wins over `allow` on overlap (fail-safe).
+     */
+    block: string[];
+    /**
+     * Fragments the publisher explicitly CHARGES. The classifier already tolls
+     * agents it recognizes (known-agent UA or declared intent); this list extends
+     * that recognition to crawlers the conservative default would let read free
+     * (browser-shaped or ambiguous UAs). Precedence: block > allow > charge.
+     * Absent → recognition is the classifier's default set, unchanged.
+     */
+    charge?: string[];
+}
+export interface PublisherConfig {
+    /**
+     * Stable identifier for this publisher; tags attributed events and logs. The
+     * single-tenant default uses `"default"`.
+     */
+    id: string;
+    /** The publisher origin the gate reverse-proxies article requests to. */
+    originUrl: string;
+    /**
+     * Path prefixes (no leading slash, e.g. `["essays", "posts"]`) whose articles
+     * are gateable. A request outside every prefix passes straight through, free.
+     */
+    articlePrefixes: string[];
+    /**
+     * Base price for a single read, in whole USDC. A citation is priced up from
+     * this (see the tollgate's `quote`). Branded `Usdc` so it can't be mixed with a
+     * raw number in money math.
+     */
+    price: Usdc;
+    /**
+     * Citation price as a multiple of `price` (a citation has downstream reach, so
+     * it's typically priced up). Both kinds resolve to the same payees; only the
+     * amount differs. 1 prices a citation the same as a read. The single-tenant
+     * default sources this from `CITATION_MULTIPLIER`.
+     */
+    citationMultiplier: number;
+    /**
+     * Slug → credits graph: who gets paid for this article, and in what shares.
+     * THE publisher-agnostic seam (see `CreditsResolver`). An HTTP API, a static
+     * fixture, or a database — the gate doesn't care.
+     */
+    credits: CreditsResolver;
+    /**
+     * issuer === audience for Citation License Tokens minted on this publisher's
+     * behalf (e.g. `naulon:<host>`). Scoping licenses to the publisher identity is
+     * what stops a receipt minted for one publisher from unlocking another.
+     */
+    licenseIdentity: string;
+    /**
+     * HMAC secret for the settlement emit to this publisher's earnings ledger.
+     * Undefined leaves the emit dark — the gate still tolls and serves; it just
+     * doesn't report earnings. (Keeps the no-creds mock loop working, per the hard
+     * rule that the loop must run with no secrets.)
+     */
+    settlementSecret?: string;
+    /**
+     * Static per-tenant credential the gate presents to the origin on every proxied
+     * fetch, as `X-Naulon-Origin-Auth: <value>`, so an origin behind its own bot/rate
+     * edge can recognize fleet traffic and skip challenging it. Undefined = origin
+     * requests unauthenticated (default; fine for origins with no edge, or that
+     * allowlist the fleet by IP instead). Sent ONLY when originUrl is https — never
+     * leak a bearer over cleartext.
+     */
+    originAuthSecret?: string;
+    /**
+     * Verified search / discovery crawler UA fragments that read FREE for this
+     * publisher — the SEO allowlist. A request whose user-agent contains one of
+     * these is classified human (a discovery read), so a publisher's indexing is
+     * never tolled into a deindex. Honored by `classify` ahead of the known-agent
+     * list, matched case-insensitively. Undefined leaves only the classifier's
+     * global defaults in effect; the single-tenant resolver leaves it unset.
+     */
+    seoAllowlist?: string[];
+    /**
+     * Tri-state crawler policy (allow / charge-by-default / block). Unset — the
+     * single-tenant default — leaves only `seoAllowlist` + classifier defaults in
+     * effect, byte-identical to before this field existed.
+     */
+    crawlerPolicy?: CrawlerPolicy;
+    /**
+     * What the toll covers. Absent / {mode:"prefixes"} → the stock articlePrefixes
+     * matcher (byte-identical). {mode:"site"} → every path tolls, slug = the full
+     * decoded pathname; discovery surfaces (robots/sitemap/feeds/favicon), static
+     * assets, and gate control routes are hard-excluded regardless — tolling
+     * discovery would starve the catalog agents buy from. excludePrefixes adds
+     * publisher-chosen free sections on top (no leading slash, like articlePrefixes).
+     */
+    gateScope?: {
+        mode: "prefixes";
+    } | {
+        mode: "site";
+        excludePrefixes: string[];
+    };
+    /**
+     * Optional hook: additional settlement legs for a priced toll, beyond the author
+     * payment. Given the resolved `price` (whole USDC) and `kind`, return any extra
+     * direct buyer→recipient legs to settle alongside the author. Each is additive
+     * (the author leg is unaffected) and settled as its own authorization. Leaving
+     * this unset — the single-tenant default — yields no extra legs, so the 402 and
+     * the settle path are byte-identical to a plain single-author toll. A downstream
+     * resolver (e.g. a multi-tenant control plane charging a secondary fee) populates
+     * it; the amount math (flat, percentage, tiered, capped — whatever) lives entirely
+     * in that resolver, never in this core.
+     */
+    extraLegs?: (price: Usdc, kind: TollKind) => PayoutLeg[];
+    /**
+     * Pay co-authors directly on-chain (split-at-source) instead of routing the whole
+     * toll to the primary author. OFF by default (and irrelevant for a single-author
+     * article): the author leg settles the FULL price to the highest-share payee and
+     * the rest of the co-author split is recorded on the event for the publisher to
+     * reconcile off-protocol — the stock behavior, byte-identical on the wire.
+     *
+     * When ON and an article has >1 payee, the gate reduces the primary's synchronous
+     * (content-gating) leg to the primary's OWN share and emits one DEFERRED leg per
+     * other co-author — each a direct buyer→co-author transfer drained on-chain like
+     * any extra leg. The buyer's total is unchanged (the price is DIVIDED, not added
+     * to); only the recipients change. This keeps a genuinely multi-author payout
+     * custody-free: no author ever holds another author's cut. Opt-in because some
+     * publishers (a publication paying its writers off-protocol) want the single
+     * recipient; the credits graph decides who, this flag decides whether on-chain.
+     */
+    coauthorSplit?: boolean;
+    /**
+     * Optional hook: the reconciliation id to stamp into the on-chain `Memo` for a
+     * priced toll (Arc only). Given the article `slug` and `kind`, return the id that
+     * ties this settlement to a citation / license for off-chain reconciliation —
+     * carried straight onto `Quote.memoId`, then keccak256'd to the indexed `bytes32`
+     * lookup key on settle (see the tollgate's `toMemoId`). Return `undefined` (or
+     * leave the hook unset) to stamp nothing: the settle path falls back to the
+     * authorization nonce and is byte-identical to the stock Gateway toll, so the
+     * single-tenant default is unaffected. The open-core gate never INVENTS an id —
+     * a downstream control plane owns the format,
+     * exactly like `extraLegs` owns the secondary-leg math.
+     */
+    memoId?: (ctx: {
+        slug: string;
+        kind: TollKind;
+    }) => string | undefined;
+    /**
+     * Publisher is paused (e.g. a billing lapse upstream) — serve the origin straight
+     * through, FREE and untolled, instead of darking the site. Suspension must never
+     * turn a live publisher's readers away with an error; the gate simply stops
+     * earning until it's lifted. A resolver that has no paused state leaves this unset
+     * (false), and the gate tolls normally. Distinct from an UNKNOWN host (resolver
+     * returns undefined → the gate's not-served response): a known-but-paused
+     * publisher still has an origin to serve.
+     */
+    suspended?: boolean;
+}
+export interface PublisherResolver {
+    /**
+     * Resolve the gate's inbound `Host` to the publisher it fronts. The
+     * single-tenant default ignores `host` and returns its one config for every
+     * request; a DB-backed impl looks the host up and may cache. Return `undefined`
+     * for a host this resolver does not recognize — the gate decides how to respond
+     * to an unknown host (it must not leak another publisher's config or misroute).
+     */
+    resolve(host: string): Promise<PublisherConfig | undefined>;
+}
+//# sourceMappingURL=publisher.d.ts.map

package/dist/publisher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher.d.ts","sourceRoot":"","sources":["../src/publisher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEjF;;;;;;;;GAQG;AACH,MAAM,WAAW,SAAS;IACxB,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,sEAAsE;IACtE,KAAK,EAAE,aAAa,CAAC;IACrB,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,2EAA2E;IAC3E,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB;;;;OAIG;IACH,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,yEAAyE;IACzE,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;OAIG;IACH,KAAK,EAAE,IAAI,CAAC;IACZ;;;;;OAKG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,OAAO,EAAE,eAAe,CAAC;IACzB;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAC/E;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,KAAK,SAAS,EAAE,CAAC;IACzD;;;;;;;;;;;;;;;OAeG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,QAAQ,CAAA;KAAE,KAAK,MAAM,GAAG,SAAS,CAAC;IACvE;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAAC;CAC7D"}

package/dist/publisher.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=publisher.js.map

package/dist/publisher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher.js","sourceRoot":"","sources":["../src/publisher.ts"],"names":[],"mappings":""}

package/dist/settlementEmit.d.ts

@@ -0,0 +1,31 @@
+/**
+ * naulon → publisher settlement emit (the producer side of wire #3).
+ *
+ * After an x402 paid read settles on-chain, naulon reports it to the publisher's
+ * earnings ledger: POST ${ORIGIN_URL}/api/credits/settlement, HMAC-signed. The
+ * publisher's ledger is canonical; its author dashboard reads from these events,
+ * never from scraping chain balance. The request shape + signature recipe are
+ * specified by `buildSettlementBody` / `signSettlement` below.
+ *
+ * This module is PURE: it maps an AttributedEvent into the publisher's request shape and
+ * signs it. No fetch, no ambient clock — the caller passes the timestamp and
+ * owns delivery/retry (tollgate/src/settlementSink.ts). That keeps the money
+ * math and the signature recipe unit-testable offline.
+ */
+import { type TieBreak } from "./attribution.ts";
+import type { AttributedEvent } from "./types.ts";
+import { signSettlement, type SettlementBody } from "@naulon/sdk";
+export { signSettlement };
+export type { SettlementBody, SettlementSplit, SignedSettlement } from "@naulon/sdk";
+/**
+ * Map a settled AttributedEvent into IA's settlement shape.
+ *
+ * Invariants this guarantees (IA rejects a violation):
+ *  - Σ splits[].amount === grossAmount   (dust-free, via splitMicro)
+ *  - exactly one split is `primary: true`, and it is the on-chain recipient
+ *    (the largest-share payee — mirrors x402.ts `primaryPayee`)
+ *  - eventId === event.id (the stable, persisted UUID / license jti) so an
+ *    at-least-once retry carries the same id and IA dedupes it.
+ */
+export declare function buildSettlementBody(event: AttributedEvent, chainId: number, tieBreak?: TieBreak): SettlementBody;
+//# sourceMappingURL=settlementEmit.d.ts.map

package/dist/settlementEmit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settlementEmit.d.ts","sourceRoot":"","sources":["../src/settlementEmit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,YAAY,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAwB,MAAM,aAAa,CAAC;AAOxF,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAMrF;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,QAAmB,GAC5B,cAAc,CAiChB"}

package/dist/settlementEmit.js

@@ -0,0 +1,65 @@
+/**
+ * naulon → publisher settlement emit (the producer side of wire #3).
+ *
+ * After an x402 paid read settles on-chain, naulon reports it to the publisher's
+ * earnings ledger: POST ${ORIGIN_URL}/api/credits/settlement, HMAC-signed. The
+ * publisher's ledger is canonical; its author dashboard reads from these events,
+ * never from scraping chain balance. The request shape + signature recipe are
+ * specified by `buildSettlementBody` / `signSettlement` below.
+ *
+ * This module is PURE: it maps an AttributedEvent into the publisher's request shape and
+ * signs it. No fetch, no ambient clock — the caller passes the timestamp and
+ * owns delivery/retry (tollgate/src/settlementSink.ts). That keeps the money
+ * math and the signature recipe unit-testable offline.
+ */
+import { primaryPayee } from "./attribution.js";
+import { splitMicro } from "./attribution.js";
+import { signSettlement } from "@naulon/sdk";
+// The settlement WIRE CONTRACT (the body shape + the HMAC signer) now lives in
+// @naulon/sdk — the verify side (verifySettlement) mirrors it from the same
+// source. Re-exported so existing `@naulon/shared` importers are unchanged.
+// `buildSettlementBody` below stays here: it consumes the gate-internal
+// AttributedEvent + attribution math, which are not contract surface.
+export { signSettlement };
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+const MICRO = 1_000_000;
+/**
+ * Map a settled AttributedEvent into IA's settlement shape.
+ *
+ * Invariants this guarantees (IA rejects a violation):
+ *  - Σ splits[].amount === grossAmount   (dust-free, via splitMicro)
+ *  - exactly one split is `primary: true`, and it is the on-chain recipient
+ *    (the largest-share payee — mirrors x402.ts `primaryPayee`)
+ *  - eventId === event.id (the stable, persisted UUID / license jti) so an
+ *    at-least-once retry carries the same id and IA dedupes it.
+ */
+export function buildSettlementBody(event, chainId, tieBreak = "wallet") {
+    const grossMicro = Math.round(event.amount * MICRO);
+    const allocations = splitMicro(grossMicro, event.payees);
+    // The on-chain leg pays the largest-share payee; that same wallet is `paidTo`
+    // and the one split flagged primary. Uses the shared `primaryPayee` chooser so
+    // this record names exactly the wallet x402's requirement builder paid — same
+    // tie-break, single source of truth.
+    const primaryWallet = event.payees.length ? primaryPayee(event.payees, tieBreak) : undefined;
+    const splits = allocations.map((a, i) => ({
+        authorId: a.authorId,
+        wallet: a.wallet,
+        amount: String(a.micro),
+        weight: Math.round((event.payees[i]?.share ?? 0) * 1000),
+        ...(a.wallet === primaryWallet ? { primary: true } : {}),
+    }));
+    const payer = event.payerAddress && event.payerAddress !== ZERO_ADDRESS ? event.payerAddress : null;
+    return {
+        eventId: event.id,
+        slug: event.slug,
+        txHash: event.settlementRef,
+        chainId,
+        currency: "USDC",
+        grossAmount: String(grossMicro),
+        paidTo: (primaryWallet ?? ZERO_ADDRESS),
+        payer,
+        settledAt: new Date(event.at).toISOString(),
+        splits,
+    };
+}
+//# sourceMappingURL=settlementEmit.js.map

package/dist/settlementEmit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settlementEmit.js","sourceRoot":"","sources":["../src/settlementEmit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,YAAY,EAAiB,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,EAAE,cAAc,EAA6C,MAAM,aAAa,CAAC;AAExF,+EAA+E;AAC/E,4EAA4E;AAC5E,4EAA4E;AAC5E,wEAAwE;AACxE,sEAAsE;AACtE,OAAO,EAAE,cAAc,EAAE,CAAC;AAG1B,MAAM,YAAY,GAAG,4CAA4C,CAAC;AAElE,MAAM,KAAK,GAAG,SAAS,CAAC;AAExB;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAsB,EACtB,OAAe,EACf,WAAqB,QAAQ;IAE7B,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC;IACpD,MAAM,WAAW,GAAG,UAAU,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAEzD,8EAA8E;IAC9E,+EAA+E;IAC/E,8EAA8E;IAC9E,qCAAqC;IACrC,MAAM,aAAa,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAE7F,MAAM,MAAM,GAAsB,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QAC3D,QAAQ,EAAE,CAAC,CAAC,QAAQ;QACpB,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;QACvB,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;QACxD,GAAG,CAAC,CAAC,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC,CAAE,EAAE,OAAO,EAAE,IAAI,EAAY,CAAC,CAAC,CAAC,EAAE,CAAC;KACpE,CAAC,CAAC,CAAC;IAEJ,MAAM,KAAK,GACT,KAAK,CAAC,YAAY,IAAI,KAAK,CAAC,YAAY,KAAK,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC;IAExF,OAAO;QACL,OAAO,EAAE,KAAK,CAAC,EAAE;QACjB,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,MAAM,EAAE,KAAK,CAAC,aAAa;QAC3B,OAAO;QACP,QAAQ,EAAE,MAAM;QAChB,WAAW,EAAE,MAAM,CAAC,UAAU,CAAC;QAC/B,MAAM,EAAE,CAAC,aAAa,IAAI,YAAY,CAAkB;QACxD,KAAK;QACL,SAAS,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE;QAC3C,MAAM;KACP,CAAC;AACJ,CAAC"}

package/dist/supabase.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Call the Supabase REST (PostgREST) API and return the parsed JSON body.
+ * Throws on any non-2xx so callers fail loud rather than silently losing a
+ * write. `path` is everything after the project URL, e.g.
+ * `/rest/v1/naulon_events?select=data&order=at.asc`.
+ */
+export declare function supabaseRest(path: string, init?: RequestInit): Promise<unknown>;
+//# sourceMappingURL=supabase.d.ts.map

package/dist/supabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supabase.d.ts","sourceRoot":"","sources":["../src/supabase.ts"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,WAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAkBzF"}