@elytracms/studio 0.0.96 → 0.0.98

package/dist/components/cms/rich-text/value.js.map

@@ -1 +1 @@
-{"version":3,"file":"value.js","sourceRoot":"","sources":["../../../../src/components/cms/rich-text/value.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  createBlockSequenceValue,\n  isBlockSequenceValueShape,\n  componentBlockNode,\n  richTextDocsEquivalent,\n} from '@elytracms/core/rich-text'\nimport type {\n  BlockNode,\n  BlockSequenceValue,\n  RichTextDoc,\n  RichTextNode,\n  TypographyNode,\n} from '@elytracms/core/rich-text'\nimport { isComponentBlockNode, isComponentNode } from '@elytracms/core/project-graph'\nimport type { JsonValue } from '@elytracms/core/project-graph'\nimport { COMPONENT_EMBED_NODE_TYPE } from './component-embed'\nimport { UNKNOWN_NODE_CARRIER_TYPE } from './unknown-node'\n\n/**\n * Storage ⟷ editor projection for the CMS TipTap flow editor (EC-314, converged\n * by EC-547 per the EC-500 design).\n *\n * Storage is the converged block sequence `{ version: 2, content: BlockNode[] }`\n * — typography nodes byte-identical to the historical rich-text shape plus\n * first-class `elytra/component` nodes. TipTap requires ITS grammar (a\n * `{ type: 'doc', content }` document over a CLOSED schema), so this module is\n * the just-in-time projection between the two:\n *\n * - **Way in** ({@link toEditorDoc}): typography passes near-identically; an\n *   `elytra/component` node becomes the existing ComponentEmbed atom (the\n *   original node riding verbatim in `attrs.node`); any node type the editor\n *   does not natively edit is wrapped into the opaque\n *   {@link UNKNOWN_NODE_CARRIER_TYPE} atom so the closed ProseMirror schema\n *   cannot drop it.\n * - **Way out** ({@link blockSequenceValueFromDoc}): embed atoms convert back to\n *   tagged `elytra/component` nodes, carriers restore their carried JSON\n *   byte-for-byte, typography is re-emitted with {@link normalizeEditorDoc}'s\n *   lean-attrs canonicalisation applied.\n *\n * The round-trip law (EC-500 D3): the projection may only rewrite nodes the flow\n * editor natively edits; every other node survives byte-for-byte.\n *\n * Two editor-ergonomics concerns carry over unchanged from EC-314:\n *\n * 1. **Lean canonicalisation.** ProseMirror stamps every declared attribute onto a\n *    node/mark, so TipTap emits `null` defaults the lean storage convention omits\n *    (`link` → `ref: null`, `codeBlock` → `language: null`, `image` → `title: null`).\n *    {@link normalizeEditorDoc} prunes those so an untouched document round-trips to\n *    the same shape the extractor/renderer already read.\n *\n * 2. **No false dirty.** Opening a field must not mark it changed, and typing then\n *    undoing back to the original must clear dirty. {@link isEquivalentToStored}\n *    compares semantically in editor-projection space so the editor can re-emit the\n *    *exact stored value* when nothing really changed.\n */\n\n/**\n * The storage node types the flow editor natively edits — the projection's ONE\n * wrap/pass decision: anything outside this set rides through the editor inside\n * the opaque carrier atom. Everything listed here MUST be declared by\n * `buildRichTextExtensions`' ProseMirror schema (an undeclared type would be\n * silently dropped); `extensions.test.ts` pins the two sets equal, so drift\n * between this declaration and the schema is loud.\n *\n * The ProseMirror schema declares TWO more types than this set: the\n * ComponentEmbed atom and the carrier — both editor-only projection vehicles\n * that are never valid STORAGE vocabulary (EC-548 retired `componentEmbed` at\n * rest). Excluding them here is deliberate and load-bearing: a STORED node\n * reusing either name is a foreigner and rides the carrier byte-for-byte,\n * instead of being misread as an editor atom (which for a stored\n * `componentEmbed` would silently rewrite it to `elytra/component` on save —\n * a compat migration the owner ruled out).\n */\nexport const EDITOR_NATIVE_NODE_TYPES: ReadonlySet<string> = new Set([\n  'doc',\n  'paragraph',\n  'text',\n  'heading',\n  'bulletList',\n  'orderedList',\n  'listItem',\n  'blockquote',\n  'codeBlock',\n  'hardBreak',\n  'horizontalRule',\n  'image',\n])\n\n/** ProseMirror node types that carry no reference/atom payload and render as prose. */\nconst EMPTY_TOLERANT_BLOCKS = new Set(['paragraph', 'heading'])\n\n/**\n * Project whatever a body-capable field currently holds into an editor document.\n *\n * Accepts the canonical v2 `{ version: 2, content }` sequence (object or JSON\n * string) and projects it per the module contract. Anything unparseable becomes\n * an empty document (never throws; validation is first-class elsewhere). The\n * projection is deliberately TOTAL and shape-driven, not schema-validating: a\n * v2 value with one malformed node must still open (the bad node rides in a\n * carrier, visibly labelled) rather than blanking the whole field — the editor\n * is not the validator.\n */\nexport function toEditorDoc(value: unknown): RichTextDoc {\n  const sequence = asBlockSequenceShape(value)\n  if (sequence) {\n    return { type: 'doc', content: sequence.content.map(projectStoredNode) }\n  }\n  // Anything that is not the v2 sequence (a pre-convergence envelope, a bare\n  // doc, legacy plaintext, junk) opens EMPTY — deliberately not projected:\n  // validation names those shapes with the explicit \"re-seed\" issue (EC-548\n  // deleted the staging acceptance), and quietly editing over them here would\n  // hide it.\n  return { type: 'doc', content: [] }\n}\n\n/** Structural v2 test, tolerating a JSON-string form of the same value. */\nfunction asBlockSequenceShape(value: unknown): { version: 2; content: unknown[] } | undefined {\n  if (isBlockSequenceValueShape(value)) return value\n  if (typeof value === 'string') {\n    try {\n      const parsed: unknown = JSON.parse(value)\n      if (isBlockSequenceValueShape(parsed)) return parsed\n    } catch {\n      /* not JSON — fall through */\n    }\n  }\n  return undefined\n}\n\n/**\n * One stored node → its editor projection. Total over arbitrary JSON:\n *\n * - a tagged component node → the ComponentEmbed atom, the node itself riding\n *   verbatim (tag included) in `attrs.node`;\n * - a node type the editor natively edits → passed through, `content` recursed\n *   (so a component nested in a blockquote still projects to an embed);\n * - EVERYTHING else — foreign types, a tagged-but-malformed component node,\n *   even non-node JSON in the content array — → the opaque carrier atom, the\n *   original payload riding verbatim in `attrs.node`.\n */\nfunction projectStoredNode(node: unknown): RichTextNode {\n  if (isComponentBlockNode(node)) {\n    return { type: COMPONENT_EMBED_NODE_TYPE, attrs: { node: node as unknown as JsonValue } }\n  }\n  if (isEditorNativeNode(node)) {\n    const out: RichTextNode = { ...node }\n    if (node.content) out.content = node.content.map(projectStoredNode)\n    return out\n  }\n  return { type: UNKNOWN_NODE_CARRIER_TYPE, attrs: { node: node as JsonValue } }\n}\n\nfunction isEditorNativeNode(node: unknown): node is RichTextNode {\n  return (\n    typeof node === 'object' &&\n    node !== null &&\n    !Array.isArray(node) &&\n    typeof (node as { type?: unknown }).type === 'string' &&\n    EDITOR_NATIVE_NODE_TYPES.has((node as { type: string }).type)\n  )\n}\n\n/**\n * Project a (normalized) editor document back into the stored v2 sequence —\n * the way-out half of the module contract: embed atoms → tagged\n * `elytra/component` nodes, carriers → their carried JSON byte-for-byte,\n * typography re-emitted as-is (lean canonicalisation is\n * {@link normalizeEditorDoc}'s job, upstream).\n */\nexport function blockSequenceValueFromDoc(doc: RichTextDoc): BlockSequenceValue {\n  return createBlockSequenceValue((doc.content ?? []).map(restoreStoredNode))\n}\n\nfunction restoreStoredNode(node: RichTextNode): BlockNode {\n  if (node.type === COMPONENT_EMBED_NODE_TYPE) {\n    const embedded: unknown = node.attrs?.node\n    if (isComponentNode(embedded)) {\n      // Re-tag through the one constructor (identity on already-tagged nodes),\n      // so an atom payload the node factory built untagged leaves the editor\n      // as a first-class tagged citizen — \"write current\".\n      const { type: _tag, ...rest } = embedded\n      return componentBlockNode(rest)\n    }\n    // An embed whose payload is missing/malformed: keep the node verbatim as\n    // typography — never a silent drop; validation reports it elsewhere.\n    return node as TypographyNode\n  }\n  if (node.type === UNKNOWN_NODE_CARRIER_TYPE) {\n    const carried: unknown = node.attrs?.node\n    // Byte-for-byte restore of the carried original (the D3 round-trip law).\n    // An empty carrier (nothing to restore — not constructible via the\n    // projection) degrades to the carrier node itself staying visible.\n    if (carried !== null && carried !== undefined) return carried as BlockNode\n    return node as TypographyNode\n  }\n  const out: TypographyNode = { ...(node as TypographyNode) }\n  if (node.content) out.content = node.content.map(restoreStoredNode)\n  return out\n}\n\n/**\n * Prune the `null` attribute values ProseMirror stamps from declared-but-unset\n * attributes, and drop the resulting empty `attrs` bags, so the editor's output\n * matches the lean storage convention. Recurses `content`; leaves `marks` attrs\n * pruned the same way. Pure; returns a fresh tree. (Embed and carrier payloads\n * are single non-null `attrs` entries, so pruning passes them through by\n * reference — their bytes are never rewritten here.)\n */\nexport function normalizeEditorDoc(doc: RichTextDoc): RichTextDoc {\n  return { type: 'doc', content: (doc.content ?? []).map(pruneNode) }\n}\n\nfunction pruneNode(node: RichTextNode): RichTextNode {\n  const out: RichTextNode = { type: node.type }\n  const attrs = pruneAttrs(node.attrs)\n  if (attrs) out.attrs = attrs\n  if (typeof node.text === 'string') out.text = node.text\n  if (node.marks && node.marks.length > 0) {\n    out.marks = node.marks.map((mark) => {\n      const markAttrs = pruneAttrs(mark.attrs)\n      return markAttrs ? { type: mark.type, attrs: markAttrs } : { type: mark.type }\n    })\n  }\n  if (node.content) out.content = node.content.map(pruneNode)\n  return out\n}\n\nfunction pruneAttrs(\n  attrs: Record<string, unknown> | undefined,\n): Record<string, never> | undefined {\n  if (!attrs) return undefined\n  const entries = Object.entries(attrs).filter(([, v]) => v !== null && v !== undefined)\n  return entries.length > 0 ? (Object.fromEntries(entries) as Record<string, never>) : undefined\n}\n\n/**\n * Whether a document carries no author-visible content — only empty paragraphs or\n * headings (TipTap keeps a mandatory trailing block even when the field is blank).\n * Any text, atom (image/embed/carrier/hardBreak/hr), list, or blockquote makes it\n * non-empty.\n */\nexport function isEffectivelyEmpty(doc: RichTextDoc): boolean {\n  return (doc.content ?? []).every(isEmptyBlock)\n}\n\nfunction isEmptyBlock(node: RichTextNode): boolean {\n  if (!EMPTY_TOLERANT_BLOCKS.has(node.type)) return false\n  return (node.content ?? []).every(\n    (child) => child.type === 'text' && (child.text ?? '').length === 0,\n  )\n}\n\n/**\n * Whether the (already normalized) editor document is semantically the stored one —\n * so the editor can re-emit the exact stored value instead of a re-serialization,\n * keeping the field un-dirtied. Both sides are compared in editor-projection space\n * ({@link toEditorDoc} is deterministic), so a stored v2 component/carrier and its\n * on-screen atom compare equal. Two empty documents are always equivalent (the\n * trailing-paragraph difference between `content: []` and `[{ paragraph }]` is not\n * a change); otherwise defers to the shared structural comparison.\n */\nexport function isEquivalentToStored(current: RichTextDoc, storedValue: unknown): boolean {\n  const stored = toEditorDoc(storedValue)\n  if (isEffectivelyEmpty(current) && isEffectivelyEmpty(stored)) return true\n  return richTextDocsEquivalent(current, stored)\n}\n"]}
+{"version":3,"file":"value.js","sourceRoot":"","sources":["../../../../src/components/cms/rich-text/value.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  createBlockSequenceValue,\n  isBlockSequenceValueShape,\n  componentBlockNode,\n  richTextDocsEquivalent,\n} from '@elytracms/core/rich-text'\nimport type {\n  BlockNode,\n  BlockSequenceValue,\n  RichTextDoc,\n  RichTextNode,\n  TypographyNode,\n} from '@elytracms/core/rich-text'\nimport { isComponentBlockNode, isComponentNode } from '@elytracms/core/project-graph'\nimport type { JsonValue } from '@elytracms/core/project-graph'\nimport { COMPONENT_EMBED_NODE_TYPE } from './component-embed'\nimport { UNKNOWN_NODE_CARRIER_TYPE } from './unknown-node'\n\n/**\n * Storage ⟷ editor projection for the CMS TipTap flow editor (EC-314, converged\n * by EC-547 per the EC-500 design).\n *\n * Storage is the converged block sequence `{ version: 2, content: BlockNode[] }`\n * — typography nodes byte-identical to the historical rich-text shape plus\n * first-class `elytra/component` nodes. TipTap requires ITS grammar (a\n * `{ type: 'doc', content }` document over a CLOSED schema), so this module is\n * the just-in-time projection between the two:\n *\n * - **Way in** ({@link toEditorDoc}): typography passes near-identically; an\n *   `elytra/component` node becomes the existing ComponentEmbed atom (the\n *   original node riding verbatim in `attrs.node`); any node type the editor\n *   does not natively edit is wrapped into the opaque\n *   {@link UNKNOWN_NODE_CARRIER_TYPE} atom so the closed ProseMirror schema\n *   cannot drop it.\n * - **Way out** ({@link blockSequenceValueFromDoc}): embed atoms convert back to\n *   tagged `elytra/component` nodes, carriers restore their carried JSON\n *   byte-for-byte, typography is re-emitted with {@link normalizeEditorDoc}'s\n *   lean-attrs canonicalisation applied.\n *\n * The round-trip law (EC-500 D3): the projection may only rewrite nodes the flow\n * editor natively edits; every other node survives byte-for-byte.\n *\n * Two editor-ergonomics concerns carry over unchanged from EC-314:\n *\n * 1. **Lean canonicalisation.** ProseMirror stamps every declared attribute onto a\n *    node/mark, so TipTap emits `null` defaults the lean storage convention omits\n *    (`link` → `ref: null`, `codeBlock` → `language: null`, `image` → `title: null`).\n *    {@link normalizeEditorDoc} prunes those so an untouched document round-trips to\n *    the same shape the extractor/renderer already read.\n *\n * 2. **No false dirty.** Opening a field must not mark it changed, and typing then\n *    undoing back to the original must clear dirty. {@link isEquivalentToStored}\n *    compares semantically in editor-projection space so the editor can re-emit the\n *    *exact stored value* when nothing really changed.\n */\n\n/**\n * The storage node types the flow editor natively edits — the projection's ONE\n * wrap/pass decision: anything outside this set rides through the editor inside\n * the opaque carrier atom. Everything listed here MUST be declared by\n * `buildRichTextExtensions`' ProseMirror schema (an undeclared type would be\n * silently dropped); `extensions.test.ts` pins the two sets equal, so drift\n * between this declaration and the schema is loud.\n *\n * The ProseMirror schema declares TWO more types than this set: the\n * ComponentEmbed atom and the carrier — both editor-only projection vehicles\n * that are never valid STORAGE vocabulary (EC-548 retired `componentEmbed` at\n * rest). Excluding them here is deliberate and load-bearing: a STORED node\n * reusing either name is a foreigner and rides the carrier byte-for-byte,\n * instead of being misread as an editor atom (which for a stored\n * `componentEmbed` would silently rewrite it to `elytra/component` on save —\n * a compat migration the owner ruled out).\n */\nexport const EDITOR_NATIVE_NODE_TYPES: ReadonlySet<string> = new Set([\n  'doc',\n  'paragraph',\n  'text',\n  'heading',\n  'bulletList',\n  'orderedList',\n  'listItem',\n  'blockquote',\n  'codeBlock',\n  'hardBreak',\n  'horizontalRule',\n  'image',\n])\n\n/** ProseMirror node types that carry no reference/atom payload and render as prose. */\nconst EMPTY_TOLERANT_BLOCKS = new Set(['paragraph', 'heading'])\n\n/**\n * Project whatever a body-capable field currently holds into an editor document.\n *\n * Accepts the canonical v2 `{ version: 2, content }` sequence (object or JSON\n * string) and projects it per the module contract. Anything unparseable becomes\n * an empty document (never throws; validation is first-class elsewhere). The\n * projection is deliberately TOTAL and shape-driven, not schema-validating: a\n * v2 value with one malformed node must still open (the bad node rides in a\n * carrier, visibly labelled) rather than blanking the whole field — the editor\n * is not the validator.\n */\nexport function toEditorDoc(value: unknown): RichTextDoc {\n  const sequence = asBlockSequenceShape(value)\n  if (sequence) {\n    return { type: 'doc', content: sequence.content.map(projectStoredNode) }\n  }\n  // Anything that is not the v2 sequence (a pre-convergence envelope, a bare\n  // doc, legacy plaintext, junk) opens EMPTY — deliberately not projected:\n  // validation names those shapes with the explicit \"re-seed\" issue (EC-548\n  // deleted the staging acceptance), and quietly editing over them here would\n  // hide it.\n  return { type: 'doc', content: [] }\n}\n\n/** Structural v2 test, tolerating a JSON-string form of the same value. */\nfunction asBlockSequenceShape(value: unknown): { version: 2; content: unknown[] } | undefined {\n  if (isBlockSequenceValueShape(value)) return value\n  if (typeof value === 'string') {\n    try {\n      const parsed: unknown = JSON.parse(value)\n      if (isBlockSequenceValueShape(parsed)) return parsed\n    } catch {\n      /* not JSON — fall through */\n    }\n  }\n  return undefined\n}\n\n/**\n * One stored node → its editor projection. Total over arbitrary JSON:\n *\n * - a tagged component node → the ComponentEmbed atom, the node itself riding\n *   verbatim (tag included) in `attrs.node`;\n * - a node type the editor natively edits → passed through, `content` recursed\n *   (so a component nested in a blockquote still projects to an embed);\n * - EVERYTHING else — foreign types, a tagged-but-malformed component node,\n *   even non-node JSON in the content array — → the opaque carrier atom, the\n *   original payload riding verbatim in `attrs.node`.\n */\nfunction projectStoredNode(node: unknown): RichTextNode {\n  if (isComponentBlockNode(node)) {\n    return { type: COMPONENT_EMBED_NODE_TYPE, attrs: { node: node as unknown as JsonValue } }\n  }\n  if (isEditorNativeNode(node)) {\n    const out: RichTextNode = { ...node }\n    if (node.content) out.content = node.content.map(projectStoredNode)\n    return out\n  }\n  return { type: UNKNOWN_NODE_CARRIER_TYPE, attrs: { node: node as JsonValue } }\n}\n\nfunction isEditorNativeNode(node: unknown): node is RichTextNode {\n  return (\n    typeof node === 'object' &&\n    node !== null &&\n    !Array.isArray(node) &&\n    typeof (node as { type?: unknown }).type === 'string' &&\n    EDITOR_NATIVE_NODE_TYPES.has((node as { type: string }).type)\n  )\n}\n\n/**\n * Project a (normalized) editor document back into the stored v2 sequence —\n * the way-out half of the module contract: embed atoms → tagged\n * `elytra/component` nodes, carriers → their carried JSON byte-for-byte,\n * typography re-emitted as-is (lean canonicalisation is\n * {@link normalizeEditorDoc}'s job, upstream).\n */\nexport function blockSequenceValueFromDoc(doc: RichTextDoc): BlockSequenceValue {\n  return createBlockSequenceValue((doc.content ?? []).map(restoreStoredNode))\n}\n\nfunction restoreStoredNode(node: RichTextNode): BlockNode {\n  if (node.type === COMPONENT_EMBED_NODE_TYPE) {\n    const embedded: unknown = node.attrs?.node\n    if (isComponentNode(embedded)) {\n      // Re-tag through the one constructor (identity on already-tagged nodes),\n      // so an atom payload the node factory built untagged leaves the editor\n      // as a first-class tagged citizen — \"write current\".\n      const { type: _tag, ...rest } = embedded\n      return componentBlockNode(rest)\n    }\n    // An embed whose payload is missing/malformed: keep the node verbatim as\n    // typography — never a silent drop; validation reports it elsewhere.\n    return node as TypographyNode\n  }\n  if (node.type === UNKNOWN_NODE_CARRIER_TYPE) {\n    const carried: unknown = node.attrs?.node\n    // Byte-for-byte restore of the carried original (the D3 round-trip law).\n    // An empty carrier (nothing to restore — not constructible via the\n    // projection) degrades to the carrier node itself staying visible.\n    if (carried !== null && carried !== undefined) return carried as BlockNode\n    return node as TypographyNode\n  }\n  const out: TypographyNode = { ...(node as TypographyNode) }\n  if (node.content) out.content = node.content.map(restoreStoredNode)\n  return out\n}\n\n/**\n * Prune the `null` attribute values ProseMirror stamps from declared-but-unset\n * attributes, and drop the resulting empty `attrs` bags, so the editor's output\n * matches the lean storage convention. Recurses `content`; leaves `marks` attrs\n * pruned the same way. Pure; returns a fresh tree. (Embed and carrier payloads\n * are single non-null `attrs` entries, so pruning passes them through by\n * reference — their bytes are never rewritten here.)\n */\nexport function normalizeEditorDoc(doc: RichTextDoc): RichTextDoc {\n  return { type: 'doc', content: (doc.content ?? []).map(pruneNode) }\n}\n\nfunction pruneNode(node: RichTextNode): RichTextNode {\n  const out: RichTextNode = { type: node.type }\n  const attrs = pruneAttrs(node.attrs)\n  if (attrs) out.attrs = attrs\n  if (typeof node.text === 'string') out.text = node.text\n  if (node.marks && node.marks.length > 0) {\n    out.marks = node.marks.map((mark) => {\n      const markAttrs = pruneAttrs(mark.attrs)\n      return markAttrs ? { type: mark.type, attrs: markAttrs } : { type: mark.type }\n    })\n  }\n  if (node.content) out.content = node.content.map(pruneNode)\n  return out\n}\n\nfunction pruneAttrs(\n  attrs: Record<string, unknown> | undefined,\n): Record<string, never> | undefined {\n  if (!attrs) return undefined\n  const entries = Object.entries(attrs).filter(([, v]) => v !== null && v !== undefined)\n  return entries.length > 0 ? (Object.fromEntries(entries) as Record<string, never>) : undefined\n}\n\n/**\n * Whether a document carries no author-visible content — only empty paragraphs or\n * headings (TipTap keeps a mandatory trailing block even when the field is blank).\n * Any text, atom (image/embed/carrier/hardBreak/hr), list, or blockquote makes it\n * non-empty.\n */\nexport function isEffectivelyEmpty(doc: RichTextDoc): boolean {\n  return (doc.content ?? []).every(isEmptyBlock)\n}\n\nfunction isEmptyBlock(node: RichTextNode): boolean {\n  if (!EMPTY_TOLERANT_BLOCKS.has(node.type)) return false\n  return (node.content ?? []).every(\n    (child) => child.type === 'text' && (child.text ?? '').length === 0,\n  )\n}\n\n/**\n * Whether the (already normalized) editor document is semantically the stored one —\n * so the editor can re-emit the exact stored value instead of a re-serialization,\n * keeping the field un-dirtied. Both sides are compared in editor-projection space\n * ({@link toEditorDoc} is deterministic), so a stored v2 component/carrier and its\n * on-screen atom compare equal. Two empty documents are always equivalent (the\n * trailing-paragraph difference between `content: []` and `[{ paragraph }]` is not\n * a change); otherwise defers to the shared structural comparison.\n */\nexport function isEquivalentToStored(current: RichTextDoc, storedValue: unknown): boolean {\n  const stored = toEditorDoc(storedValue)\n  if (isEffectivelyEmpty(current) && isEffectivelyEmpty(stored)) return true\n  return richTextDocsEquivalent(current, stored)\n}\n\n/**\n * EC-679 — the value the editor REPORTS for the (normalized) document on screen (pure;\n * the editor's `onUpdate` reports exactly this). Three outcomes: unchanged → the stored\n * value verbatim (never a re-serialization, so the field is not dirtied), emptied →\n * `undefined` (the field is cleared), otherwise the new stamped value. An empty editor\n * over an ABSENT body therefore reports `undefined` — the value the draft already holds,\n * which the form's writer judges as no edit ({@link fieldEdit} in `use-document-draft.ts`).\n */\nexport function reportedValue(current: RichTextDoc, stored: unknown): unknown {\n  if (isEquivalentToStored(current, stored)) return stored\n  return isEffectivelyEmpty(current) ? undefined : blockSequenceValueFromDoc(current)\n}\n"]}

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

@@ -1,6 +1,6 @@
 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 { CollectionViewSource, DocumentWrites } from '../../lib/collection-view/collection-view-source.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';
@@ -45,11 +45,44 @@ export declare const documentVisibility: VisibilitySource;
  * 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).
+ *
+ * EC-667 — that session view is a COMPOSITE while it shows a pending write (Codex F18):
+ * `revision` is its whole-document token (the EARLIEST authoring revision of any position
+ * — what a whole-document writer, the slot alias or the translation, writes at), and
+ * `shown` is the view itself, the token a position's edit reads ITS provenance from at
+ * the first keystroke ({@link positionBase}).
  */
 export interface DraftView {
     readonly document: CmsDocument;
     readonly revision: number | undefined;
+    /** EC-667 — the session view the draft was last rebased onto (absent: none — a fixture, a record rail). */
+    readonly shown?: CmsDocument;
 }
+/** What a draft reads its tokens from: the write model's view registry (EC-647 / EC-667). */
+export type ViewTokens = Pick<DocumentWrites, 'revisionOfView'>;
+/** EC-667 — the draft of a session view as it is shown (pure): its value, its whole-document token, the view itself. */
+export declare function sessionDraftView(doc: CmsDocument, tokens: ViewTokens | undefined): DraftView;
+/**
+ * EC-667 — the base an edit of `path` that STARTS now on `draft` is authored against
+ * (pure; the committer captures it at the first keystroke): the revision the content at
+ * that position of the shown session view was authored against — under a pending
+ * whole-document snapshot the snapshot's revision, under a pending own write that write's
+ * base — never the revision of a row adopted underneath it. Captured at the start, it
+ * survives the pending write's refusal or failure (looking it up when the commit arrives
+ * would be too late). Without a view token: the draft's whole-document revision.
+ */
+export declare function positionBase(draft: DraftView, path: ValuePath, tokens: ViewTokens | undefined): number | undefined;
+/**
+ * THE draft rebase as one value (pure — what the editor runs when the session's document
+ * changes): the session view with the uncommitted positions laid over it ({@link
+ * rebaseDraft}), its whole-document token, the view itself (EC-647 → EC-667: the rebase
+ * moves the value AND its tokens), and — when the screen has a canvas — the token of the
+ * canvas field's position, which the canvas's next edit is authored at.
+ */
+export declare function rebaseDraftView(doc: CmsDocument, previous: DraftView, uncommitted: readonly UncommittedPosition[], tokens: ViewTokens, canvasPath?: ValuePath): {
+    view: DraftView;
+    canvasRevision: 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
@@ -67,6 +100,36 @@ 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;
+/**
+ * THE form writers' core (pure; what {@link DocumentDraft.setFieldValue} and {@link
+ * DocumentDraft.editField} run): `update` transforms the draft at ONE field position;
+ * the draft takes the result (`apply`) and, with a revisioned write model, the position
+ * is the committer's, authored at its token read BEFORE the draft moves (EC-667).
+ *
+ * **EC-679 — an editor that opens a document never writes.** The position is EDITED only
+ * when the value AT THE POSITION differs from what the DRAFT held there before the call,
+ * by the write path's own comparison: {@link semanticValueEqual} over the value the
+ * update stores (`writeField` canonicalises, so an emptied value that stores as absent
+ * equals absent). A control that re-reports what the draft already holds — the rich-text
+ * editor on mount, on a remount (a tab or Draft/Published switch) or on a read-only flip,
+ * measured on the base as an `unset` of an absent body or a same-value `set` per open —
+ * moves nothing and commits nothing (`undefined`). Compared against the draft, never the
+ * session's base: typing a value and typing it away again are two edits, and the revert
+ * writes too. Every field type is covered here by construction; the canvas writes through
+ * {@link canvasCommit}, not this.
+ */
+export declare function fieldEdit(input: {
+    collection: CollectionDef;
+    draft: DraftView;
+    field: string;
+    locale: Locale;
+    update: (current: CmsDocument) => CmsDocument;
+    /** The write model's view tokens (absent: no revisioned write model). */
+    tokens: ViewTokens | undefined;
+    /** Absent: no revisioned write model (the draft moves, nothing is committed). */
+    committer: Pick<DraftCommitter, 'edited'> | undefined;
+    apply: (next: CmsDocument) => void;
+}): 'edited' | 'draft' | undefined;
 /**
  * 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
@@ -99,6 +162,11 @@ export declare function canvasWrite(input: {
  * 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.
+ *
+ * EC-667: `revision` is the token of the canvas FIELD's position in the shown view
+ * ({@link rebaseDraftView}) — under a pending snapshot the snapshot's revision. The canvas
+ * mounts at the draft's whole-document token (the earliest, possibly earlier than its
+ * field's), so the first rebase with a token reports it even when nothing moved.
  */
 export declare function canvasFieldChange(previous: CmsDocument, next: CmsDocument, path: ValuePath, last: CanvasFieldChange | undefined, revision: number | undefined): CanvasFieldChange | undefined;
 /**
@@ -140,16 +208,20 @@ export interface DocumentDraft {
     /**
      * 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.
+     * at this revision. EC-667: the view's WHOLE-DOCUMENT token — the earliest authoring
+     * revision of any position it shows (a field's own edit reads its position's token).
      */
     revision: number | undefined;
     /** Uncommitted (document model) / unsaved (record model) edits exist. */
     dirty: boolean;
     /** The record model: the editor renders a Save button + navigation guard. */
     explicitSave: boolean;
-    /** A field's control wrote `value` (the active locale for a localized field). */
+    /**
+     * A field's control wrote `value` (the active locale for a localized field). EC-679: a
+     * value the draft already holds at the position is no edit ({@link fieldEdit}).
+     */
     setFieldValue(field: FieldDef, value: unknown): void;
-    /** A writer that transforms ONE field position (fill / reset from base). */
+    /** A writer that transforms ONE field position (fill / reset from base) — the same no-op rule. */
     editField(field: FieldDef, update: (draft: CmsDocument) => CmsDocument): void;
     /**
      * The canvas emitted a new value for its field (node patches, committed at once). The

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

@@ -47,6 +47,35 @@ export const documentVisibility = {
         return () => document.removeEventListener('visibilitychange', listener);
     },
 };
+/** EC-667 — the draft of a session view as it is shown (pure): its value, its whole-document token, the view itself. */
+export function sessionDraftView(doc, tokens) {
+    return { document: doc, revision: tokens?.revisionOfView(doc), shown: doc };
+}
+/**
+ * EC-667 — the base an edit of `path` that STARTS now on `draft` is authored against
+ * (pure; the committer captures it at the first keystroke): the revision the content at
+ * that position of the shown session view was authored against — under a pending
+ * whole-document snapshot the snapshot's revision, under a pending own write that write's
+ * base — never the revision of a row adopted underneath it. Captured at the start, it
+ * survives the pending write's refusal or failure (looking it up when the commit arrives
+ * would be too late). Without a view token: the draft's whole-document revision.
+ */
+export function positionBase(draft, path, tokens) {
+    return tokens && draft.shown ? tokens.revisionOfView(draft.shown, path) : draft.revision;
+}
+/**
+ * THE draft rebase as one value (pure — what the editor runs when the session's document
+ * changes): the session view with the uncommitted positions laid over it ({@link
+ * rebaseDraft}), its whole-document token, the view itself (EC-647 → EC-667: the rebase
+ * moves the value AND its tokens), and — when the screen has a canvas — the token of the
+ * canvas field's position, which the canvas's next edit is authored at.
+ */
+export function rebaseDraftView(doc, previous, uncommitted, tokens, canvasPath) {
+    return {
+        view: { document: rebaseDraft(doc, previous.document, uncommitted), revision: tokens.revisionOfView(doc), shown: doc },
+        canvasRevision: canvasPath ? tokens.revisionOfView(doc, canvasPath) : 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
@@ -78,6 +107,37 @@ export function rebaseDraft(sessionDoc, draft, uncommitted) {
     const patches = uncommitted.map((position) => positionPatch(draft, position.path));
     return applyDocumentPatches({ document: sessionDoc, patches, since: [] }).document;
 }
+/**
+ * THE form writers' core (pure; what {@link DocumentDraft.setFieldValue} and {@link
+ * DocumentDraft.editField} run): `update` transforms the draft at ONE field position;
+ * the draft takes the result (`apply`) and, with a revisioned write model, the position
+ * is the committer's, authored at its token read BEFORE the draft moves (EC-667).
+ *
+ * **EC-679 — an editor that opens a document never writes.** The position is EDITED only
+ * when the value AT THE POSITION differs from what the DRAFT held there before the call,
+ * by the write path's own comparison: {@link semanticValueEqual} over the value the
+ * update stores (`writeField` canonicalises, so an emptied value that stores as absent
+ * equals absent). A control that re-reports what the draft already holds — the rich-text
+ * editor on mount, on a remount (a tab or Draft/Published switch) or on a read-only flip,
+ * measured on the base as an `unset` of an absent body or a same-value `set` per open —
+ * moves nothing and commits nothing (`undefined`). Compared against the draft, never the
+ * session's base: typing a value and typing it away again are two edits, and the revert
+ * writes too. Every field type is covered here by construction; the canvas writes through
+ * {@link canvasCommit}, not this.
+ */
+export function fieldEdit(input) {
+    const { draft, field, committer } = input;
+    const path = fieldPositionPath(input.collection, field, input.locale);
+    const authored = { base: positionBase(draft, path, input.tokens) };
+    const next = input.update(draft.document);
+    if (semanticValueEqual(readValueAt(draft.document, path), readValueAt(next, path)))
+        return undefined;
+    input.apply(next);
+    if (!committer)
+        return 'draft';
+    committer.edited(field, path, authored);
+    return 'edited';
+}
 /**
  * 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
@@ -108,11 +168,17 @@ export function canvasWrite(input) {
  * 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.
+ *
+ * EC-667: `revision` is the token of the canvas FIELD's position in the shown view
+ * ({@link rebaseDraftView}) — under a pending snapshot the snapshot's revision. The canvas
+ * mounts at the draft's whole-document token (the earliest, possibly earlier than its
+ * field's), so the first rebase with a token reports it even when nothing moved.
  */
 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))
+    const tokenHeld = last === undefined ? revision === undefined : last.revision === revision;
+    if (semanticValueEqual(from, to) && tokenHeld)
         return undefined;
     return { from, to, seq: (last?.seq ?? 0) + 1, revision };
 }
@@ -178,11 +244,9 @@ 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]);
-    // 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),
-    }));
+    // EC-647: the draft and the revision of the view it rebased onto travel as ONE value
+    // (EC-667: with the view itself — the per-position token).
+    const [view, setViewState] = useState(() => sessionDraftView(doc, documentModel));
     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
@@ -195,8 +259,8 @@ export function useDocumentDraft(input) {
         draftRef.current = 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]);
+    /** An edit of the draft: its value moves, the tokens it is authored against do not. */
+    const setDraft = useCallback((next) => setView({ ...draftRef.current, document: next }), [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]);
@@ -220,7 +284,9 @@ export function useDocumentDraft(input) {
         },
         // 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.
+        // colleague's change the draft has not rebased onto yet. EC-667: the form's
+        // writers name the POSITION's token ({@link positionBase}, passed to `edited`);
+        // this whole-document token (the earliest) is the fallback.
         baseOf: () => draftRef.current.revision,
         scheduler,
     }), 
@@ -249,30 +315,33 @@ export function useDocumentDraft(input) {
         if (!documentModel)
             return;
         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-647: the rebase moves the value AND the revision — the session view's own
+        // (EC-667: its tokens, whole-document and per position).
+        const { view: next, canvasRevision } = rebaseDraftView(doc, draftRef.current, committer.uncommitted(), documentModel, canvasPath);
+        setView(next);
         // 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.
+        // carries the revision — EC-667: the canvas FIELD's token — so the canvas's next edit
+        // is authored where its value is.
         if (!canvasPath)
             return;
-        setCanvasChange((last) => canvasFieldChange(previous, next, canvasPath, last, revision) ?? last);
+        setCanvasChange((last) => canvasFieldChange(previous, next.document, canvasPath, last, canvasRevision) ?? last);
     }, [doc]);
     // --- Writers ----------------------------------------------------------------------------
-    const setFieldValue = useCallback((field, value) => {
-        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.document));
-        if (documentModel)
-            committer.edited(field.name, fieldPositionPath(collection, field.name, locale));
+        fieldEdit({
+            collection,
+            draft: draftRef.current,
+            field: field.name,
+            locale,
+            update,
+            tokens: documentModel,
+            committer: documentModel ? committer : undefined,
+            apply: setDraft,
+        });
     }, [collection, locale, setDraft, documentModel, committer]);
+    const setFieldValue = useCallback((field, value) => editField(field, (current) => writeField(collection, current, field.name, locale, value, { lookupManifest })), [collection, locale, lookupManifest, editField]);
     const setCanvasValue = useCallback((field, lift) => {
         const focus = committer.focusedField();
         canvasCommit({
@@ -407,7 +476,7 @@ export function useDocumentDraft(input) {
         // 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) });
+        setView(sessionDraftView(next, documentModel));
         if (moved)
             setCanvasNonce((n) => n + 1);
     },