spl-pay-per-suite 1.1.1

package/LICENSE

@@ -0,0 +1,5 @@
+Copyright (c) 2026 Slid Phi Labs. All rights reserved.
+
+This package provides client tooling for SPL Pay Per Suite (quotes, checkout links, job intake).
+Proprietary compression engines are not included. Commercial processing is fulfilled by Slid Phi Labs after payment.
+See https://www.slidphilabs.com/pps

package/README.md

@@ -0,0 +1,121 @@
+# SPL Pay Per Suite
+
+**On-spot project quotes · dual payment rails · lab job intake** for Slid Phi Labs.
+
+| Who | Rail |
+|-----|------|
+| **Humans** | Stripe · [slidphilabs.com/pps](https://www.slidphilabs.com/pps) |
+| **Agents** | **x402** · `POST /api/x402-suite` (402 → pay → retry) |
+
+- **npm:** `spl-pay-per-suite`
+- **CLI:** `spl-pps` · `pay-per-suite`
+- **MCP:** stdio tools including `spl_pps_x402_*`
+- **Discovery:** `GET https://www.slidphilabs.com/api/agent`
+
+Private engines stay in the lab. This package quotes, routes payment, and submits jobs — it does **not** ship proprietary codecs.
+
+## Install
+
+```bash
+npm i spl-pay-per-suite
+# or one-shot
+npx spl-pay-per-suite quote --bytes 1048576 --class zeros --product zrw
+```
+
+## CLI
+
+```bash
+spl-pps quote --bytes 5242880 --class mixed_ints --product auto --op compress
+spl-pps quote ./payload.bin
+spl-pps pay ./payload.bin --email you@company.com
+spl-pps job --email you@company.com --paid --file ./payload.bin
+spl-pps products
+```
+
+## Library
+
+```js
+import { computeQuote, createCheckout, submitJob, quoteFile } from "spl-pay-per-suite";
+
+const q = computeQuote({ product: "zrw", dataClass: "zeros", op: "compress", bytes: 1_000_000 });
+console.log(q.amount_display); // e.g. "37.00"
+
+const pay = await createCheckout({ ...q.breakdown, email: "you@company.com" });
+// open pay.url
+
+await submitJob({
+  email: "you@company.com",
+  paidConfirm: true,
+  amount_display: q.amount_display,
+  product: "zrw",
+  dataClass: "zeros",
+  op: "compress",
+  bytes: 1_000_000,
+});
+```
+
+## Agentic commerce (x402)
+
+**All standing products** + **metered suite jobs**.
+
+```bash
+# Discovery + catalog
+curl -s https://www.slidphilabs.com/api/agent | jq .
+curl -s https://www.slidphilabs.com/api/x402-products | jq .
+spl-pps x402
+spl-pps catalog
+
+# Buy CDDG:Split (probe 402, then pay + retry)
+spl-pps buy --sku cddg-split --email you@x.com
+# payFetch("https://www.slidphilabs.com/api/x402-products", { method:"POST", body: JSON.stringify({ sku: "cddg-split", email }) })
+
+# Metered suite job
+spl-pps x402-req --bytes 1048576 --class zeros --product zrw
+# payFetch("https://www.slidphilabs.com/api/x402-suite", { ... })
+```
+
+**SKUs:** `cddg-split` · `zrw-n00b` · `zrw-pro` · `zrw-l33t` · `blackjack` · `shard-zip` · `shard-tsdb` · `slid-phi` · `support-integration` · `consulting` · `sponsor` · `donate` · `try-gate`
+
+Server env (Vercel): `X402_PAY_TO`, `X402_ASSET`, `X402_NETWORK`, `SOLANA_RPC_URL`. Optional staging: `X402_DEV_BYPASS=1` + header `X-PAYMENT-DEV: ok`.
+
+## MCP
+
+```bash
+npx spl-pay-per-suite mcp-serve
+```
+
+```json
+{
+  "mcpServers": {
+    "spl-pay-per-suite": {
+      "command": "npx",
+      "args": ["-y", "spl-pay-per-suite", "mcp-serve"]
+    }
+  }
+}
+```
+
+**Tools:** `spl_pps_info` · `spl_pps_quote` · `spl_pps_checkout` · `spl_pps_submit_job` · `spl_pps_classify` · **`spl_pps_x402_info`** · **`spl_pps_x402_catalog`** · **`spl_pps_x402_buy`** · **`spl_pps_x402_requirements`** · **`spl_pps_x402_submit`**
+
+## Pricing model (public)
+
+| Factor | Role |
+|--------|------|
+| Product base | Service value (auto / ZRW / CDDG Split / family) |
+| Size | Progressive $/MB |
+| Data class | Shape multiplier |
+| Operation | compress · decompress · roundtrip |
+
+Min **$9** · max **$10,000** per job (Stripe custom-amount limit).
+
+## Env (optional)
+
+| Var | Default |
+|-----|---------|
+| `SPL_PPS_API` | `https://www.slidphilabs.com` |
+| `SPL_PPS_SITE` | `https://www.slidphilabs.com/pps` |
+| `SPL_PPS_PAYMENT_LINK` | live Stripe PPP / suite link |
+
+## License
+
+© 2026 Slid Phi Labs. Client tooling only; engines and commercial fulfillment remain proprietary.

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "spl-pay-per-suite",
+  "version": "1.1.1",
+  "description": "SPL Pay Per Suite \u2014 on-spot quotes, Stripe (humans) + x402 agentic commerce (machines). Library, CLI, and MCP.",
+  "type": "module",
+  "main": "src/index.mjs",
+  "exports": {
+    ".": "./src/index.mjs",
+    "./quote": "./src/quote.mjs"
+  },
+  "bin": {
+    "spl-pps": "src/cli.mjs",
+    "spl-pay-per-suite": "src/cli.mjs",
+    "pay-per-suite": "src/cli.mjs"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "mcp": "node src/mcp-server.mjs"
+  },
+  "keywords": [
+    "slid-phi-labs",
+    "spl",
+    "pay-per-suite",
+    "ppp",
+    "compression",
+    "stripe",
+    "x402",
+    "agentic",
+    "mcp",
+    "cli",
+    "quote",
+    "agentic-commerce",
+    "agent-commerce",
+    "agents.txt",
+    "llms.txt",
+    "solana",
+    "base",
+    "usdc"
+  ],
+  "author": "Slid Phi Labs",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://www.slidphilabs.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ceedot-rock/SlidPhiLabs.git",
+    "directory": "packages/spl-pay-per-suite"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "https://www.slidphilabs.com/api/agent"
+  },
+  "agentic": {
+    "commerce": "x402",
+    "discovery": "https://www.slidphilabs.com/api/agent",
+    "catalog": "https://www.slidphilabs.com/api/x402-products",
+    "agents_txt": "https://www.slidphilabs.com/agents.txt",
+    "agents_json": "https://www.slidphilabs.com/agents.json",
+    "llms_txt": "https://www.slidphilabs.com/llms.txt",
+    "agent_card": "https://www.slidphilabs.com/.well-known/agent-card.json",
+    "agentic_commerce": "https://www.slidphilabs.com/.well-known/agentic-commerce.json",
+    "networks": [
+      "solana-mainnet-beta",
+      "eip155:8453"
+    ],
+    "payment_header": "X-PAYMENT",
+    "one_liner": "Agent commerce: GET https://www.slidphilabs.com/api/agent then pay via x402 on Solana or Base mainnet (X-PAYMENT) on catalog POST.",
+    "site": "https://www.slidphilabs.com"
+  },
+  "x402": {
+    "discovery": "https://www.slidphilabs.com/api/agent",
+    "catalog": "https://www.slidphilabs.com/api/x402-products",
+    "networks": [
+      "solana-mainnet-beta",
+      "eip155:8453"
+    ],
+    "payment_header": "X-PAYMENT"
+  },
+  "bugs": {
+    "url": "https://www.slidphilabs.com"
+  }
+}

package/src/cli.mjs

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+/**
+ * SPL Pay Per Suite CLI
+ *   spl-pps quote --bytes 1048576 --class zeros --product zrw --op compress
+ *   spl-pps quote ./data.bin
+ *   spl-pps pay --bytes ... [--email you@x.com]
+ *   spl-pps job --email you@x.com --paid --file data.bin
+ *   spl-pps mcp   (hint: run MCP server)
+ */
+import {
+  computeQuote,
+  quoteRemote,
+  createCheckout,
+  submitJob,
+  quoteFile,
+  agentDiscovery,
+  x402Catalog,
+  x402ProductRequirements,
+  x402BuyProduct,
+  x402Requirements,
+  x402SubmitJob,
+  X402_SUITE_URL,
+  X402_PRODUCTS_URL,
+  SERVICE_NAME,
+  SITE_PPS,
+  STRIPE_PAYMENT_LINK,
+  PRODUCT_BASE,
+  DATA_MULT,
+  OP_MULT,
+} from "./index.mjs";
+
+function usage() {
+  console.log(`
+${SERVICE_NAME} — humans: Stripe · agents: x402
+
+Usage:
+  spl-pps quote [file] [--bytes N] [--class CLASS] [--product P] [--op compress|decompress|roundtrip]
+  spl-pps pay   [file] [same flags] [--email you@domain.com]     # Stripe (humans)
+  spl-pps job   --email you@domain.com [--paid] [--file path]   # after Stripe
+  spl-pps x402                 # agent discovery
+  spl-pps catalog              # standing products (x402)
+  spl-pps buy --sku cddg-split [--email] [--payment HDR | --dev-bypass]
+  spl-pps x402-req [flags]     # metered suite job 402 probe
+  spl-pps x402-job [flags]     # metered suite job submit
+  spl-pps products
+  spl-pps open
+
+Suite tools: ${Object.keys(PRODUCT_BASE).join(", ")}
+Classes:     ${Object.keys(DATA_MULT).join(", ")}
+Ops:         ${Object.keys(OP_MULT).join(", ")}
+
+Site:          ${SITE_PPS}
+Stripe:        ${STRIPE_PAYMENT_LINK}
+x402 products: ${X402_PRODUCTS_URL}
+x402 jobs:     ${X402_SUITE_URL}
+Agent pay:     x402-client payFetch against product or job URL
+`);
+}
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--bytes" || a === "-b") args.bytes = Number(argv[++i]);
+    else if (a === "--class" || a === "-c") args.dataClass = argv[++i];
+    else if (a === "--product" || a === "-p") args.product = argv[++i];
+    else if (a === "--op" || a === "-o") args.op = argv[++i];
+    else if (a === "--email" || a === "-e") args.email = argv[++i];
+    else if (a === "--file" || a === "-f") args.file = argv[++i];
+    else if (a === "--note") args.note = argv[++i];
+    else if (a === "--paid") args.paid = true;
+    else if (a === "--remote") args.remote = true;
+    else if (a === "--payment") args.payment = argv[++i];
+    else if (a === "--sku") args.sku = argv[++i];
+    else if (a === "--dev-bypass") args.devBypass = true;
+    else if (a === "--help" || a === "-h") args.help = true;
+    else if (a.startsWith("-")) {
+      console.error("Unknown flag:", a);
+      process.exit(2);
+    } else args._.push(a);
+  }
+  return args;
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const cmd = argv[0] || "help";
+  const args = parseArgs(argv.slice(1));
+
+  if (cmd === "help" || args.help) {
+    usage();
+    return;
+  }
+
+  if (cmd === "products") {
+    console.log(JSON.stringify({ service: SERVICE_NAME, products: PRODUCT_BASE, classes: DATA_MULT, ops: OP_MULT }, null, 2));
+    return;
+  }
+
+  if (cmd === "open") {
+    console.log(SITE_PPS);
+    return;
+  }
+
+  if (cmd === "mcp") {
+    console.log("Start MCP:  node src/mcp-server.mjs");
+    console.log("Or:         npm run mcp --prefix packages/spl-pay-per-suite");
+    console.log("Config:     { \"command\": \"npx\", \"args\": [\"-y\", \"spl-pay-per-suite\", \"mcp-serve\"] }");
+    return;
+  }
+
+  if (cmd === "mcp-serve") {
+    await import("./mcp-server.mjs");
+    return;
+  }
+
+  if (cmd === "x402" || cmd === "agent") {
+    console.log(JSON.stringify(await agentDiscovery(), null, 2));
+    return;
+  }
+
+  if (cmd === "catalog" || cmd === "x402-catalog") {
+    console.log(JSON.stringify(await x402Catalog(), null, 2));
+    return;
+  }
+
+  if (cmd === "buy" || cmd === "x402-buy") {
+    const sku = args.sku || args.product || args._[0];
+    if (!sku) {
+      console.error("--sku required (e.g. cddg-split, zrw-n00b, blackjack)");
+      process.exit(1);
+    }
+    const opts = {
+      sku,
+      email: args.email || "",
+      note: args.note || "",
+      paymentHeader: args.payment,
+      devBypass: !!args.devBypass,
+    };
+    try {
+      // no payment → show requirements
+      if (!opts.paymentHeader && !opts.devBypass) {
+        console.log(JSON.stringify(await x402ProductRequirements(opts), null, 2));
+        return;
+      }
+      console.log(JSON.stringify(await x402BuyProduct(opts), null, 2));
+    } catch (e) {
+      if (e.status === 402) {
+        console.error("# Payment required — pay accepts[0] then: spl-pps buy --sku " + sku + " --payment <HDR>");
+        console.log(JSON.stringify(e.requirements, null, 2));
+        process.exit(402 % 256);
+      }
+      throw e;
+    }
+    return;
+  }
+
+  if (cmd === "x402-req" || cmd === "x402-requirements") {
+    const file = args.file || args._[0];
+    let opts = {
+      product: args.product || "auto",
+      dataClass: args.dataClass || "unknown",
+      op: args.op || "compress",
+      bytes: args.bytes || 0,
+      email: args.email || "",
+      note: args.note || "",
+    };
+    if (file) {
+      const qf = await quoteFile(file, args);
+      opts = {
+        ...opts,
+        product: args.product || qf.classification.tool || "auto",
+        dataClass: args.dataClass || qf.classification.dataClass,
+        bytes: qf.bytes,
+        fileName: qf.fileName,
+      };
+    }
+    console.log(JSON.stringify(await x402Requirements(opts), null, 2));
+    return;
+  }
+
+  if (cmd === "x402-job") {
+    const file = args.file || args._[0];
+    let opts = {
+      product: args.product || "auto",
+      dataClass: args.dataClass || "unknown",
+      op: args.op || "compress",
+      bytes: args.bytes || 0,
+      email: args.email || "",
+      note: args.note || "",
+      paymentHeader: args.payment,
+      devBypass: !!args.devBypass,
+    };
+    if (file) {
+      const qf = await quoteFile(file, args);
+      opts.bytes = qf.bytes;
+      opts.fileName = qf.fileName;
+      opts.product = args.product || qf.classification.tool || "auto";
+      opts.dataClass = args.dataClass || qf.classification.dataClass;
+    }
+    try {
+      console.log(JSON.stringify(await x402SubmitJob(opts), null, 2));
+    } catch (e) {
+      if (e.status === 402) {
+        console.error("# Payment required — pay accepts[0] then retry with --payment");
+        console.log(JSON.stringify(e.requirements, null, 2));
+        process.exit(402 % 256);
+      }
+      throw e;
+    }
+    return;
+  }
+
+  if (cmd === "quote") {
+    const file = args.file || args._[0];
+    let result;
+    if (file) {
+      result = await quoteFile(file, args);
+    } else {
+      const opts = {
+        product: args.product || "auto",
+        dataClass: args.dataClass || "unknown",
+        op: args.op || "compress",
+        bytes: args.bytes || 0,
+      };
+      result = args.remote ? await quoteRemote(opts) : computeQuote(opts);
+    }
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  if (cmd === "pay") {
+    const file = args.file || args._[0];
+    let opts = {
+      product: args.product || "auto",
+      dataClass: args.dataClass || "unknown",
+      op: args.op || "compress",
+      bytes: args.bytes || 0,
+      email: args.email || "",
+    };
+    if (file) {
+      const qf = await quoteFile(file, args);
+      opts = {
+        ...opts,
+        product: args.product || qf.classification.tool || "auto",
+        dataClass: args.dataClass || qf.classification.dataClass,
+        bytes: qf.bytes,
+      };
+      console.error(`# ${SERVICE_NAME} quote for ${qf.fileName}: $${qf.quote.amount_display}`);
+    } else {
+      const q = computeQuote(opts);
+      console.error(`# ${SERVICE_NAME} quote: $${q.amount_display}`);
+    }
+    const chk = await createCheckout(opts);
+    console.log(JSON.stringify(chk, null, 2));
+    if (chk.url) console.error(`\nOpen: ${chk.url}`);
+    if (chk.instructions) console.error(chk.instructions);
+    return;
+  }
+
+  if (cmd === "job") {
+    if (!args.email) {
+      console.error("--email required");
+      process.exit(1);
+    }
+    let opts = {
+      email: args.email,
+      product: args.product || "auto",
+      dataClass: args.dataClass || "unknown",
+      op: args.op || "compress",
+      bytes: args.bytes || 0,
+      paidConfirm: !!args.paid,
+      note: args.note || "",
+      fileName: "",
+    };
+    const file = args.file || args._[0];
+    if (file) {
+      const qf = await quoteFile(file, args);
+      opts.fileName = qf.fileName;
+      opts.bytes = qf.bytes;
+      opts.product = args.product || qf.classification.tool;
+      opts.dataClass = args.dataClass || qf.classification.dataClass;
+      opts.amount_display = qf.quote.amount_display;
+      opts.tool = qf.classification.tool;
+    } else {
+      opts.amount_display = computeQuote(opts).amount_display;
+    }
+    const job = await submitJob(opts);
+    console.log(JSON.stringify(job, null, 2));
+    return;
+  }
+
+  usage();
+  process.exit(1);
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/src/index.mjs

@@ -0,0 +1,333 @@
+/**
+ * SPL Pay Per Suite — client SDK
+ * Quote on the spot · Stripe pay · submit job to the lab suite.
+ */
+import {
+  computeQuote,
+  classifyBytes,
+  STRIPE_PAYMENT_LINK,
+  SITE_PPS,
+  API_BASE,
+  PRODUCT_BASE,
+  DATA_MULT,
+  OP_MULT,
+} from "./quote.mjs";
+
+export {
+  computeQuote,
+  classifyBytes,
+  STRIPE_PAYMENT_LINK,
+  SITE_PPS,
+  API_BASE,
+  PRODUCT_BASE,
+  DATA_MULT,
+  OP_MULT,
+};
+
+export const SERVICE_NAME = "SPL Pay Per Suite";
+
+/**
+ * Live quote from site API (falls back to local computeQuote).
+ */
+export async function quoteRemote(opts = {}) {
+  try {
+    const r = await fetch(`${API_BASE}/api/ppp-quote`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        product: opts.product || "auto",
+        dataClass: opts.dataClass || opts.data_class || "unknown",
+        op: opts.op || "compress",
+        bytes: opts.bytes || 0,
+      }),
+    });
+    if (r.ok) {
+      const data = await r.json();
+      return { ...data, service: SERVICE_NAME, suite_url: SITE_PPS, source: "api" };
+    }
+  } catch {
+    /* local fallback */
+  }
+  return { ...computeQuote(opts), source: "local" };
+}
+
+/**
+ * Get Stripe checkout URL (session if server has secret; else payment link).
+ */
+export async function createCheckout(opts = {}) {
+  try {
+    const r = await fetch(`${API_BASE}/api/ppp-checkout`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        product: opts.product || "auto",
+        dataClass: opts.dataClass || opts.data_class || "unknown",
+        op: opts.op || "compress",
+        bytes: opts.bytes || 0,
+        email: opts.email || "",
+      }),
+    });
+    if (r.ok) {
+      const data = await r.json();
+      return { ...data, service: SERVICE_NAME };
+    }
+  } catch {
+    /* fall through */
+  }
+  const q = computeQuote(opts);
+  const url = new URL(STRIPE_PAYMENT_LINK);
+  if (opts.email) url.searchParams.set("prefilled_email", opts.email);
+  return {
+    ok: true,
+    mode: "payment_link",
+    url: url.toString(),
+    quote: q,
+    service: SERVICE_NAME,
+    instructions: `On Stripe, enter amount $${q.amount_display} (your SPL Pay Per Suite quote).`,
+  };
+}
+
+/**
+ * Submit a paid (or ready) project job to the lab.
+ */
+export async function submitJob(opts = {}) {
+  const r = await fetch(`${API_BASE}/api/ppp-job`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      email: opts.email,
+      product: opts.product || opts.tool || "auto",
+      dataClass: opts.dataClass || opts.data_class || "unknown",
+      op: opts.op || "compress",
+      bytes: opts.bytes || 0,
+      amount_display: opts.amount_display || opts.amount || "",
+      tool: opts.tool || opts.product || "auto",
+      fileName: opts.fileName || opts.file_name || "",
+      paidConfirm: opts.paidConfirm ?? opts.paid ?? false,
+      note: opts.note || "",
+      sampleHint: opts.sampleHint || opts.sample_hint || "",
+    }),
+  });
+  const data = await r.json().catch(() => ({}));
+  if (!r.ok) {
+    const err = new Error(data.error || `Job submit failed (${r.status})`);
+    err.data = data;
+    throw err;
+  }
+  return { ...data, service: SERVICE_NAME };
+}
+
+/** Agentic x402 endpoints (machines). Humans use Stripe. */
+export const X402_SUITE_URL = `${API_BASE}/api/x402-suite`;
+export const X402_PRODUCTS_URL = `${API_BASE}/api/x402-products`;
+export const AGENT_DISCOVERY_URL = `${API_BASE}/api/agent`;
+
+/**
+ * Discover agentic commerce rails (Stripe human + x402 agent).
+ */
+export async function agentDiscovery() {
+  try {
+    const r = await fetch(AGENT_DISCOVERY_URL);
+    if (r.ok) return await r.json();
+  } catch {
+    /* fall through */
+  }
+  return {
+    service: SERVICE_NAME,
+    suite_ui: SITE_PPS,
+    rails: {
+      human: { stripe: true, ui: SITE_PPS },
+      agent: { protocol: "x402", job: X402_SUITE_URL },
+    },
+    source: "local-fallback",
+  };
+}
+
+/**
+ * List all standing products available for agent x402 purchase.
+ */
+export async function x402Catalog() {
+  try {
+    const r = await fetch(X402_PRODUCTS_URL);
+    if (r.ok) return { ...(await r.json()), source: "api" };
+  } catch {
+    /* fall through */
+  }
+  return {
+    service: "Slid Phi Labs",
+    buy_product: X402_PRODUCTS_URL,
+    error: "catalog unreachable",
+    source: "local-fallback",
+  };
+}
+
+/**
+ * Probe 402 requirements for a standing product SKU (no pay).
+ */
+export async function x402ProductRequirements(opts = {}) {
+  const sku = opts.sku || opts.product || "cddg-split";
+  const r = await fetch(X402_PRODUCTS_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      sku,
+      email: opts.email || "",
+      note: opts.note || "",
+    }),
+  });
+  const data = await r.json().catch(() => ({}));
+  return {
+    service: SERVICE_NAME,
+    rail: "x402",
+    kind: "standing_product",
+    status: r.status,
+    payment_required: r.status === 402,
+    endpoint: X402_PRODUCTS_URL,
+    sku,
+    requirements: data,
+    how:
+      r.status === 402
+        ? "Retry POST with X-PAYMENT. Use x402-client payFetch against X402_PRODUCTS_URL."
+        : data.message || data.error || "see body",
+  };
+}
+
+/**
+ * Buy standing product after payment (or dev bypass).
+ */
+export async function x402BuyProduct(opts = {}) {
+  const headers = { "Content-Type": "application/json" };
+  if (opts.paymentHeader || opts.xPayment) {
+    headers["X-PAYMENT"] = opts.paymentHeader || opts.xPayment;
+  }
+  if (opts.devBypass || process.env.X402_DEV_BYPASS === "1") {
+    headers["X-PAYMENT-DEV"] = "ok";
+  }
+  const r = await fetch(X402_PRODUCTS_URL, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      sku: opts.sku || opts.product,
+      email: opts.email || "",
+      note: opts.note || "",
+    }),
+  });
+  const data = await r.json().catch(() => ({}));
+  if (r.status === 402) {
+    const err = new Error("Payment required (x402 product)");
+    err.status = 402;
+    err.requirements = data;
+    throw err;
+  }
+  if (!r.ok) {
+    const err = new Error(data.error || data.detail || `x402 buy failed (${r.status})`);
+    err.data = data;
+    throw err;
+  }
+  return { ...data, service: SERVICE_NAME, rail: "x402" };
+}
+
+/**
+ * Probe x402 requirements for a metered suite job (expects HTTP 402 body with accepts[]).
+ * Does not pay — agents use x402-client payFetch to complete.
+ */
+export async function x402Requirements(opts = {}) {
+  const body = {
+    product: opts.product || "auto",
+    dataClass: opts.dataClass || opts.data_class || "unknown",
+    op: opts.op || "compress",
+    bytes: opts.bytes || 0,
+    email: opts.email || "",
+    note: opts.note || "",
+    fileName: opts.fileName || opts.file_name || "",
+    tool: opts.tool || opts.product || "auto",
+  };
+  const r = await fetch(X402_SUITE_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const data = await r.json().catch(() => ({}));
+  return {
+    service: SERVICE_NAME,
+    rail: "x402",
+    status: r.status,
+    payment_required: r.status === 402,
+    endpoint: X402_SUITE_URL,
+    requirements: data,
+    quote: data.quote || data.accepts?.[0]?.extra?.quote || null,
+    how: r.status === 402
+      ? "Retry POST with X-PAYMENT header (base64 payment proof). Use x402-client payFetch(url, { method:'POST', headers:{'Content-Type':'application/json'}, body })."
+      : data.message || "Unexpected status",
+  };
+}
+
+/**
+ * Submit agent job with optional pre-built X-PAYMENT header, or X402_DEV_BYPASS.
+ * For live pay+retry from Node, prefer: import { payFetch } from 'x402-client' against X402_SUITE_URL.
+ */
+export async function x402SubmitJob(opts = {}) {
+  const headers = { "Content-Type": "application/json" };
+  if (opts.paymentHeader || opts.xPayment) {
+    headers["X-PAYMENT"] = opts.paymentHeader || opts.xPayment;
+  }
+  if (opts.devBypass || process.env.X402_DEV_BYPASS === "1") {
+    headers["X-PAYMENT-DEV"] = "ok";
+  }
+  const r = await fetch(X402_SUITE_URL, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      product: opts.product || opts.tool || "auto",
+      dataClass: opts.dataClass || opts.data_class || "unknown",
+      op: opts.op || "compress",
+      bytes: opts.bytes || 0,
+      email: opts.email || "",
+      note: opts.note || "",
+      fileName: opts.fileName || opts.file_name || "",
+      tool: opts.tool || opts.product || "auto",
+      sampleHint: opts.sampleHint || "",
+    }),
+  });
+  const data = await r.json().catch(() => ({}));
+  if (r.status === 402) {
+    const err = new Error("Payment required (x402)");
+    err.status = 402;
+    err.requirements = data;
+    throw err;
+  }
+  if (!r.ok) {
+    const err = new Error(data.error || data.detail || `x402 job failed (${r.status})`);
+    err.data = data;
+    throw err;
+  }
+  return { ...data, service: SERVICE_NAME, rail: "x402" };
+}
+
+/**
+ * Quote + classify from a file path (Node).
+ */
+export async function quoteFile(filePath, opts = {}) {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  const st = await fs.stat(filePath);
+  const sample = await fs.readFile(filePath);
+  const head = sample.subarray(0, Math.min(sample.length, 8192));
+  const cls = classifyBytes(head);
+  const product = opts.product || (opts.autoTool === false ? "auto" : cls.tool) || "auto";
+  const dataClass = opts.dataClass || cls.dataClass;
+  const quote = computeQuote({
+    product,
+    dataClass,
+    op: opts.op || "compress",
+    bytes: st.size,
+  });
+  return {
+    service: SERVICE_NAME,
+    fileName: path.basename(filePath),
+    bytes: st.size,
+    classification: cls,
+    quote,
+    suite_url: SITE_PPS,
+  };
+}

package/src/mcp-server.mjs

@@ -0,0 +1,317 @@
+#!/usr/bin/env node
+/**
+ * SPL Pay Per Suite — MCP server (stdio JSON-RPC / tools-list style)
+ *
+ * Tools:
+ *   spl_pps_quote
+ *   spl_pps_checkout
+ *   spl_pps_submit_job
+ *   spl_pps_classify
+ *   spl_pps_info
+ *   spl_pps_x402_info
+ *   spl_pps_x402_requirements
+ *   spl_pps_x402_submit
+ *
+ * Env:
+ *   SPL_PPS_API, SPL_PPS_SITE, SPL_PPS_PAYMENT_LINK, X402_DEV_BYPASS
+ */
+import readline from "node:readline";
+import {
+  computeQuote,
+  classifyBytes,
+  createCheckout,
+  submitJob,
+  quoteRemote,
+  agentDiscovery,
+  x402Catalog,
+  x402ProductRequirements,
+  x402BuyProduct,
+  x402Requirements,
+  x402SubmitJob,
+  X402_SUITE_URL,
+  X402_PRODUCTS_URL,
+  SERVICE_NAME,
+  SITE_PPS,
+  STRIPE_PAYMENT_LINK,
+  PRODUCT_BASE,
+  DATA_MULT,
+  OP_MULT,
+} from "./index.mjs";
+
+const TOOLS = [
+  {
+    name: "spl_pps_info",
+    description:
+      "SPL Pay Per Suite overview: service name, site URL, Stripe (humans) + x402 (agents), products, data classes, ops.",
+    inputSchema: { type: "object", properties: {} },
+  },
+  {
+    name: "spl_pps_x402_info",
+    description:
+      "Agentic commerce discovery: standing product catalog + suite job endpoints, headers, flow. Stripe remains for humans.",
+    inputSchema: { type: "object", properties: {} },
+  },
+  {
+    name: "spl_pps_x402_catalog",
+    description:
+      "List all standing Slid Phi Labs products agents can buy via x402 (CDDG:Split, ZRW tiers, Blackjack, shards, support, etc.) with USD prices.",
+    inputSchema: { type: "object", properties: {} },
+  },
+  {
+    name: "spl_pps_x402_buy",
+    description:
+      "Buy a standing product via x402. Without paymentHeader → returns 402 requirements. With paymentHeader (or devBypass) → order_id + access_url.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sku: {
+          type: "string",
+          description:
+            "cddg-split | zrw-n00b | zrw-pro | zrw-l33t | blackjack | shard-zip | shard-tsdb | slid-phi | support-integration | consulting | sponsor | donate | try-gate",
+        },
+        email: { type: "string" },
+        note: { type: "string" },
+        paymentHeader: { type: "string" },
+        devBypass: { type: "boolean" },
+      },
+      required: ["sku"],
+    },
+  },
+  {
+    name: "spl_pps_x402_requirements",
+    description:
+      "Probe POST /api/x402-suite (metered job) without paying. Returns 402 accepts[] for suite compress/decompress jobs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        product: { type: "string" },
+        dataClass: { type: "string" },
+        op: { type: "string" },
+        bytes: { type: "number" },
+        email: { type: "string" },
+        note: { type: "string" },
+      },
+    },
+  },
+  {
+    name: "spl_pps_x402_submit",
+    description:
+      "Submit metered suite job via x402 (not fixed SKU). Pass paymentHeader after paying, or devBypass for staging.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        product: { type: "string" },
+        dataClass: { type: "string" },
+        op: { type: "string" },
+        bytes: { type: "number" },
+        email: { type: "string" },
+        note: { type: "string" },
+        fileName: { type: "string" },
+        paymentHeader: { type: "string", description: "Base64 X-PAYMENT proof" },
+        devBypass: { type: "boolean", description: "Staging only if server allows" },
+      },
+    },
+  },
+  {
+    name: "spl_pps_quote",
+    description:
+      "Instant quote for an SPL Pay Per Suite project. Inputs: product, dataClass, op, bytes. Returns USD amount and breakdown.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        product: {
+          type: "string",
+          description: "auto | zrw | cddg-split | blackjack | shard-zip | shard-tsdb | slid-phi",
+        },
+        dataClass: {
+          type: "string",
+          description:
+            "zeros | ramp | walk | mixed_ints | timeseries | json_series | binary | unknown",
+        },
+        op: { type: "string", description: "compress | decompress | roundtrip" },
+        bytes: { type: "number", description: "Payload size in bytes" },
+        remote: { type: "boolean", description: "If true, use live site API" },
+      },
+    },
+  },
+  {
+    name: "spl_pps_checkout",
+    description:
+      "Create Stripe checkout URL for the quoted SPL Pay Per Suite amount. Prefer after spl_pps_quote.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        product: { type: "string" },
+        dataClass: { type: "string" },
+        op: { type: "string" },
+        bytes: { type: "number" },
+        email: { type: "string" },
+      },
+    },
+  },
+  {
+    name: "spl_pps_submit_job",
+    description:
+      "Submit a Pay Per Suite job after payment. Lab runs the best available tool and emails results. Requires email.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        email: { type: "string" },
+        product: { type: "string" },
+        dataClass: { type: "string" },
+        op: { type: "string" },
+        bytes: { type: "number" },
+        amount_display: { type: "string" },
+        tool: { type: "string" },
+        fileName: { type: "string" },
+        paidConfirm: { type: "boolean" },
+        note: { type: "string" },
+        sampleHint: { type: "string" },
+      },
+      required: ["email"],
+    },
+  },
+  {
+    name: "spl_pps_classify",
+    description:
+      "Classify a base64 sample (first few KB) into a data class and recommended tool. No proprietary encode.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sample_base64: { type: "string", description: "Base64 of file head (≤8KB recommended)" },
+      },
+      required: ["sample_base64"],
+    },
+  },
+];
+
+function ok(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function err(id, code, message) {
+  return { jsonrpc: "2.0", id, error: { code, message } };
+}
+
+async function callTool(name, args = {}) {
+  switch (name) {
+    case "spl_pps_info":
+      return {
+        service: SERVICE_NAME,
+        site: SITE_PPS,
+        pay_human: STRIPE_PAYMENT_LINK,
+        pay_agent_products: X402_PRODUCTS_URL,
+        pay_agent_jobs: X402_SUITE_URL,
+        rails: { human: "stripe", agent: "x402" },
+        suite_tools: Object.keys(PRODUCT_BASE),
+        data_classes: Object.keys(DATA_MULT),
+        ops: Object.keys(OP_MULT),
+        npm: "spl-pay-per-suite",
+        cli: "npx spl-pay-per-suite quote|pay|job|x402|catalog|buy",
+      };
+    case "spl_pps_x402_info":
+      return agentDiscovery();
+    case "spl_pps_x402_catalog":
+      return x402Catalog();
+    case "spl_pps_x402_buy": {
+      try {
+        return await x402BuyProduct(args);
+      } catch (e) {
+        if (e.status === 402) {
+          return {
+            payment_required: true,
+            status: 402,
+            sku: args.sku,
+            requirements: e.requirements,
+            how: "Pay accepts[0] then call again with paymentHeader",
+          };
+        }
+        throw e;
+      }
+    }
+    case "spl_pps_x402_requirements":
+      return x402Requirements({
+        product: args.product || "auto",
+        dataClass: args.dataClass || args.data_class || "unknown",
+        op: args.op || "compress",
+        bytes: args.bytes || 0,
+        email: args.email || "",
+        note: args.note || "",
+      });
+    case "spl_pps_x402_submit":
+      return x402SubmitJob(args);
+    case "spl_pps_quote": {
+      const opts = {
+        product: args.product || "auto",
+        dataClass: args.dataClass || args.data_class || "unknown",
+        op: args.op || "compress",
+        bytes: args.bytes || 0,
+      };
+      return args.remote ? await quoteRemote(opts) : computeQuote(opts);
+    }
+    case "spl_pps_checkout":
+      return createCheckout({
+        product: args.product || "auto",
+        dataClass: args.dataClass || args.data_class || "unknown",
+        op: args.op || "compress",
+        bytes: args.bytes || 0,
+        email: args.email || "",
+      });
+    case "spl_pps_submit_job":
+      return submitJob(args);
+    case "spl_pps_classify": {
+      const raw = Buffer.from(String(args.sample_base64 || ""), "base64");
+      return { service: SERVICE_NAME, ...classifyBytes(raw), bytes_sampled: raw.length };
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+async function handle(msg) {
+  const { id, method, params } = msg;
+  if (method === "initialize") {
+    return ok(id, {
+      protocolVersion: "2024-11-05",
+      serverInfo: { name: "spl-pay-per-suite", version: "1.0.0" },
+      capabilities: { tools: {} },
+    });
+  }
+  if (method === "notifications/initialized" || method === "initialized") {
+    return null;
+  }
+  if (method === "tools/list" || method === "list_tools") {
+    return ok(id, { tools: TOOLS });
+  }
+  if (method === "tools/call" || method === "call_tool") {
+    const name = params?.name || params?.tool;
+    const args = params?.arguments || params?.args || {};
+    try {
+      const result = await callTool(name, args);
+      return ok(id, {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        structuredContent: result,
+      });
+    } catch (e) {
+      return err(id, -32000, e.message || String(e));
+    }
+  }
+  if (method === "ping") return ok(id, {});
+  return err(id, -32601, `Method not found: ${method}`);
+}
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+rl.on("line", async (line) => {
+  const t = line.trim();
+  if (!t) return;
+  let msg;
+  try {
+    msg = JSON.parse(t);
+  } catch {
+    process.stdout.write(JSON.stringify(err(null, -32700, "Parse error")) + "\n");
+    return;
+  }
+  const out = await handle(msg);
+  if (out) process.stdout.write(JSON.stringify(out) + "\n");
+});
+
+process.stderr.write(`${SERVICE_NAME} MCP ready (stdio)\n`);

package/src/quote.mjs

@@ -0,0 +1,147 @@
+/**
+ * SPL Pay Per Suite — local quote engine (matches site /api/ppp-quote).
+ * Price = product value base + size fee × data-class × operation.
+ */
+
+export const PRODUCT_BASE = {
+  auto: 2900,
+  zrw: 2900,
+  "cddg-split": 4900,
+  blackjack: 3900,
+  "shard-zip": 3900,
+  "shard-tsdb": 3900,
+  "slid-phi": 3900,
+};
+
+export const DATA_MULT = {
+  zeros: 0.85,
+  ramp: 0.95,
+  walk: 1.05,
+  mixed_ints: 1.15,
+  timeseries: 1.2,
+  json_series: 1.1,
+  binary: 1.25,
+  unknown: 1.15,
+};
+
+export const OP_MULT = {
+  compress: 1.0,
+  decompress: 0.85,
+  roundtrip: 1.35,
+};
+
+export const MIN_CENTS = 900;
+export const MAX_CENTS = 1_000_000;
+
+export const STRIPE_PAYMENT_LINK =
+  process.env.SPL_PPS_PAYMENT_LINK ||
+  "https://buy.stripe.com/aFa00k4B70OYetL0O46wE0g";
+
+export const SITE_PPS = process.env.SPL_PPS_SITE || "https://www.slidphilabs.com/pps";
+export const API_BASE = process.env.SPL_PPS_API || "https://www.slidphilabs.com";
+
+function sizeFeeCents(bytes) {
+  const mb = Math.max(0, Number(bytes) || 0) / (1024 * 1024);
+  if (mb <= 0) return 0;
+  if (mb <= 1) return Math.round(mb * 800);
+  if (mb <= 10) return 800 + Math.round((mb - 1) * 450);
+  if (mb <= 100) return 800 + 9 * 450 + Math.round((mb - 10) * 220);
+  return 800 + 9 * 450 + 90 * 220 + Math.round((mb - 100) * 90);
+}
+
+/**
+ * @param {{ product?: string, dataClass?: string, op?: string, bytes?: number }} opts
+ */
+export function computeQuote({
+  product = "auto",
+  dataClass = "unknown",
+  op = "compress",
+  bytes = 0,
+} = {}) {
+  const prod = PRODUCT_BASE[product] != null ? product : "auto";
+  const cls = DATA_MULT[dataClass] != null ? dataClass : "unknown";
+  const operation = OP_MULT[op] != null ? op : "compress";
+  const b = Math.max(0, Math.min(Number(bytes) || 0, 5 * 1024 * 1024 * 1024));
+  const base = PRODUCT_BASE[prod];
+  const size = sizeFeeCents(b);
+  const raw = Math.round((base + size) * DATA_MULT[cls] * OP_MULT[operation]);
+  const cents = Math.min(MAX_CENTS, Math.max(MIN_CENTS, raw));
+
+  return {
+    ok: true,
+    service: "SPL Pay Per Suite",
+    currency: "usd",
+    amount_cents: cents,
+    amount_display: (cents / 100).toFixed(2),
+    breakdown: {
+      product: prod,
+      product_base_cents: base,
+      size_cents: size,
+      data_class: cls,
+      data_multiplier: DATA_MULT[cls],
+      op: operation,
+      op_multiplier: OP_MULT[operation],
+      bytes: b,
+      mb: +(b / (1024 * 1024)).toFixed(4),
+      min_cents: MIN_CENTS,
+      max_cents: MAX_CENTS,
+    },
+    pay_url: STRIPE_PAYMENT_LINK,
+    suite_url: SITE_PPS,
+  };
+}
+
+/**
+ * Lightweight data-class heuristic from a Buffer / Uint8Array sample.
+ * Does not run proprietary codecs.
+ */
+export function classifyBytes(buf) {
+  if (!buf || !buf.length) return { dataClass: "unknown", tool: "auto", confidence: 0 };
+  const u8 = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  const n = Math.min(u8.length, 4096);
+  let zeros = 0;
+  let printable = 0;
+  for (let i = 0; i < n; i++) {
+    if (u8[i] === 0) zeros++;
+    if (u8[i] >= 32 && u8[i] < 127) printable++;
+  }
+  const zeroRatio = zeros / n;
+  const printRatio = printable / n;
+
+  // JSON-ish
+  if (printRatio > 0.85 && (u8[0] === 0x7b || u8[0] === 0x5b)) {
+    return { dataClass: "json_series", tool: "zrw", confidence: 0.7 };
+  }
+
+  // Look for int32-like ramp/zeros if length multiple of 4
+  if (u8.length >= 16 && u8.length % 4 === 0) {
+    const view = new DataView(u8.buffer, u8.byteOffset, Math.min(u8.length, 400));
+    const ints = [];
+    for (let i = 0; i + 4 <= view.byteLength; i += 4) {
+      ints.push(view.getInt32(i, true));
+    }
+    if (ints.length >= 4) {
+      const allZero = ints.every((v) => v === 0);
+      if (allZero) return { dataClass: "zeros", tool: "zrw", confidence: 0.9 };
+      let ramp = true;
+      for (let i = 1; i < Math.min(ints.length, 64); i++) {
+        if (ints[i] !== ints[0] + i) {
+          ramp = false;
+          break;
+        }
+      }
+      if (ramp) return { dataClass: "ramp", tool: "zrw", confidence: 0.85 };
+      const diffs = [];
+      for (let i = 1; i < Math.min(ints.length, 64); i++) diffs.push(Math.abs(ints[i] - ints[i - 1]));
+      const maxD = Math.max(...diffs);
+      if (maxD > 0 && maxD < 1000) {
+        return { dataClass: "walk", tool: "zrw", confidence: 0.65 };
+      }
+      return { dataClass: "mixed_ints", tool: "blackjack", confidence: 0.55 };
+    }
+  }
+
+  if (zeroRatio > 0.6) return { dataClass: "zeros", tool: "zrw", confidence: 0.6 };
+  if (printRatio > 0.9) return { dataClass: "json_series", tool: "shard-zip", confidence: 0.45 };
+  return { dataClass: "binary", tool: "auto", confidence: 0.4 };
+}