@@ -71,6 +71,10 @@ const withDrops = (row: Record<string, unknown>) => {
   return d.length > 0 ? { droppedFields: d } : {};
 };
 
+/** The submitted rows of a `validateData` call: one verdict is owed per row (#26684 previews a batch). */
+const rowsOf = (args: ValidateArgs) =>
+  (Array.isArray(args.data) ? args.data : [args.data]) as Array<Record<string, unknown>>;
+
 /** The row's key set — a clean row must not grow an empty `droppedFields`. */
 const keysOf = (r: ImportRowResult | undefined) => Object.keys(r ?? {}).sort();
 
@@ -85,7 +89,7 @@ describe('[#20701] the dry run copies validateData\'s per-row drops onto the row
   it('a create-resolved row carries the verdict\'s droppedFields verbatim; a clean row carries no key', async () => {
     const validateData = vi.fn(async (args: ValidateArgs) => ({
       object: OBJECT, mode: args.mode ?? 'insert', valid: true,
-      results: [{ valid: true, errors: [], warnings: [], ...withDrops(args.data as Record<string, unknown>) }],
+      results: rowsOf(args).map((row) => ({ valid: true, errors: [], warnings: [], ...withDrops(row) })),
       posture: { valueShapeStrict: false, mediaValueShapeStrict: false },
     }));
     const p: ImportProtocolLike = { findData: vi.fn(async () => []), createData: vi.fn(), updateData: vi.fn(), validateData };
@@ -116,12 +120,12 @@ describe('[#20701] the dry run copies validateData\'s per-row drops onto the row
   it('a row the verdict refuses carries no droppedFields, and an admitted warning rides beside the drops', async () => {
     const warning = { field: 'name', code: 'invalid_format', message: 'admitted' };
     const validateData = vi.fn(async (args: ValidateArgs) => {
-      const refused = (args.data as Record<string, unknown>).name === 'bad';
+      const results = rowsOf(args).map((row) => (row.name === 'bad'
+        ? { valid: false, errors: [{ field: 'name', code: 'required', message: 'name is required' }], warnings: [], droppedFields: [COMPUTED] }
+        : { valid: true, errors: [], warnings: [warning], droppedFields: [COMPUTED] }));
       return {
-        object: OBJECT, mode: 'insert' as const, valid: !refused,
-        results: [refused
-          ? { valid: false, errors: [{ field: 'name', code: 'required', message: 'name is required' }], warnings: [], droppedFields: [COMPUTED] }
-          : { valid: true, errors: [], warnings: [warning], droppedFields: [COMPUTED] }],
+        object: OBJECT, mode: 'insert' as const, valid: results.every((r) => r.valid),
+        results,
         posture: { valueShapeStrict: false, mediaValueShapeStrict: false },
       };
     });
 
@@ -77,8 +77,9 @@ function makeProvider(shape: 'inline' | 'createMany' | 'insertMany' | 'update' |
   }
   if (shape === 'validate') {
     p.validateData = vi.fn(async (args: ValidateArgs) => {
-      calls.push({ kind: 'validateData', rows: [args.data as Record<string, unknown>], context: args.context });
-      return { results: [{ valid: true, errors: [] }] } as any;
+      const rows = (Array.isArray(args.data) ? args.data : [args.data]) as Array<Record<string, unknown>>;
+      calls.push({ kind: 'validateData', rows, context: args.context });
+      return { results: rows.map(() => ({ valid: true, errors: [] })) } as any;
     });
   }
   return { p, calls };
@@ -135,14 +136,22 @@ describe('runImport — createMissingOptions hands the kept values to the write
     expect(calls[0].context.keptOptionValues).toEqual({ priority: ['Bogus'] });
   });
 
-  it('the dry run asks validateData with the same per-row context the write would carry', async () => {
+  it('the dry run asks validateData with the context the batch write would carry: the union of its rows\' kept values', async () => {
+    // [#26684] The dry run previews the create rows as the batch the commit
+    // writes them in, so its one call carries that batch call's context.
     const { p, calls } = makeProvider('validate');
     const summary = await runImport({ ...baseOpts, p, dryRun: true, rows: ROWS });
     expect(summary.created).toBe(3);
-    expect(calls.map((c) => c.kind)).toEqual(['validateData', 'validateData', 'validateData']);
-    expect(calls[0].context.keptOptionValues).toEqual({ priority: ['Bogus'] });
-    expect(calls[1].context).not.toHaveProperty('keptOptionValues');
-    expect(calls[2].context.keptOptionValues).toEqual({ tags: ['Other'] });
+    expect(calls.map((c) => c.kind)).toEqual(['validateData']);
+    expect(calls[0].rows).toHaveLength(3);
+    expect(calls[0].context.keptOptionValues).toEqual({ priority: ['Bogus'], tags: ['Other'] });
+  });
+
+  it('a dry run whose rows kept nothing carries the import\'s write context unchanged', async () => {
+    const { p, calls } = makeProvider('validate');
+    await runImport({ ...baseOpts, p, dryRun: true, rows: [{ code: 'b', priority: 'High' }] });
+    expect(calls).toHaveLength(1);
+    expect(calls[0].context).not.toHaveProperty('keptOptionValues');
   });
 
   it('with the option off, an unmatched cell fails at coercion and no write carries the key', async () => {
 
@@ -78,6 +78,7 @@ describe('[#22445] the dry run of a matched row names the stored row it would up
     await runImport({ ...baseOpts, p, writeMode: 'upsert', dryRun: true, rows: [{ code: 'c8', title: 'fresh' }] });
 
     expect(validateData.mock.calls[0]![0]).toMatchObject({ mode: 'insert' });
-    expect(validateData.mock.calls[0]![0].data).toEqual({ code: 'c8', title: 'fresh' });
+    // [#26684] A create row is previewed with the rows of its batch: an array.
+    expect(validateData.mock.calls[0]![0].data).toEqual([{ code: 'c8', title: 'fresh' }]);
   });
 });
@@ -261,14 +261,24 @@ describe('#22474 — the preview binds the master-detail header the write binds'
       return count;
     }
 
-    it('insert and update previews of a plain line issue no read of the header object', async () => {
+    it('an update preview of a plain line issues no read of the header object', async () => {
       storeFor(PLAIN_LINE).set('p1', { id: 'p1', invoice: 'h_sent', quantity: 1 });
       const count = countHeaderReads(engine);
-      expect(await preview(engine, PLAIN_LINE, { invoice: 'h_sent', quantity: 1 }, 'insert')).toEqual(ADMITTED);
       expect(await preview(engine, PLAIN_LINE, { quantity: 2, id: 'p1' }, 'update')).toEqual(ADMITTED);
       expect(count.reads).toBe(0);
     });
 
+    it('an insert preview of a plain line reads the header only as the insert does', async () => {
+      // [#26684] The insert preview runs the write's reference check, which
+      // asks the header's read door whether `h_sent` exists: the read the
+      // insert itself makes. The header binding adds none.
+      const count = countHeaderReads(engine);
+      expect(await preview(engine, PLAIN_LINE, { invoice: 'h_sent', quantity: 1 }, 'insert')).toEqual(ADMITTED);
+      const previewReads = count.reads;
+      expect(await write(() => engine.insert(PLAIN_LINE, { invoice: 'h_sent', quantity: 1 }))).toEqual(ADMITTED);
+      expect(count.reads - previewReads).toBe(previewReads);
+    });
+
     it('positive control: the parent-scoped line does read it', async () => {
       const count = countHeaderReads(engine);
       await preview(engine, LINE, { invoice: 'h_draft', quantity: 1 }, 'insert');