@elytracms/studio 0.0.94 → 0.0.96

package/dist/components/cms/draft-commit.d.ts

@@ -42,8 +42,16 @@ export interface UncommittedPosition {
     readonly base: number | undefined;
 }
 export interface DraftCommitter {
-    /** A field's control wrote `path`. */
-    edited(field: string, path: ValuePath): void;
+    /**
+     * A field's control wrote `path`. `authored` — the revision the edit was authored
+     * against when the writer knows it better than the draft does (EC-647: a canvas
+     * inspector control's burst is authored on the CANVAS's value, whose revision can trail
+     * the draft's); absent → {@link DraftCommitterOptions.baseOf}. A re-edit of an
+     * uncommitted position keeps the base of its first edit either way.
+     */
+    edited(field: string, path: ValuePath, authored?: {
+        readonly base: number | undefined;
+    }): void;
     /** Focus entered a field's control. */
     focused(field: string): void;
     /** Focus left a field's control (commits it and what rode along). */
@@ -61,7 +69,12 @@ export interface DraftCommitter {
 }
 export interface DraftCommitterOptions {
     policyOf: (field: string) => CommitPolicy;
-    /** The revision the session's view is at now (captured as a position's base on its first edit). */
+    /**
+     * The revision the editor's draft is at now — the revision of the view a field's edit
+     * is authored on (captured as a position's base on its first edit). EC-647: the
+     * draft's, never the session's tracked one (which may hold a change the draft has not
+     * rebased onto yet).
+     */
     baseOf?: () => number | undefined;
     commit: (positions: readonly UncommittedPosition[]) => void;
     scheduler?: Scheduler;

package/dist/components/cms/draft-commit.js

@@ -29,10 +29,11 @@ export function createDraftCommitter(options) {
         options.commit(batch.map(([, position]) => position));
     };
     return {
-        edited(field, path) {
+        edited(field, path, authored) {
             const key = formatValuePath(path);
             const previous = pending.get(key);
-            pending.set(key, { field, path, base: previous ? previous.base : options.baseOf?.() });
+            const base = previous ? previous.base : authored ? authored.base : options.baseOf?.();
+            pending.set(key, { field, path, base });
             const policy = options.policyOf(field);
             if (policy === 'change' || focus === undefined) {
                 commitField(field);

package/dist/components/cms/draft-commit.js.map

@@ -1 +1 @@
-{"version":3,"file":"draft-commit.js","sourceRoot":"","sources":["../../../src/components/cms/draft-commit.ts"],"names":[],"mappings":"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","sourcesContent":["import { formatValuePath } from '@elytracms/core/cms-core'\nimport type { ValuePath } from '@elytracms/core/cms-core'\nimport type { CommitPolicy } from './commit-policy'\nimport { IDLE_COMMIT_MS } from './commit-policy'\n\n/**\n * EC-595 A2 — the editor's COMMIT-ON-QUIESCENCE core (pure, clock injected; the house\n * pattern: no DOM, no React).\n *\n * The editor's draft changes per keystroke (live validation reads it); what is\n * COMMITTED — handed to the persister as patches — follows each field's\n * {@link CommitPolicy}. This core tracks the uncommitted positions and decides when\n * each is committed:\n *\n * - an edit of a `change`-policy field commits at once;\n * - an edit of the FOCUSED field waits for its blur, Enter (`blur-or-enter`) or idle\n *   pause (`blur-or-idle`, re-armed on every edit — {@link Scheduler});\n * - an edit of a field that does NOT have focus (a derived value — the auto-slug\n *   following the title, fill-from-base) rides along with the focused field's next\n *   commit, or commits at once when no field has focus;\n * - {@link DraftCommitter.commitAll} is the FORCED commit (publish, unmount, tab hide,\n *   duplicate, an AI proposal, transfer) — everything uncommitted, now.\n *\n * `commit` receives the positions; the caller builds the patches from its latest draft\n * (the value AT commit time, so a committed value is never a stale keystroke).\n */\n\n/** The injected clock: timers for the idle pause. */\nexport interface Scheduler {\n  setTimeout(callback: () => void, ms: number): unknown\n  clearTimeout(handle: unknown): void\n}\n\n/** The real clock (the editor's default). */\nexport const browserScheduler: Scheduler = {\n  setTimeout: (callback, ms) => globalThis.setTimeout(callback, ms),\n  clearTimeout: (handle) => globalThis.clearTimeout(handle as ReturnType<typeof setTimeout>),\n}\n\n/** One uncommitted position and the field (by name) whose control wrote it. */\nexport interface UncommittedPosition {\n  readonly field: string\n  readonly path: ValuePath\n  /**\n   * The revision the user's view was at when they STARTED editing this position — the\n   * patch's base. A colleague's change of the same position that arrives (by\n   * subscription) while the user is still typing is therefore refused on that field at\n   * commit, never overwritten (EC-595 point 7: \"local wins until flushed, then the\n   * per-path check decides\").\n   */\n  readonly base: number | undefined\n}\n\nexport interface DraftCommitter {\n  /** A field's control wrote `path`. */\n  edited(field: string, path: ValuePath): void\n  /** Focus entered a field's control. */\n  focused(field: string): void\n  /** Focus left a field's control (commits it and what rode along). */\n  blurred(field: string): void\n  /** Enter in a single-line control (commits it). */\n  entered(field: string): void\n  /** The forced commit: everything uncommitted, now. */\n  commitAll(): void\n  /** The uncommitted positions (the editor overlays them on a rebased draft). */\n  uncommitted(): readonly UncommittedPosition[]\n  /** The field that has focus, if any. */\n  focusedField(): string | undefined\n  /** Cancel the idle timers (unmount). */\n  dispose(): void\n}\n\nexport interface DraftCommitterOptions {\n  policyOf: (field: string) => CommitPolicy\n  /** The revision the session's view is at now (captured as a position's base on its first edit). */\n  baseOf?: () => number | undefined\n  commit: (positions: readonly UncommittedPosition[]) => void\n  scheduler?: Scheduler\n  idleMs?: number\n}\n\nexport function createDraftCommitter(options: DraftCommitterOptions): DraftCommitter {\n  const scheduler = options.scheduler ?? browserScheduler\n  const idleMs = options.idleMs ?? IDLE_COMMIT_MS\n  /** Uncommitted positions by path key (one per position — a re-edit keeps one entry). */\n  const pending = new Map<string, UncommittedPosition>()\n  const idleTimers = new Map<string, unknown>()\n  let focus: string | undefined\n\n  const cancelIdle = (field: string) => {\n    const handle = idleTimers.get(field)\n    if (handle !== undefined) scheduler.clearTimeout(handle)\n    idleTimers.delete(field)\n  }\n\n  /** Commit `field`'s positions plus every position of a field that does not have focus. */\n  const commitField = (field: string) => {\n    cancelIdle(field)\n    const batch = [...pending.entries()].filter(\n      ([, position]) => position.field === field || position.field !== focus,\n    )\n    if (batch.length === 0) return\n    for (const [key] of batch) pending.delete(key)\n    options.commit(batch.map(([, position]) => position))\n  }\n\n  return {\n    edited(field, path) {\n      const key = formatValuePath(path)\n      const previous = pending.get(key)\n      pending.set(key, { field, path, base: previous ? previous.base : options.baseOf?.() })\n      const policy = options.policyOf(field)\n      if (policy === 'change' || focus === undefined) {\n        commitField(field)\n        return\n      }\n      if (focus !== field) return // rides along with the focused field's commit\n      if (policy === 'blur-or-idle') {\n        cancelIdle(field)\n        idleTimers.set(\n          field,\n          scheduler.setTimeout(() => {\n            idleTimers.delete(field)\n            commitField(field)\n          }, idleMs),\n        )\n      }\n    },\n    focused(field) {\n      if (focus !== undefined && focus !== field) commitField(focus)\n      focus = field\n    },\n    blurred(field) {\n      if (focus === field) focus = undefined\n      commitField(field)\n    },\n    entered(field) {\n      if (options.policyOf(field) === 'blur-or-enter') commitField(field)\n    },\n    commitAll() {\n      for (const field of [...idleTimers.keys()]) cancelIdle(field)\n      if (pending.size === 0) return\n      const batch = [...pending.values()]\n      pending.clear()\n      options.commit(batch)\n    },\n    uncommitted: () => [...pending.values()],\n    focusedField: () => focus,\n    dispose() {\n      for (const field of [...idleTimers.keys()]) cancelIdle(field)\n    },\n  }\n}\n"]}
+{"version":3,"file":"draft-commit.js","sourceRoot":"","sources":["../../../src/components/cms/draft-commit.ts"],"names":[],"mappings":"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","sourcesContent":["import { formatValuePath } from '@elytracms/core/cms-core'\nimport type { ValuePath } from '@elytracms/core/cms-core'\nimport type { CommitPolicy } from './commit-policy'\nimport { IDLE_COMMIT_MS } from './commit-policy'\n\n/**\n * EC-595 A2 — the editor's COMMIT-ON-QUIESCENCE core (pure, clock injected; the house\n * pattern: no DOM, no React).\n *\n * The editor's draft changes per keystroke (live validation reads it); what is\n * COMMITTED — handed to the persister as patches — follows each field's\n * {@link CommitPolicy}. This core tracks the uncommitted positions and decides when\n * each is committed:\n *\n * - an edit of a `change`-policy field commits at once;\n * - an edit of the FOCUSED field waits for its blur, Enter (`blur-or-enter`) or idle\n *   pause (`blur-or-idle`, re-armed on every edit — {@link Scheduler});\n * - an edit of a field that does NOT have focus (a derived value — the auto-slug\n *   following the title, fill-from-base) rides along with the focused field's next\n *   commit, or commits at once when no field has focus;\n * - {@link DraftCommitter.commitAll} is the FORCED commit (publish, unmount, tab hide,\n *   duplicate, an AI proposal, transfer) — everything uncommitted, now.\n *\n * `commit` receives the positions; the caller builds the patches from its latest draft\n * (the value AT commit time, so a committed value is never a stale keystroke).\n */\n\n/** The injected clock: timers for the idle pause. */\nexport interface Scheduler {\n  setTimeout(callback: () => void, ms: number): unknown\n  clearTimeout(handle: unknown): void\n}\n\n/** The real clock (the editor's default). */\nexport const browserScheduler: Scheduler = {\n  setTimeout: (callback, ms) => globalThis.setTimeout(callback, ms),\n  clearTimeout: (handle) => globalThis.clearTimeout(handle as ReturnType<typeof setTimeout>),\n}\n\n/** One uncommitted position and the field (by name) whose control wrote it. */\nexport interface UncommittedPosition {\n  readonly field: string\n  readonly path: ValuePath\n  /**\n   * The revision the user's view was at when they STARTED editing this position — the\n   * patch's base. A colleague's change of the same position that arrives (by\n   * subscription) while the user is still typing is therefore refused on that field at\n   * commit, never overwritten (EC-595 point 7: \"local wins until flushed, then the\n   * per-path check decides\").\n   */\n  readonly base: number | undefined\n}\n\nexport interface DraftCommitter {\n  /**\n   * A field's control wrote `path`. `authored` — the revision the edit was authored\n   * against when the writer knows it better than the draft does (EC-647: a canvas\n   * inspector control's burst is authored on the CANVAS's value, whose revision can trail\n   * the draft's); absent → {@link DraftCommitterOptions.baseOf}. A re-edit of an\n   * uncommitted position keeps the base of its first edit either way.\n   */\n  edited(field: string, path: ValuePath, authored?: { readonly base: number | undefined }): void\n  /** Focus entered a field's control. */\n  focused(field: string): void\n  /** Focus left a field's control (commits it and what rode along). */\n  blurred(field: string): void\n  /** Enter in a single-line control (commits it). */\n  entered(field: string): void\n  /** The forced commit: everything uncommitted, now. */\n  commitAll(): void\n  /** The uncommitted positions (the editor overlays them on a rebased draft). */\n  uncommitted(): readonly UncommittedPosition[]\n  /** The field that has focus, if any. */\n  focusedField(): string | undefined\n  /** Cancel the idle timers (unmount). */\n  dispose(): void\n}\n\nexport interface DraftCommitterOptions {\n  policyOf: (field: string) => CommitPolicy\n  /**\n   * The revision the editor's draft is at now — the revision of the view a field's edit\n   * is authored on (captured as a position's base on its first edit). EC-647: the\n   * draft's, never the session's tracked one (which may hold a change the draft has not\n   * rebased onto yet).\n   */\n  baseOf?: () => number | undefined\n  commit: (positions: readonly UncommittedPosition[]) => void\n  scheduler?: Scheduler\n  idleMs?: number\n}\n\nexport function createDraftCommitter(options: DraftCommitterOptions): DraftCommitter {\n  const scheduler = options.scheduler ?? browserScheduler\n  const idleMs = options.idleMs ?? IDLE_COMMIT_MS\n  /** Uncommitted positions by path key (one per position — a re-edit keeps one entry). */\n  const pending = new Map<string, UncommittedPosition>()\n  const idleTimers = new Map<string, unknown>()\n  let focus: string | undefined\n\n  const cancelIdle = (field: string) => {\n    const handle = idleTimers.get(field)\n    if (handle !== undefined) scheduler.clearTimeout(handle)\n    idleTimers.delete(field)\n  }\n\n  /** Commit `field`'s positions plus every position of a field that does not have focus. */\n  const commitField = (field: string) => {\n    cancelIdle(field)\n    const batch = [...pending.entries()].filter(\n      ([, position]) => position.field === field || position.field !== focus,\n    )\n    if (batch.length === 0) return\n    for (const [key] of batch) pending.delete(key)\n    options.commit(batch.map(([, position]) => position))\n  }\n\n  return {\n    edited(field, path, authored) {\n      const key = formatValuePath(path)\n      const previous = pending.get(key)\n      const base = previous ? previous.base : authored ? authored.base : options.baseOf?.()\n      pending.set(key, { field, path, base })\n      const policy = options.policyOf(field)\n      if (policy === 'change' || focus === undefined) {\n        commitField(field)\n        return\n      }\n      if (focus !== field) return // rides along with the focused field's commit\n      if (policy === 'blur-or-idle') {\n        cancelIdle(field)\n        idleTimers.set(\n          field,\n          scheduler.setTimeout(() => {\n            idleTimers.delete(field)\n            commitField(field)\n          }, idleMs),\n        )\n      }\n    },\n    focused(field) {\n      if (focus !== undefined && focus !== field) commitField(focus)\n      focus = field\n    },\n    blurred(field) {\n      if (focus === field) focus = undefined\n      commitField(field)\n    },\n    entered(field) {\n      if (options.policyOf(field) === 'blur-or-enter') commitField(field)\n    },\n    commitAll() {\n      for (const field of [...idleTimers.keys()]) cancelIdle(field)\n      if (pending.size === 0) return\n      const batch = [...pending.values()]\n      pending.clear()\n      options.commit(batch)\n    },\n    uncommitted: () => [...pending.values()],\n    focusedField: () => focus,\n    dispose() {\n      for (const field of [...idleTimers.keys()]) cancelIdle(field)\n    },\n  }\n}\n"]}

package/dist/components/cms/use-document-draft.d.ts

@@ -1,7 +1,10 @@
 import type { PresenceEntry } from '@elytracms/core/persistence';
 import type { CmsDocument, CollectionDef, DocumentPatch, FieldDef, Locale, PropFieldLookup, ValuePath } from '@elytracms/core/cms-core';
 import type { CollectionViewSource } from '../../lib/collection-view/collection-view-source.js';
-import type { Scheduler, UncommittedPosition } from './draft-commit.js';
+import type { CanvasFieldChange, CanvasLift } from '../builder/canvas-rebase.js';
+import type { CommitPolicy } from './commit-policy.js';
+import type { CanvasControl, CanvasControlPosition } from './canvas-commit.js';
+import type { DraftCommitter, Scheduler, UncommittedPosition } from './draft-commit.js';
 /**
  * EC-595 A2 — the detail editor's draft over the revisioned document (and, for the
  * explicit-save rails, over a record).
@@ -10,7 +13,9 @@ import type { Scheduler, UncommittedPosition } from './draft-commit.js';
  * reads it); a field's edit is COMMITTED per its control kind's policy
  * ({@link commitPolicyOf} / {@link createDraftCommitter}) as the patch of the position it
  * wrote — never a document. The canvas commits each action's node patches at once
- * (`compositionPatches`). The draft REBASES whenever the session's document changes
+ * (`compositionPatches`); a burst of typing in one of its inspector controls is that
+ * control's uncommitted position, committed on its kind's policy like a form field
+ * (EC-630, `canvas-commit.ts`). The draft REBASES whenever the session's document changes
  * (a write result, a colleague's change by subscription, a resolved conflict): it is the
  * session's document with this editor's uncommitted positions laid over it — local wins
  * until committed, then the per-path check decides (EC-595 point 7).
@@ -35,6 +40,26 @@ export interface VisibilitySource {
     onHidden(onHidden: () => void): () => void;
 }
 export declare const documentVisibility: VisibilitySource;
+/**
+ * EC-647 — the editor's draft and the revision of the session view it was last rebased
+ * onto, as ONE value: every edit made on the draft was authored against that revision (an
+ * uncommitted position keeps the revision its first keystroke saw). `undefined`: the view
+ * had no revision (a fixture session, a record rail, a document still being created).
+ */
+export interface DraftView {
+    readonly document: CmsDocument;
+    readonly revision: number | undefined;
+}
+/**
+ * EC-647 — the slot alias write (pure): the draft with `alias` set (or removed), written
+ * whole AT THE DRAFT'S REVISION — never the session's tracked one, which may already hold
+ * a colleague's change the draft has not absorbed (Codex F10). There is no identity-
+ * metadata operation for the alias (the value-position grammar has no position for it,
+ * measured on the base), so it stays a whole-document `replace` with its precondition.
+ */
+export declare function aliasWrite(draft: DraftView, alias: string | undefined, writes: {
+    replace(doc: CmsDocument, revision: number | undefined): void;
+}): CmsDocument;
 /** The patch that writes the value `doc` holds at `path` (unset when absent). */
 export declare function positionPatch(doc: CmsDocument, path: ValuePath): DocumentPatch;
 /**
@@ -42,6 +67,65 @@ export declare function positionPatch(doc: CmsDocument, path: ValuePath): Docume
  * over it, values from the editor's current draft.
  */
 export declare function rebaseDraft(sessionDoc: CmsDocument, draft: CmsDocument, uncommitted: readonly UncommittedPosition[]): CmsDocument;
+/**
+ * EC-630 — the canvas's write into the draft (pure). The canvas writer's node patches,
+ * keyed by node id, are the canvas's OWN delta: from `base`, the value it last agreed on
+ * with the draft, to `value` — never a document diff, and never measured against the
+ * draft's CURRENT value (a colleague's change that reached the draft a moment before the
+ * edit lifted would read as part of the edit, and its patches would revert it). The draft
+ * takes the delta over whatever it holds now (normally `base` itself) and canonicalises the
+ * field through the write lens. `undefined` when the canvas changed nothing.
+ */
+export declare function canvasWrite(input: {
+    collection: CollectionDef;
+    draft: CmsDocument;
+    field: string;
+    locale: Locale;
+    value: unknown;
+    base: unknown;
+    lookupManifest: PropFieldLookup;
+}): {
+    next: CmsDocument;
+    patches: DocumentPatch[];
+} | undefined;
+/**
+ * EC-630 — the change of the canvas field made UNDERNEATH the canvas when the draft
+ * rebased from `previous` to `next` (pure), numbered after `last`; `undefined` when the
+ * field did not move. The canvas's own edits are in both values (the session's view holds
+ * every patch it committed, the draft overlays every position it has not), so the change
+ * is someone else's: a colleague's patch, a write's canonical row, a resolved conflict.
+ *
+ * EC-647: it carries `revision`, the revision the draft is at after the rebase, and is
+ * reported when only THAT moved too (`from` ≡ `to`): the canvas's agreed value is valid
+ * at the newer revision, so its next edit is authored there — the revision follows the
+ * value, never runs ahead of it.
+ */
+export declare function canvasFieldChange(previous: CmsDocument, next: CmsDocument, path: ValuePath, last: CanvasFieldChange | undefined, revision: number | undefined): CanvasFieldChange | undefined;
+/**
+ * EC-647 — the canvas's write path (pure; what {@link DocumentDraft.setCanvasValue} runs):
+ * the canvas writer's delta into the draft ({@link canvasWrite}, handed to `apply`), then
+ * routed ({@link routeCanvasWrite}) — committed at once, or held as a focused inspector
+ * control's uncommitted position — and in both cases paired with the revision of the
+ * canvas value the edit was authored on (`lift.revision`), never the draft's: the draft
+ * may already hold a colleague's change the canvas has not been rebased onto (Codex F12),
+ * and the store must check the edit from the canvas's revision to refuse it where it
+ * overlaps that change. `commit` absent → a draft without a revisioned write model (the
+ * draft moves, nothing is committed). `undefined` when the canvas changed nothing.
+ */
+export declare function canvasCommit(input: {
+    collection: CollectionDef;
+    draft: CmsDocument;
+    field: string;
+    locale: Locale;
+    lift: CanvasLift;
+    lookupManifest: PropFieldLookup;
+    /** The focused canvas inspector control, if focus is on one. */
+    focused: CanvasControl | undefined;
+    committer: DraftCommitter;
+    /** The draft takes the canvas's write (before it is routed — a forced commit reads it). */
+    apply: (next: CmsDocument) => void;
+    commit?: (patches: readonly DocumentPatch[], bases: readonly (number | undefined)[]) => void;
+}): 'deferred' | 'committed' | 'draft' | undefined;
 /**
  * The reader's "now" for presence liveness: THIS session's own latest heartbeat `at`
  * (written by the same store clock as everyone else's — the playground store runs a
@@ -53,6 +137,12 @@ export declare function rebaseDraft(sessionDoc: CmsDocument, draft: CmsDocument,
 export declare function presenceReaderNow(entries: readonly PresenceEntry[], sessionId: string, fallback: string): string;
 export interface DocumentDraft {
     draft: CmsDocument;
+    /**
+     * EC-647 — the revision of the session view the draft was last rebased onto (see
+     * {@link DraftView}): a writer that authors from {@link draft} (the translation) writes
+     * at this revision.
+     */
+    revision: number | undefined;
     /** Uncommitted (document model) / unsaved (record model) edits exist. */
     dirty: boolean;
     /** The record model: the editor renders a Save button + navigation guard. */
@@ -61,22 +151,48 @@ export interface DocumentDraft {
     setFieldValue(field: FieldDef, value: unknown): void;
     /** A writer that transforms ONE field position (fill / reset from base). */
     editField(field: FieldDef, update: (draft: CmsDocument) => CmsDocument): void;
-    /** The canvas emitted a new value for its field (node patches, committed at once). */
-    setCanvasValue(field: FieldDef, value: unknown): void;
+    /**
+     * The canvas emitted a new value for its field (node patches, committed at once). The
+     * lift's `base` is the value the canvas last agreed on with the draft: the canvas
+     * writer's delta is `base` → `value`, applied over whatever the draft holds now (EC-630 —
+     * a change that landed underneath meanwhile is never reverted by the canvas's own
+     * write); its `revision` is the revision that value was agreed at — the revision the
+     * edit is committed at (EC-647, {@link canvasCommit}).
+     */
+    setCanvasValue(field: FieldDef, lift: CanvasLift): void;
     /** The slot alias (a document-level key: a whole-document write at the held revision). */
     setAlias(alias: string | undefined): void;
     /** Field boundary events (focus / blur / Enter) — the commit policy's triggers. */
     focused(field: FieldDef): void;
     blurred(field: FieldDef): void;
     entered(field: FieldDef): void;
+    /**
+     * EC-630 — the canvas inspector's boundary events: a control writing `position` of the
+     * canvas field `field`, committing on `policy` (THE declaration for its kind). A burst of
+     * typing in it is its uncommitted position until blur / Enter / the idle pause.
+     */
+    canvasFocused(field: FieldDef, position: CanvasControlPosition, policy: CommitPolicy): void;
+    canvasBlurred(field: FieldDef, position: CanvasControlPosition): void;
+    canvasEntered(field: FieldDef, position: CanvasControlPosition): void;
     /** The forced commit (sync; the persister serialises what follows) / the record model's Save. */
     save(): void;
     /** The FORCED FLUSH: commit everything uncommitted and await persistence. */
     flush(): Promise<void>;
     /** Adopt a draft from outside (a restored version). */
     replaceDraft(next: CmsDocument): void;
-    /** Bumped when the canvas must remount from the draft (a restore, a colleague's change). */
+    /**
+     * Bumped when the canvas must remount from the draft: a restored version replaced the
+     * document, or a locale switch pointed the canvas at another bucket. (A change made
+     * underneath the canvas is NOT a remount — {@link canvasChange}.)
+     */
     canvasNonce: number;
+    /**
+     * EC-630 — the latest change of the canvas field's value made UNDERNEATH the canvas (a
+     * colleague's patch by subscription, a write's canonical row, a resolved conflict): the
+     * draft's value before and after it. The canvas REBASES onto it — the change lands, its
+     * undo history and selection survive — where it used to remount and lose both.
+     */
+    canvasChange: CanvasFieldChange | undefined;
     /** The OTHER sessions present on this document, live by the reader's clock. */
     presence: readonly PresenceEntry[];
 }

package/dist/components/cms/use-document-draft.js

@@ -4,6 +4,7 @@ import { applyDocumentPatches, formatValuePath, readValueAt, semanticValueEqual,
 import { fieldPositionPath } from '../../lib/cms/field-patch.js';
 import { compositionPatches } from '../builder/composition-patches.js';
 import { commitPolicyOf } from './commit-policy.js';
+import { canvasControl, routeCanvasWrite } from './canvas-commit.js';
 import { browserScheduler, createDraftCommitter } from './draft-commit.js';
 /**
  * EC-595 A2 — the detail editor's draft over the revisioned document (and, for the
@@ -13,7 +14,9 @@ import { browserScheduler, createDraftCommitter } from './draft-commit.js';
  * reads it); a field's edit is COMMITTED per its control kind's policy
  * ({@link commitPolicyOf} / {@link createDraftCommitter}) as the patch of the position it
  * wrote — never a document. The canvas commits each action's node patches at once
- * (`compositionPatches`). The draft REBASES whenever the session's document changes
+ * (`compositionPatches`); a burst of typing in one of its inspector controls is that
+ * control's uncommitted position, committed on its kind's policy like a form field
+ * (EC-630, `canvas-commit.ts`). The draft REBASES whenever the session's document changes
  * (a write result, a colleague's change by subscription, a resolved conflict): it is the
  * session's document with this editor's uncommitted positions laid over it — local wins
  * until committed, then the per-path check decides (EC-595 point 7).
@@ -44,6 +47,22 @@ export const documentVisibility = {
         return () => document.removeEventListener('visibilitychange', listener);
     },
 };
+/**
+ * EC-647 — the slot alias write (pure): the draft with `alias` set (or removed), written
+ * whole AT THE DRAFT'S REVISION — never the session's tracked one, which may already hold
+ * a colleague's change the draft has not absorbed (Codex F10). There is no identity-
+ * metadata operation for the alias (the value-position grammar has no position for it,
+ * measured on the base), so it stays a whole-document `replace` with its precondition.
+ */
+export function aliasWrite(draft, alias, writes) {
+    const next = { ...draft.document };
+    if (alias === undefined)
+        delete next.alias;
+    else
+        next.alias = alias;
+    writes.replace(next, draft.revision);
+    return next;
+}
 /** The patch that writes the value `doc` holds at `path` (unset when absent). */
 export function positionPatch(doc, path) {
     const value = readValueAt(doc, path);
@@ -59,6 +78,81 @@ export function rebaseDraft(sessionDoc, draft, uncommitted) {
     const patches = uncommitted.map((position) => positionPatch(draft, position.path));
     return applyDocumentPatches({ document: sessionDoc, patches, since: [] }).document;
 }
+/**
+ * EC-630 — the canvas's write into the draft (pure). The canvas writer's node patches,
+ * keyed by node id, are the canvas's OWN delta: from `base`, the value it last agreed on
+ * with the draft, to `value` — never a document diff, and never measured against the
+ * draft's CURRENT value (a colleague's change that reached the draft a moment before the
+ * edit lifted would read as part of the edit, and its patches would revert it). The draft
+ * takes the delta over whatever it holds now (normally `base` itself) and canonicalises the
+ * field through the write lens. `undefined` when the canvas changed nothing.
+ */
+export function canvasWrite(input) {
+    const { collection, draft, field, locale, lookupManifest } = input;
+    const path = fieldPositionPath(collection, field, locale);
+    const localized = path.length > 1 ? locale : undefined;
+    const patches = compositionPatches(input.base, input.value, field, localized);
+    if (patches.length === 0)
+        return undefined;
+    const applied = applyDocumentPatches({ document: draft, patches, since: [] }).document;
+    return { next: writeField(collection, draft, field, locale, readValueAt(applied, path), { lookupManifest }), patches };
+}
+/**
+ * EC-630 — the change of the canvas field made UNDERNEATH the canvas when the draft
+ * rebased from `previous` to `next` (pure), numbered after `last`; `undefined` when the
+ * field did not move. The canvas's own edits are in both values (the session's view holds
+ * every patch it committed, the draft overlays every position it has not), so the change
+ * is someone else's: a colleague's patch, a write's canonical row, a resolved conflict.
+ *
+ * EC-647: it carries `revision`, the revision the draft is at after the rebase, and is
+ * reported when only THAT moved too (`from` ≡ `to`): the canvas's agreed value is valid
+ * at the newer revision, so its next edit is authored there — the revision follows the
+ * value, never runs ahead of it.
+ */
+export function canvasFieldChange(previous, next, path, last, revision) {
+    const from = readValueAt(previous, path);
+    const to = readValueAt(next, path);
+    if (semanticValueEqual(from, to) && (last === undefined || last.revision === revision))
+        return undefined;
+    return { from, to, seq: (last?.seq ?? 0) + 1, revision };
+}
+/**
+ * EC-647 — the canvas's write path (pure; what {@link DocumentDraft.setCanvasValue} runs):
+ * the canvas writer's delta into the draft ({@link canvasWrite}, handed to `apply`), then
+ * routed ({@link routeCanvasWrite}) — committed at once, or held as a focused inspector
+ * control's uncommitted position — and in both cases paired with the revision of the
+ * canvas value the edit was authored on (`lift.revision`), never the draft's: the draft
+ * may already hold a colleague's change the canvas has not been rebased onto (Codex F12),
+ * and the store must check the edit from the canvas's revision to refuse it where it
+ * overlaps that change. `commit` absent → a draft without a revisioned write model (the
+ * draft moves, nothing is committed). `undefined` when the canvas changed nothing.
+ */
+export function canvasCommit(input) {
+    const { lift, commit } = input;
+    const write = canvasWrite({
+        collection: input.collection,
+        draft: input.draft,
+        field: input.field,
+        locale: input.locale,
+        value: lift.value,
+        base: lift.base,
+        lookupManifest: input.lookupManifest,
+    });
+    if (!write)
+        return undefined;
+    input.apply(write.next);
+    if (!commit)
+        return 'draft';
+    // EC-630: a burst of typing in a focused inspector control is that control's
+    // uncommitted position (its policy commits it); a canvas action commits now.
+    return routeCanvasWrite({
+        patches: write.patches,
+        focused: input.focused,
+        committer: input.committer,
+        revision: lift.revision,
+        commitNow: (patches) => commit(patches, patches.map(() => lift.revision)),
+    });
+}
 /**
  * The reader's "now" for presence liveness: THIS session's own latest heartbeat `at`
  * (written by the same store clock as everyone else's — the playground store runs a
@@ -84,63 +178,65 @@ export function useDocumentDraft(input) {
     const writes = source.writes;
     const documentModel = writes.kind === 'document' ? writes : undefined;
     const ref = useMemo(() => ({ collection: doc.collection, id: doc.id }), [doc.collection, doc.id]);
-    const [draft, setDraftState] = useState(doc);
-    const draftRef = useRef(draft);
+    // EC-647: the draft and the revision of the view it rebased onto travel as ONE value.
+    const [view, setViewState] = useState(() => ({
+        document: doc,
+        revision: documentModel?.revisionOfView(doc),
+    }));
+    const draft = view.document;
+    const draftRef = useRef(view);
     // EC-616: the record as the editor opened it (or as of their last successful save) — the
     // BASE a record rail diffs a save against, so it writes only the editor's changes. It moves
     // only while the draft equals the source's value (at open, and once a save is reflected
     // back): another writer's change arriving mid-edit never becomes the editor's base.
     const baseRef = useRef(doc);
-    baseRef.current = recordSaveBase(baseRef.current, draftRef.current, doc);
-    const setDraft = useCallback((next) => {
+    baseRef.current = recordSaveBase(baseRef.current, draftRef.current.document, doc);
+    const setView = useCallback((next) => {
         draftRef.current = next;
-        setDraftState(next);
+        setViewState(next);
     }, []);
+    /** An edit of the draft: its value moves, the revision it is authored against does not. */
+    const setDraft = useCallback((next) => setView({ document: next, revision: draftRef.current.revision }), [setView]);
     const scheduler = input.scheduler ?? browserScheduler;
     const now = input.now ?? (() => new Date().toISOString());
     const fieldsByName = useMemo(() => new Map(collection.fields.map((f) => [f.name, f])), [collection]);
     // --- Committing --------------------------------------------------------------------
     const writesRef = useRef(documentModel);
     writesRef.current = documentModel;
+    /** EC-630 — the canvas inspector controls that took focus, by committer key (their position + policy). */
+    const canvasControls = useRef(new Map());
     const committer = useMemo(() => createDraftCommitter({
         policyOf: (name) => {
             const field = fieldsByName.get(name);
-            return field ? commitPolicyOf(field) : 'blur-or-idle';
+            if (field)
+                return commitPolicyOf(field);
+            return canvasControls.current.get(name)?.policy ?? 'blur-or-idle';
         },
         commit: (positions) => {
             const target = writesRef.current;
             if (!target)
                 return;
-            void target.commit(ref, positions.map((position) => positionPatch(draftRef.current, position.path)), positions.map((position) => position.base));
+            void target.commit(ref, positions.map((position) => positionPatch(draftRef.current.document, position.path)), positions.map((position) => position.base));
         },
-        baseOf: () => writesRef.current?.revisionOf(ref),
+        // EC-647: a position's base is the revision of the DRAFT its first keystroke was
+        // made on — never the session's tracked revision, which may already hold a
+        // colleague's change the draft has not rebased onto yet.
+        baseOf: () => draftRef.current.revision,
         scheduler,
     }), 
     // One committer per open document (the editor is keyed by it).
     [ref]);
-    // --- The canvas's value and its remount ---------------------------------------------
+    // --- The canvas's value: its remount and its rebase ------------------------------------
     const canvasPath = canvasField ? fieldPositionPath(collection, canvasField.name, locale) : undefined;
     const canvasPathKey = canvasPath ? formatValuePath(canvasPath) : '';
-    const canvasValueRef = useRef(canvasPath ? readValueAt(draft, canvasPath) : undefined);
     const [canvasNonce, setCanvasNonce] = useState(0);
-    const syncCanvas = useCallback((next) => {
-        if (!canvasPath)
-            return;
-        const value = readValueAt(next, canvasPath);
-        if (semanticValueEqual(value, canvasValueRef.current))
-            return;
-        canvasValueRef.current = value;
-        setCanvasNonce((n) => n + 1);
-    }, 
-    // The path is keyed by its string form.
-    [canvasPathKey]);
+    const [canvasChange, setCanvasChange] = useState(undefined);
     // A locale switch points the canvas at another bucket: remount from it.
     const lastCanvasPathKey = useRef(canvasPathKey);
     useEffect(() => {
         if (lastCanvasPathKey.current === canvasPathKey)
             return;
         lastCanvasPathKey.current = canvasPathKey;
-        canvasValueRef.current = canvasPath ? readValueAt(draftRef.current, canvasPath) : undefined;
         setCanvasNonce((n) => n + 1);
     }, [canvasPathKey]);
     // --- The rebase (document model) -------------------------------------------------------
@@ -152,54 +248,64 @@ export function useDocumentDraft(input) {
         }
         if (!documentModel)
             return;
-        const next = rebaseDraft(doc, draftRef.current, committer.uncommitted());
-        setDraft(next);
-        syncCanvas(next);
+        const previous = draftRef.current.document;
+        const next = rebaseDraft(doc, previous, committer.uncommitted());
+        // EC-647: the rebase moves the value AND the revision — the session view's own.
+        const revision = documentModel.revisionOfView(doc);
+        setView({ document: next, revision });
+        // EC-630: the canvas field moved underneath the canvas — the canvas rebases onto the
+        // change (its own edits are in both values: the session's view holds every patch it
+        // committed, and the draft overlays every position it has not). EC-647: the change
+        // carries the revision, so the canvas's next edit is authored where its value is.
+        if (!canvasPath)
+            return;
+        setCanvasChange((last) => canvasFieldChange(previous, next, canvasPath, last, revision) ?? last);
     }, [doc]);
     // --- Writers ----------------------------------------------------------------------------
     const setFieldValue = useCallback((field, value) => {
-        const next = writeField(collection, draftRef.current, field.name, locale, value, { lookupManifest });
+        const next = writeField(collection, draftRef.current.document, field.name, locale, value, { lookupManifest });
         setDraft(next);
         if (documentModel)
             committer.edited(field.name, fieldPositionPath(collection, field.name, locale));
     }, [collection, locale, lookupManifest, setDraft, documentModel, committer]);
     const editField = useCallback((field, update) => {
-        setDraft(update(draftRef.current));
+        setDraft(update(draftRef.current.document));
         if (documentModel)
             committer.edited(field.name, fieldPositionPath(collection, field.name, locale));
     }, [collection, locale, setDraft, documentModel, committer]);
-    const setCanvasValue = useCallback((field, value) => {
-        const path = fieldPositionPath(collection, field.name, locale);
-        const before = readValueAt(draftRef.current, path);
-        const next = writeField(collection, draftRef.current, field.name, locale, value, { lookupManifest });
-        const after = readValueAt(next, path);
-        setDraft(next);
-        canvasValueRef.current = after;
-        if (!documentModel)
-            return;
-        // The canvas writer's node patches, keyed by node id (computed here, in its write
-        // path, from the canonical values before and after the action — never a document diff).
-        const localized = path.length > 1 ? locale : undefined;
-        void documentModel.commit(ref, compositionPatches(before, after, field.name, localized));
-    }, [collection, locale, lookupManifest, setDraft, documentModel, ref]);
+    const setCanvasValue = useCallback((field, lift) => {
+        const focus = committer.focusedField();
+        canvasCommit({
+            collection,
+            draft: draftRef.current.document,
+            field: field.name,
+            locale,
+            lift,
+            lookupManifest,
+            focused: focus === undefined ? undefined : canvasControls.current.get(focus),
+            committer,
+            apply: setDraft,
+            ...(documentModel
+                ? { commit: (patches, bases) => void documentModel.commit(ref, patches, bases) }
+                : {}),
+        });
+    }, [collection, locale, lookupManifest, setDraft, documentModel, ref, committer]);
     const setAlias = useCallback((alias) => {
-        const next = { ...draftRef.current };
-        if (alias === undefined)
-            delete next.alias;
-        else
-            next.alias = alias;
-        setDraft(next);
-        if (!documentModel)
+        if (!documentModel) {
+            aliasWrite(draftRef.current, alias, { replace: (next) => setDraft(next) });
             return;
+        }
+        // The uncommitted positions first (the snapshot holds them), then the snapshot AT
+        // THE DRAFT'S REVISION (EC-647 — Codex F10).
         committer.commitAll();
-        documentModel.replace(next);
+        setDraft(aliasWrite(draftRef.current, alias, documentModel));
     }, [setDraft, documentModel, committer]);
     // --- Forced flush ----------------------------------------------------------------------
     const save = useCallback(() => {
         if (documentModel)
             committer.commitAll();
         else if (writes.kind === 'record')
-            writes.save(draftRef.current, baseRef.current);
+            writes.save(draftRef.current.document, baseRef.current);
     }, [documentModel, committer, writes]);
     const flush = useCallback(async () => {
         save();
@@ -271,13 +377,46 @@ export function useDocumentDraft(input) {
         if (documentModel)
             committer.entered(field.name);
     }, [documentModel, committer]);
+    // EC-630 — the canvas inspector's commit boundary: a control at a position of the canvas
+    // field gained focus, lost it, or saw Enter. Its policy is THE declaration's for its kind.
+    const canvasControlOf = useCallback((field, position, policy) => canvasControl(fieldPositionPath(collection, field.name, locale), position, policy), [collection, locale]);
+    const canvasFocused = useCallback((field, position, policy) => {
+        if (!documentModel)
+            return;
+        const control = canvasControlOf(field, position, policy);
+        canvasControls.current.set(control.key, control);
+        committer.focused(control.key);
+        focusedPathRef.current = control.path;
+        heartbeat();
+    }, [documentModel, committer, canvasControlOf, heartbeat]);
+    const canvasBlurred = useCallback((field, position) => {
+        if (!documentModel)
+            return;
+        const key = canvasControlOf(field, position, 'change').key;
+        committer.blurred(key);
+        canvasControls.current.delete(key);
+        focusedPathRef.current = undefined;
+        heartbeat();
+    }, [documentModel, committer, canvasControlOf, heartbeat]);
+    const canvasEntered = useCallback((field, position) => {
+        if (documentModel)
+            committer.entered(canvasControlOf(field, position, 'change').key);
+    }, [documentModel, committer, canvasControlOf]);
     const replaceDraft = useCallback((next) => {
-        setDraft(next);
-        syncCanvas(next);
-    }, [setDraft, syncCanvas]);
+        // A restored version replaces the document: when it moved the canvas field, the
+        // canvas remounts from it (its history belonged to the replaced value).
+        const moved = canvasPath && !semanticValueEqual(readValueAt(draftRef.current.document, canvasPath), readValueAt(next, canvasPath));
+        // EC-647: the restored value comes with the revision the session showed it at.
+        setView({ document: next, revision: documentModel?.revisionOfView(next) });
+        if (moved)
+            setCanvasNonce((n) => n + 1);
+    }, 
+    // The path is keyed by its string form.
+    [setView, documentModel, canvasPathKey]);
     const dirty = useMemo(() => !semanticValueEqual(draft, doc), [draft, doc]);
     return {
         draft,
+        revision: view.revision,
         dirty,
         explicitSave: writes.kind === 'record',
         setFieldValue,
@@ -287,10 +426,14 @@ export function useDocumentDraft(input) {
         focused,
         blurred,
         entered,
+        canvasFocused,
+        canvasBlurred,
+        canvasEntered,
         save,
         flush,
         replaceDraft,
         canvasNonce,
+        canvasChange,
         presence,
     };
 }