@@ -164,6 +164,26 @@ describe('ColumnConfigSidebar', () => {
     })
   })
 
+  it('keeps Reference creation open until a target table is selected', async () => {
+    await act(async () => {
+      root.render(
+        <ColumnConfigSidebar
+          config={{ mode: 'create', proposedName: 'Related row', type: 'reference' }}
+          onClose={vi.fn()}
+          existingColumn={null}
+          workspaceId='workspace-1'
+          tableId='table-current'
+        />
+      )
+    })
+
+    await act(async () => findButton('Save')?.click())
+
+    expect(container).toHaveTextContent('Select a table')
+    expect(mockAddColumn).not.toHaveBeenCalled()
+    expect(mockUpdateColumn).not.toHaveBeenCalled()
+  })
+
   it('edits Reference configuration without exposing column renaming', async () => {
     await act(async () => {
       root.render(
 
@@ -25,7 +25,7 @@ import type {
   WorkflowGroup,
 } from '@/lib/table'
 import { getColumnId } from '@/lib/table/column-keys'
-import { columnTypeOf } from '@/lib/table/column-types'
+import { columnTypeOf, typeMetadataOf } from '@/lib/table/column-types'
 import { TABLE_LIMITS } from '@/lib/table/constants'
 import { isEmptyCellValue } from '@/lib/table/deps'
 import { cellValueFilterConditions } from '@/lib/table/query-builder/cell-filter'
@@ -4164,11 +4164,7 @@ export function TableGrid({
             columnPosition: adjustedPosition >= 0 ? adjustedPosition : cols.length,
             columnUnique: entry.def?.unique ?? false,
             columnRequired: entry.def?.required ?? false,
-            // Without these a deleted select column can't be re-created — it is
-            // invalid with no options, and the saved cell data is option ids.
-            ...(entry.def?.options ? { columnOptions: entry.def.options } : {}),
-            ...(entry.def?.multiple ? { columnMultiple: true } : {}),
-            ...(entry.def?.currencyCode ? { columnCurrencyCode: entry.def.currencyCode } : {}),
+            columnTypeMetadata: entry.def ? typeMetadataOf(entry.def) : {},
             cellData,
             previousOrder: orderSnapshot,
             previousWidth,
 
@@ -195,6 +195,7 @@ describe('useTableUndo – delete-column undo cell restore chunking', () => {
     columnPosition: 0,
     columnUnique: false,
     columnRequired: false,
+    columnTypeMetadata: {},
     cellData: [],
     previousOrder: null,
     previousWidth: null,
@@ -248,8 +249,10 @@ describe('useTableUndo – restoring a deleted select column', () => {
     columnPosition: 0,
     columnUnique: false,
     columnRequired: false,
-    columnOptions: [{ id: 'opt_open', name: 'Open' }],
-    columnMultiple: true,
+    columnTypeMetadata: {
+      options: [{ id: 'opt_open', name: 'Open' }],
+      multiple: true,
+    },
     cellData: [],
     previousOrder: null,
     previousWidth: null,
@@ -272,3 +275,38 @@ describe('useTableUndo – restoring a deleted select column', () => {
     expect(payload.id).toBe('col_status')
   })
 })
+
+describe('useTableUndo – restoring a deleted reference column', () => {
+  it('re-creates the column with its target table', async () => {
+    mockPopUndo.mockReturnValueOnce(
+      makeEntry({
+        type: 'delete-column',
+        columnName: 'owner',
+        columnId: 'col_owner',
+        columnType: 'reference',
+        columnPosition: 0,
+        columnUnique: false,
+        columnRequired: false,
+        columnTypeMetadata: { referenceTableId: 'tbl_people' },
+        cellData: [],
+        previousOrder: null,
+        previousWidth: null,
+        previousPinnedColumns: null,
+      })
+    )
+
+    const { undo } = TestHook()
+    ;(undo as () => void)()
+    await flush()
+
+    expect(mockMutate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: 'col_owner',
+        name: 'owner',
+        type: 'reference',
+        referenceTableId: 'tbl_people',
+      }),
+      expect.any(Object)
+    )
+  })
+})
@@ -386,11 +386,7 @@ export function useTableUndo({
                   type: action.columnType,
                   required: action.columnRequired,
                   unique: action.columnUnique,
-                  // A select column is rejected without its options, and the
-                  // cell data restored below is keyed by those option ids.
-                  ...(action.columnOptions ? { options: action.columnOptions } : {}),
-                  ...(action.columnMultiple ? { multiple: true } : {}),
-                  ...(action.columnCurrencyCode ? { currencyCode: action.columnCurrencyCode } : {}),
+                  ...action.columnTypeMetadata,
                   position: action.columnPosition,
                 },
                 {
 
@@ -9,6 +9,7 @@ import {
   tableRowsQuerySchema,
   updateTableColumnBodySchema,
 } from '@/lib/api/contracts/tables'
+import { MAX_REFERENCE_TABLE_ID_LENGTH } from '@/lib/table/constants'
 
 describe('reference column metadata', () => {
   const referenceColumn = {
@@ -44,6 +45,45 @@ describe('reference column metadata', () => {
   it('rejects reference metadata on another column type', () => {
     expect(tableColumnSchema.safeParse({ ...referenceColumn, type: 'string' }).success).toBe(false)
   })
+
+  it('bounds reference table IDs at the standard identifier length', () => {
+    const maximumId = 't'.repeat(MAX_REFERENCE_TABLE_ID_LENGTH)
+    const oversizedId = 't'.repeat(MAX_REFERENCE_TABLE_ID_LENGTH + 1)
+
+    expect(
+      tableColumnSchema.safeParse({ ...referenceColumn, referenceTableId: maximumId }).success
+    ).toBe(true)
+    expect(
+      createTableColumnBodySchema.safeParse({
+        workspaceId: 'ws-1',
+        column: { ...referenceColumn, referenceTableId: maximumId },
+      }).success
+    ).toBe(true)
+    expect(
+      updateTableColumnBodySchema.safeParse({
+        workspaceId: 'ws-1',
+        columnName: 'account',
+        updates: { referenceTableId: maximumId },
+      }).success
+    ).toBe(true)
+
+    expect(
+      tableColumnSchema.safeParse({ ...referenceColumn, referenceTableId: oversizedId }).success
+    ).toBe(false)
+    expect(
+      createTableColumnBodySchema.safeParse({
+        workspaceId: 'ws-1',
+        column: { ...referenceColumn, referenceTableId: oversizedId },
+      }).success
+    ).toBe(false)
+    expect(
+      updateTableColumnBodySchema.safeParse({
+        workspaceId: 'ws-1',
+        columnName: 'account',
+        updates: { referenceTableId: oversizedId },
+      }).success
+    ).toBe(false)
+  })
 })
 
 /**
 
@@ -31,6 +31,7 @@ import type {
 import {
   COLUMN_TYPES,
   FILTER_OPS,
+  MAX_REFERENCE_TABLE_ID_LENGTH,
   MAX_RUN_TARGET_ROW_IDS,
   MAX_SELECT_OPTIONS,
   MAX_TABLE_BATCH_ITEMS,
@@ -85,15 +86,18 @@ export const currencyCodeSchema = z
   .regex(/^[A-Za-z]{3}$/, 'Must be a 3-letter ISO 4217 currency code, e.g. USD')
   .overwrite((code) => code.toUpperCase())
 
-export const referenceTableIdSchema = requiredFieldSchema('Reference table ID is required')
+export const referenceTableIdSchema = requiredFieldSchema('Reference table ID is required').max(
+  MAX_REFERENCE_TABLE_ID_LENGTH,
+  `Reference table ID must be ${MAX_REFERENCE_TABLE_ID_LENGTH} characters or less`
+)
 
 /**
  * Cross-field rules for type-owned metadata. A `select` column must declare a
  * non-empty option set, a `reference` column must declare its target table,
  * and type-specific fields are rejected on every type that does not own them.
  * Skipped when `type` is absent (a metadata-only update on an existing column).
  */
-export function refineColumnOptions(
+export function refineColumnTypeMetadata(
   data: {
     type?: (typeof COLUMN_TYPES)[number]
     options?: z.infer<typeof selectOptionsSchema>
@@ -243,7 +247,7 @@ export const tableColumnSchema = z
       .optional()
       .describe('Target table whose row IDs are stored by a reference column.'),
   })
-  .superRefine(refineColumnOptions)
+  .superRefine(refineColumnTypeMetadata)
   .describe('A typed column in a table schema.')
 
 export const createTableBodySchema = z.object({
@@ -328,7 +332,7 @@ export const createTableColumnBodySchema = z.object({
         .optional()
         .describe('Target table for a reference column.'),
     })
-    .superRefine(refineColumnOptions)
+    .superRefine(refineColumnTypeMetadata)
     .describe('Typed column definition to add.'),
 })
 
@@ -348,7 +352,7 @@ export const updateTableColumnBodySchema = z.object({
         .optional()
         .describe('New target table for a reference column.'),
     })
-    .superRefine(refineColumnOptions)
+    .superRefine(refineColumnTypeMetadata)
     .describe('Column fields to update.'),
 })
 
 
@@ -19,7 +19,7 @@ import {
   predicateSchema,
   referenceTableIdSchema,
   refineCancelTableRunsScope,
-  refineColumnOptions,
+  refineColumnTypeMetadata,
   rowAnchorMutexRefine,
   runColumnBodyBaseSchema,
   runColumnExcludeMutexRefine,
@@ -493,7 +493,7 @@ const v2TableColumnInputShape = {
 export const v2TableColumnInputSchema = z
   .object(v2TableColumnInputShape)
   .strict()
-  .superRefine(refineColumnOptions)
+  .superRefine(refineColumnTypeMetadata)
 
 /**
  * Initial columns take the same shape as every other v2 column input.
@@ -744,7 +744,7 @@ export const v2CreateTableColumnBodySchema = z
           .describe('Zero-based insertion position for the column.'),
       })
       .strict()
-      .superRefine(refineColumnOptions)
+      .superRefine(refineColumnTypeMetadata)
       .describe('Column definition to add.'),
   })
   .strict()
@@ -779,7 +779,7 @@ export const v2UpdateTableColumnBodySchema = z
           .describe('Replacement target table for a reference column.'),
       })
       .strict()
-      .superRefine(refineColumnOptions)
+      .superRefine(refineColumnTypeMetadata)
       .describe('Mutable column fields.'),
   })
   .strict()
 
@@ -1,5 +1,7 @@
 import { Table as TableIcon } from '@sim/emcn/icons'
+import { stringColumnType } from '@/lib/table/column-types/string'
 import type { ColumnTypeDefinition } from '@/lib/table/column-types/types'
+import { MAX_REFERENCE_TABLE_ID_LENGTH } from '@/lib/table/constants'
 
 export const referenceColumnType: ColumnTypeDefinition = {
   id: 'reference',
@@ -16,13 +18,7 @@ export const referenceColumnType: ColumnTypeDefinition = {
   editor: 'text',
   expandable: false,
 
-  coerce(value) {
-    if (typeof value === 'string') return { ok: true, value }
-    if (typeof value === 'number' || typeof value === 'boolean') {
-      return { ok: true, value: String(value) }
-    }
-    return { ok: false }
-  },
+  coerce: stringColumnType.coerce,
 
   validateCell(value, column) {
     return typeof value === 'string' ? null : `${column.name} must be a row ID string`
@@ -32,6 +28,11 @@ export const referenceColumnType: ColumnTypeDefinition = {
     if (typeof column.referenceTableId !== 'string' || column.referenceTableId.length === 0) {
       return [`Column "${column.name}" must define a reference table ID`]
     }
+    if (column.referenceTableId.length > MAX_REFERENCE_TABLE_ID_LENGTH) {
+      return [
+        `Column "${column.name}" reference table ID must be ${MAX_REFERENCE_TABLE_ID_LENGTH} characters or less`,
+      ]
+    }
     return []
   },
 
@@ -41,8 +42,5 @@ export const referenceColumnType: ColumnTypeDefinition = {
     return typeof value === 'object' ? JSON.stringify(value) : String(value)
   },
 
-  formatForInput(value) {
-    if (typeof value === 'object') return JSON.stringify(value)
-    return String(value)
-  },
+  formatForInput: stringColumnType.formatForInput,
 }
@@ -3,6 +3,7 @@
  */
 
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { MAX_REFERENCE_TABLE_ID_LENGTH } from '@/lib/table/constants'
 import type { TableDefinition } from '@/lib/table/types'
 
 const mocks = vi.hoisted(() => ({
@@ -159,4 +160,59 @@ describe('reference column metadata persistence', () => {
     expect(updated).toBe(table)
     expect(trx.update).not.toHaveBeenCalled()
   })
+
+  it('does not rewrite the schema when the target and supplied constraints are unchanged', async () => {
+    const table = tableWithReference()
+    table.schema.columns[0] = { ...table.schema.columns[0], required: true, unique: true }
+    const trx = useTable(table)
+
+    const updated = await updateColumnReference(
+      {
+        tableId: 'tbl_people',
+        columnName: 'col_account',
+        referenceTableId: 'tbl_accounts',
+        required: true,
+        unique: true,
+      },
+      'req_1'
+    )
+
+    expect(updated).toBe(table)
+    expect(trx.update).not.toHaveBeenCalled()
+  })
+
+  it('accepts a reference table ID at the standard identifier length', async () => {
+    const maximumId = 't'.repeat(MAX_REFERENCE_TABLE_ID_LENGTH)
+    useTable(tableWithReference())
+
+    const updated = await updateColumnReference(
+      {
+        tableId: 'tbl_people',
+        columnName: 'col_account',
+        referenceTableId: maximumId,
+      },
+      'req_1'
+    )
+
+    expect(updated.schema.columns[0]).toMatchObject({ referenceTableId: maximumId })
+    expect(mocks.set).toHaveBeenCalledOnce()
+  })
+
+  it('rejects a reference table ID longer than the standard identifier length', async () => {
+    const oversizedId = 't'.repeat(MAX_REFERENCE_TABLE_ID_LENGTH + 1)
+    const trx = useTable(tableWithReference())
+
+    await expect(
+      updateColumnReference(
+        {
+          tableId: 'tbl_people',
+          columnName: 'col_account',
+          referenceTableId: oversizedId,
+        },
+        'req_1'
+      )
+    ).rejects.toMatchObject({ code: 'validation' })
+
+    expect(trx.update).not.toHaveBeenCalled()
+  })
 })
@@ -1526,7 +1526,8 @@ export async function updateColumnReference(
       )
       const renamePending = data.newName !== undefined && data.newName !== column.name
       if (
-        constrained === updatedColumn &&
+        constrained.required === column.required &&
+        constrained.unique === column.unique &&
         updatedColumn.referenceTableId === column.referenceTableId &&
         !renamePending
       ) {