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

package/dist/svelte/controller.d.ts

@@ -0,0 +1,86 @@
+import { type CaughtFailure, type Settled } from '@vibesdotdev/kernel';
+export { EditorControllerErrorReasonSchema, type EditorControllerErrorReason } from '../schemas/editor-surface.ts';
+import type { Logger } from '@vibesdotdev/logging';
+import type { EditorAgentPresence, EditorProposal, EditorPublishResult, EditorTransaction, EditorTransactionSnapshot } from '@vibesdotdev/editor';
+import type { WorkspaceDocumentSnapshot } from '@vibesdotdev/workspace-schemas/document';
+export type EditorSurfaceFailureReporter = Pick<Logger, 'error'>;
+export type EditorSurfaceFailureFallback = (message: string, context: EditorSurfaceObserverFailure & {
+    reporterCause: CaughtFailure;
+}) => void;
+export type EditorSurfaceObserverBoundary = 'controller.listener.initial' | 'controller.listener.update' | 'host.controller-ready' | 'host.state-change' | 'host.operation-error';
+export interface EditorSurfaceObserverFailure {
+    readonly boundary: EditorSurfaceObserverBoundary;
+    readonly transactionId?: string;
+    readonly resourceUri?: string;
+    readonly phase?: EditorControllerPhase;
+    readonly cause: unknown;
+}
+export declare function reportEditorSurfaceObserverFailure(failure: EditorSurfaceObserverFailure, reporter: EditorSurfaceFailureReporter, fallback?: EditorSurfaceFailureFallback): Settled<void>;
+export declare function invokeEditorSurfaceObserver<T>(callback: ((value: T) => void) | undefined, value: T, context: Omit<EditorSurfaceObserverFailure, 'cause'>, reporter: EditorSurfaceFailureReporter, fallback?: EditorSurfaceFailureFallback): void;
+export type EditorSurfaceVariant = 'embedded' | 'focused';
+export type EditorControllerPhase = 'clean' | 'dirty' | 'publishing' | 'reloading' | 'conflict' | 'error' | 'disposed';
+export interface EditorSelection {
+    readonly anchorOffset: number;
+    readonly headOffset: number;
+}
+export interface EditorControllerOptions {
+    variant?: EditorSurfaceVariant;
+    reviewOnly?: boolean;
+    narrow?: boolean;
+    /** Where observer failures are reported: the host binds it to the runtime the surface was handed. */
+    reporter: EditorSurfaceFailureReporter;
+}
+export interface EditorPreviewState {
+    readonly open: boolean;
+    readonly mode: 'webapp' | 'applet' | 'genui';
+    readonly targetUri?: string;
+}
+export interface EditorControllerState {
+    readonly transactionId: string;
+    readonly resourceUri: string;
+    readonly base: WorkspaceDocumentSnapshot;
+    readonly draft: string;
+    readonly dirty: boolean;
+    readonly phase: EditorControllerPhase;
+    readonly conflict?: WorkspaceDocumentSnapshot;
+    readonly ownerCurrent?: WorkspaceDocumentSnapshot;
+    readonly focused: boolean;
+    readonly selection?: EditorSelection;
+    readonly variant: EditorSurfaceVariant;
+    readonly reviewOnly: boolean;
+    readonly narrow: boolean;
+    readonly readOnly: boolean;
+    readonly readOnlyReason?: string;
+    readonly error?: string;
+    readonly disposed: boolean;
+    readonly proposals: readonly EditorProposal[];
+    readonly agentPresences: readonly EditorAgentPresence[];
+    readonly followAgent: boolean;
+    readonly previewState: EditorPreviewState;
+}
+export type EditorControllerListener = (state: EditorControllerState) => void;
+export { CapabilityError as EditorControllerError } from '@vibesdotdev/kernel';
+export interface EditorController {
+    readonly transaction: EditorTransaction;
+    state(): EditorControllerState;
+    subscribe(listener: EditorControllerListener): () => void;
+    setDraft(draft: string): void;
+    setFocused(focused: boolean): void;
+    setSelection(selection: EditorSelection | undefined): void;
+    setVariant(variant: EditorSurfaceVariant): void;
+    setReviewMode(options: {
+        reviewOnly: boolean;
+        narrow: boolean;
+    }): void;
+    publish(): Promise<EditorPublishResult>;
+    reload(): Promise<EditorTransactionSnapshot>;
+    keepDraft(): void;
+    clearError(): void;
+    dispose(): void;
+    approveProposal(proposalId: string): Promise<void>;
+    rejectProposal(proposalId: string, reason?: string): void;
+    setFollowAgent(follow: boolean): void;
+    togglePreview(open?: boolean, mode?: 'webapp' | 'applet' | 'genui', targetUri?: string): void;
+}
+export declare function createEditorController(transaction: EditorTransaction, options: EditorControllerOptions): EditorController;
+//# sourceMappingURL=controller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/svelte/controller.ts"],"names":[],"mappings":"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"}

package/dist/svelte/controller.js

@@ -0,0 +1,438 @@
+import { CapabilityError, CaughtFailureSchema, settleNow } from '@vibesdotdev/kernel';
+export { EditorControllerErrorReasonSchema } from "../schemas/editor-surface.js";
+export function reportEditorSurfaceObserverFailure(failure, reporter, fallback) {
+    const reported = settleNow(() => reporter.error('Editor surface observer failed', failure));
+    if (reported.ok || !fallback)
+        return reported;
+    return settleNow(() => fallback('Editor surface observer failure reporting failed', {
+        ...failure, reporterCause: reported.cause
+    }));
+}
+export function invokeEditorSurfaceObserver(callback, value, context, reporter, fallback) {
+    if (!callback)
+        return;
+    const delivered = settleNow(() => callback(value));
+    if (!delivered.ok)
+        reportEditorSurfaceObserverFailure({ ...context, cause: delivered.cause }, reporter, fallback);
+}
+export { CapabilityError as EditorControllerError } from '@vibesdotdev/kernel';
+function controllerRefusal(reason) {
+    const codes = { disposed: 'UNAVAILABLE', 'read-only': 'PERMISSION_DENIED', busy: 'CONFLICT', 'clean-conflict': 'CONFLICT' };
+    return new CapabilityError('Editor surface refused.', codes[reason], { reason });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : 'The editor operation failed.';
+}
+function initialReadOnlyReason(options, base) {
+    if (options.narrow)
+        return 'Editing is unavailable in the narrow review layout.';
+    if (options.reviewOnly)
+        return 'This surface was opened for review.';
+    if (!base.authority.canWrite) {
+        return base.authority.reason ?? 'The document owner did not grant write authority.';
+    }
+    return undefined;
+}
+function freezeState(state) {
+    return Object.freeze({
+        ...state,
+        selection: state.selection ? Object.freeze({ ...state.selection }) : undefined,
+        proposals: Object.freeze([...state.proposals]),
+        agentPresences: Object.freeze([...state.agentPresences]),
+        previewState: Object.freeze({ ...state.previewState })
+    });
+}
+class EditorControllerImpl {
+    transaction;
+    #current;
+    #listeners = new Set();
+    #unsubscribeTransaction;
+    #publishingDraft;
+    #reloadingDraft;
+    #activeTransactionOperation;
+    #reporter;
+    constructor(transaction, options) {
+        this.transaction = transaction;
+        this.#reporter = options.reporter;
+        const resolvedOptions = {
+            variant: options.variant ?? 'embedded',
+            reviewOnly: options.reviewOnly ?? false,
+            narrow: options.narrow ?? false
+        };
+        const snapshot = transaction.snapshot();
+        const readOnlyReason = initialReadOnlyReason(resolvedOptions, snapshot.base);
+        const initialProposals = transaction.getProposals ? transaction.getProposals() : [];
+        const initialAgentPresences = transaction.getAgentPresences ? transaction.getAgentPresences() : [];
+        this.#current = freezeState({
+            transactionId: transaction.id,
+            resourceUri: transaction.resourceUri,
+            base: snapshot.base,
+            draft: snapshot.base.text,
+            dirty: false,
+            phase: 'clean',
+            focused: false,
+            variant: resolvedOptions.variant,
+            reviewOnly: resolvedOptions.reviewOnly,
+            narrow: resolvedOptions.narrow,
+            readOnly: Boolean(readOnlyReason),
+            readOnlyReason,
+            disposed: false,
+            proposals: initialProposals,
+            agentPresences: initialAgentPresences,
+            followAgent: false,
+            previewState: {
+                open: false,
+                mode: 'webapp'
+            }
+        });
+        this.#unsubscribeTransaction = transaction.subscribe((event) => this.#onTransactionEvent(event));
+    }
+    state() {
+        return this.#current;
+    }
+    subscribe(listener) {
+        this.#assertActive();
+        this.#listeners.add(listener);
+        invokeEditorSurfaceObserver(listener, this.#current, {
+            boundary: 'controller.listener.initial',
+            transactionId: this.#current.transactionId,
+            resourceUri: this.#current.resourceUri,
+            phase: this.#current.phase
+        }, this.#reporter);
+        return () => this.#listeners.delete(listener);
+    }
+    setDraft(draft) {
+        this.#assertActive();
+        if (draft === this.#current.draft)
+            return;
+        this.#assertEditable();
+        const dirty = draft !== this.#current.base.text;
+        this.#patch({
+            draft,
+            dirty,
+            phase: this.#publishingDraft !== undefined || this.#activeTransactionOperation === 'publish'
+                ? 'publishing'
+                : this.#reloadingDraft !== undefined || this.#activeTransactionOperation === 'reload'
+                    ? 'reloading'
+                    : this.#current.conflict
+                        ? 'conflict'
+                        : dirty
+                            ? 'dirty'
+                            : 'clean',
+            error: undefined
+        });
+    }
+    setFocused(focused) {
+        this.#assertActive();
+        if (focused === this.#current.focused)
+            return;
+        this.#patch({ focused });
+    }
+    setSelection(selection) {
+        this.#assertActive();
+        if (selection) {
+            if (!Number.isInteger(selection.anchorOffset) || selection.anchorOffset < 0) {
+                throw new RangeError('Editor selection anchorOffset must be a non-negative integer.');
+            }
+            if (!Number.isInteger(selection.headOffset) || selection.headOffset < 0) {
+                throw new RangeError('Editor selection headOffset must be a non-negative integer.');
+            }
+        }
+        this.#patch({ selection });
+    }
+    setVariant(variant) {
+        this.#assertActive();
+        if (variant === this.#current.variant)
+            return;
+        this.#patch({ variant });
+    }
+    setReviewMode(options) {
+        this.#assertActive();
+        if (options.reviewOnly === this.#current.reviewOnly &&
+            options.narrow === this.#current.narrow) {
+            return;
+        }
+        this.#patch({ reviewOnly: options.reviewOnly, narrow: options.narrow });
+    }
+    async publish() {
+        this.#assertEditable();
+        this.#assertIdle();
+        const submittedDraft = this.#current.draft;
+        this.#publishingDraft = submittedDraft;
+        this.#patch({ phase: 'publishing', error: undefined });
+        try {
+            const result = await this.transaction.publish(submittedDraft);
+            if (result.status === 'published') {
+                this.#acceptPublishedSnapshot(result.snapshot, submittedDraft);
+            }
+            else {
+                this.#patch({
+                    phase: 'conflict',
+                    conflict: result.current,
+                    ownerCurrent: result.current,
+                    dirty: this.#current.draft !== this.#current.base.text
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            this.#patch({ phase: 'error', error: errorMessage(CaughtFailureSchema.parse(error)) });
+            throw error;
+        }
+        finally {
+            this.#publishingDraft = undefined;
+        }
+    }
+    async reload() {
+        this.#assertActive();
+        this.#assertIdle();
+        const requestedDraft = this.#current.draft;
+        this.#reloadingDraft = requestedDraft;
+        this.#patch({ phase: 'reloading', error: undefined });
+        try {
+            const result = await this.transaction.reload();
+            this.#acceptReloadedSnapshot(result.snapshot, requestedDraft);
+            return result.snapshot;
+        }
+        catch (error) {
+            this.#patch({ phase: 'error', error: errorMessage(CaughtFailureSchema.parse(error)) });
+            throw error;
+        }
+        finally {
+            this.#reloadingDraft = undefined;
+        }
+    }
+    keepDraft() {
+        this.#assertActive();
+        const dirty = this.#current.draft !== this.#current.base.text;
+        if (!this.#current.conflict)
+            return;
+        if (!dirty) {
+            throw controllerRefusal('clean-conflict');
+        }
+        this.#patch({
+            conflict: undefined,
+            ownerCurrent: undefined,
+            dirty,
+            phase: dirty ? 'dirty' : 'clean',
+            error: undefined
+        });
+    }
+    clearError() {
+        this.#assertActive();
+        const dirty = this.#current.draft !== this.#current.base.text;
+        this.#patch({
+            error: undefined,
+            phase: this.#current.conflict ? 'conflict' : dirty ? 'dirty' : 'clean'
+        });
+    }
+    dispose() {
+        if (this.#current.disposed)
+            return;
+        this.#unsubscribeTransaction?.();
+        this.#unsubscribeTransaction = undefined;
+        this.#publishingDraft = undefined;
+        this.#reloadingDraft = undefined;
+        this.#activeTransactionOperation = undefined;
+        this.#patch({
+            phase: 'disposed',
+            focused: false,
+            selection: undefined,
+            disposed: true
+        });
+        this.#listeners.clear();
+    }
+    async approveProposal(proposalId) {
+        this.#assertActive();
+        const preApproveDraft = this.#current.draft;
+        const result = await this.transaction.approveProposal(proposalId);
+        const proposals = this.transaction.getProposals ? this.transaction.getProposals() : [];
+        if (result.status === 'published') {
+            this.#acceptPublishedSnapshot(result.snapshot, preApproveDraft);
+            this.#patch({ proposals });
+        }
+        else {
+            this.#patch({
+                proposals,
+                phase: 'conflict',
+                conflict: result.current,
+                ownerCurrent: result.current,
+                dirty: this.#current.draft !== this.#current.base.text
+            });
+        }
+    }
+    rejectProposal(proposalId, reason) {
+        this.#assertActive();
+        this.transaction.rejectProposal(proposalId, reason);
+        const proposals = this.transaction.getProposals ? this.transaction.getProposals() : [];
+        this.#patch({ proposals });
+    }
+    setFollowAgent(follow) {
+        this.#assertActive();
+        if (this.#current.followAgent === follow)
+            return;
+        this.#patch({ followAgent: follow });
+    }
+    togglePreview(open, mode, targetUri) {
+        this.#assertActive();
+        const isOpen = open ?? !this.#current.previewState.open;
+        const previewMode = mode ?? this.#current.previewState.mode;
+        const currentUri = targetUri ?? this.#current.previewState.targetUri;
+        this.#patch({
+            previewState: {
+                open: isOpen,
+                mode: previewMode,
+                targetUri: currentUri
+            }
+        });
+    }
+    #acceptSnapshot(snapshot) {
+        this.#patch({
+            base: snapshot.base,
+            draft: snapshot.base.text,
+            dirty: false,
+            phase: 'clean',
+            conflict: undefined,
+            ownerCurrent: undefined,
+            error: undefined
+        });
+    }
+    #acceptPublishedSnapshot(snapshot, submittedDraft) {
+        if (this.#current.draft === submittedDraft) {
+            this.#acceptSnapshot(snapshot);
+            return;
+        }
+        const dirty = this.#current.draft !== snapshot.base.text;
+        this.#patch({
+            base: snapshot.base,
+            dirty,
+            phase: dirty ? 'dirty' : 'clean',
+            conflict: undefined,
+            ownerCurrent: undefined,
+            error: undefined
+        });
+    }
+    #acceptReloadedSnapshot(snapshot, requestedDraft) {
+        if (this.#current.draft === requestedDraft) {
+            this.#acceptSnapshot(snapshot);
+            return;
+        }
+        const dirty = this.#current.draft !== snapshot.base.text;
+        this.#patch({
+            base: snapshot.base,
+            dirty,
+            phase: dirty ? 'dirty' : 'clean',
+            conflict: undefined,
+            ownerCurrent: undefined,
+            error: undefined
+        });
+    }
+    #onTransactionEvent(event) {
+        if (this.#current.disposed)
+            return;
+        switch (event.type) {
+            case 'operation.started':
+                this.#activeTransactionOperation = event.operation;
+                this.#patch({
+                    phase: event.operation === 'publish' ? 'publishing' : 'reloading',
+                    error: undefined
+                });
+                break;
+            case 'reloaded':
+                this.#activeTransactionOperation = undefined;
+                this.#acceptReloadedSnapshot(event.snapshot, this.#reloadingDraft ?? event.snapshot.base.text);
+                break;
+            case 'published':
+                this.#activeTransactionOperation = undefined;
+                this.#acceptPublishedSnapshot(event.snapshot, this.#publishingDraft ?? event.snapshot.base.text);
+                break;
+            case 'conflict':
+                this.#activeTransactionOperation = undefined;
+                this.#patch({
+                    phase: 'conflict',
+                    conflict: event.current,
+                    ownerCurrent: event.current,
+                    dirty: this.#current.draft !== this.#current.base.text
+                });
+                break;
+            case 'owner.changed':
+                this.#patch({
+                    phase: 'conflict',
+                    conflict: event.current,
+                    ownerCurrent: event.current,
+                    dirty: this.#current.draft !== this.#current.base.text
+                });
+                break;
+            case 'owner.deleted':
+            case 'owner.unavailable':
+                this.#patch({ phase: 'error', error: event.reason });
+                break;
+            case 'operation.failed':
+                this.#activeTransactionOperation = undefined;
+                this.#patch({ phase: 'error', error: event.message });
+                break;
+            case 'agent.presence': {
+                const agentPresences = this.transaction.getAgentPresences ? this.transaction.getAgentPresences() : [];
+                this.#patch({ agentPresences });
+                break;
+            }
+            case 'proposal.created':
+            case 'proposal.resolved': {
+                const proposals = this.transaction.getProposals ? this.transaction.getProposals() : [];
+                this.#patch({ proposals });
+                break;
+            }
+            case 'disposed':
+                this.dispose();
+                break;
+        }
+    }
+    #assertActive() {
+        if (this.#current.disposed || this.transaction.disposed) {
+            throw controllerRefusal('disposed');
+        }
+    }
+    #assertEditable() {
+        this.#assertActive();
+        if (this.#current.readOnly) {
+            throw controllerRefusal('read-only');
+        }
+    }
+    #assertIdle() {
+        if (this.#publishingDraft !== undefined ||
+            this.#reloadingDraft !== undefined ||
+            this.#activeTransactionOperation !== undefined ||
+            this.#current.phase === 'publishing' ||
+            this.#current.phase === 'reloading') {
+            throw controllerRefusal('busy');
+        }
+    }
+    #patch(patch) {
+        const next = { ...this.#current, ...patch };
+        const resolvedOptions = {
+            variant: next.variant,
+            reviewOnly: next.reviewOnly,
+            narrow: next.narrow
+        };
+        const readOnlyReason = initialReadOnlyReason(resolvedOptions, next.base);
+        this.#current = freezeState({
+            ...next,
+            readOnly: Boolean(readOnlyReason),
+            readOnlyReason
+        });
+        for (const listener of Array.from(this.#listeners)) {
+            invokeEditorSurfaceObserver(listener, this.#current, {
+                boundary: 'controller.listener.update',
+                transactionId: this.#current.transactionId,
+                resourceUri: this.#current.resourceUri,
+                phase: this.#current.phase
+            }, this.#reporter);
+        }
+    }
+}
+export function createEditorController(transaction, options) {
+    if (transaction.disposed) {
+        throw controllerRefusal('disposed');
+    }
+    return new EditorControllerImpl(transaction, options);
+}

package/dist/svelte/editor-context-actions.d.ts

@@ -0,0 +1,7 @@
+import type { CommandPaletteClient, SearchOptions } from '@vibesdotdev/command-palette';
+import type { CommandPaletteResult, FederatedResult } from '@vibesdotdev/command-palette/schemas';
+import type { EditorControllerState } from './controller.ts';
+export type EditorContextActionClient = Pick<CommandPaletteClient, 'search'>;
+export declare function createEditorContextActionSearch(state: EditorControllerState): SearchOptions;
+export declare function executableEditorContextActions(result: FederatedResult): CommandPaletteResult[];
+//# sourceMappingURL=editor-context-actions.d.ts.map

package/dist/svelte/editor-context-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-context-actions.d.ts","sourceRoot":"","sources":["../../src/svelte/editor-context-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AACxF,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAClG,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAC,CAAC;AAE7E,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,qBAAqB,GAAG,aAAa,CAoC3F;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,eAAe,GAAG,oBAAoB,EAAE,CAI9F"}

package/dist/svelte/editor-context-actions.js

@@ -0,0 +1,41 @@
+export function createEditorContextActionSearch(state) {
+    const selection = state.selection
+        ? {
+            anchorOffset: state.selection.anchorOffset,
+            headOffset: state.selection.headOffset
+        }
+        : null;
+    return {
+        query: '',
+        surfaceId: 'web',
+        placement: 'context-menu',
+        target: {
+            kind: 'editor/transaction',
+            id: state.transactionId,
+            label: state.base.ref.path,
+            uri: state.base.uri,
+            data: {
+                workspaceSessionId: state.base.ref.workspaceSessionId,
+                path: state.base.ref.path
+            }
+        },
+        data: {
+            document: {
+                workspaceSessionId: state.base.ref.workspaceSessionId,
+                path: state.base.ref.path,
+                resourceUri: state.base.uri
+            },
+            selection,
+            editor: {
+                transactionId: state.transactionId,
+                dirty: state.dirty,
+                readOnly: state.readOnly
+            }
+        }
+    };
+}
+export function executableEditorContextActions(result) {
+    return result.groups
+        .flatMap((group) => group.items)
+        .filter((item) => item.action.type === 'execute');
+}

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

@@ -0,0 +1,11 @@
+import type { EditorControllerState } from './controller.ts';
+/**
+ * Host-neutral classification for any action that would release an editor.
+ *
+ * The embedding surface owns the pending navigation or close intent. This
+ * helper keeps chat, Files, Vessel, and standalone hosts from inventing subtly
+ * different draft-loss rules.
+ */
+export type EditorExitDisposition = 'safe' | 'dirty' | 'busy' | 'conflict';
+export declare function editorExitDisposition(state: Pick<EditorControllerState, 'dirty' | 'phase' | 'conflict' | 'disposed'>): EditorExitDisposition;
+//# sourceMappingURL=editor-exit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editor-exit.d.ts","sourceRoot":"","sources":["../../src/svelte/editor-exit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,CAAC;AAE3E,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,IAAI,CAAC,qBAAqB,EAAE,OAAO,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,CAAC,GAC7E,qBAAqB,CAMvB"}

package/dist/svelte/editor-exit.js

@@ -0,0 +1,11 @@
+export function editorExitDisposition(state) {
+    if (state.disposed)
+        return 'safe';
+    if (state.phase === 'publishing' || state.phase === 'reloading')
+        return 'busy';
+    if (state.phase === 'conflict' || state.conflict)
+        return 'conflict';
+    if (state.dirty)
+        return 'dirty';
+    return 'safe';
+}

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

@@ -0,0 +1,19 @@
+import type { EditorControllerPhase } from './controller.ts';
+export type EditorHumanStatusLabel = 'Saved' | 'Unsaved changes' | 'Saving…' | 'Newer version available' | 'View only';
+export type EditorHumanStatusTone = 'neutral' | 'attention' | 'danger';
+export interface EditorHumanStatus {
+    readonly label: EditorHumanStatusLabel;
+    readonly tone: EditorHumanStatusTone;
+}
+export interface EditorHumanStatusState {
+    readonly phase: EditorControllerPhase;
+    readonly dirty: boolean;
+    readonly readOnly: boolean;
+    readonly conflict?: unknown;
+}
+/**
+ * Compresses controller mechanics into the one document fact a person needs
+ * beside Save. Conflict and an in-flight save outrank projection details.
+ */
+export declare function editorHumanStatus(state: EditorHumanStatusState): EditorHumanStatus;
+//# sourceMappingURL=editor-status.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editor-status.d.ts","sourceRoot":"","sources":["../../src/svelte/editor-status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D,MAAM,MAAM,sBAAsB,GACjC,OAAO,GAAG,iBAAiB,GAAG,SAAS,GAAG,yBAAyB,GAAG,WAAW,CAAC;AAEnF,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;AAEvE,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC;CACrC;AAED,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,iBAAiB,CAclF"}

package/dist/svelte/editor-status.js

@@ -0,0 +1,19 @@
+/**
+ * Compresses controller mechanics into the one document fact a person needs
+ * beside Save. Conflict and an in-flight save outrank projection details.
+ */
+export function editorHumanStatus(state) {
+    if (state.phase === 'publishing') {
+        return { label: 'Saving…', tone: 'attention' };
+    }
+    if (state.conflict !== undefined) {
+        return { label: 'Newer version available', tone: 'danger' };
+    }
+    if (state.readOnly) {
+        return { label: 'View only', tone: 'neutral' };
+    }
+    if (state.dirty) {
+        return { label: 'Unsaved changes', tone: 'attention' };
+    }
+    return { label: 'Saved', tone: 'neutral' };
+}