@@ -0,0 +1,11 @@
+---
+'@objectstack/spec': minor
+---
+
+The import row report and the validate-only answer can now say which fields a write drops. `ImportRowResultSchema` and each `ValidateDataResponseSchema.results[]` row gain an optional `droppedFields`: an array of `DroppedFieldsEventSchema`, the engine's own strip event. So the reason vocabulary is the engine's (`readonly`, `readonly_when`, `primary_key`, `computed`), and there is no second enum. The row still succeeds: `ok`, `action` and `valid` are unchanged. The key is declared ahead of its producer. A server that does not produce the report omits the key, so an absent key alone does not prove nothing was dropped.
+
+`ImportRowResultSchema` also declares `warnings`, which the REST import dry run already serves: the findings the validate verdict admits, in the `ValidateDataIssue` shape, on an ok dry-run row. Until now `ImportRowResultSchema.parse` stripped the key, and readers typed by the spec could not see it.
+
+`ImportJobResultsSchema.results` now says what an async reader gets: a capped sample, failures first. An ok row's `droppedFields` or `warnings` reaches that reader only if the row falls inside the sample. The cap is unchanged.
+
+A consumer that branches on `reason` must stay exhaustive over `DroppedFieldsEvent['reason']`. The known exhaustive consumer is objectui's write-warning toast table, `STRIPPED_LINE` in `packages/app-shell/src/providers/writeWarningToast.ts`, which covers all four reasons today. A reader that renders the import or preview report should word `reason` through that table rather than a second one. When the union widens again, the table keyed by it fails type-check on the missing reason, while a second table would fall behind without a sound.
@@ -215,7 +215,7 @@ const result = CreateImportJobRequestSchema.parse(data);
 | **startedAt** | `string` | optional | Processing start timestamp (ISO 8601) |
 | **completedAt** | `string` | optional | Completion timestamp (ISO 8601) |
 | **createdAt** | `string` | ✅ | Job creation timestamp (ISO 8601) |
-| **results** | `{ row: integer; ok: boolean; action: Enum<'created' \| 'updated' \| 'skipped' \| 'failed'>; id?: string; … }[]` | ✅ | Capped sample of per-row outcomes (failures first) |
+| **results** | `{ row: integer; ok: boolean; action: Enum<'created' \| 'updated' \| 'skipped' \| 'failed'>; id?: string; … }[]` | ✅ | Capped sample of per-row outcomes, failures first. An ok row, and any `droppedFields` or `warnings` it carries, reaches this reader only if it falls inside the sample; `resultsTruncated` says whether the sample is partial, and the job counters count every row. |
 | **resultsTruncated** | `boolean` | ✅ | Whether `results` is a capped sample of a larger set |
 
 ### Nested Shape: `ImportJobResults.results[number]`
@@ -229,6 +229,8 @@ const result = CreateImportJobRequestSchema.parse(data);
 | **field** | `string` | optional | Field that caused a coercion/validation error |
 | **code** | `string` | optional | Error code (failed rows) |
 | **error** | `string` | optional | Human-readable error message (failed rows) |
+| **warnings** | `{ field: string; code: string; message: string }[]` | optional | Findings this deployment ADMITS rather than rejects (ADR-0104 value shapes under a warn-first posture), in the same `{ field, code, message }` shape the validate verdict carries. Set only on a dry-run row the verdict accepted: the row is `ok` because the write would store it and log the same complaint. A committed row never carries it, since the write path has no channel to report admitted findings on. |
+| **droppedFields** | `{ object: string; fields: string[]; reason: Enum<'readonly' \| 'readonly_when' \| 'primary_key' \| 'computed'> }[]` | optional | Write-observability: caller-supplied fields the engine LEGALLY strips from THIS row, one event per reason, in the engine's own `droppedFields` shape and reason vocabulary. A dry-run row reports the strips the write would make; a committed row reports the strips it made. The row still succeeds: `ok` and `action` are unchanged. Present only when at least one field was dropped. A server that does not produce this report omits the key too, so an absent key alone does not prove nothing was dropped. In an async job's `results`, an ok row's drops reach the reader only if the row falls inside that capped, failures-first sample. |
 
 
 ---
@@ -355,6 +357,8 @@ Type: `{ sourceField: string; targetField: string; targetLabel?: string; transfo
 | **field** | `string` | optional | Field that caused a coercion/validation error |
 | **code** | `string` | optional | Error code (failed rows) |
 | **error** | `string` | optional | Human-readable error message (failed rows) |
+| **warnings** | `{ field: string; code: string; message: string }[]` | optional | Findings this deployment ADMITS rather than rejects (ADR-0104 value shapes under a warn-first posture), in the same `{ field, code, message }` shape the validate verdict carries. Set only on a dry-run row the verdict accepted: the row is `ok` because the write would store it and log the same complaint. A committed row never carries it, since the write path has no channel to report admitted findings on. |
+| **droppedFields** | `{ object: string; fields: string[]; reason: Enum<'readonly' \| 'readonly_when' \| 'primary_key' \| 'computed'> }[]` | optional | Write-observability: caller-supplied fields the engine LEGALLY strips from THIS row, one event per reason, in the engine's own `droppedFields` shape and reason vocabulary. A dry-run row reports the strips the write would make; a committed row reports the strips it made. The row still succeeds: `ok` and `action` are unchanged. Present only when at least one field was dropped. A server that does not produce this report omits the key too, so an absent key alone does not prove nothing was dropped. In an async job's `results`, an ok row's drops reach the reader only if the row falls inside that capped, failures-first sample. |
 
 
 ---
@@ -372,6 +376,26 @@ Type: `{ sourceField: string; targetField: string; targetLabel?: string; transfo
 | **field** | `string` | optional | Field that caused a coercion/validation error |
 | **code** | `string` | optional | Error code (failed rows) |
 | **error** | `string` | optional | Human-readable error message (failed rows) |
+| **warnings** | `{ field: string; code: string; message: string }[]` | optional | Findings this deployment ADMITS rather than rejects (ADR-0104 value shapes under a warn-first posture), in the same `{ field, code, message }` shape the validate verdict carries. Set only on a dry-run row the verdict accepted: the row is `ok` because the write would store it and log the same complaint. A committed row never carries it, since the write path has no channel to report admitted findings on. |
+| **droppedFields** | `{ object: string; fields: string[]; reason: Enum<'readonly' \| 'readonly_when' \| 'primary_key' \| 'computed'> }[]` | optional | Write-observability: caller-supplied fields the engine LEGALLY strips from THIS row, one event per reason, in the engine's own `droppedFields` shape and reason vocabulary. A dry-run row reports the strips the write would make; a committed row reports the strips it made. The row still succeeds: `ok` and `action` are unchanged. Present only when at least one field was dropped. A server that does not produce this report omits the key too, so an absent key alone does not prove nothing was dropped. In an async job's `results`, an ok row's drops reach the reader only if the row falls inside that capped, failures-first sample. |
+
+### Nested Shape: `ImportRowResult.warnings[number]`
+
+| Property | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| **field** | `string` | ✅ | The field the finding is about (`_record` for an object-level rule). |
+| **code** | `string` | ✅ | Machine-readable finding code, e.g. `required`, `invalid_type`, `rule_violation`. |
+| **message** | `string` | ✅ | Human-readable message — a validation rule's author-written text where one exists. |
+
+### Nested Shape: `ImportRowResult.droppedFields[number]`
+
+A write-path strip event: caller-supplied fields legally dropped from the payload
+
+| Property | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| **object** | `string` | ✅ | Object the write targeted (resolved object name) |
+| **fields** | `string[]` | ✅ | Caller-supplied field names the engine removed from the write payload |
+| **reason** | `Enum<'readonly' \| 'readonly_when' \| 'primary_key' \| 'computed'>` | ✅ | Why the fields were dropped: static readonly, a TRUE readonlyWhen predicate, the primary-key strip of a payload id the engine ruled is not an identifier, or a computed (formula) field no driver has a column for |
 
 
 ---
 
@@ -2977,7 +2977,7 @@ A write-path strip event: caller-supplied fields legally dropped from the payloa
 | **object** | `string` | ✅ | The object name. |
 | **mode** | `Enum<'insert' \| 'update'>` | ✅ | The write mode the verdict was reached for. |
 | **valid** | `boolean` | ✅ | True when EVERY row is valid — the whole-set answer. |
-| **results** | `{ valid: boolean; errors: object[]; warnings: object[] }[]` | ✅ | Per-row verdicts, in submission order. |
+| **results** | `{ valid: boolean; errors: object[]; warnings: object[]; droppedFields?: object[] }[]` | ✅ | Per-row verdicts, in submission order. |
 | **posture** | `{ valueShapeStrict: boolean; mediaValueShapeStrict: boolean }` | ✅ | The ADR-0104 posture the verdict was reached under — reported because it is the difference between "this row is fine" and "this row is fine HERE". The same row can be an error on a self-certified deployment and an admitted warning on an un-migrated one, and a caller explaining a verdict needs to know which it got. An unconditionally-strict preview was considered and rejected (option B): it would fail rows on every un-migrated deployment that the write would have accepted. |
 
 ### Nested Shape: `ValidateDataResponse.results[number]`
@@ -2987,6 +2987,7 @@ A write-path strip event: caller-supplied fields legally dropped from the payloa
 | **valid** | `boolean` | ✅ | True when this row would be accepted by the write path. |
 | **errors** | `{ field: string; code: string; message: string }[]` | ✅ | Findings that would REJECT this row. Empty when valid. |
 | **warnings** | `{ field: string; code: string; message: string }[]` | ✅ | Findings the target deployment ADMITS rather than rejects — today, ADR-0104 value shapes under a warn-first posture. The row is valid; the write would store it and log the same complaint. |
+| **droppedFields** | `{ object: string; fields: string[]; reason: Enum<'readonly' \| 'readonly_when' \| 'primary_key' \| 'computed'> }[]` | optional | Write-observability for the preview: caller-supplied fields the write would LEGALLY strip from THIS row, one event per reason, in the shape and reason vocabulary the write itself reports. A strip is not a finding: `valid` is unaffected, and the fields appear in neither `errors` nor `warnings`. Present only when at least one field would be dropped. A server that does not produce this report omits the key too, so an absent key alone does not prove nothing would be dropped. |
 
 ### Nested Shape: `ValidateDataResponse.posture`
 
 
@@ -941,11 +941,13 @@
     "api/ImportResponse:writeMode",
     "api/ImportRowResult:action",
     "api/ImportRowResult:code",
+    "api/ImportRowResult:droppedFields",
     "api/ImportRowResult:error",
     "api/ImportRowResult:field",
     "api/ImportRowResult:id",
     "api/ImportRowResult:ok",
     "api/ImportRowResult:row",
+    "api/ImportRowResult:warnings",
     "api/ImportValidationConfig:dateFormat",
     "api/ImportValidationConfig:deduplication",
     "api/ImportValidationConfig:maxErrors",
 
@@ -1,5 +1,5 @@
 import { describe, it, expect, expectTypeOf } from 'vitest';
-import type { ImportRequest } from './export.zod';
+import type { ImportRequest, ImportRowResult } from './export.zod';
 import {
   ExportFormat,
   ImportValidationMode,
@@ -10,7 +10,12 @@ import {
   ExportImportTemplateSchema,
   ImportRequestSchema,
   CreateImportJobRequestSchema,
+  ImportRowResultSchema,
+  ImportJobResultsSchema,
 } from './export.zod';
+import type { ValidateDataIssue } from './protocol.zod';
+import { DroppedFieldsEventSchema } from '../data/data-engine.zod';
+import type { DroppedFieldsEvent } from '../data/data-engine.zod';
 
 // ==========================================
 // Export Format
@@ -386,3 +391,88 @@ describe('ImportRequestSchema — mappingName declared (#10330)', () => {
     expect(described).toMatch(/CONFLICTING_MAPPING/);
   });
 });
+
+// ==========================================
+// Import Row Result — the write-drop signal and the served dry-run warnings
+// ==========================================
+
+/**
+ * The row report carries two optional keys that ride on an `ok` row:
+ * `droppedFields` (the engine's strip report, declared ahead of its producer)
+ * and `warnings` (served by the REST dry run before it was declared). The
+ * schema is a plain, non-strict `z.object`, so an undeclared key is not
+ * refused — it is STRIPPED by `parse`. Each pin therefore asserts the key
+ * SURVIVES a parse, never bare `success`: a schema without the key would
+ * still answer `success: true` and hand back a row with the report gone.
+ */
+describe('ImportRowResultSchema — droppedFields and warnings', () => {
+  const okRow = { row: 2, ok: true, action: 'created' as const, id: 'rec_1' };
+  const drops = [
+    { object: 'project', fields: ['doubled'], reason: 'computed' as const },
+    { object: 'project', fields: ['code'], reason: 'readonly' as const },
+  ];
+
+  it('parses a row without droppedFields — the key is optional', () => {
+    const parsed = ImportRowResultSchema.parse(okRow);
+    expect(parsed).toEqual(okRow);
+    expect('droppedFields' in parsed).toBe(false);
+  });
+
+  it('parses a row with droppedFields and keeps every event', () => {
+    const parsed = ImportRowResultSchema.parse({ ...okRow, droppedFields: drops });
+    expect(parsed.droppedFields).toEqual(drops);
+    expect(parsed.ok).toBe(true);
+    expect(parsed.action).toBe('created');
+  });
+
+  it('the element is the engine\'s DroppedFieldsEventSchema itself — no second vocabulary', () => {
+    const element = ImportRowResultSchema.shape.droppedFields.unwrap().element;
+    expect(element).toBe(DroppedFieldsEventSchema);
+  });
+
+  it('accepts exactly the engine\'s reason set, `computed` included', () => {
+    const engineReasons = DroppedFieldsEventSchema.shape.reason.options;
+    expect(engineReasons).toContain('computed');
+    for (const reason of engineReasons) {
+      const parsed = ImportRowResultSchema.parse({
+        ...okRow, droppedFields: [{ object: 'project', fields: ['f'], reason }],
+      });
+      expect(parsed.droppedFields?.[0]?.reason, `reason ${reason}`).toBe(reason);
+    }
+    const outside = ImportRowResultSchema.safeParse({
+      ...okRow, droppedFields: [{ object: 'project', fields: ['f'], reason: 'not_a_reason' }],
+    });
+    expect(outside.success).toBe(false);
+    const issue = outside.success ? undefined : outside.error.issues[0];
+    expect(issue?.code).toBe('invalid_value');
+    expect(issue?.path).toEqual(['droppedFields', 0, 'reason']);
+  });
+
+  it('keeps the served dry-run warnings, in the validate verdict\'s issue shape', () => {
+    const warnings = [{ field: 'billing_address', code: 'invalid_type', message: 'billing_address has an invalid value' }];
+    const parsed = ImportRowResultSchema.parse({ ...okRow, warnings });
+    expect(parsed.warnings).toEqual(warnings);
+    const partial = ImportRowResultSchema.safeParse({ ...okRow, warnings: [{ field: 'x', code: 'y' }] });
+    expect(partial.success).toBe(false);
+    const issue = partial.success ? undefined : partial.error.issues[0];
+    expect(issue?.path).toEqual(['warnings', 0, 'message']);
+  });
+
+  it('the async job sample carries the same row keys', () => {
+    const parsed = ImportJobResultsSchema.parse({
+      jobId: 'imp_1', object: 'project', status: 'succeeded', dryRun: false, writeMode: 'insert',
+      total: 1, processed: 1, created: 1, updated: 0, skipped: 0, errors: 0, percentComplete: 100,
+      undoable: true, createdAt: '2026-09-30T00:00:00.000Z',
+      results: [{ ...okRow, droppedFields: drops }], resultsTruncated: false,
+    });
+    expect(parsed.results[0]?.droppedFields).toEqual(drops);
+    const described = (ImportJobResultsSchema.shape.results as { description?: string }).description ?? '';
+    expect(described).toMatch(/failures first/);
+    expect(described).toMatch(/inside the sample/);
+  });
+
+  it('the typed reader sees both keys, in the engine\'s and the verdict\'s types', () => {
+    expectTypeOf<NonNullable<ImportRowResult['droppedFields']>[number]>().toEqualTypeOf<DroppedFieldsEvent>();
+    expectTypeOf<NonNullable<ImportRowResult['warnings']>[number]>().toEqualTypeOf<ValidateDataIssue>();
+  });
+});