@openchamber/sdk 1.23.2-preview.1

package/dist/ui/tabs.js

@@ -0,0 +1,61 @@
+import { button, clearNode, el, ensureStyle } from "./dom.js";
+import { moveListSelection, navigationKey } from "./navigation.js";
+import { UI_CSS } from "./style.js";
+export const mountTabs = (root, initial) => {
+    ensureStyle(UI_CSS);
+    let props = initial;
+    const track = el('div', 'oc-sdk oc-sdk-tabs');
+    track.setAttribute('role', 'tablist');
+    root.append(track);
+    const paint = () => {
+        clearNode(track);
+        track.dataset.track = props.trackBackground ? 'true' : 'false';
+        for (const item of props.items) {
+            const tab = button('oc-sdk-tab');
+            tab.setAttribute('role', 'tab');
+            const active = item.id === props.activeId;
+            tab.setAttribute('aria-selected', active ? 'true' : 'false');
+            tab.tabIndex = active ? 0 : -1;
+            tab.dataset.id = item.id;
+            const label = el('span');
+            label.textContent = item.label;
+            tab.append(label);
+            if (item.count !== undefined) {
+                const count = el('span', 'oc-sdk-tab-count');
+                count.textContent = String(item.count);
+                tab.append(count);
+            }
+            tab.addEventListener('click', () => {
+                if (item.id !== props.activeId)
+                    props.onChange(item.id);
+            });
+            track.append(tab);
+        }
+    };
+    const onKeyDown = (event) => {
+        const step = navigationKey(event, 'horizontal');
+        if (!step) {
+            return;
+        }
+        const next = moveListSelection(props.items, props.activeId, step);
+        if (next && next !== props.activeId) {
+            event.preventDefault();
+            props.onChange(next);
+            const tab = track.querySelector(`[data-id="${CSS.escape(next)}"]`);
+            if (tab instanceof HTMLElement)
+                tab.focus();
+        }
+    };
+    track.addEventListener('keydown', onKeyDown);
+    paint();
+    return {
+        update: (next) => {
+            props = { ...props, ...next };
+            paint();
+        },
+        dispose: () => {
+            track.removeEventListener('keydown', onKeyDown);
+            track.remove();
+        },
+    };
+};

package/dist/ui/text.d.ts

@@ -0,0 +1,23 @@
+import { type Handle } from './dom.ts';
+export type TextPart = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'image';
+    src: string;
+    alt: string;
+} | {
+    kind: 'link';
+    href: string;
+    label: string;
+};
+export type TextProps = {
+    text: string;
+    /** Called with the href of a clicked link. A sandboxed iframe cannot open it alone. */
+    onOpenUrl?: (url: string) => void;
+};
+export type TextHandle = Handle<TextProps>;
+export declare const isHttpUrl: (value: string) => boolean;
+/** Splits text into plain runs, `![alt](https://…)` images, and `[label](https://…)` links. Anything else stays text. */
+export declare const splitTextMedia: (text: string) => TextPart[];
+export declare const mountText: (root: Element, initial: TextProps) => TextHandle;

package/dist/ui/text.js

@@ -0,0 +1,89 @@
+import { clearNode, el, ensureStyle } from "./dom.js";
+import { UI_CSS } from "./style.js";
+const MARKDOWN_TOKEN = /(!?)\[([^\]]*)\]\((https?:\/\/[^)\s]+)\)/g;
+export const isHttpUrl = (value) => {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+};
+/** Splits text into plain runs, `![alt](https://…)` images, and `[label](https://…)` links. Anything else stays text. */
+export const splitTextMedia = (text) => {
+    const parts = [];
+    let last = 0;
+    for (const match of text.matchAll(MARKDOWN_TOKEN)) {
+        const index = match.index ?? 0;
+        if (index > last) {
+            parts.push({ kind: 'text', text: text.slice(last, index) });
+        }
+        const marker = match[1] ?? '';
+        const label = (match[2] ?? '').trim();
+        const href = match[3] ?? '';
+        if (!isHttpUrl(href)) {
+            parts.push({ kind: 'text', text: match[0] });
+        }
+        else if (marker === '!') {
+            parts.push({ kind: 'image', src: href, alt: label });
+        }
+        else {
+            parts.push({ kind: 'link', href, label: label || href });
+        }
+        last = index + match[0].length;
+    }
+    if (last < text.length) {
+        parts.push({ kind: 'text', text: text.slice(last) });
+    }
+    return parts;
+};
+export const mountText = (root, initial) => {
+    ensureStyle(UI_CSS);
+    let props = initial;
+    const node = el('div', 'oc-sdk oc-sdk-text');
+    root.append(node);
+    const onClick = (event) => {
+        if (!(event.target instanceof HTMLAnchorElement) || !props.onOpenUrl) {
+            return;
+        }
+        event.preventDefault();
+        props.onOpenUrl(event.target.href);
+    };
+    const paint = () => {
+        clearNode(node);
+        for (const part of splitTextMedia(props.text)) {
+            if (part.kind === 'text') {
+                node.append(document.createTextNode(part.text));
+            }
+            else if (part.kind === 'link') {
+                const link = el('a');
+                link.href = part.href;
+                link.rel = 'noopener noreferrer';
+                link.target = '_blank';
+                link.textContent = part.label;
+                node.append(link);
+            }
+            else {
+                const img = el('img');
+                img.src = part.src;
+                img.alt = part.alt;
+                img.loading = 'lazy';
+                img.referrerPolicy = 'no-referrer';
+                node.append(img);
+            }
+        }
+    };
+    node.addEventListener('click', onClick);
+    paint();
+    return {
+        update: (next) => {
+            props = { ...props, ...next };
+            paint();
+        },
+        dispose: () => {
+            node.removeEventListener('click', onClick);
+            node.remove();
+        },
+    };
+};

package/dist/ui/theme.d.ts

@@ -0,0 +1,22 @@
+import type { GuestHostSurface, HostTheme } from '../contract.ts';
+export type ThemeRoot = {
+    style: {
+        colorScheme: string;
+        setProperty: (name: string, value: string) => void;
+    };
+    dataset?: {
+        ocSurface?: string;
+        ocTheme?: string;
+    };
+};
+/**
+ * Paint the host theme onto the iframe root. Guest chrome reads these
+ * variables, and the root itself gets the host font and text colour so plain
+ * DOM the guest draws outside the kit (a `<pre>`, a `<p>`) inherits them
+ * instead of the browser's serif default.
+ */
+export declare const applyHostTheme: (theme: HostTheme, root: ThemeRoot) => void;
+export declare const applyHostReady: (ctx: {
+    theme: HostTheme;
+    surface: GuestHostSurface;
+}, root: ThemeRoot) => void;

package/dist/ui/theme.js

@@ -0,0 +1,69 @@
+const TOKEN_VARS = [
+    ['--oc-bg', 'background'],
+    ['--oc-elevated', 'elevated'],
+    ['--oc-fg', 'foreground'],
+    ['--oc-muted', 'muted'],
+    ['--oc-subtle', 'subtle'],
+    ['--oc-border', 'border'],
+    ['--oc-hover', 'hover'],
+    ['--oc-selection', 'selection'],
+    ['--oc-focus', 'focus'],
+    ['--oc-primary', 'primary'],
+    ['--oc-muted-surface', 'mutedSurface'],
+    ['--oc-elevated-fg', 'elevatedForeground'],
+    ['--oc-active', 'active'],
+    ['--oc-selection-fg', 'selectionForeground'],
+    ['--oc-primary-fg', 'primaryForeground'],
+    ['--oc-success', 'success'],
+    ['--oc-warning', 'warning'],
+    ['--oc-error', 'error'],
+    ['--oc-info', 'info'],
+    ['--oc-font', 'font'],
+    ['--oc-mono', 'mono'],
+    ['--oc-radius', 'radius'],
+    ['--surface-background', 'background'],
+    ['--surface-elevated', 'elevated'],
+    ['--surface-foreground', 'foreground'],
+    ['--surface-muted-foreground', 'muted'],
+    ['--surface-subtle', 'subtle'],
+    ['--interactive-border', 'border'],
+    ['--interactive-hover', 'hover'],
+    ['--interactive-selection', 'selection'],
+    ['--interactive-focus-ring', 'focus'],
+    ['--primary', 'primary'],
+    ['--surface-muted', 'mutedSurface'],
+    ['--surface-elevated-foreground', 'elevatedForeground'],
+    ['--interactive-active', 'active'],
+    ['--interactive-selection-foreground', 'selectionForeground'],
+    ['--primary-foreground', 'primaryForeground'],
+    ['--status-success', 'success'],
+    ['--status-warning', 'warning'],
+    ['--status-error', 'error'],
+    ['--status-info', 'info'],
+    ['--font-sans', 'font'],
+    ['--font-mono', 'mono'],
+    ['--radius', 'radius'],
+];
+/**
+ * Paint the host theme onto the iframe root. Guest chrome reads these
+ * variables, and the root itself gets the host font and text colour so plain
+ * DOM the guest draws outside the kit (a `<pre>`, a `<p>`) inherits them
+ * instead of the browser's serif default.
+ */
+export const applyHostTheme = (theme, root) => {
+    root.style.colorScheme = theme.mode;
+    for (const [name, key] of TOKEN_VARS) {
+        root.style.setProperty(name, theme.tokens[key]);
+    }
+    root.style.setProperty('font-family', theme.tokens.font);
+    root.style.setProperty('font-size', '0.875rem');
+    root.style.setProperty('line-height', '1.45');
+    root.style.setProperty('color', theme.tokens.foreground);
+};
+export const applyHostReady = (ctx, root) => {
+    applyHostTheme(ctx.theme, root);
+    if (root.dataset) {
+        root.dataset.ocSurface = ctx.surface;
+        root.dataset.ocTheme = ctx.theme.mode;
+    }
+};

package/dist/workspace-schemas.d.ts

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+export declare const guestWorkspaceQuerySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"projects">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"worktrees">;
+    projectId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"sessions">;
+    projectId: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const guestWorkspaceSnapshotSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"projects">;
+    state: z.ZodEnum<{
+        loading: "loading";
+        ready: "ready";
+        error: "error";
+    }>;
+    projects: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        directory: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"worktrees">;
+    projectId: z.ZodString;
+    state: z.ZodEnum<{
+        loading: "loading";
+        ready: "ready";
+        error: "error";
+    }>;
+    worktrees: z.ZodArray<z.ZodObject<{
+        directory: z.ZodString;
+        name: z.ZodString;
+        branch: z.ZodString;
+        status: z.ZodEnum<{
+            ready: "ready";
+            pending: "pending";
+            invalid: "invalid";
+            missing: "missing";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"sessions">;
+    projectId: z.ZodString;
+    state: z.ZodEnum<{
+        loading: "loading";
+        ready: "ready";
+        error: "error";
+    }>;
+    coverage: z.ZodArray<z.ZodObject<{
+        directory: z.ZodString;
+        state: z.ZodEnum<{
+            loading: "loading";
+            ready: "ready";
+            error: "error";
+        }>;
+    }, z.core.$strip>>;
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        projectId: z.ZodString;
+        directory: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        archivedAt: z.ZodNullable<z.ZodNumber>;
+        worktree: z.ZodNullable<z.ZodObject<{
+            directory: z.ZodString;
+            name: z.ZodString;
+            branch: z.ZodString;
+            status: z.ZodEnum<{
+                ready: "ready";
+                pending: "pending";
+                invalid: "invalid";
+                missing: "missing";
+            }>;
+        }, z.core.$strip>>;
+        activity: z.ZodEnum<{
+            unknown: "unknown";
+            idle: "idle";
+            running: "running";
+            retrying: "retrying";
+            "waiting-permission": "waiting-permission";
+            "waiting-question": "waiting-question";
+        }>;
+        outcome: z.ZodNullable<z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+        }>>;
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            data: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "kind">;
+export declare const guestSessionWorktreeSchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    kind: z.ZodLiteral<"existing">;
+    directory: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"new">;
+    name: z.ZodOptional<z.ZodString>;
+    baseBranch: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>;
+export declare const guestStorageRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"get">;
+    key: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"delete">;
+    key: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"set">;
+    key: z.ZodString;
+    value: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"keys">;
+}, z.core.$strict>], "op">;
+export declare const guestStorageResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    storage: z.ZodLiteral<true>;
+    op: z.ZodLiteral<"get">;
+    found: z.ZodLiteral<false>;
+}, z.core.$strip>, z.ZodObject<{
+    storage: z.ZodLiteral<true>;
+    op: z.ZodLiteral<"get">;
+    found: z.ZodLiteral<true>;
+    value: z.ZodJSONSchema;
+}, z.core.$strip>, z.ZodObject<{
+    storage: z.ZodLiteral<true>;
+    op: z.ZodEnum<{
+        delete: "delete";
+        set: "set";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    storage: z.ZodLiteral<true>;
+    op: z.ZodLiteral<"keys">;
+    keys: z.ZodArray<z.ZodString>;
+}, z.core.$strip>]>;

package/dist/workspace-schemas.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { GUEST_STORAGE_KEY_MAX, GUEST_STORAGE_VALUE_BYTES, GUEST_STORAGE_KEYS_MAX } from "./workspace.js";
+const identity = z.string().trim().min(1).max(1024);
+const state = z.enum(['loading', 'ready', 'error']);
+const worktree = z.object({
+    directory: identity, name: z.string(), branch: z.string(),
+    status: z.enum(['ready', 'pending', 'invalid', 'missing']),
+});
+export const guestWorkspaceQuerySchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('projects') }).strict(),
+    z.object({ kind: z.literal('worktrees'), projectId: identity }).strict(),
+    z.object({ kind: z.literal('sessions'), projectId: identity }).strict(),
+]);
+export const guestWorkspaceSnapshotSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('projects'), state, projects: z.array(z.object({ id: identity, name: z.string(), directory: identity })) }),
+    z.object({ kind: z.literal('worktrees'), projectId: identity, state, worktrees: z.array(worktree) }),
+    z.object({ kind: z.literal('sessions'), projectId: identity, state,
+        coverage: z.array(z.object({ directory: identity, state })),
+        sessions: z.array(z.object({
+            id: identity, title: z.string(), projectId: identity, directory: identity, parentId: identity.nullable(),
+            createdAt: z.number(), updatedAt: z.number(), archivedAt: z.number().nullable(), worktree: worktree.nullable(),
+            activity: z.enum(['unknown', 'idle', 'running', 'retrying', 'waiting-permission', 'waiting-question']),
+            outcome: z.enum(['completed', 'failed']).nullable(), items: z.array(z.object({ id: identity, data: z.json().optional() })),
+        })),
+    }),
+]);
+export const guestSessionWorktreeSchema = z.union([
+    z.boolean(),
+    z.object({ kind: z.literal('existing'), directory: identity }).strict(),
+    z.object({ kind: z.literal('new'), name: z.string().trim().min(1).max(200).optional(), baseBranch: z.string().trim().min(1).max(200).optional() }).strict(),
+]);
+const storageKey = z.string().min(1).max(GUEST_STORAGE_KEY_MAX);
+export const guestStorageRequestSchema = z.discriminatedUnion('op', [
+    z.object({ op: z.literal('get'), key: storageKey }).strict(),
+    z.object({ op: z.literal('delete'), key: storageKey }).strict(),
+    z.object({ op: z.literal('set'), key: storageKey, value: z.json().refine((value) => new TextEncoder().encode(JSON.stringify(value)).length <= GUEST_STORAGE_VALUE_BYTES) }).strict(),
+    z.object({ op: z.literal('keys') }).strict(),
+]);
+export const guestStorageResultSchema = z.union([
+    z.object({ storage: z.literal(true), op: z.literal('get'), found: z.literal(false) }),
+    z.object({ storage: z.literal(true), op: z.literal('get'), found: z.literal(true), value: z.json() }),
+    z.object({ storage: z.literal(true), op: z.enum(['set', 'delete']) }),
+    z.object({ storage: z.literal(true), op: z.literal('keys'), keys: z.array(storageKey).max(GUEST_STORAGE_KEYS_MAX) }),
+]);

package/dist/workspace.d.ts

@@ -0,0 +1,109 @@
+import type { JsonValue } from './contract.ts';
+export type GuestLoadState = 'loading' | 'ready' | 'error';
+export type GuestProject = {
+    id: string;
+    name: string;
+    directory: string;
+};
+export type GuestWorktree = {
+    directory: string;
+    name: string;
+    branch: string;
+    status: 'ready' | 'pending' | 'invalid' | 'missing';
+};
+export type GuestSessionActivity = 'unknown' | 'idle' | 'running' | 'retrying' | 'waiting-permission' | 'waiting-question';
+export type GuestSessionRecord = {
+    id: string;
+    title: string;
+    projectId: string;
+    directory: string;
+    parentId: string | null;
+    createdAt: number;
+    updatedAt: number;
+    archivedAt: number | null;
+    worktree: GuestWorktree | null;
+    activity: GuestSessionActivity;
+    /** Observed turn outcome, never a task status. Unknown history stays null. */
+    outcome: 'completed' | 'failed' | null;
+    items: {
+        id: string;
+        data?: JsonValue;
+    }[];
+};
+export type GuestDirectoryCoverage = {
+    directory: string;
+    state: GuestLoadState;
+};
+export type GuestProjectsSnapshot = {
+    kind: 'projects';
+    state: GuestLoadState;
+    projects: GuestProject[];
+};
+export type GuestWorktreesSnapshot = {
+    kind: 'worktrees';
+    projectId: string;
+    state: GuestLoadState;
+    worktrees: GuestWorktree[];
+};
+export type GuestSessionsSnapshot = {
+    kind: 'sessions';
+    projectId: string;
+    state: GuestLoadState;
+    coverage: GuestDirectoryCoverage[];
+    sessions: GuestSessionRecord[];
+};
+export type GuestWorkspaceSnapshot = GuestProjectsSnapshot | GuestWorktreesSnapshot | GuestSessionsSnapshot;
+export type GuestWorkspaceQuery = {
+    kind: 'projects';
+} | {
+    kind: 'worktrees';
+    projectId: string;
+} | {
+    kind: 'sessions';
+    projectId: string;
+};
+export type GuestWorkspaceSubscription = {
+    subscriptionId: string;
+    query: GuestWorkspaceQuery;
+};
+export type GuestWorkspaceUpdate = {
+    subscriptionId: string;
+    snapshot: GuestWorkspaceSnapshot;
+};
+export declare const GUEST_STORAGE_KEY_MAX = 128;
+export declare const GUEST_STORAGE_VALUE_BYTES = 65536;
+export declare const GUEST_STORAGE_TOTAL_BYTES = 2097152;
+export declare const GUEST_STORAGE_KEYS_MAX = 2000;
+export type GuestStorageRequest = {
+    op: 'get' | 'delete';
+    key: string;
+} | {
+    op: 'set';
+    key: string;
+    value: JsonValue;
+} | {
+    op: 'keys';
+};
+export type GuestStorageResult = {
+    storage: true;
+} & ({
+    op: 'get';
+    found: false;
+} | {
+    op: 'get';
+    found: true;
+    value: JsonValue;
+} | {
+    op: 'set' | 'delete';
+} | {
+    op: 'keys';
+    keys: string[];
+});
+export type GuestSessionWorktree = boolean | {
+    kind: 'existing';
+    directory: string;
+} | {
+    kind: 'new';
+    name?: string;
+    baseBranch?: string;
+};

package/dist/workspace.js

@@ -0,0 +1,4 @@
+export const GUEST_STORAGE_KEY_MAX = 128;
+export const GUEST_STORAGE_VALUE_BYTES = 65_536;
+export const GUEST_STORAGE_TOTAL_BYTES = 2_097_152;
+export const GUEST_STORAGE_KEYS_MAX = 2_000;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@openchamber/sdk",
+  "version": "1.23.2-preview.1",
+  "description": "Contract for OpenChamber guests: manifest parse and iframe host bridge.",
+  "private": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/openchamber/openchamber.git",
+    "directory": "packages/sdk"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./ui": {
+      "types": "./dist/ui/index.d.ts",
+      "default": "./dist/ui/index.js"
+    },
+    "./schemas": {
+      "types": "./dist/schemas.d.ts",
+      "default": "./dist/schemas.js"
+    }
+  },
+  "bin": {
+    "openchamber-guest-bundle": "./scripts/bundle-guest.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint \"./src/**/*.ts\" --config ../../eslint.config.js",
+    "bundle": "bun scripts/bundle-guest.ts",
+    "test": "node ../../scripts/run-isolated-tests.mjs src scripts",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\""
+  },
+  "files": [
+    "dist",
+    "scripts/bundle-guest.ts",
+    "README.md",
+    "API.md",
+    "DOCUMENTATION.md",
+    "GUEST_SERVICES.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "zod": "^4.3.6"
+  }
+}

package/scripts/bundle-guest.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+import { writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+const usage = 'Usage: openchamber-guest-bundle [--node] <entry.ts> <outfile.js>';
+
+const args = process.argv.slice(2);
+const nodeTarget = args.includes('--node');
+const [entry, outfile] = args.filter((arg) => arg !== '--node');
+if (!entry || !outfile) {
+  console.error(usage);
+  process.exit(1);
+}
+
+const bun = globalThis.Bun;
+if (!bun?.build) {
+  console.error('This bundle command needs Bun.');
+  process.exit(1);
+}
+
+// A panel runs in a sandboxed iframe that cannot load ESM, so it gets a
+// browser IIFE. A local service runs under Node, so `--node` keeps ESM and
+// leaves the Node built-ins external.
+const result = await bun.build({
+  entrypoints: [resolve(entry)],
+  format: nodeTarget ? 'esm' : 'iife',
+  target: nodeTarget ? 'node' : 'browser',
+  minify: !nodeTarget,
+  write: false,
+});
+
+if (!result.success) {
+  const message = result.logs.map((log) => log.message).join('\n');
+  console.error(message || 'Guest script build failed');
+  process.exit(1);
+}
+
+const artifact = result.outputs[0];
+if (!artifact) {
+  console.error('Guest script build produced no output');
+  process.exit(1);
+}
+
+await writeFile(resolve(outfile), await artifact.text());