nudge-ui 0.2.4 → 0.2.6

package/dist/inspector/conformance/borderCases.js

@@ -21,11 +21,6 @@ function structuredProps(authored, structure, properties) {
         },
     ]));
 }
-/**
- * Framework-neutral border corpus. Covers shorthand decomposition into width,
- * style, and color longhands (including omitted CSS initials), side-specific
- * shorthands, token attribution, border-radius, and true raw fallbacks.
- */
 export const BORDER_CASES = [
     {
         id: "border-shorthand-literal",

package/dist/inspector/conformance/colorCases.d.ts

@@ -1,8 +1,2 @@
 import type { ConformanceFixture } from "./fixture.js";
-/**
- * Framework-neutral color corpus covering `color` and `background-color`.
- * Each fixture asserts authored CSS values and capability against the
- * inspector's resolution pipeline. The gallery lets a human exercise the
- * same cases through the real inspector UI.
- */
 export declare const COLOR_CASES: ConformanceFixture[];

package/dist/inspector/conformance/colorCases.js

@@ -14,12 +14,6 @@ const COLOR_ACCENT = token("--color-accent", "oklch(63% .2 25)", "fixtures/color
 const COLOR_PRIMARY = token("--color-primary", "#2563eb", "fixtures/color.css:7");
 const COLOR_DANGER = token("--color-danger", "#dc2626", "fixtures/color.css:8");
 const OPACITY_MUTED = token("--opacity-muted", "0.35", "fixtures/color.css:9");
-/**
- * Framework-neutral color corpus covering `color` and `background-color`.
- * Each fixture asserts authored CSS values and capability against the
- * inspector's resolution pipeline. The gallery lets a human exercise the
- * same cases through the real inspector UI.
- */
 export const COLOR_CASES = [
     {
         id: "color-named-keywords",

package/dist/inspector/conformance/fixture.d.ts

@@ -59,10 +59,6 @@ export interface ConformanceResult {
     preview: PreviewResult | null;
     cleanup(): void;
 }
-/**
- * Mounts one data-led fixture and runs it through the same CSSOM resolver used
- * by the inspector. The caller owns assertions; this module only owns setup,
- * teardown, and the public inspection result.
- */
+/** Runs a fixture through the same CSSOM resolver the inspector uses; the caller owns assertions. */
 export declare function runConformanceFixture(fixture: ConformanceFixture, doc?: Document): ConformanceResult;
 export declare function assertConformanceFixture(result: ConformanceResult, fixture: ConformanceFixture): string[];

package/dist/inspector/conformance/fixture.js

@@ -1,11 +1,7 @@
 import { applyRules, verifyPreview } from "../projection/managedStylesheet.js";
 import { projectInspectorValues } from "../spacing/projection.js";
 import { createBrowserCssInspection } from "../inspection/browserCssInspection.js";
-/**
- * Mounts one data-led fixture and runs it through the same CSSOM resolver used
- * by the inspector. The caller owns assertions; this module only owns setup,
- * teardown, and the public inspection result.
- */
+/** Runs a fixture through the same CSSOM resolver the inspector uses; the caller owns assertions. */
 export function runConformanceFixture(fixture, doc = document) {
     const style = doc.createElement("style");
     style.dataset.conformanceFixture = fixture.id;

package/dist/inspector/conformance/spacingCases.d.ts

@@ -1,6 +1,2 @@
 import type { ConformanceFixture } from "./fixture.js";
-/**
- * Shared spacing corpus. Unit tests run every case through the fixture runner;
- * browser tests select representative cases where real CSSOM behaviour matters.
- */
 export declare const SPACING_CASES: ConformanceFixture[];

package/dist/inspector/conformance/spacingCases.js

@@ -10,10 +10,6 @@ const SPACE_ALIAS = token("--space-alias", "var(--space-4)", "fixtures/spacing.c
 function boxProperties(values, capability = "box-sides") {
     return Object.fromEntries(Object.entries(values).map(([property, authored]) => [property, { authored, capability }]));
 }
-/**
- * Shared spacing corpus. Unit tests run every case through the fixture runner;
- * browser tests select representative cases where real CSSOM behaviour matters.
- */
 export const SPACING_CASES = [
     {
         id: "spacing-physical-four-value",

package/dist/inspector/conformance/typographyCases.d.ts

@@ -1,7 +1,2 @@
 import type { ConformanceFixture } from "./fixture.js";
-/**
- * Framework-neutral typography corpus. The fixture runner asserts authored
- * CSS and capability independently from browser-computed output; the gallery
- * lets a human exercise the same cases through the real inspector.
- */
 export declare const TYPOGRAPHY_CASES: ConformanceFixture[];

package/dist/inspector/conformance/typographyCases.js

@@ -10,11 +10,6 @@ const TYPE_WEIGHT = token("--type-weight-strong", "650", "fixtures/typography.cs
 const TYPE_LEADING = token("--type-leading-body", "1.5", "fixtures/typography.css:4");
 const TYPE_TRACKING = token("--type-tracking-tight", "-0.018em", "fixtures/typography.css:5");
 const TYPE_FAMILY = token("--type-family-body", 'Inter, ui-sans-serif, system-ui, sans-serif', "fixtures/typography.css:6");
-/**
- * Framework-neutral typography corpus. The fixture runner asserts authored
- * CSS and capability independently from browser-computed output; the gallery
- * lets a human exercise the same cases through the real inspector.
- */
 export const TYPOGRAPHY_CASES = [
     {
         id: "type-direct-literals",

package/dist/inspector/drafts/draftStore.d.ts

@@ -0,0 +1,95 @@
+import { type ChangeRecord } from "../changes/types.js";
+import type { StructuralChange } from "../changes/structuralTypes.js";
+import type { SketchDocument } from "../sketch/model.js";
+import type { Timeline } from "../workspace/timeline.js";
+import { type Draft, type DraftContents, type DraftSnapshot } from "./model.js";
+export interface DraftChangesSnapshot extends DraftContents {
+    readonly draftId: string;
+    readonly revision: number;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+}
+/** A canonical write result. `blocked` means the lease or a save lock refused the write. */
+export type CommitResult = "applied" | "unchanged" | "blocked";
+/** Why the active draft's preview must be rebuilt. */
+export type DraftProjectionEvent = {
+    readonly kind: "edit";
+    readonly verificationTargets?: ReadonlyMap<string, HTMLElement | null>;
+} | {
+    readonly kind: "reconcile";
+    readonly structuralIds: ReadonlySet<string>;
+} | {
+    readonly kind: "switch";
+}
+/** The active draft was cleared; every earlier preview diagnostic is void. */
+ | {
+    readonly kind: "reset";
+};
+export type DraftDiscardTarget = {
+    readonly kind: "selector";
+    readonly selector: string;
+} | {
+    readonly kind: "instance-override";
+    readonly id: string;
+};
+export interface DraftStorage {
+    read(key: string): string | null;
+    write(key: string, value: string): void;
+    remove(key: string): void;
+}
+export interface DraftSketchSource {
+    getSnapshot(): {
+        readonly ready: boolean;
+        readonly documents: readonly SketchDocument[];
+    };
+    subscribe(listener: () => void): () => void;
+}
+export interface DraftStoreSeams {
+    /** Whether this tab holds the workspace write lease. */
+    canWrite(): boolean;
+    readonly timeline: Timeline;
+    readonly storage: DraftStorage;
+    readonly sketches: DraftSketchSource;
+    /** Brings a draft's owning frame back when history replays an edit. */
+    revealDraft(draftId: string, cardId?: string): void;
+    /** Rebuilds the active draft's preview. Called after subscribers see the new snapshot. */
+    project(snapshot: DraftChangesSnapshot, event: DraftProjectionEvent): void;
+}
+export interface DraftStore {
+    getActive(): DraftChangesSnapshot;
+    /** Fires for any draft content change, active-draft switch, or history change. */
+    subscribeActive(listener: () => void): () => void;
+    get(id: string): DraftChangesSnapshot;
+    ids(): readonly string[];
+    getDraft(id: string): Draft | null;
+    getSnapshot(): DraftSnapshot;
+    subscribe(listener: () => void): () => void;
+    canEdit(id?: string): boolean;
+    isLocked(id?: string): boolean;
+    /** Blocks writes to one draft until the returned release runs. */
+    lock(id: string): () => void;
+    /** Makes a draft active; `cardId` is the frame history replay should reveal for it. */
+    activate(id: string, cardId?: string): void;
+    commitChanges(incoming: readonly ChangeRecord[], verificationTargets?: ReadonlyMap<string, HTMLElement | null>): CommitResult;
+    revertChange(change: ChangeRecord): boolean;
+    discardChanges(target: DraftDiscardTarget): boolean;
+    commitStructuralChange(change: StructuralChange): boolean;
+    revertStructuralChange(changeId: string): boolean;
+    commitContents(next: DraftContents): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    reconcile(id: string, verifiedKeys: ReadonlySet<string>, verifiedStructuralIds: ReadonlySet<string>): number;
+    clear(id: string, expectedRevision?: number): boolean;
+    clearActive(): boolean;
+    forget(id: string): void;
+    sketchOwner(document: SketchDocument): string | null;
+    assignSketch(draftId: string, sketchId: string): void;
+    /** Replaces every in-memory draft with the stored drafts, so a tab that takes over never writes stale edits. */
+    load(projectId: string, options?: {
+        persistent?: boolean;
+    }): void;
+    persist(): void;
+    discardAll(): void;
+    reset(): void;
+}
+export declare function createDraftStore(seams: DraftStoreSeams): DraftStore;

package/dist/inspector/drafts/draftStore.js

@@ -0,0 +1,461 @@
+import { deserializeChange, isSerializableChange, serializeChange, } from "../changes/codecs.js";
+import { changeKey, mergeChange, sameEffectiveChanges, selectorForChange } from "../changes/model.js";
+import { isElementChange } from "../changes/types.js";
+import { isStructuralChange } from "../projection/structuralProjectionBoundary.js";
+import { applicationTarget, documentTarget, isDraftTarget, targetFromKey, targetKey, } from "./model.js";
+const EMPTY = { changes: [], structuralChanges: [] };
+const PROJECTION_RANK = { edit: 1, reconcile: 2, switch: 3, reset: 4 };
+function cloneValue(value, key) {
+    if (key === "oldToken" || key === "newToken")
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => cloneValue(item));
+    if (value !== null && typeof value === "object") {
+        const clone = {};
+        for (const [childKey, child] of Object.entries(value))
+            clone[childKey] = cloneValue(child, childKey);
+        return clone;
+    }
+    return value;
+}
+function freezeValue(value, key) {
+    if (key === "oldToken" || key === "newToken")
+        return value;
+    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+        for (const [childKey, child] of Object.entries(value))
+            freezeValue(child, childKey);
+        Object.freeze(value);
+    }
+    return value;
+}
+function frozenContents(value) {
+    return freezeValue({
+        changes: value.changes.map((change) => cloneValue(change)),
+        structuralChanges: value.structuralChanges.map((change) => cloneValue(change)),
+    });
+}
+function sameDraftContents(left, right) {
+    return sameEffectiveChanges([...left.changes], [...right.changes])
+        && JSON.stringify(left.structuralChanges) === JSON.stringify(right.structuralChanges);
+}
+function mergeProjection(current, next) {
+    return current && PROJECTION_RANK[current.kind] > PROJECTION_RANK[next.kind] ? current : next;
+}
+function isPersistedDrafts(value, projectId) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    if (candidate.schemaVersion !== 2 || candidate.projectId !== projectId || !Array.isArray(candidate.drafts))
+        return false;
+    const targets = new Set();
+    for (const draft of candidate.drafts) {
+        if (!draft || !isDraftTarget(draft.target) || targets.has(targetKey(draft.target))
+            || !Number.isSafeInteger(draft.revision) || draft.revision < 1
+            || !draft.contents || !Array.isArray(draft.contents.changes) || !draft.contents.changes.every(isSerializableChange)
+            || !Array.isArray(draft.contents.structuralChanges) || !draft.contents.structuralChanges.every(isStructuralChange))
+            return false;
+        const textIds = draft.contents.changes
+            .filter((change) => change.kind === "text-content")
+            .map((change) => "id" in change ? change.id : "");
+        if (new Set(textIds).size !== textIds.length)
+            return false;
+        targets.add(targetKey(draft.target));
+    }
+    return !!candidate.sketchOwners && typeof candidate.sketchOwners === "object" && !Array.isArray(candidate.sketchOwners)
+        && Object.values(candidate.sketchOwners).every((id) => typeof id === "string" && targetFromKey(id) !== null);
+}
+export function createDraftStore(seams) {
+    const drafts = new Map();
+    const locked = new Set();
+    /** Overrides the capture-URL owner for sketches drawn while another draft was active. */
+    const sketchOwners = new Map();
+    const activeListeners = new Set();
+    const draftListeners = new Set();
+    /** Until a frame is activated, edits belong to the current page's draft. */
+    let activeDraftId = null;
+    let projectId = "";
+    let persistent = true;
+    let activeSnapshot = null;
+    let draftsSnapshot = null;
+    let depth = 0;
+    let activePending = false;
+    let draftsPending = false;
+    let pendingProjection = null;
+    const activeId = () => activeDraftId ??= targetKey(applicationTarget());
+    const storageKey = () => `nudge-ui-drafts:${projectId}:v2`;
+    function draftState(id = activeId()) {
+        let draft = drafts.get(id);
+        if (!draft) {
+            draft = { id, revision: 0, contents: EMPTY };
+            drafts.set(id, draft);
+        }
+        return draft;
+    }
+    function flush() {
+        if (activePending) {
+            activePending = false;
+            for (const listener of activeListeners)
+                listener();
+        }
+        if (draftsPending) {
+            draftsPending = false;
+            for (const listener of draftListeners)
+                listener();
+        }
+        if (pendingProjection) {
+            const event = pendingProjection;
+            pendingProjection = null;
+            seams.project(getActive(), event);
+        }
+    }
+    /** Subscribers and the projector observe only complete, settled state. */
+    function mutate(operation) {
+        depth += 1;
+        try {
+            return operation();
+        }
+        finally {
+            depth -= 1;
+            if (depth === 0)
+                flush();
+        }
+    }
+    function activeChanged() {
+        activeSnapshot = null;
+        activePending = true;
+        if (depth === 0)
+            flush();
+    }
+    function draftsChanged() {
+        draftsSnapshot = null;
+        draftsPending = true;
+        if (depth === 0)
+            flush();
+    }
+    function contentsChanged() {
+        draftsSnapshot = null;
+        draftsPending = true;
+        activeChanged();
+    }
+    function project(event) {
+        pendingProjection = mergeProjection(pendingProjection, event);
+    }
+    function replaceContents(draft, next) {
+        draft.contents = frozenContents(next);
+        draft.revision += 1;
+        contentsChanged();
+    }
+    function resetContents() {
+        drafts.clear();
+        locked.clear();
+        activeDraftId = null;
+        seams.timeline.clear();
+    }
+    function canEdit(id = activeId()) {
+        return seams.canWrite() && !locked.has(id);
+    }
+    function commitActive(next, event = { kind: "edit" }) {
+        if (!canEdit())
+            return false;
+        return mutate(() => {
+            const draft = draftState();
+            const before = draft.contents;
+            replaceContents(draft, next);
+            seams.timeline.recordEdit({
+                draftId: draft.id,
+                focus: { draftId: draft.id, ...(draft.activateCardId ? { cardId: draft.activateCardId } : {}) },
+                before,
+                after: draft.contents,
+            }, sameDraftContents);
+            project(event);
+            return true;
+        });
+    }
+    function activate(id, cardId) {
+        mutate(() => {
+            draftState(id).activateCardId = cardId;
+            if (activeId() === id)
+                return;
+            activeDraftId = id;
+            activeChanged();
+            project({ kind: "switch" });
+        });
+    }
+    function replay(direction) {
+        if (locked.size > 0 || !seams.canWrite())
+            return false;
+        return mutate(() => {
+            const replayed = seams.timeline.replay(direction, (entry, next) => {
+                replaceContents(draftState(entry.draftId), next);
+                // Replay always makes the entry's draft active, including when another
+                // draft is active; a known frame is revealed before that switch.
+                if (entry.focus?.cardId)
+                    seams.revealDraft(entry.focus.draftId, entry.focus.cardId);
+                else
+                    seams.revealDraft(entry.draftId);
+                if (activeId() !== entry.draftId)
+                    activate(entry.draftId);
+            });
+            if (replayed)
+                project({ kind: "edit" });
+            return replayed;
+        });
+    }
+    function clear(id, event, expectedRevision) {
+        const draft = draftState(id);
+        if (!canEdit(id) || (expectedRevision !== undefined && draft.revision !== expectedRevision))
+            return false;
+        mutate(() => {
+            replaceContents(draft, EMPTY);
+            seams.timeline.discardDraftHistory(id);
+            if (id === activeId())
+                project(event);
+        });
+        return true;
+    }
+    function get(id) {
+        const draft = drafts.get(id);
+        return {
+            draftId: id,
+            revision: draft?.revision ?? 0,
+            changes: draft?.contents.changes ?? [],
+            structuralChanges: draft?.contents.structuralChanges ?? [],
+            ...seams.timeline.status(),
+        };
+    }
+    function getActive() {
+        if (!activeSnapshot) {
+            const draft = draftState();
+            activeSnapshot = Object.freeze({ draftId: draft.id, revision: draft.revision, ...draft.contents, ...seams.timeline.status() });
+        }
+        return activeSnapshot;
+    }
+    function sketchOwner(document) {
+        const owner = sketchOwners.get(document.id);
+        if (owner)
+            return owner;
+        try {
+            return targetKey(documentTarget(document.capture.url));
+        }
+        catch {
+            return null;
+        }
+    }
+    function getDraft(id) {
+        const target = targetFromKey(id);
+        if (!target)
+            return null;
+        const { revision, changes, structuralChanges } = get(id);
+        return {
+            id,
+            target,
+            revision,
+            contents: { changes, structuralChanges },
+            sketchIds: seams.sketches.getSnapshot().documents.filter((document) => sketchOwner(document) === id).map((document) => document.id),
+        };
+    }
+    function persisted() {
+        const sketches = seams.sketches.getSnapshot();
+        const liveSketches = new Set(sketches.documents.map((document) => document.id));
+        return {
+            schemaVersion: 2,
+            projectId,
+            drafts: [...drafts.values()].flatMap(({ id, revision, contents }) => {
+                const target = targetFromKey(id);
+                if (!target || contents.changes.length + contents.structuralChanges.length === 0)
+                    return [];
+                return [{
+                        target,
+                        revision,
+                        contents: {
+                            changes: contents.changes.flatMap((change) => {
+                                const serialized = serializeChange(change);
+                                return serialized ? [serialized] : [];
+                            }),
+                            structuralChanges: contents.structuralChanges,
+                        },
+                    }];
+            }),
+            sketchOwners: Object.fromEntries([...sketchOwners].filter(([id]) => !sketches.ready || liveSketches.has(id))),
+        };
+    }
+    function restore() {
+        const raw = persistent ? seams.storage.read(storageKey()) : null;
+        const stored = raw ? JSON.parse(raw) : null;
+        if (!isPersistedDrafts(stored, projectId))
+            return;
+        for (const draft of stored.drafts) {
+            const state = draftState(targetKey(draft.target));
+            state.contents = frozenContents({
+                changes: draft.contents.changes.map(deserializeChange),
+                structuralChanges: draft.contents.structuralChanges,
+            });
+            state.revision = draft.revision;
+        }
+        for (const [sketchId, draftId] of Object.entries(stored.sketchOwners))
+            sketchOwners.set(sketchId, draftId);
+    }
+    seams.timeline.subscribe(activeChanged);
+    seams.sketches.subscribe(draftsChanged);
+    return {
+        getActive,
+        subscribeActive(listener) {
+            activeListeners.add(listener);
+            return () => activeListeners.delete(listener);
+        },
+        get,
+        ids: () => [...drafts.keys()],
+        getDraft,
+        getSnapshot() {
+            if (!draftsSnapshot) {
+                const ids = new Set([
+                    ...drafts.keys(),
+                    ...seams.sketches.getSnapshot().documents.flatMap((document) => sketchOwner(document) ?? []),
+                ]);
+                draftsSnapshot = { projectId, drafts: [...ids].flatMap((id) => getDraft(id) ?? []) };
+            }
+            return draftsSnapshot;
+        },
+        subscribe(listener) {
+            draftListeners.add(listener);
+            return () => draftListeners.delete(listener);
+        },
+        canEdit,
+        isLocked: (id) => id === undefined ? locked.size > 0 : locked.has(id),
+        lock(id) {
+            if (locked.has(id))
+                throw new Error("This iteration is already saving.");
+            locked.add(id);
+            return () => { locked.delete(id); };
+        },
+        activate,
+        commitChanges(incoming, verificationTargets) {
+            if (incoming.length === 0)
+                return "unchanged";
+            const contents = draftState().contents;
+            const changes = incoming.reduce((current, change) => mergeChange(current, change), [...contents.changes]);
+            if (sameEffectiveChanges([...contents.changes], changes))
+                return "unchanged";
+            return commitActive({ ...contents, changes }, { kind: "edit", verificationTargets }) ? "applied" : "blocked";
+        },
+        revertChange(change) {
+            const contents = draftState().contents;
+            const changes = contents.changes.filter((candidate) => changeKey(candidate) !== changeKey(change));
+            return changes.length !== contents.changes.length && commitActive({ ...contents, changes });
+        },
+        discardChanges(target) {
+            const contents = draftState().contents;
+            const changes = contents.changes.filter((change) => target.kind === "selector"
+                ? selectorForChange(change) !== target.selector
+                : !isElementChange(change) || change.instanceOverride?.id !== target.id);
+            return changes.length !== contents.changes.length && commitActive({ ...contents, changes });
+        },
+        commitStructuralChange(change) {
+            const contents = draftState().contents;
+            if (contents.structuralChanges.some((candidate) => candidate.id === change.id))
+                return false;
+            return commitActive({ ...contents, structuralChanges: [...contents.structuralChanges, change] });
+        },
+        revertStructuralChange(changeId) {
+            const contents = draftState().contents;
+            const structuralChanges = contents.structuralChanges.filter((change) => change.id !== changeId);
+            return structuralChanges.length !== contents.structuralChanges.length && commitActive({ ...contents, structuralChanges });
+        },
+        commitContents: (next) => !sameDraftContents(draftState().contents, next) && commitActive(next),
+        undo: () => replay("undo"),
+        redo: () => replay("redo"),
+        reconcile(id, verifiedKeys, verifiedStructuralIds) {
+            if (!canEdit(id))
+                return 0;
+            const draft = draftState(id);
+            const retain = (value) => ({
+                changes: value.changes.filter((change) => !verifiedKeys.has(changeKey(change))),
+                structuralChanges: value.structuralChanges.filter((change) => !verifiedStructuralIds.has(change.id)),
+            });
+            const next = retain(draft.contents);
+            const removed = draft.contents.changes.length - next.changes.length
+                + draft.contents.structuralChanges.length - next.structuralChanges.length;
+            if (removed === 0)
+                return 0;
+            mutate(() => {
+                replaceContents(draft, next);
+                seams.timeline.pruneDraftHistory(id, retain, sameDraftContents);
+                if (id === activeId())
+                    project({ kind: "reconcile", structuralIds: verifiedStructuralIds });
+            });
+            return removed;
+        },
+        clear: (id, expectedRevision) => clear(id, { kind: "edit" }, expectedRevision),
+        clearActive: () => clear(activeId(), { kind: "reset" }),
+        forget(id) {
+            if (!drafts.has(id) || locked.has(id))
+                return;
+            mutate(() => {
+                seams.timeline.discardDraftHistory(id);
+                drafts.delete(id);
+                contentsChanged();
+                if (id === activeId())
+                    project({ kind: "edit" });
+            });
+        },
+        sketchOwner,
+        assignSketch(draftId, sketchId) {
+            if (sketchOwners.get(sketchId) === draftId || !targetFromKey(draftId))
+                return;
+            sketchOwners.set(sketchId, draftId);
+            draftsChanged();
+        },
+        load(nextProjectId, options = {}) {
+            mutate(() => {
+                projectId = nextProjectId;
+                persistent = options.persistent ?? true;
+                sketchOwners.clear();
+                resetContents();
+                try {
+                    restore();
+                }
+                catch {
+                    resetContents();
+                    sketchOwners.clear();
+                }
+                contentsChanged();
+                project({ kind: "switch" });
+            });
+        },
+        persist() {
+            if (!projectId || !persistent || !seams.canWrite())
+                return;
+            try {
+                seams.storage.write(storageKey(), JSON.stringify(persisted()));
+            }
+            catch {
+                return;
+            }
+        },
+        discardAll() {
+            if (projectId && persistent && seams.canWrite()) {
+                try {
+                    seams.storage.remove(storageKey());
+                }
+                catch {
+                    return;
+                }
+            }
+            mutate(() => {
+                sketchOwners.clear();
+                resetContents();
+                contentsChanged();
+                project({ kind: "reset" });
+            });
+        },
+        reset() {
+            mutate(() => {
+                projectId = "";
+                persistent = true;
+                sketchOwners.clear();
+                resetContents();
+                contentsChanged();
+            });
+        },
+    };
+}