@@ -0,0 +1,15 @@
+---
+'@object-ui/plugin-grid': patch
+'@object-ui/app-shell': patch
+---
+
+fix(plugin-grid): the import wizard no longer demands a required field that carries a default
+
+Clause-②: yes (widening)
+Metadata-protocol: none
+
+The mapping step held Next with "required field(s) not mapped" for a required field left unmapped even when the field declares a `defaultValue`, static or an expression, which the create fills for a row that leaves the field out. A file without that column could not be imported. The step now treats such a field as satisfied, and leaves the value to the server. The same check spares the preview's blank cell in a mapped column of such a field, which the server also fills with the default. An option marked `default: true` counts as a default when no `defaultValue` is declared, as the create reads it. A required field with no default still blocks, and its blank cell is still marked. The wizard reads only whether a default is declared; it never evaluates one.
+
+`ImportWizardProps['fields']` gains an optional `defaultValue` (passed through as the object schema declares it), and its option objects an optional `default`. The Console's two hosts of the wizard, the object list's Import and the AI chat's spreadsheet import, now pass the field's `defaultValue` through.
+
+What to do: a host that builds the wizard's `fields` itself passes each field's `defaultValue` through to get the same behaviour; without it a defaulted required field is still demanded.
@@ -41,6 +41,7 @@ interface WizardField {
   label: string;
   type: string;
   required?: boolean;
+  defaultValue?: unknown;
   options?: Array<{ label?: string; value?: string | number } | string>;
   multiple?: boolean;
 }
@@ -71,6 +72,8 @@ function normalizeFields(schema: any): WizardField[] {
       label: (def?.label ?? def?.name ?? name) as string,
       type: (def?.type ?? 'text') as string,
       required: !!def?.required,
+      // The wizard reads only that a default is declared (the create fills it).
+      ...(def?.defaultValue != null ? { defaultValue: def.defaultValue } : {}),
       options: def?.options,
       // A field holding a list is never offered as a match key (#27567).
       ...(def?.multiple === true ? { multiple: true } : {}),
 
@@ -37,6 +37,24 @@ describe('importTargetFields', () => {
     expect(byName.code.required).toBe(false);
   });
 
+  it('passes a declared defaultValue through as declared, and none when absent or null', () => {
+    const expression = { dialect: 'cel', source: "record.source == 'self' ? 'to_review' : 'to_confirm'" };
+    const out = importTargetFields('duty', {
+      review_status: { type: 'select', label: 'Review status', required: true, defaultValue: expression },
+      priority: { type: 'select', label: 'Priority', required: true, defaultValue: 'normal' },
+      owner_name: { type: 'text', label: 'Owner', required: true, defaultValue: null },
+      title: { type: 'text', label: 'Title', required: true },
+    });
+    const byName = Object.fromEntries(out.map((f) => [f.name, f]));
+    // The expression envelope is carried as is, never evaluated or flattened.
+    expect(byName.review_status.defaultValue).toBe(expression);
+    expect(byName.priority.defaultValue).toBe('normal');
+    expect('defaultValue' in byName.owner_name).toBe(false);
+    expect('defaultValue' in byName.title).toBe(false);
+    // `required` still states the schema; the wizard decides what a default spares.
+    expect(byName.review_status.required).toBe(true);
+  });
+
   it('still drops computed fields — no storage column to match or write', () => {
     const out = importTargetFields('device', fields);
     const names = out.map((f) => f.name);
 
@@ -30,6 +30,7 @@ export interface ImportTargetField {
   label: string;
   type: string;
   required?: boolean;
+  defaultValue?: unknown;
   matchOnly?: boolean;
   options?: unknown;
   multiple?: boolean;
@@ -65,6 +66,10 @@ export function importTargetFields(
       // A non-writable target can never be a required WRITE column —
       // `required` only steers the mapping step's completeness hint.
       required: writable && !!def?.required,
+      // Passed through as declared: the wizard reads only that a default is
+      // there (the create fills it), so a defaulted required field is not
+      // demanded from the file. Never evaluated client-side.
+      ...(def?.defaultValue != null ? { defaultValue: def.defaultValue } : {}),
       ...(matchOnly ? { matchOnly: true } : {}),
       // Enum options seed the downloadable template's example row.
       ...(def?.options ? { options: def.options } : {}),
 
@@ -0,0 +1,119 @@
+/**
+ * ObjectUI – Copyright (c) 2024-present ObjectStack Inc.
+ * Licensed under MIT.
+ */
+
+/**
+ * A required field that carries a default is not demanded from the file.
+ *
+ * The create fills a declared `defaultValue` (static or an expression) and,
+ * when none is declared, an option marked `default: true`, for a row that
+ * leaves the field out or blank. So the mapping step does not hold Next for
+ * such a field left unmapped, and the preview does not mark its blank cell.
+ * A required field with no default still blocks. The wizard only asks whether
+ * a default is declared: the expression below is never evaluated here.
+ */
+import { describe, it, expect } from 'vitest';
+import { render, screen, fireEvent, waitFor, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import React from 'react';
+
+import { ImportWizard } from './ImportWizard';
+
+type WizardField = React.ComponentProps<typeof ImportWizard>['fields'][number];
+
+const REVIEW_OPTIONS = [
+  { label: 'To review', value: 'to_review' },
+  { label: 'To confirm', value: 'to_confirm' },
+];
+
+/** A record-derived expression default, the shape the reported app declares. */
+const EXPRESSION_DEFAULT = { dialect: 'cel', source: "record.source == 'self' ? 'to_review' : 'to_confirm'" };
+
+const title: WizardField = { name: 'title', label: 'Title', type: 'text' };
+const owner: WizardField = { name: 'owner_name', label: 'Owner', type: 'text', required: true };
+const reviewStatus: WizardField = {
+  name: 'review_status', label: 'Review status', type: 'select', required: true,
+  defaultValue: EXPRESSION_DEFAULT, options: REVIEW_OPTIONS,
+};
+const priority: WizardField = {
+  name: 'priority', label: 'Priority', type: 'select', required: true, defaultValue: 'normal',
+  options: [{ label: 'Normal', value: 'normal' }, { label: 'High', value: 'high' }],
+};
+const stage: WizardField = {
+  name: 'stage', label: 'Stage', type: 'select', required: true,
+  options: [{ label: 'New', value: 'new', default: true }, { label: 'Done', value: 'done' }],
+};
+
+/** Paste TSV into the upload step via the wizard's window-level handler. */
+function pasteRows(text: string) {
+  const evt = new Event('paste', { bubbles: true, cancelable: true }) as Event & {
+    clipboardData: { getData: (type: string) => string };
+  };
+  evt.clipboardData = { getData: (type: string) => (type === 'text/plain' ? text : '') };
+  act(() => { window.dispatchEvent(evt); });
+}
+
+function renderWizard(fields: WizardField[]) {
+  render(<ImportWizard objectName="duty" fields={fields} dataSource={{}} open onOpenChange={() => {}} />);
+}
+
+describe('ImportWizard mapping step: a required field with a default', () => {
+  it('does not hold Next for an unmapped required field with an expression default', async () => {
+    renderWizard([title, reviewStatus]);
+    pasteRows('Title\nAlpha');
+    const next = await screen.findByTestId('import-next-btn');
+    await waitFor(() => expect(next).toBeEnabled());
+    expect(screen.queryByTestId('import-missing-required')).not.toBeInTheDocument();
+  });
+
+  it('does not hold Next for a static default or an option marked default', async () => {
+    renderWizard([title, priority, stage]);
+    pasteRows('Title\nAlpha');
+    const next = await screen.findByTestId('import-next-btn');
+    await waitFor(() => expect(next).toBeEnabled());
+    expect(screen.queryByTestId('import-missing-required')).not.toBeInTheDocument();
+  });
+
+  it('still names a required field with no default, and only that one', async () => {
+    renderWizard([title, owner, reviewStatus, priority, stage]);
+    pasteRows('Title\nAlpha');
+    const hint = await screen.findByTestId('import-missing-required');
+    expect(hint).toHaveTextContent('Owner (owner_name)');
+    expect(hint).not.toHaveTextContent('review_status');
+    expect(hint).not.toHaveTextContent('priority');
+    expect(hint).not.toHaveTextContent('stage');
+    expect(screen.getByTestId('import-next-btn')).toBeDisabled();
+  });
+
+  it('a null defaultValue declares no default', async () => {
+    renderWizard([title, { ...owner, defaultValue: null }]);
+    pasteRows('Title\nAlpha');
+    expect(await screen.findByTestId('import-missing-required')).toHaveTextContent('Owner (owner_name)');
+  });
+});
+
+describe('ImportWizard preview: a blank cell in a required field with a default', () => {
+  const cell = (row: number, col: number) => screen.getByTestId(`import-preview-cell-${row}-${col}`);
+
+  async function openPreview(fields: WizardField[], tsv: string) {
+    renderWizard(fields);
+    pasteRows(tsv);
+    const next = await screen.findByTestId('import-next-btn');
+    await waitFor(() => expect(next).toBeEnabled());
+    fireEvent.click(next);
+    return screen.findByTestId('import-run-btn');
+  }
+
+  it('leaves the blank cell of a defaulted required column unmarked and counts its row', async () => {
+    const button = await openPreview([title, reviewStatus], 'Title\tReview status\nAlpha\t\nBeta\tTo confirm');
+    expect(cell(0, 1)).toHaveAttribute('aria-invalid', 'false');
+    expect(button).toHaveTextContent('Import 2 Rows');
+  });
+
+  it('still marks the blank cell of a required column with no default', async () => {
+    const button = await openPreview([title, owner], 'Title\tOwner\nAlpha\t\nBeta\tAda');
+    expect(cell(0, 1)).toHaveAttribute('aria-invalid', 'true');
+    expect(button).toHaveTextContent('Import 1 Row');
+  });
+});
@@ -360,9 +360,15 @@ export interface ImportWizardProps {
     label: string;
     type: string;
     required?: boolean;
+    /** The object schema's `defaultValue`, static or an expression, passed
+     *  through as declared. The wizard reads only whether one is declared
+     *  ({@link importFillsDefault}) and never evaluates it: the create fills
+     *  it, so a required field carrying one need not come from the file. */
+    defaultValue?: unknown;
     /** Allowed values for select/enum fields. Accepts option objects or bare
-     *  strings. */
-    options?: Array<{ label?: string; value?: string | number } | string>;
+     *  strings. An option marked `default: true` is the field's default when it
+     *  declares no `defaultValue`, as the create reads it. */
+    options?: Array<{ label?: string; value?: string | number; default?: boolean } | string>;
     /** The object schema's `multiple` flag: a `select` / `radio` / `lookup` /
      *  `user` / `file` / `image` field flagged `multiple: true` stores a list.
      *  "Match on" reads it, as the server does, to leave such a field out
@@ -622,6 +628,29 @@ function isMatchKeyField(field: Pick<ImportTargetField, 'type' | 'multiple'>): b
   return !isMultiValueField({ type: field.type, multiple: field.multiple === true });
 }
 
+/**
+ * Whether the create fills this field when a row leaves it out or blank. It
+ * asks what the engine's insert defaulting asks: a declared `defaultValue`
+ * (`null` and absent declare none; an expression counts, whatever it reads),
+ * else an option marked `default: true` that carries a value. Presence only:
+ * the value, and an expression's result, are the server's.
+ */
+function importFillsDefault(field: Pick<ImportTargetField, 'defaultValue' | 'options'>): boolean {
+  if (field.defaultValue != null) return true;
+  return (field.options ?? []).some(
+    (o) => typeof o === 'object' && o !== null && o.default === true && o.value != null,
+  );
+}
+
+/**
+ * Whether a create needs this field's value from the file: it is required and
+ * the create has no default to fill it with. The mapping step's missing-field
+ * check and the preview's blank-cell check both ask this.
+ */
+function importRequiresValue(field: ImportTargetField): boolean {
+  return field.required === true && !importFillsDefault(field);
+}
+
 /** The only comma a numeric cell may carry: a thousands grouping of its integer part. */
 const THOUSANDS_GROUPED_INTEGER = /^[+-]?\d{1,3}(?:,\d{3})+(?![\d,])[^,]*$/;
 
@@ -759,7 +788,7 @@ function checkImportCell(
   opts: CellCheckOptions,
 ): CellRefusal | undefined {
   const value = cell.trim();
-  if (value === '') return field.required && opts.requireValues ? { code: 'required' } : undefined;
+  if (value === '') return importRequiresValue(field) && opts.requireValues ? { code: 'required' } : undefined;
   const { type } = field;
   if (BOOLEAN_VALUE_TYPES.has(type)) {
     return BOOLEAN_IMPORT_TOKENS.has(value.toLowerCase()) ? undefined : { code: 'invalid_boolean', value };
@@ -883,6 +912,9 @@ function validateRow(row: string[], mappedCols: MappedCol[], rowIndex: number, k
       errors.push({ row: rowIndex, field: col.field.name, message: `Invalid ${col.field.type} value: "${refusal.value}"` });
       continue;
     }
+    // A blank cell of a defaulted field is left out, so the create fills the
+    // default, as the server import does; an empty string would be stored.
+    if (raw.trim() === '' && importFillsDefault(col.field)) continue;
     record[col.field.name] = raw;
   }
   return { record, errors };
@@ -1741,7 +1773,7 @@ const StepMapping: React.FC<{
                     <SelectItem value="__skip__">{t('grid.import.skip')}</SelectItem>
                     {fields.map((f) => (
                       <SelectItem key={f.name} value={f.name} disabled={usedFields.has(f.name) && mapping[idx] !== f.name}>
-                        {f.label}{f.required ? ' *' : ''}{f.matchOnly ? ` ${t('grid.import.matchOnlyField')}` : ''}
+                        {f.label}{importRequiresValue(f) ? ' *' : ''}{f.matchOnly ? ` ${t('grid.import.matchOnlyField')}` : ''}
                       </SelectItem>
                     ))}
                   </SelectContent>
@@ -2486,7 +2518,7 @@ export const ImportWizard: React.FC<ImportWizardProps> = ({
 
   const missingRequired = useMemo(() => {
     const mapped = new Set(Object.values(mapping));
-    return fields.filter((f) => f.required && !mapped.has(f.name));
+    return fields.filter((f) => importRequiresValue(f) && !mapped.has(f.name));
   }, [fields, mapping]);
   // objectui#12303 — the "Can't continue" hint's id, so the Next it disables
   // is described by it. A saved mapping lets the server own the columns, so