@crowdedkingdoms/crowdyjs 15.12.1-test.1 → 16.0.0-dev.1

package/dist/crowdy-dsh/bridge.js

@@ -0,0 +1,523 @@
+/**
+ * Page half of the Studio ↔ harness bridge.
+ *
+ * Owns the iframe handshake (seed files, persistence scope, boot nonce), the
+ * `BroadcastChannel` the worker's tools call into, and the mapping from those
+ * calls onto the headless `CrowdyStudioController` and the game's
+ * `PlayerHostAdapterV1` (observe only). Everything the model asks for runs
+ * here with the player's own authority, through the same controller methods
+ * the human buttons use; a live deploy additionally waits for the player to
+ * confirm on the page.
+ *
+ * Where the player's app token goes, precisely: the harness worker needs it
+ * to call the metered model endpoint and the GraphQL API as the player. It is
+ * sent over the channel (`page.hello`, `page.token`), held in the worker's
+ * memory as `process.env.CROWDY_APP_TOKEN`, and never written to a seed file,
+ * the virtual filesystem or OPFS. The model has no tool that reads the
+ * environment, and the Crowdy filesystem backend serves only the project
+ * mount, so `read_file` cannot reach it either.
+ *
+ * The iframe is same-origin by design: `BroadcastChannel` and OPFS are both
+ * origin-scoped. A `sandbox` attribute therefore cannot isolate it, and the
+ * Content-Security-Policy the host serves on `/dsh/*` is the control that
+ * matters (see the-construct's `security-headers.mjs`). Moving the harness to
+ * its own origin with a `MessageChannel` relay is tracked as a follow-up.
+ */
+import { CROWDY_DSH_PROTOCOL_VERSION, isDshBridgeFrame, isDshFrameMessage, } from './protocol.js';
+const DEFAULT_MAX_SIDE = 1280;
+const HELLO_DEBOUNCE_MS = 1500;
+export class StudioDshBridge {
+    constructor(options) {
+        this.options = options;
+        /** Unguessable: any same-origin script can open a `BroadcastChannel` by name. */
+        this.channelName = `crowdy-dsh:${randomId()}`;
+        /**
+         * One-time secret carried by every frame on the channel. The iframe boot
+         * message delivers it to the worker; a host that boots the harness itself
+         * (tests, a native shell) reads it here and must pass it along.
+         */
+        this.nonce = randomId();
+        this.channel = null;
+        this.frameListener = null;
+        this.booted = false;
+        this.lastHelloAt = 0;
+        this.lastToken = null;
+        this.unsubscribeState = null;
+        this.tokenTimer = null;
+        this.captureCounter = 0;
+        this.inflight = new Set();
+        this.models = [];
+        this.status = { phase: 'idle' };
+        /** One live-deploy question at a time: a second request must not replace the first prompt. */
+        this.liveDeployPending = false;
+    }
+    get currentStatus() {
+        return this.status;
+    }
+    /** The models the harness was booted with. */
+    get catalog() {
+        return this.models;
+    }
+    /**
+     * Attach to the iframe: answer its `ready` with the boot files and start the
+     * broadcast channel. Resolves once the harness reports it booted.
+     */
+    async attach(frame) {
+        this.detach();
+        this.setStatus({ phase: 'waiting-for-frame' });
+        this.models = await this.options.transport.models(this.options.appId);
+        if (this.models.length === 0) {
+            throw new Error('No model is allowed for this app; ask the app owner to enable the Studio agent.');
+        }
+        this.connect();
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                cleanup();
+                reject(new Error('The agent did not start within 60s.'));
+            }, 60000);
+            const cleanup = () => {
+                clearTimeout(timeout);
+            };
+            this.frameListener = (event) => {
+                if (event.source !== frame.contentWindow)
+                    return;
+                if (event.origin !== location.origin)
+                    return;
+                const data = event.data;
+                if (!isDshFrameMessage(data))
+                    return;
+                if (data.type === 'crowdy-dsh:ready') {
+                    if (this.booted)
+                        return;
+                    this.setStatus({ phase: 'booting' });
+                    frame.contentWindow?.postMessage(this.bootMessage(), location.origin);
+                }
+                else if (data.type === 'crowdy-dsh:booted') {
+                    this.booted = true;
+                    cleanup();
+                    this.setStatus({ phase: 'ready' });
+                    this.hello(true);
+                    resolve();
+                }
+                else if (data.type === 'crowdy-dsh:failed') {
+                    cleanup();
+                    this.setStatus({ phase: 'failed', message: data.message });
+                    reject(new Error(data.message));
+                }
+            };
+            window.addEventListener('message', this.frameListener);
+        });
+    }
+    /**
+     * Join the broadcast channel and start mirroring controller state, without
+     * an iframe handshake. `attach` calls this; a host that boots the harness
+     * itself (tests, a native shell) calls it directly.
+     */
+    connect() {
+        if (this.channel)
+            return;
+        this.openChannel();
+        this.watchController();
+    }
+    detach() {
+        if (this.frameListener)
+            window.removeEventListener('message', this.frameListener);
+        this.frameListener = null;
+        this.unsubscribeState?.();
+        this.unsubscribeState = null;
+        if (this.tokenTimer)
+            clearInterval(this.tokenTimer);
+        this.tokenTimer = null;
+        if (this.channel) {
+            this.emit('page.bye', {});
+            this.channel.close();
+        }
+        this.channel = null;
+        this.booted = false;
+        this.inflight.clear();
+        this.setStatus({ phase: 'idle' });
+    }
+    /** Push a capture the player took from the pane header into `captures/`. */
+    async shareCapture(label) {
+        const shot = await this.screenshot(label);
+        this.emit('page.capture', shot);
+        return shot;
+    }
+    /** Queue text into the agent's current session (e.g. "Fix with AI"). */
+    prompt(text, mode = 'queue') {
+        if (!this.channel) {
+            this.options.onWarning?.('The agent is not running yet; open the Agent pane first.');
+            return;
+        }
+        this.emit('page.prompt', { text, mode });
+    }
+    /** Re-send the token (the page refreshed it). */
+    tokenChanged() {
+        const token = this.options.getToken();
+        if (token && token !== this.lastToken) {
+            this.lastToken = token;
+            this.emit('page.token', { appToken: token });
+        }
+    }
+    // ── boot ────────────────────────────────────────────────────────────────────
+    bootMessage() {
+        const projectId = this.options.controller.getState().project?.projectId ?? '';
+        // No token here: `crowdy.json` lands in the worker's filesystem. The
+        // token follows over the channel once the worker says it is ready.
+        const crowdy = {
+            graphqlUrl: this.options.graphqlUrl,
+            appId: this.options.appId,
+            projectId,
+            bridgeChannel: this.channelName,
+            bridgeNonce: this.nonce,
+            githubFirst: true,
+            root: '/dsh/workspace',
+            persistScope: this.options.persistScope,
+        };
+        return {
+            type: 'crowdy-dsh:boot',
+            files: {
+                'crowdy.json': JSON.stringify(crowdy, null, 2),
+                'settings.yaml': renderSettingsYaml(this.options.transport.modelBaseUrl, this.models),
+            },
+            nonce: this.nonce,
+            persistScope: this.options.persistScope,
+            mount: '/dsh/workspace',
+        };
+    }
+    // ── channel ─────────────────────────────────────────────────────────────────
+    openChannel() {
+        this.channel = new BroadcastChannel(this.channelName);
+        this.channel.addEventListener('message', (event) => {
+            void this.handle(event.data);
+        });
+    }
+    hello(force = false) {
+        const now = Date.now();
+        if (!force && now - this.lastHelloAt < HELLO_DEBOUNCE_MS)
+            return;
+        this.lastHelloAt = now;
+        const token = this.options.getToken();
+        this.emit('page.hello', {
+            appId: this.options.appId,
+            projectId: this.options.controller.getState().project?.projectId ?? null,
+            ...(token ? { appToken: token } : {}),
+        });
+    }
+    emit(event, payload) {
+        if (!this.channel)
+            return;
+        const frame = { v: CROWDY_DSH_PROTOCOL_VERSION, n: this.nonce, from: 'page', t: 'event', event, payload };
+        this.channel.postMessage(frame);
+    }
+    reply(id, result) {
+        const frame = { v: CROWDY_DSH_PROTOCOL_VERSION, n: this.nonce, from: 'page', t: 'res', id, result };
+        this.channel?.postMessage(frame);
+    }
+    fail(id, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const frame = { v: CROWDY_DSH_PROTOCOL_VERSION, n: this.nonce, from: 'page', t: 'err', id, code: 'PAGE_ERROR', message };
+        this.channel?.postMessage(frame);
+    }
+    async handle(data) {
+        // Frames without this boot's nonce are dropped unread: the channel is
+        // reachable by any same-origin script, the nonce only by the worker we booted.
+        if (!isDshBridgeFrame(data, this.nonce) || data.from !== 'worker')
+            return;
+        if (data.t === 'event') {
+            this.onWorkerEvent(data.event, data.payload);
+            return;
+        }
+        if (data.t !== 'req')
+            return;
+        const pending = { id: data.id, method: data.method };
+        this.inflight.add(pending);
+        try {
+            const result = await this.dispatch(data.method, data.params);
+            this.reply(data.id, result);
+        }
+        catch (error) {
+            this.fail(data.id, error);
+        }
+        finally {
+            this.inflight.delete(pending);
+        }
+    }
+    onWorkerEvent(event, payload) {
+        switch (event) {
+            case 'worker.ready': {
+                const ready = payload;
+                this.setStatus({ phase: 'ready', ...(ready.store ? { store: ready.store } : {}) });
+                this.hello();
+                return;
+            }
+            case 'worker.fileChanged': {
+                const change = payload;
+                void this.options.controller.reloadProject().then(() => this.options.onFileChanged?.(change), (error) => this.options.onWarning?.(`The agent changed ${change.path} but the editor could not reload: ${String(error)}`));
+                return;
+            }
+            case 'worker.warning': {
+                this.options.onWarning?.(payload.message);
+                return;
+            }
+            case 'worker.openFile': {
+                const ref = payload;
+                try {
+                    this.options.controller.openFile({ source: 'PROJECT', target: ref.target, path: ref.path });
+                }
+                catch {
+                    // The file may not exist yet; the editor shows what it has.
+                }
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    // ── requests ────────────────────────────────────────────────────────────────
+    async dispatch(method, params) {
+        const controller = this.options.controller;
+        switch (method) {
+            case 'studio.screenshot':
+                return this.screenshot(params?.label);
+            case 'studio.draftTest':
+                return this.build('draft');
+            case 'studio.deployLive': {
+                const confirm = this.options.confirmLiveDeploy;
+                if (!confirm)
+                    throw new Error('Live deploys from the agent are not enabled on this page; use the Deploy button in Crowdy Studio.');
+                // Serialized: two concurrent requests would share one prompt and the
+                // player could answer a question other than the one on screen.
+                if (this.liveDeployPending)
+                    throw new Error('A live deploy is already waiting for the player to answer. Wait for that answer before asking again.');
+                this.liveDeployPending = true;
+                let approved;
+                try {
+                    const projectName = controller.getState().project?.metadata.name ?? 'this project';
+                    approved = await confirm({ projectName });
+                }
+                finally {
+                    this.liveDeployPending = false;
+                }
+                if (!approved)
+                    throw new Error('The player declined the live deploy. Keep working with draft tests.');
+                return this.build('live');
+            }
+            case 'studio.runtimeStatus':
+                return { runtime: this.runtimeStatus(controller.getState()) };
+            case 'studio.runtimeLogs': {
+                const limit = clampLimit(params?.limit, 40);
+                controller.setSurfaceVisible('logs', true);
+                const lines = controller.getState().logs.map(formatRunLine);
+                return { lines: lines.slice(-limit), truncated: lines.length > limit };
+            }
+            case 'studio.clientLogs': {
+                const limit = clampLimit(params?.limit, 80);
+                const lines = [...(this.options.host?.clientLogs?.() ?? [])];
+                return { lines: lines.slice(-limit), truncated: lines.length > limit };
+            }
+            case 'studio.projectList': {
+                const state = controller.getState();
+                return {
+                    projects: state.projects.map(summarize),
+                    currentProjectId: state.project?.projectId ?? null,
+                };
+            }
+            case 'studio.projectOpen': {
+                const { projectId } = params;
+                await controller.switchProject(projectId);
+                const project = controller.getState().project;
+                if (!project)
+                    throw new Error(`Project ${projectId} did not open.`);
+                this.emit('page.project', { projectId: project.projectId });
+                return { project: summarizeProject(project.projectId, project.metadata.name, project.kind, project.revision.savedAt) };
+            }
+            case 'studio.projectCreate': {
+                const { name, template } = params;
+                const kind = template === 'server' ? 'SERVER' : template === 'client' ? 'CLIENT' : 'FULL_STACK';
+                const project = await controller.createProject({ name, kind: kind });
+                this.emit('page.project', { projectId: project.projectId });
+                return { project: summarizeProject(project.projectId, project.metadata.name, project.kind, project.revision.savedAt) };
+            }
+            case 'game.observe': {
+                const host = this.options.host?.playerHost;
+                if (!host)
+                    throw new Error('This game does not expose a player host; nothing to observe.');
+                const observation = await host.observe({ detail: 'STANDARD', maxNearbyActors: 16, maxNearbyVoxels: 64 });
+                this.emit('page.context', { observation });
+                return { observation, capturedAt: new Date().toISOString() };
+            }
+            default:
+                throw new Error(`Unsupported bridge method ${String(method)}`);
+        }
+    }
+    async build(mode) {
+        const controller = this.options.controller;
+        if (!controller.getState().project)
+            throw new Error('No project is open in Crowdy Studio.');
+        const result = mode === 'draft' ? await controller.testDraft() : await controller.deployLive();
+        const state = controller.getState();
+        const diagnostics = [...state.authoritativeDiagnostics, ...state.localDiagnostics].map(toDshDiagnostic);
+        const runtime = this.runtimeStatus(state);
+        const ok = result.status === 'RUNNING';
+        const build = {
+            ok,
+            mode,
+            summary: result.message,
+            diagnostics,
+            buildLog: state.buildOutput.slice(-12000),
+            runtime,
+        };
+        this.emit('page.context', { diagnostics, runtime });
+        if (ok && result.targets.includes('CLIENT') && this.options.host?.captureFrame) {
+            // Let one frame render with the new client module before capturing.
+            await new Promise((resolve) => setTimeout(resolve, 600));
+            try {
+                build.screenshot = await this.screenshot(`after ${mode} ${mode === 'draft' ? 'test' : 'deploy'}`);
+            }
+            catch {
+                // A missing capture is not a failed build.
+            }
+        }
+        return build;
+    }
+    runtimeStatus(state) {
+        const targets = state.project ? [...new Set(state.project.files.map((file) => file.target))] : [];
+        return targets.map((target) => ({
+            target,
+            phase: state.runtime.target === target || state.runtime.target === undefined ? state.runtime.phase : 'IDLE',
+            moduleName: target === 'SERVER' ? state.project?.metadata.serverModuleName : state.project?.metadata.clientModuleName,
+            runningRevision: state.runtimeSync.state === 'RUNNING_SAVED' || state.runtimeSync.state === 'RUNNING_STALE' ? state.runtimeSync.savedRevisionId : undefined,
+            savedRevision: state.project?.revision.id,
+            message: state.runtime.message,
+        }));
+    }
+    async screenshot(label) {
+        const capture = this.options.host?.captureFrame;
+        if (!capture)
+            throw new Error('This game does not provide screenshots to the agent.');
+        const source = await capture();
+        if (!source)
+            throw new Error('Nothing to capture right now (no frame rendered).');
+        const encoded = await encodePng(source, this.options.maxCaptureSide ?? DEFAULT_MAX_SIDE);
+        this.captureCounter += 1;
+        const caption = [label, this.options.host?.describeView?.()].filter(Boolean).join(' — ');
+        return {
+            name: `capture-${String(this.captureCounter).padStart(4, '0')}.png`,
+            mediaType: 'image/png',
+            bytes: encoded.bytes,
+            width: encoded.width,
+            height: encoded.height,
+            ...(caption ? { caption } : {}),
+        };
+    }
+    // ── controller watch ────────────────────────────────────────────────────────
+    watchController() {
+        const controller = this.options.controller;
+        this.lastProjectId = controller.getState().project?.projectId ?? null;
+        this.lastSaveState = controller.getState().saveState;
+        this.unsubscribeState = controller.subscribe((state) => {
+            const projectId = state.project?.projectId ?? null;
+            if (projectId !== this.lastProjectId) {
+                this.lastProjectId = projectId;
+                this.emit('page.project', { projectId });
+            }
+            if (state.saveState === 'SAVED' && this.lastSaveState !== 'SAVED' && this.inflight.size === 0) {
+                this.emit('page.saved', { revision: state.project?.revision.id });
+            }
+            this.lastSaveState = state.saveState;
+        });
+        this.tokenTimer = setInterval(() => this.tokenChanged(), 20000);
+    }
+    setStatus(status) {
+        this.status = status;
+        this.options.onStatus?.(status);
+    }
+}
+// ── helpers ───────────────────────────────────────────────────────────────────
+/** 128 bits from the platform CSPRNG, hex; falls back to `Math.random` only where `crypto` is absent. */
+function randomId() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return c.randomUUID().replace(/-/g, '');
+    if (c?.getRandomValues) {
+        const bytes = c.getRandomValues(new Uint8Array(16));
+        return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+    }
+    return `${Math.random().toString(36).slice(2)}${Math.random().toString(36).slice(2)}`;
+}
+function clampLimit(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.max(1, Math.min(400, Math.floor(value)));
+}
+function formatRunLine(run) {
+    const status = run.success ? 'ok' : 'FAILED';
+    const error = run.errorMessage ? ` — ${run.errorMessage}` : '';
+    return `${run.startedAt} ${run.moduleName} ${run.triggerSource} ${status} ${Math.round(run.durationUs / 1000)}ms fuel=${run.fuelUsed}${error}`;
+}
+function toDshDiagnostic(diagnostic) {
+    return {
+        target: diagnostic.target,
+        path: diagnostic.path,
+        line: diagnostic.line,
+        column: diagnostic.column,
+        severity: diagnostic.severity === 'hint' ? 'info' : diagnostic.severity,
+        message: diagnostic.code ? `${diagnostic.message} [${diagnostic.code}]` : diagnostic.message,
+    };
+}
+function summarize(summary) {
+    return { projectId: summary.projectId, name: summary.name, kind: String(summary.kind), updatedAt: summary.updatedAt };
+}
+function summarizeProject(projectId, name, kind, updatedAt) {
+    return { projectId, name, kind, updatedAt };
+}
+/** Render the harness settings that point its native adapter at the metered endpoint. */
+export function renderSettingsYaml(modelBaseUrl, models) {
+    const quote = (value) => JSON.stringify(value);
+    const lines = [
+        '# Written by Crowdy Studio at boot; the metered model endpoint fronts the platform key.',
+        'llm-deepseek:',
+        '  apiKeyEnv: CROWDY_APP_TOKEN',
+        `  baseURL: ${quote(modelBaseUrl)}`,
+        '  thinking: disabled',
+        '  models:',
+    ];
+    for (const model of models) {
+        lines.push(`    - id: ${quote(model.id)}`);
+        lines.push(`      name: ${quote(model.name)}`);
+        if (model.contextWindow)
+            lines.push(`      contextWindow: ${model.contextWindow}`);
+        lines.push('      maxTokens: 8192');
+        lines.push(`      inputModalities: [${model.inputModalities.map(quote).join(', ')}]`);
+    }
+    const first = models[0];
+    if (first) {
+        lines.push('agent-default-model:', '  provider: deepseek-official', `  model: ${quote(first.id)}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+/** Downscale and PNG-encode a frame in the page. */
+async function encodePng(source, maxSide) {
+    let bitmap;
+    if (source instanceof Blob)
+        bitmap = await createImageBitmap(source);
+    else
+        bitmap = source;
+    const scale = Math.min(1, maxSide / Math.max(bitmap.width, bitmap.height));
+    const width = Math.max(1, Math.round(bitmap.width * scale));
+    const height = Math.max(1, Math.round(bitmap.height * scale));
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const context = canvas.getContext('2d');
+    if (!context)
+        throw new Error('2D canvas unavailable for the capture.');
+    context.drawImage(bitmap, 0, 0, width, height);
+    if (source instanceof Blob && 'close' in bitmap)
+        bitmap.close();
+    const blob = await new Promise((resolve) => canvas.toBlob(resolve, 'image/png'));
+    if (!blob)
+        throw new Error('PNG encoding failed.');
+    return { bytes: await blob.arrayBuffer(), width, height };
+}

package/dist/crowdy-dsh/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Crowdy Studio agent pane: the DeepSeek Harness running in the player's
+ * browser, embedded beside the Studio editor and bridged to it.
+ *
+ * @module @crowdedkingdoms/crowdyjs/crowdy-dsh
+ */
+export { StudioDshBridge, renderSettingsYaml, type CrowdyStudioDshHost, type StudioDshBridgeOptions, type StudioDshBridgeStatus, } from './bridge.js';
+export { CrowdyStudioDshPane, CROWDY_STUDIO_DSH_STYLES, type CrowdyStudioDshPaneOptions } from './pane.js';
+export { CrowdyStudioDshTransport, type CrowdyStudioModelCatalogEntry, type CrowdyStudioModelUsage, type CrowdyStudioModelUsageEntry, type CrowdyStudioProviderConsent, } from './transport.js';
+export * from './protocol.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/crowdy-dsh/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/crowdy-dsh/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,GAC3B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,KAAK,0BAA0B,EAAE,MAAM,WAAW,CAAC;AAC3G,OAAO,EACL,wBAAwB,EACxB,KAAK,6BAA6B,EAClC,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,GACjC,MAAM,gBAAgB,CAAC;AACxB,cAAc,eAAe,CAAC"}

package/dist/crowdy-dsh/index.js

@@ -0,0 +1,10 @@
+/**
+ * Crowdy Studio agent pane: the DeepSeek Harness running in the player's
+ * browser, embedded beside the Studio editor and bridged to it.
+ *
+ * @module @crowdedkingdoms/crowdyjs/crowdy-dsh
+ */
+export { StudioDshBridge, renderSettingsYaml, } from './bridge.js';
+export { CrowdyStudioDshPane, CROWDY_STUDIO_DSH_STYLES } from './pane.js';
+export { CrowdyStudioDshTransport, } from './transport.js';
+export * from './protocol.js';

package/dist/crowdy-dsh/pane.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The Studio agent pane: a same-origin iframe hosting the DeepSeek Harness
+ * web UI (running in a Web Worker) plus the Crowdy chrome around it — the
+ * provider-data notice the player accepts once, a Screenshot button, the
+ * payer / spend line, and the bridge status.
+ *
+ * The harness owns the conversation UI (chat, diffs, plan mode, approvals);
+ * this pane owns what the game knows: who pays, whether the player consented,
+ * and the capture button that pushes a frame into the model's `captures/`.
+ */
+import type { CrowdyStudioController } from '../crowdy-studio/controller.js';
+import type { StudioLayoutController } from '../crowdy-studio/layout.js';
+import { StudioDshBridge, type CrowdyStudioDshHost } from './bridge.js';
+import { CrowdyStudioDshTransport } from './transport.js';
+export interface CrowdyStudioDshPaneOptions {
+    controller: CrowdyStudioController;
+    transport: CrowdyStudioDshTransport;
+    appId: string;
+    /** Where the packed harness page is served, e.g. `/dsh/`. */
+    webBase: string;
+    /** Stable per-player key for session persistence (never a token). */
+    persistScope: string;
+    getToken(): string | null;
+    graphqlUrl: string;
+    host?: CrowdyStudioDshHost;
+    /** Studio origin for the wallet link; omitted hides the link. */
+    studioOrigin?: string;
+    layout?: StudioLayoutController;
+    onWarning?(message: string): void;
+}
+export declare class CrowdyStudioDshPane {
+    private readonly options;
+    readonly root: HTMLElement;
+    readonly bridge: StudioDshBridge;
+    private readonly frame;
+    private readonly status;
+    private readonly spend;
+    private readonly notice;
+    private readonly captureButton;
+    private readonly message;
+    private usageTimer;
+    private started;
+    private disposed;
+    constructor(parent: HTMLElement, options: CrowdyStudioDshPaneOptions);
+    /**
+     * The page-side gate on a live deploy. The harness UI has its own approval
+     * inside the iframe, but the page cannot see it and the channel is open to
+     * any same-origin script, so the player confirms here too. Auto-declines
+     * after a minute so a stale prompt cannot be accepted by accident later.
+     */
+    private confirmLiveDeploy;
+    /** Boot once the pane is visible; the notice gates the first boot on consent. */
+    start(): Promise<void>;
+    dispose(): void;
+    private boot;
+    private renderNotice;
+    private renderStatus;
+    private refreshUsage;
+    private renderSpend;
+    private say;
+    private run;
+}
+export declare const CROWDY_STUDIO_DSH_STYLES = "\n.ck-crowdy-studio-dsh{flex:none;display:flex;flex-direction:column;min-width:0;min-height:0;border-left:1px solid var(--ck-line);background:#0b1220}\n.ck-crowdy-studio-dsh>header{display:flex;align-items:center;gap:8px;padding:6px 10px;border-bottom:1px solid var(--ck-line)}\n.ck-crowdy-studio-dsh>header h2{margin:0;font-size:13px;flex:none}\n.ck-crowdy-studio-dsh-status{flex:1;min-width:0;color:var(--ck-muted);font-size:12px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}\n.ck-crowdy-studio-dsh[data-phase=failed] .ck-crowdy-studio-dsh-status{color:#fca5a5}\n.ck-crowdy-studio-dsh-frame{flex:1;min-height:0;width:100%;border:0;background:#fff}\n.ck-crowdy-studio-dsh-notice{padding:10px;font-size:12px;color:var(--ck-text);border-bottom:1px solid var(--ck-line)}\n.ck-crowdy-studio-dsh-notice p{margin:0 0 8px}\n.ck-crowdy-studio-dsh-notice-actions{display:flex;gap:6px}\n.ck-crowdy-studio-dsh-spend{padding:4px 10px;font-size:11px;color:var(--ck-muted);border-top:1px solid var(--ck-line)}\n.ck-crowdy-studio-dsh-spend a{color:#bae6fd}\n.ck-crowdy-studio-dsh-message{padding:4px 10px;font-size:11px;color:#fde68a;border-top:1px solid var(--ck-line)}\n.ck-crowdy-studio-dsh-message button{font-size:11px;padding:2px 8px;margin-left:4px}\n.ck-crowdy-studio-dsh-confirm{background:#b91c1c;color:#fff;border:0;border-radius:3px}\n";
+//# sourceMappingURL=pane.d.ts.map

package/dist/crowdy-dsh/pane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pane.d.ts","sourceRoot":"","sources":["../../src/crowdy-dsh/pane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,KAAK,mBAAmB,EAA8B,MAAM,aAAa,CAAC;AACpG,OAAO,EAAE,wBAAwB,EAA+B,MAAM,gBAAgB,CAAC;AAEvF,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,sBAAsB,CAAC;IACnC,SAAS,EAAE,wBAAwB,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,IAAI,MAAM,GAAG,IAAI,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B,iEAAiE;IACjE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,sBAAsB,CAAC;IAChC,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAID,qBAAa,mBAAmB;IAe5B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAd1B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoB;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAS;gBAGvB,MAAM,EAAE,WAAW,EACF,OAAO,EAAE,0BAA0B;IAgEtD;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IA4BzB,iFAAiF;IAC3E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB5B,OAAO,IAAI,IAAI;YAOD,IAAI;IASlB,OAAO,CAAC,YAAY;IAuBpB,OAAO,CAAC,YAAY;YAqBN,YAAY;IAU1B,OAAO,CAAC,WAAW;IAmBnB,OAAO,CAAC,GAAG;YAKG,GAAG;CAOlB;AAQD,eAAO,MAAM,wBAAwB,u0CAepC,CAAC"}