@vibesdotdev/editor 0.0.0-stage → 1.0.0-rc.2

package/dist/svelte/editor-svelte.plugin.d.ts

@@ -0,0 +1,38 @@
+export declare const workspaceSearchWidgetDescriptor: {
+    id: string;
+    kind: "tools/ui";
+    surfaces: ("cli" | "tui" | "worker" | "bridge" | "web")[];
+    role: "badge" | "widget" | "approval";
+    targetToolId: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    enabled?: boolean | undefined;
+    priority?: number | undefined;
+    capabilityId?: string | undefined;
+    requiredContext?: string[] | undefined;
+    optionalContext?: string[] | undefined;
+    config?: unknown;
+    retention?: string | {
+        reason: string;
+        maxAgeDays?: number | undefined;
+        maxEntries?: number | undefined;
+        maxBytes?: number | undefined;
+        cascadeFrom?: string | undefined;
+        ageField?: string | undefined;
+        enforcedBy?: string | undefined;
+    } | undefined;
+    hardware?: ("consumer" | "cloud")[] | undefined;
+    targetId?: string | undefined;
+    placement?: "inline" | "top" | "bottom" | undefined;
+};
+/**
+ * Svelte/browser surface for editor-owned tool cards.
+ *
+ * `tools/tool#workspace-search` is workspace's facade. Editor owns the Atlas
+ * action layer and the designed Kit card. tools/svelte still registers a
+ * search-only fallback; last Kit registration wins when this plugin loads.
+ */
+export declare const editorSveltePlugin: import("@vibesdotdev/kernel").RuntimePlugin;
+export default editorSveltePlugin;
+//# sourceMappingURL=editor-svelte.plugin.d.ts.map

package/dist/svelte/editor-svelte.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-svelte.plugin.d.ts","sourceRoot":"","sources":["../../src/svelte/editor-svelte.plugin.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI1C,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,6CAW7B,CAAC;AAEH,eAAe,kBAAkB,CAAC"}

package/dist/svelte/editor-svelte.plugin.js

@@ -0,0 +1,26 @@
+import { createRuntimePlugin } from '@vibesdotdev/kernel';
+import { createSvelteToolWidgetDescriptor, createSvelteToolWidgetLoader } from '@vibesdotdev/tools/svelte/tool-widgets';
+import editorConfigDescriptor from "../config/editor.config.descriptor.js";
+export const workspaceSearchWidgetDescriptor = createSvelteToolWidgetDescriptor({
+    toolId: 'workspace-search',
+    name: 'Workspace search Svelte widget',
+    description: 'Renders Atlas search, graph, symbol, index, and sync-status results in Svelte surfaces.'
+});
+/**
+ * Svelte/browser surface for editor-owned tool cards.
+ *
+ * `tools/tool#workspace-search` is workspace's facade. Editor owns the Atlas
+ * action layer and the designed Kit card. tools/svelte still registers a
+ * search-only fallback; last Kit registration wins when this plugin loads.
+ */
+export const editorSveltePlugin = createRuntimePlugin({
+    id: '@vibesdotdev/editor/svelte',
+    name: 'Editor Svelte',
+    description: 'Svelte/browser surface for editor-owned Atlas tool cards',
+    dependencies: ['tools'],
+    descriptors: [workspaceSearchWidgetDescriptor, editorConfigDescriptor],
+    loaders: [
+        createSvelteToolWidgetLoader(workspaceSearchWidgetDescriptor, () => import('./tool-widgets/WorkspaceSearchToolCard.svelte'))
+    ]
+});
+export default editorSveltePlugin;

package/dist/svelte/editor-svelte.vessel.plugin.d.ts

@@ -0,0 +1,309 @@
+export declare const editorWorkspaceVesselAppDescriptor: {
+    identity: {
+        glyph: string;
+        accent: "neutral" | "amber" | "cyan" | "teal" | "azure" | "blue" | "lime" | "rose" | "violet";
+        artworkId?: string | undefined;
+    };
+    id: string;
+    kind: "vessel/app";
+    name: string;
+    description: string;
+    owner: {
+        packageName: string;
+        entrypoint?: string | undefined;
+        specPath?: string | undefined;
+        runtimeKind?: string | undefined;
+        runtimeId?: string | undefined;
+    };
+    category: "agent" | "service" | "runtime" | "tool" | "settings" | "audit" | "feature" | "docs" | "app";
+    launch: {
+        type: "svelte-component";
+        import: string;
+        exportName?: string | undefined;
+    } | {
+        type: "vessel-surface";
+        surfaceId: string;
+        initialState?: Record<string, string | number | boolean | null> | undefined;
+    } | {
+        type: "sveltekit-route";
+        href: string;
+    } | {
+        type: "runtime-client";
+        clientId: string;
+        view: "default" | "inspector";
+    } | {
+        type: "tui-app";
+        route: string;
+    } | {
+        type: "tool";
+        toolId: string;
+    } | {
+        type: "config-manifest";
+        manifestId: string;
+    } | {
+        type: "docs-topic";
+        topicId: string;
+    } | {
+        type: "runtime-descriptor";
+        kind: string;
+        id: string;
+    } | {
+        type: "platform-component";
+        componentId: string;
+        version: string;
+        props: Record<string, unknown>;
+        origin?: string | undefined;
+    } | {
+        type: "applet-artifact";
+        artifactId: string;
+        browserRuntime: boolean;
+        componentRef?: {
+            id: string;
+            version: string;
+            props: Record<string, unknown>;
+            origin?: string | undefined;
+        } | undefined;
+    } | {
+        type: "external-url";
+        href: string;
+    };
+    availability: {
+        status: "unknown" | "unavailable" | "degraded" | "available";
+        summary: string;
+        lastCheckedAt?: string | undefined;
+    };
+    defaultWindow: {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+        minWidth: number;
+        minHeight: number;
+    };
+    tags: string[];
+    workLocations: ("browser" | "cloud" | "computer" | "vessel")[];
+    readinessAreaIds: string[];
+    setupStepIds: string[];
+    hardware?: string[] | undefined;
+    enabled?: boolean | undefined;
+    priority?: number | undefined;
+    capabilityId?: string | undefined;
+    requiredContext?: string[] | undefined;
+    optionalContext?: string[] | undefined;
+    config?: unknown;
+    retention?: string | {
+        reason: string;
+        maxAgeDays?: number | undefined;
+        maxEntries?: number | undefined;
+        maxBytes?: number | undefined;
+        cascadeFrom?: string | undefined;
+        ageField?: string | undefined;
+        enforcedBy?: string | undefined;
+    } | undefined;
+    ports?: {
+        id: string;
+        label: string;
+        direction: "output" | "input";
+        schema: {
+            mediaType: string;
+            shape: "any" | "event" | "stream" | "json" | "text" | "binary";
+            schemaId?: string | undefined;
+        };
+        multiple: boolean;
+        required: boolean;
+    }[] | undefined;
+};
+export declare const editorWorkspaceVesselReadinessDescriptor: {
+    id: string;
+    kind: "vessel/readiness-area";
+    label: string;
+    userPromise: string;
+    status: "unknown" | "ready" | "blocked" | "planned" | "needs-setup";
+    summary: string;
+    owner: {
+        packageName: string;
+        entrypoint?: string | undefined;
+        specPath?: string | undefined;
+        runtimeKind?: string | undefined;
+        runtimeId?: string | undefined;
+    };
+    targetKinds: string[];
+    evidence: ({
+        type: "runtime-query";
+        kind: string;
+        resultSummary: string;
+        id?: string | undefined;
+    } | {
+        type: "command";
+        cwd: string;
+        command: string;
+        exitCode: number;
+        summary: string;
+    } | {
+        type: "http";
+        method: string;
+        url: string;
+        status: number;
+        summary: string;
+    } | {
+        type: "screenshot";
+        path: string;
+        summary: string;
+        viewport?: string | undefined;
+    } | {
+        type: "source";
+        path: string;
+        summary: string;
+        line?: number | undefined;
+    } | {
+        type: "spec";
+        path: string;
+        summary: string;
+        heading?: string | undefined;
+    })[];
+    linkedFindingIds: string[];
+    upstreamWorkItemIds: string[];
+    proofGate: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    hardware?: string[] | undefined;
+    enabled?: boolean | undefined;
+    priority?: number | undefined;
+    capabilityId?: string | undefined;
+    requiredContext?: string[] | undefined;
+    optionalContext?: string[] | undefined;
+    config?: unknown;
+    retention?: string | {
+        reason: string;
+        maxAgeDays?: number | undefined;
+        maxEntries?: number | undefined;
+        maxBytes?: number | undefined;
+        cascadeFrom?: string | undefined;
+        ageField?: string | undefined;
+        enforcedBy?: string | undefined;
+    } | undefined;
+    nextAction?: {
+        label: string;
+        href?: string | undefined;
+        command?: string | undefined;
+    } | undefined;
+};
+export declare const editorWorkspaceVesselSetupDescriptor: {
+    id: string;
+    kind: "vessel/setup-step";
+    areaId: string;
+    order: number;
+    label: string;
+    userAction: string;
+    userResult: string;
+    place: "browser" | "cloud" | "vibes" | "computer" | "vessel";
+    status: "unknown" | "ready" | "blocked" | "planned" | "needs-setup";
+    owner: {
+        packageName: string;
+        entrypoint?: string | undefined;
+        specPath?: string | undefined;
+        runtimeKind?: string | undefined;
+        runtimeId?: string | undefined;
+    };
+    evidence: ({
+        type: "runtime-query";
+        kind: string;
+        resultSummary: string;
+        id?: string | undefined;
+    } | {
+        type: "command";
+        cwd: string;
+        command: string;
+        exitCode: number;
+        summary: string;
+    } | {
+        type: "http";
+        method: string;
+        url: string;
+        status: number;
+        summary: string;
+    } | {
+        type: "screenshot";
+        path: string;
+        summary: string;
+        viewport?: string | undefined;
+    } | {
+        type: "source";
+        path: string;
+        summary: string;
+        line?: number | undefined;
+    } | {
+        type: "spec";
+        path: string;
+        summary: string;
+        heading?: string | undefined;
+    })[];
+    upstreamWorkItemIds: string[];
+    proofGate: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    hardware?: string[] | undefined;
+    enabled?: boolean | undefined;
+    priority?: number | undefined;
+    capabilityId?: string | undefined;
+    requiredContext?: string[] | undefined;
+    optionalContext?: string[] | undefined;
+    config?: unknown;
+    retention?: string | {
+        reason: string;
+        maxAgeDays?: number | undefined;
+        maxEntries?: number | undefined;
+        maxBytes?: number | undefined;
+        cascadeFrom?: string | undefined;
+        ageField?: string | undefined;
+        enforcedBy?: string | undefined;
+    } | undefined;
+    nextAction?: {
+        label: string;
+        href?: string | undefined;
+        command?: string | undefined;
+    } | undefined;
+    falsifier?: string | undefined;
+};
+export declare const editorWorkspaceVesselSurfaceDescriptor: {
+    kind: "vessel/surface";
+    id: string;
+    name: string;
+    description: string;
+    label: string;
+    surfaceKind: string;
+    owner: {
+        packageName: string;
+    };
+    contract: {
+        apiVersion: string;
+        stateSchemaId: string;
+        stateSchemaVersion: number;
+        stateSchema: import("zod/v4").ZodObject<{
+            adapterId: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            initialPath: import("zod/v4").ZodDefault<import("zod/v4").ZodString>;
+            mode: import("zod/v4").ZodDefault<import("zod/v4").ZodLiteral<"code">>;
+        }, import("zod/v4/core").$strict>;
+    };
+    activation: string;
+    execution: string;
+    requiredCapabilities: ({
+        id: string;
+        reason: string;
+        selectorId?: undefined;
+    } | {
+        id: string;
+        selectorId: string;
+        reason: string;
+    })[];
+    optionalCapabilities: never[];
+    primaryAudience: string;
+    secondaryAudiences: string[];
+    technicalLanguagePolicy: string;
+    promotionGate: string;
+};
+export declare const editorSvelteVesselPlugin: import("@vibesdotdev/kernel").RuntimePlugin;
+export default editorSvelteVesselPlugin;
+//# sourceMappingURL=editor-svelte.vessel.plugin.d.ts.map

package/dist/svelte/editor-svelte.vessel.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-svelte.vessel.plugin.d.ts","sourceRoot":"","sources":["../../src/svelte/editor-svelte.vessel.plugin.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsC7C,CAAC;AAEH,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAanD,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe/C,CAAC;AAEH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCjD,CAAC;AAEH,eAAO,MAAM,wBAAwB,6CAqBnC,CAAC;AAEH,eAAe,wBAAwB,CAAC"}

package/dist/svelte/editor-svelte.vessel.plugin.js

@@ -0,0 +1,130 @@
+import { createRuntimeAsset, createRuntimePlugin, loader } from '@vibesdotdev/kernel';
+import { vesselAppDescriptorSchema, vesselReadinessAreaSchema, vesselSetupStepSchema } from '@vibesdotdev/vessel/schemas';
+import { editorWorkspaceVesselStateSchema } from "./editor-workspace-state.js";
+const editorVesselOwner = {
+    packageName: '@vibesdotdev/editor/svelte',
+    entrypoint: './vessel.plugin',
+    runtimeKind: 'runtime/client',
+    runtimeId: 'editor'
+};
+export const editorWorkspaceVesselAppDescriptor = vesselAppDescriptorSchema.parse({
+    kind: 'vessel/app',
+    id: 'workspace.code',
+    name: 'Code',
+    description: 'Explore and edit code in the current workspace.',
+    owner: editorVesselOwner,
+    identity: { glyph: 'lucide:code-2', accent: 'violet' },
+    category: 'app',
+    launch: {
+        type: 'vessel-surface',
+        surfaceId: 'editor.workspace',
+        initialState: { initialPath: '/', mode: 'code' }
+    },
+    availability: {
+        status: 'unknown',
+        summary: 'Code checks the bound workspace and editor client when opened.'
+    },
+    defaultWindow: { x: 136, y: 80, width: 1180, height: 760, minWidth: 760, minHeight: 520 },
+    tags: ['code', 'editor', 'files', 'workspace'],
+    workLocations: ['vessel'],
+    readinessAreaIds: ['readiness.code'],
+    setupStepIds: ['setup.workspace.code'],
+    ports: [
+        {
+            id: 'in.default',
+            label: 'In',
+            direction: 'input',
+            schema: { mediaType: 'application/json', shape: 'any' },
+            multiple: true
+        },
+        {
+            id: 'out.document',
+            label: 'Document',
+            direction: 'output',
+            schema: { mediaType: 'text/plain', shape: 'text' },
+            multiple: true
+        }
+    ]
+});
+export const editorWorkspaceVesselReadinessDescriptor = vesselReadinessAreaSchema.parse({
+    kind: 'vessel/readiness-area',
+    id: 'readiness.code',
+    label: 'Code',
+    userPromise: 'Edit code in this workspace',
+    status: 'unknown',
+    summary: 'Code readiness follows the bound workspace document and editor runtime client.',
+    owner: editorVesselOwner,
+    targetKinds: ['workspace/environment', 'workspace/document', 'runtime/client'],
+    evidence: [],
+    linkedFindingIds: [],
+    upstreamWorkItemIds: [],
+    proofGate: 'A workspace document opens and publishes through runtime/client#editor in the real workbench.'
+});
+export const editorWorkspaceVesselSetupDescriptor = vesselSetupStepSchema.parse({
+    kind: 'vessel/setup-step',
+    id: 'setup.workspace.code',
+    areaId: 'readiness.code',
+    order: 11,
+    label: 'Open Code',
+    userAction: 'Open a text document from the current workspace.',
+    userResult: 'Code edits and saves through the workspace document owner.',
+    place: 'vessel',
+    status: 'unknown',
+    owner: editorVesselOwner,
+    evidence: [],
+    upstreamWorkItemIds: [],
+    proofGate: 'The Code entrypoint mounts the real filesystem workbench and editor transaction.',
+    falsifier: 'Code bypasses workspace/document, invents a second file tree, or reports Save before publish succeeds.'
+});
+export const editorWorkspaceVesselSurfaceDescriptor = createRuntimeAsset({
+    kind: 'vessel/surface',
+    id: 'editor.workspace',
+    name: 'Code workspace',
+    description: 'Focused code editing over the runtime-bound workspace.',
+    label: 'Code workspace',
+    surfaceKind: 'component',
+    owner: { packageName: '@vibesdotdev/editor/svelte' },
+    contract: {
+        apiVersion: '1.0.0',
+        stateSchemaId: 'editor.workspace.state',
+        stateSchemaVersion: 1,
+        stateSchema: editorWorkspaceVesselStateSchema
+    },
+    activation: 'on-open',
+    execution: 'host-trusted',
+    requiredCapabilities: [
+        {
+            id: 'workspace/environment',
+            reason: 'Give Code one host-bound, rooted workspace authority.'
+        },
+        {
+            id: 'runtime/client',
+            selectorId: 'editor',
+            reason: 'Open and publish editor transactions through the registered client.'
+        }
+    ],
+    optionalCapabilities: [],
+    primaryAudience: 'workspace-user',
+    secondaryAudiences: ['host-integrator'],
+    technicalLanguagePolicy: 'hide',
+    promotionGate: 'Real browser proof opens, edits, and publishes a workspace document.'
+});
+export const editorSvelteVesselPlugin = createRuntimePlugin({
+    id: '@vibesdotdev/editor/svelte/vessel',
+    name: 'Editor Svelte Vessel Surface',
+    description: 'Owner-declared Code workspace contribution for Vessel hosts.',
+    dependencies: ['vessel'],
+    descriptors: [
+        editorWorkspaceVesselAppDescriptor,
+        editorWorkspaceVesselSurfaceDescriptor,
+        editorWorkspaceVesselReadinessDescriptor,
+        editorWorkspaceVesselSetupDescriptor
+    ],
+    loaders: [
+        loader(editorWorkspaceVesselSurfaceDescriptor.id, { kind: 'vessel/surface', scope: 'browser' }, async () => {
+            const module = await import('./components/EditorWorkspace.svelte');
+            return { impl: module.default };
+        })
+    ]
+});
+export default editorSvelteVesselPlugin;

package/dist/svelte/editor-workspace-state.d.ts

@@ -0,0 +1,8 @@
+import * as z from 'zod/v4';
+/** Compact, component-free route state accepted by the Editor-owned Code surface. */
+export declare const editorWorkspaceVesselStateSchema: z.ZodObject<{
+    adapterId: z.ZodOptional<z.ZodString>;
+    initialPath: z.ZodDefault<z.ZodString>;
+    mode: z.ZodDefault<z.ZodLiteral<"code">>;
+}, z.core.$strict>;
+//# sourceMappingURL=editor-workspace-state.d.ts.map

package/dist/svelte/editor-workspace-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-workspace-state.d.ts","sourceRoot":"","sources":["../../src/svelte/editor-workspace-state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,qFAAqF;AACrF,eAAO,MAAM,gCAAgC;;;;kBAGnC,CAAC"}

package/dist/svelte/editor-workspace-state.js

@@ -0,0 +1,7 @@
+import { filesystemWorkspaceVesselStateSchema } from '@vibesdotdev/filesystem/svelte/filesystem-workspace';
+import * as z from 'zod/v4';
+/** Compact, component-free route state accepted by the Editor-owned Code surface. */
+export const editorWorkspaceVesselStateSchema = filesystemWorkspaceVesselStateSchema
+    .omit({ mode: true })
+    .extend({ mode: z.literal('code').default('code') })
+    .strict();

package/dist/svelte/editor-workspace.d.ts

@@ -0,0 +1,41 @@
+import type { EditorClient } from '@vibesdotdev/editor';
+import type { EditorControllerState } from './controller.ts';
+import { editorExitDisposition } from './editor-exit.ts';
+export { editorWorkspaceVesselStateSchema } from './editor-workspace-state.ts';
+/**
+ * The one owner bridge from Filesystem navigation into Editor transactions.
+ * Hosts mount EditorWorkspace instead of rebuilding this composition.
+ */
+export declare const editorWorkspaceEditorSurface: {
+    Editor: import("svelte").Component<{
+        controller?: import("./controller.ts").EditorController;
+        transaction?: import("@vibesdotdev/editor").EditorTransaction;
+        client?: EditorClient;
+        context?: import("@vibesdotdev/editor").EditorContextRef;
+        document?: import("@vibesdotdev/workspace-schemas/document").WorkspaceDocumentRef;
+        documentId?: string;
+        variant?: import("./controller.ts").EditorSurfaceVariant;
+        reviewOnly?: boolean;
+        narrow?: boolean;
+        height?: string | number;
+        ariaLabel?: string;
+        class?: string;
+        oncontrollerready?: (controller: import("./controller.ts").EditorController) => void;
+        onstatechange?: (state: EditorControllerState) => void;
+        onoperationerror?: (error: import("@vibesdotdev/kernel").CaughtFailure) => void;
+        contextActionClient?: import("./editor-context-actions.ts").EditorContextActionClient;
+    }, {}, "">;
+    UnsupportedState: import("svelte").Component<{
+        title?: string;
+        reason: string;
+        code?: string;
+    }, {}, "">;
+    projectState(state: EditorControllerState): {
+        draft: string;
+        dirty: boolean;
+        phase: import("./controller.ts").EditorControllerPhase;
+        readOnly: boolean;
+    };
+    exitDisposition: typeof editorExitDisposition;
+};
+//# sourceMappingURL=editor-workspace.d.ts.map

package/dist/svelte/editor-workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-workspace.d.ts","sourceRoot":"","sources":["../../src/svelte/editor-workspace.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAIzD,OAAO,EAAE,gCAAgC,EAAE,MAAM,6BAA6B,CAAC;AAE/E;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;wBAGpB,qBAAqB;;;;;;;CASuC,CAAC"}

package/dist/svelte/editor-workspace.js

@@ -0,0 +1,21 @@
+import { editorExitDisposition } from "./editor-exit.js";
+import EditorUnsupportedState from './components/EditorUnsupportedState.svelte';
+import VibesEditor from './components/VibesEditor.svelte';
+export { editorWorkspaceVesselStateSchema } from "./editor-workspace-state.js";
+/**
+ * The one owner bridge from Filesystem navigation into Editor transactions.
+ * Hosts mount EditorWorkspace instead of rebuilding this composition.
+ */
+export const editorWorkspaceEditorSurface = {
+    Editor: VibesEditor,
+    UnsupportedState: EditorUnsupportedState,
+    projectState(state) {
+        return {
+            draft: state.draft,
+            dirty: state.dirty,
+            phase: state.phase,
+            readOnly: state.readOnly
+        };
+    },
+    exitDisposition: editorExitDisposition
+};

package/dist/svelte/index.d.ts

@@ -0,0 +1,16 @@
+export { EditorControllerError, EditorControllerErrorReasonSchema, type EditorControllerErrorReason, createEditorController, invokeEditorSurfaceObserver, reportEditorSurfaceObserverFailure, type EditorController, type EditorControllerListener, type EditorControllerOptions, type EditorControllerPhase, type EditorControllerState, type EditorSelection, type EditorSurfaceFailureFallback, type EditorSurfaceFailureReporter, type EditorSurfaceObserverBoundary, type EditorSurfaceObserverFailure, type EditorSurfaceVariant, type EditorPreviewState } from './controller.ts';
+export { editorExitDisposition, type EditorExitDisposition } from './editor-exit.ts';
+export { createEditorContextActionSearch, executableEditorContextActions, type EditorContextActionClient } from './editor-context-actions.ts';
+export { default as VibesEditor } from './components/VibesEditor.svelte';
+export { default as EditorResourceTrail } from './components/EditorResourceTrail.svelte';
+export { default as EditorCapabilityRow } from './components/EditorCapabilityRow.svelte';
+export { default as EditorDocumentPane } from './components/EditorDocumentPane.svelte';
+export { default as EditorConflictState } from './components/EditorConflictState.svelte';
+export { default as EditorUnsupportedState } from './components/EditorUnsupportedState.svelte';
+export { default as EditorWorkspace } from './components/EditorWorkspace.svelte';
+export { default as EditorAgentSpotlight } from './components/EditorAgentSpotlight.svelte';
+export { default as EditorProposalReview } from './components/EditorProposalReview.svelte';
+export { default as EditorPreviewPane } from './components/EditorPreviewPane.svelte';
+export { editorWorkspaceEditorSurface } from './editor-workspace.ts';
+export { editorWorkspaceVesselStateSchema } from './editor-workspace-state.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/svelte/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svelte/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,qBAAqB,EACrB,iCAAiC,EACjC,KAAK,2BAA2B,EAChC,sBAAsB,EACtB,2BAA2B,EAC3B,kCAAkC,EAClC,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAClC,KAAK,4BAA4B,EACjC,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,qBAAqB,EAAE,KAAK,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACrF,OAAO,EACN,+BAA+B,EAC/B,8BAA8B,EAC9B,KAAK,yBAAyB,EAC9B,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AACzF,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AACzF,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AACzF,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AAC/F,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAC3F,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAC3F,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AACrF,OAAO,EACN,4BAA4B,EAC5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,gCAAgC,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/svelte/index.js

@@ -0,0 +1,15 @@
+export { EditorControllerError, EditorControllerErrorReasonSchema, createEditorController, invokeEditorSurfaceObserver, reportEditorSurfaceObserverFailure } from "./controller.js";
+export { editorExitDisposition } from "./editor-exit.js";
+export { createEditorContextActionSearch, executableEditorContextActions } from "./editor-context-actions.js";
+export { default as VibesEditor } from './components/VibesEditor.svelte';
+export { default as EditorResourceTrail } from './components/EditorResourceTrail.svelte';
+export { default as EditorCapabilityRow } from './components/EditorCapabilityRow.svelte';
+export { default as EditorDocumentPane } from './components/EditorDocumentPane.svelte';
+export { default as EditorConflictState } from './components/EditorConflictState.svelte';
+export { default as EditorUnsupportedState } from './components/EditorUnsupportedState.svelte';
+export { default as EditorWorkspace } from './components/EditorWorkspace.svelte';
+export { default as EditorAgentSpotlight } from './components/EditorAgentSpotlight.svelte';
+export { default as EditorProposalReview } from './components/EditorProposalReview.svelte';
+export { default as EditorPreviewPane } from './components/EditorPreviewPane.svelte';
+export { editorWorkspaceEditorSurface } from "./editor-workspace.js";
+export { editorWorkspaceVesselStateSchema } from "./editor-workspace-state.js";

package/dist/svelte/styles.css

@@ -0,0 +1 @@
+@source './';

package/dist/svelte/surface-reporter.d.ts

@@ -0,0 +1,13 @@
+import { type RuntimeRef } from '@vibesdotdev/kernel';
+import type { EditorSurfaceFailureReporter } from './controller.ts';
+/** Where a runtime comes from: the store `getRuntimeSvelteContext()` returns. */
+export interface RuntimeSource {
+    load(): Promise<RuntimeRef>;
+}
+/**
+ * A reporter that logs `error` entries on the runtime `source` loads. A source
+ * that never loaded has no runtime to bind a logger to, so the entry is
+ * dropped; the store records that failed load on its own `error`.
+ */
+export declare function surfaceReporterOn(source: RuntimeSource, id: string): EditorSurfaceFailureReporter;
+//# sourceMappingURL=surface-reporter.d.ts.map

package/dist/svelte/surface-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-reporter.d.ts","sourceRoot":"","sources":["../../src/svelte/surface-reporter.ts"],"names":[],"mappings":"AAMA,OAAO,EAAoD,KAAK,UAAU,EAAyB,MAAM,qBAAqB,CAAC;AAC/H,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAEpE,iFAAiF;AACjF,MAAM,WAAW,aAAa;IAC7B,IAAI,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;CAC5B;AAID;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,GAAG,4BAA4B,CAkBjG"}