@proteinjs/db 1.54.3 → 1.55.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proteinjs/db",
-  "version": "1.54.3",
+  "version": "1.55.1",
   "main": "./dist/generated/index.js",
   "types": "./dist/generated/index.d.ts",
   "exports": {
@@ -41,7 +41,7 @@
     "test": "jest --passWithNoTests"
   },
   "dependencies": {
-    "@proteinjs/db-query": "^1.11.0",
+    "@proteinjs/db-query": "^1.11.1",
     "@proteinjs/logger": "^1.2.0",
     "@proteinjs/reflection": "^1.2.0",
     "@proteinjs/serializer": "^1.1.10",
@@ -66,5 +66,5 @@
     "ts-jest": "29.1.1",
     "typescript": "5.2.2"
   },
-  "gitHead": "351cc984b09d074bf0306a82750efd99ec00654a"
+  "gitHead": "195e4d8a6aae026ad6c6b8b0fbfa831a57ecb501"
 }

package/src/Columns.ts

@@ -1,6 +1,6 @@
 import moment from 'moment';
 import { v1 as uuidv1 } from 'uuid';
-import { Column, ColumnOptions, getColumnPropertyName, Table, tableByName } from './Table';
+import { Column, ColumnOptions, getColumnPropertyName, Table } from './Table';
 import { Record } from './Record';
 import { ReferenceArray } from './reference/ReferenceArray';
 import { Db } from './Db';
@@ -263,17 +263,29 @@ export class ReferenceArrayColumn<T extends Record> extends ObjectColumn<Referen
     return new ReferenceArray(this.referenceTable, ids);
   }
 
-  async beforeDelete(table: Table<any>, columnPropertyName: string, records: any[]) {
+  /**
+   * Cascade: the referenced records go with the holder. Runs through the Db the firing write
+   * hands it — its driver, its transaction context, its authority — and off the ids the column
+   * stores; nothing here opens a Db of its own or re-reads the referenced rows, either of which
+   * would run as the session's user rather than as the write (a system delete's cascade must stay
+   * system: in a background context there is no session user at all).
+   */
+  async beforeDelete(
+    table: Table<any>,
+    columnPropertyName: string,
+    records: any[],
+    getTable?: (tableName: string) => Table<any>,
+    db?: Db
+  ): Promise<void> {
     if (!this.cascadeDelete) {
       return;
     }
 
     const recordIdsToDelete: string[] = [];
     for (const record of records) {
-      const referenceArray = record[columnPropertyName] as ReferenceArray<Record>;
-      const referenceRecords = await referenceArray.get();
-      for (const referenceRecord of referenceRecords) {
-        recordIdsToDelete.push(referenceRecord.id);
+      const referenceArray = record[columnPropertyName] as ReferenceArray<Record> | null | undefined;
+      if (referenceArray) {
+        recordIdsToDelete.push(...referenceArray._ids);
       }
     }
 
@@ -281,11 +293,12 @@ export class ReferenceArrayColumn<T extends Record> extends ObjectColumn<Referen
       return;
     }
 
-    const referenceTable = tableByName(this.referenceTable);
+    // Optional in the hook contract for implementers that need neither; the Db hands both to every hook.
+    const referenceTable = getTable!(this.referenceTable);
     const qb = new QueryBuilderFactory()
       .getQueryBuilder(referenceTable)
       .condition({ field: 'id', operator: 'IN', value: recordIdsToDelete });
-    await new Db().delete(referenceTable, qb);
+    await db!.delete(referenceTable, qb);
   }
 }
 
@@ -331,7 +344,18 @@ export class ReferenceColumn<T extends Record> extends StringColumn<Reference<T>
     return reference as Reference<T>;
   }
 
-  async beforeDelete(table: Table<any>, columnPropertyName: string, records: any[]) {
+  /**
+   * Cascade: the referenced record goes with the holder. Runs through the Db the firing write
+   * hands it (its driver, transaction context and authority) off the stored id — see
+   * `ReferenceArrayColumn.beforeDelete` for why the hook never opens a Db of its own.
+   */
+  async beforeDelete(
+    table: Table<any>,
+    columnPropertyName: string,
+    records: any[],
+    getTable?: (tableName: string) => Table<any>,
+    db?: Db
+  ): Promise<void> {
     if (!this.cascadeDelete) {
       return;
     }
@@ -348,11 +372,12 @@ export class ReferenceColumn<T extends Record> extends StringColumn<Reference<T>
       return;
     }
 
-    const referenceTable = tableByName(this.referenceTable);
+    // Optional in the hook contract for implementers that need neither; the Db hands both to every hook.
+    const referenceTable = getTable!(this.referenceTable);
     const qb = new QueryBuilderFactory()
       .getQueryBuilder(referenceTable)
       .condition({ field: 'id', operator: 'IN', value: recordIdsToDelete });
-    await new Db().delete(referenceTable, qb);
+    await db!.delete(referenceTable, qb);
   }
 }
 
@@ -508,6 +533,12 @@ export class DynamicReferenceColumn<T extends Record> extends StringColumn<Refer
     return new Reference<T>(tableName, serializedFieldValue);
   }
 
+  /**
+   * Cascade: the referenced record goes with the holder, whichever table the row names. Runs
+   * through the Db the firing write hands it (its driver, transaction context and authority) off
+   * the stored ids — see `ReferenceArrayColumn.beforeDelete` for why the hook never opens a Db of
+   * its own.
+   */
   async beforeDelete(
     table: Table<any>,
     columnPropertyName: string,
@@ -519,12 +550,8 @@ export class DynamicReferenceColumn<T extends Record> extends StringColumn<Refer
       return;
     }
 
-    const getTableFn = getTable ? getTable : tableByName;
-    const dbInstance = db ? db : new Db();
-
-    // Get all referenced record IDs grouped by table
+    // The referenced ids, grouped by the table each row names
     const recordsToDelete = new Map<string, string[]>();
-
     for (const record of records) {
       const reference = record[columnPropertyName] as Reference<Record>;
       if (!reference?._id || !reference._table) {
@@ -537,17 +564,13 @@ export class DynamicReferenceColumn<T extends Record> extends StringColumn<Refer
       recordsToDelete.get(reference._table)!.push(reference._id);
     }
 
-    // Delete records from each referenced table using Promise.all to properly await all deletions
-    const entries = Array.from(recordsToDelete.entries());
-    console.log(`entries to delete: ${JSON.stringify(entries)}`);
-    for (const [tableName, ids] of entries) {
-      if (ids.length > 0) {
-        const referenceTable = getTableFn(tableName);
-        const qb = new QueryBuilderFactory()
-          .getQueryBuilder(referenceTable)
-          .condition({ field: 'id', operator: 'IN', value: ids });
-        await dbInstance.delete(referenceTable, qb);
-      }
+    // Optional in the hook contract for implementers that need neither; the Db hands both to every hook.
+    for (const [tableName, ids] of Array.from(recordsToDelete.entries())) {
+      const referenceTable = getTable!(tableName);
+      const qb = new QueryBuilderFactory()
+        .getQueryBuilder(referenceTable)
+        .condition({ field: 'id', operator: 'IN', value: ids });
+      await db!.delete(referenceTable, qb);
     }
   }
 }

package/src/Db.ts

@@ -551,6 +551,14 @@ export class Db<R extends Record = Record> implements DbService<R> {
     return recordDeleteCount;
   }
 
+  /**
+   * A column's `beforeDelete` hook runs with the authority of the write that fired it: the Db it
+   * is handed rides this instance's driver, tables and transaction context AND its system mode.
+   * The hooks cascade a delete through reference columns, and a system delete's cascade must stay
+   * system — handed a default (non-system) Db, the cascade ran as whoever the session held, which
+   * narrowed it to that user's rows inside a request and refused it outright in a background
+   * context, where a scoped table finds no user to scope the query to.
+   */
   private async runColumnBeforeDeletes(table: Table<any>, recordsToDelete: Record[]) {
     for (const columnPropertyName in table.columns) {
       const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
@@ -560,7 +568,7 @@ export class Db<R extends Record = Record> implements DbService<R> {
           columnPropertyName,
           recordsToDelete,
           this.getTable,
-          new Db(this.dbDriver, this.getTable, this.transactionContextFactory)
+          new Db(this.dbDriver, this.getTable, this.transactionContextFactory, this.runAsSystem)
         );
       }
     }

package/src/Record.ts

@@ -25,10 +25,26 @@ const recordColumns: Columns<Record> = {
   }),
 };
 
-class MissingFieldError extends Error {
+/** A record field no declared column owns — the one serialize failure a write omits instead of failing on. */
+export class MissingFieldError extends Error {
   constructor(tableName: string, fieldName: string) {
     super(`Table ${tableName} is missing field: ${fieldName}`);
     this.name = 'MissingFieldError';
+    // ES5 down-leveled `extends Error` loses the subclass prototype — restore it so
+    // `instanceof MissingFieldError` holds for the write-side catch.
+    Object.setPrototypeOf(this, MissingFieldError.prototype);
+  }
+}
+
+/** Two declared columns of one table share a stored name: the second would silently take the first's seat. */
+export class DuplicateColumnNameError extends Error {
+  constructor(tableName: string, columnName: string, propertyNames: [string, string]) {
+    super(
+      `(${tableName}) Columns ${propertyNames[0]} and ${propertyNames[1]} both declare the column name ` +
+        `'${columnName}'; a stored cell can have only one seat`
+    );
+    this.name = 'DuplicateColumnNameError';
+    Object.setPrototypeOf(this, DuplicateColumnNameError.prototype);
   }
 }
 
@@ -102,7 +118,13 @@ export class RecordSerializer<T extends Record> {
       try {
         const { columnName, serializedFieldValue } = await fieldSerializer.serialize(fieldPropertyName, fieldValue);
         serialized[columnName] = serializedFieldValue;
-      } catch (MissingFieldError) {
+      } catch (error) {
+        // Only a field no column owns is omitted; a column that cannot serialize its value fails
+        // the write — nothing is stored for a cell the column could not make, and the caller hears it.
+        if (!(error instanceof MissingFieldError)) {
+          throw error;
+        }
+
         omittedFields.push(fieldPropertyName);
       }
     }
@@ -132,17 +154,45 @@ export class RecordSerializer<T extends Record> {
     const plan = this.hydrationPlan();
     const records: (T | Promise<T>)[] = new Array(serializedRecords.length);
     let settles = false;
-    for (let i = 0; i < serializedRecords.length; i++) {
-      const record = this.hydrate(plan, serializedRecords[i]);
-      if (this.isPromise(record)) {
-        settles = true;
+    try {
+      for (let i = 0; i < serializedRecords.length; i++) {
+        const record = this.hydrate(plan, serializedRecords[i]);
+        if (this.isPromise(record)) {
+          settles = true;
+        }
+        records[i] = record;
       }
-      records[i] = record;
+    } catch (error) {
+      return this.failAfterSettling(records, error);
     }
 
     return settles ? Promise.all(records) : (records as T[]);
   }
 
+  /**
+   * Settle, then fail: a row (or cell) that threw synchronously fails the set — but never before
+   * every promise an earlier row or cell already created has settled. A promise left behind by a
+   * synchronous throw is observed by nobody: its rejection is an `unhandledRejection` no caller
+   * can catch. So the throw becomes the set's rejection, after the created promises settle.
+   */
+  private failAfterSettling(created: unknown[], error: unknown): Promise<never> {
+    const settling: Promise<void>[] = [];
+    for (const value of created) {
+      if (this.isPromise(value)) {
+        settling.push(
+          value.then(
+            () => undefined,
+            () => undefined
+          )
+        );
+      }
+    }
+
+    return Promise.all(settling).then(() => {
+      throw error;
+    });
+  }
+
   /** One row → one record (`deserializeAll` is the door for a result set). */
   async deserialize(serializedRecord: SerializedRecord): Promise<T> {
     return await this.hydrate(this.hydrationPlan(), serializedRecord);
@@ -164,51 +214,56 @@ export class RecordSerializer<T extends Record> {
     const record: any = {};
     let settling: Promise<void>[] | undefined;
     let omittedFields: string[] | undefined;
-    for (const columnName in prepared) {
-      const slot = plan.slotsByColumnName[columnName];
-      if (!slot) {
-        // a column exists in the db that is no longer defined in Table.columns
-        (omittedFields ??= []).push(columnName);
-        continue;
-      }
+    try {
+      for (const columnName in prepared) {
+        const slot = plan.slotsByColumnName[columnName];
+        if (!slot) {
+          // a column exists in the db that no declared column owns (a column the table no longer
+          // declares, or one a rename left behind under the property's old name)
+          (omittedFields ??= []).push(columnName);
+          continue;
+        }
 
-      const { propertyName, column } = slot;
-      const storedValue = prepared[columnName];
-      if (!column.deserialize) {
-        record[propertyName] = storedValue;
-        continue;
-      }
+        const { propertyName, column } = slot;
+        const storedValue = prepared[columnName];
+        if (!column.deserialize) {
+          record[propertyName] = storedValue;
+          continue;
+        }
 
-      if (column.deserializeOnFirstRead && storedValue !== null && storedValue !== undefined) {
-        this.defineFieldReadOnFirstRead(record, propertyName, column, storedValue);
-        continue;
-      }
+        if (column.deserializeOnFirstRead && storedValue !== null && storedValue !== undefined) {
+          this.defineFieldReadOnFirstRead(record, propertyName, column, storedValue);
+          continue;
+        }
 
-      let fieldValue: unknown;
-      try {
-        fieldValue = column.deserialize(storedValue, prepared);
-      } catch (error) {
-        this.omitCellNotDeserialized(columnName, prepared, error);
-        continue;
-      }
+        let fieldValue: unknown;
+        try {
+          fieldValue = column.deserialize(storedValue, prepared);
+        } catch (error) {
+          this.omitCellNotDeserialized(columnName, prepared, error);
+          continue;
+        }
 
-      if (this.isPromise(fieldValue)) {
-        record[propertyName] = undefined; // seats the property in column order; the value lands when it settles
-        (settling ??= []).push(
-          fieldValue.then(
-            (value) => {
-              record[propertyName] = value;
-            },
-            (error) => {
-              delete record[propertyName];
-              this.omitCellNotDeserialized(columnName, prepared, error);
-            }
-          )
-        );
-        continue;
-      }
+        if (this.isPromise(fieldValue)) {
+          record[propertyName] = undefined; // seats the property in column order; the value lands when it settles
+          (settling ??= []).push(
+            fieldValue.then(
+              (value) => {
+                record[propertyName] = value;
+              },
+              (error) => {
+                delete record[propertyName];
+                this.omitCellNotDeserialized(columnName, prepared, error);
+              }
+            )
+          );
+          continue;
+        }
 
-      record[propertyName] = fieldValue;
+        record[propertyName] = fieldValue;
+      }
+    } catch (error) {
+      return this.failAfterSettling(settling ?? [], error);
     }
 
     if (omittedFields) {
@@ -271,13 +326,18 @@ export class RecordSerializer<T extends Record> {
       require('./encryption/EncryptionRecordHooks') as typeof import('./encryption/EncryptionRecordHooks');
     const slotsByColumnName: HydrationPlan['slotsByColumnName'] = {};
     const columns: { [propertyName: string]: Column<any, any> } = this.table.columns;
-    // Seated by column name, then by property name — a stored key that is a property name
-    // resolves to that property's column first, as it always has.
+    // Seated by the declared COLUMN name alone — the name a stored row carries a cell under (a
+    // driver's rows are keyed by column name, always). A stored key that is only a property's name
+    // — a column a rename retired and left physically present — names no seat: it is omitted like
+    // any other undeclared column and never reaches a declared column's parser.
     for (const propertyName in columns) {
-      slotsByColumnName[columns[propertyName].name] = { propertyName, column: columns[propertyName] };
-    }
-    for (const propertyName in columns) {
-      slotsByColumnName[propertyName] = { propertyName, column: columns[propertyName] };
+      const columnName = columns[propertyName].name;
+      const seated = slotsByColumnName[columnName];
+      if (seated) {
+        throw new DuplicateColumnNameError(this.table.name, columnName, [seated.propertyName, propertyName]);
+      }
+
+      slotsByColumnName[columnName] = { propertyName, column: columns[propertyName] };
     }
 
     this.plan = { hooks: new EncryptionRecordHooks(), slotsByColumnName };
@@ -335,22 +395,21 @@ export class FieldSerializer<T extends Record> {
 
   async deserialize(columnName: string, serializedFieldValue: any, serializedRecord: SerializedRecord) {
     const columns: { [prop: string]: Column<any, any> } = this.table.columns;
-    let fieldPropertyName = columnName;
-    let column = columns[columnName]; // the scenario that the column name is the same as the property name
-    if (!column) {
-      for (const columnPropertyName in columns) {
-        const checkColumn = (this.table.columns as any)[columnPropertyName];
-        if (checkColumn && columnName == checkColumn.name) {
-          fieldPropertyName = columnPropertyName;
-          column = checkColumn;
-          break;
-        }
+    // One seat per stored cell: the declared column whose NAME the cell is stored under (the law
+    // `RecordSerializer` hydrates by) — never a property that merely shares the stored key's name.
+    let fieldPropertyName: string | undefined;
+    let column: Column<any, any> | undefined;
+    for (const columnPropertyName in columns) {
+      if (columnName === columns[columnPropertyName].name) {
+        fieldPropertyName = columnPropertyName;
+        column = columns[columnPropertyName];
+        break;
       }
     }
 
-    if (!column) {
-      // this is the case where a column exists in the db that is no longer defined in Table.columns
-      throw new MissingFieldError(this.table.name, fieldPropertyName);
+    if (!column || !fieldPropertyName) {
+      // this is the case where a column exists in the db that no declared column owns
+      throw new MissingFieldError(this.table.name, columnName);
     }
 
     let fieldValue = serializedFieldValue;

package/src/auth/TableServiceAuth.ts

@@ -1,7 +1,7 @@
 import { Logger } from '@proteinjs/logger';
 import { ServiceError, ServiceRefusal } from '@proteinjs/service';
 import { Table, isTable } from '../Table';
-import { TableAuth, TableAuthError } from './TableAuth';
+import { TableAuth } from './TableAuth';
 
 export class TableServiceAuth {
   private logger = new Logger({ name: this.constructor.name });

package/src/schema/TableManager.ts

@@ -419,6 +419,30 @@ export class TableManager {
     return true;
   }
 
+  /**
+   * The census, at every schema sync of an existing table: the physical columns no declared column
+   * of the table owns — a column a rename retired (`tags` beside the `tag_list` that replaced it),
+   * a column the table dropped from its declaration. Such a column is never read or altered by the
+   * schema sync and never seated by the row reader; it rides every row of the table until a
+   * migration retires it. One WARN per table naming the columns — names only, never a value.
+   */
+  private warnUndeclaredColumns(table: Table<any>, physicalColumnNames: string[]): void {
+    const declared = new Set<string>();
+    for (const columnPropertyName in table.columns) {
+      declared.add(table.columns[columnPropertyName].name);
+    }
+
+    const undeclared = physicalColumnNames.filter((columnName) => !declared.has(columnName));
+    if (undeclared.length === 0) {
+      return;
+    }
+
+    this.logger.warn({
+      message: `Physical columns no declared column owns; a migration retires them`,
+      obj: { table: table.name, columns: undeclared },
+    });
+  }
+
   private async getTableChanges(table: Table<any>) {
     const { indexesToCreate, indexesToDrop } = await this.getIndexOperations(table);
     const tableChanges: TableChanges = {
@@ -440,6 +464,7 @@ export class TableManager {
     const columnMetadata = await this.schemaMetadata.getColumnMetadata(table);
     const uniqueColumns = await this.schemaMetadata.getUniqueColumns(table);
     const foreignKeys = await this.schemaMetadata.getForeignKeys(table);
+    this.warnUndeclaredColumns(table, Object.keys(columnMetadata));
     for (const columnPropertyName in table.columns) {
       const column = table.columns[columnPropertyName];
       if (columnMetadata[column.name]) {

package/src/source/SourceRecordSyncRunner.ts

@@ -662,7 +662,7 @@ export class SourceRecordSyncRunner {
             break;
           }
         }
-      } catch (error) {
+      } catch {
         // Unresolvable from cwd — reported below.
       }
     }

package/test/SettleThenFail.test.ts

@@ -0,0 +1,167 @@
+import { Column, Table } from '../src/Table';
+import { Record, RecordSerializer, SerializedRecord, withRecordColumns } from '../src/Record';
+import { StringColumn } from '../src/Columns';
+import { EncryptionRecordHooks } from '../src/encryption/EncryptionRecordHooks';
+import { EncryptionEnvelope } from '../src/encryption/EncryptionEnvelope';
+import { DataKeyStore, DataKeyMaterial } from '../src/encryption/DataKeyStore';
+
+/**
+ * Settle, then fail. The set reader hydrates rows in order and hands them to ONE promise after the
+ * loop; a row that needs an await (a ciphertext envelope whose key is read asynchronously) is a
+ * promise in the set from the moment its hook answers. If a LATER row then throws synchronously,
+ * the loop ends before that one promise exists — and the earlier row's promise is observed by
+ * nobody: its rejection is an `unhandledRejection`, which no caller can catch and a fatal boundary
+ * turns into an exit. The law: a synchronous throw fails the set only after every promise the set
+ * already created has settled — one rejection, carrying the throw, and no unhandled rejection. The
+ * same inside one row, for its cells.
+ */
+
+interface Doc extends Record {
+  title: string;
+  later: number;
+  after: string;
+}
+
+/** A column whose `deserialize` answers with a promise: resolves the number, rejects for -1. */
+class LaterColumn implements Column<number, number> {
+  constructor(public name: string) {}
+
+  deserialize(storedValue: number | null): Promise<number | null> {
+    return storedValue === -1 ? Promise.reject(new RangeError('unreadable')) : Promise.resolve(storedValue);
+  }
+}
+
+class DocTable extends Table<Doc> {
+  public name = 'settle_doc';
+  public columns = withRecordColumns<Doc>({
+    title: new StringColumn('title'),
+    later: new LaterColumn('later'),
+    after: new StringColumn('after'),
+  });
+}
+
+const docTable = new DocTable() as Table<Doc>;
+
+const keyFor = (owner: string, version: number): DataKeyMaterial => ({
+  owner,
+  version,
+  cipherKey: Buffer.alloc(32, 7),
+  indexKey: Buffer.alloc(32, 9),
+});
+
+const storedRow = (id: string, cells: Partial<SerializedRecord> = {}): SerializedRecord => ({
+  id,
+  created: new Date(1_700_000_000_000),
+  updated: new Date(1_700_000_000_000),
+  title: `title ${id}`,
+  later: 1,
+  after: `after ${id}`,
+  ...cells,
+});
+
+/** The unhandled rejections Node reported while `run` ran, counted after the loop drained twice. */
+const unhandledRejectionsDuring = async (
+  run: () => Promise<unknown>
+): Promise<{ unhandled: number; outcome: unknown }> => {
+  let unhandled = 0;
+  const listener = () => {
+    unhandled++;
+  };
+  process.on('unhandledRejection', listener);
+  try {
+    const outcome = await run().then(
+      (value) => ({ resolved: value }),
+      (error) => ({ rejected: error })
+    );
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    return { unhandled, outcome };
+  } finally {
+    process.off('unhandledRejection', listener);
+  }
+};
+
+describe('settle, then fail', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('an envelope row whose key read rejects, beside a later row that throws synchronously: one rejection, nothing unhandled', async () => {
+    const key = keyFor('owner-1', 4);
+    jest.spyOn(DataKeyStore.prototype, 'getKeyByVersion').mockRejectedValue(new Error('key unavailable'));
+    const onDeserialize = EncryptionRecordHooks.prototype.onDeserialize;
+    jest.spyOn(EncryptionRecordHooks.prototype, 'onDeserialize').mockImplementation(function (
+      this: EncryptionRecordHooks,
+      table,
+      row
+    ) {
+      if (row.id === 'r2') {
+        throw new Error('hook failed');
+      }
+      return onDeserialize.call(this, table, row);
+    });
+    const rows = [
+      storedRow('r1', { title: new EncryptionEnvelope().encrypt('secret', key) }),
+      storedRow('r2'),
+      storedRow('r3'),
+    ];
+
+    const { unhandled, outcome } = await unhandledRejectionsDuring(async () =>
+      new RecordSerializer<Doc>(docTable).deserializeAll(rows)
+    );
+
+    expect(outcome).toEqual({ rejected: new Error('hook failed') });
+    expect(unhandled).toBe(0);
+  });
+
+  test('inside one row: a cell whose promise rejects, beside a later cell that throws synchronously', async () => {
+    // A stored value whose `then` getter throws — the one synchronous throw the duck-typed
+    // promise check can meet after a column has answered.
+    const throwingThenable = {
+      get then(): never {
+        throw new Error('not a promise after all');
+      },
+    };
+    class ThenableColumn implements Column<unknown, unknown> {
+      constructor(public name: string) {}
+
+      deserialize(): unknown {
+        return throwingThenable;
+      }
+    }
+    interface Cells extends Record {
+      later: number;
+      odd: unknown;
+    }
+    class CellsTable extends Table<Cells> {
+      public name = 'settle_cells';
+      public columns = withRecordColumns<Cells>({
+        later: new LaterColumn('later'),
+        odd: new ThenableColumn('odd'),
+      });
+    }
+    const rows = [storedRow('c1', { later: -1, odd: 'x' })];
+
+    const { unhandled, outcome } = await unhandledRejectionsDuring(async () =>
+      new RecordSerializer<Cells>(new CellsTable() as Table<Cells>).deserializeAll(rows)
+    );
+
+    expect(outcome).toEqual({ rejected: new Error('not a promise after all') });
+    expect(unhandled).toBe(0);
+  });
+
+  test('a set that mixes the async road with a rejecting cell and a synchronous cell resolves, every row served', async () => {
+    const rows = [storedRow('r1'), storedRow('r2', { later: -1 }), storedRow('r3', { later: 3 })];
+
+    const { unhandled, outcome } = await unhandledRejectionsDuring(async () =>
+      new RecordSerializer<Doc>(docTable).deserializeAll(rows)
+    );
+
+    expect(unhandled).toBe(0);
+    const records = (outcome as { resolved: Doc[] }).resolved;
+    expect(records.map((record) => record.id)).toEqual(['r1', 'r2', 'r3']);
+    expect(records[0].later).toBe(1);
+    expect(records[1]).not.toHaveProperty('later');
+    expect(records[2].later).toBe(3);
+  });
+});