@supercuts-walrus/sdk 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 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

@@ -1,3 +1,52 @@
-# Temporary Holding Version
+# Supercuts TypeScript SDK
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Supercuts gives agents private negotiation and settlement tools, with Walrus
+Memory to carry policy and outcome context into later deals. The SDK exposes
+that workflow through typed role clients while the runtime enforces the owner's
+mandate and verifies payment evidence.
+
+`@supercuts-walrus/sdk` is a typed, role-scoped wrapper over the one-request Supercuts
+subprocess seam. Wallet keys, state keys, witnesses, and service credentials stay
+inside the Supercuts process; the SDK receives intents and verified receipts.
+
+Install the SDK. It installs the matching backend runtime automatically:
+
+```sh
+pnpm add @supercuts-walrus/sdk@0.1.1
+```
+
+```ts
+import { BuyerClient, initializeProfile } from "@supercuts-walrus/sdk";
+
+await initializeProfile({ home: "/private/buyer" }, { role: "buyer", mock: true });
+const buyer = await BuyerClient.connect({
+  home: "/private/buyer",
+  approvalProvider: {
+    async approve(intent) {
+      // Show intent.summary and intent.parameters in trusted operator UI.
+      return { approved: true };
+    },
+  },
+});
+const receipt = await buyer.deposit(100n);
+```
+
+Mock receipts are always labeled as non-funded. The approval provider belongs in
+trusted host code, outside model-controlled tool arguments.
+
+For Testnet, initialize with `deploymentConfig`, owner-only `suiKeyFile` and
+`tatumKeyFile`, and the write/Tatum gRPC endpoints instead of `mock: true`.
+Live buyer methods include operation-bound deposit/withdrawal, accepted shielded
+agreement settlement, and `payX402Resource(operationId, resourceUrl)`. The x402
+method obtains amount, asset, and payee from the resource's 402 challenge; it
+does not accept caller-supplied payment requirements.
+
+Use `planSettlement(...)` before negotiation or payment when the owner mandate
+requires plans, then pass the returned `planHash` to `payX402Resource`,
+`payX402`, `settleShielded`, or `settleAcceptedShielded`. Typed
+`rememberSettlement` writes are always assigned `agent_observation` provenance;
+they can be cited but cannot expand authority or act as owner policy. Recall
+returns blob ID, kind, provenance, and distance only, never decrypted text.
+
+Unsupported live role commands fail closed with `LIVE_COMMAND_UNAVAILABLE`.
+Mock and Testnet receipts remain distinct.

package/dist/index.d.ts

@@ -0,0 +1,589 @@
+export declare const SEAM_PROTOCOL: 1;
+export declare const SDK_VERSION: string;
+export type Role = "buyer" | "seller" | "auditor";
+export type Rail = "shielded" | "x402";
+export type OperationId = string & {
+    readonly __brand: "OperationId";
+};
+export type SessionId = string & {
+    readonly __brand: "SessionId";
+};
+export type TransactionDigest = string & {
+    readonly __brand: "TransactionDigest";
+};
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type DealState = "created" | "discovered" | "planned" | "awaiting_approval" | "review_required" | "funding_required" | "negotiating" | "agreed" | "evidence_ready" | "payment_pending" | "paid" | "delivery_pending" | "delivered" | "outcome_pending" | "complete" | "failed" | "unresolved";
+export interface ExecuteDealInput {
+    operationId: string;
+    capabilityId?: string;
+    capabilityClass?: string;
+    input: Record<string, unknown>;
+    budget: {
+        asset: string;
+        maximum: string;
+    };
+    privacyHint?: "any" | "shielded";
+    requestedRail?: Rail;
+}
+export interface DealView {
+    version: "supercuts.deal.v2";
+    dealId: string;
+    operationId: string;
+    state: DealState;
+    rail?: Rail;
+    visibility?: "shielded-direct-payment" | "public-x402";
+    planHash?: string;
+    paymentDigest?: string;
+    deliveryHash?: string;
+    evidence: {
+        agreement: "pending" | "verified";
+        payment: "pending" | "finalized";
+        delivery: "pending" | "verified";
+        outcomeMemory: "pending" | "indexed" | "unresolved";
+    };
+    nextAction?: "resume" | "check_memory" | "reconcile_memory" | "fund_buyer" | "owner_approval" | "owner_review";
+    timingsMs?: Record<string, number>;
+}
+export interface DealReconciliation {
+    resolved: boolean;
+    state: string;
+    blobId?: string;
+}
+export interface DealEvidenceView {
+    version: "supercuts.deal-evidence.v1";
+    dealId: string;
+    transcriptBlobIds: string[];
+    agreementBlobId?: string;
+    deliveryBlobId?: string;
+    outcomeMemoryBlobId?: string;
+    ciphertextReadback: "pending" | "verified" | "unresolved";
+    inventory: "pending" | "indexed" | "missing" | "unresolved";
+    paymentFinalized: boolean;
+    paymentDigest?: string;
+}
+export interface DealDelivery {
+    dealId: string;
+    contentType: string;
+    artifactSha256: string;
+    artifact: Uint8Array;
+}
+export interface DealPolicySummary {
+    perDealCeiling: string;
+    totalBudget: string;
+    remainingBudget: string;
+    expiresAt: number;
+    defaultRail: "shielded";
+    allowPublicX402: boolean;
+    allowedAssets: string[];
+    allowedCapabilityIds?: string[];
+    allowedCapabilityClasses?: string[];
+}
+export interface DealCatalogEntry {
+    origin: string;
+    manifest: CapabilityManifest;
+    manifestBlobId: string;
+}
+export interface CapabilityManifest {
+    protocol: "supercuts.capability.v1";
+    capabilityId: string;
+    sellerId: string;
+    capability: string;
+    description: string;
+    inputSchema: Readonly<Record<string, unknown>>;
+    outputSchema: Readonly<Record<string, unknown>>;
+    supportedRails: Rail[];
+    priceBand: {
+        minimum: string;
+        maximum: string;
+    };
+    asset: string;
+    endpoint: string;
+    expiresAt: number;
+    manifestHash: string;
+}
+export interface ProcurementTask {
+    taskId: string;
+    request: string;
+    privacy: "public" | "confidential";
+    maximumAmount: bigint;
+    asset: string;
+    requiredCapability: string;
+}
+export interface SettlementIntent {
+    operationId: OperationId;
+    dealId: string;
+    rail: Rail;
+    amount: bigint;
+    asset: string;
+    counterparty: string;
+    requestId: string;
+}
+export interface DeliveryReceipt {
+    requestId: string;
+    operationId: OperationId;
+    artifactSha256: string;
+    deliveredAt: number;
+    observation: "artifact-delivered";
+}
+export interface MemoryFact {
+    kind: "task" | "capability_choice" | "offer" | "agreed_cost" | "seller_responsiveness" | "settlement_rail" | "delivery_hash" | "latency" | "retry_behavior" | "outcome" | "privacy_policy";
+    subject: string;
+    observation: string;
+    operationId: OperationId;
+    createdAt: number;
+}
+export interface SettlementMemoryV1 {
+    version: "supercuts.settlement-memory.v1";
+    kind: "privacy_rule" | "budget_limit" | "reliability" | "quality" | "outcome";
+    provenance?: "agent_observation";
+    scope: {
+        counterparty?: string;
+        capabilityId?: string;
+        capabilityClass?: string;
+        network?: "sui:testnet";
+        asset?: string;
+    };
+    createdAt: number;
+    evidenceHash?: string;
+    observation?: string;
+    signal: {
+        requiresShielded?: boolean;
+        maximumAmount?: string;
+        reliability?: number;
+        quality?: number;
+        outcome?: "succeeded" | "failed" | "unresolved";
+    };
+}
+export interface SettlementCitation {
+    blobId: string;
+    kind: SettlementMemoryV1["kind"] | "legacy";
+    provenance: "owner_policy" | "verified_outcome" | "agent_observation" | "legacy_untrusted";
+    distance: number;
+}
+export interface SettlementPlanV1 {
+    version: "supercuts.settlement-plan.v1";
+    planHash: string;
+    operationId: string;
+    status: "approved" | "review_required";
+    mandateHash: string;
+    manifestHash: string;
+    capabilityId: string;
+    capabilityClass: string;
+    sellerId: string;
+    endpoint: string;
+    network: "sui:testnet";
+    asset: string;
+    rail: Rail;
+    openingAmount: string;
+    maximumAmount: string;
+    manifestMinimum: string;
+    manifestMaximum: string;
+    riskLevel: "low" | "medium" | "review_required";
+    createdAt: number;
+    expiresAt: number;
+    citations: SettlementCitation[];
+    reasonCodes: string[];
+    approvedFromPlanHash?: string;
+}
+export interface DemoEvent {
+    schema: "supercuts.demo.v1";
+    sequence: number;
+    runId: string;
+    timestamp: string;
+    actor: string;
+    stage: string;
+    status: string;
+    mode: "live" | "recorded-funded-run";
+    publicDetails: Readonly<Record<string, unknown>>;
+    evidenceHashes: string[];
+    explorerLinks: string[];
+}
+export interface AuthorizationIntent {
+    challengeId: string;
+    intentHash: string;
+    role: Role;
+    command: string;
+    summary: string;
+    parameters: Record<string, string | boolean>;
+    expiresAt: number;
+}
+export interface ApprovalDecision {
+    approved: boolean;
+    reason?: string;
+}
+export interface ApprovalProvider {
+    approve(intent: Readonly<AuthorizationIntent>): Promise<ApprovalDecision>;
+}
+export interface SupercutsSdkConfig {
+    home: string;
+    approvalProvider?: ApprovalProvider;
+    seamPath?: string;
+    timeoutMs?: number;
+}
+export interface MockInitializeOptions {
+    role: Role;
+    mock: true;
+    artifactManifest?: string;
+    maxAmount?: bigint;
+    allowedCounterparties?: string[];
+    requireShielded?: boolean;
+    maxMemoryDistance?: number;
+}
+export interface LiveInitializeOptions {
+    role: Role;
+    mock?: false;
+    deploymentConfig: string;
+    suiKeyFile: string;
+    tatumKeyFile: string;
+    writeGrpc: string;
+    tatumGrpc: string;
+    snarkjsPath?: string;
+    converterPath?: string;
+    rapidsnarkPath?: string;
+    memoryConfigFile?: string;
+    walrusPublisher?: string;
+    walrusAggregator?: string;
+    maxAmount?: bigint;
+    allowedCounterparties?: string[];
+    requireShielded?: boolean;
+    maxMemoryDistance?: number;
+}
+export type InitializeOptions = MockInitializeOptions | LiveInitializeOptions;
+export interface DoctorReport {
+    role: Role;
+    network: "testnet";
+    packageId: string;
+    poolId: string;
+    asset: string;
+    verifierVersion: number;
+    artifactManifestSha256: string;
+    keyPermissions: "owner-only";
+    rpc: string;
+    healthy: true;
+}
+export interface Status {
+    role: Role;
+    network: "testnet";
+    operations: number;
+    mock: boolean;
+}
+export interface WalletBalance {
+    available: bigint;
+    notes: number;
+}
+export interface QueuedExit {
+    operationId: string;
+    commitment: string;
+    payoutAddress: string;
+    amount: bigint;
+    exactExit: boolean;
+    windowStart: number;
+    executeAt: number;
+    windowEnd: number;
+    status: "queued" | "submitted" | "finalized";
+    visibility?: string;
+}
+export interface TransactionReceipt {
+    transactionDigest: TransactionDigest;
+    finalized: boolean;
+    evidence: string;
+    amount?: bigint;
+    commitment?: string;
+}
+export interface OfferState {
+    sessionId: SessionId;
+    revision: number;
+    state: string;
+    termsHash?: string;
+    transcriptCommitment: string;
+}
+export interface PaymentQuote {
+    rail: Rail;
+    amount: bigint;
+    counterparty: string;
+    asset: string;
+    policyDecision: "allowed";
+    visibility: string;
+}
+export interface PaymentReceipt {
+    operationId: OperationId;
+    status: "broadcast" | "finalized" | "unresolved";
+    rail: Rail;
+    amount: bigint;
+    counterparty: string;
+    asset: string;
+    requestId: string;
+    transactionDigest: TransactionDigest;
+    policyDecision: "allowed";
+    tatumVerified: boolean;
+    visibility: string;
+    evidence: string;
+}
+export interface MemoryStatus {
+    namespace: string;
+    completed: number;
+    jobs: Array<{
+        operationId: string;
+        blobId: string;
+        status: string;
+    }>;
+}
+export interface Capability {
+    capabilityId: string;
+    seller: string;
+    service: string;
+    terms: string;
+    blobId: string;
+    visibility: "public-capability";
+}
+export interface DisclosureReference {
+    package: string;
+    packageHash: string;
+    auditor: string;
+    dealId: string;
+}
+export interface AuditResult {
+    dealId: string;
+    agreementVerified: boolean;
+    paymentVerified: boolean;
+    transactionDigest: TransactionDigest;
+    evidence: string;
+}
+export declare class SupercutsSdkError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly recovery?: string | undefined;
+    constructor(code: string, message: string, retryable: boolean, recovery?: string | undefined);
+}
+export declare class SeamUnavailable extends Error {
+    constructor(message: string);
+}
+export declare function operationId(value: string): OperationId;
+export declare function sessionId(value: string): SessionId;
+declare class Seam {
+    #private;
+    private readonly config;
+    constructor(config: SupercutsSdkConfig);
+    call<T>(method: string, params?: Record<string, unknown>, withHome?: boolean): Promise<T>;
+}
+type Arguments = Record<string, unknown>;
+declare abstract class RoleClient {
+    protected readonly config: SupercutsSdkConfig;
+    protected readonly seam: Seam;
+    protected constructor(config: SupercutsSdkConfig);
+    doctor(): Promise<DoctorReport>;
+    status(): Promise<Status>;
+    protected ensureCompatible(): Promise<void>;
+    protected read<T>(command: string, args?: Arguments): Promise<T>;
+    protected mutate<T>(command: string, args: Arguments): Promise<T>;
+}
+declare const paymentArgs: (input: {
+    operationId: OperationId;
+    amount: bigint;
+    counterparty: string;
+    asset?: string;
+    requestId?: string;
+    broadcastOnly?: boolean;
+    planHash?: string;
+}) => Arguments;
+declare const exitArgs: (input: {
+    operationId: OperationId;
+    commitment: string;
+    amount: bigint;
+    exactExit?: boolean;
+    windowStart: number;
+    windowEnd: number;
+}) => Arguments;
+export declare class BuyerClient extends RoleClient {
+    listDealCapabilities(): Promise<DealCatalogEntry[]>;
+    getDealPolicy(): Promise<DealPolicySummary>;
+    static connect(config: SupercutsSdkConfig): Promise<BuyerClient>;
+    executeDeal(input: ExecuteDealInput): Promise<DealView>;
+    getDeal(operationId: string): Promise<DealView>;
+    resumeDeal(operationId: string): Promise<DealView>;
+    reconcileDealOutcome(operationId: string): Promise<DealReconciliation>;
+    getDealEvidence(dealId: string): Promise<DealEvidenceView>;
+    getDealDelivery(dealId: string): Promise<DealDelivery>;
+    discoverSellers(capabilities: Capability[]): Promise<Capability[]>;
+    discoverCapabilities(manifests: CapabilityManifest[]): Promise<CapabilityManifest[]>;
+    discoverCapabilityBlobs(blobIds: string[]): Promise<Array<CapabilityManifest & {
+        blobId: string;
+    }>>;
+    planSettlement(input: {
+        operationId: OperationId;
+        manifest: CapabilityManifest;
+        alternatives?: CapabilityManifest[];
+        requestedAmount?: bigint;
+        privacyHint?: "any" | "shielded";
+        requestedRail?: Rail;
+    }): Promise<SettlementPlanV1>;
+    deposit(amount: bigint, id?: OperationId): Promise<TransactionReceipt>;
+    balance(): Promise<WalletBalance>;
+    recover(): Promise<{
+        recovered: number;
+        source: string;
+    }>;
+    withdraw(commitment: string, recipient?: string, id?: OperationId): Promise<TransactionReceipt>;
+    queueExit(input: Parameters<typeof exitArgs>[0]): Promise<QueuedExit>;
+    exitStatus(id: OperationId): Promise<QueuedExit>;
+    finalizeExit(id: OperationId, digest: string, approvalId?: OperationId): Promise<Record<string, unknown>>;
+    openOffer(session?: SessionId): Promise<OfferState>;
+    propose(session: SessionId, revision: number, terms: Readonly<Record<string, JsonValue>>): Promise<OfferState>;
+    accept(session: SessionId, revision: number, terms: Readonly<Record<string, JsonValue>>): Promise<OfferState>;
+    acceptCryptographicAgreement(session: SessionId, agreement: Readonly<Record<string, JsonValue>>, plan?: {
+        planHash: string;
+        manifest: CapabilityManifest;
+    }): Promise<{
+        sessionId: string;
+        revision: string;
+        state: "accepted";
+        dealCommitment: string;
+        expiry: string;
+        paymentAmount: string;
+    }>;
+    showOffer(session: SessionId): Promise<OfferState>;
+    quote(input: {
+        rail: Rail;
+        amount: bigint;
+        counterparty: string;
+        asset?: string;
+    }): Promise<PaymentQuote>;
+    settleShielded(input: Parameters<typeof paymentArgs>[0]): Promise<PaymentReceipt>;
+    settleAcceptedShielded(operationId: OperationId, session: SessionId, planHash?: string): Promise<PaymentReceipt>;
+    payX402(input: Parameters<typeof paymentArgs>[0]): Promise<PaymentReceipt>;
+    payX402Resource(id: OperationId, resourceUrl: string, planHash?: string): Promise<PaymentReceipt & {
+        response: Uint8Array;
+        responseSha256: string;
+    }>;
+    paymentStatus(operationId: OperationId, reconcile?: boolean): Promise<PaymentReceipt>;
+    reconcilePayment(operationId: OperationId): Promise<PaymentReceipt>;
+    fetchResource(input: {
+        requestId: string;
+        operationId: OperationId;
+        response: Uint8Array;
+    }): Promise<{
+        requestId: string;
+        responseHash: string;
+        body: Uint8Array;
+        deliveryStatus: string;
+    }>;
+    remember(operationId: OperationId, fact: string): Promise<{
+        operationId: string;
+        namespace: string;
+        blobId: string;
+        status: string;
+    }>;
+    rememberSettlement(operationId: OperationId, memory: Omit<SettlementMemoryV1, "provenance">): Promise<{
+        operationId: string;
+        namespace: string;
+        blobId: string;
+        status: string;
+        provenance: "agent_observation";
+    }>;
+    recall(query: string): Promise<{
+        namespace: string;
+        citations: SettlementCitation[];
+        effect: string;
+    }>;
+    memoryStatus(): Promise<MemoryStatus>;
+    syncMemoryInventory(blobId?: string): Promise<{
+        namespace: string;
+        indexed: number;
+        deleted: number;
+        cursor: string | null;
+        blobId?: string;
+        present?: boolean;
+        expiresAt?: string;
+    }>;
+    requestDisclosure(input: {
+        dealId: string;
+        auditor: string;
+        paymentDigest: TransactionDigest;
+        transcriptRoot: string;
+    }): Promise<DisclosureReference>;
+}
+export declare class SellerClient extends RoleClient {
+    static connect(config: SupercutsSdkConfig): Promise<SellerClient>;
+    publishCapability(input: {
+        capabilityId?: string;
+        seller: string;
+        service: string;
+        terms: string;
+    }): Promise<Capability>;
+    publishManifest(manifest: CapabilityManifest, id?: OperationId): Promise<CapabilityManifest & {
+        blobId: string;
+        visibility: "public-capability";
+    }>;
+    counter(session: SessionId, revision: number, terms: Readonly<Record<string, JsonValue>>): Promise<OfferState>;
+    prepareCryptographicAgreement(session: SessionId, draft: Readonly<Record<string, JsonValue>>): Promise<{
+        sessionId: string;
+        revision: string;
+        state: "counter";
+        dealCommitment: string;
+        agreement: string;
+    }>;
+    showOffer(session: SessionId): Promise<OfferState>;
+    paymentStatus(operationId: OperationId): Promise<PaymentReceipt>;
+    recoverPayment(commitment: string, amount: bigint): Promise<{
+        recovered: number;
+        source: string;
+    }>;
+    balance(): Promise<WalletBalance>;
+    withdraw(commitment: string, recipient?: string, id?: OperationId): Promise<TransactionReceipt>;
+    queueExit(input: Parameters<typeof exitArgs>[0]): Promise<QueuedExit>;
+    exitStatus(id: OperationId): Promise<QueuedExit>;
+    finalizeExit(id: OperationId, digest: string, approvalId?: OperationId): Promise<Record<string, unknown>>;
+    serveResource(requestId: string, body: Uint8Array): Promise<{
+        requestId: string;
+        responseHash: string;
+        deliveryStatus: string;
+    }>;
+    fetchResource(input: {
+        requestId: string;
+        operationId: OperationId;
+        response: Uint8Array;
+    }): Promise<{
+        requestId: string;
+        responseHash: string;
+        body: Uint8Array;
+        deliveryStatus: string;
+    }>;
+    remember(operationId: OperationId, fact: string): Promise<{
+        operationId: string;
+        namespace: string;
+        blobId: string;
+        status: string;
+    }>;
+    recall(query: string): Promise<{
+        namespace: string;
+        citations: SettlementCitation[];
+        effect: string;
+    }>;
+    memoryStatus(): Promise<MemoryStatus>;
+    syncMemoryInventory(blobId?: string): Promise<{
+        namespace: string;
+        indexed: number;
+        deleted: number;
+        cursor: string | null;
+        blobId?: string;
+        present?: boolean;
+        expiresAt?: string;
+    }>;
+}
+export declare class AuditorClient extends RoleClient {
+    static connect(config: SupercutsSdkConfig): Promise<AuditorClient>;
+    verify(input: {
+        package: string;
+        auditor: string;
+        dealId: string;
+    }): Promise<AuditResult>;
+}
+export declare function initializeProfile(config: Omit<SupercutsSdkConfig, "approvalProvider">, options: InitializeOptions): Promise<{
+    role: Role;
+    home: string;
+    network: "testnet";
+    mock: boolean;
+}>;
+export {};

package/dist/index.js

@@ -0,0 +1,193 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+export const SEAM_PROTOCOL = 1;
+const require = createRequire(import.meta.url);
+export const SDK_VERSION = require("../package.json").version;
+export class SupercutsSdkError extends Error {
+    code;
+    retryable;
+    recovery;
+    constructor(code, message, retryable, recovery) {
+        super(message);
+        this.code = code;
+        this.retryable = retryable;
+        this.recovery = recovery;
+        this.name = "SupercutsSdkError";
+    }
+}
+export class SeamUnavailable extends Error {
+    constructor(message) { super(message); this.name = "SeamUnavailable"; }
+}
+export function operationId(value) { if (!value || value.length > 256)
+    throw new TypeError("operation ID must contain 1..256 characters"); return value; }
+export function sessionId(value) { if (!value || value.length > 256)
+    throw new TypeError("session ID must contain 1..256 characters"); return value; }
+function defaultSeamPath() {
+    try {
+        return require.resolve("@supercuts-walrus/backend/seam");
+    }
+    catch {
+        throw new SeamUnavailable(`@supercuts-walrus/backend@${SDK_VERSION} is missing. Reinstall @supercuts-walrus/sdk to restore its runtime dependency.`);
+    }
+}
+class Seam {
+    config;
+    #path;
+    #timeout;
+    constructor(config) {
+        this.config = config;
+        this.#path = config.seamPath ?? defaultSeamPath();
+        this.#timeout = config.timeoutMs ?? 300_000;
+        if (!Number.isSafeInteger(this.#timeout) || this.#timeout <= 0)
+            throw new TypeError("timeoutMs must be a positive integer");
+        if (!existsSync(this.#path))
+            throw new SeamUnavailable(`Supercuts runtime file is missing at ${this.#path}. Reinstall @supercuts-walrus/sdk and @supercuts-walrus/backend.`);
+    }
+    async call(method, params, withHome = true) {
+        const request = { protocol: SEAM_PROTOCOL, requestId: randomUUID(), method, ...(withHome ? { home: this.config.home } : {}), ...(params ? { params } : {}) };
+        return await new Promise((resolve, reject) => {
+            const child = spawn(process.execPath, [this.#path], { stdio: ["pipe", "pipe", "pipe"], env: { ...process.env } });
+            let stdout = "", stderrBytes = 0, done = false;
+            const timer = setTimeout(() => { child.kill("SIGKILL"); finish(new SeamUnavailable(`${method} exceeded ${this.#timeout}ms. Retry the operation with the same operation ID after checking the role journal.`)); }, this.#timeout);
+            const finish = (error, value) => { if (done)
+                return; done = true; clearTimeout(timer); error ? reject(error) : resolve(value); };
+            child.stdout.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => { stdout += chunk; if (stdout.length > 2 * 1024 * 1024) {
+                child.kill("SIGKILL");
+                finish(new SeamUnavailable("seam response exceeded 2 MiB"));
+            } });
+            child.stderr.on("data", (chunk) => { stderrBytes += chunk.length; });
+            child.on("error", (error) => finish(new SeamUnavailable(`could not start Supercuts seam: ${error.message}`)));
+            child.stdin.on("error", () => finish(new SeamUnavailable("Supercuts seam closed its input before accepting the request. Check the backend installation and retry with the same operation ID.")));
+            child.on("close", (code, signal) => {
+                if (done)
+                    return;
+                let response;
+                try {
+                    response = JSON.parse(stdout);
+                }
+                catch {
+                    return finish(new SeamUnavailable(`seam returned invalid JSON (exit ${code ?? signal ?? "unknown"}; ${stderrBytes} stderr bytes). Check the installed backend and retry with the same operation ID.`));
+                }
+                if (!response || response.protocol !== SEAM_PROTOCOL || response.requestId !== request.requestId || typeof response.ok !== "boolean")
+                    return finish(new SeamUnavailable("seam response protocol or shape is invalid. Reinstall matching SDK and backend versions."));
+                if (!response.ok)
+                    return finish(new SupercutsSdkError(response.error?.code ?? "INTERNAL_ERROR", response.error?.message ?? "Supercuts returned no detail", Boolean(response.error?.retryable), response.error?.recovery));
+                if (response.result === undefined)
+                    return finish(new SeamUnavailable("seam success response omitted its result. Check backend compatibility."));
+                finish(undefined, response.result);
+            });
+            child.stdin.end(JSON.stringify(request));
+        });
+    }
+}
+class RoleClient {
+    config;
+    seam;
+    constructor(config) {
+        this.config = config;
+        this.seam = new Seam(config);
+    }
+    async doctor() { return this.read("doctor"); }
+    async status() { return this.read("status"); }
+    async ensureCompatible() { const version = await this.seam.call("version", undefined, false); if (version.protocol !== SEAM_PROTOCOL || version.packageVersion !== SDK_VERSION)
+        throw new SeamUnavailable(`Supercuts backend ${version.packageVersion}/protocol ${version.protocol} is incompatible with SDK ${SDK_VERSION}/protocol ${SEAM_PROTOCOL}. Install matching versions.`); }
+    async read(command, args = {}) { return this.seam.call("command.execute", { command, arguments: args }); }
+    async mutate(command, args) {
+        const provider = this.config.approvalProvider;
+        if (!provider)
+            throw new SupercutsSdkError("SDK_APPROVAL_PROVIDER_REQUIRED", `${command} requires an ApprovalProvider`, false);
+        const intent = await this.seam.call("authorization.preview", { command, arguments: args });
+        const decision = await provider.approve(Object.freeze(intent));
+        if (!decision.approved)
+            throw new SupercutsSdkError("AUTHORIZATION_DENIED", decision.reason ?? "the approval provider denied this intent", false);
+        const approval = await this.seam.call("authorization.approve", { challengeId: intent.challengeId });
+        return this.seam.call("command.execute", { command, arguments: args, approvalToken: approval.token });
+    }
+}
+const paymentArgs = (input) => ({
+    "operation-id": input.operationId, amount: input.amount.toString(), counterparty: input.counterparty,
+    ...(input.asset ? { asset: input.asset } : {}), ...(input.requestId ? { "request-id": input.requestId } : {}), ...(input.broadcastOnly ? { "broadcast-only": true } : {}), ...(input.planHash ? { "plan-hash": input.planHash } : {}),
+});
+const payment = (value) => ({ ...value, amount: BigInt(value.amount) });
+const queuedExit = (value) => ({ ...value, amount: BigInt(value.amount) });
+const exitArgs = (input) => ({ "operation-id": input.operationId, commitment: input.commitment, amount: input.amount.toString(), "exact-exit": input.exactExit === true, "window-start": String(input.windowStart), "window-end": String(input.windowEnd) });
+export class BuyerClient extends RoleClient {
+    async listDealCapabilities() { const result = await this.seam.call("deal.catalog"); return result.capabilities; }
+    async getDealPolicy() { return this.seam.call("deal.policy"); }
+    static async connect(config) { const client = new BuyerClient(config); await client.ensureCompatible(); const report = await client.doctor(); if (report.role !== "buyer")
+        throw new SupercutsSdkError("SDK_ROLE_MISMATCH", `expected buyer profile, found ${report.role}`, false); return client; }
+    async executeDeal(input) { return this.seam.call("deal.execute", { input }); }
+    async getDeal(operationId) { return this.seam.call("deal.get", { operationId }); }
+    async resumeDeal(operationId) { return this.seam.call("deal.resume", { operationId }); }
+    async reconcileDealOutcome(operationId) { return this.seam.call("deal.reconcile", { operationId }); }
+    async getDealEvidence(dealId) { return this.seam.call("deal.evidence", { dealId }); }
+    async getDealDelivery(dealId) { const value = await this.seam.call("deal.delivery", { dealId }); return { ...value, artifact: Buffer.from(value.artifact, "base64") }; }
+    async discoverSellers(capabilities) { const value = await this.read("capability.discover", { capabilities }); return value.capabilities; }
+    async discoverCapabilities(manifests) { const value = await this.read("capability.discover", { capabilities: manifests }); return value.capabilities; }
+    async discoverCapabilityBlobs(blobIds) { const value = await this.read("capability.discover", { "blob-ids": blobIds }); return value.capabilities; }
+    async planSettlement(input) { return this.mutate("settlement.plan", { "operation-id": input.operationId, manifest: input.manifest, ...(input.alternatives ? { alternatives: input.alternatives } : {}), ...(input.requestedAmount !== undefined ? { "requested-amount": input.requestedAmount.toString() } : {}), ...(input.privacyHint ? { "privacy-hint": input.privacyHint } : {}), ...(input.requestedRail ? { "requested-rail": input.requestedRail } : {}) }); }
+    async deposit(amount, id = operationId(randomUUID())) { const value = await this.mutate("wallet.deposit", { amount: amount.toString(), "operation-id": id }); return { ...value, amount: BigInt(value.amount) }; }
+    async balance() { const value = await this.read("wallet.balance"); return { ...value, available: BigInt(value.available) }; }
+    async recover() { return this.mutate("wallet.recover", {}); }
+    async withdraw(commitment, recipient, id = operationId(randomUUID())) { const value = await this.mutate("wallet.withdraw", { commitment, "operation-id": id, ...(recipient ? { recipient } : {}) }); return { ...value, amount: BigInt(value.amount) }; }
+    async queueExit(input) { return queuedExit(await this.mutate("wallet.exit.queue", exitArgs(input))); }
+    async exitStatus(id) { return queuedExit(await this.read("wallet.exit.status", { "operation-id": id })); }
+    async finalizeExit(id, digest, approvalId = operationId(randomUUID())) { return this.mutate("wallet.exit.finalize", { "operation-id": approvalId, "exit-id": id, digest }); }
+    async openOffer(session) { return this.mutate("offer.open", session ? { session } : {}); }
+    async propose(session, revision, terms) { return this.mutate("offer.propose", { session, revision, terms: JSON.stringify(terms) }); }
+    async accept(session, revision, terms) { return this.mutate("offer.accept", { session, revision, terms: JSON.stringify(terms) }); }
+    async acceptCryptographicAgreement(session, agreement, plan) { return this.mutate("offer.accept", { session, agreement: Buffer.from(JSON.stringify(agreement)).toString("base64url"), ...(plan ? { "plan-hash": plan.planHash, manifest: plan.manifest } : {}) }); }
+    async showOffer(session) { return this.read("offer.show", { session }); }
+    async quote(input) { const value = await this.read("pay.quote", { rail: input.rail, amount: input.amount.toString(), counterparty: input.counterparty, ...(input.asset ? { asset: input.asset } : {}) }); return { ...value, amount: BigInt(value.amount) }; }
+    async settleShielded(input) { return payment(await this.mutate("pay.shielded", paymentArgs(input))); }
+    async settleAcceptedShielded(operationId, session, planHash) { return payment(await this.mutate("pay.shielded", { "operation-id": operationId, session, ...(planHash ? { "plan-hash": planHash } : {}) })); }
+    async payX402(input) { return payment(await this.mutate("pay.x402", paymentArgs(input))); }
+    async payX402Resource(id, resourceUrl, planHash) { const value = await this.mutate("pay.x402", { "operation-id": id, "resource-url": resourceUrl, ...(planHash ? { "plan-hash": planHash } : {}) }); return { ...value, amount: BigInt(value.amount), response: Buffer.from(value.response, "base64"), responseSha256: String(value.responseSha256) }; }
+    async paymentStatus(operationId, reconcile = false) { return payment(await this.read("pay.status", { "operation-id": operationId, ...(reconcile ? { reconcile: true } : {}) })); }
+    async reconcilePayment(operationId) { return this.paymentStatus(operationId, true); }
+    async fetchResource(input) { const value = await this.read("resource.fetch", { "request-id": input.requestId, "operation-id": input.operationId, response: Buffer.from(input.response).toString("base64") }); return { ...value, body: Buffer.from(value.body, "base64") }; }
+    async remember(operationId, fact) { return this.mutate("memory.remember", { "operation-id": operationId, fact }); }
+    async rememberSettlement(operationId, memory) { return this.mutate("memory.remember", { "operation-id": operationId, memory }); }
+    async recall(query) { return this.read("memory.recall", { query }); }
+    async memoryStatus() { return this.read("memory.status"); }
+    async syncMemoryInventory(blobId) { return this.read("memory.inventory", blobId ? { "blob-id": blobId } : {}); }
+    async requestDisclosure(input) { return this.mutate("disclose", { "deal-id": input.dealId, auditor: input.auditor, "payment-digest": input.paymentDigest, "transcript-root": input.transcriptRoot }); }
+}
+export class SellerClient extends RoleClient {
+    static async connect(config) { const client = new SellerClient(config); await client.ensureCompatible(); const report = await client.doctor(); if (report.role !== "seller")
+        throw new SupercutsSdkError("SDK_ROLE_MISMATCH", `expected seller profile, found ${report.role}`, false); return client; }
+    async publishCapability(input) { return this.mutate("capability.publish", { ...(input.capabilityId ? { "capability-id": input.capabilityId } : {}), seller: input.seller, service: input.service, terms: input.terms }); }
+    async publishManifest(manifest, id = operationId(randomUUID())) { return this.mutate("capability.publish", { manifest, "operation-id": id }); }
+    async counter(session, revision, terms) { return this.mutate("offer.counter", { session, revision, terms: JSON.stringify(terms) }); }
+    async prepareCryptographicAgreement(session, draft) { return this.mutate("offer.counter", { session, agreement: Buffer.from(JSON.stringify(draft)).toString("base64url") }); }
+    async showOffer(session) { return this.read("offer.show", { session }); }
+    async paymentStatus(operationId) { return payment(await this.read("pay.status", { "operation-id": operationId })); }
+    async recoverPayment(commitment, amount) { return this.mutate("wallet.recover", { commitment, amount: amount.toString() }); }
+    async balance() { const value = await this.read("wallet.balance"); return { ...value, available: BigInt(value.available) }; }
+    async withdraw(commitment, recipient, id = operationId(randomUUID())) { const value = await this.mutate("wallet.withdraw", { commitment, "operation-id": id, ...(recipient ? { recipient } : {}) }); return { ...value, amount: BigInt(value.amount) }; }
+    async queueExit(input) { return queuedExit(await this.mutate("wallet.exit.queue", exitArgs(input))); }
+    async exitStatus(id) { return queuedExit(await this.read("wallet.exit.status", { "operation-id": id })); }
+    async finalizeExit(id, digest, approvalId = operationId(randomUUID())) { return this.mutate("wallet.exit.finalize", { "operation-id": approvalId, "exit-id": id, digest }); }
+    async serveResource(requestId, body) { return this.mutate("resource.serve", { "request-id": requestId, body: Buffer.from(body).toString("base64") }); }
+    async fetchResource(input) { const value = await this.read("resource.fetch", { "request-id": input.requestId, "operation-id": input.operationId, response: Buffer.from(input.response).toString("base64") }); return { ...value, body: Buffer.from(value.body, "base64") }; }
+    async remember(operationId, fact) { return this.mutate("memory.remember", { "operation-id": operationId, fact }); }
+    async recall(query) { return this.read("memory.recall", { query }); }
+    async memoryStatus() { return this.read("memory.status"); }
+    async syncMemoryInventory(blobId) { return this.read("memory.inventory", blobId ? { "blob-id": blobId } : {}); }
+}
+export class AuditorClient extends RoleClient {
+    static async connect(config) { const client = new AuditorClient(config); await client.ensureCompatible(); const report = await client.doctor(); if (report.role !== "auditor")
+        throw new SupercutsSdkError("SDK_ROLE_MISMATCH", `expected auditor profile, found ${report.role}`, false); return client; }
+    async verify(input) { return this.read("audit.verify", { package: input.package, auditor: input.auditor, "deal-id": input.dealId }); }
+}
+export async function initializeProfile(config, options) {
+    const seam = new Seam(config);
+    const version = await seam.call("version", undefined, false);
+    if (version.protocol !== SEAM_PROTOCOL || version.packageVersion !== SDK_VERSION)
+        throw new SeamUnavailable("installed Supercuts backend is incompatible with this SDK");
+    const live = options.mock === true ? {} : { "deployment-config": options.deploymentConfig, "sui-key-file": options.suiKeyFile, "tatum-key-file": options.tatumKeyFile, "write-grpc": options.writeGrpc, "tatum-grpc": options.tatumGrpc, ...(options.snarkjsPath ? { snarkjs: options.snarkjsPath } : {}), ...(options.converterPath ? { converter: options.converterPath } : {}), ...(options.rapidsnarkPath ? { rapidsnark: options.rapidsnarkPath } : {}), ...(options.memoryConfigFile ? { "memory-config-file": options.memoryConfigFile } : {}), ...(options.walrusPublisher ? { "walrus-publisher": options.walrusPublisher } : {}), ...(options.walrusAggregator ? { "walrus-aggregator": options.walrusAggregator } : {}) };
+    return seam.call("initialize", { role: options.role, ...(options.mock ? { mock: true } : live), ...(options.mock && options.artifactManifest ? { "artifact-manifest": options.artifactManifest } : {}), ...(options.maxAmount !== undefined ? { "max-amount": options.maxAmount.toString() } : {}), ...(options.allowedCounterparties ? { "allow-counterparty": options.allowedCounterparties.join(",") } : {}), ...(options.requireShielded ? { "require-shielded": true } : {}), ...(options.maxMemoryDistance !== undefined ? { "max-memory-distance": String(options.maxMemoryDistance) } : {}) });
+}

package/package.json

@@ -1,6 +1,36 @@
 {
   "name": "@supercuts-walrus/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Typed, role-scoped TypeScript SDK for Supercuts",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22.13"
+  },
+  "dependencies": {
+    "@supercuts-walrus/backend": "0.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc --noEmit -p tsconfig.json",
+    "pretest": "pnpm --dir ../.. build",
+    "test": "tsx --test test/**/*.test.ts"
+  }
 }