@supercuts-walrus/backend 0.0.0-stage → 0.1.0

package/dist/seller-database.js

@@ -0,0 +1,80 @@
+import { fail } from "./errors.js";
+/** Server-only PostgREST access. The service-role key must never reach a buyer tool. */
+export class SellerDatabase {
+    origin;
+    serviceKey;
+    http;
+    constructor(origin, serviceKey, http = fetch) {
+        this.origin = origin;
+        this.serviceKey = serviceKey;
+        this.http = http;
+        const url = new URL(origin);
+        if (url.protocol !== "https:")
+            fail("SELLER_DB_INVALID", "Supabase URL must use HTTPS");
+        if (!serviceKey)
+            fail("SELLER_DB_INVALID", "Supabase service key is required");
+    }
+    async request(path, init = {}) {
+        const response = await this.http(new URL(`/rest/v1/${path}`, this.origin), {
+            ...init,
+            headers: { apikey: this.serviceKey, Authorization: `Bearer ${this.serviceKey}`, ...(init.body ? { "content-type": "application/json" } : {}), ...(init.headers ?? {}) },
+            signal: init.signal ?? AbortSignal.timeout(30_000),
+        });
+        if (!response.ok) {
+            await response.arrayBuffer();
+            fail("SELLER_DB_UNAVAILABLE", `Supabase returned ${response.status}`);
+        }
+        const body = await response.text();
+        return body ? JSON.parse(body) : undefined;
+    }
+    async getSnapshot(sellerId) {
+        const rows = await this.request(`seller_state?seller_id=eq.${encodeURIComponent(sellerId)}&select=payload,revision`);
+        return rows[0];
+    }
+    async putSnapshot(snapshot, expectedRevision) {
+        if (expectedRevision === undefined) {
+            await this.request("seller_state?on_conflict=seller_id", { method: "POST", headers: { Prefer: "resolution=merge-duplicates,return=minimal" }, body: JSON.stringify({ seller_id: snapshot.sellerId, payload: snapshot, revision: 0, updated_at: new Date().toISOString() }) });
+            return 0;
+        }
+        const rows = await this.request(`seller_state?seller_id=eq.${encodeURIComponent(snapshot.sellerId)}&revision=eq.${expectedRevision}&select=revision`, { method: "PATCH", headers: { Prefer: "return=representation" }, body: JSON.stringify({ payload: snapshot, revision: expectedRevision + 1, updated_at: new Date().toISOString() }) });
+        if (!Array.isArray(rows) || rows.length !== 1 || rows[0]?.revision !== expectedRevision + 1)
+            fail("SELLER_STATE_CONFLICT", "another seller instance updated the durable snapshot");
+        return expectedRevision + 1;
+    }
+    async listCatalog() {
+        return await this.request("seller_catalog?select=seller_id,capability_id,manifest,blob_id,signature,transport_public_key,preview,updated_at&order=capability_id.asc");
+    }
+    async listDirectory(now = Date.now(), offset = 0) {
+        if (!Number.isSafeInteger(offset) || offset < 0 || offset > 100_000)
+            fail("SELLER_DIRECTORY_INVALID", "directory offset is invalid");
+        const rows = await this.request(`seller_directory?expires_at=gt.${now}&select=registration&order=capability_id.asc&limit=100&offset=${offset}`);
+        return rows.map((row) => row.registration);
+    }
+    async putDirectory(registration) {
+        const manifest = registration.manifest;
+        const existing = await this.request(`seller_directory?capability_id=eq.${encodeURIComponent(manifest.capabilityId)}&select=seller_id,registration`);
+        if (existing[0] && existing[0].seller_id !== manifest.sellerId)
+            fail("SELLER_DIRECTORY_CONFLICT", "capability ID belongs to another seller");
+        await this.request("seller_directory?on_conflict=capability_id", { method: "POST", headers: { Prefer: "resolution=merge-duplicates,return=minimal" }, body: JSON.stringify({ capability_id: manifest.capabilityId, seller_id: manifest.sellerId, registration, endpoint_origin: new URL(manifest.endpoint).origin, expires_at: manifest.expiresAt, updated_at: new Date().toISOString() }) });
+    }
+    async putCatalog(row) {
+        await this.request("seller_catalog?on_conflict=capability_id", { method: "POST", headers: { Prefer: "resolution=merge-duplicates,return=minimal" }, body: JSON.stringify({ ...row, updated_at: new Date().toISOString() }) });
+    }
+    async addEvent(row) {
+        await this.request("seller_events", { method: "POST", headers: { Prefer: "return=minimal" }, body: JSON.stringify({ ...row, created_at: new Date().toISOString() }) });
+    }
+    async listEvents(runId) {
+        return await this.request(`seller_events?run_id=eq.${encodeURIComponent(runId)}&select=seller_id,stage,status,details,created_at&order=id.asc`);
+    }
+    async listPaymentClaims() {
+        return await this.request("seller_payment_claims?select=digest,request_id,seller_id&order=digest.asc");
+    }
+    async claimPayment(digest, requestId, sellerId) {
+        const inserted = await this.request("seller_payment_claims?on_conflict=digest&select=digest,request_id,seller_id", { method: "POST", headers: { Prefer: "resolution=ignore-duplicates,return=representation" }, body: JSON.stringify({ digest, request_id: requestId, seller_id: sellerId }) });
+        if (Array.isArray(inserted) && inserted.length === 1)
+            return;
+        const existing = await this.request(`seller_payment_claims?digest=eq.${encodeURIComponent(digest)}&select=request_id,seller_id`);
+        if (existing[0]?.request_id !== requestId || existing[0]?.seller_id !== sellerId)
+            fail("PAYMENT_CONSUMED", "payment digest is already claimed by another resource");
+    }
+}

package/dist/seller-directory-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/seller-directory-cli.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { verifySignedCapability } from "./capability.js";
+import { fail } from "./errors.js";
+async function main() {
+    const [command, file, directory] = process.argv.slice(2);
+    if (command !== "publish" || !file || !directory)
+        fail("ARGUMENT_REQUIRED", "usage: supercuts-seller-directory publish <owner-only-registration.json> <directory-origin>");
+    const path = resolve(file);
+    if ((statSync(path).mode & 0o077) !== 0)
+        fail("SELLER_CONFIG_PERMISSIONS", "registration file must be owner-only");
+    const registration = JSON.parse(readFileSync(path, "utf8"));
+    await verifySignedCapability(registration);
+    const url = new URL(directory);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "::1"].includes(url.hostname)) || url.username || url.password || url.pathname !== "/" || url.search || url.hash)
+        fail("SELLER_DIRECTORY_INVALID", "directory origin must be HTTPS or loopback HTTP without path or credentials");
+    const response = await fetch(new URL("/v2/directory/register", url), { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ registration }), redirect: "error", signal: AbortSignal.timeout(90_000) });
+    const result = await response.json();
+    if (!response.ok || result.ok !== true)
+        fail("SELLER_DIRECTORY_UNAVAILABLE", String(result.message ?? `directory returned HTTP ${response.status}`));
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+}
+main().catch((error) => { process.stderr.write(`${error instanceof Error ? error.message : "directory publication failed"}\n`); process.exitCode = 1; });

package/dist/seller-directory.d.ts

@@ -0,0 +1,5 @@
+import { type SignedCapabilityRegistration } from "./capability.js";
+import type { SellerDatabase } from "./seller-database.js";
+export declare function validateDirectoryOrigin(endpoint: string, allowLoopback?: boolean): Promise<URL>;
+/** The directory stores signed public metadata, never a seller role home. */
+export declare function registerDirectoryCapability(db: Pick<SellerDatabase, "putDirectory">, registration: SignedCapabilityRegistration, aggregator: string, http?: typeof fetch, allowLoopback?: boolean): Promise<void>;

package/dist/seller-directory.js

@@ -0,0 +1,50 @@
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+import { verifySignedCapability } from "./capability.js";
+import { fail } from "./errors.js";
+import { canonicalJson } from "./settlement.js";
+function publicAddress(address) {
+    if (address.includes(":"))
+        return !/^(::|::1$|fc|fd|fe80:|2001:db8:)/i.test(address) && !address.startsWith("::ffff:");
+    const octets = address.split(".").map(Number);
+    return octets.length === 4 && octets.every((part) => Number.isInteger(part) && part >= 0 && part <= 255)
+        && octets[0] !== 0 && octets[0] !== 10 && octets[0] !== 127 && octets[0] < 224
+        && !(octets[0] === 169 && octets[1] === 254) && !(octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31)
+        && !(octets[0] === 192 && octets[1] === 168) && !(octets[0] === 100 && octets[1] >= 64 && octets[1] <= 127);
+}
+export async function validateDirectoryOrigin(endpoint, allowLoopback = false) {
+    const url = new URL(endpoint);
+    if (url.username || url.password || url.hash || url.search || url.port && url.port !== "443" && !allowLoopback)
+        fail("SELLER_ENDPOINT_UNSAFE", "directory endpoint has credentials, query, fragment, or nonstandard port");
+    if (allowLoopback && url.protocol === "http:" && ["localhost", "127.0.0.1", "::1"].includes(url.hostname))
+        return url;
+    if (url.protocol !== "https:" || url.hostname === "localhost" || url.hostname.endsWith(".localhost"))
+        fail("SELLER_ENDPOINT_UNSAFE", "directory endpoint must use a public HTTPS origin");
+    const addresses = isIP(url.hostname) ? [{ address: url.hostname }] : await lookup(url.hostname, { all: true });
+    if (!addresses.length || addresses.some(({ address }) => !publicAddress(address)))
+        fail("SELLER_ENDPOINT_UNSAFE", "directory endpoint resolves to a nonpublic address");
+    return url;
+}
+/** The directory stores signed public metadata, never a seller role home. */
+export async function registerDirectoryCapability(db, registration, aggregator, http = fetch, allowLoopback = false) {
+    await verifySignedCapability(registration);
+    if (!/^[A-Za-z0-9_-]{1,256}$/.test(registration.manifestBlobId))
+        fail("WALRUS_BLOB_INVALID", "directory registration has an invalid Walrus blob ID");
+    const endpoint = await validateDirectoryOrigin(registration.manifest.endpoint, allowLoopback);
+    const read = async (url, limit) => {
+        const response = await http(url, { redirect: "error", signal: AbortSignal.timeout(15_000) });
+        if (!response.ok)
+            fail("SELLER_DIRECTORY_UNAVAILABLE", `registration verification returned HTTP ${response.status}`);
+        const bytes = Buffer.from(await response.arrayBuffer());
+        if (!bytes.length || bytes.length > limit)
+            fail("SELLER_DIRECTORY_INVALID", "registration verification response is too large");
+        return JSON.parse(bytes.toString());
+    };
+    const blob = await read(new URL(`/v1/blobs/${encodeURIComponent(registration.manifestBlobId)}`, aggregator), 128 * 1024);
+    if (canonicalJson(blob) !== canonicalJson(registration.manifest))
+        fail("CAPABILITY_BLOB_MISMATCH", "Walrus manifest differs from the signed registration");
+    const catalog = await read(new URL("/v2/catalog", endpoint.origin), 512 * 1024);
+    if (!Array.isArray(catalog.capabilities) || catalog.capabilities.length > 100 || !catalog.capabilities.some((item) => canonicalJson(item) === canonicalJson(registration)))
+        fail("SELLER_DIRECTORY_UNAVAILABLE", "seller endpoint does not serve the exact signed registration");
+    await db.putDirectory(registration);
+}

package/dist/seller-live-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/seller-live-cli.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { fail } from "./errors.js";
+import { Phase3App, errorOutput } from "./phase3.js";
+import { LiveSellerTransport } from "./live-seller-transport.js";
+async function main() {
+    const home = process.argv[2], configPath = process.argv[3];
+    if (!home || !configPath)
+        return fail("ARGUMENT_REQUIRED", "usage: supercuts-seller-live <seller-home> <owner-only-config.json>");
+    if ((statSync(configPath).mode & 0o077) !== 0)
+        fail("SELLER_CONFIG_PERMISSIONS", "seller config must be owner-only");
+    const config = JSON.parse(readFileSync(configPath, "utf8"));
+    if (!Array.isArray(config.capabilities) || !config.capabilities.length)
+        fail("SELLER_CONFIG_INVALID", "seller config must name registered capabilities and handlers");
+    const app = new Phase3App(home), transport = new LiveSellerTransport(app, config);
+    try {
+        for (const item of config.capabilities) {
+            let registration = item.registration;
+            if (item.registrationFile) {
+                const registrationPath = resolve(item.registrationFile);
+                if ((statSync(registrationPath).mode & 0o077) !== 0)
+                    fail("SELLER_CONFIG_PERMISSIONS", "registration file must be owner-only");
+                registration = JSON.parse(readFileSync(registrationPath, "utf8"));
+            }
+            if (!registration)
+                return fail("SELLER_CONFIG_INVALID", "capability requires registration or registrationFile");
+            const path = resolve(item.handler);
+            if ((statSync(path).mode & 0o077) !== 0)
+                fail("SELLER_HANDLER_PERMISSIONS", "seller handler module must be owner-only");
+            const loaded = await import(pathToFileURL(path).href);
+            const handler = loaded.default ?? loaded.handle;
+            if (typeof handler !== "function")
+                return fail("SELLER_HANDLER_INVALID", "seller handler must export default or handle(request)");
+            await transport.register(registration, handler);
+        }
+        const origin = new URL(config.origin), server = transport.createServer();
+        const host = config.listenHost ?? "127.0.0.1", port = config.listenPort ?? (origin.protocol === "http:" && ["127.0.0.1", "localhost", "::1"].includes(origin.hostname) ? Number(origin.port || 80) : 8788);
+        if (!Number.isInteger(port) || port < 1 || port > 65535)
+            fail("SELLER_CONFIG_INVALID", "seller listenPort must be a valid TCP port");
+        await new Promise((done) => server.listen(port, host, done));
+        process.stdout.write(`${JSON.stringify({ ok: true, service: "supercuts-seller-live", origin: config.origin, capabilities: transport.runtime.catalog().map((item) => item.manifest.capabilityId) })}\n`);
+        const stop = () => server.close(() => { app.close(); process.exit(0); });
+        process.on("SIGINT", stop);
+        process.on("SIGTERM", stop);
+    }
+    catch (error) {
+        app.close();
+        throw error;
+    }
+}
+main().catch((error) => { process.stdout.write(`${JSON.stringify(errorOutput(error))}\n`); process.exitCode = 1; });

package/dist/seller-provision.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/seller-provision.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import { readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import { createHash } from "node:crypto";
+import { validateCapabilityManifest } from "./capability.js";
+import { fail } from "./errors.js";
+import { executeMandated, loadMandate } from "./mandate.js";
+import { Phase3App } from "./phase3.js";
+import { SellerDatabase } from "./seller-database.js";
+import { captureSellerHome, encryptSellerSnapshot } from "./seller-state.js";
+async function main() {
+    const path = process.argv[2] ? resolve(process.argv[2]) : fail("ARGUMENT_REQUIRED", "usage: supercuts-seller-provision <owner-only-config.json>");
+    if ((statSync(path).mode & 0o077) !== 0)
+        fail("CREDENTIAL_PERMISSIONS", "seller provision config must be owner-only");
+    const config = JSON.parse(readFileSync(path, "utf8"));
+    if (!Array.isArray(config.sellers) || config.sellers.length !== 3 || new Set(config.sellers.map((seller) => seller.sellerId)).size !== 3)
+        fail("SELLER_CONFIG_INVALID", "exactly three distinct sellers are required");
+    const required = (key) => process.env[key] ?? fail("SELLER_CONFIG_MISSING", `${key} is required`);
+    const db = new SellerDatabase(required("SUPABASE_URL"), required("SUPABASE_SERVICE_ROLE_KEY"));
+    const key = required("SELLER_STATE_KEY");
+    for (const seller of config.sellers) {
+        const app = new Phase3App(resolve(seller.home));
+        try {
+            if (app.profile.mock || app.profile.role !== "seller")
+                fail("LIVE_PROFILE_REQUIRED", "provision only live seller role homes");
+            const encoded = app.store.getSecret("live:sui-private-key")?.toString() ?? fail("LIVE_CREDENTIAL_MISSING", "seller Sui key is missing");
+            const decoded = decodeSuiPrivateKey(encoded);
+            if (decoded.scheme !== "ED25519")
+                fail("SELLER_IDENTITY_MISMATCH", "seller requires an ED25519 signer");
+            const signer = Ed25519Keypair.fromSecretKey(decoded.secretKey);
+            if (signer.toSuiAddress() !== seller.sellerId)
+                fail("SELLER_IDENTITY_MISMATCH", "seller ID must equal its Sui signer address");
+            const artifacts = {};
+            for (const capability of seller.capabilities) {
+                const manifest = capability.manifest;
+                validateCapabilityManifest(manifest);
+                if (manifest.sellerId !== seller.sellerId)
+                    fail("SELLER_IDENTITY_MISMATCH", "manifest seller ID differs from its role home");
+                if (capability.artifact) {
+                    const body = readFileSync(resolve(capability.artifact));
+                    if (manifest.capability === "sui.market-brief") {
+                        let report;
+                        try {
+                            report = JSON.parse(body.toString());
+                        }
+                        catch (error) {
+                            return fail("BRIEF_INVALID", "market brief must be JSON", error);
+                        }
+                        if (typeof report.title !== "string" || typeof report.body !== "string" || !Array.isArray(report.citations) || report.citations.length < 2 || report.citations.some((value) => typeof value !== "string" || !/^https:\/\//.test(value)))
+                            fail("BRIEF_INVALID", "market brief needs a title, body, and at least two HTTPS citations");
+                    }
+                    artifacts[manifest.capabilityId] = body.toString("base64url");
+                }
+                for (const [briefHash, artifactPath] of Object.entries(capability.variants ?? {})) {
+                    if (!/^[0-9a-f]{64}$/.test(briefHash))
+                        fail("SELLER_CONFIG_INVALID", "variant brief hash is invalid");
+                    artifacts[`${manifest.capabilityId}:${briefHash}`] = readFileSync(resolve(artifactPath)).toString("base64url");
+                }
+                if (!capability.artifact && !Object.keys(capability.variants ?? {}).length)
+                    fail("SELLER_ARTIFACT_MISSING", "capability needs a prepared artifact or brief variants");
+                const published = await executeMandated(app, loadMandate(seller.home), "capability.publish", { "operation-id": `publish-${manifest.manifestHash}`, manifest });
+                const blobId = String(published.blobId ?? "");
+                if (!blobId)
+                    fail("WALRUS_PUBLISH_FAILED", "capability publish returned no blob ID");
+                const hashes = {};
+                for (const [artifactKey, value] of Object.entries(artifacts))
+                    if (artifactKey === manifest.capabilityId || artifactKey.startsWith(`${manifest.capabilityId}:`))
+                        hashes[artifactKey.slice(manifest.capabilityId.length).replace(/^:/, "") || "default"] = createHash("sha256").update(Buffer.from(value, "base64url")).digest("hex");
+                const preview = { ...capability.preview, artifactHashes: hashes };
+                const transportPublicKey = app.store.getSecret("identity:x25519-public")?.toString("base64url") ?? fail("IDENTITY_MISSING", "seller transport key is missing");
+                const signature = (await signer.signPersonalMessage(Buffer.from(`${manifest.manifestHash}:${transportPublicKey}`))).signature;
+                await db.putCatalog({ seller_id: seller.sellerId, capability_id: manifest.capabilityId, manifest, blob_id: blobId, signature, transport_public_key: transportPublicKey, preview });
+            }
+            await db.putSnapshot(encryptSellerSnapshot(await captureSellerHome(seller.home, seller.sellerId, artifacts), key));
+            process.stdout.write(`${JSON.stringify({ sellerId: seller.sellerId, capabilities: seller.capabilities.map((item) => item.manifest.capabilityId), status: "provisioned" })}\n`);
+        }
+        finally {
+            app.close();
+        }
+    }
+}
+main().catch((error) => { process.stderr.write(`${error instanceof Error ? error.message : "provision failed"}\n`); process.exitCode = 1; });

package/dist/seller-register-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/seller-register-cli.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { readFileSync, statSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import { createCapabilityManifest } from "./capability.js";
+import { fail } from "./errors.js";
+import { Phase3App, errorOutput } from "./phase3.js";
+import { executeMandated, loadMandate } from "./mandate.js";
+async function main() {
+    const home = process.argv[2], specPath = process.argv[3], outputPath = process.argv[4];
+    if (!home || !specPath || !outputPath)
+        return fail("ARGUMENT_REQUIRED", "usage: supercuts-seller-register <seller-home> <capability-spec.json> <registration.json>");
+    if ((statSync(specPath).mode & 0o077) !== 0)
+        fail("SELLER_CONFIG_PERMISSIONS", "capability spec must be owner-only");
+    const spec = JSON.parse(readFileSync(specPath, "utf8"));
+    const app = new Phase3App(home);
+    try {
+        if (app.profile.role !== "seller" || app.profile.mock)
+            fail("SELLER_LIVE_REQUIRED", "registration requires a live seller role home");
+        const encoded = app.store.getSecret("live:sui-private-key")?.toString() ?? fail("LIVE_CREDENTIAL_MISSING", "seller signer is missing");
+        const decoded = decodeSuiPrivateKey(encoded);
+        if (decoded.scheme !== "ED25519")
+            fail("SIGNER_UNSUPPORTED", "seller requires an ED25519 signer");
+        const signer = Ed25519Keypair.fromSecretKey(decoded.secretKey), manifest = createCapabilityManifest({ ...spec, sellerId: signer.toSuiAddress() });
+        const published = await executeMandated(app, loadMandate(home), "capability.publish", { "operation-id": `publish-${manifest.manifestHash}`, manifest });
+        const blobId = String(published.blobId ?? "");
+        if (!blobId)
+            fail("WALRUS_PUBLISH_FAILED", "capability publication omitted a Walrus blob ID");
+        const transportPublicKey = app.store.getSecret("identity:x25519-public")?.toString("base64url") ?? fail("IDENTITY_MISSING", "seller transport key is missing");
+        const sellerSignature = (await signer.signPersonalMessage(Buffer.from(`${manifest.manifestHash}:${transportPublicKey}`))).signature;
+        const registration = { manifest, manifestBlobId: blobId, transportPublicKey, sellerSignature };
+        writeFileSync(resolve(outputPath), `${JSON.stringify(registration, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        process.stdout.write(`${JSON.stringify({ ok: true, capabilityId: manifest.capabilityId, manifestBlobId: blobId, registrationFile: resolve(outputPath) })}\n`);
+    }
+    finally {
+        app.close();
+    }
+}
+main().catch((error) => { process.stdout.write(`${JSON.stringify(errorOutput(error))}\n`); process.exitCode = 1; });

package/dist/seller-runtime.d.ts

@@ -0,0 +1,60 @@
+import { type SignedCapabilityRegistration } from "./capability.js";
+import type { RoleStore } from "./store.js";
+export interface ServiceRequest {
+    dealId: string;
+    capabilityId: string;
+    input: Record<string, unknown>;
+    requestId: string;
+    paymentDigest: string;
+    agreementHash: string;
+    agreedAmount: string;
+    rail: "shielded" | "x402";
+}
+export interface ServiceResult {
+    artifact: Uint8Array;
+    contentType: string;
+    metadata: Record<string, unknown>;
+}
+export type ServiceHandler = (request: ServiceRequest) => Promise<ServiceResult>;
+export interface VerifiedSellerPayment {
+    finalized: true;
+    tatumVerified: true;
+    digest: string;
+    agreementHash: string;
+    sellerId: string;
+    asset: string;
+    amount: string;
+    rail: "shielded" | "x402";
+}
+export interface SellerRuntimePorts {
+    readBlob(blobId: string): Promise<Uint8Array>;
+    verifyPayment(request: ServiceRequest): Promise<VerifiedSellerPayment>;
+    encryptAndPublish(request: ServiceRequest, result: ServiceResult): Promise<{
+        blobId: string;
+        ciphertext: Uint8Array;
+    }>;
+    serve(runtime: SellerRuntime): Promise<void>;
+}
+export interface SellerDelivery {
+    dealId: string;
+    requestId: string;
+    blobId: string;
+    ciphertextHash: string;
+    artifactSha256: string;
+    contentType: string;
+    metadata: Record<string, unknown>;
+}
+/** Framework-neutral seller execution boundary. The trusted payment verifier
+ * must use chain finality and exact agreement binding, never a buyer's digest
+ * alone. The transport must decrypt/authenticate task input before calling
+ * fulfill and encrypt the artifact before Walrus publication. */
+export declare class SellerRuntime {
+    #private;
+    private readonly store;
+    private readonly ports;
+    constructor(store: RoleStore, ports: SellerRuntimePorts);
+    registerCapability(registration: SignedCapabilityRegistration, handler: ServiceHandler): Promise<void>;
+    catalog(): Array<SignedCapabilityRegistration>;
+    fulfill(request: ServiceRequest): Promise<SellerDelivery>;
+    serve(): Promise<void>;
+}

package/dist/seller-runtime.js

@@ -0,0 +1,96 @@
+import { createHash } from "node:crypto";
+import { verifySignedCapability, validateCapabilityPayload } from "./capability.js";
+import { fail } from "./errors.js";
+import { canonicalJson } from "./settlement.js";
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+const cacheKey = (requestId) => `seller:delivery:${requestId}`;
+/** Framework-neutral seller execution boundary. The trusted payment verifier
+ * must use chain finality and exact agreement binding, never a buyer's digest
+ * alone. The transport must decrypt/authenticate task input before calling
+ * fulfill and encrypt the artifact before Walrus publication. */
+export class SellerRuntime {
+    store;
+    ports;
+    #handlers = new Map();
+    constructor(store, ports) {
+        this.store = store;
+        this.ports = ports;
+        store.db.exec("CREATE TABLE IF NOT EXISTS seller_runtime_deliveries(request_id TEXT PRIMARY KEY,request_hash TEXT NOT NULL,status TEXT NOT NULL,blob_id TEXT,artifact_sha256 TEXT,created_at INTEGER NOT NULL)");
+    }
+    async registerCapability(registration, handler) {
+        await verifySignedCapability(registration);
+        const bytes = await this.ports.readBlob(registration.manifestBlobId);
+        let remote;
+        try {
+            remote = JSON.parse(Buffer.from(bytes).toString());
+        }
+        catch (error) {
+            return fail("CAPABILITY_BLOB_INVALID", "Walrus capability blob is not JSON", error);
+        }
+        if (canonicalJson(remote) !== canonicalJson(registration.manifest))
+            fail("CAPABILITY_BLOB_MISMATCH", "Walrus capability blob differs from the seller's signed manifest");
+        const id = registration.manifest.capabilityId;
+        const prior = this.#handlers.get(id);
+        const saved = this.store.getSecret(`seller:capability:${id}`);
+        const old = saved ? JSON.parse(saved.toString()) : prior?.registration;
+        if (old && old.manifest.manifestHash !== registration.manifest.manifestHash) {
+            if (old.manifest.expiresAt > Date.now() || old.manifest.sellerId !== registration.manifest.sellerId || old.manifest.capabilityId !== id)
+                fail("SELLER_CAPABILITY_CONFLICT", "an active capability cannot be replaced with different terms");
+            this.store.putSecret(`seller:capability:${id}`, Buffer.from(canonicalJson(registration)));
+        }
+        else
+            this.store.putSecretOnce(`seller:capability:${id}`, Buffer.from(canonicalJson(registration)));
+        this.#handlers.set(id, { registration, handler });
+    }
+    catalog() { return [...this.#handlers.values()].map((item) => item.registration); }
+    async fulfill(request) {
+        if (!request || typeof request.requestId !== "string" || !/^[A-Za-z0-9._:-]{1,128}$/.test(request.requestId) || typeof request.dealId !== "string" || !request.dealId || typeof request.paymentDigest !== "string" || !request.paymentDigest || typeof request.agreementHash !== "string" || !/^[0-9a-f]{64}$/.test(request.agreementHash) || typeof request.agreedAmount !== "string" || !/^[1-9][0-9]*$/.test(request.agreedAmount) || !request.input || typeof request.input !== "object" || Array.isArray(request.input))
+            fail("SELLER_REQUEST_INVALID", "deal or request identity is invalid");
+        const registered = this.#handlers.get(request.capabilityId) ?? fail("SELLER_CAPABILITY_UNKNOWN", "capability is not registered");
+        const manifest = registered.registration.manifest;
+        if (!manifest.supportedRails.includes(request.rail))
+            fail("SELLER_RAIL_UNSUPPORTED", "seller capability does not offer this payment rail");
+        if (BigInt(request.agreedAmount) < BigInt(manifest.priceBand.minimum) || BigInt(request.agreedAmount) > BigInt(manifest.priceBand.maximum))
+            fail("SELLER_PAYMENT_UNVERIFIED", "agreed amount is outside the signed capability price band");
+        validateCapabilityPayload(manifest, "input", request.input);
+        const requestHash = sha256(canonicalJson({ domain: "supercuts-seller-request-v1", request }));
+        const prior = this.store.db.prepare("SELECT request_hash,status FROM seller_runtime_deliveries WHERE request_id=?").get(request.requestId);
+        if (prior && prior.request_hash !== requestHash)
+            fail("SELLER_REQUEST_CONFLICT", "request ID identifies a different task or payment");
+        if (prior?.status === "complete") {
+            const saved = this.store.getSecret(cacheKey(request.requestId)) ?? fail("SELLER_DELIVERY_CORRUPT", "completed delivery metadata is missing");
+            return JSON.parse(saved.toString());
+        }
+        if (prior)
+            fail("SELLER_DELIVERY_UNRESOLVED", "seller request may already have run; operator reconciliation is required");
+        const payment = await this.ports.verifyPayment(request);
+        if (payment.finalized !== true || payment.tatumVerified !== true || payment.digest !== request.paymentDigest || payment.agreementHash !== request.agreementHash || payment.sellerId !== manifest.sellerId || payment.asset !== manifest.asset || payment.amount !== request.agreedAmount || payment.rail !== request.rail)
+            fail("SELLER_PAYMENT_UNVERIFIED", "final payment does not match the signed capability and agreement");
+        this.store.db.prepare("INSERT INTO seller_runtime_deliveries(request_id,request_hash,status,created_at) VALUES(?,?,'running',?)").run(request.requestId, requestHash, Date.now());
+        const result = await registered.handler(request);
+        if (!(result.artifact instanceof Uint8Array) || result.artifact.length > 512 * 1024 || !result.artifact.length || typeof result.contentType !== "string" || !result.contentType)
+            fail("DEAL_ARTIFACT_TOO_LARGE", "seller artifact must contain 1..524288 bytes and a content type");
+        if (!result.metadata || typeof result.metadata !== "object" || Array.isArray(result.metadata))
+            fail("CAPABILITY_PAYLOAD_INVALID", "seller metadata must be an object");
+        validateCapabilityPayload(manifest, "output", result.metadata);
+        const published = await this.ports.encryptAndPublish(request, result);
+        if (!published.blobId || !(published.ciphertext instanceof Uint8Array) || !published.ciphertext.length)
+            fail("SELLER_DELIVERY_INVALID", "encrypted delivery publication is incomplete");
+        const fetched = await this.ports.readBlob(published.blobId);
+        if (!Buffer.from(fetched).equals(Buffer.from(published.ciphertext)))
+            fail("WALRUS_BLOB_MISMATCH", "encrypted seller delivery failed Walrus readback");
+        const delivery = { dealId: request.dealId, requestId: request.requestId, blobId: published.blobId, ciphertextHash: sha256(published.ciphertext), artifactSha256: sha256(result.artifact), contentType: result.contentType, metadata: result.metadata };
+        this.store.db.exec("BEGIN IMMEDIATE");
+        try {
+            this.store.putSecretOnce(cacheKey(request.requestId), Buffer.from(canonicalJson(delivery)));
+            this.store.db.prepare("UPDATE seller_runtime_deliveries SET status='complete',blob_id=?,artifact_sha256=? WHERE request_id=? AND status='running'").run(delivery.blobId, delivery.artifactSha256, request.requestId);
+            this.store.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.store.db.exec("ROLLBACK");
+            throw error;
+        }
+        return delivery;
+    }
+    serve() { return this.ports.serve(this); }
+}

package/dist/seller-service.d.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { type IncomingMessage, type ServerResponse } from "node:http";
+import { SellerDatabase } from "./seller-database.js";
+export declare class SellerService {
+    #private;
+    private readonly db;
+    private readonly snapshotKey;
+    private readonly origin;
+    private readonly facilitatorUrl;
+    private readonly facilitatorKey;
+    private readonly allowedBuyers;
+    private readonly directoryAggregator?;
+    private constructor();
+    static create(config: {
+        db: SellerDatabase;
+        snapshotKey: string;
+        origin: string;
+        facilitatorUrl: string;
+        facilitatorKey: string;
+        allowedBuyers: ReadonlySet<string>;
+        claudeKey: string;
+        directoryAggregator?: string;
+    }): Promise<SellerService>;
+    private artifact;
+    private resource;
+    private persist;
+    private publishCiphertext;
+    private serialize;
+    private body;
+    private reply;
+    handle(request: IncomingMessage, response: ServerResponse): Promise<void>;
+    createServer(): import("http").Server<typeof IncomingMessage, typeof ServerResponse>;
+    close(): void;
+}