@volter/twin-fireworks 0.1.0

package/src/fireworks-capabilities.ts

@@ -0,0 +1,1229 @@
+// Fireworks capability manifest — the EXPECTED REAL-PRODUCT SURFACE (the target), authored
+// top-down from what the Fireworks API actually does — NOT from what this twin has built. The
+// denominator was enumerated from FIRST-PARTY sources, all read 2026-09-16:
+//   • the merged Gateway REST API 5.10.0 OpenAPI spec (docs.fireworks.ai/merged.openapi.yaml —
+//     the control plane: deployments, datasets, batch-inference + supervised-fine-tuning jobs,
+//     users/apiKeys, secrets, models, quotas, serverless);
+//   • the text-completion / Responses / Anthropic-messages OpenAPI specs
+//     (docs.fireworks.ai/api-reference/…) — the inference plane;
+//   • docs.fireworks.ai (openai-compatibility, streaming, rate-limits, error-codes pages).
+// Most entries start as `todo` and coverage reads LOW until the twin truly reaches 100% of the
+// API. `verify()` (required to count as done) is ground truth; `expected:'done'` only on
+// capabilities we genuinely claim, so a broken one shows as a regression.
+//
+// There are NO carve-outs. A twin is a deterministic, offline model of the vendor's API contract:
+// where the vendor runs a model, the twin returns a DETERMINISTIC labeled stub, and that stub IS
+// the twin's answer, not a shortfall from a "real" one. The protocol envelope (shape/streaming/
+// tool_calls/usage, the Anthropic-compat envelope, the gateway google.rpc statuses) is faithful.
+// Every entry here is either done or todo.
+//
+// TIERING (§6 rule 3): `core` = "first-week-of-every-integration". For Fireworks that is the
+// chat-completions spine (including its documented OpenAI differences), the embeddings/rerank
+// surface, the auth gate, and the control-plane deployment CRUD backbone. The Responses API,
+// the Anthropic-compat surface, fine-tuning jobs, users/apiKeys, secrets and datasets are
+// specialist surfaces and are tiered `common` — tier inflation is what §9 round one corrected
+// on the groq manifest.
+//
+// (Fireworks is an API-first vendor — its console is a keys/usage dev console, not where the
+// work happens — so this pack ships NO mirror and has NO UI capabilities.)
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { checkCapabilities, type CapabilityReport, type CapabilitySpec, verifyBoundary, isInfrastructureError, harnessError } from '@volter/world-tooling';
+import { pendingActions, projectResources } from '@volter/world-core';
+import type { TwinAction } from '@volter/world-core';
+import { handleFireworksTwinRequest, type FireworksResponseEnvelope } from './fireworks-twin.ts';
+import {
+  fireworksRequestForAction,
+  fullSyncFireworks,
+  performFireworksAction,
+  pullFireworksState,
+  pushPendingFireworksActions,
+  syncFireworksFromReal,
+  unpushableReason,
+  type FireworksExecute,
+} from './fireworks-connector.ts';
+import type { SseEvent } from './fireworks-twin.ts';
+
+// ── API verify: drive REAL requests against a fresh temp root, then assert status/shape ──
+type Step = { m: string; p: string; b?: unknown };
+type Body = Record<string, any>;
+
+/** Run a sequence of real Fireworks requests against an isolated root; return all responses. */
+async function withRoot(steps: (h: (s: Step) => Promise<FireworksResponseEnvelope>, root: string) => Promise<boolean>): Promise<boolean> {
+  const root = mkdtempSync(join(tmpdir(), 'fireworks-cap-'));
+  const h = (s: Step) => handleFireworksTwinRequest({ method: s.m, path: s.p, body: s.b === undefined ? undefined : JSON.stringify(s.b), root });
+  try {
+    // `root` is handed to the steps too, so a verify can inspect the LOG (projectResources /
+    // pendingActions) and not merely the responses — the difference between proving "the reply
+    // did not change" and proving "nothing was written" (§9 round two).
+    return await verifyBoundary('fireworks.withRoot', () => steps(h, root));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
+/** Like withRoot, but the request helper passes request HEADERS through (for auth / the
+ *  deterministic 429 trigger, which the trusted no-headers helper never fires). */
+type StepH = Step & { headers?: Record<string, string> };
+async function withRootH(steps: (h: (s: StepH) => Promise<FireworksResponseEnvelope>) => Promise<boolean>): Promise<boolean> {
+  const root = mkdtempSync(join(tmpdir(), 'fireworks-cap-'));
+  const h = (s: StepH) => handleFireworksTwinRequest({ method: s.m, path: s.p, body: s.b === undefined ? undefined : JSON.stringify(s.b), root, ...(s.headers ? { headers: s.headers } : {}) });
+  try {
+    return await verifyBoundary('fireworks.withRootH', () => steps(h));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
+/** Collect the streaming SSE events for a chat request against an isolated root. */
+function withStream(body: unknown, fn: (events: SseEvent[], final: FireworksResponseEnvelope) => boolean): Promise<boolean> {
+  return new Promise<boolean>((resolve, reject) => {
+    const root = mkdtempSync(join(tmpdir(), 'fireworks-cap-'));
+    const events: SseEvent[] = [];
+    handleFireworksTwinRequest({ method: 'POST', path: '/inference/v1/chat/completions', body: JSON.stringify(body), root, sseSink: (e) => events.push(e) })
+      .then((final) => resolve(fn(events, final)))
+      .catch((err) => { if (isInfrastructureError(err)) reject(harnessError('fireworks.withStream', err)); else resolve(false); })
+      .finally(() => rmSync(root, { recursive: true, force: true }));
+  });
+}
+
+/** A connector verify against an isolated root, with the injected fake executor the test builds. */
+async function withConnectorRoot(id: string, fn: (root: string) => Promise<boolean>): Promise<boolean> {
+  const root = mkdtempSync(join(tmpdir(), 'fireworks-cap-'));
+  try {
+    return await fn(root);
+  } catch (err) {
+    if (isInfrastructureError(err)) throw harnessError(id, err);
+    return false;
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
+const ok = (r: FireworksResponseEnvelope) => r.status >= 200 && r.status < 300;
+
+// ── shorthands (mirror the groq/ai-gateway manifests) ──
+const done = (id: string, area: string, title: string, dimension: CapabilitySpec['dimension'], tier: CapabilitySpec['tier'], verify: CapabilitySpec['verify']): CapabilitySpec => ({ id, area, title, dimension, tier, expected: 'done', verify });
+const todo = (id: string, area: string, title: string, dimension: CapabilitySpec['dimension'], tier: CapabilitySpec['tier']): CapabilitySpec => ({ id, area, title, dimension, expected: 'todo', tier });
+
+const CHAT_PATH = '/inference/v1/chat/completions';
+const MODEL = 'accounts/fireworks/models/kimi-k2-instruct';
+const CHAT = (extra: Record<string, unknown> = {}) => ({ model: MODEL, messages: [{ role: 'user', content: 'hello twin' }], ...extra });
+const ACCOUNT = '/v1/accounts/my-account';
+
+/** A recording fake executor: `calls` is the ground truth a connector verify reads. */
+function fakeExecute(reply: (method: string, path: string) => unknown = () => ({ data: [] })): { execute: FireworksExecute; calls: string[]; bodies: Array<Record<string, unknown> | undefined>; statuses: number[] } {
+  const calls: string[] = [];
+  // The BODY is recorded too: a push verify that asserts only method+path cannot see a payload
+  // that would 400 at the real vendor (§9 round one, finding 6).
+  const bodies: Array<Record<string, unknown> | undefined> = [];
+  const statuses: number[] = [];
+  const execute: FireworksExecute = async (method, path, body) => {
+    calls.push(`${method} ${path}`);
+    bodies.push(body);
+    const status = reply(method, path) === null ? 500 : 200;
+    statuses.push(status);
+    return { status, data: reply(method, path) };
+  };
+  return { execute, calls, bodies, statuses };
+}
+
+/** Seed one deployment via the control plane. Returns the deployment id. */
+async function seedDeployment(h: (s: Step) => Promise<FireworksResponseEnvelope>): Promise<string | null> {
+  const d = await h({ m: 'POST', p: `${ACCOUNT}/deployments?deploymentId=my-deployment`, b: { baseModel: 'accounts/fireworks/models/llama-v3p1-8b-instruct', displayName: 'twin seed' } });
+  return ok(d) ? 'my-deployment' : null;
+}
+
+export const FIREWORKS_CAPABILITIES: CapabilitySpec[] = [
+  // ── Planned gaps ──────────────────────────────────────────────────────────────────────
+  todo('fireworks.chat.response_ids_unique', 'chat', 'Chat: response ids are unique per request — id is derived from a hash of (messages, model) today, so two identical calls share one id', 'api', 'niche'),
+  todo('fireworks.chat.tool_call_streaming_deltas', 'chat', 'Streaming: scripted tool_calls stream as argument deltas (today the full tool_call arrives on one delta)', 'api', 'niche'),
+  todo('fireworks.serverless.list', 'serverless', 'Serverless model catalog: GET /v1/serverlessModels is not served (the twin serves only account-owned resources)', 'api', 'common'),
+  todo('fireworks.serverless.rate_limits', 'serverless', 'Serverless rate limits + series: GET /v1/serverlessRateLimits is not served', 'api', 'niche'),
+  // A surface of the pinned consumer the census cannot see: @ai-sdk/fireworks ships
+  // FireworksImageModel, which POSTs `${baseURL}/image_generation/{model}` (legacy models) or
+  // `${baseURL}/workflows/{model}/text_to_image` + `.../get_result` (async workflows). The twin
+  // serves none of these and the spec census has no image-generation path in scope, so this todo
+  // is the only place the gap is named.
+  todo('fireworks.image_generation.create', 'image_generation', 'Image generation: POST /inference/v1/image_generation/{model} and the /workflows/{model}/text_to_image + get_result pair (the pinned @ai-sdk/fireworks FireworksImageModel surface) are not served', 'api', 'common'),
+  todo('fireworks.quota.read', 'quota', 'Quotas: GET /v1/accounts/{id}/quotas is not served (quotas are vendor-assigned)', 'api', 'common'),
+  todo('fireworks.account.read', 'account', 'Account: GET /v1/accounts/{id} is NOT served — the twin holds no account rows (an account is vendor state one-per-credential, not creatable through the API), so it answers the vendor 404; serving the real account row needs pulled account state', 'api', 'niche'),
+  todo('fireworks.datasets.upload', 'datasets', 'Datasets: the dataset-upload extra (POST /datasets/{id}:upload) is not served', 'api', 'common'),
+  todo('fireworks.sft.create', 'fine_tuning', 'Supervised fine-tuning: POST /supervisedFineTuningJobs is served; a full create→READY lifecycle with training progression is not modeled', 'api', 'common'),
+  todo('fireworks.models.get_download_endpoint', 'models', 'Models: GET /models/{id}:getDownloadEndpoint is not served', 'api', 'niche'),
+  todo('fireworks.batch.chat_completion_batch', 'batch_inference', 'Batch inference: the batch OUTPUT surface (job completion, output dataset population, per-request completions inside it) is not modeled — jobs stay in JOB_STATE_CREATING and never produce output', 'api', 'niche'),
+
+  // ── Chat Completions (the protocol envelope — faithful) ────────────────────────────────
+  done('fireworks.chat.create', 'chat', 'Chat: create → faithful envelope (id/object/created/model/choices/usage)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT() });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      if (b.object !== 'chat.completion' || b.model !== MODEL || typeof b.created !== 'number') return false;
+      if (!String(b.id).startsWith('chatcmpl-')) return false;
+      const c = b.choices?.[0];
+      if (!c || c.message?.role !== 'assistant' || typeof c.message?.content !== 'string' || c.finish_reason !== 'stop') return false;
+      const u = b.usage;
+      return typeof u?.prompt_tokens === 'number' && u.prompt_tokens > 0 && u.total_tokens === u.prompt_tokens + u.completion_tokens;
+    }),
+  ),
+  done('fireworks.chat.stub_labeled', 'chat', 'Stub completion is clearly labeled as a twin stub (not real output)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT() });
+      const text = (r.body as Body).choices?.[0]?.message?.content as string;
+      return ok(r) && typeof text === 'string' && text.includes(`[twin-stub:${MODEL}]`) && text.includes('hello twin');
+    }),
+  ),
+  done('fireworks.chat.validation_fastapi_422', 'chat', 'Chat validation answers the FastAPI 422 HTTPValidationError envelope (loc/msg/type) the vendor spec declares', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const noModel = await h({ m: 'POST', p: CHAT_PATH, b: { messages: [{ role: 'user', content: 'x' }] } });
+      const noMsg = await h({ m: 'POST', p: CHAT_PATH, b: { model: MODEL } });
+      if (noModel.status !== 422 || noMsg.status !== 422) return false;
+      const d = (noModel.body as Body)?.detail;
+      return Array.isArray(d) && d[0]?.loc?.[0] === 'body' && d[0]?.loc?.[1] === 'model' && typeof d[0]?.msg === 'string' && typeof d[0]?.type === 'string';
+    }),
+  ),
+  done('fireworks.chat.max_tokens_alias_exclusion', 'chat', "Chat: 'max_tokens' and 'max_completion_tokens' cannot both be set (the vendor's own alias rule — OpenAI allows both)", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const both = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ max_tokens: 10, max_completion_tokens: 10 }) });
+      return both.status === 400 && typeof ((both.body as Body)?.error?.message as string) === 'string' && ((both.body as Body).error.message as string).includes('max_completion_tokens');
+    }),
+  ),
+  done('fireworks.chat.service_tier_priority_only', 'chat', "Chat: service_tier accepts the full enum but only 'priority' is honored — every other value behaves as 'default' and NEVER errors", 'api', 'core', () =>
+    withRoot(async (h) => {
+      for (const tier of ['auto', 'default', 'flex', 'priority']) {
+        const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ service_tier: tier }) });
+        if (!ok(r)) return false; // all four ACCEPTED — 'auto'/'flex' are not errors
+      }
+      const bogus = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ service_tier: 'bogus' }) });
+      return bogus.status === 422; // outside the enum IS an error
+    }),
+  ),
+  // THE VALIDATION TABLE: every documented range/enum/type on the inference doors is enforced
+  // with the FastAPI 422 envelope and pydantic's own error `type` — the vendor's server refuses
+  // each of these; a 200 here would be a wire lie. One check per (parameter, constraint).
+  done('fireworks.chat.sampling_ranges_enforced', 'chat', 'Chat: the documented sampling ranges are enforced — temperature 0..2, top_p 0..1, n 1..128, top_k 0..100, penalties -2..2, message role enum, stream boolean — each answering the FastAPI 422 envelope with its pydantic error type', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const expect422 = async (extra: Record<string, unknown>, loc: Array<string | number>, type: string) => {
+        const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT(extra) });
+        if (r.status !== 422) return false;
+        const d = (r.body as Body)?.detail;
+        return Array.isArray(d) && JSON.stringify(d[0]?.loc) === JSON.stringify(loc) && d[0]?.type === type;
+      };
+      // temperature 0..2 (the spec's own description)
+      if (!(await expect422({ temperature: 5 }, ['body', 'temperature'], 'less_than_equal'))) return false;
+      if (!(await expect422({ temperature: -0.1 }, ['body', 'temperature'], 'greater_than_equal'))) return false;
+      // top_p 0..1 (the spec's "Required range: `0 <= x <= 1`")
+      if (!(await expect422({ top_p: 1.5 }, ['body', 'top_p'], 'less_than_equal'))) return false;
+      if (!(await expect422({ top_p: -0.5 }, ['body', 'top_p'], 'greater_than_equal'))) return false;
+      // n 1..128
+      if (!(await expect422({ n: 0 }, ['body', 'n'], 'greater_than_equal'))) return false;
+      if (!(await expect422({ n: 129 }, ['body', 'n'], 'less_than_equal'))) return false;
+      // top_k 0..100
+      if (!(await expect422({ top_k: 101 }, ['body', 'top_k'], 'less_than_equal'))) return false;
+      // penalties -2..2
+      if (!(await expect422({ frequency_penalty: 2.5 }, ['body', 'frequency_penalty'], 'less_than_equal'))) return false;
+      if (!(await expect422({ presence_penalty: -3 }, ['body', 'presence_penalty'], 'greater_than_equal'))) return false;
+      // message role enum — FastAPI's loc carries the message INDEX
+      if (!(await expect422({ messages: [{ role: 'wizard', content: 'x' }] }, ['body', 'messages', 0, 'role'], 'enum'))) return false;
+      if (!(await expect422({ messages: [{ role: 'user', content: 'a' }, { role: 'guru', content: 'b' }] }, ['body', 'messages', 1, 'role'], 'enum'))) return false;
+      // stream boolean
+      if (!(await expect422({ stream: 'yes' }, ['body', 'stream'], 'bool_type'))) return false;
+      // type violations: pydantic's JSON-parse kinds — a string where a float belongs is
+      // float_parsing; a string/float where an integer belongs is int_parsing/int_from_float.
+      if (!(await expect422({ temperature: 'hot' }, ['body', 'temperature'], 'float_parsing'))) return false;
+      if (!(await expect422({ n: 'many' }, ['body', 'n'], 'int_parsing'))) return false;
+      if (!(await expect422({ n: 1.5 }, ['body', 'n'], 'int_from_float'))) return false;
+      if (!(await expect422({ max_tokens: 'x' }, ['body', 'max_tokens'], 'int_parsing'))) return false;
+      // boundaries ACCEPTED: temperature 0 and 2, top_p 0 and 1, n 1, top_k 0 and 100, penalties -2 and 2
+      for (const extra of [{ temperature: 0 }, { temperature: 2 }, { top_p: 0 }, { top_p: 1 }, { n: 1 }, { top_k: 0 }, { top_k: 100 }, { frequency_penalty: -2 }, { presence_penalty: 2 }]) {
+        if (!ok(await h({ m: 'POST', p: CHAT_PATH, b: CHAT(extra) }))) return false;
+      }
+      return true;
+    }),
+  ),
+  done('fireworks.completions.sampling_ranges_enforced', 'completions', 'Legacy completions: the same sampling ranges are enforced at the completions door (temperature 0..2, top_p 0..1, n 1..128, top_k 0..100, penalties -2..2, stream boolean) with the same pydantic kinds', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/completions', b: { model: MODEL, prompt: 'x', temperature: 5 } });
+      if (r.status !== 422 || ((r.body as Body)?.detail?.[0]?.type) !== 'less_than_equal') return false;
+      const topP = await h({ m: 'POST', p: '/inference/v1/completions', b: { model: MODEL, prompt: 'x', top_p: 1.5 } });
+      if (topP.status !== 422 || ((topP.body as Body)?.detail?.[0]?.type) !== 'less_than_equal') return false;
+      const typeErr = await h({ m: 'POST', p: '/inference/v1/completions', b: { model: MODEL, prompt: 'x', temperature: 'hot' } });
+      if (typeErr.status !== 422 || ((typeErr.body as Body)?.detail?.[0]?.type) !== 'float_parsing') return false;
+      const stream = await h({ m: 'POST', p: '/inference/v1/completions', b: { model: MODEL, prompt: 'x', stream: 'yes' } });
+      return stream.status === 422 && ((stream.body as Body)?.detail?.[0]?.type) === 'bool_type';
+    }),
+  ),
+  done('fireworks.chat.context_length_exceeded_behavior', 'chat', "Chat: context_length_exceeded_behavior defaults to 'truncate' (the documented OpenAI difference) — 'error' refuses with a context-length message", 'api', 'common', () =>
+    withRoot(async (h) => {
+      // A huge max_tokens with the default (truncate) is ACCEPTED — no error.
+      const trunc = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ max_tokens: 1_000_000 }) });
+      if (!ok(trunc)) return false;
+      // With 'error' the same request refuses.
+      const err = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ max_tokens: 1_000_000, context_length_exceeded_behavior: 'error' }) });
+      return err.status === 400 && String((err.body as Body)?.error?.message ?? '').includes('context');
+    }),
+  ),
+  done('fireworks.chat.stop_sequences', 'chat', 'Chat: stop sequences truncate the completion and keep finish_reason stop', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ stop: ['[twin-stub'] }) });
+      if (!ok(r)) return false;
+      const text = (r.body as Body).choices?.[0]?.message?.content as string;
+      return ok(r) && !text.includes('[twin-stub') && text.length === 0; // the stub text STARTS with the label
+    }),
+  ),
+  done('fireworks.chat.max_tokens_length_finish', 'chat', 'Chat: max_tokens truncation answers finish_reason length, not stop', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ max_tokens: 2 }) });
+      if (!ok(r)) return false;
+      const c = (r.body as Body).choices?.[0];
+      return c?.finish_reason === 'length' && typeof c?.message?.content === 'string';
+    }),
+  ),
+  done('fireworks.chat.reasoning_content_field', 'chat', 'Chat: reasoning_effort surfaces the separate reasoning_content field (the Fireworks reasoning-model extension)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ reasoning_effort: 'high' }) });
+      if (!ok(r)) return false;
+      const m = (r.body as Body).choices?.[0]?.message;
+      return typeof m?.reasoning_content === 'string' && m.reasoning_content.includes('[twin-stub:');
+    }),
+  ),
+  done('fireworks.chat.json_response_format', 'chat', 'Chat: response_format json_object/json_schema produce JSON content', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ response_format: { type: 'json_object' } }) });
+      if (!ok(r)) return false;
+      const text = (r.body as Body).choices?.[0]?.message?.content as string;
+      try { JSON.parse(text.split('\n').at(-1) ?? ''); return true; } catch { return false; }
+    }),
+  ),
+  todo('fireworks.chat.tools_full_support', 'chat', 'Chat: native tool_calls generation from a tools array (today the stub never emits tool_calls on the non-streaming path)', 'api', 'core'),
+  todo('fireworks.chat.n_choices', 'chat', 'Chat: n > 1 choices', 'api', 'niche'),
+  todo('fireworks.chat.logit_bias_echo', 'chat', 'Chat: logit_bias accepted and echoed in behavior (no-op on a stub)', 'api', 'niche'),
+  todo('fireworks.chat.vision_input', 'chat', 'Chat: image_url content blocks accepted (multimodal input)', 'api', 'common'),
+  todo('fireworks.chat.usage_caching_fields', 'chat', 'Chat: cached-prompt token fields (prompt_tokens_details) on usage', 'api', 'niche'),
+
+  // ── Streaming (the documented OpenAI difference is the fidelity surface) ───────────────
+  done('fireworks.streaming.usage_on_final_chunk_by_default', 'streaming', 'Streaming: usage arrives on the FINAL chunk (the one carrying finish_reason) BY DEFAULT — no stream_options.include_usage needed', 'api', 'core', () =>
+    withStream(CHAT({ stream: true }), (events, final) => {
+      if (final.status !== 200) return false;
+      const datas = events.filter((e) => !e.done).map((e) => e.data as Body);
+      if (datas.length < 3) return false;
+      const finalChunk = datas.at(-1)!; // the finish_reason chunk — [DONE] is filtered out of `datas`
+      if (finalChunk?.choices?.[0]?.finish_reason === null) return false;
+      const u = finalChunk?.usage;
+      return typeof u?.prompt_tokens === 'number' && u.total_tokens === u.prompt_tokens + u.completion_tokens;
+    }),
+  ),
+  done('fireworks.streaming.include_usage_false_opts_out', 'streaming', 'Streaming: stream_options.include_usage=false is the opt-OUT (the inverse of OpenAI) — the final chunk then carries usage null', 'api', 'common', () =>
+    withStream(CHAT({ stream: true, stream_options: { include_usage: false } }), (events, final) => {
+      if (final.status !== 200) return false;
+      const datas = events.filter((e) => !e.done).map((e) => e.data as Body);
+      const finalChunk = datas.at(-1)!;
+      return finalChunk?.usage === null;
+    }),
+  ),
+  done('fireworks.streaming.chunk_shape', 'streaming', 'Streaming: chunk shape (object chat.completion.chunk, delta content pieces in order, [DONE] sentinel)', 'api', 'core', () =>
+    withStream(CHAT({ stream: true }), (events, final) => {
+      if (final.status !== 200) return false;
+      const datas = events.filter((e) => !e.done).map((e) => e.data as Body);
+      if (!datas.every((d) => d.object === 'chat.completion.chunk' && Array.isArray(d.choices))) return false;
+      // First chunk carries the role; middle chunks carry content pieces; last carries finish_reason.
+      if (datas[0]?.choices?.[0]?.delta?.role !== 'assistant') return false;
+      const joined = datas.slice(1, -1).map((d) => d.choices?.[0]?.delta?.content ?? '').join('');
+      return joined.length > 0 && datas.at(-1)?.choices?.[0]?.finish_reason === 'stop' && events.at(-1)?.done === true;
+    }),
+  ),
+  done('fireworks.streaming.pre_stream_refusal_real_status', 'streaming', 'Streaming: a pre-stream failure (missing model) answers its REAL 422 status, never a 200 stream with an error frame', 'api', 'core', () =>
+    withRoot(async (h) => {
+      // The in-process call is what the HTTP server replays: the handler must refuse BEFORE
+      // emitting chunks when the request is invalid.
+      const events: SseEvent[] = [];
+      const r = await handleFireworksTwinRequest({ method: 'POST', path: CHAT_PATH, body: JSON.stringify({ messages: [{ role: 'user', content: 'x' }], stream: true }), sseSink: (e) => events.push(e) });
+      return r.status === 422 && events.length === 0;
+    }),
+  ),
+  todo('fireworks.streaming.buffer_options', 'streaming', 'Streaming: stream_options buffer_tokens/buffer_ms/buffer_mode (the Fireworks buffering extensions)', 'api', 'niche'),
+
+  // ── Legacy completions ─────────────────────────────────────────────────────────────────
+  done('fireworks.completions.create', 'completions', 'Legacy completions: create → faithful envelope with REQUIRED usage (the spec marks it required, unlike chat)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/completions', b: { model: MODEL, prompt: 'hello twin' } });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      return b.object === 'text_completion' && Array.isArray(b.choices) && b.choices[0]?.text?.includes('[twin-stub:')
+        && typeof b.usage?.prompt_tokens === 'number' && b.usage.total_tokens === b.usage.prompt_tokens + b.usage.completion_tokens;
+    }),
+  ),
+  done('fireworks.completions.prompt_array', 'completions', 'Legacy completions: an array prompt answers one choice per prompt', 'api', 'niche', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/completions', b: { model: MODEL, prompt: ['a', 'b'] } });
+      if (!ok(r)) return false;
+      const choices = (r.body as Body).choices as Body[];
+      return choices.length === 2 && choices[0]?.index === 0 && choices[1]?.index === 1;
+    }),
+  ),
+  todo('fireworks.completions.echo', 'completions', 'Legacy completions: echo=true returns the prompt in the text', 'api', 'niche'),
+  todo('fireworks.completions.logprobs', 'completions', 'Legacy completions: logprobs/top_logprobs shape', 'api', 'niche'),
+
+  // ── Responses API (stateful CRUD over the kernel log) ──────────────────────────────────
+  done('fireworks.responses.create_and_get', 'responses', 'Responses: create stores and GET retrieves by id (store defaults true)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const created = await h({ m: 'POST', p: '/inference/v1/responses', b: { model: MODEL, input: 'hello twin' } });
+      if (!ok(created)) return false;
+      const rid = (created.body as Body)?.id;
+      if (typeof rid !== 'string') return false;
+      const got = await h({ m: 'GET', p: `/inference/v1/responses/${encodeURIComponent(rid)}` });
+      if (!ok(got)) return false;
+      const b = got.body as Body;
+      return b.id === rid && b.status === 'completed' && b.object === 'response' && Array.isArray(b.output);
+    }),
+  ),
+  done('fireworks.responses.store_false_null_id', 'responses', "Responses: store=false answers id:null (the vendor's own contract) and stores NOTHING — a later GET 404s", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const created = await h({ m: 'POST', p: '/inference/v1/responses', b: { model: MODEL, input: 'ephemeral', store: false } });
+      if (!ok(created)) return false;
+      if ((created.body as Body)?.id !== null) return false;
+      const list = await h({ m: 'GET', p: '/inference/v1/responses?limit=100' });
+      const data = ((list.body as Body)?.data ?? []) as Body[];
+      return !data.some((d) => (d.output?.[0]?.content?.[0]?.text as string)?.includes('ephemeral'));
+    }),
+  ),
+  done('fireworks.responses.delete', 'responses', 'Responses: DELETE removes the stored response (a later GET 404s)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const created = await h({ m: 'POST', p: '/inference/v1/responses', b: { model: MODEL, input: 'doomed' } });
+      const rid = (created.body as Body)?.id as string;
+      const del = await h({ m: 'DELETE', p: `/inference/v1/responses/${encodeURIComponent(rid)}` });
+      if (!ok(del) || (del.body as Body)?.deleted !== true) return false;
+      const got = await h({ m: 'GET', p: `/inference/v1/responses/${encodeURIComponent(rid)}` });
+      return got.status === 404;
+    }),
+  ),
+  done('fireworks.responses.list_envelope', 'responses', 'Responses: list answers {object:list, data, has_more, first_id, last_id} per the vendor spec', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'GET', p: '/inference/v1/responses' });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      return b.object === 'list' && Array.isArray(b.data) && typeof b.has_more === 'boolean' && (b.first_id === null || typeof b.first_id === 'string') && (b.last_id === null || typeof b.last_id === 'string');
+    }),
+  ),
+  todo('fireworks.responses.previous_response_id_chain', 'responses', 'Responses: previous_response_id conversation chaining validated against stored history', 'api', 'common'),
+  todo('fireworks.responses.streaming_events', 'responses', 'Responses: streaming event sequence (response.created → response.output_text.delta → response.completed)', 'api', 'common'),
+
+  // ── Anthropic-compatible /v1/messages ──────────────────────────────────────────────────
+  done('fireworks.messages.anthropic_envelope', 'messages', 'Messages: the Anthropic envelope (id/type/role/content blocks/model/stop_reason/stop_sequence/usage) — NOT the OpenAI shape', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/messages', b: { model: MODEL, messages: [{ role: 'user', content: 'hello twin' }] } });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      return b.type === 'message' && b.role === 'assistant' && Array.isArray(b.content) && b.content[0]?.type === 'text'
+        && ['end_turn', 'max_tokens', 'stop_sequence', 'tool_use', 'pause_turn', 'refusal'].includes(b.stop_reason)
+        && typeof b.usage?.input_tokens === 'number' && typeof b.usage?.output_tokens === 'number';
+    }),
+  ),
+  done('fireworks.messages.max_tokens_optional', 'messages', 'Messages: max_tokens is OPTIONAL on Fireworks (required on Anthropic — the documented difference)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/messages', b: { model: MODEL, messages: [{ role: 'user', content: 'no max token' }] } });
+      return ok(r) && (r.body as Body)?.stop_reason === 'end_turn';
+    }),
+  ),
+  done('fireworks.messages.max_tokens_stop_reason', 'messages', 'Messages: max_tokens truncation answers stop_reason max_tokens', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/messages', b: { model: MODEL, max_tokens: 2, messages: [{ role: 'user', content: 'long' }] } });
+      return ok(r) && (r.body as Body)?.stop_reason === 'max_tokens';
+    }),
+  ),
+  done('fireworks.messages.anthropic_error_envelope', 'messages', 'Messages: errors use the Anthropic envelope {type:error, error:{type,message}} — a DIFFERENT shape from the OpenAI-compat plane', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/messages', b: { messages: [{ role: 'user', content: 'x' }] } });
+      if (r.status !== 400) return false;
+      const b = r.body as Body;
+      return b.type === 'error' && b.error?.type === 'invalid_request_error' && typeof b.error?.message === 'string';
+    }),
+  ),
+  done('fireworks.messages.anthropic_streaming', 'messages', 'Messages streaming: message_start → content_block_start/delta/stop → message_delta (the ONE delta carrying ACTUAL usage) → message_stop, WITHOUT a [DONE] sentinel', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const events: SseEvent[] = [];
+      const r = await handleFireworksTwinRequest({ method: 'POST', path: '/inference/v1/messages', body: JSON.stringify({ model: MODEL, messages: [{ role: 'user', content: 'stream me' }], stream: true }), sseSink: (e) => events.push(e) });
+      if (r.status !== 200) return false;
+      const datas = events.filter((e) => !e.done).map((e) => e.data as Body);
+      const types = datas.map((d) => d.type);
+      if (types[0] !== 'message_start' || types.at(-1) !== 'message_stop') return false;
+      const delta = datas.find((d) => d.type === 'message_delta');
+      return typeof delta?.usage?.output_tokens === 'number' && delta.usage.output_tokens > 0
+        && typeof delta?.delta?.stop_reason === 'string';
+    }),
+  ),
+  done('fireworks.messages.system_blocks', 'messages', 'Messages: system accepts a string or text blocks and feeds the prompt — it is priced into input_tokens and is the stub text when no user message carries text', 'api', 'niche', () =>
+    withRoot(async (h) => {
+      // blocks form and string form both accepted
+      const blocks = await h({ m: 'POST', p: '/inference/v1/messages', b: { model: MODEL, system: [{ type: 'text', text: 'be terse' }], messages: [{ role: 'user', content: 'hi' }] } });
+      if (!ok(blocks)) return false;
+      const priced = ((blocks.body as Body)?.usage?.input_tokens as number | undefined) ?? 0;
+      const bare = await h({ m: 'POST', p: '/inference/v1/messages', b: { model: MODEL, messages: [{ role: 'user', content: 'hi' }] } });
+      const bareTokens = ((bare.body as Body)?.usage?.input_tokens as number | undefined) ?? 0;
+      if (priced <= bareTokens) return false; // the system text was priced in
+      // messages must be non-empty (the vendor rule), so a blank user message leaves the system
+      // text as the only prompt the stub echoes
+      const only = await h({ m: 'POST', p: '/inference/v1/messages', b: { model: MODEL, system: 'be terse', messages: [{ role: 'user', content: ' ' }] } });
+      const t = (only.body as Body)?.content?.[0]?.text as string | undefined;
+      return ok(only) && typeof t === 'string' && t.includes('be terse');
+    }),
+  ),
+  todo('fireworks.messages.tool_use_blocks', 'messages', 'Messages: tool_use / tool_result content blocks and stop_reason tool_use', 'api', 'common'),
+  todo('fireworks.messages.thinking_blocks', 'messages', 'Messages: thinking / redacted_thinking content blocks for reasoning models', 'api', 'niche'),
+
+  // ── Embeddings + rerank ────────────────────────────────────────────────────────────────
+  done('fireworks.embeddings.create', 'embeddings', 'Embeddings: create → {object:list, data[{index, object:embedding, embedding}], usage}', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/embeddings', b: { model: 'nomic-ai/nomic-embed-text-v1.5', input: 'hello twin' } });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      const d = b.data?.[0];
+      return b.object === 'list' && d?.object === 'embedding' && d?.index === 0 && Array.isArray(d?.embedding) && d.embedding.length > 0
+        && typeof b.usage?.prompt_tokens === 'number';
+    }),
+  ),
+  done('fireworks.embeddings.unit_norm', 'embeddings', 'Embeddings: pseudo-vectors are L2-normalized (a vector the length-sensitive consumers can use)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/embeddings', b: { model: 'nomic-ai/nomic-embed-text-v1.5', input: 'norm check' } });
+      const vec = (r.body as Body)?.data?.[0]?.embedding as number[];
+      const norm = Math.hypot(...vec);
+      return Math.abs(norm - 1) < 1e-9;
+    }),
+  ),
+  done('fireworks.embeddings.dimensions_param', 'embeddings', 'Embeddings: dimensions param changes the vector length; an invalid one is refused with the pydantic kinds (int_parsing / int_from_float / bounds) BEFORE any allocation — an absurd size never allocates', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/embeddings', b: { model: 'nomic-ai/nomic-embed-text-v1.5', input: 'dims', dimensions: 256 } });
+      if (!ok(r) || ((r.body as Body)?.data?.[0]?.embedding as unknown[]).length !== 256) return false;
+      const expect422 = async (dims: unknown, type: string) => {
+        const res = await h({ m: 'POST', p: '/inference/v1/embeddings', b: { model: 'nomic-ai/nomic-embed-text-v1.5', input: 'x', dimensions: dims } });
+        return res.status === 422 && ((res.body as Body)?.detail?.[0]?.type) === type && ((res.body as Body)?.detail?.[0]?.loc?.[1]) === 'dimensions';
+      };
+      // a string is int_parsing; a float is int_from_float; below 1 / above the model bound are
+      // the pydantic range kinds; 0 is a bound failure too (never a 200 with an empty vector).
+      if (!(await expect422('x', 'int_parsing'))) return false;
+      if (!(await expect422(2.5, 'int_from_float'))) return false;
+      if (!(await expect422(-1, 'greater_than_equal'))) return false;
+      if (!(await expect422(0, 'greater_than_equal'))) return false;
+      if (!(await expect422(1_000_000_000, 'less_than_equal'))) return false;
+      // The happy path still answers fast at the largest legal size.
+      const big = await h({ m: 'POST', p: '/inference/v1/embeddings', b: { model: 'nomic-ai/nomic-embed-text-v1.5', input: 'big', dimensions: 4096 } });
+      return ok(big) && ((big.body as Body)?.data?.[0]?.embedding as unknown[]).length === 4096;
+    }),
+  ),
+  done('fireworks.embeddings.input_array', 'embeddings', 'Embeddings: an array input answers one embedding per element, indexed in order', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/embeddings', b: { model: 'nomic-ai/nomic-embed-text-v1.5', input: ['a', 'b', 'c'] } });
+      const data = (r.body as Body)?.data as Body[];
+      return data.length === 3 && data.map((d) => d.index).join(',') === '0,1,2';
+    }),
+  ),
+  todo('fireworks.embeddings.base64_encoding', 'embeddings', 'Embeddings: encoding_format base64 is served (deterministic float vectors base64-encoded) but no verify proves the decoded bytes equal the float path', 'api', 'niche'),
+  done('fireworks.rerank.create', 'rerank', 'Rerank: create → {object:list, data[{index, relevance_score, document}], usage} ordered by score', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/rerank', b: { model: 'accounts/fireworks/models/qwen3-reranker-8b', query: 'weather', documents: ['the sky is blue', 'it is raining today', 'a weather report'] } });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      const data = b.data as Body[];
+      const scores = data.map((d) => d.relevance_score as number);
+      return b.object === 'list' && Array.isArray(data) && data.every((d) => typeof d.index === 'number' && typeof d.relevance_score === 'number')
+        && scores.every((s, i) => i === 0 || scores[i - 1]! >= s);
+    }),
+  ),
+  done('fireworks.rerank.query_responsive_order', 'rerank', 'Rerank: the ORDER responds to the query (shared-token overlap biases the score — a constant ordering would be a fake)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const docs = ['alpha document', 'beta document', 'gamma document'];
+      const one = await h({ m: 'POST', p: '/inference/v1/rerank', b: { query: 'alpha', documents: docs } });
+      const two = await h({ m: 'POST', p: '/inference/v1/rerank', b: { query: 'gamma', documents: docs } });
+      if (!ok(one) || !ok(two)) return false;
+      const first = ((one.body as Body).data as Body[])[0];
+      const second = ((two.body as Body).data as Body[])[0];
+      return first?.index === 0 && second?.index === 2;
+    }),
+  ),
+  done('fireworks.rerank.top_n_and_return_documents', 'rerank', 'Rerank: top_n slices the data; return_documents=false omits the document text', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const docs = ['a one', 'b two', 'c three'];
+      const r = await h({ m: 'POST', p: '/inference/v1/rerank', b: { query: 'a', documents: docs, top_n: 1, return_documents: false } });
+      const data = (r.body as Body)?.data as Body[];
+      return data.length === 1 && data[0]?.document === undefined;
+    }),
+  ),
+
+  // ── Auth (the vendor requires a bearer on every request) ───────────────────────────────
+  done('fireworks.auth.missing_key_401', 'auth', 'Auth: a request presenting an auth surface with no credential answers 401', 'api', 'core', () =>
+    withRootH(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT(), headers: { authorization: '' } });
+      return r.status === 401;
+    }),
+  ),
+  done('fireworks.auth.invalid_key_401', 'auth', 'Auth: a presented-but-invalid key answers 401 (sentinel keys model the invalid path)', 'api', 'core', () =>
+    withRootH(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT(), headers: { authorization: 'Bearer fw_invalid' } });
+      return r.status === 401;
+    }),
+  ),
+  done('fireworks.auth.any_key_accepted', 'auth', 'Auth: any other non-empty bearer key is accepted (the twin cannot validate against real keys) — and the completion really answers', 'api', 'core', () =>
+    withRootH(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT(), headers: { authorization: 'Bearer fw_any_key' } });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      return b.object === 'chat.completion' && typeof b.id === 'string' && Array.isArray(b.choices) && b.choices.length > 0;
+    }),
+  ),
+  done('fireworks.auth.anthropic_plane_gated_too', 'auth', 'Auth: the Anthropic-compat plane answers its OWN error envelope on a 401', 'api', 'common', () =>
+    withRootH(async (h) => {
+      const r = await h({ m: 'POST', p: '/inference/v1/messages', b: { model: MODEL, messages: [{ role: 'user', content: 'x' }] }, headers: { authorization: 'Bearer fw_invalid' } });
+      return r.status === 401 && (r.body as Body)?.type === 'error';
+    }),
+  ),
+
+  // ── Error semantics (the vendor's documented status table) ─────────────────────────────
+  // HOLLOW BY METHOD (capability-mutation-sweep): the behavior asserted here is the ABSENCE of a
+  // route — the unknown path falls through every branch to the bare `return notFound(...)` at the
+  // router's end. There is no guard or property line to neuter that makes an unknown path answer
+  // anything else (deleting the fallthrough itself is a global break, not a localized mutation);
+  // adding-a-twin.md §"hollow" grades exactly this cell by method, not by fact.
+  done('fireworks.errors.unknown_path_404', 'errors', 'Errors: an unknown path on the inference plane answers 404 with the OpenAI-compat envelope (the control plane answers its own google.rpc shape)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'GET', p: '/inference/v1/definitely-not-a-thing' });
+      if (r.status !== 404 || typeof ((r.body as Body)?.error?.message as string) !== 'string') return false;
+      // The control plane's unknown path answers the google.rpc envelope, not the OpenAI shape.
+      const c = await h({ m: 'GET', p: '/v1/accounts/my-account/definitely-not-a-thing' });
+      return c.status === 404 && (c.body as Body)?.code === 'NOT_FOUND' && (c.body as Body)?.error === undefined;
+    }),
+  ),
+  done('fireworks.errors.rate_limit_429_scripted', 'errors', 'Errors: a scripted 429 fault (the kernel fault grammar) answers the vendor envelope in Fireworks’ own shape', 'api', 'common', () =>
+    withRoot(async (h) => {
+      // The scenario engine is the scripting door; the capability verifies the ENVELOPE the
+      // scripted failure produces (the handler path, not the scenario plumbing). The fault is
+      // the kernel's grammar — `fault:{kind:'status'}` — rendered into Fireworks' own
+      // {error:{message, code, type}} shape by the adapter's renderFault.
+      const { createFireworksScenarioEngine } = await import('./fireworks-scenario.ts');
+      const engine = createFireworksScenarioEngine({
+        handlers: [{ on: { userTextIncludes: 'fail me' }, fault: { kind: 'status', status: 429, retryAfterSeconds: 1 } }],
+      });
+      const r = await handleFireworksTwinRequest({ method: 'POST', path: CHAT_PATH, body: JSON.stringify(CHAT({ messages: [{ role: 'user', content: 'fail me' }] })), scenarioEngine: engine });
+      const b = r.body as Body;
+      return r.status === 429 && typeof b?.error?.message === 'string' && b?.error?.code === 429 && b?.error?.type === 'rate_limit_exceeded' && r.headers?.['retry-after'] === '1';
+    }),
+  ),
+  todo('fireworks.errors.503_load_shed', 'errors', 'Errors: 503 on serverless load-shed (the documented serverless behavior) beyond the scripted path', 'api', 'common'),
+
+  // ── CONTROL PLANE: deployments (the deployment CRUD backbone) ───────────────────────────
+  done('fireworks.deployments.create_query_id', 'deployments', 'Deployments: create takes the deploymentId as a QUERY param (the vendor spec) and answers the resource', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: `${ACCOUNT}/deployments?deploymentId=my-deployment`, b: { baseModel: 'accounts/fireworks/models/llama-v3p1-8b-instruct' } });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      if (b.name !== 'accounts/my-account/deployments/my-deployment' || b.state !== 'CREATING' || b.baseModel !== 'accounts/fireworks/models/llama-v3p1-8b-instruct') return false;
+      // EXACT key set — the vendor's gatewayDeployment schema carries no `id`; identity is the
+      // hierarchical name, and nothing twin-internal (type/updatedAt/_account) may leak.
+      return JSON.stringify(Object.keys(b).sort()) === JSON.stringify(['baseModel', 'createTime', 'displayName', 'name', 'state', 'status', 'updateTime']);
+    }),
+  ),
+  done('fireworks.deployments.get', 'deployments', 'Deployments: GET by id retrieves the created row', 'api', 'core', () =>
+    withRoot(async (h) => {
+      if (!(await seedDeployment(h))) return false;
+      const r = await h({ m: 'GET', p: `${ACCOUNT}/deployments/my-deployment` });
+      return ok(r) && (r.body as Body)?.name === 'accounts/my-account/deployments/my-deployment';
+    }),
+  ),
+  done('fireworks.deployments.list_envelope', 'deployments', 'Deployments: list answers the gateway envelope {deployments, nextPageToken, totalSize} with pageSize pagination', 'api', 'core', () =>
+    withRoot(async (h) => {
+      if (!(await seedDeployment(h))) return false;
+      const r = await h({ m: 'GET', p: `${ACCOUNT}/deployments?pageSize=100` });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      return Array.isArray(b.deployments) && b.deployments.length === 1 && typeof b.nextPageToken !== 'undefined' && b.totalSize === 1;
+    }),
+  ),
+  done('fireworks.deployments.pagination', 'deployments', 'Deployments: pageSize + pageToken page deterministically through the list', 'api', 'common', () =>
+    withRoot(async (h) => {
+      await h({ m: 'POST', p: `${ACCOUNT}/deployments?deploymentId=d1`, b: { baseModel: 'accounts/fireworks/models/llama-v3p1-8b-instruct' } });
+      await h({ m: 'POST', p: `${ACCOUNT}/deployments?deploymentId=d2`, b: { baseModel: 'accounts/fireworks/models/llama-v3p1-8b-instruct' } });
+      const p1 = await h({ m: 'GET', p: `${ACCOUNT}/deployments?pageSize=1` });
+      const b1 = p1.body as Body;
+      if (!ok(p1) || b1.deployments?.length !== 1 || typeof b1.nextPageToken !== 'string') return false;
+      const p2 = await h({ m: 'GET', p: `${ACCOUNT}/deployments?pageSize=1&pageToken=${b1.nextPageToken}` });
+      const b2 = p2.body as Body;
+      return ok(p2) && b2.deployments?.length === 1 && b2.deployments[0]?.name !== b1.deployments[0]?.name;
+    }),
+  ),
+  done('fireworks.deployments.account_scoped', 'deployments', 'Tenancy: every control-plane write/read is account-namespaced in the kernel — a create under one account with an id another account holds (explicit or minted) can never land on or destroy the other account\'s row', 'api', 'core', () =>
+    withRoot(async (h) => {
+      // ── explicit id: create under acct-A, then address the SAME id through acct-B's paths. ──
+      const created = await h({ m: 'POST', p: '/v1/accounts/acct-A/deployments?deploymentId=shared-dep', b: { baseModel: 'accounts/fireworks/models/llama-v3p1-8b-instruct' } });
+      if (!ok(created)) return false;
+      const crossGet = await h({ m: 'GET', p: '/v1/accounts/acct-B/deployments/shared-dep' });
+      if (crossGet.status !== 404 || (crossGet.body as Body)?.code !== 'NOT_FOUND') return false;
+      const crossPatch = await h({ m: 'PATCH', p: '/v1/accounts/acct-B/deployments/shared-dep', b: { displayName: 'stolen' } });
+      if (crossPatch.status !== 404) return false;
+      const crossDelete = await h({ m: 'DELETE', p: '/v1/accounts/acct-B/deployments/shared-dep' });
+      if (crossDelete.status !== 404) return false;
+      // The owning account still sees the row, untouched by the cross-account attempts.
+      const still = await h({ m: 'GET', p: '/v1/accounts/acct-A/deployments/shared-dep' });
+      if (!ok(still) || (still.body as Body)?.displayName === 'stolen' || (still.body as Body)?.name !== 'accounts/acct-A/deployments/shared-dep') return false;
+      // THE DESTROY CASE: a create under acct-B with the SAME explicit id must NOT overwrite
+      // acct-A's row (the defect wrote both onto one kernel subject and A's row vanished).
+      const bCreate = await h({ m: 'POST', p: '/v1/accounts/acct-B/deployments?deploymentId=shared-dep', b: { baseModel: 'accounts/fireworks/models/llama-v3p1-8b-instruct', displayName: 'B owns this' } });
+      if (!ok(bCreate)) return false;
+      const aAfter = await h({ m: 'GET', p: '/v1/accounts/acct-A/deployments/shared-dep' });
+      if (!ok(aAfter) || (aAfter.body as Body)?.displayName === 'B owns this') return false; // A's row survived B's create of the same id
+      const bAfter = await h({ m: 'GET', p: '/v1/accounts/acct-B/deployments/shared-dep' });
+      if (!ok(bAfter) || (bAfter.body as Body)?.displayName !== 'B owns this') return false;
+      // ── no-id mint: two tenants each POST one deployment with no explicit id — the minted ids
+      //    may repeat across accounts (each mints its own `deployment_twin_1`), and each
+      //    account's LIST shows exactly its own row. ──
+      for (const acct of ['acct-A', 'acct-B']) {
+        const minted = await h({ m: 'POST', p: `/v1/accounts/${acct}/deployments`, b: { baseModel: 'accounts/fireworks/models/llama-v3p1-8b-instruct' } });
+        if (!ok(minted)) return false;
+      }
+      const listA = await h({ m: 'GET', p: '/v1/accounts/acct-A/deployments?pageSize=100' });
+      const listB = await h({ m: 'GET', p: '/v1/accounts/acct-B/deployments?pageSize=100' });
+      if (!ok(listA) || !ok(listB)) return false;
+      const namesA = ((listA.body as Body)?.deployments ?? []).map((d: Body) => d.name) as string[];
+      const namesB = ((listB.body as Body)?.deployments ?? []).map((d: Body) => d.name) as string[];
+      // Each account holds its own shared-dep AND its own mint of deployment_twin_1; the minted
+      // names differ only by account — exactly the tenancy the namespaced subject provides.
+      return namesA.includes('accounts/acct-A/deployments/deployment_twin_1') && namesB.includes('accounts/acct-B/deployments/deployment_twin_1');
+    }),
+  ),
+  // THE TABLE: one row per control-plane collection, each proving the same tenancy invariant on
+  // its own type — a cross-account create of the SAME explicit id leaves the other tenant's row
+  // byte-identical. Deployments carries the deeper probe above (GET/PATCH/DELETE + the mint);
+  // this table proves the CLASS across every collection the Gateway serves, including apiKeys
+  // (nested under users, minted ids) and the secret's `name`-carried id.
+  done('fireworks.control.tenancy_table', 'control', 'Tenancy table: for EVERY control-plane collection, a cross-account create of the same id cannot land on or destroy the other account\'s row', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const BASE = 'accounts/fireworks/models/llama-v3p1-8b-instruct';
+      // [collection path, create body builder per account, get path per account, field that
+      //  names the account's own value on the GET]
+      const cases: Array<{ coll: string; body: (acct: string) => unknown; idQ: string; get: (acct: string) => string; field: string; value: (acct: string) => unknown }> = [
+        { coll: 'deployments', idQ: 'deploymentId=shared', body: (a) => ({ baseModel: BASE, displayName: `dep-${a}` }), get: (a) => `/v1/accounts/${a}/deployments/shared`, field: 'displayName', value: (a) => `dep-${a}` },
+        { coll: 'datasets', idQ: '', body: (a) => ({ dataset: { displayName: `ds-${a}` }, datasetId: 'shared' }), get: (a) => `/v1/accounts/${a}/datasets/shared`, field: 'displayName', value: (a) => `ds-${a}` },
+        { coll: 'batchInferenceJobs', idQ: 'batchInferenceJobId=shared', body: (a) => ({ model: BASE, inputDatasetId: 'ds-shared' }), get: (a) => `/v1/accounts/${a}/batchInferenceJobs/shared`, field: 'inputDatasetId', value: () => 'ds-shared' },
+        { coll: 'supervisedFineTuningJobs', idQ: 'supervisedFineTuningJobId=shared', body: (a) => ({ dataset: `accounts/${a}/datasets/ds-shared`, baseModel: BASE }), get: (a) => `/v1/accounts/${a}/supervisedFineTuningJobs/shared`, field: 'dataset', value: (a) => `accounts/${a}/datasets/ds-shared` },
+        { coll: 'users', idQ: 'userId=shared', body: () => ({ role: 'admin' }), get: (a) => `/v1/accounts/${a}/users/shared`, field: 'role', value: () => 'admin' },
+        { coll: 'models', idQ: 'modelId=shared', body: (a) => ({ displayName: `model-${a}` }), get: (a) => `/v1/accounts/${a}/models/shared`, field: 'displayName', value: (a) => `model-${a}` },
+        { coll: 'secrets', idQ: '', body: (a) => ({ name: `accounts/${a}/secrets/shared`, keyName: 'K' }), get: (a) => `/v1/accounts/${a}/secrets/shared`, field: 'keyName', value: () => 'K' },
+      ];
+      for (const c of cases) {
+        // The dataset each job references must exist per account (409 from an earlier case's
+        // seed in this shared root is the row already existing — fine).
+        if (c.coll === 'batchInferenceJobs' || c.coll === 'supervisedFineTuningJobs') {
+          for (const acct of ['tenA', 'tenB']) {
+            const seeded = await h({ m: 'POST', p: `/v1/accounts/${acct}/datasets`, b: { dataset: { displayName: 'shared ds' }, datasetId: 'ds-shared' } });
+            if (!ok(seeded) && seeded.status !== 409) return false;
+          }
+        }
+        const a = await h({ m: 'POST', p: `/v1/accounts/tenA/${c.coll}${c.idQ ? `?${c.idQ}` : ''}`, b: c.body('tenA') });
+        if (!ok(a)) return false;
+        const before = await h({ m: 'GET', p: c.get('tenA') });
+        if (!ok(before)) return false;
+        const snapshot = JSON.stringify(before.body);
+        // B creates the SAME id under its own account — must succeed and leave A's row untouched.
+        const b = await h({ m: 'POST', p: `/v1/accounts/tenB/${c.coll}${c.idQ ? `?${c.idQ}` : ''}`, b: c.body('tenB') });
+        if (!ok(b)) return false;
+        const after = await h({ m: 'GET', p: c.get('tenA') });
+        if (!ok(after) || JSON.stringify(after.body) !== snapshot) return false; // byte-identical
+        if ((after.body as Body)?.[c.field] !== c.value('tenA')) return false;
+        // And B's row is its own.
+        const bGet = await h({ m: 'GET', p: c.get('tenB') });
+        if (!ok(bGet) || JSON.stringify(bGet.body) === snapshot) return false;
+      }
+      // apiKeys: minted ids — one key per tenant, each account's list shows only its own.
+      for (const acct of ['tenA', 'tenB']) {
+        if (!ok(await h({ m: 'POST', p: `/v1/accounts/${acct}/users?userId=u1`, b: { role: 'user' } }))) return false;
+        if (!ok(await h({ m: 'POST', p: `/v1/accounts/${acct}/users/u1/apiKeys`, b: { apiKey: { displayName: `key-${acct}` } } }))) return false;
+      }
+      const keysA = await h({ m: 'GET', p: '/v1/accounts/tenA/users/u1/apiKeys' });
+      const keysB = await h({ m: 'GET', p: '/v1/accounts/tenB/users/u1/apiKeys' });
+      if (!ok(keysA) || !ok(keysB)) return false;
+      const ka = ((keysA.body as Body)?.apiKeys ?? []) as Body[];
+      const kb = ((keysB.body as Body)?.apiKeys ?? []) as Body[];
+      return ka.length === 1 && kb.length === 1 && ka[0]!.name !== kb[0]!.name;
+    }),
+  ),
+  done('fireworks.deployments.delete_empty_object', 'deployments', "Deployments: DELETE answers 200 with an EMPTY object (the vendor's own delete shape) and the row is really gone", 'api', 'core', () =>
+    withRoot(async (h) => {
+      if (!(await seedDeployment(h))) return false;
+      const r = await h({ m: 'DELETE', p: `${ACCOUNT}/deployments/my-deployment` });
+      if (!ok(r) || JSON.stringify(r.body) !== '{}') return false;
+      const after = await h({ m: 'GET', p: `${ACCOUNT}/deployments/my-deployment` });
+      return after.status === 404;
+    }),
+  ),
+  done('fireworks.deployments.delete_then_404', 'deployments', 'Deployments: a deleted deployment GETs 404 with the gateway error shape {code, message}', 'api', 'core', () =>
+    withRoot(async (h) => {
+      if (!(await seedDeployment(h))) return false;
+      await h({ m: 'DELETE', p: `${ACCOUNT}/deployments/my-deployment` });
+      const r = await h({ m: 'GET', p: `${ACCOUNT}/deployments/my-deployment` });
+      if (r.status !== 404) return false;
+      const b = r.body as Body;
+      return b.code === 'NOT_FOUND' && typeof b.message === 'string';
+    }),
+  ),
+  done('fireworks.deployments.patch_readonly_fields_ignored', 'deployments', 'Deployments: PATCH updates mutable fields; vendor-set fields (state/status/createTime/name) are NOT client-writable — refused with the grpc-gateway unknown-field 400', 'api', 'common', () =>
+    withRoot(async (h) => {
+      if (!(await seedDeployment(h))) return false;
+      const r = await h({ m: 'PATCH', p: `${ACCOUNT}/deployments/my-deployment`, b: { displayName: 'renamed', state: 'READY' } });
+      if (r.status !== 400 || !String((r.body as Body)?.message ?? '').includes('"state"')) return false;
+      // The mutable field alone still patches through.
+      const good = await h({ m: 'PATCH', p: `${ACCOUNT}/deployments/my-deployment`, b: { displayName: 'renamed' } });
+      const b = good.body as Body;
+      return ok(good) && b.displayName === 'renamed' && b.state === 'CREATING'; // state is vendor-set
+    }),
+  ),
+  // The PATCH whitelist (the create path's own field discipline, extended to updates): an
+  // UNDECLARED field is refused the way grpc-gateway refuses an unknown field, and an
+  // output-only field never passes (googleads-twin.ts is the estate precedent).
+  done('fireworks.control.patch_unknown_field_refused', 'control', 'PATCH: an undeclared OR output-only field is refused 400 (grpc-gateway FIELD_NOT_FOUND semantics) on every patchable collection — arbitrary fields are never stored, vendor-set fields never pass, and the policy is one and the same across collections', 'api', 'common', () =>
+    withRoot(async (h) => {
+      if (!ok(await h({ m: 'POST', p: `${ACCOUNT}/deployments?deploymentId=p1`, b: { baseModel: 'accounts/fireworks/models/llama-v3p1-8b-instruct' } }))) return false;
+      if (!ok(await h({ m: 'POST', p: `${ACCOUNT}/users?userId=p1`, b: { role: 'user' } }))) return false;
+      if (!ok(await h({ m: 'POST', p: `${ACCOUNT}/models?modelId=p1`, b: { displayName: 'm' } }))) return false;
+      const dep = await h({ m: 'PATCH', p: `${ACCOUNT}/deployments/p1`, b: { notAField: 'x' } });
+      if (dep.status !== 400 || !String((dep.body as Body)?.message ?? '').includes('notAField')) return false;
+      // An output-only field is REFUSED like an invented one (grpc-gateway's own policy for a
+      // client-set readOnly field, uniform across every collection — the patch_readonly verify
+      // pins the deployment case).
+      const outputOnly = await h({ m: 'PATCH', p: `${ACCOUNT}/deployments/p1`, b: { createTime: '2020-01-01T00:00:00Z' } });
+      if (outputOnly.status !== 400 || !String((outputOnly.body as Body)?.message ?? '').includes('"createTime"')) return false;
+      const user = await h({ m: 'PATCH', p: `${ACCOUNT}/users/p1`, b: { bogus: 1 } });
+      if (user.status !== 400) return false;
+      const model = await h({ m: 'PATCH', p: `${ACCOUNT}/models/p1`, b: { bogus: 1 } });
+      if (model.status !== 400) return false;
+      // A declared mutable field still patches through.
+      const good = await h({ m: 'PATCH', p: `${ACCOUNT}/deployments/p1`, b: { displayName: 'kept' } });
+      return ok(good) && (good.body as Body)?.displayName === 'kept';
+    }),
+  ),
+  done('fireworks.deployments.undelete', 'deployments', 'Deployments: the :undelete custom verb restores a deleted deployment (the restored row carries its name again)', 'api', 'niche', () =>
+    withRoot(async (h) => {
+      if (!(await seedDeployment(h))) return false;
+      await h({ m: 'DELETE', p: `${ACCOUNT}/deployments/my-deployment` });
+      const r = await h({ m: 'POST', p: `${ACCOUNT}/deployments/my-deployment:undelete` });
+      if (!ok(r)) return false;
+      const after = await h({ m: 'GET', p: `${ACCOUNT}/deployments/my-deployment` });
+      return ok(after) && (after.body as Body)?.name === 'accounts/my-account/deployments/my-deployment';
+    }),
+  ),
+  done('fireworks.deployments.scale_spec_spelling', 'deployments', 'Deployments: :scale is the spec PATCH …/{deployment_id}:scale with {replicaCount} answering {} (Gateway_ScaleDeployment); a scale without replicaCount is refused', 'api', 'common', () =>
+    withRoot(async (h) => {
+      if (!(await seedDeployment(h))) return false;
+      const missing = await h({ m: 'PATCH', p: `${ACCOUNT}/deployments/my-deployment:scale`, b: {} });
+      if (missing.status !== 400) return false;
+      const r = await h({ m: 'PATCH', p: `${ACCOUNT}/deployments/my-deployment:scale`, b: { replicaCount: 3 } });
+      if (!ok(r) || JSON.stringify(r.body) !== '{}') return false;
+      const after = await h({ m: 'GET', p: `${ACCOUNT}/deployments/my-deployment` });
+      return ok(after) && (after.body as Body)?.replicaCount === 3;
+    }),
+  ),
+  done('fireworks.deployments.duplicate_create_409', 'deployments', 'Deployments: creating an existing id answers 409 ALREADY_EXISTS (the gateway code)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      if (!(await seedDeployment(h))) return false;
+      const r = await h({ m: 'POST', p: `${ACCOUNT}/deployments?deploymentId=my-deployment`, b: { baseModel: 'accounts/fireworks/models/llama-v3p1-8b-instruct' } });
+      return r.status === 409 && (r.body as Body)?.code === 'ALREADY_EXISTS';
+    }),
+  ),
+  done('fireworks.deployments.base_model_required', 'deployments', 'Deployments: a create without baseModel is refused (the spec marks it required)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: `${ACCOUNT}/deployments?deploymentId=no-base`, b: { displayName: 'nope' } });
+      return r.status === 400;
+    }),
+  ),
+  todo('fireworks.deployments.create_minted_id', 'deployments', 'Deployments: a create WITHOUT a deploymentId mints a vendor-style id (today the twin mints a _twin_ id)', 'api', 'common'),
+  todo('fireworks.deployments.filter_orderby', 'deployments', 'Deployments: list filter/orderBy/readMask params', 'api', 'niche'),
+  todo('fireworks.deployments.show_deleted', 'deployments', 'Deployments: list showDeleted=true includes DELETED rows', 'api', 'niche'),
+
+  // ── CONTROL PLANE: datasets, jobs, users/apiKeys, secrets, models ──────────────────────
+  done('fireworks.datasets.create_body_id', 'datasets', 'Datasets: create carries datasetId in the BODY (the vendor spec — unlike deployments)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: `${ACCOUNT}/datasets`, b: { dataset: { displayName: 'twin data' }, datasetId: 'my-dataset' } });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      return b.name === 'accounts/my-account/datasets/my-dataset' && b.state === 'UPLOADING';
+    }),
+  ),
+  // The spec marks the id REQUIRED on these two creates (datasets: CreateDatasetRequest.required
+  // = dataset + datasetId; models: GatewayGatewayCreateModelBody.required = modelId) — the vendor
+  // 400s a create without one, so minting one here would fake a success the vendor never answers.
+  done('fireworks.datasets.id_required', 'datasets', 'Datasets: a create without datasetId (or without dataset) is refused 400 — the spec marks them required; the twin never mints one', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const noId = await h({ m: 'POST', p: `${ACCOUNT}/datasets`, b: { dataset: { displayName: 'no id' } } });
+      if (noId.status !== 400) return false;
+      const noBody = await h({ m: 'POST', p: `${ACCOUNT}/datasets`, b: { datasetId: 'only-id' } });
+      return noBody.status === 400;
+    }),
+  ),
+  done('fireworks.models.id_required', 'models', 'Models: a create without modelId is refused 400 (the spec marks it required) — the twin never mints one', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: `${ACCOUNT}/models`, b: { displayName: 'no id' } });
+      return r.status === 400;
+    }),
+  ),
+  done('fireworks.datasets.lifecycle', 'datasets', 'Datasets: create → GET → PATCH (a spec-mutable field lands; a vendor-set one is refused) → list → delete lifecycle', 'api', 'common', () =>
+    withRoot(async (h) => {
+      if (!ok(await h({ m: 'POST', p: `${ACCOUNT}/datasets`, b: { dataset: { displayName: 'lifecycle' }, datasetId: 'ds1' } }))) return false;
+      const got = await h({ m: 'GET', p: `${ACCOUNT}/datasets/ds1` });
+      // Gateway_UpdateDataset's mutable fields: a PATCH of one lands and reads back; the
+      // vendor-set `state` is refused with the grpc-gateway unknown-field 400.
+      const patched = await h({ m: 'PATCH', p: `${ACCOUNT}/datasets/ds1`, b: { displayName: 'renamed-ds', externalUrl: 'gs://bucket/ds.jsonl' } });
+      if (!ok(patched)) return false;
+      const pb = patched.body as Body;
+      if (pb.displayName !== 'renamed-ds' || pb.externalUrl !== 'gs://bucket/ds.jsonl') return false;
+      const readBack = await h({ m: 'GET', p: `${ACCOUNT}/datasets/ds1` });
+      if (!ok(readBack) || (readBack.body as Body)?.displayName !== 'renamed-ds') return false;
+      const refused = await h({ m: 'PATCH', p: `${ACCOUNT}/datasets/ds1`, b: { state: 'READY' } });
+      if (refused.status !== 400 || !String((refused.body as Body)?.message ?? '').includes('"state"')) return false;
+      const list = await h({ m: 'GET', p: `${ACCOUNT}/datasets` });
+      const del = await h({ m: 'DELETE', p: `${ACCOUNT}/datasets/ds1` });
+      const gone = await h({ m: 'GET', p: `${ACCOUNT}/datasets/ds1` });
+      return ok(got) && ok(list) && ok(del) && gone.status === 404;
+    }),
+  ),
+  // The spec gives the job collections delete+get ONLY (no update op) — a PATCH there is the
+  // vendor's route-not-found 404, never a served no-op.
+  done('fireworks.batch_jobs.patch_refused', 'batch_inference', 'Batch/SFT jobs: PATCH on a job answers 404 (the spec gives those collections delete+get only — no update route)', 'api', 'niche', () =>
+    withRoot(async (h) => {
+      if (!ok(await h({ m: 'POST', p: `${ACCOUNT}/datasets`, b: { dataset: { displayName: 'ds' }, datasetId: 'ds1' } }))) return false;
+      if (!ok(await h({ m: 'POST', p: `${ACCOUNT}/batchInferenceJobs?batchInferenceJobId=job1`, b: { model: MODEL, inputDatasetId: 'ds1' } }))) return false;
+      if (!ok(await h({ m: 'POST', p: `${ACCOUNT}/supervisedFineTuningJobs?supervisedFineTuningJobId=sft1`, b: { dataset: 'accounts/my-account/datasets/ds1', baseModel: MODEL } }))) return false;
+      const batch = await h({ m: 'PATCH', p: `${ACCOUNT}/batchInferenceJobs/job1`, b: { displayName: 'x' } });
+      const sft = await h({ m: 'PATCH', p: `${ACCOUNT}/supervisedFineTuningJobs/sft1`, b: { displayName: 'x' } });
+      return batch.status === 404 && sft.status === 404;
+    }),
+  ),
+  done('fireworks.batch_jobs.create_and_cancel', 'batch_inference', 'Batch inference jobs: create (body IS the job; id as query param; the input dataset must really exist) and the :cancel verb answers {}', 'api', 'common', () =>
+    withRoot(async (h) => {
+      if (!ok(await h({ m: 'POST', p: `${ACCOUNT}/datasets`, b: { dataset: { displayName: 'ds' }, datasetId: 'ds1' } }))) return false;
+      const c = await h({ m: 'POST', p: `${ACCOUNT}/batchInferenceJobs?batchInferenceJobId=job1`, b: { displayName: 'batch', model: MODEL, inputDatasetId: 'ds1' } });
+      if (!ok(c)) return false;
+      const cancel = await h({ m: 'POST', p: `${ACCOUNT}/batchInferenceJobs/job1:cancel` });
+      if (!ok(cancel) || JSON.stringify(cancel.body) !== '{}') return false;
+      const after = await h({ m: 'GET', p: `${ACCOUNT}/batchInferenceJobs/job1` });
+      return ok(after) && (after.body as Body)?.state === 'JOB_STATE_CANCELLING';
+    }),
+  ),
+  done('fireworks.batch_jobs.cancel_wrong_state_refused', 'batch_inference', 'Batch inference jobs: cancelling an already-CANCELLING job is refused (400)', 'api', 'niche', () =>
+    withRoot(async (h) => {
+      await h({ m: 'POST', p: `${ACCOUNT}/datasets`, b: { dataset: { displayName: 'ds' }, datasetId: 'ds1' } });
+      await h({ m: 'POST', p: `${ACCOUNT}/batchInferenceJobs?batchInferenceJobId=job2`, b: { model: MODEL, inputDatasetId: 'ds1' } });
+      await h({ m: 'POST', p: `${ACCOUNT}/batchInferenceJobs/job2:cancel` });
+      const again = await h({ m: 'POST', p: `${ACCOUNT}/batchInferenceJobs/job2:cancel` });
+      return again.status === 400;
+    }),
+  ),
+  todo('fireworks.batch_jobs.resume', 'batch_inference', 'Batch inference jobs: the :resume verb is served (answers {}) but the PAUSED-state precondition is not modeled — the vendor refuses resume on a job that was never paused', 'api', 'niche'),
+  done('fireworks.sft.create_required_dataset', 'fine_tuning', 'Supervised fine-tuning: create REQUIRES a dataset that really exists (the spec marks it required; the id rides the query param the connector sends)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      if (!ok(await h({ m: 'POST', p: `${ACCOUNT}/datasets`, b: { dataset: { displayName: 'ds' }, datasetId: 'ds1' } }))) return false;
+      const missing = await h({ m: 'POST', p: `${ACCOUNT}/supervisedFineTuningJobs`, b: { displayName: 'nope' } });
+      if (missing.status !== 400) return false;
+      // A dataset field naming a dataset that never landed is refused too — presence of the
+      // field is not existence of the row.
+      const ghost = await h({ m: 'POST', p: `${ACCOUNT}/supervisedFineTuningJobs?supervisedFineTuningJobId=ghost`, b: { dataset: 'accounts/my-account/datasets/no-such-ds', baseModel: MODEL } });
+      if (ghost.status !== 400) return false;
+      const good = await h({ m: 'POST', p: `${ACCOUNT}/supervisedFineTuningJobs?supervisedFineTuningJobId=with-ds`, b: { dataset: 'accounts/my-account/datasets/ds1', baseModel: MODEL } });
+      return ok(good) && (good.body as Body)?.state === 'JOB_STATE_CREATING' && (good.body as Body)?.name === 'accounts/my-account/supervisedFineTuningJobs/with-ds';
+    }),
+  ),
+  done('fireworks.users.roles_validated', 'users', 'Users: create validates role against the closed enum (admin/user/contributor/inference-user/custom)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const good = await h({ m: 'POST', p: `${ACCOUNT}/users?userId=u1`, b: { role: 'admin', displayName: 'Admin' } });
+      if (!ok(good) || (good.body as Body)?.role !== 'admin') return false;
+      const bad = await h({ m: 'POST', p: `${ACCOUNT}/users?userId=u2`, b: { role: 'superadmin' } });
+      return bad.status === 400;
+    }),
+  ),
+  done('fireworks.apikeys.key_returned_once', 'apiKeys', "API keys: the full key is returned ONCE at creation and never again on read (the vendor's own contract)", 'api', 'common', () =>
+    withRoot(async (h) => {
+      await h({ m: 'POST', p: `${ACCOUNT}/users?userId=u1`, b: { role: 'user' } });
+      const created = await h({ m: 'POST', p: `${ACCOUNT}/users/u1/apiKeys`, b: { apiKey: { displayName: 'k1' } } });
+      if (!ok(created)) return false;
+      const key = (created.body as Body)?.key;
+      if (typeof key !== 'string' || !key.startsWith('fw_')) return false;
+      const got = await h({ m: 'GET', p: `${ACCOUNT}/users/u1/apiKeys/${(created.body as Body).keyId}` });
+      return ok(got) && (got.body as Body)?.key === undefined && (got.body as Body)?.prefix === key.slice(0, 6);
+    }),
+  ),
+  done('fireworks.apikeys.delete_verb_body_keyid', 'apiKeys', 'API keys: deletion is the verb-suffixed POST apiKeys:delete with a {keyId} body (the vendor oddity) — both the collection-level spelling and the id-segment spelling', 'api', 'common', () =>
+    withRoot(async (h) => {
+      await h({ m: 'POST', p: `${ACCOUNT}/users?userId=u1`, b: { role: 'user' } });
+      const created = await h({ m: 'POST', p: `${ACCOUNT}/users/u1/apiKeys`, b: { apiKey: { displayName: 'k1' } } });
+      const keyId = (created.body as Body)?.keyId as string;
+      // the spec's collection-level spelling (Gateway_DeleteApiKey)
+      const del = await h({ m: 'POST', p: `${ACCOUNT}/users/u1/apiKeys:delete`, b: { keyId } });
+      if (!ok(del) || JSON.stringify(del.body) !== '{}') return false;
+      const got = await h({ m: 'GET', p: `${ACCOUNT}/users/u1/apiKeys/${keyId}` });
+      if (got.status !== 404) return false;
+      // the id-segment spelling routes the same way
+      const created2 = await h({ m: 'POST', p: `${ACCOUNT}/users/u1/apiKeys`, b: { apiKey: { displayName: 'k2' } } });
+      const keyId2 = (created2.body as Body)?.keyId as string;
+      const del2 = await h({ m: 'POST', p: `${ACCOUNT}/users/u1/apiKeys/${keyId2}:delete`, b: { keyId: keyId2 } });
+      if (!ok(del2) || JSON.stringify(del2.body) !== '{}') return false;
+      const got2 = await h({ m: 'GET', p: `${ACCOUNT}/users/u1/apiKeys/${keyId2}` });
+      return got2.status === 404;
+    }),
+  ),
+  done('fireworks.secrets.value_never_on_read', 'secrets', 'Secrets: create stores name+keyName+value; the list/read surface never echoes the value', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const c = await h({ m: 'POST', p: `${ACCOUNT}/secrets`, b: { name: 'my-secret', keyName: 'KEY_ID', value: 's3cr3t' } });
+      if (!ok(c)) return false;
+      const list = await h({ m: 'GET', p: `${ACCOUNT}/secrets` });
+      const rows = (list.body as Body)?.secrets as Body[];
+      return ok(list) && rows.length === 1 && rows[0]?.keyName === 'KEY_ID' && rows[0]?.value === undefined;
+    }),
+  ),
+  done('fireworks.secrets.name_keyname_required', 'secrets', 'Secrets: a create without name/keyName is refused', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: `${ACCOUNT}/secrets`, b: { name: 'only-name' } });
+      return r.status === 400;
+    }),
+  ),
+  done('fireworks.models.create_and_list', 'models', 'Models: create (owned, not public) and list under the account', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const c = await h({ m: 'POST', p: `${ACCOUNT}/models?modelId=my-model`, b: { displayName: 'my fine-tune', contextLength: 8192 } });
+      if (!ok(c) || (c.body as Body)?.public !== false) return false;
+      const list = await h({ m: 'GET', p: `${ACCOUNT}/models` });
+      const rows = (list.body as Body)?.models as Body[];
+      return ok(list) && rows.some((m) => m.name === 'accounts/my-account/models/my-model');
+    }),
+  ),
+  // The catalog refusal (fireworks-models.ts): the real vendor answers 404 "Model id not
+  // found" for an id it does not serve — never a silent 200 with a stub completion. The
+  // control plane feeds the catalog: a model CREATED under the account becomes addressable.
+  done('fireworks.models.unknown_id_404', 'models', 'Inference: an unknown model id answers the vendor 404 "Model id not found" (catalog refusal; control-plane-created models are addressable ONLY by their qualified name — the bare suffix is not an alias and never crosses accounts)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const bad = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ model: 'accounts/fireworks/models/never-existed' }) });
+      if (bad.status !== 404 || !(bad.body as Body)?.error?.message?.includes('Model id not found')) return false;
+      const badEmbed = await h({ m: 'POST', p: '/inference/v1/embeddings', b: { model: 'no-such-embedder', input: 'x' } });
+      if (badEmbed.status !== 404) return false;
+      // A control-plane-created model joins the catalog by its FULL resource name only. The
+      // bare suffix is NOT a serving path — a model created under one account must not answer
+      // under its bare id from anywhere (tenancy on the inference plane).
+      const c = await h({ m: 'POST', p: `${ACCOUNT}/models?modelId=my-model`, b: { displayName: 'mine' } });
+      if (!ok(c)) return false;
+      const served = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ model: 'accounts/my-account/models/my-model' }) });
+      if (!ok(served)) return false;
+      const bareChat = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ model: 'my-model' }) });
+      if (bareChat.status !== 404) return false;
+      const bareEmbed = await h({ m: 'POST', p: '/inference/v1/embeddings', b: { model: 'my-model', input: 'x' } });
+      if (bareEmbed.status !== 404) return false;
+      // And another account's path serves nothing of it either.
+      const other = await h({ m: 'POST', p: '/v1/accounts/other-account/models/other-model', b: {} });
+      return other.status === 404;
+    }),
+  ),
+  todo('fireworks.models.catalog_coverage', 'models', 'Models: the static catalog covers the DOCUMENTED serverless ids (chat aliases + full resource names, the Qwen3 embedding/rerank tables, the legacy nomic-ai embedder); ids Fireworks serves but the catalog omits still answer 404 — extend FIREWORKS_MODELS from the live model tables', 'api', 'common'),
+  todo('fireworks.control.get_account', 'control', 'Control plane: GET /v1/accounts/{id} is not served (see fireworks.account.read — the twin answers the vendor 404 for an account id it does not hold)', 'api', 'common'),
+  todo('fireworks.control.quota_resource', 'control', 'Control plane: the quota resource surface', 'api', 'common'),
+
+  // ── Conformance + connector backbone ───────────────────────────────────────────────────
+  done('fireworks.conformance.probes', 'conformance', 'Offline conformance harness passes (one real probe per claimed endpoint + the router census)', 'api', 'core', async () => {
+    const { checkFireworksConformance } = await import('./fireworks-conformance.ts');
+    const report = await checkFireworksConformance();
+    return report.ok && report.probes >= 10 && report.checksRun >= 10;
+  }),
+  done('fireworks.connector.pull_control_plane', 'connector', 'Connector: pull enumerates the seven control-plane collections and folds them (one batch)', 'connector', 'core', () =>
+    withConnectorRoot('fireworks.connector.pull_control_plane', async (root) => {
+      const { execute, calls } = fakeExecute((method, path) => {
+        if (path.includes('/deployments')) return { deployments: [{ name: 'accounts/acc/deployments/dep1', baseModel: 'accounts/fireworks/models/llama-v3p1-8b-instruct', state: 'READY' }], nextPageToken: null, totalSize: 1 };
+        if (path.includes('/users')) return { users: [{ name: 'accounts/acc/users/u1', role: 'admin', state: 'READY' }], nextPageToken: null, totalSize: 1 };
+        return { nextPageToken: null, totalSize: 0 };
+      });
+      const result = await syncFireworksFromReal(execute, { accountId: 'acc', root, occurredAt: '2026-09-16T00:00:00.000Z' });
+      const rows = projectResources('fireworks', root);
+      // Pulled rows carry the ACCOUNT-NAMESPACED kernel id (the same space the create path
+      // writes), so a pulled row and a created row of one vendor resource are one subject.
+      return result.observed === 2 && calls.length === 7 && rows.some((r) => r.type === 'deployment' && r.id === 'acc/dep1' && r.state === 'READY') && rows.some((r) => r.type === 'user' && r.id === 'acc/u1');
+    }),
+  ),
+  done('fireworks.connector.pull_refused_throws', 'connector', 'Connector: a REFUSED pull throws (a failed pull is never folded as an empty account)', 'connector', 'core', () =>
+    withConnectorRoot('fireworks.connector.pull_refused_throws', async (root) => {
+      const execute: FireworksExecute = async () => ({ status: 401, data: { code: 'UNAUTHENTICATED', message: 'nope' } });
+      try { await pullFireworksState(execute, 'acc'); return false; } catch (e) {
+        return e instanceof Error && e.message.includes('401');
+      }
+    }),
+  ),
+  // HOLLOW BY METHOD (capability-mutation-sweep): the zero-delta dedup this verify asserts is the
+  // KERNEL's shadow-diff (world-core observeResources re-pulls appends nothing), not any line of
+  // this pack — there is no guard or property in twin/connector/stub whose neuter makes a second
+  // identical pull append a delta. The behavior is the absence of pack code on that path.
+  done('fireworks.connector.pull_idempotent', 'connector', 'Connector: a re-pull of identical state appends ZERO deltas (shadow-diff dedup)', 'connector', 'core', () =>
+    withConnectorRoot('fireworks.connector.pull_idempotent', async (root) => {
+      const reply = () => ({ deployments: [{ name: 'accounts/acc/deployments/dep1', baseModel: 'm', state: 'READY' }], nextPageToken: null, totalSize: 1 });
+      const { execute } = fakeExecute(reply);
+      const first = await syncFireworksFromReal(execute, { accountId: 'acc', root, occurredAt: '2026-09-16T00:00:00.000Z' });
+      const second = await syncFireworksFromReal(execute, { accountId: 'acc', root, occurredAt: '2026-09-16T00:01:00.000Z' });
+      return first.deltasAppended === 1 && second.deltasAppended === 0 && second.observed === 1;
+    }),
+  ),
+  done('fireworks.connector.push_create_query_params', 'connector', 'Connector: a deployment create push sends the id as a QUERY param (the vendor spec) and records _external_id at confirm', 'connector', 'core', () =>
+    withConnectorRoot('fireworks.connector.push_create_query_params', async (root) => {
+      const { execute, calls, bodies } = fakeExecute(() => ({ name: 'accounts/acc/deployments/dep1' }));
+      await import('@volter/world-core').then((core) => core.applyTwinWrite('fireworks', {
+        operation: 'deployment.create', subjectType: 'deployment', subjectId: 'dep1',
+        fields: { baseModel: 'accounts/fireworks/models/llama-v3p1-8b-instruct', displayName: 'pushed' },
+        actor: { kind: 'agent' },
+      }, root));
+      const result = await pushPendingFireworksActions(execute, { accountId: 'acc', root, occurredAt: '2026-09-16T00:00:00.000Z' });
+      return result.pushed === 1 && calls[0] === 'POST /v1/accounts/acc/deployments?deploymentId=dep1'
+        && (bodies[0] as Body)?.baseModel === 'accounts/fireworks/models/llama-v3p1-8b-instruct'
+        && result.externalIds[result.confirmed[0]!] === 'dep1';
+    }),
+  ),
+  done('fireworks.connector.push_delete_uses_external_id', 'connector', "Connector: a delete push addresses the vendor by the recorded _external_id — never the twin's own mint", 'connector', 'core', () =>
+    withConnectorRoot('fireworks.connector.push_delete_uses_external_id', async (root) => {
+      const core = await import('@volter/world-core');
+      // A locally-minted subject with NO recorded external id is refused, never guessed.
+      await core.applyTwinWrite('fireworks', { operation: 'deployment.create', subjectType: 'deployment', subjectId: 'dep_twin_1', fields: { baseModel: 'm' }, actor: { kind: 'agent' } }, root);
+      await core.applyTwinWrite('fireworks', { operation: 'deployment.delete', subjectType: 'deployment', subjectId: 'dep_twin_1', fields: {}, actor: { kind: 'agent' } }, root);
+      const { execute, calls } = fakeExecute(() => ({}));
+      const result = await pushPendingFireworksActions(execute, { accountId: 'acc', root, occurredAt: '2026-09-16T00:00:00.000Z' });
+      // BOTH actions stay pending: the create (a vendor response naming no resource can't be
+      // confirmed faithfully) and the delete (no vendor id recorded). The delete's refusal names
+      // the never-pushed cause; the create's names the unconfirmable response. The DELETE itself
+      // must never reach the wire — a create POST may be attempted, but nothing addresses the
+      // vendor by the twin's own mint for destruction.
+      if (result.refused.length !== 2) return false;
+      if (!result.refused.some((r) => r.reason.includes('never pushed'))) return false;
+      if (calls.some((c) => c.startsWith('DELETE'))) return false;
+      // NOW record an external id on a LOCALLY-MINTED subject and confirm the create; the delete
+      // must address THAT id, not the mint.
+      const create = await core.applyTwinWrite('fireworks', { operation: 'deployment.create', subjectType: 'deployment', subjectId: 'dep_twin_2', fields: { baseModel: 'm' }, actor: { kind: 'agent' } }, root);
+      await core.confirmAction({ service: 'fireworks', actionId: create.result.actionId, subject: { type: 'deployment', id: 'dep_twin_2' }, fields: { baseModel: 'm', _external_id: 'dep_REAL' }, occurredAt: '2026-09-16T00:00:00.000Z', root });
+      await core.applyTwinWrite('fireworks', { operation: 'deployment.delete', subjectType: 'deployment', subjectId: 'dep_twin_2', fields: {}, actor: { kind: 'agent' } }, root);
+      const result2 = await pushPendingFireworksActions(execute, { accountId: 'acc', root, occurredAt: '2026-09-16T00:01:00.000Z' });
+      return result2.pushed === 1 && calls.at(-1) === 'DELETE /v1/accounts/acc/deployments/dep_REAL';
+    }),
+  ),
+  done('fireworks.connector.inference_ops_not_pushed', 'connector', 'Connector: inference operations are refused by NAME (replaying a completion would spend real money and store nothing)', 'connector', 'core', () =>
+    withConnectorRoot('fireworks.connector.inference_ops_not_pushed', async (root) => {
+      const why = unpushableReason('response.create');
+      if (!why || !why.includes('spend real money')) return false;
+      // And the push sweep reports it rather than throwing.
+      const core = await import('@volter/world-core');
+      await core.applyTwinWrite('fireworks', { operation: 'response.create', subjectType: 'response', subjectId: 'resp1', fields: { model: MODEL }, actor: { kind: 'agent' } }, root);
+      const { execute, calls } = fakeExecute(() => ({}));
+      const result = await pushPendingFireworksActions(execute, { accountId: 'acc', root, occurredAt: '2026-09-16T00:00:00.000Z' });
+      return result.pushed === 0 && result.refused.length === 1 && calls.length === 0;
+    }),
+  ),
+  done('fireworks.connector.request_for_action_shapes', 'connector', 'Connector: fireworksRequestForAction maps each collection to its spec-shaped request (job/dep/user body DIRECT, dataset wrapped with datasetId)', 'connector', 'common', () =>
+    withConnectorRoot('fireworks.connector.request_for_action_shapes', async () => {
+      const dep = fireworksRequestForAction({ operation: 'deployment.create', subject: { type: 'deployment', id: 'd1' }, fields: { baseModel: 'm' } }, 'acc');
+      const ds = fireworksRequestForAction({ operation: 'dataset.create', subject: { type: 'dataset', id: 'ds1' }, fields: { displayName: 'x' } }, 'acc');
+      const job = fireworksRequestForAction({ operation: 'batchInferenceJob.create', subject: { type: 'batchInferenceJob', id: 'j1' }, fields: { model: 'm' } }, 'acc');
+      const user = fireworksRequestForAction({ operation: 'user.create', subject: { type: 'user', id: 'u1' }, fields: { role: 'admin' } }, 'acc');
+      const del = fireworksRequestForAction({ operation: 'deployment.delete', subject: { type: 'deployment', id: 'd1' }, fields: {} }, 'acc');
+      return dep.path === '/v1/accounts/acc/deployments?deploymentId=d1' && (dep.body as Body)?.baseModel === 'm'
+        && ds.path === '/v1/accounts/acc/datasets' && (ds.body as Body)?.datasetId === 'ds1'
+        && job.path === '/v1/accounts/acc/batchInferenceJobs?batchInferenceJobId=j1' && (job.body as Body)?.model === 'm'
+        && user.path === '/v1/accounts/acc/users?userId=u1' && (user.body as Body)?.role === 'admin'
+        && del.method === 'DELETE' && del.path === '/v1/accounts/acc/deployments/d1';
+    }),
+  ),
+  done('fireworks.connector.full_sync', 'connector', 'Connector: fullSync pushes pending writes then pulls (the round trip), reporting both sides', 'connector', 'common', () =>
+    withConnectorRoot('fireworks.connector.full_sync', async (root) => {
+      const core = await import('@volter/world-core');
+      await core.applyTwinWrite('fireworks', { operation: 'deployment.create', subjectType: 'deployment', subjectId: 'depX', fields: { baseModel: 'm' }, actor: { kind: 'agent' } }, root);
+      const { execute } = fakeExecute((method, path) => {
+        if (method === 'POST' && path.includes('/deployments')) return { name: 'accounts/acc/deployments/depX' }; // a create names its resource
+        if (method === 'GET' && path.includes('/deployments')) return { deployments: [{ name: 'accounts/acc/deployments/depX', baseModel: 'm', state: 'READY' }], nextPageToken: null, totalSize: 1 };
+        return { nextPageToken: null, totalSize: 0 };
+      });
+      const result = await fullSyncFireworks(execute, { accountId: 'acc', root, occurredAt: '2026-09-16T00:00:00.000Z' });
+      return result.pushed === 1 && result.observed === 1 && result.collections === 7;
+    }),
+  ),
+  done('fireworks.connector.pull_tombstones_vanished', 'connector', 'Connector: a pull paginated to exhaustion tombstones a subject the vendor OBSERVED once but no longer lists — and completeness is PER ACCOUNT: pulling account B never tombstones account A\'s rows (both accounts\' rows stay live after each pull)', 'connector', 'common', () =>
+    withConnectorRoot('fireworks.connector.pull_tombstones_vanished', async (root) => {
+      const core = await import('@volter/world-core');
+      // Pull one: account A lists two deployments; account B lists one. Both accounts' rows land.
+      const listingA = { deployments: [{ name: 'accounts/accA/deployments/dep1', baseModel: 'm', state: 'READY' }, { name: 'accounts/accA/deployments/gone', baseModel: 'm', state: 'READY' }], nextPageToken: null, totalSize: 2 };
+      const listingB = { deployments: [{ name: 'accounts/accB/deployments/other', baseModel: 'm', state: 'READY' }], nextPageToken: null, totalSize: 1 };
+      const { execute: first } = fakeExecute((method, path) => {
+        if (path.includes('/accounts/accA/')) return listingA;
+        if (path.includes('/accounts/accB/')) return listingB;
+        return { nextPageToken: null, totalSize: 0 };
+      });
+      await syncFireworksFromReal(first, { accountId: 'accA', root, occurredAt: '2026-09-16T00:00:00.000Z' });
+      await syncFireworksFromReal(first, { accountId: 'accB', root, occurredAt: '2026-09-16T00:00:30.000Z' });
+      const rowsAfterBoth = core.projectResources('fireworks', root);
+      const dep1 = rowsAfterBoth.find((r) => r.type === 'deployment' && r.id === 'accA/dep1');
+      const other = rowsAfterBoth.find((r) => r.type === 'deployment' && r.id === 'accB/other');
+      if (dep1?.deleted === true || other?.deleted === true) return false; // a cross-account tombstone is the defect
+      // Pull two: account A no longer lists `gone`. Only THAT A-row tombstones; B's row and
+      // A's kept row stay live.
+      const { execute: second } = fakeExecute((method, path) => {
+        if (path.includes('/accounts/accA/')) return { deployments: [listingA.deployments[0]], nextPageToken: null, totalSize: 1 };
+        return { nextPageToken: null, totalSize: 0 };
+      });
+      await syncFireworksFromReal(second, { accountId: 'accA', root, occurredAt: '2026-09-16T00:01:00.000Z' });
+      const rows = core.projectResources('fireworks', root);
+      const gone = rows.find((r) => r.type === 'deployment' && r.id === 'accA/gone');
+      const kept = rows.find((r) => r.type === 'deployment' && r.id === 'accA/dep1');
+      const bStill = rows.find((r) => r.type === 'deployment' && r.id === 'accB/other');
+      // A row the pull tombstoned must be GONE from the serve path, and a pulled row must wear the
+      // vendor's own field names — the serve path read `_deleted` only and the mappers stored
+      // `vendor_name`/`status_code`, so a deleted resource answered 200 with `deleted:true` on the
+      // wire and every client reading `.name` got undefined (round-four review).
+      const listAfter = await handleFireworksTwinRequest({ method: 'GET', path: '/v1/accounts/accA/deployments', headers: { authorization: 'Bearer k' }, root });
+      const servedRows = ((listAfter.body as Body)?.deployments ?? []) as Array<Record<string, unknown>>;
+      // The kept row is served and the tombstoned one is NOT — an empty list would pass the shape
+      // checks below vacuously, so assert the membership first.
+      if (servedRows.length !== 1) return false;
+      if (servedRows[0]?.name !== 'accounts/accA/deployments/dep1') return false;
+      const goneGet = await handleFireworksTwinRequest({ method: 'GET', path: '/v1/accounts/accA/deployments/gone', headers: { authorization: 'Bearer k' }, root });
+      if (goneGet.status !== 404) return false;
+      if (servedRows.some((r) => 'deleted' in r || 'vendor_name' in r || 'status_code' in r)) return false;
+      if (!servedRows.every((r) => typeof r.name === 'string')) return false;
+      return gone?.deleted === true && kept != null && kept.deleted !== true && bStill != null && bStill.deleted !== true;
+    }),
+  ),
+  done('fireworks.connector.perform_addresses_subject_account', 'connector', 'Connector: performFireworksAction derives the Gateway account from the SUBJECT\'s namespaced id — a subject of another account is performed against THAT account\'s REST path, never the pack default', 'connector', 'common', () =>
+    withConnectorRoot('fireworks.connector.perform_addresses_subject_account', async (root) => {
+      const core = await import('@volter/world-core');
+      const calls: string[] = [];
+      const execute = async (req: { method: string; path: string }) => {
+        calls.push(`${req.method} ${req.path}`);
+        return { status: 200, headers: {}, body: JSON.stringify({ name: `${req.path.includes('/accounts/') ? req.path.split('/accounts/')[1]!.split('/')[0] : 'x'}/deployments/dep1` }) };
+      };
+      // A subject under SECRETACCT: the DELETE must address /v1/accounts/SECRETACCT/…
+      const res = await performFireworksAction(execute, {
+        id: 'a1', service: 'fireworks', op: 'set', occurredAt: '2026-09-16T00:00:00.000Z',
+        operation: 'deployment.delete', subject: { type: 'deployment', id: 'SECRETACCT/dep1' }, fields: {},
+      }, { resolve: () => 'SECRETACCT/dep1', root });
+      if (res.externalId !== 'dep1') return false;
+      if (!calls.some((c) => c === 'DELETE /v1/accounts/SECRETACCT/deployments/dep1')) return false;
+      // A bare subject id (no namespace) falls back to the pack's default account.
+      await performFireworksAction(execute, {
+        id: 'a2', service: 'fireworks', op: 'set', occurredAt: '2026-09-16T00:00:00.000Z',
+        operation: 'deployment.delete', subject: { type: 'deployment', id: 'dep2' }, fields: {},
+      }, { resolve: () => 'dep2', root });
+      return calls.some((c) => c === 'DELETE /v1/accounts/my-account/deployments/dep2');
+    }),
+  ),
+  todo('fireworks.connector.live_budget_guard', 'connector', 'Connector: liveFireworksExecute refuses unmodeled paths and charges the budget before every call — the MECHANISM is implemented and pinned by fireworks-budget.test.ts; what is missing is a manifest verify() proving it (a test the manifest itself cannot see is not coverage)', 'connector', 'core'),
+  todo('fireworks.connector.unpushable_actions_drain', 'connector', 'Connector: a permanently-unpushable action can be acknowledged so `pendingActions` can reach empty again', 'connector', 'niche'),
+  todo('fireworks.connector.pull_serverless_catalog', 'connector', 'Connector: pull the serverless model catalog (a vendor-owned surface, not account state)', 'connector', 'common'),
+];
+
+// TWIN-87 committed area census — Fireworks' top-level API product areas (docs nav / the spec
+// tag families), authored top-down independent of what a manifest entry happens to already exist
+// for. fireworks-capabilities.test.ts's area-census meta-test (assertAreaCensus) fails the gate
+// if a declared area has zero manifest entries and no named exclusion, OR if a manifest entry's
+// `area` drifts outside this list — so a whole missing area can never hide invisibly.
+export const FIREWORKS_AREAS = [
+  'account', 'apiKeys', 'auth', 'batch_inference', 'chat', 'completions', 'conformance', 'control',
+  'connector', 'datasets', 'deployments', 'embeddings', 'errors', 'fine_tuning', 'image_generation',
+  'messages', 'models', 'quota', 'rerank', 'responses', 'secrets', 'serverless', 'streaming', 'users',
+] as const;
+
+export function fireworksCapabilities(): Promise<CapabilityReport> {
+  return checkCapabilities('fireworks', FIREWORKS_CAPABILITIES);
+}