@weaccelerateinc/agent-sdk 0.0.0-stage → 0.10.3

package/starter/README.md

@@ -0,0 +1,88 @@
+# Accelerate managed MCP starter
+
+The starter uses the same versioned profile as the reference demo: `managed_review_v1`. It quietly creates one managed browser, waits until payment for private OTP and masked selection, verifies CVV, fills, then delivers a safe filled-form image. A purchase review gives a full 300 seconds from the provider-confirmed sent timestamp for a simple approve/decline decision. The default purpose is `sandbox_fill_only`: its image is informational, submission is permanently disallowed, and the agent cancels after image delivery.
+
+The default runnable mode is **synthetic**. It uses the real SDK, managed MCP adapter and official stdio protocol against an in-process fixture. It simulates private verification and review delivery; no real credentials, wallet, browser, OTP, CVV, provider attachment or purchase are used. This is a contract smoke test, not live qualification.
+
+## Install and run
+
+Requires Node.js 22 or newer. Install the exact SDK 0.9.0 archive and checksum supplied by Accelerate; [release distribution](https://github.com/weaccelerateinc/accelerate-agent-sdk/blob/main/docs/releases.md) records verified availability. Do not assume npm publication.
+
+```sh
+npx --no-install accelerate-agent init ./accelerate-demo
+cd accelerate-demo
+npm install /absolute/path/to/accelerate-agent-sdk-0.9.0.tgz
+npm test
+npm run smoke
+```
+
+The install resolves pinned MCP libraries and creates `package-lock.json`; commit that lockfile. The starter is private and is not an npm publication target.
+
+`smoke` discovers the actual MCP tools, creates silently, shops before verification, requests payment, observes simulated selection, applies details, freezes the quote, verifies private fill permission, fills, simulates safe review delivery and cancels. It verifies that no submit tool exists. Smoke always forces synthetic mode and does not inherit Accelerate secrets.
+
+```json
+{
+  "mcpServers": {
+    "accelerate-demo": {
+      "command": "node",
+      "args": ["/absolute/path/to/accelerate-demo/server.mjs"],
+      "env": { "ACCELERATE_STARTER_MODE": "synthetic" }
+    }
+  }
+}
+```
+
+Stdout is reserved for protocol messages. No browser or HTTP UI is started. Tool arguments cannot supply the shopper, workspace, conversation, phone, profile or creation idempotency key. Never copy the fixture's in-memory identity or ownership state into live mode.
+
+## Connect your authenticated backend
+
+Live mode uses the same profile and stays fill-only by default. Configure these only in the authenticated backend process:
+
+```dotenv
+ACCELERATE_STARTER_MODE=live
+ACCELERATE_API_KEY=<your tenant API key>
+ACCELERATE_MERCHANT_ID=<your merchant UUID>
+ACCELERATE_CONTEXT_MODULE=/absolute/server/path/your-trusted-context.mjs
+```
+
+The service origin defaults to Accelerate's managed service. No Kernel, extension, VGS, executor or processor secret is required. The starter does not load `.env` automatically; use the platform's secret settings. `accelerate-agent doctor` checks the key/API pair, not downstream browser readiness or merchant qualification.
+
+Provide `createTrustedHost({client,privateChat,deliverReview})` in the server-owned module using `trusted-context.example.mjs`. It deliberately fails until connected to the real application; it provides no pretend authentication. A stdio process must be bound to the intended verified principal. Do not expose it as an anonymous network server or treat `_meta` as identity.
+
+The host connects four durable hooks plus its private sender:
+
+- `resolveContext(extra)` derives verified `{customer_id,workspace_id,conversation_id,phone_number}` from existing server authentication.
+- `withOwnedCheckout(context,id,work)` holds the durable owner lock, authorizes all exact saved fields, invokes `work` once and returns its result.
+- `withCheckoutCreation(context,work)` serializes the exact server-owned attempt with `{idempotency_key,persistCreated}`. Preserve an unresolved-attempt fence after uncertain dispatch or persistence; never create a replacement automatically.
+- `dispatchCheckoutEvent(context,event)` durably accepts and deduplicates the event. `payment_requested` starts private chat only at payment. `approval_requested` retrieves the private CVV prompt after the exact quote is frozen. `review_ready` invokes `await deliverReview(context,event)` from that same durable handler and resolves only after actual provider delivery and service acknowledgement. Preserve pending safe-event work on failure; the runtime verifies the acknowledgement before returning fill success. No model handles the image or private state.
+- `sendPrivateReview(context,message)` uploads and sends the exact supplied PNG and text together to the authenticated private conversation. Honor the stable key, abort signal and delivery deadline, and return the actual provider `{message_id,sent_at}` only after sent confirmation. A queued message is insufficient.
+
+The runtime reuses `deliverPrivateCheckoutReview` to validate image/quote metadata, render the exact total, acknowledge the provider receipt and wipe image bytes. The customer supplies native transport; there is no public media URL, new operator credential or supplied provider authenticator. Recover safe lifecycle/delivery events through the durable outbox; never recover by repeating fill or creating another checkout.
+
+Private OTP, selection, CVV and decisions enter through a separate authenticated webhook **before** model prompts, history, tracing, analytics or ordinary queues. Reuse the [private ingress contract](https://github.com/weaccelerateinc/accelerate-agent-sdk/blob/main/docs/private-chat.md) and [ingress example](https://github.com/weaccelerateinc/accelerate-agent-sdk/blob/main/examples/private-chat-ingress.js). They require exact ownership, provider signature verification, stable message IDs and trusted timestamps. Erase handled private transport bodies, including before same-ID provider NACKs; errors never fall through to the model.
+
+## Run the supported sandbox flow
+
+The current safe capture is qualified only for the configured sandbox merchant's `https://demos.weaccelerate.com/normal/payment` page. Start at `https://demos.weaccelerate.com/normal`; use synthetic initial contact fields, continue to payment, and apply the private selected address there. Unsupported pages fail closed. Merchant ID alone does not qualify other layouts.
+
+1. Start and shop in the same managed browser without sending wallet prompts.
+2. At payment, call `accelerate_checkout_request_payment`; complete private OTP and masked card selection. Wait for `selection_ready`.
+3. Apply the selected address, read final shipping/tax-inclusive pricing and freeze that exact quote.
+4. Complete private CVV for fill permission. No purchase approval is requested before filling.
+5. Fill the verified revision once. The private handler delivers the actual safe form image and exact total: PAN stars plus last four, visible expiry and CVV stars.
+6. For the default fill-only checkout, require successful informational image delivery, then cancel the same checkout. Submit is absent and forbidden. Do not inspect the populated browser.
+
+For an explicitly enabled purchase integration, the same private image asks for simple approve/decline and grants a full five-minute decision window from the actual provider receipt. `ready_for_submit` is insufficient: wait for `purchase_approved:true`, then use a separate explicit owner-authorized submit operation before the returned deadline. After qualification, purchase mode requires both of these backend settings:
+
+```dotenv
+ACCELERATE_STARTER_PURPOSE=purchase
+ACCELERATE_ENABLE_PURCHASE_SUBMIT=true
+```
+
+The model cannot enable these settings. `purpose:purchase` without the submit flag still exposes no submit tool.
+
+## Explicit legacy compatibility
+
+The supported profile is fixed: payment-time verification, after-fill review and 300000ms. Conflicting timing or approval overrides are rejected. Existing `before_fill` deployments can explicitly register `profile:'legacy_before_fill_v1'`; its default timing is `on_start`, with deliberate `verificationTiming:'on_payment'` available for the deferred legacy flow. It requests revision/code approval before fresh CVV and uses the original short submit lease after filling. It has no post-fill human review. Existing checkouts retain their original policy; never switch a checkout between profiles or silently downgrade after an unsupported capture.
+
+See [the managed MCP guide](https://github.com/weaccelerateinc/accelerate-agent-sdk/blob/main/docs/managed-mcp.md) and [new customer integration](https://github.com/weaccelerateinc/accelerate-agent-sdk/blob/main/docs/new-customer-integration.md) for the full contract. Synthetic smoke, connection checks and one sandbox fill do not certify PCI scope or production payments.

package/starter/gitignore.template

@@ -0,0 +1,5 @@
+node_modules/
+.env
+.env.*
+!.env.example
+*.log

package/starter/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "accelerate-managed-mcp-starter",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "start": "node server.mjs",
+    "smoke": "node smoke.mjs",
+    "test": "node --test tests/*.test.mjs"
+  },
+  "dependencies": {
+    "@weaccelerateinc/agent-sdk": "0.10.3",
+    "@modelcontextprotocol/server": "2.3.1"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/client": "2.3.1"
+  }
+}

package/starter/runtime.mjs

@@ -0,0 +1,61 @@
+import { isAbsolute } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { AccelerateClient } from '@weaccelerateinc/agent-sdk';
+import { AcceleratePrivateChatClient, deliverPrivateCheckoutReview } from '@weaccelerateinc/agent-sdk/private-chat';
+import { registerManagedCheckoutTools } from '@weaccelerateinc/agent-sdk/managed-mcp';
+import { createSyntheticHost } from './synthetic.mjs';
+
+const requiredHooks = ['resolveContext', 'withOwnedCheckout', 'withCheckoutCreation', 'dispatchCheckoutEvent'];
+export async function configureStarter(server, env = process.env) {
+  const mode = env.ACCELERATE_STARTER_MODE ?? 'synthetic';
+  const purpose = env.ACCELERATE_STARTER_PURPOSE ?? 'sandbox_fill_only';
+  const enableSubmit = env.ACCELERATE_ENABLE_PURCHASE_SUBMIT === 'true';
+  if (!['sandbox_fill_only', 'purchase'].includes(purpose) ||
+    env.ACCELERATE_ENABLE_PURCHASE_SUBMIT !== undefined && !['true', 'false'].includes(env.ACCELERATE_ENABLE_PURCHASE_SUBMIT) ||
+    enableSubmit && purpose !== 'purchase') throw Error('Unsupported server purchase policy.');
+  let host, privateChat;
+  const matches = (state, event) => state.checkout.id === event.checkout.id && state.checkout.revision === event.checkout.revision &&
+    state.checkout.purpose === purpose && state.checkout.approval_policy === 'after_fill' &&
+    state.checkout.status === 'ready_for_submit' && state.checkout.quote && event.checkout.quote &&
+    ['checkout_origin', 'amount_cents', 'currency'].every(key => state.checkout.quote[key] === event.checkout.quote[key]);
+  const delivered = state => state?.review?.delivered === true && state.review.approval_window_ms === 300000 &&
+    (purpose === 'sandbox_fill_only' ? state.stage === 'review_delivered' : ['approval_required', 'approved_for_submit'].includes(state.stage));
+  // Invoke from the host's durable event worker, including retries of that same
+  // event. This is private host code, never an MCP tool or a model callback.
+  const deliverReview = async (context, event) => {
+    if (event?.version !== 'v1' || event.kind !== 'review_ready' || event.checkout?.approval_policy !== 'after_fill' ||
+      event.checkout.purpose !== purpose || event.checkout.status !== 'ready_for_submit') throw Error('Private review delivery is unavailable.');
+    const binding = Object.fromEntries(['customer_id', 'workspace_id', 'conversation_id'].map(key => [key, context[key]]));
+    const state = await privateChat.chat.get(event.checkout.id, binding);
+    if (!matches(state, event) || state.review?.approval_window_ms !== 300000 ||
+      typeof state.review.delivery_expires_at !== 'string') throw Error('Private review delivery is unavailable.');
+    if (delivered(state)) return state;
+    return deliverPrivateCheckoutReview({ client: privateChat, state, binding,
+      messageId: event.idempotency_key, send: message => host.sendPrivateReview(context, message) });
+  };
+  if (mode === 'synthetic') { host = createSyntheticHost({ purpose, deliverReview }); privateChat = host.privateChat; }
+  else if (mode === 'live') {
+    // This path is configured by the server operator, never an MCP argument.
+    if (typeof env.ACCELERATE_CONTEXT_MODULE !== 'string' || !isAbsolute(env.ACCELERATE_CONTEXT_MODULE)) {
+      throw Error('A trusted absolute server context module is required.');
+    }
+    const module = await import(pathToFileURL(env.ACCELERATE_CONTEXT_MODULE).href);
+    if (typeof module.createTrustedHost !== 'function') throw Error('The trusted context module is incomplete.');
+    const client = AccelerateClient.fromEnv(env); privateChat = AcceleratePrivateChatClient.fromEnv(env);
+    host = { ...await module.createTrustedHost({ client, privateChat, deliverReview }), client };
+  } else throw Error('Unsupported starter mode.');
+  if ([...requiredHooks, 'sendPrivateReview'].some(key => typeof host?.[key] !== 'function')) throw Error('Authenticated server hooks and private review delivery are required.');
+  const dispatchCheckoutEvent = async (context, event) => {
+    await host.dispatchCheckoutEvent(context, event);
+    if (event.kind === 'review_ready') {
+      const binding = Object.fromEntries(['customer_id', 'workspace_id', 'conversation_id'].map(key => [key, context[key]]));
+      const state = await privateChat.chat.get(event.checkout.id, binding);
+      if (!matches(state, event) || !delivered(state)) throw Error('Private review delivery is unconfirmed.');
+    }
+  };
+  registerManagedCheckoutTools(server, { client: host.client,
+    resolveContext: host.resolveContext, withOwnedCheckout: host.withOwnedCheckout,
+    withCheckoutCreation: host.withCheckoutCreation, dispatchCheckoutEvent,
+    profile: 'managed_review_v1', purpose, enableSubmit });
+  return { mode, counters: host.counters };
+}

package/starter/server.mjs

@@ -0,0 +1,13 @@
+import { McpServer } from '@modelcontextprotocol/server';
+import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
+import { configureStarter } from './runtime.mjs';
+
+const server = new McpServer({ name: 'accelerate-managed-starter', version: '0.1.0' });
+try {
+  await configureStarter(server);
+  server.onerror = () => {}; // Never print protocol arguments or provider errors.
+  await server.connect(new StdioServerTransport());
+} catch {
+  process.stderr.write(JSON.stringify({ ok: false, code: 'starter_configuration_unavailable' }) + '\n');
+  process.exitCode = 1;
+}

package/starter/smoke.mjs

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+
+const client = new Client({ name: 'accelerate-starter-smoke', version: '0.1.0' });
+const transport = new StdioClientTransport({ command: process.execPath,
+  args: [fileURLToPath(new URL('./server.mjs', import.meta.url))],
+  env: { ...getDefaultEnvironment(), ACCELERATE_STARTER_MODE: 'synthetic' }, stderr: 'pipe' });
+let complete = false;
+const timer = setTimeout(() => { void transport.close(); }, 15000);
+try {
+  await client.connect(transport);
+  const tools = await client.listTools();
+  assert.equal(tools.tools.length, 8);
+  assert.equal(tools.tools.some(tool => tool.name === 'accelerate_checkout_request_payment'), true);
+  assert.equal(tools.tools.some(tool => tool.name === 'accelerate_checkout_submit'), false);
+  const call = async (name, args) => {
+    const result = await client.callTool({ name, arguments: args });
+    const value = result.structuredContent ?? JSON.parse(result.content.find(part => part.type === 'text').text);
+    assert.equal(value.ok, true); return value;
+  };
+  const checkoutUrl = 'https://demos.weaccelerate.com/normal/payment';
+  const checkout = (await call('accelerate_checkout_start', { start_url: checkoutUrl })).checkout;
+  assert.equal(checkout.purpose, 'sandbox_fill_only'); assert.equal(checkout.submit_allowed, false);
+  assert.equal(checkout.approval_policy, 'after_fill'); assert.equal(checkout.purchase_approved, false);
+  assert.equal(checkout.status, 'wallet_required'); assert.equal(checkout.card, undefined);
+  const id = checkout.id;
+  assert.equal((await call('accelerate_checkout_status', { checkout_id: id })).checkout.status, 'wallet_required');
+  await call('accelerate_checkout_browser', { checkout_id: id, operation: 'browser_snapshot', arguments: { filter: 'all' } });
+  assert.equal((await call('accelerate_checkout_status', { checkout_id: id })).checkout.status, 'wallet_required');
+  const requested = await call('accelerate_checkout_request_payment', { checkout_id: id });
+  assert.equal(requested.checkout.status, 'wallet_required');
+  assert.equal((await call('accelerate_checkout_status', { checkout_id: id })).checkout.status, 'selection_ready');
+  await call('accelerate_checkout_apply_details', { checkout_id: id, checkout_url: checkoutUrl });
+  const quote = (await call('accelerate_checkout_request_approval', { checkout_id: id, checkout_url: checkoutUrl,
+    amount_cents: 100, currency: 'USD', checkout_total_selector: '#checkout-total', submit_selector: '#place-order' })).checkout;
+  assert.equal((await call('accelerate_checkout_status', { checkout_id: id })).checkout.status, 'approved');
+  assert.equal((await call('accelerate_checkout_fill', { checkout_id: id, revision: quote.revision })).checkout.status, 'ready_for_submit');
+  const reviewed = (await call('accelerate_checkout_status', { checkout_id: id })).checkout;
+  assert.equal(reviewed.purchase_approved, false);
+  const remaining = Date.parse(reviewed.submit_expires_at) - Date.now();
+  assert.ok(remaining > 290000 && remaining <= 300000);
+  assert.equal((await call('accelerate_checkout_cancel', { checkout_id: id })).checkout.status, 'cancelled');
+  complete = true;
+  process.stdout.write(JSON.stringify({ ok: true, synthetic_only: true, mcp_protocol: true,
+    profile: 'managed_review_v1', verification_deferred: true, private_verification_before_fill: true,
+    private_review_receipt_acknowledged: true, approval_window_ms: 300000, purchase_approval_requested: false,
+    submit_tool_absent: true, fill_ready: true, cancelled: true, live_checkout_requests: 0 }) + '\n');
+} catch {
+  process.stderr.write(JSON.stringify({ ok: false, code: 'synthetic_smoke_failed' }) + '\n');
+} finally {
+  clearTimeout(timer); await client.close().catch(() => {}); await transport.close().catch(() => {});
+  process.exitCode = complete ? 0 : 1;
+}

package/starter/synthetic.mjs

@@ -0,0 +1,163 @@
+import { createHash } from 'node:crypto';
+import { AccelerateClient } from '@weaccelerateinc/agent-sdk';
+import { AcceleratePrivateChatClient, deliverPrivateCheckoutReview } from '@weaccelerateinc/agent-sdk/private-chat';
+
+const context = Object.freeze({ customer_id: 'synthetic-customer', workspace_id: 'synthetic-workspace',
+  conversation_id: 'synthetic-direct-conversation', phone_number: '+15555550123' });
+const origin = 'https://synthetic.accelerate.invalid';
+export const syntheticCheckoutUrl = 'https://demos.weaccelerate.com/normal/payment';
+const invalid = () => { throw Error('Synthetic checkout request rejected.'); };
+const digest = value => createHash('sha256').update(value).digest('base64url');
+const png = () => Buffer.from([137, 80, 78, 71, 13, 10, 26, 10, 1, 2, 3]);
+
+/** In-process fixtures only: no network, source, browser, raw OTP or security code.
+ * Private verification is simulated; safe image delivery uses the real SDK. */
+export function createSyntheticHost({ purpose = 'sandbox_fill_only', deliverReview } = {}) {
+  if (!['sandbox_fill_only', 'purchase'].includes(purpose)) invalid();
+  const records = new Map(), owners = new Map(), events = new Set(), messages = new Map();
+  const calls = { create: 0, browser: 0, payment_requested: 0, approval_requested: 0,
+    private_verification: 0, fill: 0, review: 0, review_sent: 0, review_acknowledged: 0,
+    purchase_decision: 0, submit: 0, cancel: 0, external: 0 };
+  let tail = Promise.resolve();
+  const locked = async work => {
+    const previous = tail; let release;
+    tail = new Promise(resolve => { release = resolve; }); await previous;
+    try { return await work(); } finally { release(); }
+  };
+  const view = record => ({ id: record.id, status: record.status, revision: record.revision,
+    expires_at: record.expires_at, purpose, submit_allowed: purpose === 'purchase',
+    approval_policy: 'after_fill', purchase_approved: record.purchaseApproved === true,
+    retry_safe: false, payment_confirmed: false,
+    ...(record.selected ? { card: { brand: 'Visa', last4: '4242' }, address: { label: 'Saved address ***23' } } : {}),
+    ...(record.quote ? { quote: record.quote } : {}),
+    ...(record.review ? { submit_expires_at: record.review.expires_at } : {}) });
+  const privateView = record => ({ checkout: view(record), stage: record.stage, handled: true, duplicate: false,
+    cards: [], addresses: [],
+    ...(['cvv_required', 'review_delivery_required', 'review_delivered', 'approval_required', 'approved_for_submit'].includes(record.stage)
+      ? { approval: { revision: record.revision, ...record.quote } } : {}),
+    ...(record.review ? { review: { ...record.review } } : {}) });
+  const fetchImpl = async (url, request) => {
+    const parsed = new URL(url);
+    if (parsed.origin !== origin) { calls.external++; invalid(); }
+    const body = request.body ? JSON.parse(request.body) : undefined;
+    if (parsed.pathname === '/v1/checkouts' && request.method === 'POST') {
+      if (body.interaction_mode !== 'chat' || body.purpose !== purpose || body.approval_policy !== 'after_fill' ||
+        Object.keys(context).some(key => body[key] !== context[key]) || body.start_url !== syntheticCheckoutUrl) invalid();
+      const id = 'mcs_' + digest(body.idempotency_key);
+      if (!records.has(id)) { calls.create++; records.set(id, { id, status: 'wallet_required', stage: 'not_started', revision: 0,
+        expires_at: new Date(Date.now() + 900000).toISOString(), selected: false }); }
+      return Response.json(view(records.get(id)), { status: 201 });
+    }
+    const match = /^\/v1\/checkouts\/(mcs_[A-Za-z0-9_-]{43})(?:\/(browser|details|approval|fill|submit|cancel|private-chat\/(?:state|review|review-delivered|reply)))?$/.exec(parsed.pathname);
+    if (!match || !records.has(match[1])) invalid();
+    const record = records.get(match[1]), action = match[2];
+    if (!action && request.method === 'GET') return Response.json(view(record));
+    if (request.method !== 'POST') invalid();
+    if (action?.startsWith('private-chat/')) {
+      if (['customer_id', 'workspace_id', 'conversation_id'].some(key => body[key] !== context[key])) invalid();
+      if (action === 'private-chat/state') return Response.json(privateView(record));
+      if (action === 'private-chat/review' && record.stage === 'review_delivery_required' && Date.now() < Date.parse(record.review.delivery_expires_at)) {
+        calls.review++; record.imageRetrieved = true;
+        return new Response(png(), { headers: { 'Content-Type': 'image/png',
+          'X-Accelerate-Review-Id': record.review.id, 'X-Accelerate-Review-Expires-At': record.review.expires_at,
+          'X-Accelerate-Review-Amount-Cents': String(record.quote.amount_cents), 'X-Accelerate-Review-Currency': 'USD',
+          'X-Accelerate-Review-Approval-Window-Ms': '300000', 'X-Accelerate-Review-Delivery-Expires-At': record.review.delivery_expires_at } });
+      }
+      if (action === 'private-chat/review-delivered') {
+        const receipt = messages.get(body.message_id);
+        if (!record.imageRetrieved || body.review_id !== record.review?.id || !receipt || receipt.checkout !== record.id ||
+          receipt.sent_at !== body.sent_at || Date.parse(body.sent_at) > Date.now() ||
+          Date.parse(body.sent_at) >= Date.parse(record.review.delivery_expires_at)) invalid();
+        if (!record.review.delivered) { calls.review_acknowledged++; record.review.delivered = true;
+          record.review.expires_at = new Date(Date.parse(body.sent_at) + 300000).toISOString();
+          record.stage = purpose === 'purchase' ? 'approval_required' : 'review_delivered'; }
+        return Response.json(privateView(record));
+      }
+      if (action === 'private-chat/reply' && purpose === 'purchase' && record.stage === 'approval_required' &&
+        record.review?.delivered && typeof body.sent_at === 'string' && Date.parse(body.sent_at) <= Date.now() &&
+        Date.parse(body.sent_at) > Date.parse(record.review.expires_at) - 300000 && Date.now() < Date.parse(record.review.expires_at)) {
+        if (!['approve', 'decline'].includes(body.text)) invalid();
+        calls.purchase_decision++;
+        if (body.text === 'approve') { record.purchaseApproved = true; record.stage = 'approved_for_submit'; }
+        else { record.status = 'cancelled'; record.stage = 'closed'; delete record.review; }
+        return Response.json(privateView(record));
+      }
+      invalid();
+    }
+    if (action === 'browser' && ['wallet_required', 'selection_ready', 'details_ready'].includes(record.status)) {
+      calls.browser++;
+      return Response.json({ content: [{ type: 'text',
+        text: 'Synthetic demo checkout\nUSD $1.00\n#checkout-total\n#place-order\n[e1_1] Button Continue' }] });
+    }
+    if (action === 'details' && record.status === 'selection_ready' && body.checkout_url === syntheticCheckoutUrl) record.status = 'details_ready';
+    else if (action === 'approval' && record.status === 'details_ready' && body.checkout_url === syntheticCheckoutUrl &&
+      body.amount_cents === 100 && body.currency === 'USD') {
+      record.status = 'approval_required'; record.stage = 'cvv_required'; record.revision++;
+      record.quote = { checkout_origin: 'https://demos.weaccelerate.com', amount_cents: 100, currency: 'USD' };
+    } else if (action === 'fill' && record.status === 'approved' && body.revision === record.revision) {
+      calls.fill++; record.status = 'ready_for_submit'; record.stage = 'review_delivery_required';
+      record.review = { id: 'rvr_' + digest(record.id + ':' + record.revision), delivered: false, approval_window_ms: 300000,
+        expires_at: new Date(Date.now() + 420000).toISOString(), delivery_expires_at: new Date(Date.now() + 60000).toISOString() };
+    } else if (action === 'cancel') { calls.cancel++; record.status = 'cancelled'; record.stage = 'closed'; record.purchaseApproved = false; delete record.review; }
+    else if (action === 'submit') {
+      calls.submit++;
+      if (purpose !== 'purchase' || !record.purchaseApproved || record.stage !== 'approved_for_submit' ||
+        body.revision !== record.revision || Date.now() >= Date.parse(record.review.expires_at)) return Response.json({ error: { code: 'submit_unavailable' } }, { status: 409 });
+      record.status = 'submit_attempted'; record.stage = 'closed'; record.purchaseApproved = false; delete record.review;
+    } else invalid();
+    return Response.json(view(record));
+  };
+  const options = { baseUrl: origin, apiKey: 'synthetic_tenant_not_a_real_key'.padEnd(48, 'x'),
+    merchantId: 'aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee', fetchImpl };
+  const client = new AccelerateClient(options), privateChat = new AcceleratePrivateChatClient(options);
+  const host = { client, privateChat,
+    resolveContext: async () => ({ ...context }),
+    withOwnedCheckout: async (current, id, work) => locked(async () => {
+      const saved = owners.get(id);
+      if (!saved || Object.keys(context).some(key => current[key] !== context[key] || saved[key] !== current[key])) invalid();
+      return work({ ...saved });
+    }),
+    withCheckoutCreation: async (current, work) => locked(() => {
+      if (Object.keys(context).some(key => current[key] !== context[key])) invalid();
+      return work({ idempotency_key: 'synthetic-exact-attempt-1', persistCreated: async saved => {
+        if (Object.keys(context).some(key => saved[key] !== context[key])) invalid();
+        owners.set(saved.checkout_id, { ...saved });
+      } });
+    }),
+    sendPrivateReview: async (current, message) => {
+      if (Object.keys(context).some(key => current[key] !== context[key]) || message.contentType !== 'image/png' ||
+        !message.bytes.equals(png()) || message.signal.aborted || Date.now() >= Date.parse(message.delivery_expires_at)) invalid();
+      const record = [...records.values()].find(value => value.stage === 'review_delivery_required');
+      if (!record || !message.text.includes('1.00 USD') || (purpose === 'sandbox_fill_only'
+        ? !message.text.includes('No purchase approval is needed') || message.text.includes('Do you approve')
+        : !message.text.includes('5 minutes from this message'))) invalid();
+      const message_id = 'synthetic-review-' + digest(message.idempotency_key);
+      if (!messages.has(message_id)) { calls.review_sent++; messages.set(message_id, { checkout: record.id, sent_at: new Date(Date.now()).toISOString() }); }
+      return { message_id, sent_at: messages.get(message_id).sent_at };
+    },
+    dispatchCheckoutEvent: async (current, event) => {
+      if (Object.keys(context).some(key => current[key] !== context[key]) ||
+        event.version !== 'v1' || !['payment_requested', 'approval_requested', 'review_ready'].includes(event.kind) ||
+        event.idempotency_key !== 'accelerate-checkout-event:' + createHash('sha256').update(JSON.stringify([
+          'v1', event.kind, event.checkout.id, ['approval_requested', 'review_ready'].includes(event.kind) ? event.checkout.revision : 0])).digest('hex') ||
+        !owners.has(event.checkout.id)) invalid();
+      if (events.has(event.idempotency_key)) return;
+      const record = records.get(event.checkout.id);
+      if (event.kind === 'payment_requested' && record.status === 'wallet_required') {
+        calls.payment_requested++; record.selected = true; record.status = 'selection_ready'; record.stage = 'preparing_checkout'; record.revision = 1;
+      } else if (event.kind === 'approval_requested' && record.stage === 'cvv_required') {
+        calls.approval_requested++; calls.private_verification++; record.status = 'approved'; record.stage = 'verified';
+      } else if (event.kind === 'review_ready' && record.stage === 'review_delivery_required') {
+        if (deliverReview) await deliverReview(current, event);
+        else await deliverPrivateCheckoutReview({ client: privateChat, state: privateView(record),
+          binding: Object.fromEntries(['customer_id', 'workspace_id', 'conversation_id'].map(key => [key, context[key]])),
+          messageId: event.idempotency_key, send: message => host.sendPrivateReview(current, message) });
+      } else invalid();
+      // Only receipt acknowledgement completes this event; a failure retains
+      // this exact event for redelivery, without replaying private filling.
+      events.add(event.idempotency_key);
+    },
+    counters: () => ({ ...calls }),
+  };
+  return host;
+}