@civitai/blocks-react 0.8.0 → 0.10.0

package/dist/internal/mockHost.js

@@ -6,8 +6,9 @@
  * a block in a cross-origin iframe and answers its `postMessage` protocol:
  * mints a token, runs the lazy-consent round-trip, brokers the orchestrator
  * money path (estimate → submit → poll), opens the native Buzz-purchase and
- * resource-picker modals. Locally — in a `vitest` test OR a starter's dev
- * harness — there is no host, so this plays one.
+ * resource-picker modals, and serves the App-Blocks KV datastore. Locally — in
+ * a `vitest` test OR a starter's dev harness — there is no host, so this plays
+ * one.
  *
  * It is the portable core that the React `<Harness>` (a.k.a. `<MockHostProvider>`
  * in `../testing`) wraps. Every block app used to hand-roll ~250 lines of this;
@@ -22,11 +23,33 @@
  *     `window.location.origin` (the React `<Harness>` is documented for that).
  *  3. Dispatches a configurable `BLOCK_INIT`, then answers the full protocol.
  *
- * NOT a real RS256 JWT, NO real Buzz, NO orchestrator — only the bridge
- * round-trips are exercised. Never import this from production code.
+ * SCENARIOS (Layer 1 of the local-dev DX): the {@link MockHostOptions.generation},
+ * {@link MockHostOptions.buzz}, and {@link MockHostOptions.storage} groups let a
+ * dev simulate REAL costs, slow gens, FAILURES, an insufficient-Buzz balance,
+ * and a working KV store with a quota — entirely synthetically, so the full
+ * money / error / storage UX is exercisable locally without spending a single
+ * Buzz or touching the network. The returned {@link MockHost} exposes
+ * `setScenario()` + a `buzz` handle so a harness UI can flip scenarios
+ * mid-session.
+ *
+ * PURE + SYNTHETIC: NOT a real RS256 JWT, NO real Buzz, NO orchestrator, and
+ * — asserted by the test suite — NO network (`fetch`/`XMLHttpRequest` are never
+ * called). Only the postMessage bridge round-trips are exercised. Never import
+ * this from production code.
  */
+import { BrowsingLevel, SFW_LEVELS, } from '@civitai/app-sdk/blocks';
+/** The full all-levels ceiling a `red` domain projects (mirrors the server). */
+const ALL_LEVELS = BrowsingLevel.PG |
+    BrowsingLevel.PG13 |
+    BrowsingLevel.R |
+    BrowsingLevel.X |
+    BrowsingLevel.XXX;
 const DEV_TOKEN = 'dev.mockhost.mock.jwt.NOT.A.REAL.RS256';
 const BUDGETED_SCOPE = 'ai:write:budgeted';
+/** v0 host storage ceilings (mirror civitai/civitai's APP_STORAGE limits). */
+const DEFAULT_STORAGE_QUOTA_BYTES = 50 * 1024 * 1024; // 50 MB per app
+const DEFAULT_STORAGE_VALUE_CAP_BYTES = 64 * 1024; // 64 KB per value
+const DEFAULT_STORAGE_LIMIT_ROWS = 1_000_000;
 const DEFAULT_CHECKPOINT_PICK = {
     versionId: 691639,
     modelId: 618692,
@@ -44,9 +67,24 @@ const DEFAULT_LORA_PICK = {
     modelType: 'LORA',
 };
 const DEFAULT_VIEWER = { id: 2, username: 'dev-viewer', status: 'active' };
+const INSUFFICIENT_BUZZ_ERROR = 'Insufficient Buzz to run this generation.';
+const GENERIC_GEN_ERROR = 'Generation failed (simulated).';
+/** Byte size of a JSON value as the mock store would persist it. */
+function jsonByteSize(value) {
+    try {
+        return new TextEncoder().encode(JSON.stringify(value ?? null)).length;
+    }
+    catch {
+        return 0;
+    }
+}
 /**
  * Reads the URL query toggles the gen-matrix dev harness uses, so a starter's
  * dev harness keeps working with `?viewer/?consent/?fail/?theme/?pick/?pickCkpt`.
+ * Layer-1 additions: `?balance/?latency/?costPerGen/?failNext/?failRate/?seed`
+ * map onto the new scenario groups so a dev can flip insufficient-buzz /
+ * failures / latency without editing code.
+ *
  * Returns a partial overlay applied ON TOP of explicit {@link MockHostOptions}
  * (URL wins — it's the interactive dev knob). No-op outside a browser.
  */
@@ -68,6 +106,14 @@ export function readMockHostUrlOptions(win = globalThis
         out.theme = 'light';
     else if (params.get('theme') === 'dark')
         out.theme = 'dark';
+    // ?domain=green|blue|red projects a color-domain (and its derived ceiling);
+    // ?maturity=sfw|mature sets the ceiling directly.
+    const domain = params.get('domain');
+    if (domain === 'green' || domain === 'blue' || domain === 'red')
+        out.domain = domain;
+    const maturity = params.get('maturity');
+    if (maturity === 'sfw' || maturity === 'mature')
+        out.maturity = maturity;
     // ?pick (LoRA) / ?pickCkpt (Checkpoint): 'cancel' → dismissed; 'pony' → an
     // incompatible Pony LoRA; any other value → the default curated pick.
     const pick = params.get('pick');
@@ -93,6 +139,56 @@ export function readMockHostUrlOptions(win = globalThis
             cannedPicks.Checkpoint = DEFAULT_CHECKPOINT_PICK;
         out.cannedPicks = cannedPicks;
     }
+    // --- Layer-1 scenario toggles ---
+    const generation = {};
+    const buzz = {};
+    const balance = params.get('balance');
+    if (balance !== null && balance.trim() !== '' && Number.isFinite(Number(balance))) {
+        buzz.balance = Number(balance);
+    }
+    if (params.get('insufficient') === '1' || params.get('insufficient') === 'true') {
+        buzz.insufficient = true;
+    }
+    const latency = params.get('latency');
+    if (latency !== null && latency.trim() !== '') {
+        // ?latency=2000 or ?latency=500-2000
+        const range = latency.split('-').map((s) => Number(s.trim()));
+        const lo = range[0] ?? NaN;
+        const hi = range[1] ?? NaN;
+        if (range.length === 2 && Number.isFinite(lo) && Number.isFinite(hi)) {
+            generation.latencyMs = [lo, hi];
+        }
+        else if (Number.isFinite(lo)) {
+            generation.latencyMs = lo;
+        }
+    }
+    const costPerGen = params.get('costPerGen') ?? params.get('cost');
+    if (costPerGen !== null && Number.isFinite(Number(costPerGen))) {
+        generation.costPerGen = Number(costPerGen);
+    }
+    const failNext = params.get('failNext');
+    if (failNext !== null && Number.isInteger(Number(failNext))) {
+        generation.failNext = Number(failNext);
+    }
+    const failRate = params.get('failRate');
+    if (failRate !== null && Number.isFinite(Number(failRate))) {
+        generation.failRate = Number(failRate);
+    }
+    if (Object.keys(generation).length > 0)
+        out.generation = generation;
+    if (Object.keys(buzz).length > 0)
+        out.buzz = buzz;
+    const seed = params.get('seed');
+    if (seed) {
+        try {
+            const parsed = JSON.parse(seed);
+            if (parsed && typeof parsed === 'object')
+                out.storage = { seed: parsed };
+        }
+        catch {
+            /* ignore malformed ?seed= */
+        }
+    }
     return out;
 }
 /**
@@ -102,9 +198,11 @@ export function readMockHostUrlOptions(win = globalThis
  * from a node/jsdom/happy-dom test OR a browser dev harness.
  *
  * @example
- * const host = createMockHost({ failMode: 'some', pollsUntilDone: 1 });
+ * const host = createMockHost({ generation: { failNext: 1, latencyMs: 1500 }, buzz: { balance: 5 } });
  * const uninstall = host.install();
  * // … drive the block / assertions …
+ * host.buzz.setBalance(0);       // flip to insufficient mid-session
+ * host.setScenario({ generation: { failRate: 1 } });
  * uninstall();
  */
 export function createMockHost(options = {}) {
@@ -115,15 +213,62 @@ export function createMockHost(options = {}) {
     // Bind to a non-nullable local so the `install()` closure keeps the narrowing.
     const win = maybeWin;
     const viewer = options.viewer === undefined ? DEFAULT_VIEWER : options.viewer;
-    const failMode = options.failMode ?? 'none';
-    const pollsUntilDone = options.pollsUntilDone ?? 2;
-    const cost = options.cost ?? 8;
     const buzzBudget = options.buzzBudget ?? 200;
     const theme = options.theme ?? 'dark';
-    const cannedPicks = options.cannedPicks ?? { Checkpoint: DEFAULT_CHECKPOINT_PICK, LORA: DEFAULT_LORA_PICK };
     const blockInstanceId = options.blockInstanceId ?? 'page_mock';
     const blockId = options.blockId ?? 'mock-block';
     const appId = options.appId ?? 'app_dev';
+    // ---- LIVE, mutable scenario state (so setScenario / buzz.setBalance work) ----
+    // Legacy + scenario knobs are merged into one mutable record; `setScenario`
+    // rewrites these in place without re-installing.
+    let failMode = options.failMode ?? 'none';
+    let pollsUntilDone = options.pollsUntilDone ?? 2;
+    let gen = { ...(options.generation ?? {}) };
+    let buzz = { ...(options.buzz ?? {}) };
+    // Legacy `cost` feeds costPerGen unless the scenario set its own.
+    let legacyCost = options.cost ?? 8;
+    let cannedPicks = options.cannedPicks ?? { Checkpoint: DEFAULT_CHECKPOINT_PICK, LORA: DEFAULT_LORA_PICK };
+    // ---- Storage scenario (in-memory KV backend) ----
+    const storageScenario = { ...(options.storage ?? {}) };
+    const store = new Map();
+    const seedNow = new Date().toISOString();
+    for (const [k, v] of Object.entries(storageScenario.seed ?? {})) {
+        store.set(k, { value: v, updatedAt: seedNow });
+    }
+    let storageFailNext = storageScenario.failNext ?? 0;
+    const quotaBytes = storageScenario.quotaBytes ?? DEFAULT_STORAGE_QUOTA_BYTES;
+    const valueCapBytes = storageScenario.valueCapBytes ?? DEFAULT_STORAGE_VALUE_CAP_BYTES;
+    const limitRows = storageScenario.limitRows ?? DEFAULT_STORAGE_LIMIT_ROWS;
+    const usedBytes = () => {
+        let total = 0;
+        for (const [k, row] of store)
+            total += jsonByteSize(row.value) + k.length;
+        return total;
+    };
+    // Resolve a per-gen cost from the scenario (or legacy `cost`).
+    const costFor = (body) => {
+        const spec = gen.costPerGen ?? legacyCost;
+        return typeof spec === 'function' ? spec(body) : (spec ?? legacyCost);
+    };
+    const latencyFor = () => {
+        const l = gen.latencyMs;
+        if (l === undefined)
+            return 0;
+        if (Array.isArray(l)) {
+            const [min, max] = l;
+            return Math.round(min + Math.random() * Math.max(0, max - min));
+        }
+        return l;
+    };
+    const imagesFor = (workflowId, body) => {
+        if (gen.images)
+            return typeof gen.images === 'function' ? gen.images(body) : gen.images;
+        if (gen.image)
+            return [typeof gen.image === 'function' ? gen.image(body) : gen.image];
+        return [
+            `https://placehold.co/512x512/1971c2/ffffff/png?text=${encodeURIComponent(workflowId.slice(-4))}`,
+        ];
+    };
     let installed = false;
     let teardown = () => { };
     function install() {
@@ -135,11 +280,19 @@ export function createMockHost(options = {}) {
         let consentGranted = !!options.consentGranted;
         let tokenSerial = 0;
         let submitCount = 0;
+        // body + cost remembered per workflow so the succeeded snapshot can echo them.
         const workflows = new Map();
         const timers = new Set();
         const dispatchToBlock = (data) => {
             win.dispatchEvent(new MessageEvent('message', { data, origin: parentOrigin }));
         };
+        const after = (ms, fn) => {
+            const t = setTimeout(() => {
+                timers.delete(t);
+                fn();
+            }, ms);
+            timers.add(t);
+        };
         const nextToken = () => {
             tokenSerial += 1;
             return {
@@ -149,14 +302,17 @@ export function createMockHost(options = {}) {
                 ...(consentGranted ? { buzzBudget } : {}),
             };
         };
-        const succeededSnapshot = (workflowId) => ({
-            workflowId,
-            status: 'succeeded',
-            cost: { total: cost },
-            imageUrls: [
-                `https://placehold.co/512x512/1971c2/ffffff/png?text=${encodeURIComponent(workflowId.slice(-4))}`,
-            ],
-        });
+        const succeededSnapshot = (workflowId) => {
+            const wf = workflows.get(workflowId);
+            const cost = wf?.cost ?? legacyCost;
+            const body = wf?.body ?? {};
+            return {
+                workflowId,
+                status: 'succeeded',
+                cost: { total: cost },
+                imageUrls: imagesFor(workflowId, body),
+            };
+        };
         const parentMock = {
             postMessage: (msg) => {
                 if (typeof msg !== 'object' ||
@@ -179,30 +335,56 @@ export function createMockHost(options = {}) {
                         // host-initiated TOKEN_REFRESH carrying it (the App's auto-resume
                         // depends on seeing the new scope on its token).
                         consentGranted = true;
-                        const t = setTimeout(() => {
+                        after(0, () => {
                             dispatchToBlock({ type: 'TOKEN_REFRESH', payload: { token: nextToken() } });
-                        }, 0);
-                        timers.add(t);
+                        });
                         return;
                     }
                     case 'REQUEST_SIGN_IN':
                         // The real host opens its login UI; nothing to reply.
                         return;
-                    case 'ESTIMATE_WORKFLOW':
+                    case 'ESTIMATE_WORKFLOW': {
+                        const body = typed.payload?.body ?? {};
                         dispatchToBlock({
                             type: 'ESTIMATE_RESULT',
                             payload: {
                                 requestId,
-                                snapshot: { workflowId: 'wf_estimate', status: 'pending', cost: { total: cost } },
+                                snapshot: {
+                                    workflowId: 'wf_estimate',
+                                    status: 'pending',
+                                    cost: { total: costFor(body) },
+                                },
                             },
                         });
                         return;
+                    }
                     case 'SUBMIT_WORKFLOW': {
                         submitCount += 1;
-                        const failThis = failMode === 'all' ||
+                        const body = typed.payload?.body ?? {};
+                        const cost = costFor(body);
+                        // Insufficient-Buzz path: legacy failMode, the buzz scenario's
+                        // force flag, OR a simulated balance that can't cover this gen.
+                        const balanceSimulated = typeof buzz.balance === 'number';
+                        const insufficient = failMode === 'all' ||
                             failMode === 'insufficient' ||
-                            (failMode === 'some' && submitCount % 3 === 0);
-                        if (failThis) {
+                            buzz.insufficient === true ||
+                            (balanceSimulated && buzz.balance < cost);
+                        // Generic generation failure: failNext countdown, failRate dice, or
+                        // the legacy 'some' (~1 in 3) mode.
+                        let genericFail = false;
+                        if (!insufficient) {
+                            if ((gen.failNext ?? 0) > 0) {
+                                gen.failNext = gen.failNext - 1;
+                                genericFail = true;
+                            }
+                            else if (typeof gen.failRate === 'number' && Math.random() < gen.failRate) {
+                                genericFail = true;
+                            }
+                            else if (failMode === 'some' && submitCount % 3 === 0) {
+                                genericFail = true;
+                            }
+                        }
+                        if (insufficient) {
                             dispatchToBlock({
                                 type: 'WORKFLOW_SUBMITTED',
                                 payload: {
@@ -210,14 +392,31 @@ export function createMockHost(options = {}) {
                                     snapshot: {
                                         workflowId: `wf_fail_${submitCount}`,
                                         status: 'failed',
-                                        error: 'Insufficient Buzz to run this generation.',
+                                        error: INSUFFICIENT_BUZZ_ERROR,
                                     },
                                 },
                             });
                             return;
                         }
+                        if (genericFail) {
+                            dispatchToBlock({
+                                type: 'WORKFLOW_SUBMITTED',
+                                payload: {
+                                    requestId,
+                                    snapshot: {
+                                        workflowId: `wf_fail_${submitCount}`,
+                                        status: 'failed',
+                                        error: GENERIC_GEN_ERROR,
+                                    },
+                                },
+                            });
+                            return;
+                        }
+                        // Success path: debit the simulated balance + remember body/cost.
+                        if (balanceSimulated)
+                            buzz.balance = buzz.balance - cost;
                         const workflowId = `wf_${submitCount}_${Date.now()}`;
-                        workflows.set(workflowId, { polls: 0 });
+                        workflows.set(workflowId, { polls: 0, cost, body });
                         dispatchToBlock({
                             type: 'WORKFLOW_SUBMITTED',
                             payload: { requestId, snapshot: { workflowId, status: 'pending' } },
@@ -230,10 +429,28 @@ export function createMockHost(options = {}) {
                         const polls = (wf?.polls ?? 0) + 1;
                         if (wf)
                             wf.polls = polls;
-                        const snapshot = polls >= pollsUntilDone
-                            ? succeededSnapshot(workflowId)
-                            : { workflowId, status: 'processing' };
-                        dispatchToBlock({ type: 'WORKFLOW_STATUS', payload: { requestId, snapshot } });
+                        if (polls >= pollsUntilDone) {
+                            // Apply synthetic latency on the terminal (succeeded) poll only.
+                            const delay = latencyFor();
+                            if (delay > 0) {
+                                after(delay, () => dispatchToBlock({
+                                    type: 'WORKFLOW_STATUS',
+                                    payload: { requestId, snapshot: succeededSnapshot(workflowId) },
+                                }));
+                            }
+                            else {
+                                dispatchToBlock({
+                                    type: 'WORKFLOW_STATUS',
+                                    payload: { requestId, snapshot: succeededSnapshot(workflowId) },
+                                });
+                            }
+                        }
+                        else {
+                            dispatchToBlock({
+                                type: 'WORKFLOW_STATUS',
+                                payload: { requestId, snapshot: { workflowId, status: 'processing' } },
+                            });
+                        }
                         return;
                     }
                     case 'CANCEL_WORKFLOW': {
@@ -245,12 +462,18 @@ export function createMockHost(options = {}) {
                         });
                         return;
                     }
-                    case 'OPEN_BUZZ_PURCHASE':
+                    case 'OPEN_BUZZ_PURCHASE': {
+                        // Refill the simulated balance so the post-top-up retry succeeds.
+                        const newBalance = typeof buzz.balance === 'number' ? buzz.balance + 1000 : 1000;
+                        if (typeof buzz.balance === 'number')
+                            buzz.balance = newBalance;
+                        buzz.insufficient = false;
                         dispatchToBlock({
                             type: 'BUZZ_PURCHASE_RESULT',
-                            payload: { requestId, purchased: true, newBalance: 1000 },
+                            payload: { requestId, purchased: true, newBalance },
                         });
                         return;
+                    }
                     case 'OPEN_CHECKPOINT_PICKER': {
                         const selected = cannedPicks.Checkpoint;
                         dispatchToBlock({
@@ -281,6 +504,111 @@ export function createMockHost(options = {}) {
                         });
                         return;
                     }
+                    // ---- App Blocks KV datastore (W4) — in-memory backend ----
+                    case 'APP_STORAGE_GET': {
+                        const key = typed.payload?.key ?? '';
+                        const row = store.get(key);
+                        dispatchToBlock({
+                            type: 'APP_STORAGE_GET_RESULT',
+                            payload: { requestId, value: row ? row.value : null },
+                        });
+                        return;
+                    }
+                    case 'APP_STORAGE_SET': {
+                        const key = typed.payload?.key ?? '';
+                        const value = typed.payload?.value;
+                        if (storageFailNext > 0) {
+                            storageFailNext -= 1;
+                            dispatchToBlock({
+                                type: 'APP_STORAGE_SET_RESULT',
+                                payload: { requestId, ok: false, error: 'STORAGE_UNAVAILABLE' },
+                            });
+                            return;
+                        }
+                        const sizeBytes = jsonByteSize(value);
+                        if (sizeBytes > valueCapBytes) {
+                            dispatchToBlock({
+                                type: 'APP_STORAGE_SET_RESULT',
+                                payload: { requestId, ok: false, error: 'PAYLOAD_TOO_LARGE' },
+                            });
+                            return;
+                        }
+                        // Quota check: projected usage after this upsert.
+                        const existing = store.get(key);
+                        const existingBytes = existing ? jsonByteSize(existing.value) + key.length : 0;
+                        const projected = usedBytes() - existingBytes + sizeBytes + key.length;
+                        if (projected > quotaBytes) {
+                            dispatchToBlock({
+                                type: 'APP_STORAGE_SET_RESULT',
+                                payload: { requestId, ok: false, error: 'PAYLOAD_TOO_LARGE' },
+                            });
+                            return;
+                        }
+                        store.set(key, { value, updatedAt: new Date().toISOString() });
+                        dispatchToBlock({
+                            type: 'APP_STORAGE_SET_RESULT',
+                            payload: { requestId, ok: true, sizeBytes },
+                        });
+                        return;
+                    }
+                    case 'APP_STORAGE_DELETE': {
+                        const key = typed.payload?.key ?? '';
+                        if (storageFailNext > 0) {
+                            storageFailNext -= 1;
+                            dispatchToBlock({
+                                type: 'APP_STORAGE_DELETE_RESULT',
+                                payload: { requestId, ok: false, deleted: false, error: 'STORAGE_UNAVAILABLE' },
+                            });
+                            return;
+                        }
+                        const had = store.delete(key);
+                        dispatchToBlock({
+                            type: 'APP_STORAGE_DELETE_RESULT',
+                            payload: { requestId, ok: true, deleted: had },
+                        });
+                        return;
+                    }
+                    case 'APP_STORAGE_LIST': {
+                        const prefix = typed.payload?.prefix ?? '';
+                        const limit = typed.payload?.limit ?? 100;
+                        const cursor = typed.payload?.cursor;
+                        // Cursor = base64 of the last returned key (matches the hook's
+                        // documented `nextCursor` contract).
+                        const afterKey = cursor ? safeAtob(cursor) : undefined;
+                        const allKeys = [...store.entries()]
+                            .filter(([k]) => k.startsWith(prefix))
+                            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+                        const startIdx = afterKey
+                            ? allKeys.findIndex(([k]) => k > afterKey)
+                            : 0;
+                        const slice = (startIdx < 0 ? [] : allKeys.slice(startIdx)).slice(0, limit);
+                        const keys = slice.map(([key, row]) => ({ key, updatedAt: row.updatedAt }));
+                        const last = slice[slice.length - 1]?.[0];
+                        const hasMore = last !== undefined &&
+                            allKeys.findIndex(([k]) => k === last) < allKeys.length - 1;
+                        dispatchToBlock({
+                            type: 'APP_STORAGE_LIST_RESULT',
+                            payload: {
+                                requestId,
+                                keys,
+                                ...(hasMore && last ? { nextCursor: safeBtoa(last) } : {}),
+                            },
+                        });
+                        return;
+                    }
+                    case 'APP_STORAGE_QUOTA': {
+                        dispatchToBlock({
+                            type: 'APP_STORAGE_QUOTA_RESULT',
+                            payload: {
+                                requestId,
+                                usedBytes: usedBytes(),
+                                rowCount: store.size,
+                                limitBytes: quotaBytes,
+                                limitRows,
+                            },
+                        });
+                        return;
+                    }
                     default:
                         return;
                 }
@@ -291,14 +619,24 @@ export function createMockHost(options = {}) {
             configurable: true,
             writable: true,
         });
-        // Merge theme + forward-compat domain/maturity into the init context.
+        // Merge theme into the init context.
         const baseContext = options.context ?? { slotId: 'app.page' };
-        const context = {
-            ...baseContext,
-            theme,
-            ...(options.domain !== undefined ? { domain: options.domain } : {}),
-            ...(options.maturity !== undefined ? { maturity: options.maturity } : {}),
-        };
+        const context = { ...baseContext, theme };
+        // Color-domain maturity (civitai #2670). Resolve the ceiling by precedence:
+        // explicit maxBrowsingLevel > maturity convenience > domain-derived. Only
+        // EMIT a field when the corresponding option was set, so the default mock
+        // host stays a #2670-predating host (the hook fail-closes to SFW).
+        const resolvedCeiling = options.maxBrowsingLevel !== undefined
+            ? options.maxBrowsingLevel
+            : options.maturity === 'sfw'
+                ? SFW_LEVELS
+                : options.maturity === 'mature'
+                    ? ALL_LEVELS
+                    : options.domain !== undefined
+                        ? options.domain === 'red'
+                            ? ALL_LEVELS
+                            : SFW_LEVELS
+                        : undefined;
         const initPayload = {
             blockInstanceId,
             blockId,
@@ -309,9 +647,10 @@ export function createMockHost(options = {}) {
             viewer,
             theme,
             renderMode: 'iframe',
+            ...(options.domain !== undefined ? { domain: options.domain } : {}),
+            ...(resolvedCeiling !== undefined ? { maxBrowsingLevel: resolvedCeiling } : {}),
         };
-        const initTimer = setTimeout(() => dispatchToBlock({ type: 'BLOCK_INIT', payload: initPayload }), 0);
-        timers.add(initTimer);
+        after(0, () => dispatchToBlock({ type: 'BLOCK_INIT', payload: initPayload }));
         let torn = false;
         teardown = () => {
             if (torn)
@@ -329,6 +668,43 @@ export function createMockHost(options = {}) {
         };
         return teardown;
     }
-    return { install };
+    function setScenario(patch) {
+        if (patch.failMode !== undefined)
+            failMode = patch.failMode;
+        if (patch.pollsUntilDone !== undefined)
+            pollsUntilDone = patch.pollsUntilDone;
+        if (patch.cost !== undefined)
+            legacyCost = patch.cost;
+        if (patch.cannedPicks !== undefined)
+            cannedPicks = patch.cannedPicks;
+        if (patch.generation !== undefined)
+            gen = { ...gen, ...patch.generation };
+        if (patch.buzz !== undefined)
+            buzz = { ...buzz, ...patch.buzz };
+        if (patch.storage !== undefined) {
+            // Only the live-tunable storage knob (`failNext`) is applied mid-session;
+            // seed/quota are install-time (re-install to change the backing store).
+            if (patch.storage.failNext !== undefined)
+                storageFailNext = patch.storage.failNext;
+        }
+    }
+    const buzzHandle = {
+        getBalance: () => buzz.balance,
+        setBalance: (n) => {
+            buzz.balance = n;
+        },
+    };
+    return { install, setScenario, buzz: buzzHandle };
+}
+/** btoa/atob that work in both browser + node (happy-dom + vitest). */
+function safeBtoa(s) {
+    if (typeof btoa === 'function')
+        return btoa(s);
+    return Buffer.from(s, 'utf-8').toString('base64');
+}
+function safeAtob(s) {
+    if (typeof atob === 'function')
+        return atob(s);
+    return Buffer.from(s, 'base64').toString('utf-8');
 }
 //# sourceMappingURL=mockHost.js.map