@supercuts-walrus/backend 0.0.0-stage → 0.1.1

package/dist/x402-resource-service.js

@@ -0,0 +1,173 @@
+import { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
+import { fail, SupercutsError } from "./errors.js";
+import { paymentBindingBytes, PaymentConsumptionLedger, requirementsHash, verifyBinding, verifyExactPayment } from "./x402.js";
+import { isValidPersonalMessageSignature } from "@mysten/sui/verify";
+const encode = (value) => Buffer.from(JSON.stringify(value)).toString("base64");
+function decode(value, code) {
+    const encoded = value ?? fail(code, "required x402 header is missing");
+    try {
+        const parsed = JSON.parse(Buffer.from(encoded, "base64").toString());
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            fail(code, "x402 header must encode an object");
+        return parsed;
+    }
+    catch (error) {
+        return fail(code, "x402 header is not valid base64 JSON", error);
+    }
+}
+function safeUrl(value) { try {
+    return new URL(value);
+}
+catch (error) {
+    return fail("X402_CONFIG_INVALID", "x402 service URL is invalid", error);
+} }
+/** Seller-owned standard x402 v2 exact resource with additional request-binding replay protection. */
+export class X402ResourceService {
+    config;
+    http;
+    persist;
+    claimExternal;
+    #ledger;
+    #artifacts = new Map();
+    #origin;
+    #facilitator;
+    #prefix;
+    constructor(store, config, http = fetch, persist, claimExternal) {
+        this.config = config;
+        this.http = http;
+        this.persist = persist;
+        this.claimExternal = claimExternal;
+        this.#ledger = new PaymentConsumptionLedger(store);
+        this.#origin = safeUrl(config.origin);
+        this.#facilitator = safeUrl(config.facilitatorUrl);
+        this.#prefix = (config.pathPrefix ?? "/capability").replace(/\/$/, "");
+        if (this.#origin.protocol !== "https:" && !(this.#origin.protocol === "http:" && ["localhost", "127.0.0.1", "::1"].includes(this.#origin.hostname)))
+            fail("X402_CONFIG_INVALID", "resource origin must use HTTPS except on loopback");
+        if (this.#facilitator.protocol !== "https:" && !(this.#facilitator.protocol === "http:" && ["localhost", "127.0.0.1", "::1"].includes(this.#facilitator.hostname)))
+            fail("X402_CONFIG_INVALID", "facilitator must use HTTPS except on loopback");
+        if (!/^0x[0-9a-f]{64}$/i.test(config.payTo) || !/^0x[0-9a-f]+::[A-Za-z0-9_]+::[A-Za-z0-9_]+$/.test(config.asset) || !/^[1-9][0-9]*$/.test(config.amount))
+            fail("X402_CONFIG_INVALID", "payTo, asset, or amount is invalid");
+        if (!config.facilitatorKey || config.facilitatorKey.length < 24 || config.facilitatorKey.length > 1024)
+            fail("X402_CONFIG_INVALID", "facilitatorKey must be an owner-only secret");
+    }
+    register(requestId, operationId, body) {
+        if (!requestId || !operationId || requestId.length > 256 || operationId.length > 256 || !body.length || body.length > 10 * 1024 * 1024)
+            fail("RESOURCE_INVALID", "artifact registration is invalid");
+        const existing = this.#artifacts.get(requestId), next = Buffer.from(body);
+        if (existing && (existing.operationId !== operationId || !existing.body.equals(next)))
+            fail("RESOURCE_REQUEST_CONFLICT", "request already identifies another artifact or operation");
+        this.#artifacts.set(requestId, { requestId, operationId, body: next });
+        return { url: new URL(`${this.#prefix}/${encodeURIComponent(requestId)}`, this.#origin).toString(), artifactSha256: (awaitHash(next)) };
+    }
+    requirements(artifact) {
+        return { scheme: "exact", network: this.config.network, amount: this.config.amount, asset: this.config.asset, payTo: this.config.payTo, maxTimeoutSeconds: this.config.maxTimeoutSeconds ?? 300, extra: { requestId: artifact.requestId, operationId: artifact.operationId } };
+    }
+    resourceUrl(requestId) { return new URL(`${this.#prefix}/${encodeURIComponent(requestId)}`, this.#origin).toString(); }
+    challenge(artifact) {
+        // The live Sui exact facilitator requires the x402 nonce to be exactly
+        // 32 random bytes (hex encoded), not merely an application nonce.
+        const requirements = this.requirements(artifact), baseHash = requirementsHash(requirements), nonce = this.#ledger.challenge(artifact.requestId, baseHash, () => randomBytes(32).toString("hex"));
+        const stored = this.#ledger.getChallenge(artifact.requestId, baseHash) ?? fail("X402_CHALLENGE_MISSING", "resource challenge was not persisted");
+        const expiresAt = stored.createdAt + requirements.maxTimeoutSeconds * 1_000;
+        requirements.extra = { ...requirements.extra, nonce, expiresAt };
+        // The nonce changes the signed requirement set and is persisted per request.
+        const finalHash = requirementsHash(requirements);
+        return { x402Version: 2, resource: { url: this.resourceUrl(artifact.requestId), description: "Supercuts seller capability artifact", mimeType: "application/json" }, accepts: [{ ...requirements, extra: { ...requirements.extra, requirementsHash: finalHash } }] };
+    }
+    async handle(request, response) {
+        try {
+            if (request.method !== "GET")
+                return this.send(response, 405, Buffer.from("Method Not Allowed"), { allow: "GET" });
+            const url = new URL(request.url ?? "/", this.#origin), prefix = `${this.#prefix}/`;
+            if (!url.pathname.startsWith(prefix))
+                return this.send(response, 404, Buffer.from("Not Found"));
+            const requestId = decodeURIComponent(url.pathname.slice(prefix.length)), artifact = this.#artifacts.get(requestId);
+            if (!artifact)
+                return this.send(response, 404, Buffer.from("Not Found"));
+            const challenge = this.challenge(artifact), requirements = challenge.accepts instanceof Array ? challenge.accepts[0] : fail("X402_STATE_INVALID", "challenge omitted requirements");
+            const paymentHeader = Array.isArray(request.headers["payment-signature"]) ? request.headers["payment-signature"][0] : request.headers["payment-signature"];
+            if (!paymentHeader) {
+                await this.persist?.();
+                return this.send(response, 402, Buffer.from("Payment Required"), { "payment-required": encode(challenge) });
+            }
+            const stored = this.#ledger.getChallenge(artifact.requestId, requirementsHash(this.requirements(artifact))) ?? fail("X402_CHALLENGE_MISSING", "resource challenge was not persisted");
+            if (!this.#ledger.isDeliveryComplete(artifact.requestId) && Date.now() > stored.createdAt + requirements.maxTimeoutSeconds * 1_000)
+                fail("X402_CHALLENGE_EXPIRED", "payment challenge has expired");
+            const payload = decode(paymentHeader, "X402_PAYMENT_INVALID"), bindingValue = Array.isArray(request.headers["x-supercuts-binding"]) ? request.headers["x-supercuts-binding"][0] : request.headers["x-supercuts-binding"], binding = decode(bindingValue, "X402_REQUEST_BINDING_INVALID");
+            const offered = payload.accepted;
+            if (!offered || requirementsHash(offered) !== requirementsHash(requirements))
+                fail("X402_REQUIREMENTS_MISMATCH", "payment payload changed the challenged requirements");
+            const extra = requirements.extra, nonce = String(extra.nonce ?? ""), declaredHash = String(extra.requirementsHash ?? ""), expiresAt = Number(extra.expiresAt);
+            const unsignedRequirements = { ...requirements, extra: { requestId: extra.requestId, operationId: extra.operationId, nonce, expiresAt } };
+            if (!Number.isSafeInteger(expiresAt) || expiresAt !== stored.createdAt + requirements.maxTimeoutSeconds * 1_000 || declaredHash !== requirementsHash(unsignedRequirements))
+                fail("X402_REQUIREMENTS_MISMATCH", "challenge requirements hash or expiry is invalid");
+            verifyBinding(binding, artifact.requestId, nonce, unsignedRequirements, binding.transactionDigest);
+            const { payerSignature: _signature, ...unsignedBinding } = binding;
+            if (!(await isValidPersonalMessageSignature(paymentBindingBytes(unsignedBinding), binding.payerSignature, { address: binding.payer })))
+                fail("X402_PAYER_SIGNATURE_INVALID", "payer did not bind payment to this resource request");
+            const body = { x402Version: 2, paymentPayload: payload, paymentRequirements: requirements };
+            const verified = await this.facilitator("verify", body);
+            if (verified.isValid !== true)
+                fail("X402_FACILITATOR_REJECTED", "facilitator rejected the signed payment");
+            const settled = await this.facilitator("settle", body), digest = String(settled.transaction ?? "");
+            if (settled.success !== true || settled.network !== this.config.network || digest !== binding.transactionDigest)
+                fail("X402_SETTLEMENT_INVALID", "facilitator returned mismatched settlement evidence");
+            const payment = { digest, network: this.config.network, asset: this.config.asset, amount: BigInt(this.config.amount), payTo: this.config.payTo, finalized: true };
+            verifyExactPayment(payment, requirements);
+            await this.claimExternal?.(digest, artifact.requestId);
+            this.#ledger.claim(payment, artifact.requestId);
+            let delivery = this.#ledger.getDelivery(artifact.requestId);
+            if (!this.#ledger.isDeliveryComplete(artifact.requestId)) {
+                if (!this.#ledger.acquireDelivery(artifact.requestId))
+                    fail("DELIVERY_IN_PROGRESS", "resource delivery is already being produced");
+                this.#ledger.completeDelivery(artifact.requestId, artifact.body);
+                delivery = artifact.body;
+            }
+            await this.persist?.();
+            return this.send(response, 200, delivery ?? fail("DELIVERY_STATE_INVALID", "completed delivery has no bytes"), { "content-type": "application/json", "payment-response": encode({ success: true, transaction: digest, network: this.config.network }) });
+        }
+        catch (error) {
+            const known = error instanceof SupercutsError ? error : new SupercutsError("INTERNAL_ERROR", "resource service failed");
+            return this.send(response, known.code === "PAYMENT_CONSUMED" ? 409 : 400, Buffer.from(JSON.stringify({ error: known.code, message: known.message })), { "content-type": "application/json" });
+        }
+    }
+    createServer() { return createServer((request, response) => void this.handle(request, response)); }
+    async facilitator(path, body) {
+        const endpoint = new URL(path, `${this.#facilitator.toString().replace(/\/$/, "")}/`);
+        const delays = this.config.facilitatorRetryDelaysMs ?? [0, 2_000, 5_000, 10_000];
+        let lastCause;
+        for (const delay of delays) {
+            if (delay > 0)
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            let response;
+            try {
+                response = await this.http(endpoint, { method: "POST", headers: { "content-type": "application/json", "x-supercuts-facilitator-key": this.config.facilitatorKey }, body: JSON.stringify(body), signal: AbortSignal.timeout(60_000) });
+            }
+            catch (error) {
+                lastCause = error;
+                continue;
+            }
+            const raw = Buffer.from(await response.arrayBuffer());
+            let value;
+            try {
+                value = JSON.parse(raw.toString("utf8"));
+            }
+            catch (error) {
+                lastCause = error;
+                continue;
+            }
+            if (response.ok && value && typeof value === "object" && !Array.isArray(value))
+                return value;
+            const message = value && typeof value === "object" && !Array.isArray(value) && typeof value.message === "string"
+                ? `: ${value.message}` : "";
+            if (response.status < 500)
+                fail("X402_FACILITATOR_INVALID", `facilitator ${path} failed with ${response.status}${message}`);
+            lastCause = new Error(`facilitator ${path} returned ${response.status}${message}`);
+        }
+        return fail("X402_FACILITATOR_UNAVAILABLE", `facilitator ${path} remained unavailable after bounded retries`, lastCause);
+    }
+    send(response, status, body, headers = {}) { response.writeHead(status, { "content-length": String(body.length), ...headers }); response.end(body); }
+}
+import { createHash } from "node:crypto";
+function awaitHash(value) { return createHash("sha256").update(value).digest("hex"); }

package/dist/x402.d.ts

@@ -0,0 +1,46 @@
+import { RoleStore } from "./store.js";
+export interface ExactRequirements {
+    scheme: "exact";
+    network: string;
+    amount: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra: Record<string, unknown>;
+}
+export interface PaymentBinding {
+    requestId: string;
+    nonce: string;
+    requirementsHash: string;
+    transactionDigest: string;
+    payer: string;
+    payerSignature: string;
+}
+export interface FinalPayment {
+    digest: string;
+    network: string;
+    asset: string;
+    amount: bigint;
+    payTo: string;
+    finalized: boolean;
+}
+export declare function requirementsHash(requirements: ExactRequirements): string;
+export declare function paymentBindingBytes(binding: Omit<PaymentBinding, "payerSignature">): Uint8Array;
+export declare class PaymentConsumptionLedger {
+    private readonly store;
+    constructor(store: RoleStore);
+    claim(payment: FinalPayment, requestId: string): void;
+    recordDelivery(requestId: string, response: Uint8Array): void;
+    getDelivery(requestId: string): Buffer | undefined;
+    isDeliveryComplete(requestId: string): boolean;
+    acquireDelivery(requestId: string, now?: number, leaseMs?: number): boolean;
+    releaseDelivery(requestId: string): void;
+    completeDelivery(requestId: string, response: Uint8Array): void;
+    challenge(requestId: string, requirementsHashValue: string, createNonce: () => string): string;
+    getChallenge(requestId: string, requirementsHashValue: string): {
+        nonce: string;
+        createdAt: number;
+    } | undefined;
+}
+export declare function verifyBinding(binding: PaymentBinding, requestId: string, nonce: string, requirements: ExactRequirements, transactionDigest: string): void;
+export declare function verifyExactPayment(payment: FinalPayment, requirements: ExactRequirements): void;

package/dist/x402.js

@@ -0,0 +1,136 @@
+import { createHash } from "node:crypto";
+import { fail } from "./errors.js";
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+    const result = JSON.stringify(value);
+    if (result === undefined)
+        fail("X402_REQUIREMENTS_INVALID", "x402 values must be JSON-compatible");
+    return result;
+}
+export function requirementsHash(requirements) { return createHash("sha256").update(canonical(requirements)).digest("hex"); }
+export function paymentBindingBytes(binding) {
+    return Buffer.from(canonical({ domain: "supercuts-x402-binding-v1", ...binding }));
+}
+export class PaymentConsumptionLedger {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    claim(payment, requestId) {
+        if (!payment.finalized)
+            fail("PAYMENT_PENDING", "payment is not finalized");
+        if (!payment.network || !payment.digest || payment.network.length > 256 || payment.digest.length > 256 || !requestId || requestId.length > 256)
+            fail("PAYMENT_ID_INVALID", "payment or request identity is invalid");
+        const key = createHash("sha256").update(canonical([payment.network, payment.digest])).digest("hex");
+        this.store.db.exec("BEGIN IMMEDIATE");
+        try {
+            const request = this.store.db.prepare("SELECT payment_key FROM deliveries WHERE request_id = ?").get(requestId);
+            if (request && request.payment_key !== key)
+                fail("REQUEST_PAYMENT_CONFLICT", "request is already bound to another payment");
+            const existing = this.store.db.prepare("SELECT request_id FROM deliveries WHERE payment_key = ?").get(key);
+            if (existing && existing.request_id !== requestId)
+                fail("PAYMENT_CONSUMED", "payment was already used for another request");
+            if (!existing)
+                this.store.db.prepare("INSERT INTO deliveries(request_id, payment_key, response, finalized) VALUES (?, ?, ?, 1)").run(requestId, key, Buffer.alloc(0));
+            this.store.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.store.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    recordDelivery(requestId, response) {
+        const result = this.store.db.prepare("UPDATE deliveries SET response = ?, finalized = 1 WHERE request_id = ?").run(Buffer.from(response), requestId);
+        if (result.changes !== 1)
+            fail("PAYMENT_NOT_CLAIMED", "resource cannot be delivered before payment consumption");
+    }
+    getDelivery(requestId) {
+        const row = this.store.db.prepare("SELECT response FROM deliveries WHERE request_id = ?").get(requestId);
+        return row ? Buffer.from(row.response) : undefined;
+    }
+    isDeliveryComplete(requestId) {
+        const row = this.store.db.prepare("SELECT status FROM delivery_jobs WHERE request_id = ?").get(requestId);
+        return row?.status === "delivered";
+    }
+    acquireDelivery(requestId, now = Date.now(), leaseMs = 30_000) {
+        this.store.db.exec("BEGIN IMMEDIATE");
+        try {
+            const row = this.store.db.prepare("SELECT status, lease_until FROM delivery_jobs WHERE request_id = ?").get(requestId);
+            if (row?.status === "delivered" || (row?.status === "producing" && row.lease_until > now)) {
+                this.store.db.exec("COMMIT");
+                return false;
+            }
+            this.store.db.prepare("INSERT INTO delivery_jobs(request_id, status, lease_until) VALUES (?, 'producing', ?) ON CONFLICT(request_id) DO UPDATE SET status='producing', lease_until=excluded.lease_until").run(requestId, now + leaseMs);
+            this.store.db.exec("COMMIT");
+            return true;
+        }
+        catch (error) {
+            this.store.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    releaseDelivery(requestId) { this.store.db.prepare("UPDATE delivery_jobs SET status = 'pending', lease_until = 0 WHERE request_id = ? AND status = 'producing'").run(requestId); }
+    completeDelivery(requestId, response) {
+        this.store.db.exec("BEGIN IMMEDIATE");
+        try {
+            this.recordDelivery(requestId, response);
+            this.store.db.prepare("INSERT INTO delivery_jobs(request_id, status, lease_until) VALUES (?, 'delivered', 0) ON CONFLICT(request_id) DO UPDATE SET status='delivered', lease_until=0").run(requestId);
+            this.store.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.store.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    challenge(requestId, requirementsHashValue, createNonce) {
+        const existing = this.store.db.prepare("SELECT nonce, requirements_hash FROM x402_challenges WHERE request_id = ?").get(requestId);
+        if (existing) {
+            if (existing.requirements_hash !== requirementsHashValue)
+                fail("X402_REQUEST_CONFLICT", "request identity was reused with different requirements");
+            return existing.nonce;
+        }
+        const nonce = createNonce();
+        this.store.db.prepare("INSERT INTO x402_challenges(request_id, nonce, requirements_hash, created_at) VALUES (?, ?, ?, ?)").run(requestId, nonce, requirementsHashValue, Date.now());
+        return nonce;
+    }
+    getChallenge(requestId, requirementsHashValue) {
+        const row = this.store.db.prepare("SELECT nonce, requirements_hash, created_at FROM x402_challenges WHERE request_id = ?").get(requestId);
+        if (row && row.requirements_hash !== requirementsHashValue)
+            fail("X402_REQUEST_CONFLICT", "request identity was reused with different requirements");
+        return row ? { nonce: row.nonce, createdAt: row.created_at } : undefined;
+    }
+}
+export function verifyBinding(binding, requestId, nonce, requirements, transactionDigest) {
+    if (!binding.payer || !binding.payerSignature || binding.payer.length > 256 || binding.payerSignature.length > 2048)
+        fail("X402_REQUEST_BINDING_INVALID", "payer binding identity or signature is invalid");
+    if (binding.requestId !== requestId || binding.nonce !== nonce || binding.transactionDigest !== transactionDigest || binding.requirementsHash !== requirementsHash(requirements))
+        fail("X402_REQUEST_BINDING_INVALID", "payment does not bind to this request");
+}
+export function verifyExactPayment(payment, requirements) {
+    if (requirements.scheme !== "exact" || !Number.isSafeInteger(requirements.maxTimeoutSeconds) || requirements.maxTimeoutSeconds <= 0)
+        fail("X402_REQUIREMENTS_INVALID", "exact requirements need a positive integer timeout");
+    if (!requirements.network || !requirements.asset || !requirements.payTo || requirements.network.length > 256 || requirements.asset.length > 512 || requirements.payTo.length > 256)
+        fail("X402_REQUIREMENTS_INVALID", "payment network, asset, or recipient is invalid");
+    if (!payment.finalized)
+        fail("PAYMENT_PENDING", "payment is not finalized");
+    let required;
+    try {
+        required = BigInt(requirements.amount);
+    }
+    catch (error) {
+        return fail("X402_REQUIREMENTS_INVALID", "payment amount is not an integer", error);
+    }
+    if (payment.network !== requirements.network)
+        fail("X402_NETWORK_MISMATCH", "payment used the wrong network");
+    if (payment.asset !== requirements.asset)
+        fail("X402_ASSET_MISMATCH", "payment used the wrong asset");
+    if (required <= 0n)
+        fail("X402_REQUIREMENTS_INVALID", "payment amount must be positive");
+    if (payment.amount !== required)
+        fail("X402_AMOUNT_MISMATCH", "payment used the wrong exact amount");
+    if (payment.payTo !== requirements.payTo)
+        fail("X402_PAYEE_MISMATCH", "payment used the wrong recipient");
+}

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@supercuts-walrus/backend",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "private": false,
+  "type": "module",
+  "exports": {
+    "./seam": "./dist/seam.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "supercuts": "dist/cli.js",
+    "supercuts-demo": "dist/demo.js",
+    "supercuts-mcp": "dist/mcp-bootstrap.js",
+    "supercuts-resource": "dist/resource-server.js",
+    "supercuts-seller-service": "dist/seller-service.js",
+    "supercuts-seller-provision": "dist/seller-provision.js",
+    "supercuts-seller-watch": "dist/seller-watch.js",
+    "supercuts-seller-catalog": "dist/seller-catalog-generate.js",
+    "supercuts-facilitator": "dist/facilitator.js",
+    "supercuts-seam": "dist/seam.js",
+    "supercuts-v2-relayer": "dist/v2-relayer-cli.js",
+    "supercuts-memory-worker": "dist/memory-worker.js",
+    "supercuts-seller-live": "dist/seller-live-cli.js",
+    "supercuts-seller-register": "dist/seller-register-cli.js",
+    "supercuts-seller-v2-provision": "dist/seller-v2-provision.js",
+    "supercuts-hosted-exit": "dist/hosted-exit-cli.js",
+    "supercuts-hosted-seller-import": "dist/hosted-seller-import.js",
+    "supercuts-seller-directory": "dist/seller-directory-cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=22.13"
+  },
+  "dependencies": {
+    "@mysten-incubation/memwal": "0.1.11",
+    "@mysten/seal": "1.5.2",
+    "@mysten/sui": "2.38.0",
+    "@mysten/walrus": "1.2.37",
+    "ajv": "8.17.1",
+    "circomlibjs": "0.1.7",
+    "pg": "^8.23.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "@types/pg": "^8.23.1",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check": "tsc --noEmit",
+    "test": "tsx --test test/**/*.test.ts",
+    "test:e2e": "tsx --test test/phase2.e2e.test.ts",
+    "test:phase3": "tsx --test test/phase3.e2e.test.ts",
+    "test:sdk": "pnpm --dir packages/sdk test",
+    "release:gate": "node scripts/release-gate.mjs",
+    "test:seal-live": "tsx scripts/seal-live-e2e.ts"
+  }
 }