@elytracms/studio 0.0.96 → 0.0.98

package/convex/records-zod-copy.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest'
+import { convexTest } from 'convex-test'
+import { makeFunctionReference } from 'convex/server'
+import { z } from 'zod'
+import { z as newerZod } from 'zod-copy-newer'
+import { defineRecordKind } from '@elytracms/core/persistence'
+import type { AnyRecordKind } from '@elytracms/core/persistence'
+import schema from './schema'
+import { defineRecordFunctions } from './record-functions'
+
+/**
+ * EC-639 — the Convex write path (`defineRecordFunctions(kind).save` → `saveRecord` →
+ * `resolveRecordSave`) for a kind declared with ANOTHER zod copy than the engine's: an addon
+ * or a consumer's studio declares its kind with its own zod, and its Convex module validates
+ * the write in-transaction with that kind. Measured before: a `.default()` column of zod 4.6
+ * inside the engine's object (an older copy) refused every create on BOTH adapters
+ * (`expected nonoptional, received undefined`). `zod-copy-newer` is a real second copy (an
+ * aliased devDependency), not a mock.
+ */
+
+const sameCopyKind = defineRecordKind({
+  kind: 'sameTicket',
+  module: 'sameTickets',
+  fields: { title: z.string().min(1), done: z.boolean().default(false), note: z.string().optional() },
+})
+const newerCopyKind = defineRecordKind({
+  kind: 'newerTicket',
+  module: 'newerTickets',
+  fields: { title: newerZod.string().min(1), done: newerZod.boolean().default(false), note: newerZod.string().optional() },
+})
+
+const modules = {
+  ...import.meta.glob(['./**/*.ts', '!./**/*.test.ts', '!./_generated/**']),
+  './_generated/api.ts': async () => ({}),
+  [`./${sameCopyKind.module}.ts`]: async () => defineRecordFunctions(sameCopyKind),
+  [`./${newerCopyKind.module}.ts`]: async () => defineRecordFunctions(newerCopyKind),
+}
+
+const STAMP = '2026-10-28T00:00:00.000Z'
+
+async function editorBackend() {
+  const t = convexTest(schema, modules)
+  await t.run(async (ctx) => {
+    await ctx.db.insert('members', { userId: 'editor', role: 'editor', createdAt: STAMP, updatedAt: STAMP })
+  })
+  return { t, editor: t.withIdentity({ subject: 'editor', issuer: 'https://convex.test' }) }
+}
+
+describe.each([
+  ['a NEWER zod copy (refused every create before)', newerCopyKind],
+  ['the engine’s own copy (control — unchanged)', sameCopyKind],
+] as const)('EC-639 — Convex record save with %s', (_label, kind: AnyRecordKind) => {
+  const save = makeFunctionReference<'mutation'>(`${kind.module}:save`)
+  const get = makeFunctionReference<'query'>(`${kind.module}:get`)
+  const idArg = (id: string) => ({ [kind.idKey]: id })
+
+  it('creates with the default applied, edits keep it, a clear removes the optional column', async () => {
+    const { editor } = await editorBackend()
+    await editor.mutation(save, { ...idArg('t1'), title: 'First', note: 'n', createdAt: STAMP, updatedAt: STAMP })
+    expect(await editor.query(get, idArg('t1'))).toMatchObject({ title: 'First', done: false, note: 'n' })
+    await editor.mutation(save, { ...idArg('t1'), done: true, createdAt: STAMP, updatedAt: STAMP })
+    await editor.mutation(save, { ...idArg('t1'), title: 'Renamed', note: null, createdAt: STAMP, updatedAt: STAMP })
+    const edited = (await editor.query(get, idArg('t1'))) as Record<string, unknown>
+    expect(edited).toMatchObject({ title: 'Renamed', done: true })
+    expect(edited.note).toBeUndefined()
+  })
+
+  it('refuses an invalid column with the column’s own message, in the transaction', async () => {
+    const { t, editor } = await editorBackend()
+    await expect(
+      editor.mutation(save, { ...idArg('bad'), title: '', createdAt: STAMP, updatedAt: STAMP }),
+    ).rejects.toThrow(/title: Too small/)
+    const stored = await t.run(async (ctx) => ctx.db.query('records').collect())
+    expect(stored).toEqual([])
+  })
+})

package/convex/records-zod-refinements.convex.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest'
+import { convexTest } from 'convex-test'
+import { makeFunctionReference } from 'convex/server'
+import { z } from 'zod'
+import { z as newerZod } from 'zod-copy-newer'
+import { z as olderZod } from 'zod-copy-older'
+import { defineRecordKind } from '@elytracms/core/persistence'
+import type { AnyRecordKind, RecordColumnSchema } from '@elytracms/core/persistence'
+import schema from './schema'
+import { defineRecordFunctions } from './record-functions'
+
+/**
+ * EC-682 (Codex round 4 F24, a regression of 0.0.97) — the generated Convex record functions
+ * (`defineRecordFunctions(kind).save` → `saveRecord` → `resolveRecordSave`, in the transaction)
+ * for a kind whose column carries a refinement on its `.optional()` / `.default()` WRAPPER and
+ * comes from another zod release than the engine's. Measured before: the adoption judged only
+ * the wrapper's `innerType`, so `'forbidden'` — refused by the column's own `safeParse` — was
+ * STORED (create and edit). Now a supplied value is judged by the whole column; the engine's own
+ * copy is the control row (composed as it is, refused before too). `zod-copy-older` (4.1.13) and
+ * `zod-copy-newer` (4.6.7) are real second copies (aliased devDependencies), not mocks.
+ */
+
+const MESSAGE = 'forbidden value'
+const notForbidden = (value: string | undefined) => value !== 'forbidden'
+
+// The copies' builders differ only in their TYPES (EC-639 owns those); the runtime is the subject here.
+type Vendor = typeof z
+const COPIES = [
+  ['own', 'the engine’s own copy (the control)', z],
+  ['older', 'an OLDER zod copy (4.1.13)', olderZod as unknown as Vendor],
+  ['newer', 'a NEWER zod copy (4.6.7)', newerZod as unknown as Vendor],
+] as const
+
+const SHAPES = [
+  // The defect: the refinement is the WRAPPER's own check.
+  ['OptionalRefine', 'optional().refine()', (v: Vendor) => v.string().optional().refine(notForbidden, MESSAGE)],
+  ['DefaultRefine', 'default().refine()', (v: Vendor) => v.string().default('safe').refine(notForbidden, MESSAGE)],
+  // The neighbours: the refinement sits on the inner type (judged before this change too).
+  ['RefineOptional', 'refine().optional()', (v: Vendor) => v.string().refine(notForbidden, MESSAGE).optional()],
+  ['RefineDefault', 'refine().default()', (v: Vendor) => v.string().refine(notForbidden, MESSAGE).default('safe')],
+] as const
+
+const CASES = COPIES.flatMap(([copy, copyLabel, vendor]) =>
+  SHAPES.map(([shape, shapeLabel, build]) => {
+    const kind = defineRecordKind({
+      kind: `${copy}${shape}`,
+      module: `${copy}${shape}Notes`,
+      fields: { code: build(vendor) as unknown as RecordColumnSchema },
+    })
+    return [`${copyLabel}, \`z.string().${shapeLabel}\``, { kind, defaulted: shape.includes('Default') }] as const
+  }),
+)
+
+const modules = {
+  ...import.meta.glob(['./**/*.ts', '!./**/*.test.ts', '!./_generated/**']),
+  './_generated/api.ts': async () => ({}),
+  ...Object.fromEntries(CASES.map(([, { kind }]) => [`./${kind.module}.ts`, async () => defineRecordFunctions(kind)])),
+}
+
+const STAMP = '2026-10-28T00:00:00.000Z'
+
+async function editorBackend() {
+  const t = convexTest(schema, modules)
+  await t.run(async (ctx) => {
+    await ctx.db.insert('members', { userId: 'editor', role: 'editor', createdAt: STAMP, updatedAt: STAMP })
+  })
+  return { t, editor: t.withIdentity({ subject: 'editor', issuer: 'https://convex.test' }) }
+}
+
+describe.each(CASES)('EC-682 — Convex record save, %s', (_label, { kind, defaulted }: { kind: AnyRecordKind; defaulted: boolean }) => {
+  const save = makeFunctionReference<'mutation'>(`${kind.module}:save`)
+  const get = makeFunctionReference<'query'>(`${kind.module}:get`)
+  const write = (id: string, columns: Record<string, unknown> = {}) => ({ [kind.idKey]: id, ...columns, createdAt: STAMP, updatedAt: STAMP })
+
+  it('refuses `forbidden` on create with the column’s own message, in the transaction — nothing stored', async () => {
+    const { t, editor } = await editorBackend()
+    await expect(editor.mutation(save, write('created', { code: 'forbidden' }))).rejects.toThrow(/code: forbidden value/)
+    expect(await t.run(async (ctx) => ctx.db.query('records').collect())).toEqual([])
+  })
+
+  it('saves `safe`, refuses an edit to `forbidden`, keeps the stored value', async () => {
+    const { editor } = await editorBackend()
+    expect(await editor.mutation(save, write('edited', { code: 'safe' }))).toMatchObject({ code: 'safe' })
+    await expect(editor.mutation(save, write('edited', { code: 'forbidden' }))).rejects.toThrow(/code: forbidden value/)
+    expect(await editor.query(get, { [kind.idKey]: 'edited' })).toMatchObject({ code: 'safe' })
+  })
+
+  it('an absent key is the wrapper’s: the optional stays absent, the default is the column’s own (`safe`)', async () => {
+    const { editor } = await editorBackend()
+    const created = (await editor.mutation(save, write('absent'))) as Record<string, unknown>
+    if (defaulted) expect(created.code).toBe('safe')
+    else expect('code' in created).toBe(false)
+  })
+})

package/convex/schema.ts

@@ -207,6 +207,21 @@ export default defineSchema({
     .index('by_doc', ['collection', 'docId', 'variant'])
     .index('by_doc_session', ['collection', 'docId', 'variant', 'sessionId']),
 
+  /**
+   * EC-669 — the FLOOR of a removed identity: the highest `revision` (of its rows) and
+   * `version` (of its history) any deleted or cleared lifetime of `collection:docId` reached.
+   * Written by `cms:deleteDocument` and `cms:clearDocuments` (raised, never lowered, never
+   * deleted — one row per identity ever removed); read by a create and by a lifetime's first
+   * version, which start above it — so a revision or version token names one state of ONE
+   * lifetime and a stale writer of a removed lifetime is refused. Never on the delivery wire.
+   */
+  documentFloors: defineTable({
+    collection: v.string(),
+    docId: v.string(),
+    revision: v.number(),
+    version: v.number(),
+  }).index('by_doc', ['collection', 'docId']),
+
   /**
    * CMS document version snapshots — append-only (EC-224). One row per recorded
    * version (created on publish or a pre-restore snapshot, never on a plain draft
@@ -285,7 +300,11 @@ export default defineSchema({
     localizedMeta: v.optional(v.any()),
     createdAt: v.string(),
     updatedAt: v.string(),
-  }).index('by_asset', ['assetId']),
+  })
+    .index('by_asset', ['assetId'])
+    // EC-671: an ingest claim refuses a storage id an asset row references (`claimIngestUpload`).
+    .index('by_storage', ['storageKey'])
+    .index('by_thumb_storage', ['thumb.storageKey']),
 
   /**
    * Editorial redirects (EC-303) — 301/302 forwards an editor owns, stored as

package/convex/strict-delete.test.ts

@@ -0,0 +1,129 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { convexTest } from 'convex-test'
+import type { ConvexHttpClient } from 'convex/browser'
+import { getFunctionName } from 'convex/server'
+import type { FunctionReference } from 'convex/server'
+import { fieldPath } from '@elytracms/core/cms-core'
+import { createOperations } from '@elytracms/core/operations'
+import { ConvexPersistenceAdapter } from '../src/lib/persistence/convex-adapter'
+import schema from './schema'
+
+// convex-test fires a `runAfter(0)` on a REAL timer (the publish trigger's revalidation);
+// fake timers keep it queued.
+beforeEach(() => {
+  vi.useFakeTimers()
+  vi.setSystemTime('2026-10-28T00:00:00.000Z')
+})
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+/**
+ * EC-668 — the Codex review's F08-residual counterexample on Convex (round 3,
+ * `races.convex.test.ts`), copied and INVERTED: the client HOLDS `cms:deleteDocument` after the
+ * operation's guard, a colleague saves a strict draft reference to the target, the held
+ * mutation is sent — and it REFUSES, because its transaction reads the draft reference index
+ * (`referenceEntries` `by_target`, variant `draft`) and finds a referrer the guard did not judge
+ * at its current revision. The probe's positive detection control (a fresh guard refuses a
+ * second delete) is kept as written. convex-test serialises mutations: this proves the sink's
+ * data check and its refusal, not Convex's OCC retry.
+ */
+
+const modules = {
+  ...import.meta.glob(['./**/*.ts', '!./**/*.test.ts', '!./_generated/**']),
+  './_generated/api.ts': async () => ({}),
+}
+const projectId = 'strict-delete'
+const ref = { collection: 'post', id: 'p' }
+const author = { collection: 'author', id: 'a' }
+
+async function world() {
+  const t = convexTest(schema, modules)
+  const stamp = '2026-10-28T00:00:00Z'
+  await t.run(async (ctx) => {
+    await ctx.db.insert('members', { userId: 'user_admin', role: 'admin', createdAt: stamp, updatedAt: stamp })
+  })
+  const admin = t.withIdentity({ subject: 'user_admin', issuer: 'https://convex.test' })
+  const held = new Map<string, { reached(): void; gate: Promise<void> }>()
+  const client = {
+    query: (fn: FunctionReference<'query'>, args?: Record<string, unknown>) => admin.query(fn, args ?? {}),
+    mutation: async (fn: FunctionReference<'mutation'>, args?: Record<string, unknown>) => {
+      const key = `${getFunctionName(fn)}#${String(args?.docId)}`
+      const pause = held.get(key)
+      if (pause) {
+        held.delete(key)
+        pause.reached()
+        await pause.gate
+      }
+      return admin.mutation(fn, args ?? {})
+    },
+  } as unknown as ConvexHttpClient
+  const adapter = new ConvexPersistenceAdapter(client, projectId)
+  const collections = () => [
+    { id: 'author', kind: 'document' as const, fields: [{ name: 'name', type: 'text' as const }] },
+    { id: 'post', kind: 'document' as const, fields: [
+      { name: 'author', type: 'relation' as const, target: 'author', multiple: false, strict: true },
+      { name: 'soft', type: 'relation' as const, target: 'author', multiple: false },
+    ] },
+  ]
+  const ops = createOperations({ adapter, collections, validateDocument: () => [] })
+  const hold = (verb: string, id: string) => {
+    let reached!: () => void
+    let resume!: () => void
+    const at = new Promise<void>((r) => { reached = r })
+    const gate = new Promise<void>((r) => { resume = r })
+    held.set(`cms:${verb}#${id}`, { reached, gate })
+    return { at, resume }
+  }
+  const put = async (document: { collection: string; id: string; values: Record<string, unknown> }) => {
+    expect((await ops.documents.replace({ projectId, document, precondition: { ifAbsent: true } })).ok).toBe(true)
+  }
+  return { adapter, ops, hold, put }
+}
+
+it('F08 residual Convex: a strict draft saved before the delete mutation protects its target', async () => {
+  const { adapter, ops, hold, put } = await world()
+  await put({ ...author, values: { name: 'Ada' } })
+  await put({ ...ref, values: {} })
+  const pause = hold('deleteDocument', author.id)
+  const deleting = ops.documents.delete({ projectId, ref: author })
+  await pause.at
+  expect((await ops.documents.patch({ projectId, ref, baseRevision: 1, patches: [{ op: 'set', path: fieldPath('author'), value: { type: 'reference', ...author } }] })).ok).toBe(true)
+  // Positive detection control (kept as written): the guard already sees the now-saved draft and blocks a second delete.
+  expect((await ops.documents.delete({ projectId, ref: author })).ok).toBe(false)
+  pause.resume()
+  // Inverted: the held delete refuses in its transaction; the target survives.
+  const deleted = await deleting
+  expect(deleted.ok).toBe(false)
+  if (!deleted.ok) expect(deleted.error.code).toBe('conflict')
+  expect(await adapter.cms.findDocument(projectId, author)).toBeDefined()
+})
+
+describe('EC-668 Convex — the delete mutation checks the draft referrers the guard judged', () => {
+  it('a judged SOFT draft referrer edited to a strict one while the delete is held refuses (its revision moved)', async () => {
+    const { adapter, ops, hold, put } = await world()
+    await put({ ...author, values: { name: 'Ada' } })
+    await put({ ...ref, values: { soft: { type: 'reference', ...author } } })
+    const pause = hold('deleteDocument', author.id)
+    const deleting = ops.documents.delete({ projectId, ref: author })
+    await pause.at
+    expect((await ops.documents.patch({ projectId, ref, baseRevision: 1, patches: [{ op: 'set', path: fieldPath('author'), value: { type: 'reference', ...author } }] })).ok).toBe(true)
+    pause.resume()
+    expect((await deleting).ok).toBe(false)
+    expect(await adapter.cms.findDocument(projectId, author)).toBeDefined()
+  })
+
+  it('control: the held delete with nothing racing it lands, a judged soft referrer and all', async () => {
+    const { adapter, ops, hold, put } = await world()
+    await put({ ...author, values: { name: 'Ada' } })
+    await put({ ...ref, values: { soft: { type: 'reference', ...author } } })
+    const pause = hold('deleteDocument', author.id)
+    const deleting = ops.documents.delete({ projectId, ref: author })
+    await pause.at
+    // An unrelated write in the window is not a referrer.
+    await put({ collection: 'author', id: 'b', values: { name: 'Bea' } })
+    pause.resume()
+    expect((await deleting).ok).toBe(true)
+    expect(await adapter.cms.findDocument(projectId, author)).toBeUndefined()
+  })
+})

package/dist/components/cms/cms-store.d.ts

@@ -1,6 +1,7 @@
 import type { ReactNode } from 'react';
 import type { CmsDocument, CmsValidationIssue, CollectionDef, CollectionRegistry, DocumentPatch, DocumentRef, FieldDef, ValuePath, Locale, LocaleConfig, LocalizedString, RestoreScope, ValidateDocumentOptions } from '@elytracms/core/cms-core';
 import type { CmsDocumentRecord, DocumentVersionRecord, IdFactory, PresenceEntry } from '@elytracms/core/persistence';
+import type { ImportRejection } from './import-batch.js';
 import type { CommitOutcome, DocumentConflict, OperationError, OperationsClient } from '../../lib/operations/index.js';
 import type { TableViewState } from '../../lib/cms-views/index.js';
 import type { CellCommitInput, CellCommitOutcome } from './cell-edit.js';
@@ -24,10 +25,7 @@ export interface SavedView {
 }
 export interface ImportReport {
     added: number;
-    rejected: {
-        id: string;
-        issues: CmsValidationIssue[];
-    }[];
+    rejected: ImportRejection[];
 }
 /**
  * A document's recorded version history plus its live pin (EC-224), as the
@@ -73,8 +71,11 @@ export interface CmsStore {
      * editor's `doc`): the value and its revision travel together, so a writer authoring
      * from what it displayed names that revision. `undefined` for a value the session never
      * showed (a fixture session, a copy) or a provisional one (a create in flight).
+     * EC-667: with `path`, the revision the content at that position was authored against
+     * (a view showing a pending write is a composite); without it, the EARLIEST of any
+     * position — the whole-document writer's token.
      */
-    revisionOfView(view: CmsDocument): number | undefined;
+    revisionOfView(view: CmsDocument, path?: ValuePath): number | undefined;
     /**
      * EC-595 A2 / EC-578 — create a document from a whole value (duplicate, import of a
      * new row, an AI create, a transfer, a reuse promote): insert-if-absent

package/dist/components/cms/cms-store.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { applyDocumentPatches, createCollectionRegistry, createDocumentStore, documentKey, documentReachabilityIssues, documentSchema, resolveDocumentTitle, seedDefaults, titleFieldOf, validateDocument, valuesInLocale, writeField, } from '@elytracms/core/cms-core';
+import { applyDocumentPatches, createCollectionRegistry, createDocumentStore, documentKey, documentReachabilityIssues, resolveDocumentTitle, seedDefaults, titleFieldOf, touchedPaths, validateDocument, valuesInLocale, writeField, } from '@elytracms/core/cms-core';
 import { createUuidIdFactory } from '@elytracms/core/persistence';
 import { translate } from '../../lib/i18n/index.js';
 import { configureStudioLocales, useStudioLocale } from '../../lib/locale/index.js';
@@ -9,8 +9,9 @@ import { resolveDeploymentCollections, resolveDeploymentLocaleConfig, resolveDep
 import { Heading, Panel, Stack, Text } from '@elytracms/studio/ui';
 import { assetLibraryOracle, gateValidateOptions } from './gate-validation.js';
 import { matchesRef, removeDoc, replaceDoc, upsertDoc } from './document-ref-utils.js';
+import { parseImportBatch } from './import-batch.js';
 import { createRequiredContext } from '../../lib/required-context.js';
-import { createCmsPersister, getStudioActor, getStudioOperations } from '../../lib/operations/index.js';
+import { createCmsPersister, getStudioActor, getStudioOperations, importWrite } from '../../lib/operations/index.js';
 import { publishInSession, publishWithRevision as publishRevision, } from '../../lib/operations/publish-with-revision.js';
 import { operationErrorMessage } from '../../lib/persona/labels.js';
 import { fieldWritePatch } from '../../lib/cms/field-patch.js';
@@ -430,10 +431,11 @@ function CmsSession({ children, projectId, initialCollections, initialDocuments,
                 ? {
                     // EC-595 A2: ONE field patch through the persister's queue — at the
                     // revision the row was at — never a whole-document side channel.
-                    // EC-647: the row the table SHOWED names that revision.
+                    // EC-647: the row the table SHOWED names that revision — EC-667: at the
+                    // cell's position (the row may show a pending write elsewhere).
                     dispatch: async (next) => {
                         const patch = fieldWritePatch(input.collection, next, input.field.name, input.locale);
-                        const outcome = await persister.commit(ref, [patch], [persister.revisionOfView(input.doc)], input.doc);
+                        const outcome = await persister.commit(ref, [patch], [persister.revisionOfView(input.doc, touchedPaths(patch)[0])], input.doc);
                         if (outcome.status === 'applied')
                             return { ok: true, value: outcome.record };
                         if (outcome.status === 'failed')
@@ -683,28 +685,9 @@ function CmsSession({ children, projectId, initialCollections, initialDocuments,
     // transfer dialog) can no longer change a verdict. `validate` above stays the
     // session's DISPLAY validation (the editor's issues, cell edit, import, AI).
     const importDocuments = useCallback((collectionId, raw) => {
-        const report = { added: 0, rejected: [] };
         // Pre-parse so intra-batch relation/asset targets resolve during validation.
-        const parsedBatch = [];
-        const schemaFails = [];
-        for (const item of raw) {
-            const parsed = documentSchema.safeParse({ ...item, collection: collectionId });
-            if (parsed.success)
-                parsedBatch.push(parsed.data);
-            else
-                schemaFails.push({ item, error: parsed });
-        }
-        for (const { item, error } of schemaFails) {
-            report.rejected.push({
-                id: item?.id ?? translate('cms.list.import.noId'),
-                issues: (error.success ? [] : error.error.issues).map((e) => ({
-                    code: 'invalid-field-value',
-                    severity: 'error',
-                    message: e.message,
-                    path: e.path.map((p) => (typeof p === 'symbol' ? String(p) : p)),
-                })),
-            });
-        }
+        const { parsed: parsedBatch, rejected } = parseImportBatch(collectionId, raw);
+        const report = { added: 0, rejected: [...rejected] };
         // Validate each against existing docs PLUS the rest of the batch.
         const batchStore = createDocumentStore([...documents, ...parsedBatch]);
         const accepted = [];
@@ -739,12 +722,7 @@ function CmsSession({ children, projectId, initialCollections, initialDocuments,
             for (const doc of accepted) {
                 if (!persister)
                     continue;
-                const shown = documents.find((d) => matchesRef(d, doc));
-                if (persister.revisionOf(doc) !== undefined) {
-                    persister.replace(doc, shown ? persister.revisionOfView(shown) : undefined);
-                }
-                else
-                    persister.create(doc);
+                importWrite(persister, doc, documents.find((d) => matchesRef(d, doc)));
             }
             // EC-224: imports land as the working DRAFT. Publish-ness is the version
             // pointer (`publishedKeys`), set by publishing — never carried in the
@@ -873,8 +851,10 @@ function CmsSession({ children, projectId, initialCollections, initialDocuments,
                 }
                 const written = setFieldDoc(current);
                 // EC-647: authored from the row the session holds — its revision, never the
-                // tracked one (a colleague's change the user never saw is refused, visibly).
-                const outcome = await persister.commit(ref, [fieldWritePatch(collection, written, setField.field, activeLocale)], [persister.revisionOfView(current)], current);
+                // tracked one (a colleague's change the user never saw is refused, visibly);
+                // EC-667: the revision of the field's position in that row.
+                const patch = fieldWritePatch(collection, written, setField.field, activeLocale);
+                const outcome = await persister.commit(ref, [patch], [persister.revisionOfView(current, touchedPaths(patch)[0])], current);
                 if (outcome.status === 'applied')
                     return { ok: true, value: outcome.record };
                 if (outcome.status === 'failed')
@@ -1011,7 +991,7 @@ function CmsSession({ children, projectId, initialCollections, initialDocuments,
         titleOf,
         commitPatches,
         revisionOf: (ref) => persisterRef.current?.revisionOf(ref),
-        revisionOfView: (view) => persisterRef.current?.revisionOfView(view),
+        revisionOfView: (view, path) => persisterRef.current?.revisionOfView(view, path),
         insertDocument,
         newDocumentId: newId,
         commitFieldEdit,