@veyto/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,58 @@
+# @veyto/sdk
+
+**Give an AI agent a wallet with enforceable spending rules, and get a signed receipt for
+every payment it makes.**
+
+```bash
+npm install @veyto/sdk viem
+```
+
+```ts
+import { VeytoClient, VeytoDeniedError, localSigner } from "@veyto/sdk";
+
+const veyto = new VeytoClient({
+  baseUrl: "https://sandbox.veyto.io",
+  apiKey: process.env.VEYTO_API_KEY!,
+  agentId: process.env.VEYTO_AGENT_ID!,
+  rail: "eip155:84532",          // Base Sepolia
+  currency: "USDC-6",
+  sign: localSigner(process.env.MY_WALLET_KEY!),   // your key — stays in YOUR process
+});
+
+// $1 per payment, $5 per day, 20 payments an hour
+await veyto.setPolicy(agentId, "1000000", "5000000", 20);
+
+try {
+  const res = await veyto.payingFetch("https://some-service/premium/data");
+} catch (e) {
+  if (e instanceof VeytoDeniedError) {
+    console.log("Blocked:", e.reason);   // a guardrail did its job; no money moved
+  }
+}
+```
+
+## Your key stays yours
+
+Veyto is **non-custodial**. For a non-custodial agent the API returns *unsigned* EIP-3009
+material and `localSigner` signs it in your process. Only the signature goes back. There is
+no route that accepts a private key.
+
+## Blocked is not an error
+
+`VeytoDeniedError` means a limit stopped the payment and **nothing moved** — not reserved,
+not signed, not settled. Treat it differently from a thrown exception: one is an answer, the
+other is a problem.
+
+## What it does
+
+`payingFetch` · `createAgent` · `setPolicy` · `freeze` / `unfreeze` · `listAgents` ·
+`getAgent` · `getPolicy` · `getWallet` · `listIntents` · `getIntent` · `listReceipts` ·
+`getReceipt`.
+
+Full documentation: **[docs.veyto.io](https://docs.veyto.io)**.
+
+## Beta
+
+Base Sepolia and test USDC only. No mainnet. The API may change without ceremony.
+
+Copyright 2026 Veyto. Licensed under the Apache License, Version 2.0 — see [LICENSE](./LICENSE).

package/dist/client.d.ts

@@ -0,0 +1,398 @@
+import type { SignCallback } from "./localSigner.js";
+export interface VeytoClientConfig {
+    baseUrl: string;
+    apiKey: string;
+    agentId: string;
+    rail: string;
+    /**
+     * Hash the delivered payload and report it on settle, so the receipt binds a
+     * claim about WHAT arrived. Off by default: it buffers the whole body (double
+     * memory on a large download). Veyto records it as CALLER-ASSERTED — it is
+     * non-repudiation, not proof Veyto inspected the goods.
+     */
+    attestGoods?: boolean;
+    /**
+     * Extra headers sent on every call to the Veyto API (never to the paid
+     * resource — that request is the caller's own).
+     *
+     * Exists because a hosted Veyto can sit behind an edge gateway that
+     * authenticates the CALLER before the request ever reaches the API. The
+     * sandbox does: Cloudflare Access checks a service token, and without those
+     * headers an agent gets a 302 to a human login page it can never complete.
+     * That is two independent locks by design — the gateway decides who may
+     * reach the API at all, Veyto decides what they may spend — so the SDK has
+     * to be able to carry the first one.
+     *
+     *   extraHeaders: {
+     *     "CF-Access-Client-Id": process.env.CF_ACCESS_CLIENT_ID!,
+     *     "CF-Access-Client-Secret": process.env.CF_ACCESS_CLIENT_SECRET!,
+     *   }
+     */
+    extraHeaders?: Record<string, string>;
+    /**
+     * Why this agent spends — cost centre, project, client. Sent on every payment
+     * and SIGNED into the receipt. Optional, but the one accounting field that
+     * cannot be added later (ADR-0020).
+     */
+    purpose?: string;
+    currency: string;
+    fetchImpl?: typeof fetch;
+    sign?: SignCallback;
+}
+/** A receipt as the API returns it: the signed material, and what we have learned since. */
+export interface ReceiptRecord {
+    receipt_id: string;
+    intent_id: string;
+    created_at: string;
+    /** Exactly what was signed. Verify over `body_canonical` — it is already JSON; parse it yourself. */
+    signed: {
+        body_canonical: string;
+        signature: string;
+    };
+    /** Derived from the ledger, NOT signed. `signed: false` is stated in the payload, not implied. */
+    finality: {
+        state: string;
+        observed_at: string | null;
+        evidence: unknown;
+        signed: false;
+        source: string;
+    };
+}
+export interface ReceiptPage {
+    items: ReceiptRecord[];
+    /** Pass back as `before` to page. Null when the last page has been reached. */
+    next_before: string | null;
+}
+/**
+ * An agent's GOVERNED FINANCIAL STATE — deliberately not a balance.
+ *
+ * ⚠️ Veyto records what it governed; it does not hold or observe wallet funds. Every figure
+ * under `governed_exposure` is an amount recorded moving OUT under policy, and
+ * `policy_headroom` is a permission limit. Neither is money available. There is no balance
+ * field here because there is no balance Veyto can honestly report: the ledger posts
+ * `agent_wallet -N / external +N` on settlement and has no deposit postings at all.
+ */
+export interface WalletState {
+    agent_id: string;
+    wallet_account_id: string | null;
+    currency: string | null;
+    /** Other wallet accounts this agent owns that these figures do NOT cover. Empty today. */
+    wallet_accounts_not_summarized: Array<{
+        wallet_account_id: string;
+        currency: string;
+    }>;
+    /** Currencies present on this wallet that these figures do NOT cover. Empty today. */
+    currencies_not_summarized: string[];
+    custody_mode: "tier0" | "tier1" | "noncustodial";
+    /** The address this agent pays FROM. An identifier — read it on chain yourself for funds. */
+    payer_address: string;
+    agent_status?: "active" | "frozen";
+    governed_exposure: GovernedExposure | null;
+    reservations: Reservations | null;
+    policy_headroom: WalletPolicyHeadroom | null;
+    not_reported: NotReported;
+}
+export interface GovernedExposure {
+    /** Always "outflow": these are amounts recorded LEAVING, not holdings. */
+    direction: "outflow";
+    /**
+     * The ledger's `final` class. **`null` means CANNOT BE ANSWERED** — never zero. The account
+     * holds at least one disputed entry, and a contradicted book has no trustworthy total;
+     * `disputed.entry_count` says how many. Treating null as 0 would manufacture the certainty
+     * this field exists to withhold.
+     *
+     * This said "chain-verified" and that promised more than the ledger defines: the final class
+     * also folds entries to which settlement finality does not apply. Every entry today is a
+     * settlement, so the figure IS chain-verified in fact — but the name follows the definition.
+     */
+    finalized_outflow_minor: string | null;
+    /** Recorded but not independently confirmed on chain. Money may well have moved. */
+    provisional_exposure_minor: string | null;
+    adjudicated_minor: string | null;
+    disputed: {
+        entry_count: number;
+        /** True when `entries` was capped and does not list every disputed entry. */
+        entries_truncated: boolean;
+        /** One row per ENTRY, enumerated and never summed. Each id resolves through `getIntent`. */
+        entries: Array<{
+            entry_id: string;
+            intent_id: string;
+            amount_minor: string;
+            /** Per entry, by its own sign — a positive disputed position is not forced to "outflow". */
+            direction: "outflow" | "inflow";
+        }>;
+    };
+    /**
+     * Non-null only if a net INFLOW ever appears — no posting produces one today.
+     *
+     * Reported PER CLASS and never summed: mixing evidence levels into one number is exactly
+     * what the rest of this response refuses to do. `null` when there is no inflow at all.
+     */
+    unexpected_net_inflow: null | {
+        /**
+         * Named `finalized_minor` deliberately: A24 reserves the shorter balance name for a figure
+         * that must always travel with its disputed count, and this is an inflow, not a balance.
+         */
+        finalized_minor: string | null;
+        provisional_minor: string | null;
+        adjudicated_minor: string | null;
+    };
+}
+/** Every status a reservation can carry — none is dropped, so nothing tied up goes unseen. */
+export interface Reservations {
+    pending_minor: string;
+    pending_count: number;
+    committed_minor: string;
+    committed_count: number;
+    expired_minor: string;
+    expired_count: number;
+    released_minor: string;
+    released_count: number;
+}
+export interface WalletPolicyHeadroom {
+    /** Always "policy_permission_not_funds" — it travels with the number on purpose. */
+    basis: "policy_permission_not_funds";
+    /** How much more this agent is PERMITTED to spend today. Not money available. */
+    remaining_policy_headroom_minor: string | null;
+    cap_per_day_minor: string;
+    spent_today_minor: string;
+    as_of: string;
+}
+/** What Veyto declines to claim, stated rather than left to inference. */
+export interface NotReported {
+    funds_held_minor: null;
+    spendable_minor: null;
+    reason: string;
+}
+/**
+ * One decision record: what the agent attempted, what Veyto decided, and — where the attempt was
+ * DENIED by policy — why.
+ *
+ * This is the audit trail's unit. Receipts cover the payments that happened; this covers every
+ * attempt, including the ones that were refused. For a governed payer the refusals are the point.
+ */
+export interface IntentRecord {
+    intent_id: string;
+    agent_id: string;
+    /** Microsecond precision, formatted by the database — never routed through a JS `Date`. */
+    created_at: string;
+    updated_at: string;
+    attempt: IntentAttempt;
+    decision: IntentDecision;
+    evidence: IntentEvidence;
+}
+/** What the agent asked for, exactly as recorded. */
+export interface IntentAttempt {
+    amount_minor: string;
+    max_fees_minor: string;
+    currency: string;
+    payee: string;
+    rail: string;
+    resource_url: string | null;
+    purpose: string | null;
+}
+export interface IntentDecision {
+    /** The recorded lifecycle status, passed through. */
+    status: "requested" | "denied" | "approved" | "executing" | "settled" | "failed" | "uncertain" | "expired";
+    /**
+     * The recorded policy reason, **verbatim** — one of "exceeds daily cap",
+     * "exceeds per-payment cap", "exceeds hourly velocity", "amount must be positive",
+     * "max_fees negative".
+     *
+     * ⚠️ Non-null ONLY where the record was DENIED by policy. This says nothing about whether an
+     * evaluation happened for any other record — it says only that no policy denial reason is
+     * carried. The pay path records an internal string in the same column for a signing failure,
+     * and that is deliberately never exposed here.
+     */
+    reason: string | null;
+    /** Always `"policy_evaluation"` when a reason is present — it travels with the number. */
+    reason_basis: "policy_evaluation" | null;
+    /**
+     * Why no reason is given, stated rather than left to inference.
+     *
+     * Scoped to the DENIAL, deliberately. An approval is a recorded decision too, and a
+     * `requested` record may never have been evaluated at all, so any wording that classified
+     * evaluation would contradict the evidence in one direction or the other. This says only that
+     * the record carries no policy denial reason.
+     */
+    reason_not_recorded: "none_recorded" | "not_a_policy_denial" | null;
+}
+/**
+ * References, never inferences.
+ *
+ * ⚠️ `receipt_id: null` means only "no receipt row is linked" — it is NOT evidence the payment
+ * did not happen. A `settled` status does not imply a receipt exists; measured on production,
+ * some settled intents have neither a receipt nor a verdict. For finality, read the receipt.
+ */
+export interface IntentEvidence {
+    receipt_id: string | null;
+    /**
+     * A verdict record is present **now**. Not "a verdict was issued": verdict records are not
+     * append-only, so absence proves only absence.
+     */
+    verdict_present: boolean;
+}
+export interface IntentPage {
+    items: IntentRecord[];
+    next_before: string | null;
+}
+/** An agent as the API returns it. Identity and freeze state — never a key, never a balance. */
+export interface AgentRecord {
+    id: string;
+    name: string;
+    custody_mode: "tier0" | "tier1" | "noncustodial";
+    /** The address this agent pays FROM. An identifier, not a balance. */
+    payer_address: string;
+    status: "active" | "frozen";
+    created_at: string;
+}
+export interface AgentPage {
+    items: AgentRecord[];
+    /** Pass back as `before` to page. Null when the last page has been reached. */
+    next_before: string | null;
+}
+/** The caps in force on an agent. Immutable per version — a change is a new version. */
+export interface PolicyInForce {
+    version: number;
+    cap_per_payment_minor: string;
+    cap_per_day_minor: string;
+    velocity_max_per_hour: number;
+}
+/**
+ * What the agent has spent and how much room is left.
+ *
+ * ⚠️ A SNAPSHOT, NOT A GUARANTEE. Read without the wallet lock the enforcement path takes, so
+ * a concurrent payment may already have consumed some of what is reported here. Plan with it;
+ * never treat it as a promise that the next payment will be approved — only the reservation
+ * itself decides that, and it decides under a lock this read deliberately does not take.
+ */
+export interface SpendState {
+    wallet_account_id: string;
+    currency: string;
+    spent_today_minor: string;
+    remaining_today_minor: string;
+    count_last_hour: number;
+    remaining_this_hour: number;
+    /**
+     * The database instant every number above was computed at — one transaction-stable
+     * moment, taken from Postgres rather than from the API process's own clock, so it
+     * cannot drift away from the data it describes.
+     */
+    as_of: string;
+}
+/** `policy` and `spend` are both null for an agent that has never been given a policy. */
+export interface PolicyState {
+    agent_id: string;
+    agent_status?: "active" | "frozen";
+    policy: PolicyInForce | null;
+    spend: SpendState | null;
+}
+/**
+ * A read that the server refused. `status` is preserved so a caller can tell a missing scope
+ * (403) from a bad key (401) from a receipt that is not theirs (404).
+ *
+ * ⚠️ 404 remains deliberately ambiguous: the API does not distinguish "no such receipt" from
+ * "not yours", because a 403 there would confirm to an enumerating caller that an id is real.
+ * The SDK preserves that ambiguity rather than trying to be helpful about it.
+ */
+export declare class VeytoReadError extends Error {
+    readonly status: number;
+    constructor(status: number, operation: string);
+}
+export declare class VeytoDeniedError extends Error {
+    reason: string;
+    constructor(reason: string);
+}
+export declare class VeytoClient {
+    private readonly cfg;
+    constructor(cfg: VeytoClientConfig);
+    private get f();
+    private authHeaders;
+    payingFetch(url: string, init?: RequestInit): Promise<Response>;
+    private decodePayment;
+    /**
+     * Parse the payee's settlement response header.
+     *
+     * Distinguishes ABSENT from MALFORMED: a genuine settlement whose header failed to
+     * parse is not the same fact as a payee that sent none, and collapsing them would
+     * hide a real payment behind a parse error.
+     */
+    private settlementClaimFrom;
+    createAgent(name: string, custodyMode: "tier0" | "tier1" | "noncustodial", payerAddress: string): Promise<string>;
+    setPolicy(agentId: string, capPerPaymentMinor: string, capPerDayMinor: string, velocityMaxPerHour: number): Promise<void>;
+    /**
+     * Stop an agent spending, immediately.
+     *
+     * ⚠️ THE RESPONSE IS CHECKED, WHICH IT PREVIOUSLY WAS NOT. This was one of only two methods
+     * with no `!r.ok` guard, so a freeze that failed — wrong scope, frozen account, network —
+     * returned silently as though it had worked. A kill switch that lies about having fired is
+     * worse than no kill switch, because it is believed.
+     */
+    freeze(agentId: string, reason: string): Promise<void>;
+    /**
+     * Let a frozen agent spend again.
+     *
+     * The API has had this since the freeze primitive shipped — the two are generated by the same
+     * loop behind the same `policies:admin` scope. Only the SDK was missing it, which made freeze
+     * a one-way door for anyone who never dropped to raw HTTP.
+     */
+    unfreeze(agentId: string, reason: string): Promise<void>;
+    /**
+     * This account's receipts, newest first.
+     *
+     * `finality` is Veyto's CURRENT belief about on-chain settlement and is deliberately NOT
+     * part of the signed body — it is knowledge acquired after the receipt was signed, and a
+     * signature cannot learn things. Verify `signed`; read `finality`.
+     */
+    listReceipts(opts?: {
+        limit?: number;
+        before?: string;
+    }): Promise<ReceiptPage>;
+    /** One receipt. A receipt belonging to another account is indistinguishable from one that does not exist. */
+    getReceipt(receiptId: string): Promise<ReceiptRecord>;
+    /** What happened to one payment: status, submission, its receipt id, and current finality. */
+    getIntent(intentId: string): Promise<Record<string, unknown>>;
+    /** This account's agents, newest first. */
+    listAgents(opts?: {
+        limit?: number;
+        before?: string;
+    }): Promise<AgentPage>;
+    /** One agent, including whether it is frozen. Another account's agent looks like none at all. */
+    getAgent(agentId: string): Promise<AgentRecord>;
+    /**
+     * The policy governing an agent, and how much of it is left today.
+     *
+     * Requires `policies:read`, which is deliberately NOT implied by `policies:admin`-style
+     * write access nor by `agents:read`: checking your own headroom must not require the
+     * authority to raise your own ceiling.
+     */
+    getPolicy(agentId: string): Promise<PolicyState>;
+    /**
+     * An agent's governed financial state: what Veyto recorded moving out (by finality), what is
+     * currently reserved, and the policy headroom — with an explicit statement of what is NOT
+     * reported.
+     *
+     * ⚠️ There is no balance here, and that is deliberate. Veyto's ledger records governed
+     * outflow, not funds held; for money actually available, read the payer address on chain.
+     * `governed_exposure.finalized_outflow_minor === null` means the figure CANNOT BE ANSWERED
+     * because a disputed entry exists — never treat it as zero.
+     */
+    getWallet(agentId: string): Promise<WalletState>;
+    /**
+     * The decision history: what this account's agents attempted, and what Veyto decided.
+     *
+     * The answer to "why did my agent stop paying?" — which, before this existed, could not be
+     * asked at all: the intent route was POST-only and reading one record required an id you were
+     * never given a way to discover.
+     *
+     * ⚠️ A `reason` appears only where the record was DENIED by policy. Every other record reports
+     * `reason_not_recorded: "not_a_policy_denial"` instead, which asserts nothing about whether an
+     * evaluation occurred. No receipt or finality claim is implied by any status.
+     */
+    listIntents(opts?: {
+        agentId?: string;
+        status?: IntentDecision["status"];
+        limit?: number;
+        before?: string;
+    }): Promise<IntentPage>;
+}

package/dist/client.js

@@ -0,0 +1,395 @@
+// Veyto TypeScript SDK. The whole point of M1: an agent developer calls
+// `payingFetch(url)` and the governed flow happens invisibly —
+//   GET → 402 → authorize+sign via Veyto → attach payment → retry → report settle.
+// Keys stay in Veyto; the developer never touches a wallet. `fetchImpl` is
+// injectable so the flow is testable without a network.
+import { createHash, randomUUID } from "node:crypto";
+import { encodePayment } from "@veyto/x402-wire";
+/**
+ * A read that the server refused. `status` is preserved so a caller can tell a missing scope
+ * (403) from a bad key (401) from a receipt that is not theirs (404).
+ *
+ * ⚠️ 404 remains deliberately ambiguous: the API does not distinguish "no such receipt" from
+ * "not yours", because a 403 there would confirm to an enumerating caller that an id is real.
+ * The SDK preserves that ambiguity rather than trying to be helpful about it.
+ */
+export class VeytoReadError extends Error {
+    status;
+    constructor(status, operation) {
+        super(`${operation} failed: ${status}`);
+        this.status = status;
+        this.name = "VeytoReadError";
+    }
+}
+export class VeytoDeniedError extends Error {
+    reason;
+    constructor(reason) {
+        super(`payment denied by policy: ${reason}`);
+        this.reason = reason;
+        this.name = "VeytoDeniedError";
+    }
+}
+// x402 V2 header names as observed on the wire in the G0a S1 spike.
+const REQUIREMENTS_HEADER = "payment-required";
+const PAYMENT_HEADER = "payment-signature";
+const SETTLEMENT_HEADER = "payment-response";
+export class VeytoClient {
+    cfg;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    get f() {
+        return this.cfg.fetchImpl ?? fetch;
+    }
+    authHeaders() {
+        // extraHeaders first so the SDK's own auth/content-type always win: a typo'd
+        // "authorization" in extraHeaders must not silently replace the API key.
+        return {
+            ...(this.cfg.extraHeaders ?? {}),
+            authorization: `Bearer ${this.cfg.apiKey}`,
+            "content-type": "application/json",
+        };
+    }
+    // The governed paying fetch. Returns the resource's final Response. Throws
+    // VeytoDeniedError if policy blocks the payment (the caller's spend cap did its
+    // job); other failures surface as thrown errors or the resource's own status.
+    async payingFetch(url, init) {
+        const f = this.f;
+        const first = await f(url, init);
+        if (first.status !== 402)
+            return first; // not paywalled — nothing to govern
+        const requirementsB64 = first.headers.get(REQUIREMENTS_HEADER);
+        if (!requirementsB64)
+            throw new Error("402 response missing payment-required header");
+        // authorize + sign through Veyto (idempotency key makes retries safe)
+        const idempotencyKey = randomUUID();
+        const payRes = await f(`${this.cfg.baseUrl}/v1/pay`, {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: JSON.stringify({
+                agent_id: this.cfg.agentId,
+                rail: this.cfg.rail,
+                currency: this.cfg.currency,
+                requirements_b64: requirementsB64,
+                idempotency_key: idempotencyKey,
+                // ADR-0020: why this spend happened, declared at authorization time and
+                // signed into the receipt. Cannot be reconstructed afterwards.
+                ...(this.cfg.purpose ? { purpose: this.cfg.purpose } : {}),
+            }),
+        });
+        const pay = (await payRes.json());
+        if (pay.status === "denied")
+            throw new VeytoDeniedError(pay.reason ?? "unknown");
+        // A non-2xx from /v1/pay carries {error}, not {status}, so reading `status` gave
+        // `unexpected /v1/pay result: undefined` — which is what a developer saw when their
+        // agent was FROZEN. The refusal is the most important thing Veyto ever says; it
+        // must not arrive unreadable. Surfaced as a denial with the API's own reason.
+        if (!payRes.ok) {
+            const reason = pay.error ?? `HTTP ${payRes.status}`;
+            throw new VeytoDeniedError(reason);
+        }
+        if (!pay.intentId)
+            throw new Error(`unexpected /v1/pay result: ${pay.status}`);
+        // Resolve to a payment header + the ACTUAL amount/payee being paid — uniform
+        // across custodial (Veyto signed) and non-custodial (developer signs locally).
+        let paymentHeader;
+        let actualAmount;
+        let actualPayee;
+        if (pay.status === "approved_signed" && pay.paymentHeader) {
+            paymentHeader = pay.paymentHeader;
+            const a = this.decodePayment(paymentHeader).payload.authorization;
+            actualAmount = a.value;
+            actualPayee = a.to;
+        }
+        else if (pay.status === "approved_unsigned" && pay.eip3009 && pay.accepted && pay.resource) {
+            if (!this.cfg.sign) {
+                throw new Error("this agent is non-custodial; configure a `sign` callback (e.g. localSigner(pk))");
+            }
+            const { domain, fields } = pay.eip3009;
+            const signature = await this.cfg.sign(domain, fields);
+            const payload = {
+                x402Version: 2,
+                payload: { authorization: { ...fields }, signature },
+                resource: pay.resource,
+                accepted: pay.accepted,
+            };
+            paymentHeader = encodePayment(payload);
+            actualAmount = fields.value; // what the developer actually signed
+            actualPayee = fields.to;
+        }
+        else {
+            throw new Error(`unexpected /v1/pay result: ${pay.status}`);
+        }
+        // retry the resource request with the payment attached
+        const retryHeaders = new Headers(init?.headers);
+        retryHeaders.set(PAYMENT_HEADER, paymentHeader);
+        const paid = await f(url, { ...init, headers: retryHeaders });
+        // ── Report the outcome. Two INDEPENDENT dimensions, never collapsed ──────────
+        //
+        // The resource's HTTP status is an APPLICATION outcome the buyer observed. It says
+        // nothing about whether value moved. Once a signed EIP-3009 authorization has left
+        // this process it is a bearer credential the payee can settle until `validBefore`,
+        // so "the request failed" NEVER licenses "no payment occurred".
+        //
+        // Reporting `failed` on a non-2xx — which this did until 2026-08-16 — told Veyto
+        // "no value moved". The API then released the hold and marked the submission
+        // failed, and because the reconciler scans only settled/uncertain submissions, a
+        // real on-chain payment became invisible to reconciliation permanently. The
+        // settlement header, the one piece of proof, was discarded in exactly the case
+        // where it was the evidence.
+        //
+        // The settlement header is read ALWAYS, and is a PAYEE CLAIM — not verification.
+        // Only the reconciler's chain read can establish that value moved.
+        const settlementClaim = this.settlementClaimFrom(paid.headers.get(SETTLEMENT_HEADER));
+        // A claim only counts as PROOF if it actually asserts success and carries something
+        // shaped like a transaction hash. A payee explicitly saying `success:false`, or
+        // sending garbage where the hash goes, must not be read as "money moved" — that
+        // would be a false money-moved claim, the opposite failure to the one being fixed.
+        const txHash = settlementClaim.success === false ? undefined : settlementClaim.transaction;
+        const outcome = paid.ok ? "settled" : txHash ? "denied_after_payment" : "uncertain";
+        //  2xx + claim  → settled              (delivery observed, payee claims settled)
+        //  2xx + none   → settled, no hash     (delivery observed; nothing to reconcile)
+        //  !2xx + claim → denied_after_payment (value moved per payee; request denied)
+        //  !2xx + none  → uncertain            (UNKNOWN — the hold stays, per A9.2/SECURITY-MODEL:
+        //                                       only reconciliation releases uncertain holds)
+        // `failed` is never reported from here: this code cannot establish that no value moved.
+        // Optionally attest WHAT arrived. Off by default: hashing means buffering the
+        // whole body, which doubles memory for a large download and silently changes
+        // behavior for existing callers. The response is CLONED so the caller still
+        // gets an unread stream. Best-effort — a hashing failure must never break a
+        // payment that already succeeded.
+        let goodsDigest;
+        if (this.cfg.attestGoods && paid.ok) {
+            try {
+                const bytes = new Uint8Array(await paid.clone().arrayBuffer());
+                goodsDigest = createHash("sha256").update(bytes).digest("hex");
+            }
+            catch {
+                goodsDigest = undefined;
+            }
+        }
+        await f(`${this.cfg.baseUrl}/v1/pay/${pay.intentId}/settle`, {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: JSON.stringify({
+                outcome, tx_hash: txHash, actual_amount_minor: actualAmount, actual_payee: actualPayee,
+                ...(goodsDigest ? { goods_digest_sha256: goodsDigest } : {}),
+                // The exchange, captured as evidence (RAIL-ADAPTER-CONTRACT walkthrough #2).
+                // Bounded scalars with explicit provenance — never the bearer payment payload.
+                evidence: {
+                    resource_status: paid.status,
+                    resource_status_basis: "buyer_observed_http_status",
+                    settlement_claim_present: settlementClaim.present,
+                    settlement_claim_parsed: settlementClaim.parsed,
+                    settlement_claim_success: settlementClaim.success,
+                    settlement_claim_network: settlementClaim.network,
+                    settlement_claim_basis: "payee_response_header_unverified",
+                },
+            }),
+        }).catch(() => undefined);
+        return paid;
+    }
+    decodePayment(headerB64) {
+        return JSON.parse(Buffer.from(headerB64, "base64").toString("utf8"));
+    }
+    /**
+     * Parse the payee's settlement response header.
+     *
+     * Distinguishes ABSENT from MALFORMED: a genuine settlement whose header failed to
+     * parse is not the same fact as a payee that sent none, and collapsing them would
+     * hide a real payment behind a parse error.
+     */
+    settlementClaimFrom(header) {
+        if (!header)
+            return { present: false, parsed: false, transaction: undefined, success: undefined, network: undefined };
+        try {
+            const d = JSON.parse(Buffer.from(header, "base64").toString("utf8"));
+            return {
+                present: true,
+                parsed: true,
+                // A hash is only useful to reconciliation if it is structurally a hash.
+                // Structurally a hash, or no hash at all. A malformed value handed to the
+                // reconciler becomes a terminal `not_found` against a payment that may be real.
+                transaction: typeof d.transaction === "string" && /^0x[0-9a-fA-F]{64}$/.test(d.transaction) ? d.transaction : undefined,
+                success: typeof d.success === "boolean" ? d.success : undefined,
+                network: typeof d.network === "string" ? d.network : undefined,
+            };
+        }
+        catch {
+            return { present: true, parsed: false, transaction: undefined, success: undefined, network: undefined };
+        }
+    }
+    // ── convenience admin helpers (used by the quickstart) ──
+    async createAgent(name, custodyMode, payerAddress) {
+        const r = await this.f(`${this.cfg.baseUrl}/v1/agents`, {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: JSON.stringify({ name, custody_mode: custodyMode, payer_address: payerAddress, currency: this.cfg.currency }),
+        });
+        if (!r.ok)
+            throw new Error(`createAgent failed: ${r.status}`);
+        return (await r.json()).id;
+    }
+    async setPolicy(agentId, capPerPaymentMinor, capPerDayMinor, velocityMaxPerHour) {
+        const r = await this.f(`${this.cfg.baseUrl}/v1/agents/${agentId}/policy`, {
+            method: "PUT",
+            headers: this.authHeaders(),
+            body: JSON.stringify({ cap_per_payment_minor: capPerPaymentMinor, cap_per_day_minor: capPerDayMinor, velocity_max_per_hour: velocityMaxPerHour }),
+        });
+        if (!r.ok)
+            throw new Error(`setPolicy failed: ${r.status}`);
+    }
+    /**
+     * Stop an agent spending, immediately.
+     *
+     * ⚠️ THE RESPONSE IS CHECKED, WHICH IT PREVIOUSLY WAS NOT. This was one of only two methods
+     * with no `!r.ok` guard, so a freeze that failed — wrong scope, frozen account, network —
+     * returned silently as though it had worked. A kill switch that lies about having fired is
+     * worse than no kill switch, because it is believed.
+     */
+    async freeze(agentId, reason) {
+        const r = await this.f(`${this.cfg.baseUrl}/v1/agents/${agentId}/freeze`, {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: JSON.stringify({ reason }),
+        });
+        if (!r.ok)
+            throw new VeytoReadError(r.status, "freeze");
+    }
+    /**
+     * Let a frozen agent spend again.
+     *
+     * The API has had this since the freeze primitive shipped — the two are generated by the same
+     * loop behind the same `policies:admin` scope. Only the SDK was missing it, which made freeze
+     * a one-way door for anyone who never dropped to raw HTTP.
+     */
+    async unfreeze(agentId, reason) {
+        const r = await this.f(`${this.cfg.baseUrl}/v1/agents/${agentId}/unfreeze`, {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: JSON.stringify({ reason }),
+        });
+        if (!r.ok)
+            throw new VeytoReadError(r.status, "unfreeze");
+    }
+    // ── evidence: reading back what was signed ──
+    //
+    // A receipt you cannot fetch is not evidence, it is a log line we kept. These return the
+    // signed bytes VERBATIM so `verifyReceipt` can be run over them — by you, by your auditor,
+    // or by a counterparty who does not trust us and should not have to.
+    /**
+     * This account's receipts, newest first.
+     *
+     * `finality` is Veyto's CURRENT belief about on-chain settlement and is deliberately NOT
+     * part of the signed body — it is knowledge acquired after the receipt was signed, and a
+     * signature cannot learn things. Verify `signed`; read `finality`.
+     */
+    async listReceipts(opts = {}) {
+        const q = new URLSearchParams();
+        if (opts.limit !== undefined)
+            q.set("limit", String(opts.limit));
+        if (opts.before !== undefined)
+            q.set("before", opts.before);
+        const qs = q.toString();
+        const r = await this.f(`${this.cfg.baseUrl}/v1/receipts${qs ? `?${qs}` : ""}`, { headers: this.authHeaders() });
+        if (!r.ok)
+            throw new VeytoReadError(r.status, "listReceipts");
+        return (await r.json());
+    }
+    /** One receipt. A receipt belonging to another account is indistinguishable from one that does not exist. */
+    async getReceipt(receiptId) {
+        const r = await this.f(`${this.cfg.baseUrl}/v1/receipts/${receiptId}`, { headers: this.authHeaders() });
+        if (!r.ok)
+            throw new VeytoReadError(r.status, "getReceipt");
+        return (await r.json());
+    }
+    /** What happened to one payment: status, submission, its receipt id, and current finality. */
+    async getIntent(intentId) {
+        const r = await this.f(`${this.cfg.baseUrl}/v1/intents/${intentId}`, { headers: this.authHeaders() });
+        if (!r.ok)
+            throw new VeytoReadError(r.status, "getIntent");
+        return (await r.json());
+    }
+    // ── guardrails: reading the rules you are governed by ──
+    //
+    // Being governed by a cap you cannot read is the same problem as holding a receipt you
+    // cannot fetch. These answer "what am I allowed to spend, and how much of it is left"
+    // WITHOUT needing the authority to change the answer.
+    /** This account's agents, newest first. */
+    async listAgents(opts = {}) {
+        const q = new URLSearchParams();
+        if (opts.limit !== undefined)
+            q.set("limit", String(opts.limit));
+        if (opts.before !== undefined)
+            q.set("before", opts.before);
+        const qs = q.toString();
+        const r = await this.f(`${this.cfg.baseUrl}/v1/agents${qs ? `?${qs}` : ""}`, { headers: this.authHeaders() });
+        if (!r.ok)
+            throw new VeytoReadError(r.status, "listAgents");
+        return (await r.json());
+    }
+    /** One agent, including whether it is frozen. Another account's agent looks like none at all. */
+    async getAgent(agentId) {
+        const r = await this.f(`${this.cfg.baseUrl}/v1/agents/${agentId}`, { headers: this.authHeaders() });
+        if (!r.ok)
+            throw new VeytoReadError(r.status, "getAgent");
+        return (await r.json());
+    }
+    /**
+     * The policy governing an agent, and how much of it is left today.
+     *
+     * Requires `policies:read`, which is deliberately NOT implied by `policies:admin`-style
+     * write access nor by `agents:read`: checking your own headroom must not require the
+     * authority to raise your own ceiling.
+     */
+    async getPolicy(agentId) {
+        const r = await this.f(`${this.cfg.baseUrl}/v1/agents/${agentId}/policy`, { headers: this.authHeaders() });
+        if (!r.ok)
+            throw new VeytoReadError(r.status, "getPolicy");
+        return (await r.json());
+    }
+    /**
+     * An agent's governed financial state: what Veyto recorded moving out (by finality), what is
+     * currently reserved, and the policy headroom — with an explicit statement of what is NOT
+     * reported.
+     *
+     * ⚠️ There is no balance here, and that is deliberate. Veyto's ledger records governed
+     * outflow, not funds held; for money actually available, read the payer address on chain.
+     * `governed_exposure.finalized_outflow_minor === null` means the figure CANNOT BE ANSWERED
+     * because a disputed entry exists — never treat it as zero.
+     */
+    async getWallet(agentId) {
+        const r = await this.f(`${this.cfg.baseUrl}/v1/agents/${agentId}/wallet`, { headers: this.authHeaders() });
+        if (!r.ok)
+            throw new VeytoReadError(r.status, "getWallet");
+        return (await r.json());
+    }
+    /**
+     * The decision history: what this account's agents attempted, and what Veyto decided.
+     *
+     * The answer to "why did my agent stop paying?" — which, before this existed, could not be
+     * asked at all: the intent route was POST-only and reading one record required an id you were
+     * never given a way to discover.
+     *
+     * ⚠️ A `reason` appears only where the record was DENIED by policy. Every other record reports
+     * `reason_not_recorded: "not_a_policy_denial"` instead, which asserts nothing about whether an
+     * evaluation occurred. No receipt or finality claim is implied by any status.
+     */
+    async listIntents(opts = {}) {
+        const q = new URLSearchParams();
+        if (opts.status !== undefined)
+            q.set("status", opts.status);
+        if (opts.limit !== undefined)
+            q.set("limit", String(opts.limit));
+        if (opts.before !== undefined)
+            q.set("before", opts.before);
+        const path = opts.agentId ? `/v1/agents/${opts.agentId}/intents` : "/v1/intents";
+        const qs = q.toString();
+        const r = await this.f(`${this.cfg.baseUrl}${path}${qs ? `?${qs}` : ""}`, {
+            headers: this.authHeaders(),
+        });
+        if (!r.ok)
+            throw new VeytoReadError(r.status, "listIntents");
+        return (await r.json());
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { VeytoClient, VeytoDeniedError, VeytoReadError, type VeytoClientConfig, type ReceiptRecord, type ReceiptPage, type AgentRecord, type AgentPage, type PolicyInForce, type SpendState, type PolicyState, type WalletState, type GovernedExposure, type Reservations, type WalletPolicyHeadroom, type NotReported, type IntentRecord, type IntentAttempt, type IntentDecision, type IntentEvidence, type IntentPage } from "./client.js";
+export { localSigner, type SignCallback } from "./localSigner.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { VeytoClient, VeytoDeniedError, VeytoReadError } from "./client.js";
+export { localSigner } from "./localSigner.js";

package/dist/localSigner.d.ts

@@ -0,0 +1,4 @@
+import type { Hex } from "viem";
+import type { Eip3009Domain, Eip3009Fields } from "@veyto/x402-wire";
+export type SignCallback = (domain: Eip3009Domain, fields: Eip3009Fields) => Promise<Hex>;
+export declare function localSigner(privateKey: Hex): SignCallback;

package/dist/localSigner.js

@@ -0,0 +1,31 @@
+// Non-custodial signing helpers. A `SignCallback` decouples signing from key
+// management, so the SDK works with a raw key, a viem account, an external wallet,
+// or a customer KMS. `localSigner` is the simple raw-key case. Keys stay in the
+// developer's process; Veyto never sees them.
+import { privateKeyToAccount } from "viem/accounts";
+const EIP3009_TYPES = {
+    TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" },
+    ],
+};
+export function localSigner(privateKey) {
+    const account = privateKeyToAccount(privateKey);
+    return async (domain, fields) => account.signTypedData({
+        domain,
+        types: EIP3009_TYPES,
+        primaryType: "TransferWithAuthorization",
+        message: {
+            from: fields.from,
+            to: fields.to,
+            value: BigInt(fields.value),
+            validAfter: BigInt(fields.validAfter),
+            validBefore: BigInt(fields.validBefore),
+            nonce: fields.nonce,
+        },
+    });
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@veyto/sdk",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "viem": "^2.55.0",
+    "@veyto/x402-wire": "0.1.0"
+  },
+  "license": "Apache-2.0",
+  "description": "Veyto TypeScript SDK — give an AI agent a wallet with enforceable spending rules.",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "homepage": "https://docs.veyto.io",
+  "bugs": {
+    "email": "sandbox@veyto.io"
+  },
+  "keywords": [
+    "x402",
+    "agent",
+    "payments",
+    "eip-3009",
+    "base",
+    "usdc",
+    "spending-limits"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --passWithNoTests"
+  }
+}