@solidxai/core-ui 0.1.12-beta.6 → 0.1.12-beta.8

package/dist/routes/pages/admin/core/DatasourceIntrospectionPage.tsx

@@ -2,6 +2,7 @@ import {
   ArrowLeft,
   Check,
   Cog,
+  Copy,
   Database,
   ExternalLink,
   RefreshCw,
@@ -44,16 +45,16 @@ import {
   type DatasourceIntrospectionTableRecord,
   type DatasourceIntrospectionApplyResponse,
   type DatasourceIntrospectionCreateMigrationResponse,
+  datasourceIntrospectionApi,
   useApplyDatasourceIntrospectionMappingMutation,
   useCreateDatasourceIntrospectionMigrationArtifactsMutation,
   useGenerateDatasourceIntrospectionCodeMutation,
   useGetDatasourceIntrospectionBootstrapQuery,
-  useGetDatasourceIntrospectionTableDetailQuery,
   useGetDatasourceIntrospectionTablesQuery,
   usePreviewDatasourceIntrospectionMappingMutation,
   useRunDatasourceIntrospectionMigrationMutation,
 } from "../../../../redux/api/datasourceIntrospectionApi";
-import { useGetmodelByIdQuery } from "../../../../redux/api/modelApi";
+import { modelsApi } from "../../../../redux/api/modelApi";
 import "./DatasourceIntrospectionPage.css";
 
 type SessionSettings = {
@@ -61,6 +62,13 @@ type SessionSettings = {
   prioritizeUnmappedTables: boolean;
 };
 
+type BatchWorkspaceItemState = "idle" | "loading" | "ready" | "success" | "error";
+
+type BatchWorkspaceItemStatus = {
+  state: BatchWorkspaceItemState;
+  message: string;
+};
+
 type WorkspaceStep =
   | "configure"
   | "review-json"
@@ -111,10 +119,34 @@ type DrawerDraft = {
   enableSoftDelete: boolean;
   draftPublishWorkflow: boolean;
   internationalisation: boolean;
+  hasPrimaryKey: boolean;
+  primaryKeyColumnCount: number;
+  primaryKeyColumnNames: string[];
+  mappingBlockedReason: string | null;
   columns: DrawerColumnDraft[];
   preservedFields: any[];
 };
 
+type WorkspaceBatchItem = {
+  key: string;
+  record: DatasourceIntrospectionTableRecord;
+  detail: DatasourceIntrospectionTableDetail | null;
+  mappedModelData: any | null;
+  draft: DrawerDraft | null;
+  loadStatus: BatchWorkspaceItemStatus;
+  reviewStatus: BatchWorkspaceItemStatus;
+  saveStatus: BatchWorkspaceItemStatus;
+  migrationStatus: BatchWorkspaceItemStatus;
+  mappingPreview: DatasourceIntrospectionMappingPreview | null;
+  persistedMappingResult: DatasourceIntrospectionApplyResponse | null;
+  migrationArtifactsResult: DatasourceIntrospectionCreateMigrationResponse | null;
+  reviewedMetadataJsonValue: any | null;
+  metadataJsonText: string;
+  metadataJsonValidationError: string | null;
+  metadataJsonResetToken: string;
+  error: string | null;
+};
+
 function providerLabel(type: string) {
   if (type === "postgres") return "PostgreSQL";
   if (type === "mysql") return "MySQL";
@@ -139,7 +171,9 @@ const scalarFieldTypeOptions = [
   { value: "password", label: "Password" },
 ];
 
-const scalarFieldTypeValueSet = new Set(scalarFieldTypeOptions.map((option) => option.value));
+function getFieldTypeLabel(type: string) {
+  return scalarFieldTypeOptions.find((option) => option.value === type)?.label ?? startCase(type);
+}
 const mappingStrategyOptions = [
   { value: "generated_id", label: "Legacy generated id" },
   { value: "existing_id", label: "Legacy existing id" },
@@ -242,6 +276,10 @@ function getDefaultOrmTypeForSolidFieldType(dataSourceType: string, solidFieldTy
 }
 
 function statusLabel(record: DatasourceIntrospectionTableRecord) {
+  if (!record.hasPrimaryKey) {
+    return "Blocked";
+  }
+
   return record.mapped ? "Mapped" : "Ready to map";
 }
 
@@ -351,7 +389,13 @@ function buildDrawerDraft(
     };
   });
 
-  const draftUserKeyField = modelUserKeyField || tableDetail.suggestedMetadata.userKeyField;
+  const requestedUserKeyField = modelUserKeyField || tableDetail.suggestedMetadata.userKeyField;
+  const resolvedUserKeyField = (
+    columns.find((column) => column.fieldName === requestedUserKeyField)
+    || columns.find((column) => column.columnName === requestedUserKeyField)
+    || columns.find((column) => !column.handledBySuperclass && column.isPrimaryKey)
+    || columns.find((column) => !column.handledBySuperclass && column.include)
+  )?.fieldName ?? requestedUserKeyField;
 
   return {
     mapped: selectedTable.mapped,
@@ -367,11 +411,15 @@ function buildDrawerDraft(
     dataSourceType: modelData?.dataSourceType ?? tableDetail.suggestedMetadata.dataSourceType,
     legacyTableType: modelData?.legacyTableType ?? tableDetail.suggestedMetadata.legacyTableType,
     baseClassName: tableDetail.suggestedMetadata.baseClassName,
-    userKeyField: draftUserKeyField,
+    userKeyField: resolvedUserKeyField,
     enableAuditTracking: modelData?.enableAuditTracking ?? true,
     enableSoftDelete: modelData?.enableSoftDelete ?? false,
     draftPublishWorkflow: modelData?.draftPublishWorkflow ?? false,
     internationalisation: modelData?.internationalisation ?? false,
+    hasPrimaryKey: selectedTable.hasPrimaryKey,
+    primaryKeyColumnCount: selectedTable.primaryKeyColumnCount,
+    primaryKeyColumnNames: selectedTable.primaryKeyColumnNames,
+    mappingBlockedReason: selectedTable.mappingBlockedReason,
     columns,
     preservedFields,
   };
@@ -395,6 +443,13 @@ function getDrawerValidationErrors(draft: DrawerDraft) {
     errors.push("Select at least one physical column to include in the mapping.");
   }
 
+  if (!draft.hasPrimaryKey) {
+    errors.push(
+      draft.mappingBlockedReason
+      || `Table "${draft.tableName}" cannot be mapped because the datasource table does not define any primary key.`,
+    );
+  }
+
   for (const column of includedColumns) {
     const normalizedFieldName = column.fieldName.trim();
     if (!normalizedFieldName) {
@@ -407,8 +462,8 @@ function getDrawerValidationErrors(draft: DrawerDraft) {
       continue;
     }
 
-    if (!scalarFieldTypeValueSet.has(column.solidFieldType)) {
-      errors.push(`SolidX type "${column.solidFieldType}" is not allowed in step 1 for column "${column.columnName}".`);
+    if (!column.solidFieldType.trim()) {
+      errors.push(`SolidX type is required for column "${column.columnName}".`);
       continue;
     }
 
@@ -423,17 +478,26 @@ function getDrawerValidationErrors(draft: DrawerDraft) {
   if (!draft.userKeyField.trim()) {
     errors.push("Choose a user key field before saving the mapping.");
   } else {
-    const userKeyExists = includedColumns.some((column) => column.fieldName === draft.userKeyField);
+    const userKeyExists = draft.columns.some((column) => (
+      column.fieldName === draft.userKeyField
+      && (column.handledBySuperclass || column.include)
+    ));
     if (!userKeyExists) {
       errors.push("The chosen user key field must remain part of the mapped columns.");
     }
   }
 
-  if (draft.legacyTableType === "existing_id") {
-    const hasPrimaryKey = includedColumns.some((column) => column.isPrimaryKey);
-    if (!hasPrimaryKey) {
-      errors.push("Legacy existing-id mappings must keep the generated id column mapped to field name \"id\".");
-    }
+  const includedPrimaryKeyColumns = includedColumns.filter((column) => column.isPrimaryKey);
+  if (draft.hasPrimaryKey && !includedPrimaryKeyColumns.length) {
+    errors.push("Keep the datasource primary key columns included in the mapping.");
+  }
+
+  const missingDetectedPrimaryKeyColumns = draft.columns
+    .filter((column) => column.isDetectedPrimaryKey && !column.handledBySuperclass)
+    .filter((column) => !column.include || !column.isPrimaryKey)
+    .map((column) => column.columnName);
+  if (missingDetectedPrimaryKeyColumns.length) {
+    errors.push(`Keep all datasource primary key columns mapped and marked as primary key: ${missingDetectedPrimaryKeyColumns.join(", ")}.`);
   }
 
   return errors;
@@ -616,23 +680,90 @@ function parseAndValidateReviewedModelJson(
     seenFieldNames.add(normalizedFieldName);
   }
 
-  if (!parsed.fields.some((field: any) => field?.name === parsed.userKeyFieldUserKey && !field?.isMarkedForRemoval)) {
+  const expectedUserKeyFieldName = `${parsed.userKeyFieldUserKey ?? draft.userKeyField ?? ""}`.trim();
+  const resolvedUserKeyFieldName = resolveReviewedUserKeyFieldName(
+    parsed.fields,
+    expectedUserKeyFieldName,
+    draft.userKeyField,
+  );
+  const inheritedGeneratedIdUserKey =
+    draft.legacyTableType === "generated_id" && expectedUserKeyFieldName.toLowerCase() === "id";
+
+  if (!resolvedUserKeyFieldName && !inheritedGeneratedIdUserKey) {
     return {
       error: "Metadata JSON must keep userKeyFieldUserKey present in the fields array.",
       parsed: null,
     };
   }
 
+  if (draft.hasPrimaryKey) {
+    const activeFields = parsed.fields.filter((field: any) => !field?.isMarkedForRemoval);
+    const missingPrimaryKeyColumns = draft.columns
+      .filter((column) => column.isDetectedPrimaryKey && !column.handledBySuperclass)
+      .filter((column) => {
+        const matchingField = activeFields.find((field: any) =>
+          `${field?.columnName ?? ""}`.trim().toLowerCase() === column.columnName.trim().toLowerCase(),
+        );
+
+        return !matchingField || matchingField.isPrimaryKey !== true;
+      })
+      .map((column) => column.columnName);
+
+    if (missingPrimaryKeyColumns.length) {
+      return {
+        error: `Metadata JSON must keep all datasource primary key columns marked with isPrimaryKey: true: ${missingPrimaryKeyColumns.join(", ")}.`,
+        parsed: null,
+      };
+    }
+  }
+
+  parsed.userKeyFieldUserKey = resolvedUserKeyFieldName ?? expectedUserKeyFieldName;
+
   return {
     error: null,
     parsed,
   };
 }
 
+function resolveReviewedUserKeyFieldName(
+  reviewedFields: Array<Record<string, any>>,
+  requestedUserKeyFieldName: string,
+  fallbackUserKeyFieldName?: string,
+) {
+  const activeFields = reviewedFields.filter((field) => !field?.isMarkedForRemoval);
+  const normalizedRequested = `${requestedUserKeyFieldName ?? ""}`.trim().toLowerCase();
+  const normalizedFallback = `${fallbackUserKeyFieldName ?? ""}`.trim().toLowerCase();
+
+  const byExactRequested = activeFields.find((field) => field?.name?.toLowerCase?.() === normalizedRequested);
+  if (byExactRequested?.name) {
+    return byExactRequested.name;
+  }
+
+  const byExistingUserKeyFlag = activeFields.find((field) => field?.isUserKey);
+  if (byExistingUserKeyFlag?.name) {
+    return byExistingUserKeyFlag.name;
+  }
+
+  const byPrimaryKeyFallback = activeFields.find((field) => {
+    if (!field?.isPrimaryKey) {
+      return false;
+    }
+
+    const normalizedName = `${field?.name ?? ""}`.trim().toLowerCase();
+    return normalizedName === normalizedFallback || normalizedName === "id" || normalizedName === "legacyid";
+  });
+  if (byPrimaryKeyFallback?.name) {
+    return byPrimaryKeyFallback.name;
+  }
+
+  const byFallbackFieldName = activeFields.find((field) => field?.name?.toLowerCase?.() === normalizedFallback);
+  return byFallbackFieldName?.name ?? null;
+}
+
 export function DatasourceIntrospectionPage() {
   const params = useParams();
   const navigate = useNavigate();
-  const dispatch = useDispatch();
+  const dispatch = useDispatch<any>();
   const moduleId = Number(params.moduleId ?? 0);
   const isValidModuleId = Number.isFinite(moduleId) && moduleId > 0;
 
@@ -648,36 +779,30 @@ export function DatasourceIntrospectionPage() {
 
   const [selectedDatasource, setSelectedDatasource] = useState("");
   const [selectedRows, setSelectedRows] = useState<DatasourceIntrospectionTableRecord[]>([]);
-  const [workspaceTableKey, setWorkspaceTableKey] = useState("");
+  const [workspaceTableKeys, setWorkspaceTableKeys] = useState<string[]>([]);
+  const [activeWorkspaceTableKey, setActiveWorkspaceTableKey] = useState("");
+  const [workspaceItems, setWorkspaceItems] = useState<Record<string, WorkspaceBatchItem>>({});
+  const workspaceRailItemRefs = useRef<Record<string, HTMLButtonElement | null>>({});
   const [tableSearch, setTableSearch] = useState("");
   const [settingsOpen, setSettingsOpen] = useState(false);
   const [settingsTab, setSettingsTab] = useState("datasource-info");
-  const [drawerDraft, setDrawerDraft] = useState<DrawerDraft | null>(null);
   const [drawerTab, setDrawerTab] = useState("general-info");
   const [workspaceStep, setWorkspaceStep] = useState<WorkspaceStep>("configure");
-  const [mappingPreview, setMappingPreview] = useState<DatasourceIntrospectionMappingPreview | null>(null);
-  const [persistedMappingResult, setPersistedMappingResult] = useState<DatasourceIntrospectionApplyResponse | null>(null);
-  const [migrationArtifactsResult, setMigrationArtifactsResult] = useState<DatasourceIntrospectionCreateMigrationResponse | null>(null);
   const [generateCodeOutput, setGenerateCodeOutput] = useState("");
   const [isGeneratingCodeWorkflow, setIsGeneratingCodeWorkflow] = useState(false);
   const [generateCodeStatusMessage, setGenerateCodeStatusMessage] = useState("");
   const [generateCodeTimeoutMessage, setGenerateCodeTimeoutMessage] = useState<string | null>(null);
   const [generateCodeReady, setGenerateCodeReady] = useState(false);
   const [hasAttemptedGenerateCode, setHasAttemptedGenerateCode] = useState(false);
+  const [migrationPreviewCopied, setMigrationPreviewCopied] = useState(false);
   const [runMigrationOutput, setRunMigrationOutput] = useState("");
   const [runMigrationCompleted, setRunMigrationCompleted] = useState(false);
-  const [reviewedMetadataJsonValue, setReviewedMetadataJsonValue] = useState<any>(null);
-  const [metadataJsonText, setMetadataJsonText] = useState("");
-  const [metadataJsonValidationError, setMetadataJsonValidationError] = useState<string | null>(null);
-  const [metadataJsonResetToken, setMetadataJsonResetToken] = useState("initial");
-  const [drawerBootstrapping, setDrawerBootstrapping] = useState(false);
   const [fieldConfigColumnName, setFieldConfigColumnName] = useState<string | null>(null);
   const [sessionSettings, setSessionSettings] = useState<SessionSettings>({
     relationInferenceEnabled: false,
     prioritizeUnmappedTables: true,
   });
   const [draftSessionSettings, setDraftSessionSettings] = useState<SessionSettings>(sessionSettings);
-  const drawerBootstrapTimerRef = useRef<number | null>(null);
 
   const [
     previewMapping,
@@ -725,14 +850,12 @@ export function DatasourceIntrospectionPage() {
 
   useEffect(() => {
     setSelectedRows([]);
-    setWorkspaceTableKey("");
-    setDrawerDraft(null);
+    setWorkspaceTableKeys([]);
+    setActiveWorkspaceTableKey("");
+    setWorkspaceItems({});
     setFieldConfigColumnName(null);
     setTableSearch("");
     setWorkspaceStep("configure");
-    setMappingPreview(null);
-    setPersistedMappingResult(null);
-    setMigrationArtifactsResult(null);
     setGenerateCodeOutput("");
     setIsGeneratingCodeWorkflow(false);
     setGenerateCodeStatusMessage("");
@@ -741,17 +864,35 @@ export function DatasourceIntrospectionPage() {
     setHasAttemptedGenerateCode(false);
     setRunMigrationOutput("");
     setRunMigrationCompleted(false);
-    setReviewedMetadataJsonValue(null);
-    setMetadataJsonText("");
-    setMetadataJsonValidationError(null);
-    setMetadataJsonResetToken(`datasource-${Date.now()}`);
   }, [selectedDatasource]);
 
-  useEffect(() => () => {
-    if (drawerBootstrapTimerRef.current) {
-      window.clearTimeout(drawerBootstrapTimerRef.current);
-    }
-  }, []);
+  const activeWorkspaceProcessingKey = useMemo(
+    () =>
+      workspaceTableKeys.find((key) => {
+        const item = workspaceItems[key];
+        if (!item) return false;
+
+        return [
+          item.loadStatus.state,
+          item.reviewStatus.state,
+          item.saveStatus.state,
+          item.migrationStatus.state,
+        ].includes("loading");
+      }) ?? null,
+    [workspaceItems, workspaceTableKeys],
+  );
+
+  useEffect(() => {
+    const targetKey = activeWorkspaceProcessingKey ?? activeWorkspaceTableKey;
+    if (!targetKey) return;
+
+    const targetNode = workspaceRailItemRefs.current[targetKey];
+    targetNode?.scrollIntoView({
+      block: "nearest",
+      inline: "nearest",
+      behavior: "smooth",
+    });
+  }, [activeWorkspaceProcessingKey, activeWorkspaceTableKey]);
 
   const datasourceOptions = useMemo(
     () => (bootstrap?.datasources ?? []).map((datasource) => ({
@@ -773,45 +914,27 @@ export function DatasourceIntrospectionPage() {
       skip: !isValidModuleId || !selectedDatasource,
     },
   );
-
-  const selectedListRow = selectedRows[0] ?? null;
-  const selectedListRowKey = selectedListRow ? `${selectedListRow.schema ?? ""}::${selectedListRow.tableName}` : "";
-  const isWorkspaceMode = Boolean(workspaceTableKey);
-
-  const selectedTable = useMemo(
-    () => tablesResponse?.records?.find((record) => `${record.schema ?? ""}::${record.tableName}` === workspaceTableKey) ?? null,
-    [tablesResponse, workspaceTableKey],
+  const selectedDatasourceRecord = bootstrap?.datasources?.find((datasource) => datasource.name === selectedDatasource) ?? null;
+  const isSynchronizeBlocked = Boolean(selectedDatasource && tablesResponse?.synchronizeBlocked);
+  const makeTableKey = (schema: string | null | undefined, tableName: string) => `${schema ?? ""}::${tableName}`;
+  const selectedListRowKeySet = useMemo(
+    () => new Set(selectedRows.map((row) => makeTableKey(row.schema, row.tableName))),
+    [selectedRows],
   );
-
-  const {
-    data: tableDetail,
-    isLoading: isTableDetailLoading,
-    isFetching: isTableDetailFetching,
-    error: tableDetailError,
-    refetch: refetchTableDetail,
-  } = useGetDatasourceIntrospectionTableDetailQuery(
-    {
-      moduleId,
-      datasource: selectedDatasource,
-      table: selectedTable?.tableName ?? "",
-      schema: selectedTable?.schema ?? undefined,
-    },
-    {
-      skip: !isWorkspaceMode || !isValidModuleId || !selectedDatasource || !selectedTable || !!tablesResponse?.synchronizeBlocked,
-    },
+  const isWorkspaceMode = workspaceTableKeys.length > 0 && Boolean(activeWorkspaceTableKey);
+  const selectedTable = useMemo(
+    () => workspaceItems[activeWorkspaceTableKey]?.record ?? null,
+    [activeWorkspaceTableKey, workspaceItems],
   );
-
-  const {
-    data: mappedModelResponse,
-    isLoading: isMappedModelLoading,
-    isFetching: isMappedModelFetching,
-    error: mappedModelError,
-  } = useGetmodelByIdQuery(selectedTable?.mappedModelId ?? 0, {
-    skip: !isWorkspaceMode || !selectedTable?.mapped || !selectedTable?.mappedModelId,
-  });
-
-  const mappedModelData = mappedModelResponse?.data;
-  const selectedDatasourceRecord = bootstrap?.datasources?.find((datasource) => datasource.name === selectedDatasource) ?? null;
+  const activeWorkspaceItem = activeWorkspaceTableKey ? workspaceItems[activeWorkspaceTableKey] ?? null : null;
+  const drawerDraft = activeWorkspaceItem?.draft ?? null;
+  const mappingPreview = activeWorkspaceItem?.mappingPreview ?? null;
+  const persistedMappingResult = activeWorkspaceItem?.persistedMappingResult ?? null;
+  const migrationArtifactsResult = activeWorkspaceItem?.migrationArtifactsResult ?? null;
+  const reviewedMetadataJsonValue = activeWorkspaceItem?.reviewedMetadataJsonValue ?? null;
+  const metadataJsonText = activeWorkspaceItem?.metadataJsonText ?? "";
+  const metadataJsonValidationError = activeWorkspaceItem?.metadataJsonValidationError ?? null;
+  const metadataJsonResetToken = activeWorkspaceItem?.metadataJsonResetToken ?? "initial";
   const activeFieldConfigColumn = drawerDraft?.columns.find((column) => column.columnName === fieldConfigColumnName) ?? null;
   const activeFieldConfigMetaData = useMemo(() => {
     if (!drawerDraft || !activeFieldConfigColumn) {
@@ -864,76 +987,12 @@ export function DatasourceIntrospectionPage() {
         columnName: column.columnName,
       }));
   }, [activeFieldConfigColumn, drawerDraft]);
-  const drawerLoadingError = selectedTable?.mapped ? (tableDetailError || mappedModelError) : tableDetailError;
-  const isDrawerBlockingLoading = Boolean(
-    selectedTable
-    && (
-      drawerBootstrapping
-      || !drawerDraft
-      || isTableDetailLoading
-      || isTableDetailFetching
-      || (selectedTable.mapped && (isMappedModelLoading || isMappedModelFetching))
-    ),
-  );
-
-  useEffect(() => {
-    if (!isWorkspaceMode) {
-      setDrawerDraft(null);
-      setFieldConfigColumnName(null);
-      return;
-    }
-
-    if (drawerBootstrapTimerRef.current) {
-      window.clearTimeout(drawerBootstrapTimerRef.current);
-    }
-
-    setDrawerDraft(null);
-    setFieldConfigColumnName(null);
-    setDrawerTab("general-info");
-    setWorkspaceStep("configure");
-    setMappingPreview(null);
-    setPersistedMappingResult(null);
-    setMigrationArtifactsResult(null);
-    setGenerateCodeOutput("");
-    setIsGeneratingCodeWorkflow(false);
-    setGenerateCodeStatusMessage("");
-    setGenerateCodeTimeoutMessage(null);
-    setGenerateCodeReady(false);
-    setHasAttemptedGenerateCode(false);
-    setRunMigrationOutput("");
-    setRunMigrationCompleted(false);
-    setReviewedMetadataJsonValue(null);
-    setMetadataJsonText("");
-    setMetadataJsonValidationError(null);
-    setMetadataJsonResetToken(`table-${workspaceTableKey}-${Date.now()}`);
-    setDrawerBootstrapping(true);
-  }, [isWorkspaceMode, workspaceTableKey]);
-
-  useEffect(() => {
-    if (!isWorkspaceMode || !selectedTable) return;
-    setSelectedRows([selectedTable]);
-  }, [isWorkspaceMode, selectedTable]);
-
-  useEffect(() => {
-    if (!isWorkspaceMode || !selectedTable || !tableDetail) return;
-    if (selectedTable.mapped && (!mappedModelData || mappedModelData.id !== selectedTable.mappedModelId)) return;
-
-    if (drawerBootstrapTimerRef.current) {
-      window.clearTimeout(drawerBootstrapTimerRef.current);
-    }
-
-    setDrawerDraft(buildDrawerDraft(
-      tableDetail,
-      selectedTable,
-      selectedTable.mapped ? mappedModelResponse : undefined,
-    ));
-    drawerBootstrapTimerRef.current = window.setTimeout(() => {
-      setDrawerBootstrapping(false);
-    }, 150);
-  }, [isWorkspaceMode, selectedTable, tableDetail, mappedModelData, mappedModelResponse]);
+  const drawerLoadingError = activeWorkspaceItem?.error ?? null;
+  const isDrawerBlockingLoading = activeWorkspaceItem?.loadStatus.state === "loading" || !drawerDraft;
 
   const filteredRecords = useMemo(() => {
-    const records = [...(tablesResponse?.records ?? [])];
+    const records = [...(tablesResponse?.records ?? [])]
+      .filter((record) => !record.tableName.toLowerCase().startsWith("ss_"));
     const searchNeedle = tableSearch.trim().toLowerCase();
 
     const filtered = searchNeedle
@@ -958,10 +1017,183 @@ export function DatasourceIntrospectionPage() {
     return filtered;
   }, [sessionSettings.prioritizeUnmappedTables, tableSearch, tablesResponse?.records]);
 
+  const workspaceRecords = useMemo(
+    () => workspaceTableKeys
+      .map((key) => workspaceItems[key]?.record)
+      .filter(Boolean) as DatasourceIntrospectionTableRecord[],
+    [workspaceItems, workspaceTableKeys],
+  );
+  const selectedRowCount = selectedRows.length;
+  const visibleRowKeySet = useMemo(
+    () => new Set(filteredRecords.map((row) => makeTableKey(row.schema, row.tableName))),
+    [filteredRecords],
+  );
+  const visibleSelectedRowCount = useMemo(
+    () => selectedRows.filter((row) => row.hasPrimaryKey && visibleRowKeySet.has(makeTableKey(row.schema, row.tableName))).length,
+    [selectedRows, visibleRowKeySet],
+  );
+  const visibleSelectableRowCount = useMemo(
+    () => filteredRecords.filter((row) => row.hasPrimaryKey).length,
+    [filteredRecords],
+  );
+  const hasVisibleRows = filteredRecords.length > 0;
+  const allVisibleRowsSelected = visibleSelectableRowCount > 0 && visibleSelectedRowCount === visibleSelectableRowCount;
+  const totalWorkspaceCount = workspaceTableKeys.length;
+  const activeWorkspacePosition = activeWorkspaceTableKey
+    ? Math.max(0, workspaceTableKeys.indexOf(activeWorkspaceTableKey)) + 1
+    : 0;
+
+  const allWorkspaceItemsReady = useMemo(
+    () => workspaceTableKeys.length > 0 && workspaceTableKeys.every((key) => workspaceItems[key]?.draft),
+    [workspaceItems, workspaceTableKeys],
+  );
+  const allWorkspaceItemsPreviewed = useMemo(
+    () => workspaceTableKeys.length > 0 && workspaceTableKeys.every((key) => workspaceItems[key]?.mappingPreview),
+    [workspaceItems, workspaceTableKeys],
+  );
+  const allWorkspaceItemsPersisted = useMemo(
+    () => workspaceTableKeys.length > 0 && workspaceTableKeys.every((key) => workspaceItems[key]?.persistedMappingResult),
+    [workspaceItems, workspaceTableKeys],
+  );
+  const allWorkspaceItemsMigrated = useMemo(
+    () => workspaceTableKeys.length > 0 && workspaceTableKeys.every((key) => workspaceItems[key]?.migrationArtifactsResult),
+    [workspaceItems, workspaceTableKeys],
+    );
+  const hasMigrationGenerationWork = useMemo(
+    () => workspaceTableKeys.some((key) => Boolean(workspaceItems[key]?.mappingPreview?.migration.willGenerate)),
+    [workspaceItems, workspaceTableKeys],
+  );
+  const reviewedWorkspaceCount = useMemo(
+    () => workspaceTableKeys.filter((key) => workspaceItems[key]?.mappingPreview).length,
+    [workspaceItems, workspaceTableKeys],
+  );
+  const savedWorkspaceCount = useMemo(
+    () => workspaceTableKeys.filter((key) => workspaceItems[key]?.persistedMappingResult).length,
+    [workspaceItems, workspaceTableKeys],
+  );
+  const migrationReadyWorkspaceCount = useMemo(
+    () => workspaceTableKeys.filter((key) => workspaceItems[key]?.migrationArtifactsResult).length,
+    [workspaceItems, workspaceTableKeys],
+  );
+  const reviewErrorWorkspaceCount = useMemo(
+    () => workspaceTableKeys.filter((key) => workspaceItems[key]?.reviewStatus.state === "error").length,
+    [workspaceItems, workspaceTableKeys],
+  );
+  const saveErrorWorkspaceCount = useMemo(
+    () => workspaceTableKeys.filter((key) => workspaceItems[key]?.saveStatus.state === "error").length,
+    [workspaceItems, workspaceTableKeys],
+  );
+  const migrationErrorWorkspaceCount = useMemo(
+    () => workspaceTableKeys.filter((key) => workspaceItems[key]?.migrationStatus.state === "error").length,
+    [workspaceItems, workspaceTableKeys],
+  );
+  const totalIncludedMappedColumns = useMemo(
+    () => workspaceTableKeys.reduce((count, key) => {
+      const preview = workspaceItems[key]?.mappingPreview;
+      return count + (preview?.summary.includedColumnNames.length ?? 0);
+    }, 0),
+    [workspaceItems, workspaceTableKeys],
+  );
+  const totalGeneratedSystemColumns = useMemo(
+    () => workspaceTableKeys.reduce((count, key) => {
+      const preview = workspaceItems[key]?.mappingPreview;
+      return count + (preview?.summary.generatedSystemColumnCount ?? 0);
+    }, 0),
+    [workspaceItems, workspaceTableKeys],
+  );
+  const totalGeneratedMigrations = useMemo(
+    () => workspaceTableKeys.reduce((count, key) => {
+      return count + (workspaceItems[key]?.mappingPreview?.migration.willGenerate ? 1 : 0);
+    }, 0),
+    [workspaceItems, workspaceTableKeys],
+  );
+
+  const updateWorkspaceItem = (key: string, updater: (current: WorkspaceBatchItem) => WorkspaceBatchItem) => {
+    setWorkspaceItems((current) => {
+      const item = current[key];
+      if (!item) {
+        return current;
+      }
+
+      return {
+        ...current,
+        [key]: updater(item),
+      };
+    });
+  };
+
+  const buildWorkspacePlaceholder = (record: DatasourceIntrospectionTableRecord): WorkspaceBatchItem => ({
+    key: makeTableKey(record.schema, record.tableName),
+    record,
+    detail: null,
+    mappedModelData: null,
+    draft: null,
+    loadStatus: { state: "loading", message: "Loading mapping workspace..." },
+    reviewStatus: { state: "idle", message: "Not reviewed yet." },
+    saveStatus: { state: "idle", message: "Not saved yet." },
+    migrationStatus: { state: "idle", message: "Migration artifacts not created yet." },
+    mappingPreview: null,
+    persistedMappingResult: null,
+    migrationArtifactsResult: null,
+    reviewedMetadataJsonValue: null,
+    metadataJsonText: "",
+    metadataJsonValidationError: null,
+    metadataJsonResetToken: `workspace-${record.tableName}-${Date.now()}`,
+    error: null,
+  });
+
+  const loadWorkspaceItem = async (record: DatasourceIntrospectionTableRecord) => {
+    const key = makeTableKey(record.schema, record.tableName);
+
+    try {
+      const tableDetailRequest = dispatch(
+        datasourceIntrospectionApi.endpoints.getDatasourceIntrospectionTableDetail.initiate({
+          moduleId,
+          datasource: selectedDatasource,
+          table: record.tableName,
+          schema: record.schema ?? undefined,
+        }),
+      ) as any;
+      const tableDetailData = await tableDetailRequest.unwrap();
+      tableDetailRequest.unsubscribe?.();
+
+      let mappedModelData: any = null;
+      if (record.mapped && record.mappedModelId) {
+        const modelRequest = dispatch(
+          modelsApi.endpoints.getmodelById.initiate(record.mappedModelId),
+        ) as any;
+        const modelResponse = await modelRequest.unwrap();
+        modelRequest.unsubscribe?.();
+        mappedModelData = modelResponse?.data ?? modelResponse ?? null;
+      }
+
+      const draft = buildDrawerDraft(
+        tableDetailData,
+        record,
+        mappedModelData ? { data: mappedModelData } : undefined,
+      );
+
+      updateWorkspaceItem(key, (current) => ({
+        ...current,
+        detail: tableDetailData,
+        mappedModelData,
+        draft,
+        loadStatus: { state: "ready", message: "Ready to configure." },
+        error: null,
+      }));
+    } catch (error: any) {
+      updateWorkspaceItem(key, (current) => ({
+        ...current,
+        loadStatus: { state: "error", message: readQueryError(error) },
+        error: readQueryError(error),
+      }));
+    }
+  };
+
   const drawerUserKeyOptions = useMemo(() => {
     const options = new Map<string, { label: string; value: string }>();
 
-    tableDetail?.userKeyCandidates?.forEach((candidate) => {
+    activeWorkspaceItem?.detail?.userKeyCandidates?.forEach((candidate) => {
       options.set(candidate.name, {
         label: `${candidate.label} · ${candidate.reason}`,
         value: candidate.name,
@@ -980,7 +1212,7 @@ export function DatasourceIntrospectionPage() {
       });
 
     return Array.from(options.values());
-  }, [drawerDraft?.columns, tableDetail?.userKeyCandidates]);
+  }, [activeWorkspaceItem?.detail?.userKeyCandidates, drawerDraft?.columns]);
 
   const settingsTabs = [
     {
@@ -1063,33 +1295,109 @@ export function DatasourceIntrospectionPage() {
     if (selectedDatasource) {
       await refetchTables();
     }
-    if (isWorkspaceMode && selectedTable) {
-      await refetchTableDetail();
+    if (isWorkspaceMode) {
+      workspaceRecords.forEach((record) => {
+        void loadWorkspaceItem(record);
+      });
     }
   };
 
-  const startMappingForRecord = (record: DatasourceIntrospectionTableRecord) => {
-    if (drawerBootstrapTimerRef.current) {
-      window.clearTimeout(drawerBootstrapTimerRef.current);
+  const toggleSelectedRow = (row: DatasourceIntrospectionTableRecord, checked?: boolean) => {
+    if (!row.hasPrimaryKey) {
+      return;
     }
 
-    setSelectedRows([record]);
-    setWorkspaceTableKey(`${record.schema ?? ""}::${record.tableName}`);
+    const rowKey = makeTableKey(row.schema, row.tableName);
+    setSelectedRows((current) => {
+      const exists = current.some((item) => makeTableKey(item.schema, item.tableName) === rowKey);
+      const shouldInclude = checked ?? !exists;
+
+      if (shouldInclude) {
+        if (exists) return current;
+        return [...current, row];
+      }
+
+      return current.filter((item) => makeTableKey(item.schema, item.tableName) !== rowKey);
+    });
   };
 
-  const leaveWorkspace = () => {
-    if (drawerBootstrapTimerRef.current) {
-      window.clearTimeout(drawerBootstrapTimerRef.current);
+  const toggleAllVisibleRows = (checked: boolean) => {
+    setSelectedRows((current) => {
+      if (checked) {
+        const merged = [...current];
+        const currentKeySet = new Set(current.map((row) => makeTableKey(row.schema, row.tableName)));
+
+        filteredRecords.forEach((row) => {
+          if (!row.hasPrimaryKey) {
+            return;
+          }
+
+          const rowKey = makeTableKey(row.schema, row.tableName);
+          if (!currentKeySet.has(rowKey)) {
+            merged.push(row);
+          }
+        });
+
+        return merged;
+      }
+
+      return current.filter((row) => !visibleRowKeySet.has(makeTableKey(row.schema, row.tableName)));
+    });
+  };
+
+  const startMappingForRows = (records: DatasourceIntrospectionTableRecord[]) => {
+    if (!records.length) return;
+
+    const eligibleRecords = records.filter((record) => record.hasPrimaryKey);
+    const skippedRecords = records.filter((record) => !record.hasPrimaryKey);
+
+    if (skippedRecords.length) {
+      dispatch(showToast({
+        severity: "warn",
+        summary: "Skipped blocked tables",
+        detail: skippedRecords.length === 1
+          ? skippedRecords[0].mappingBlockedReason || `Table "${skippedRecords[0].tableName}" was skipped because it has no primary key.`
+          : `${skippedRecords.length} tables were skipped because they do not define a datasource primary key.`,
+      }));
     }
 
-    setWorkspaceTableKey("");
-    setDrawerDraft(null);
+    if (!eligibleRecords.length) {
+      return;
+    }
+
+    const keys = eligibleRecords.map((record) => makeTableKey(record.schema, record.tableName));
+    const nextWorkspaceItems = Object.fromEntries(
+      eligibleRecords.map((record) => [makeTableKey(record.schema, record.tableName), buildWorkspacePlaceholder(record)]),
+    );
+
+    setSelectedRows(eligibleRecords);
+    setWorkspaceTableKeys(keys);
+    setActiveWorkspaceTableKey(keys[0]);
+    setWorkspaceItems(nextWorkspaceItems);
+    setFieldConfigColumnName(null);
+    setDrawerTab("general-info");
+    setWorkspaceStep("configure");
+    setGenerateCodeOutput("");
+    setIsGeneratingCodeWorkflow(false);
+    setGenerateCodeStatusMessage("");
+    setGenerateCodeTimeoutMessage(null);
+    setGenerateCodeReady(false);
+    setHasAttemptedGenerateCode(false);
+    setRunMigrationOutput("");
+    setRunMigrationCompleted(false);
+
+    eligibleRecords.forEach((record) => {
+      void loadWorkspaceItem(record);
+    });
+  };
+
+  const leaveWorkspace = () => {
+    setWorkspaceTableKeys([]);
+    setActiveWorkspaceTableKey("");
+    setWorkspaceItems({});
     setFieldConfigColumnName(null);
     setWorkspaceStep("configure");
     setDrawerTab("general-info");
-    setMappingPreview(null);
-    setPersistedMappingResult(null);
-    setMigrationArtifactsResult(null);
     setGenerateCodeOutput("");
     setIsGeneratingCodeWorkflow(false);
     setGenerateCodeStatusMessage("");
@@ -1098,11 +1406,6 @@ export function DatasourceIntrospectionPage() {
     setHasAttemptedGenerateCode(false);
     setRunMigrationOutput("");
     setRunMigrationCompleted(false);
-    setReviewedMetadataJsonValue(null);
-    setMetadataJsonText("");
-    setMetadataJsonValidationError(null);
-    setMetadataJsonResetToken(`workspace-closed-${Date.now()}`);
-    setDrawerBootstrapping(false);
   };
 
   const applyDraftSettings = () => {
@@ -1110,18 +1413,54 @@ export function DatasourceIntrospectionPage() {
     setSettingsOpen(false);
   };
 
+  const updateActiveWorkspaceItem = (updater: (current: WorkspaceBatchItem) => WorkspaceBatchItem) => {
+    if (!activeWorkspaceTableKey) return;
+    updateWorkspaceItem(activeWorkspaceTableKey, updater);
+  };
+
   const updateDrawerDraft = (updater: (current: DrawerDraft) => DrawerDraft) => {
-    setMappingPreview(null);
-    setPersistedMappingResult(null);
-    setMigrationArtifactsResult(null);
     setGenerateCodeOutput("");
     setIsGeneratingCodeWorkflow(false);
     setGenerateCodeStatusMessage("");
     setGenerateCodeTimeoutMessage(null);
     setGenerateCodeReady(false);
     setHasAttemptedGenerateCode(false);
+    setMigrationPreviewCopied(false);
     setRunMigrationOutput("");
-    setDrawerDraft((current) => (current ? updater(current) : current));
+    updateActiveWorkspaceItem((current) => ({
+      ...current,
+      mappingPreview: null,
+      persistedMappingResult: null,
+      migrationArtifactsResult: null,
+      reviewStatus: { state: "idle", message: "Not reviewed yet." },
+      saveStatus: { state: "idle", message: "Not saved yet." },
+      migrationStatus: { state: "idle", message: "Migration artifacts not created yet." },
+      draft: current.draft ? updater(current.draft) : current.draft,
+    }));
+  };
+
+  const handleCopyMigrationPreview = async () => {
+    const migrationContent = mappingPreview?.migration.content;
+    if (!migrationContent) {
+      return;
+    }
+
+    try {
+      await navigator.clipboard.writeText(migrationContent);
+      setMigrationPreviewCopied(true);
+      window.setTimeout(() => setMigrationPreviewCopied(false), 2000);
+      dispatch(showToast({
+        severity: "success",
+        summary: "Migration copied",
+        detail: "The migration preview was copied to the clipboard.",
+      }));
+    } catch (error) {
+      dispatch(showToast({
+        severity: "error",
+        summary: "Copy failed",
+        detail: "Unable to copy the migration preview to the clipboard.",
+      }));
+    }
   };
 
   const updateGeneralField = (field: keyof DrawerDraft, value: any) => {
@@ -1182,29 +1521,6 @@ export function DatasourceIntrospectionPage() {
     }));
   };
 
-  const updateColumnSolidFieldType = (columnName: string, nextSolidFieldType: string) => {
-    updateDrawerDraft((current) => ({
-      ...current,
-      columns: current.columns.map((column) => {
-        if (column.columnName !== columnName) return column;
-        if (column.handledBySuperclass) return column;
-
-        return {
-          ...column,
-          solidFieldType: nextSolidFieldType,
-          ormType: getDefaultOrmTypeForSolidFieldType(current.dataSourceType, nextSolidFieldType),
-          fieldConfig: column.fieldConfig
-            ? {
-              ...column.fieldConfig,
-              type: nextSolidFieldType,
-              ormType: getDefaultOrmTypeForSolidFieldType(current.dataSourceType, nextSolidFieldType),
-            }
-            : column.fieldConfig,
-        };
-      }),
-    }));
-  };
-
   const openFieldConfigEditor = (columnName: string) => {
     setFieldConfigColumnName(columnName);
   };
@@ -1379,86 +1695,167 @@ export function DatasourceIntrospectionPage() {
   };
 
   const reviewMappingJson = async () => {
-    if (!drawerDraft || !bootstrap?.module?.id) return;
-
-    const validationErrors = getDrawerValidationErrors(drawerDraft);
-    if (validationErrors.length) {
-      validationErrors.forEach((detail) => {
-        dispatch(showToast({ severity: "error", summary: "Validation", detail }));
+    if (!bootstrap?.module?.id || !workspaceTableKeys.length) return;
+
+    const tablesWithErrors = workspaceTableKeys
+      .map((key) => ({ key, item: workspaceItems[key] }))
+      .filter((entry) => entry.item?.draft)
+      .flatMap(({ item }) => getDrawerValidationErrors(item.draft as DrawerDraft).map((detail) => ({
+        tableName: item?.record.tableName,
+        detail,
+      })));
+
+    if (tablesWithErrors.length) {
+      tablesWithErrors.forEach(({ tableName, detail }) => {
+        dispatch(showToast({ severity: "error", summary: tableName || "Validation", detail }));
       });
       return;
     }
 
-    try {
-      const preview = await previewMapping({
-        moduleId: bootstrap.module.id,
-        payload: buildMappingRequest(drawerDraft),
-      }).unwrap();
+    let firstSuccessKey = "";
+
+    for (const key of workspaceTableKeys) {
+      const item = workspaceItems[key];
+      if (!item?.draft) continue;
+
+      updateWorkspaceItem(key, (current) => ({
+        ...current,
+        reviewStatus: { state: "loading", message: "Generating mapping preview..." },
+      }));
+
+      try {
+        const preview = await previewMapping({
+          moduleId: bootstrap.module.id,
+          payload: buildMappingRequest(item.draft),
+        }).unwrap();
+
+        if (!firstSuccessKey) {
+          firstSuccessKey = key;
+        }
+
+        updateWorkspaceItem(key, (current) => ({
+          ...current,
+          mappingPreview: preview,
+          reviewedMetadataJsonValue: preview.metadataJson.model,
+          metadataJsonText: JSON.stringify(preview.metadataJson.model, null, 2),
+          metadataJsonValidationError: null,
+          metadataJsonResetToken: `preview-${preview.metadataJson.filePath}-${Date.now()}`,
+          persistedMappingResult: null,
+          migrationArtifactsResult: null,
+          reviewStatus: { state: "success", message: "Preview ready." },
+          saveStatus: { state: "idle", message: "Not saved yet." },
+          migrationStatus: { state: "idle", message: "Migration artifacts not created yet." },
+        }));
+      } catch (error: any) {
+        updateWorkspaceItem(key, (current) => ({
+          ...current,
+          reviewStatus: { state: "error", message: readQueryError(error) },
+        }));
+        dispatch(showToast({
+          severity: "error",
+          summary: `Preview failed for ${item.record.tableName}`,
+          detail: readQueryError(error),
+        }));
+      }
+    }
 
-      setMappingPreview(preview);
-      setReviewedMetadataJsonValue(preview.metadataJson.model);
-      setMetadataJsonText(JSON.stringify(preview.metadataJson.model, null, 2));
-      setMetadataJsonValidationError(null);
-      setMetadataJsonResetToken(`preview-${preview.metadataJson.filePath}-${Date.now()}`);
-      setPersistedMappingResult(null);
-      setMigrationArtifactsResult(null);
+    if (firstSuccessKey) {
+      setActiveWorkspaceTableKey(firstSuccessKey);
+      setWorkspaceStep("review-json");
       setGenerateCodeOutput("");
       setRunMigrationOutput("");
-      setWorkspaceStep("review-json");
-    } catch (error: any) {
-      dispatch(showToast({
-        severity: "error",
-        summary: "Preview failed",
-        detail: readQueryError(error),
-      }));
     }
   };
 
   const persistMappingArtifacts = async () => {
-    if (!drawerDraft || !bootstrap?.module?.id) return;
+    if (!bootstrap?.module?.id || !workspaceTableKeys.length) return;
 
-    const validationErrors = getDrawerValidationErrors(drawerDraft);
-    if (validationErrors.length) {
-      validationErrors.forEach((detail) => {
-        dispatch(showToast({ severity: "error", summary: "Validation", detail }));
-      });
-      setWorkspaceStep("configure");
-      return;
-    }
+    let firstSavedKey = "";
 
-    const reviewedModelValidation = parseAndValidateReviewedModelJson(metadataJsonText, drawerDraft);
-    if (reviewedModelValidation.error || !reviewedModelValidation.parsed) {
-      setMetadataJsonValidationError(reviewedModelValidation.error ?? "Metadata JSON is invalid.");
-      setWorkspaceStep("review-json");
-      dispatch(showToast({
-        severity: "error",
-        summary: "Validation",
-        detail: reviewedModelValidation.error ?? "Metadata JSON is invalid.",
-      }));
-      return;
-    }
+    for (const key of workspaceTableKeys) {
+      const item = workspaceItems[key];
+      if (!item?.draft || !item.mappingPreview) continue;
 
-    setMetadataJsonValidationError(null);
+      const validationErrors = getDrawerValidationErrors(item.draft);
+      if (validationErrors.length) {
+        updateWorkspaceItem(key, (current) => ({
+          ...current,
+          saveStatus: { state: "error", message: validationErrors[0] },
+        }));
+        validationErrors.forEach((detail) => {
+          dispatch(showToast({ severity: "error", summary: item.record.tableName, detail }));
+        });
+        continue;
+      }
 
-    try {
-      const response = await applyMapping({
-        moduleId: bootstrap.module.id,
-        payload: {
-          ...buildMappingRequest(drawerDraft, mappingPreview?.migration.timestamp ?? null),
-          reviewedModel: reviewedModelValidation.parsed,
-        },
-      }).unwrap();
+      const reviewedModelValidation = parseAndValidateReviewedModelJson(item.metadataJsonText, item.draft);
+      if (reviewedModelValidation.error || !reviewedModelValidation.parsed) {
+        updateWorkspaceItem(key, (current) => ({
+          ...current,
+          metadataJsonValidationError: reviewedModelValidation.error ?? "Metadata JSON is invalid.",
+          saveStatus: { state: "error", message: reviewedModelValidation.error ?? "Metadata JSON is invalid." },
+        }));
+        dispatch(showToast({
+          severity: "error",
+          summary: item.record.tableName,
+          detail: reviewedModelValidation.error ?? "Metadata JSON is invalid.",
+        }));
+        continue;
+      }
 
-      dispatch(showToast({
-        severity: "success",
-        summary: "Mapping saved",
-        detail: drawerDraft.mapped
-          ? "The model mapping metadata was updated successfully."
-          : "The model mapping metadata was created successfully.",
+      updateWorkspaceItem(key, (current) => ({
+        ...current,
+        metadataJsonValidationError: null,
+        saveStatus: { state: "loading", message: "Saving mapping..." },
       }));
 
-      setPersistedMappingResult(response);
-      setMigrationArtifactsResult(null);
+      try {
+        const response = await applyMapping({
+          moduleId: bootstrap.module.id,
+          payload: {
+            ...buildMappingRequest(item.draft, item.mappingPreview.migration.timestamp ?? null),
+            reviewedModel: reviewedModelValidation.parsed,
+          },
+        }).unwrap();
+
+        if (!firstSavedKey) {
+          firstSavedKey = key;
+        }
+
+        updateWorkspaceItem(key, (current) => ({
+          ...current,
+          persistedMappingResult: response,
+          migrationArtifactsResult: null,
+          saveStatus: { state: "success", message: "Mapping saved." },
+          migrationStatus: { state: "idle", message: "Migration artifacts not created yet." },
+          draft: current.draft
+            ? {
+              ...current.draft,
+              mapped: true,
+              modelId: response.modelId,
+            }
+            : current.draft,
+          record: {
+            ...current.record,
+            mapped: true,
+            mappedModelId: response.modelId,
+          },
+        }));
+      } catch (error: any) {
+        updateWorkspaceItem(key, (current) => ({
+          ...current,
+          saveStatus: { state: "error", message: readQueryError(error) },
+        }));
+        dispatch(showToast({
+          severity: "error",
+          summary: `Save failed for ${item.record.tableName}`,
+          detail: readQueryError(error),
+        }));
+      }
+    }
+
+    if (firstSavedKey) {
+      setActiveWorkspaceTableKey(firstSavedKey);
       setGenerateCodeOutput("");
       setIsGeneratingCodeWorkflow(false);
       setGenerateCodeStatusMessage("");
@@ -1467,21 +1864,11 @@ export function DatasourceIntrospectionPage() {
       setHasAttemptedGenerateCode(false);
       setRunMigrationOutput("");
       setRunMigrationCompleted(false);
-      setDrawerDraft((current) => (
-        current
-          ? {
-            ...current,
-            mapped: true,
-            modelId: response.modelId,
-          }
-          : current
-      ));
       setWorkspaceStep("generate-code");
-    } catch (error: any) {
       dispatch(showToast({
-        severity: "error",
-        summary: "Save failed",
-        detail: readQueryError(error),
+        severity: "success",
+        summary: "Mappings saved",
+        detail: "The selected table mappings were saved successfully.",
       }));
     }
   };
@@ -1543,7 +1930,6 @@ export function DatasourceIntrospectionPage() {
 
     setGenerateCodeStatusMessage("Backend is back online. You can continue.");
     setGenerateCodeReady(true);
-    setMigrationArtifactsResult(null);
     setRunMigrationOutput("");
     dispatch(showToast({
       severity: "success",
@@ -1553,50 +1939,83 @@ export function DatasourceIntrospectionPage() {
   };
 
   const handleCreateMigrationArtifacts = async () => {
-    if (!drawerDraft || !bootstrap?.module?.id || !persistedMappingResult?.modelId) return;
+    if (!bootstrap?.module?.id || !workspaceTableKeys.length) return;
 
-    const reviewedModelValidation = parseAndValidateReviewedModelJson(metadataJsonText, drawerDraft);
-    if (reviewedModelValidation.error || !reviewedModelValidation.parsed) {
-      setMetadataJsonValidationError(reviewedModelValidation.error ?? "Metadata JSON is invalid.");
-      setWorkspaceStep("review-json");
-      dispatch(showToast({
-        severity: "error",
-        summary: "Validation",
-        detail: reviewedModelValidation.error ?? "Metadata JSON is invalid.",
+    let firstMigrationKey = "";
+
+    for (const key of workspaceTableKeys) {
+      const item = workspaceItems[key];
+      if (!item?.draft || !item.persistedMappingResult?.modelId || !item.mappingPreview) continue;
+
+      const reviewedModelValidation = parseAndValidateReviewedModelJson(item.metadataJsonText, item.draft);
+      if (reviewedModelValidation.error || !reviewedModelValidation.parsed) {
+        updateWorkspaceItem(key, (current) => ({
+          ...current,
+          metadataJsonValidationError: reviewedModelValidation.error ?? "Metadata JSON is invalid.",
+          migrationStatus: { state: "error", message: reviewedModelValidation.error ?? "Metadata JSON is invalid." },
+        }));
+        dispatch(showToast({
+          severity: "error",
+          summary: item.record.tableName,
+          detail: reviewedModelValidation.error ?? "Metadata JSON is invalid.",
+        }));
+        continue;
+      }
+
+      updateWorkspaceItem(key, (current) => ({
+        ...current,
+        metadataJsonValidationError: null,
+        migrationStatus: { state: "loading", message: "Creating migration artifacts..." },
       }));
-      return;
-    }
 
-    try {
-      const response = await createMigrationArtifacts({
-        moduleId: bootstrap.module.id,
-        payload: {
-          ...buildMappingRequest(
-            {
-              ...drawerDraft,
-              mapped: true,
-              modelId: persistedMappingResult.modelId,
-            },
-            mappingPreview?.migration.timestamp ?? null,
-          ),
-          reviewedModel: reviewedModelValidation.parsed,
-        },
-      }).unwrap();
+      try {
+        const response = await createMigrationArtifacts({
+          moduleId: bootstrap.module.id,
+          payload: {
+            ...buildMappingRequest(
+              {
+                ...item.draft,
+                mapped: true,
+                modelId: item.persistedMappingResult.modelId,
+              },
+              item.mappingPreview.migration.timestamp ?? null,
+            ),
+            reviewedModel: reviewedModelValidation.parsed,
+          },
+        }).unwrap();
+
+        if (!firstMigrationKey) {
+          firstMigrationKey = key;
+        }
+
+        updateWorkspaceItem(key, (current) => ({
+          ...current,
+          migrationArtifactsResult: response,
+          migrationStatus: {
+            state: "success",
+            message: response.migration.written ? "Migration artifacts created." : "No migration file required.",
+          },
+        }));
+      } catch (error: any) {
+        updateWorkspaceItem(key, (current) => ({
+          ...current,
+          migrationStatus: { state: "error", message: readQueryError(error) },
+        }));
+        dispatch(showToast({
+          severity: "error",
+          summary: `Create migration artifacts failed for ${item.record.tableName}`,
+          detail: readQueryError(error),
+        }));
+      }
+    }
 
-      setMigrationArtifactsResult(response);
+    if (firstMigrationKey) {
+      setActiveWorkspaceTableKey(firstMigrationKey);
       setWorkspaceStep("run-migration");
       dispatch(showToast({
         severity: "success",
-        summary: "Migration artifacts created",
-        detail: response.migration.written
-          ? "The migration file and datasource registration were written successfully."
-          : "No migration file was required, but the datasource registration was updated successfully.",
-      }));
-    } catch (error: any) {
-      dispatch(showToast({
-        severity: "error",
-        summary: "Create migration artifacts failed",
-        detail: readQueryError(error),
+        summary: "Migration artifacts ready",
+        detail: "Datasource registration and migration artifacts were prepared for the selected tables.",
       }));
     }
   };
@@ -1664,19 +2083,19 @@ export function DatasourceIntrospectionPage() {
       label: "Review Mapping JSON",
       complete: currentStepIndex > 1,
       active: workspaceStep === "review-json",
-      disabled: !mappingPreview,
+      disabled: !allWorkspaceItemsPreviewed,
       onClick: () => {
-        if (mappingPreview) setWorkspaceStep("review-json");
+        if (allWorkspaceItemsPreviewed) setWorkspaceStep("review-json");
       },
     },
     {
       key: "generate-code" as const,
       label: "Generate Code",
-      complete: currentStepIndex > 2,
+      complete: currentStepIndex > 2 || generateCodeReady,
       active: workspaceStep === "generate-code",
-      disabled: !persistedMappingResult,
+      disabled: !allWorkspaceItemsPersisted,
       onClick: () => {
-        if (persistedMappingResult) setWorkspaceStep("generate-code");
+        if (allWorkspaceItemsPersisted) setWorkspaceStep("generate-code");
       },
     },
     {
@@ -1691,12 +2110,12 @@ export function DatasourceIntrospectionPage() {
     },
     {
       key: "run-migration" as const,
-      label: "Run Migration",
+      label: hasMigrationGenerationWork ? "Run Migration" : "Finish",
       complete: false,
       active: workspaceStep === "run-migration",
-      disabled: !migrationArtifactsResult,
+      disabled: !allWorkspaceItemsMigrated,
       onClick: () => {
-        if (migrationArtifactsResult) setWorkspaceStep("run-migration");
+        if (allWorkspaceItemsMigrated) setWorkspaceStep("run-migration");
       },
     },
   ];
@@ -1706,7 +2125,7 @@ export function DatasourceIntrospectionPage() {
   ) ?? [];
   const allSelectableUnmappedIncluded = selectableUnmappedColumns.length > 0
     && selectableUnmappedColumns.every((column) => column.include);
-  const drawerRawDdl = tableDetail?.rawDdl ?? null;
+  const drawerRawDdl = activeWorkspaceItem?.detail?.rawDdl ?? null;
   const drawerTabs = drawerDraft ? [
     {
       value: "general-info",
@@ -1845,7 +2264,7 @@ export function DatasourceIntrospectionPage() {
               <span>Database</span>
               <span>SolidX</span>
               <span>Status</span>
-              <span>Action</span>
+              <span>Mapping</span>
             </div>
             {drawerDraft.columns.map((column) => {
               const isUserKey = drawerDraft.userKeyField === column.fieldName;
@@ -1911,33 +2330,27 @@ export function DatasourceIntrospectionPage() {
                   <span className="sdix-column-meta">
                     <strong>{column.dataType}</strong>
                   </span>
-                  <span>
-                    {column.handledBySuperclass ? (
-                      <span>{column.solidFieldType}</span>
-                    ) : (
-                      <SolidSelect
-                        value={column.solidFieldType}
-                        options={scalarFieldTypeOptions}
-                        onChange={(event) => updateColumnSolidFieldType(column.columnName, event.value)}
-                      />
-                    )}
+                  <span className="sdix-column-type-cell">
+                    {!column.handledBySuperclass && (column.include || column.matched) ? (
+                      <SolidButton
+                        size="small"
+                        variant="outline"
+                        className="sdix-column-action-icon"
+                        onClick={() => openFieldConfigEditor(column.columnName)}
+                        aria-label={`Configure ${column.fieldName || column.columnName} field`}
+                      >
+                        <Cog size={14} />
+                      </SolidButton>
+                    ) : null}
+                    <span className={`sdix-status-badge ${column.handledBySuperclass ? "is-superclass" : "is-muted"}`}>
+                      {getFieldTypeLabel(column.solidFieldType)}
+                    </span>
                   </span>
                   <span>
                     <span className={`sdix-status-badge ${statusClassName}`}>{statusText}</span>
                   </span>
                   <span className="sdix-column-action">
                     <div className="sdix-column-action-stack">
-                      {!column.handledBySuperclass && (column.include || column.matched) ? (
-                        <SolidButton
-                          size="small"
-                          variant="outline"
-                          className="sdix-column-action-icon"
-                          onClick={() => openFieldConfigEditor(column.columnName)}
-                          aria-label={`Configure ${column.fieldName || column.columnName} field`}
-                        >
-                          <Cog size={14} />
-                        </SolidButton>
-                      ) : null}
                       {column.handledBySuperclass ? (
                         <SolidButton size="small" variant="outline" disabled className="sdix-column-action-chip sdix-column-action-chip--managed">
                           Managed
@@ -1982,6 +2395,24 @@ export function DatasourceIntrospectionPage() {
 
   const reviewJsonPanel = mappingPreview ? (
     <div className="sdix-review-panel sdix-review-panel--metadata">
+      <div className="sdix-workspace-summary">
+        <div className="sdix-workspace-summary__item">
+          <span>Selected tables</span>
+          <strong>{totalWorkspaceCount}</strong>
+        </div>
+        <div className="sdix-workspace-summary__item">
+          <span>Previews ready</span>
+          <strong>{reviewedWorkspaceCount}/{totalWorkspaceCount}</strong>
+        </div>
+        <div className="sdix-workspace-summary__item">
+          <span>Current table</span>
+          <strong>{activeWorkspacePosition}/{totalWorkspaceCount}</strong>
+        </div>
+        <div className="sdix-workspace-summary__item">
+          <span>Review errors</span>
+          <strong>{reviewErrorWorkspaceCount}</strong>
+        </div>
+      </div>
       <div className="sdix-review-meta sdix-review-meta--compact">
         <span>Target file</span>
         <strong>{mappingPreview.metadataJson.filePath}</strong>
@@ -1991,15 +2422,24 @@ export function DatasourceIntrospectionPage() {
         value={reviewedMetadataJsonValue ?? mappingPreview.metadataJson.model}
         resetToken={metadataJsonResetToken}
         onValueChange={(nextValue) => {
-          setReviewedMetadataJsonValue(nextValue);
-          if (metadataJsonValidationError) {
-            setMetadataJsonValidationError(null);
-          }
+          updateActiveWorkspaceItem((current) => ({
+            ...current,
+            reviewedMetadataJsonValue: nextValue,
+            metadataJsonValidationError: null,
+          }));
         }}
         onTextChange={(nextText) => {
-          setMetadataJsonText(nextText);
+          updateActiveWorkspaceItem((current) => ({
+            ...current,
+            metadataJsonText: nextText,
+          }));
+        }}
+        onErrorChange={(nextError) => {
+          updateActiveWorkspaceItem((current) => ({
+            ...current,
+            metadataJsonValidationError: nextError,
+          }));
         }}
-        onErrorChange={setMetadataJsonValidationError}
       />
       {metadataJsonValidationError ? (
         <div className="sdix-json-validation-error">
@@ -2011,11 +2451,42 @@ export function DatasourceIntrospectionPage() {
 
   const createMigrationsPanel = mappingPreview ? (
     <div className="sdix-review-panel sdix-review-panel--migration">
+      <div className="sdix-workspace-summary">
+        <div className="sdix-workspace-summary__item">
+          <span>Selected tables</span>
+          <strong>{totalWorkspaceCount}</strong>
+        </div>
+        <div className="sdix-workspace-summary__item">
+          <span>Migration previews ready</span>
+          <strong>{migrationReadyWorkspaceCount}/{totalWorkspaceCount}</strong>
+        </div>
+        <div className="sdix-workspace-summary__item">
+          <span>Migration files to write</span>
+          <strong>{totalGeneratedMigrations}</strong>
+        </div>
+        <div className="sdix-workspace-summary__item">
+          <span>System columns to add</span>
+          <strong>{totalGeneratedSystemColumns}</strong>
+        </div>
+      </div>
       {mappingPreview.migration.willGenerate && mappingPreview.migration.filePath ? (
         <>
-          <div className="sdix-review-meta sdix-review-meta--compact">
-            <span>Target file</span>
-            <strong>{mappingPreview.migration.filePath}</strong>
+          <div className="sdix-review-code-header">
+            <div className="sdix-review-meta sdix-review-meta--compact">
+              <span>Target file</span>
+              <strong>{mappingPreview.migration.filePath}</strong>
+            </div>
+            {mappingPreview.migration.content ? (
+              <SolidButton
+                size="small"
+                variant="outline"
+                className="sdix-review-copy-button"
+                leftIcon={migrationPreviewCopied ? <Check size={14} /> : <Copy size={14} />}
+                onClick={() => void handleCopyMigrationPreview()}
+              >
+                {migrationPreviewCopied ? "Copied" : "Copy"}
+              </SolidButton>
+            ) : null}
           </div>
           <p className="sdix-review-note">
             This migration preview is generated from the current mapping and stays read-only here. Moving ahead writes the migration file to disk and updates the datasource registration now that the entity code already exists.
@@ -2038,15 +2509,33 @@ export function DatasourceIntrospectionPage() {
       <div className="sdix-stage-panel__header">
         <span className="sdix-stage-panel__eyebrow">Step 3</span>
         <h3>Generate module code</h3>
-        <p>The reviewed metadata JSON is now persisted. Run the normal SolidX module generation flow next so the entity, DTOs, repository, service, controller, and UI code are refreshed before we register the entity on the datasource and write the migration.</p>
+        <p>The reviewed metadata JSON is now persisted for the selected batch. Run the normal SolidX module generation flow next so every mapped entity, DTO, repository, service, controller, and UI asset is refreshed before datasource registration and migration files are written.</p>
       </div>
       <div className="sdix-stage-panel__body">
+        <div className="sdix-workspace-summary">
+          <div className="sdix-workspace-summary__item">
+            <span>Selected tables</span>
+            <strong>{totalWorkspaceCount}</strong>
+          </div>
+          <div className="sdix-workspace-summary__item">
+            <span>Saved mappings</span>
+            <strong>{savedWorkspaceCount}/{totalWorkspaceCount}</strong>
+          </div>
+          <div className="sdix-workspace-summary__item">
+            <span>Columns queued</span>
+            <strong>{totalIncludedMappedColumns}</strong>
+          </div>
+          <div className="sdix-workspace-summary__item">
+            <span>System columns pending</span>
+            <strong>{totalGeneratedSystemColumns}</strong>
+          </div>
+        </div>
         <div className="sdix-stage-panel__card">
           <div className="sdix-stage-panel__card-title">What happens here</div>
           <ul className="sdix-stage-panel__list">
-            <li>The module generate-code pipeline runs for <strong>{bootstrap?.module?.displayName}</strong>.</li>
-            <li>The newly mapped model entity is generated inside the module source folder.</li>
-            <li>Any existing generated assets for this module may be refreshed.</li>
+            <li>The module generate-code pipeline runs once for <strong>{bootstrap?.module?.displayName}</strong>.</li>
+            <li>All saved mappings in this batch contribute to the generated entities inside the module source folder.</li>
+            <li>Any existing generated assets for this module may be refreshed in the same pass.</li>
           </ul>
         </div>
         <div className="sdix-stage-panel__actions">
@@ -2059,6 +2548,13 @@ export function DatasourceIntrospectionPage() {
             Generate Code
           </SolidButton>
         </div>
+        {generateCodeReady && !isGeneratingCodeWorkflow ? (
+          <div className="sdix-empty-state is-inline sdix-stage-progress sdix-stage-progress--success">
+            <Check size={24} />
+            <h3>Code generation finished</h3>
+            <p>The module generation workflow completed and the backend is back online. You can continue to migrations, or run generate code again if you want to retry.</p>
+          </div>
+        ) : null}
         {isGeneratingCodeWorkflow ? (
           <div className="sdix-empty-state is-inline sdix-stage-progress">
             <SolidSpinner size={30} />
@@ -2085,11 +2581,33 @@ export function DatasourceIntrospectionPage() {
       {!runMigrationCompleted ? (
         <div className="sdix-stage-panel__header">
           <span className="sdix-stage-panel__eyebrow">Step 5</span>
-          <h3>Run migration, build, and seed</h3>
-          <p>With the datasource file updated and module code generated, SolidX can now run the TypeORM migration for the selected datasource, rebuild the project, and reseed the mapped module metadata.</p>
+          <h3>{hasMigrationGenerationWork ? "Run migration, build, and seed" : "Finish mapping workflow"}</h3>
+          <p>
+            {hasMigrationGenerationWork
+              ? "With datasource registration updated and module code generated, SolidX can now run the TypeORM migration, rebuild the project, and reseed metadata for the full selected batch."
+              : "SolidX will now run the final wrap-up workflow for the full selected batch: execute the datasource migration command, rebuild the project, and reseed the mapped module metadata."}
+          </p>
         </div>
       ) : null}
       <div className="sdix-stage-panel__body">
+        <div className="sdix-workspace-summary">
+          <div className="sdix-workspace-summary__item">
+            <span>Selected tables</span>
+            <strong>{totalWorkspaceCount}</strong>
+          </div>
+          <div className="sdix-workspace-summary__item">
+            <span>Generated code ready</span>
+            <strong>{hasAttemptedGenerateCode ? "Yes" : "No"}</strong>
+          </div>
+          <div className="sdix-workspace-summary__item">
+            <span>Migration artifacts ready</span>
+            <strong>{migrationReadyWorkspaceCount}/{totalWorkspaceCount}</strong>
+          </div>
+          <div className="sdix-workspace-summary__item">
+            <span>Datasource</span>
+            <strong>{selectedDatasource}</strong>
+          </div>
+        </div>
         {!runMigrationCompleted ? (
           <div className="sdix-stage-panel__card">
             <div className="sdix-stage-panel__card-title">Commands</div>
@@ -2141,7 +2659,16 @@ npx @solidxai/solidctl@latest seed --modules-to-seed ${bootstrap?.module?.name |
       case "review-json":
         return (
           <span>
-            Review the generated metadata JSON before it is written to the module metadata file.
+            Reviewing
+            {" "}
+            <strong>{activeWorkspacePosition} of {totalWorkspaceCount}</strong>
+            {" "}
+            selected tables. Preview generation is ready for
+            {" "}
+            <strong>{reviewedWorkspaceCount}</strong>
+            {" "}
+            table(s)
+            {reviewErrorWorkspaceCount ? `, with ${reviewErrorWorkspaceCount} table(s) still needing review fixes.` : "."}
           </span>
         );
       case "generate-code":
@@ -2149,24 +2676,37 @@ npx @solidxai/solidctl@latest seed --modules-to-seed ${bootstrap?.module?.name |
           <span>
             Metadata JSON has been saved for
             {" "}
-            <strong>{drawerDraft.displayName || drawerDraft.singularName}</strong>
-            . Generate the module code next so the entity file exists before datasource registration is updated. Continue stays disabled until you attempt code generation at least once.
+            <strong>{savedWorkspaceCount}</strong>
+            {" "}
+            of
+            {" "}
+            <strong>{totalWorkspaceCount}</strong>
+            {" "}
+            selected tables. Generate the module code next so every entity file exists before datasource registration is updated. Continue stays disabled until you attempt code generation at least once.
           </span>
         ) : (
-          <span>Save the metadata JSON before generating code.</span>
+          <span>Save the reviewed metadata JSON for the selected tables before generating code.</span>
         );
       case "create-migrations":
         return mappingPreview ? (
           <span>
-            Create the migration artifacts for
+            Create migration artifacts for
+            {" "}
+            <strong>{migrationReadyWorkspaceCount}</strong>
+            {" "}
+            of
             {" "}
-            <strong>{mappingPreview.summary.includedColumnNames.length}</strong>
+            <strong>{totalWorkspaceCount}</strong>
             {" "}
-            mapped columns
-            {mappingPreview.summary.generatedSystemColumnCount
-              ? ` and ${mappingPreview.summary.generatedSystemColumnCount} SolidX system column migration changes`
-              : ""}
-            .
+            selected tables. This batch currently includes
+            {" "}
+            <strong>{totalIncludedMappedColumns}</strong>
+            {" "}
+            mapped columns and
+            {" "}
+            <strong>{totalGeneratedSystemColumns}</strong>
+            {" "}
+            SolidX system column changes.
           </span>
         ) : null;
       case "run-migration":
@@ -2175,28 +2715,54 @@ npx @solidxai/solidctl@latest seed --modules-to-seed ${bootstrap?.module?.name |
             The migration, build, and seed workflow has completed for
             {" "}
             <strong>{selectedDatasource}</strong>
-            . Review the output below and click Finish when you are ready to return to the model list.
+            {" "}
+            across
+            {" "}
+            <strong>{totalWorkspaceCount}</strong>
+            {" "}
+            selected table mappings. Review the output below and click Finish when you are ready to return to the model list.
           </span>
         ) : (
           <span>
-            Run the migration, build, and seed workflow for
+            {hasMigrationGenerationWork ? "Run the migration, build, and seed workflow for" : "Finish the mapping workflow for"}
             {" "}
             <strong>{selectedDatasource}</strong>
             {" "}
-            to apply the SolidX system columns on the legacy table and refresh the module metadata state.
+            across
+            {" "}
+            <strong>{totalWorkspaceCount}</strong>
+            {" "}
+            selected table mappings.
+            {" "}
+            {hasMigrationGenerationWork
+              ? "to apply the SolidX system columns on the legacy table and refresh the module metadata state."
+              : "to execute the final rebuild and reseed flow after the mapping changes are already in place."}
           </span>
         );
       case "configure":
       default:
         return drawerDraft.mapped ? (
           <span>
-            Editing mapped model
+            Editing
+            {" "}
+            <strong>{activeWorkspacePosition} of {totalWorkspaceCount}</strong>
+            {" "}
+            selected tables.
+            {" "}
+            Current mapped model:
             {" "}
             <strong>{selectedTable?.mappedModelDisplayName || selectedTable?.mappedModelSingularName}</strong>
             {drawerDraft.mappedModuleLabel ? ` in ${drawerDraft.mappedModuleLabel}` : ""}
           </span>
         ) : (
-          <span>Configure the field mapping draft before generating the metadata JSON preview.</span>
+          <span>
+            Configure
+            {" "}
+            <strong>{activeWorkspacePosition} of {totalWorkspaceCount}</strong>
+            {" "}
+            selected tables before generating the batch metadata JSON previews.
+            {allWorkspaceItemsReady ? " All selected mapping drafts are loaded." : ""}
+          </span>
         );
     }
   })() : null;
@@ -2241,12 +2807,8 @@ npx @solidxai/solidctl@latest seed --modules-to-seed ${bootstrap?.module?.name |
                 <SolidButton
                   size="small"
                   leftIcon={<Sparkles size={14} />}
-                  onClick={() => {
-                    if (selectedListRow) {
-                      startMappingForRecord(selectedListRow);
-                    }
-                  }}
-                  disabled={!selectedListRow}
+                  onClick={() => startMappingForRows(selectedRows)}
+                  disabled={!selectedRowCount}
                 >
                   Start Mapping
                 </SolidButton>
@@ -2281,12 +2843,18 @@ npx @solidxai/solidctl@latest seed --modules-to-seed ${bootstrap?.module?.name |
             </div>
           ) : null}
 
-          {selectedDatasource && tablesResponse?.synchronizeBlocked ? (
+          {isSynchronizeBlocked ? (
             <div className="sdix-blocker">
-              <ShieldAlert size={20} />
-              <div>
-                <h3>Synchronize must be disabled before introspection</h3>
-                <p>{tablesResponse.synchronizeMessage}</p>
+              <div className="sdix-blocker__icon">
+                <ShieldAlert size={22} />
+              </div>
+              <div className="sdix-blocker__content">
+                <span className="sdix-blocker__eyebrow">Configuration blocker</span>
+                <h3>Disable TypeORM synchronize before running datasource introspection</h3>
+                <p>{tablesResponse?.synchronizeMessage}</p>
+                <div className="sdix-blocker__note">
+                  Introspection is paused here to avoid schema-sync side effects while reviewing legacy datasource tables.
+                </div>
               </div>
             </div>
           ) : null}
@@ -2311,7 +2879,7 @@ npx @solidxai/solidctl@latest seed --modules-to-seed ${bootstrap?.module?.name |
                       Retry
                     </SolidButton>
                   </div>
-                ) : !filteredRecords.length ? (
+                ) : isSynchronizeBlocked ? null : !filteredRecords.length ? (
                   <div className="sdix-empty-state is-inline">
                     <Database size={22} />
                     <p>{tableSearch ? "No tables match the current quick filter." : "No database tables were discovered for this datasource."}</p>
@@ -2323,19 +2891,33 @@ npx @solidxai/solidctl@latest seed --modules-to-seed ${bootstrap?.module?.name |
                       dataKey="tableName"
                       viewportHeight="calc(100vh - 162px)"
                       size="small"
-                      onRowClick={({ data }) => setSelectedRows([data])}
-                      rowClassName={(rowData) => `${rowData.schema ?? ""}::${rowData.tableName}` === selectedListRowKey ? "sdix-table-row-selected" : ""}
+                      onRowClick={({ data }) => toggleSelectedRow(data)}
+                      rowClassName={(rowData) => selectedListRowKeySet.has(makeTableKey(rowData.schema, rowData.tableName)) ? "sdix-table-row-selected" : ""}
                       emptyMessage="No datasource tables found"
                     >
-                      <Column
-                        header=""
-                        body={(rowData: DatasourceIntrospectionTableRecord) => {
-                          const rowKey = `${rowData.schema ?? ""}::${rowData.tableName}`;
-                          return (
+                    <Column
+                      header={
+                        <div className="sdix-selection-cell" data-no-row-click="true">
+                          <SolidCheckbox
+                            checked={allVisibleRowsSelected}
+                            disabled={!hasVisibleRows || !filteredRecords.some((row) => row.hasPrimaryKey)}
+                            onChange={(event) => toggleAllVisibleRows(event.target.checked)}
+                            aria-label={
+                              allVisibleRowsSelected
+                                ? "Deselect all visible tables"
+                                : "Select all visible tables"
+                            }
+                          />
+                        </div>
+                      }
+                      body={(rowData: DatasourceIntrospectionTableRecord) => {
+                        const rowKey = `${rowData.schema ?? ""}::${rowData.tableName}`;
+                        return (
                             <div className="sdix-selection-cell" data-no-row-click="true">
                               <SolidCheckbox
-                                checked={rowKey === selectedListRowKey}
-                                onChange={(event) => setSelectedRows(event.target.checked ? [rowData] : [])}
+                                checked={selectedListRowKeySet.has(rowKey)}
+                                disabled={!rowData.hasPrimaryKey}
+                                onChange={(event) => toggleSelectedRow(rowData, event.target.checked)}
                               />
                             </div>
                           );
@@ -2357,13 +2939,24 @@ npx @solidxai/solidctl@latest seed --modules-to-seed ${bootstrap?.module?.name |
                         header="Status"
                         body={(rowData: DatasourceIntrospectionTableRecord) => (
                           <span
-                            className={`sdix-status-badge ${rowData.mapped ? "is-mapped" : "is-unmapped"}`}
+                            className={`sdix-status-badge ${!rowData.hasPrimaryKey ? "is-blocked" : rowData.mapped ? "is-mapped" : "is-unmapped"}`}
                           >
                             {statusLabel(rowData)}
                           </span>
                         )}
                         style={{ minWidth: 150 }}
                       />
+                      <Column
+                        header="Primary Key"
+                        body={(rowData: DatasourceIntrospectionTableRecord) => (
+                          rowData.hasPrimaryKey
+                            ? rowData.primaryKeyColumnCount > 1
+                              ? `${rowData.primaryKeyColumnCount} columns`
+                              : rowData.primaryKeyColumnNames[0] ?? "1 column"
+                            : <span className="sdix-muted-cell">Missing</span>
+                        )}
+                        style={{ minWidth: 160 }}
+                      />
                       <Column
                         header="Superclass"
                         body={(rowData: DatasourceIntrospectionTableRecord) => rowData.suggestedBaseClassName}
@@ -2427,7 +3020,7 @@ npx @solidxai/solidctl@latest seed --modules-to-seed ${bootstrap?.module?.name |
               ) : drawerLoadingError ? (
                 <div className="sdix-error">
                   <span>{readQueryError(drawerLoadingError)}</span>
-                  <SolidButton size="small" variant="outline" onClick={() => void refetchTableDetail()}>
+                  <SolidButton size="small" variant="outline" onClick={() => selectedTable && void loadWorkspaceItem(selectedTable)}>
                     Retry
                   </SolidButton>
                 </div>
@@ -2438,6 +3031,59 @@ npx @solidxai/solidctl@latest seed --modules-to-seed ${bootstrap?.module?.name |
                 </div>
               ) : (
                 <div className="sdix-wizard-shell">
+                  <div className="sdix-workspace-body">
+                    <aside className="sdix-workspace-rail">
+                      <div className="sdix-workspace-rail__header">
+                        <strong>Selected tables</strong>
+                        <span>{workspaceRecords.length}</span>
+                      </div>
+                      <div className="sdix-workspace-rail__list">
+                        {workspaceTableKeys.map((key) => {
+                          const item = workspaceItems[key];
+                          if (!item) return null;
+                          const isActive = key === activeWorkspaceTableKey;
+                          const status =
+                            item.migrationStatus.state !== "idle" ? item.migrationStatus
+                              : item.saveStatus.state !== "idle" ? item.saveStatus
+                                : item.reviewStatus.state !== "idle" ? item.reviewStatus
+                                  : item.loadStatus;
+
+                          return (
+                            <button
+                              key={key}
+                              ref={(node) => {
+                                workspaceRailItemRefs.current[key] = node;
+                              }}
+                              type="button"
+                              className={`sdix-workspace-rail__item${isActive ? " is-active" : ""}`}
+                              onClick={() => {
+                                setActiveWorkspaceTableKey(key);
+                                if (workspaceStep === "configure") {
+                                  setDrawerTab("general-info");
+                                }
+                              }}
+                            >
+                              <div className="sdix-workspace-rail__item-main">
+                                <strong>{item.record.tableName}</strong>
+                                <span>{item.record.schema || "dbo"}</span>
+                              </div>
+                              <div className="sdix-workspace-rail__item-status">
+                                {status.state === "loading" ? <SolidSpinner size={12} /> : null}
+                                <span className={`sdix-workspace-rail__status sdix-workspace-rail__status--${status.state}`}>
+                                  {status.state === "success"
+                                    ? "Ready"
+                                    : status.state === "error"
+                                      ? "Needs attention"
+                                      : status.message}
+                                </span>
+                              </div>
+                            </button>
+                          );
+                        })}
+                      </div>
+                    </aside>
+
+                    <div className="sdix-workspace-main">
                   <div className="sdix-wizard-stepper">
                     {stepperItems.map((step, index) => (
                       <button
@@ -2465,6 +3111,8 @@ npx @solidxai/solidctl@latest seed --modules-to-seed ${bootstrap?.module?.name |
                       {workspaceContent}
                     </div>
                   </div>
+                    </div>
+                  </div>
 
                   {drawerDraft ? (
                     <div className="sdix-wizard-footer">
@@ -2554,45 +3202,51 @@ npx @solidxai/solidctl@latest seed --modules-to-seed ${bootstrap?.module?.name |
                 setFieldConfigColumnName(null);
               }
             }}
-            style={{ width: "min(1080px, calc(100vw - 48px))" }}
+            style={{ width: "min(760px, calc(100vw - 64px))" }}
           >
             <SolidDialogHeader>
               <div>
                 <SolidDialogTitle>Field configuration</SolidDialogTitle>
                 <SolidDialogDescription>
-                  Reuse the standard field form here to fine-tune the mapped SolidX field before saving the introspection draft.
+                  Configure how this mapped field should work in SolidX before saving it to the mapping draft.
                 </SolidDialogDescription>
               </div>
               <SolidDialogClose />
             </SolidDialogHeader>
             <SolidDialogSeparator />
             <SolidDialogBody>
-              {activeFieldConfigColumn && activeFieldConfigMetaData && drawerDraft ? (
-                <FieldMetaDataForm
-                  modelMetaData={{
-                    singularName: drawerDraft.singularName,
-                    pluralName: drawerDraft.pluralName,
-                  }}
-                  fieldMetaData={activeFieldConfigMetaData}
-                  setFieldMetaData={() => undefined}
-                  setVisiblePopup={() => undefined}
-                  setIsDirty={() => undefined}
-                  allFields={fieldDraftAllFields}
-                  deleteModelFunction={() => undefined}
-                  params={params}
-                  setIsRequiredPopUp={() => undefined}
-                  showToaster={showFieldDraftToaster}
-                  onDraftSubmit={(nextFieldConfig: Record<string, any>) => applyFieldConfigDraft(activeFieldConfigColumn.columnName, nextFieldConfig)}
-                  onClose={() => setFieldConfigColumnName(null)}
-                  availableFieldTypes={scalarFieldTypeOptions.map((option) => option.value)}
-                  forceShowTypeSelector
-                  selectorRequireContinue
-                  selectorContinueLabel="Next"
-                  selectorInitialFieldType={activeFieldConfigColumn.solidFieldType}
-                  disableIdentityEditingForExisting={false}
-                  submitLabel="Save field config"
-                />
-              ) : null}
+              <div className="sdix-field-config-dialog">
+                {activeFieldConfigColumn && activeFieldConfigMetaData && drawerDraft ? (
+                  <FieldMetaDataForm
+                    modelMetaData={{
+                      singularName: drawerDraft.singularName,
+                      pluralName: drawerDraft.pluralName,
+                      dataSourceType: drawerDraft.dataSourceType,
+                      module: {
+                        name: bootstrap?.module?.name,
+                        displayName: bootstrap?.module?.displayName,
+                      },
+                    }}
+                    fieldMetaData={activeFieldConfigMetaData}
+                    setFieldMetaData={() => undefined}
+                    setVisiblePopup={() => undefined}
+                    setIsDirty={() => undefined}
+                    allFields={fieldDraftAllFields}
+                    deleteModelFunction={() => undefined}
+                    params={params}
+                    setIsRequiredPopUp={() => undefined}
+                    showToaster={showFieldDraftToaster}
+                    onDraftSubmit={(nextFieldConfig: Record<string, any>) => applyFieldConfigDraft(activeFieldConfigColumn.columnName, nextFieldConfig)}
+                    onClose={() => setFieldConfigColumnName(null)}
+                    forceShowTypeSelector
+                    selectorRequireContinue
+                    selectorContinueLabel="Next"
+                    selectorInitialFieldType={activeFieldConfigColumn.solidFieldType}
+                    disableIdentityEditingForExisting={false}
+                    submitLabel="Save field config"
+                  />
+                ) : null}
+              </div>
             </SolidDialogBody>
           </SolidDialog>