linkgress-orm 0.4.67 → 0.4.69

package/dist/query/query-builder.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CollectionQueryBuilder = exports.ReferenceQueryBuilder = exports.SelectQueryBuilder = exports.QueryBuilder = void 0;
+exports.CollectionQueryBuilder = exports.ReferenceQueryBuilder = exports.SelectQueryBuilder = exports.QueryBuilder = exports.materializeMockSelection = void 0;
 exports.getColumnNameMapForSchema = getColumnNameMapForSchema;
 exports.getRelationEntriesForSchema = getRelationEntriesForSchema;
+exports.getSchemaColumnMeta = getSchemaColumnMeta;
 exports.getTargetSchemaForRelation = getTargetSchemaForRelation;
 exports.createNestedFieldRefProxy = createNestedFieldRefProxy;
 const conditions_1 = require("./conditions");
@@ -16,6 +17,7 @@ const collection_strategy_factory_1 = require("./collection-strategy.factory");
 const union_builder_1 = require("./union-builder");
 const future_query_1 = require("./future-query");
 const mock_row_cache_1 = require("./mock-row-cache");
+const navigation_path_cache_1 = require("./navigation-path-cache");
 const join_utils_1 = require("./join-utils");
 /**
  * Field type categories for optimized result transformation
@@ -58,6 +60,26 @@ function getRelationEntriesForSchema(schema) {
     // Fallback: build the array (for schemas that weren't built with the new TableBuilder)
     return Object.entries(schema.relations);
 }
+/**
+ * Performance utility: per-schema column metadata (mapper + SQL type), computed once per
+ * schema object. `_createMockRow` and the collection mock-item builder both used to call
+ * `colBuilder.build()` for EVERY column on EVERY query build — pure waste for an immutable
+ * schema. WeakMap keyed by schema identity so schemas can be garbage-collected with their
+ * DbContext.
+ */
+const schemaColumnMetaCache = new WeakMap();
+function getSchemaColumnMeta(schema) {
+    let meta = schemaColumnMetaCache.get(schema);
+    if (meta == null) {
+        meta = new Map();
+        for (const [colName, colBuilder] of Object.entries(schema.columns)) {
+            const config = colBuilder.build();
+            meta.set(colName, { mapper: config.mapper, type: config.type, name: config.name, primaryKey: config.primaryKey });
+        }
+        schemaColumnMetaCache.set(schema, meta);
+    }
+    return meta;
+}
 /**
  * Mock-row descriptor cache for {@link ReferenceQueryBuilder.createMockTargetRow}.
  *
@@ -76,14 +98,18 @@ function getRelationEntriesForSchema(schema) {
  */
 const MOCK_ROW_FIELD_REFS = Symbol('linkgressMockFieldRefs');
 const MOCK_ROW_NAV_CACHE = Symbol('linkgressMockNavCache');
+const MOCK_ROW_CHAIN_ID = Symbol('linkgressMockChainId');
 const navigationPathSignature = (path) => path
     .map(step => `${step.alias}:${step.targetTable}:${(step.foreignKeys ?? []).join('+')}:${(step.matches ?? []).join('+')}:${step.isMandatory ? 1 : 0}:${step.sourceAlias ?? ''}`)
     .join('>');
 /**
- * Whether `value` is a reference mock row minted by `ReferenceQueryBuilder.createMockTargetRow`.
- * Those rows INHERIT their column/relation getters from a shared prototype (see MockRowCache),
- * so `Object.getPrototypeOf(row) !== Object.prototype` and own-property APIs see no columns —
- * the row's own state slots are the reliable marker.
+ * Whether `value` is a mock row minted by the query builders (`createMockTargetRow`,
+ * `SelectQueryBuilder._createMockRow`, `CollectionQueryBuilder.createMockItem`). Every
+ * such row INHERITS its column/relation getters from a shared prototype (see MockRowCache),
+ * so `Object.getPrototypeOf(row) !== Object.prototype` and own-property APIs (`Object.keys`,
+ * `{...row}`) see no columns — the row's own state slots are the reliable marker. Callers
+ * must treat a mock row like the plain-object mock it replaced (walk it for revivals,
+ * read properties directly) but never enumerate it with own-property APIs.
  */
 const isReferenceMockRow = (value) => value != null && typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, MOCK_ROW_FIELD_REFS);
 /** `Object.getOwnPropertyDescriptor` that walks the prototype chain (stops before Object.prototype). */
@@ -98,10 +124,32 @@ const findPropertyDescriptor = (value, key) => {
     }
     return undefined;
 };
+/**
+ * Materializes a selector RESULT that is itself a mock row (identity selectors like
+ * `.select(p => p)` or `(l, r) => l`): such rows inherit their columns from the shared
+ * prototype, so own-property walkers (`Object.entries` / `keys` / `values`) would see
+ * NOTHING and silently project zero columns. Reading every enumerable column getter
+ * once into a plain object restores exactly what the pre-prototype mocks exposed (their
+ * own enumerable getters) — non-enumerable relation getters stay out, as before. No-op
+ * for every other result shape (FieldRef, SqlFragment, builder, plain object, array).
+ */
+const materializeMockSelection = (result) => {
+    if (!isReferenceMockRow(result)) {
+        return result;
+    }
+    const out = {};
+    for (const key in result) {
+        if (findPropertyDescriptor(result, key)?.get != null) {
+            out[key] = result[key];
+        }
+    }
+    return out;
+};
+exports.materializeMockSelection = materializeMockSelection;
 /**
  * First enumerable key (own or inherited) backed by a getter — the "is this a mock row" probe
- * shared by the selection resolvers. Root mocks define their getters as own properties,
- * reference mocks inherit them; column getters are enumerable on both, so the first
+ * shared by the selection resolvers. All mock rows (root, collection-item, reference)
+ * inherit their getters from a shared prototype; column getters are enumerable, so the first
  * enumerable getter is always a column and `row[key]` yields its FieldRef.
  */
 const findFirstGetterKey = (value) => {
@@ -298,37 +346,67 @@ class QueryBuilder {
         if (this._cachedMockRow) {
             return this._cachedMockRow;
         }
-        const mock = {};
+        // Prototype-level cache — same pattern as ReferenceQueryBuilder.createMockTargetRow
+        // (see MockRowCache): every getter of a root mock row is fully determined by the
+        // schema object, so every query over the same table can share ONE prebuilt prototype
+        // carrying all column/relation getters; a new row is `Object.create` plus its own
+        // state slots — O(1) instead of one property definition per column+relation per
+        // query (measurable CPU under load: the root-mock walk was the ORM's largest
+        // per-query-build item after 0.4.69). Per-query state (`chainId`, the FieldRef
+        // cache) lives in symbol-keyed slots read through `this`; relation getters still
+        // construct FRESH builders per access (memoizing would fuse repeated
+        // `.where()` chains). Opt-in via the same static switch; OFF = fresh prototype
+        // per row (the pre-0.4.70 behaviour). Consumers must not probe mock rows with
+        // OWN-property APIs (`Object.keys`, `{...row}`) — see `isReferenceMockRow`.
+        const prototype = mock_row_cache_1.MockRowCache.getOrBuild(`select|${this.schema.name}`, () => Object.defineProperties({}, this.buildRootMockDescriptors()));
+        const mock = Object.create(prototype);
+        mock[MOCK_ROW_FIELD_REFS] = {};
+        mock[MOCK_ROW_CHAIN_ID] = this.chainId;
+        // Cache the mock for reuse
+        this._cachedMockRow = mock;
+        return mock;
+    }
+    /**
+     * Builds the shared property-descriptor map for {@link _createMockRow}'s cached path.
+     * The getters read per-row state through `this`-bound symbol slots, so one descriptor
+     * map serves every root mock row of the same schema. Values captured at build time
+     * (column mappers/types, target schemas, the registry) are schema-constants identical
+     * for every row of the signature.
+     */
+    buildRootMockDescriptors() {
         const tableAlias = this.schema.name;
-        const chainId = this.chainId;
         // Performance: Use pre-computed column name map if available
         const columnNameMap = getColumnNameMapForSchema(this.schema);
-        // Performance: Lazy-cache FieldRef objects - only create when first accessed
-        const fieldRefCache = {};
         // Build a mapper lookup for columns (only when needed)
         const columnMappers = {};
         const columnSqlTypes = {};
-        for (const [colName, colBuilder] of Object.entries(this.schema.columns)) {
-            const config = colBuilder.build();
-            if (config.mapper) {
-                columnMappers[colName] = config.mapper;
+        // Per-schema mapper/type lookup, computed once — `colBuilder.build()` per column
+        // per row was measurable CPU under load (every query build walks every column
+        // twice: once here, once in the descriptors). Keyed by schema identity.
+        const schemaColumnMeta = getSchemaColumnMeta(this.schema);
+        for (const [colName, meta] of schemaColumnMeta) {
+            if (meta.mapper) {
+                columnMappers[colName] = meta.mapper;
             }
-            if (config.type) {
-                columnSqlTypes[colName] = config.type;
+            if (meta.type) {
+                columnSqlTypes[colName] = meta.type;
             }
         }
+        const descriptors = {};
         // Add columns as FieldRef objects - type-safe with property name and database column name
         for (const [colName, dbColumnName] of columnNameMap) {
             const mapper = columnMappers[colName];
-            Object.defineProperty(mock, colName, {
+            descriptors[colName] = {
                 get() {
+                    const slots = this;
+                    const fieldRefCache = slots[MOCK_ROW_FIELD_REFS] ?? (slots[MOCK_ROW_FIELD_REFS] = {});
                     let cached = fieldRefCache[colName];
                     if (!cached) {
                         cached = fieldRefCache[colName] = {
                             __fieldName: colName,
                             __dbColumnName: dbColumnName,
                             __tableAlias: tableAlias,
-                            __chainId: chainId,
+                            __chainId: slots[MOCK_ROW_CHAIN_ID],
                             // Include mapper for toDriver transformation in conditions
                             __mapper: mapper,
                             // Column SQL type — lets flag* emit width-exact mask casts
@@ -339,49 +417,51 @@ class QueryBuilder {
                 },
                 enumerable: true,
                 configurable: true,
-            });
+            };
         }
         // Performance: Use pre-computed relation entries and cached schemas
         const relationEntries = getRelationEntriesForSchema(this.schema);
+        // Values captured at descriptor-build time — identical for every row of this
+        // signature (the registry is the process-wide schema registry).
+        const schemaRegistry = this.schemaRegistry;
+        const sourceTableName = this.schema.name;
         // Add relations (both collections and single references)
         for (const [relName, relConfig] of relationEntries) {
             // Performance: Use cached target schema, but prefer registry lookup for full relations
-            let targetSchema = this.schemaRegistry?.get(relConfig.targetTable);
+            let targetSchema = schemaRegistry?.get(relConfig.targetTable);
             if (!targetSchema) {
                 targetSchema = getTargetSchemaForRelation(this.schema, relName, relConfig);
             }
             if (relConfig.type === 'many') {
                 // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
-                Object.defineProperty(mock, relName, {
+                descriptors[relName] = {
                     get: () => {
-                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema, this.schemaRegistry, // Pass schema registry for nested navigation resolution
+                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', sourceTableName, targetSchema, schemaRegistry, // Pass schema registry for nested navigation resolution
                         undefined, relConfig.foreignKeys, // Propagate composite FK / literal predicates
                         relConfig.matches);
                     },
                     enumerable: false,
                     configurable: true,
-                });
+                };
             }
             else {
                 // Single reference navigation (many-to-one, one-to-one)
                 // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow
                 // with circular relations like User->Posts->User)
-                Object.defineProperty(mock, relName, {
+                descriptors[relName] = {
                     get: () => {
-                        const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema, this.schemaRegistry, // Pass schema registry for nested navigation resolution
+                        const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema, schemaRegistry, // Pass schema registry for nested navigation resolution
                         [], // Empty navigation path for first level navigation
-                        this.schema.name // Pass source table name for lateral join correlation
+                        sourceTableName // Pass source table name for lateral join correlation
                         );
                         return refBuilder.createMockTargetRow();
                     },
                     enumerable: false,
                     configurable: true,
-                });
+                };
             }
         }
-        // Cache the mock for reuse
-        this._cachedMockRow = mock;
-        return mock;
+        return descriptors;
     }
     /**
      * Add a LEFT JOIN to the query with a selector (supports both tables and subqueries)
@@ -425,7 +505,7 @@ class QueryBuilder {
             // Create fresh mocks for the selector invocation
             const freshMockLeft = createLeftMock();
             const freshMockRight = createRightMock();
-            return selector(freshMockLeft, freshMockRight);
+            return (0, exports.materializeMockSelection)(selector(freshMockLeft, freshMockRight));
         };
         return new SelectQueryBuilder(this.schema, this.client, wrappedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, false, // isDistinct defaults to false
         undefined, // schemaRegistry
@@ -474,7 +554,7 @@ class QueryBuilder {
             // Create fresh mocks for the selector invocation
             const freshMockLeft = createLeftMock();
             const freshMockRight = createRightMock();
-            return selector(freshMockLeft, freshMockRight);
+            return (0, exports.materializeMockSelection)(selector(freshMockLeft, freshMockRight));
         };
         return new SelectQueryBuilder(this.schema, this.client, wrappedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, false, // isDistinct defaults to false
         undefined, // schemaRegistry
@@ -560,7 +640,7 @@ class QueryBuilder {
     }
     orderBy(selector) {
         const mockRow = this._createMockRow();
-        const result = selector(mockRow);
+        const result = (0, exports.materializeMockSelection)(selector(mockRow));
         (0, query_utils_1.parseOrderBy)(result, this.orderByFields);
         return this;
     }
@@ -630,7 +710,7 @@ class SelectQueryBuilder {
     select(selector) {
         // Create a composed selector that applies both transformations
         const composedSelector = (row) => {
-            const firstResult = this.selector(row);
+            const firstResult = (0, exports.materializeMockSelection)(this.selector(row));
             return selector(firstResult);
         };
         return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, this.manualJoins, this.joinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy, this.chainId);
@@ -678,7 +758,7 @@ class SelectQueryBuilder {
         const rightAlias = `${rightSchema.name}_${this.joinCounter}`;
         this.joinCounter = this.joinCounter + 1;
         const mockRow = this._createMockRow();
-        const selectedMock = this.selector(mockRow);
+        const selectedMock = (0, exports.materializeMockSelection)(this.selector(mockRow));
         const leftMock = this.createFieldRefProxy(selectedMock, true);
         const rightMock = this.createMockRowForTable(rightSchema, rightAlias);
         const onCondition = on(leftMock, rightMock);
@@ -707,7 +787,7 @@ class SelectQueryBuilder {
      */
     addCteFilterJoin(type, cte, on, filter) {
         const mockRow = this._createMockRow();
-        const selectedMock = this.selector(mockRow);
+        const selectedMock = (0, exports.materializeMockSelection)(this.selector(mockRow));
         const leftMock = this.createFieldRefProxy(selectedMock, true);
         const rightMock = this.createMockRowForCte(cte);
         const onCondition = on(leftMock, rightMock);
@@ -734,7 +814,7 @@ class SelectQueryBuilder {
     where(condition) {
         const mockRow = this._createMockRow();
         // Apply the selector to get the selected shape that the user sees in the WHERE condition
-        const selectedMock = this.selector(mockRow);
+        const selectedMock = (0, exports.materializeMockSelection)(this.selector(mockRow));
         // Wrap in proxy - for WHERE, we preserve original column names
         const fieldRefProxy = this.createFieldRefProxy(selectedMock, true);
         const newCondition = condition(fieldRefProxy);
@@ -824,7 +904,7 @@ class SelectQueryBuilder {
     }
     orderBy(selector) {
         const mockRow = this._createMockRow();
-        const selectedMock = this.selector(mockRow);
+        const selectedMock = (0, exports.materializeMockSelection)(this.selector(mockRow));
         // Wrap selectedMock in a proxy that returns FieldRefs for property access
         const fieldRefProxy = this.createFieldRefProxy(selectedMock);
         const result = selector(fieldRefProxy);
@@ -856,7 +936,7 @@ class SelectQueryBuilder {
         const newJoinCounter = this.joinCounter + 1;
         // Create mock for the current selection (left side)
         const mockRow = this._createMockRow();
-        const mockLeftSelection = this.selector(mockRow);
+        const mockLeftSelection = (0, exports.materializeMockSelection)(this.selector(mockRow));
         // Create mock for the subquery result (right side)
         // For subqueries, we create a mock based on the result type
         const mockRight = this.createMockRowForSubquery(alias, subquery);
@@ -874,7 +954,7 @@ class SelectQueryBuilder {
             }];
         // Create a new selector
         const composedSelector = (row) => {
-            const leftResult = this.selector(row);
+            const leftResult = (0, exports.materializeMockSelection)(this.selector(row));
             const freshMockRight = this.createMockRowForSubquery(alias, subquery);
             return selector(leftResult, freshMockRight);
         };
@@ -900,7 +980,7 @@ class SelectQueryBuilder {
         // Create mock for the current selection (left side)
         // IMPORTANT: We call the selector with the mock row to get a result that contains FieldRef objects
         const mockRow = this._createMockRow();
-        const mockLeftSelection = this.selector(mockRow);
+        const mockLeftSelection = (0, exports.materializeMockSelection)(this.selector(mockRow));
         // The mockLeftSelection now contains FieldRef objects (with __fieldName, __dbColumnName, __tableAlias)
         // These FieldRef objects preserve the table context
         // Create mock for the right table
@@ -918,7 +998,7 @@ class SelectQueryBuilder {
             }];
         // Create a new selector that first applies the current selector, then the new selector
         const composedSelector = (row) => {
-            const leftResult = this.selector(row);
+            const leftResult = (0, exports.materializeMockSelection)(this.selector(row));
             const freshMockRight = this.createMockRowForTable(rightSchema, rightAlias);
             return selector(leftResult, freshMockRight);
         };
@@ -931,7 +1011,7 @@ class SelectQueryBuilder {
         const newJoinCounter = this.joinCounter + 1;
         // Create mock for the current selection (left side)
         const mockRow = this._createMockRow();
-        const mockLeftSelection = this.selector(mockRow);
+        const mockLeftSelection = (0, exports.materializeMockSelection)(this.selector(mockRow));
         // Create mock for the CTE columns (right side)
         const mockRight = this.createMockRowForCte(cte);
         // Evaluate the join condition
@@ -947,7 +1027,7 @@ class SelectQueryBuilder {
             }];
         // Create a new selector
         const composedSelector = (row) => {
-            const leftResult = this.selector(row);
+            const leftResult = (0, exports.materializeMockSelection)(this.selector(row));
             const freshMockRight = this.createMockRowForCte(cte);
             return selector(leftResult, freshMockRight);
         };
@@ -964,7 +1044,7 @@ class SelectQueryBuilder {
         const newJoinCounter = this.joinCounter + 1;
         // Create mock for the current selection (left side)
         const mockRow = this._createMockRow();
-        const mockLeftSelection = this.selector(mockRow);
+        const mockLeftSelection = (0, exports.materializeMockSelection)(this.selector(mockRow));
         // Create mock for the subquery result (right side)
         const mockRight = this.createMockRowForSubquery(alias, subquery);
         // Evaluate the join condition
@@ -981,7 +1061,7 @@ class SelectQueryBuilder {
             }];
         // Create a new selector
         const composedSelector = (row) => {
-            const leftResult = this.selector(row);
+            const leftResult = (0, exports.materializeMockSelection)(this.selector(row));
             const freshMockRight = this.createMockRowForSubquery(alias, subquery);
             return selector(leftResult, freshMockRight);
         };
@@ -1006,7 +1086,7 @@ class SelectQueryBuilder {
         const newJoinCounter = this.joinCounter + 1;
         // Create mock for the current selection (left side)
         const mockRow = this._createMockRow();
-        const mockLeftSelection = this.selector(mockRow);
+        const mockLeftSelection = (0, exports.materializeMockSelection)(this.selector(mockRow));
         // Create mock for the right table
         const mockRight = this.createMockRowForTable(rightSchema, rightAlias);
         // Evaluate the join condition
@@ -1021,7 +1101,7 @@ class SelectQueryBuilder {
             }];
         // Create a new selector that first applies the current selector, then the new selector
         const composedSelector = (row) => {
-            const leftResult = this.selector(row);
+            const leftResult = (0, exports.materializeMockSelection)(this.selector(row));
             const freshMockRight = this.createMockRowForTable(rightSchema, rightAlias);
             return selector(leftResult, freshMockRight);
         };
@@ -1200,7 +1280,7 @@ class SelectQueryBuilder {
      */
     selectDistinct(selector) {
         const composedSelector = (row) => {
-            const firstResult = this.selector(row);
+            const firstResult = (0, exports.materializeMockSelection)(this.selector(row));
             return selector(firstResult);
         };
         return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, this.manualJoins, this.joinCounter, true, // Set isDistinct to true
@@ -1222,13 +1302,13 @@ class SelectQueryBuilder {
         let fieldToAggregate;
         if (selector) {
             const mockRow = this._createMockRow();
-            const mockSelection = this.selector(mockRow);
+            const mockSelection = (0, exports.materializeMockSelection)(this.selector(mockRow));
             fieldToAggregate = selector(mockSelection);
         }
         else {
             // No selector - use the current selection
             const mockRow = this._createMockRow();
-            fieldToAggregate = this.selector(mockRow);
+            fieldToAggregate = (0, exports.materializeMockSelection)(this.selector(mockRow));
         }
         // Build aggregation query
         const { sql, params } = this.buildAggregationQuery('MIN', fieldToAggregate, context);
@@ -1254,13 +1334,13 @@ class SelectQueryBuilder {
         let fieldToAggregate;
         if (selector) {
             const mockRow = this._createMockRow();
-            const mockSelection = this.selector(mockRow);
+            const mockSelection = (0, exports.materializeMockSelection)(this.selector(mockRow));
             fieldToAggregate = selector(mockSelection);
         }
         else {
             // No selector - use the current selection
             const mockRow = this._createMockRow();
-            fieldToAggregate = this.selector(mockRow);
+            fieldToAggregate = (0, exports.materializeMockSelection)(this.selector(mockRow));
         }
         // Build aggregation query
         const { sql, params } = this.buildAggregationQuery('MAX', fieldToAggregate, context);
@@ -1286,13 +1366,13 @@ class SelectQueryBuilder {
         let fieldToAggregate;
         if (selector) {
             const mockRow = this._createMockRow();
-            const mockSelection = this.selector(mockRow);
+            const mockSelection = (0, exports.materializeMockSelection)(this.selector(mockRow));
             fieldToAggregate = selector(mockSelection);
         }
         else {
             // No selector - use the current selection
             const mockRow = this._createMockRow();
-            fieldToAggregate = this.selector(mockRow);
+            fieldToAggregate = (0, exports.materializeMockSelection)(this.selector(mockRow));
         }
         // Build aggregation query
         const { sql, params } = this.buildAggregationQuery('SUM', fieldToAggregate, context);
@@ -1340,7 +1420,7 @@ class SelectQueryBuilder {
                 executor: this.executor,
             }));
             const mockRow = tracer.trace('createMockRow', () => this._createMockRow());
-            const selectionResult = tracer.trace('evaluateSelector', () => this.selector(mockRow));
+            const selectionResult = tracer.trace('evaluateSelector', () => (0, exports.materializeMockSelection)(this.selector(mockRow)));
             const { sql, params, nestedPaths } = tracer.trace('buildQuery', () => this.buildQuery(selectionResult, context));
             tracer.endPhase();
             tracer.startPhase('queryExecution');
@@ -1448,7 +1528,7 @@ class SelectQueryBuilder {
             hoistedCteNames: context.hoistedCteNames,
         };
         const mockRow = this._createMockRow();
-        const selectionResult = this.selector(mockRow);
+        const selectionResult = (0, exports.materializeMockSelection)(this.selector(mockRow));
         // Build query without ORDER BY, LIMIT, OFFSET for union component
         const { sql, nestedPaths } = this.buildQueryCore(selectionResult, queryContext, false);
         // Update context's param counter
@@ -1516,7 +1596,7 @@ class SelectQueryBuilder {
             executor: this.executor,
         };
         const mockRow = this._createMockRow();
-        const selectionResult = this.selector(mockRow);
+        const selectionResult = (0, exports.materializeMockSelection)(this.selector(mockRow));
         const { sql, params, nestedPaths } = this.buildQuery(selectionResult, context);
         // Create transform function that captures current state
         const transformFn = (rows) => {
@@ -1563,7 +1643,7 @@ class SelectQueryBuilder {
             executor: this.executor,
         };
         const mockRow = this._createMockRow();
-        const selectionResult = this.selector(mockRow);
+        const selectionResult = (0, exports.materializeMockSelection)(this.selector(mockRow));
         const { sql, params, nestedPaths } = this.buildQuery(selectionResult, context);
         // Restore original limit
         this.limitValue = originalLimit;
@@ -1792,7 +1872,7 @@ class SelectQueryBuilder {
         }));
         // Analyze the selector to extract nested queries
         const mockRow = tracer.trace('createMockRow', () => this._createMockRow());
-        const selectionResult = tracer.trace('evaluateSelector', () => this.selector(mockRow));
+        const selectionResult = tracer.trace('evaluateSelector', () => (0, exports.materializeMockSelection)(this.selector(mockRow)));
         // Check if we're using temp table strategy and have collections
         const collections = tracer.trace('detectCollections', () => this.detectCollections(selectionResult));
         const useTempTableStrategy = this.collectionStrategy === 'temptable' && collections.length > 0;
@@ -2054,7 +2134,7 @@ class SelectQueryBuilder {
             'jsonb',
         ]);
         try {
-            const selected = b.selector(b.createMockItem());
+            const selected = (0, exports.materializeMockSelection)(b.selector(b.createMockItem()));
             for (const value of Object.values(selected)) {
                 if (!(value && typeof value === 'object' && '__dbColumnName' in value)) {
                     return false;
@@ -2119,10 +2199,9 @@ class SelectQueryBuilder {
                     // Find primary key column from schema, fallback to "id" if not found
                     let pkColumn = null;
                     if (targetSchema) {
-                        for (const colBuilder of Object.values(targetSchema.columns)) {
-                            const config = colBuilder.build();
-                            if (config.primaryKey) {
-                                pkColumn = config.name;
+                        for (const meta of getSchemaColumnMeta(targetSchema).values()) {
+                            if (meta.primaryKey && meta.name != null) {
+                                pkColumn = meta.name;
                                 break;
                             }
                         }
@@ -2503,7 +2582,7 @@ class SelectQueryBuilder {
         };
         // Analyze the selector to extract nested queries
         const mockRow = this._createMockRow();
-        const selectionResult = this.selector(mockRow);
+        const selectionResult = (0, exports.materializeMockSelection)(this.selector(mockRow));
         // Build the query - this populates context.placeholders
         const { sql, nestedPaths } = this.buildQuery(selectionResult, context);
         // Create transform function (closure over schema, selection, nestedPaths)
@@ -2892,7 +2971,7 @@ class SelectQueryBuilder {
         }
         // Selector function - extract selected columns
         const mockRow = this._createMockRow();
-        const selectedMock = this.selector(mockRow);
+        const selectedMock = (0, exports.materializeMockSelection)(this.selector(mockRow));
         const selection = returning(selectedMock);
         if (typeof selection === 'object' && selection !== null) {
             const columns = [];
@@ -2932,12 +3011,14 @@ class SelectQueryBuilder {
     mapDeleteReturningResults(rows, returning, fragmentMappers) {
         if (returning === true) {
             // Full entity mapping - apply fromDriver mappers
+            // getSchemaColumnMeta: `colBuilder.build()` per column PER ROW was pure waste for an
+            // immutable schema — the per-schema meta map is computed once.
+            const columnMeta = getSchemaColumnMeta(this.schema);
             return rows.map(row => {
                 const mapped = {};
-                for (const [propName, colBuilder] of Object.entries(this.schema.columns)) {
-                    const config = colBuilder.build();
-                    const dbValue = row[config.name];
-                    mapped[propName] = config.mapper ? config.mapper.fromDriver(dbValue) : dbValue;
+                for (const [propName, meta] of columnMeta) {
+                    const dbValue = row[meta.name];
+                    mapped[propName] = meta.mapper ? meta.mapper.fromDriver(dbValue) : dbValue;
                 }
                 return mapped;
             });
@@ -2953,15 +3034,13 @@ class SelectQueryBuilder {
                     continue;
                 }
                 // Try to find column by alias or name
-                const colEntry = Object.entries(this.schema.columns).find(([propName, col]) => {
-                    const config = col.build();
-                    return propName === key || config.name === key;
+                const colEntry = [...getSchemaColumnMeta(this.schema)].find(([propName, meta]) => {
+                    return propName === key || meta.name === key;
                 });
                 if (colEntry) {
-                    const [, col] = colEntry;
-                    const config = col.build();
+                    const [, meta] = colEntry;
                     // Apply fromDriver mapper if present
-                    mapped[key] = config.mapper ? config.mapper.fromDriver(value) : value;
+                    mapped[key] = meta.mapper ? meta.mapper.fromDriver(value) : value;
                 }
                 else {
                     mapped[key] = value;
@@ -2982,7 +3061,7 @@ class SelectQueryBuilder {
         }
         // Analyze the returning selector
         const mockRow = this._createMockRow();
-        const selectedMock = this.selector(mockRow);
+        const selectedMock = (0, exports.materializeMockSelection)(this.selector(mockRow));
         const selection = returning(selectedMock);
         if (typeof selection !== 'object' || selection === null) {
             return null;
@@ -3070,7 +3149,7 @@ class SelectQueryBuilder {
         const selectParts = [];
         const nestedPaths = new Set();
         const mockRow = this._createMockRow();
-        const selectedMock = this.selector(mockRow);
+        const selectedMock = (0, exports.materializeMockSelection)(this.selector(mockRow));
         const selection = returning(selectedMock);
         // Helper to get FK db column name from a schema
         const getFkDbColumnName = (sourceSchema, fkPropName) => {
@@ -3339,37 +3418,61 @@ ${joinClauses.join('\n')}`;
      * @internal
      */
     _createMockRow() {
-        const mock = {};
+        // Prototype-level cache — same pattern as the SelectQueryBuilder mock (see
+        // MockRowCache). The signature includes the manual-join shape because join
+        // sub-objects are part of the mock's surface; joined queries carry a per-query
+        // alias counter, so their signatures are effectively unique and they degrade to
+        // the uncached cost (built and discarded per row), while the far more common
+        // join-less `qb|<table>` signature hits the shared prototype. Per-query state
+        // (`chainId`, FieldRef cache, join sub-objects) lives in symbol-keyed slots read
+        // through `this`. Opt-in via the same static switch; OFF = fresh prototype per row
+        // (the pre-0.4.70 behaviour).
+        const joinSig = this.manualJoins
+            .filter(j => !j.isSubquery && j.schema)
+            .map(j => `${j.alias}:${j.schema.name}`)
+            .join('+');
+        const prototype = mock_row_cache_1.MockRowCache.getOrBuild(`qb|${this.schema.name}|${joinSig}`, () => Object.defineProperties({}, this.buildRootMockDescriptors()));
+        const mock = Object.create(prototype);
+        mock[MOCK_ROW_FIELD_REFS] = {};
+        mock[MOCK_ROW_NAV_CACHE] = {};
+        mock[MOCK_ROW_CHAIN_ID] = this.chainId;
+        return mock;
+    }
+    /**
+     * Builds the shared property-descriptor map for {@link _createMockRow}'s cached path.
+     * The getters read per-row state through `this`-bound symbol slots; values captured at
+     * build time are signature-constants identical for every row of the signature.
+     */
+    buildRootMockDescriptors() {
         const tableAlias = this.schema.name;
-        const chainId = this.chainId;
         // Performance: Use pre-computed column name map if available
         const columnNameMap = getColumnNameMapForSchema(this.schema);
-        // Performance: Lazy-cache FieldRef objects
-        const fieldRefCache = {};
         // Build a mapper lookup for columns (only when needed)
         const columnMappers = {};
         const columnSqlTypes = {};
-        for (const [colName, colBuilder] of Object.entries(this.schema.columns)) {
-            const config = colBuilder.build();
-            if (config.mapper) {
-                columnMappers[colName] = config.mapper;
+        for (const [colName, meta] of getSchemaColumnMeta(this.schema)) {
+            if (meta.mapper) {
+                columnMappers[colName] = meta.mapper;
             }
-            if (config.type) {
-                columnSqlTypes[colName] = config.type;
+            if (meta.type) {
+                columnSqlTypes[colName] = meta.type;
             }
         }
+        const descriptors = {};
         // Add columns as FieldRef objects - type-safe with property name and database column name
         for (const [colName, dbColumnName] of columnNameMap) {
             const mapper = columnMappers[colName];
-            Object.defineProperty(mock, colName, {
+            descriptors[colName] = {
                 get() {
+                    const slots = this;
+                    const fieldRefCache = slots[MOCK_ROW_FIELD_REFS] ?? (slots[MOCK_ROW_FIELD_REFS] = {});
                     let cached = fieldRefCache[colName];
                     if (!cached) {
                         cached = fieldRefCache[colName] = {
                             __fieldName: colName,
                             __dbColumnName: dbColumnName,
                             __tableAlias: tableAlias,
-                            __chainId: chainId,
+                            __chainId: slots[MOCK_ROW_CHAIN_ID],
                             // Include mapper for toDriver transformation in conditions
                             __mapper: mapper,
                             // Column SQL type — lets flag* emit width-exact mask casts
@@ -3380,48 +3483,66 @@ ${joinClauses.join('\n')}`;
                 },
                 enumerable: true,
                 configurable: true,
-            });
+            };
         }
+        // Captured at descriptor-build time — identical for every row of this signature.
+        const manualJoins = this.manualJoins;
         // Add columns from manually joined tables
-        for (const join of this.manualJoins) {
+        for (const join of manualJoins) {
             // Skip subquery joins (they don't have a schema)
             if (join.isSubquery || !join.schema) {
                 continue;
             }
-            // Performance: Use pre-computed column name map for joined schema
-            const joinColumnNameMap = getColumnNameMapForSchema(join.schema);
-            if (!mock[join.alias]) {
-                mock[join.alias] = {};
-            }
-            // Lazy-cache for joined table
-            const joinFieldRefCache = {};
+            // The join sub-object is built lazily per row (its FieldRef cache and identity are
+            // row-scoped, exactly as the pre-prototype own-property sub-object was) and
+            // memoized in the row's navigation slot so repeated accesses share one object.
+            const joinSchema = join.schema;
             const joinAlias = join.alias;
-            for (const [colName, dbColumnName] of joinColumnNameMap) {
-                Object.defineProperty(mock[join.alias], colName, {
-                    get() {
-                        let cached = joinFieldRefCache[colName];
-                        if (!cached) {
-                            cached = joinFieldRefCache[colName] = {
-                                __fieldName: colName,
-                                __dbColumnName: dbColumnName,
-                                __tableAlias: joinAlias,
-                            };
+            descriptors[joinAlias] = {
+                get() {
+                    const slots = this;
+                    const navCache = slots[MOCK_ROW_NAV_CACHE] ?? (slots[MOCK_ROW_NAV_CACHE] = {});
+                    let sub = navCache[joinAlias];
+                    if (sub === undefined) {
+                        sub = navCache[joinAlias] = {};
+                        const joinColumnNameMap = getColumnNameMapForSchema(joinSchema);
+                        const joinFieldRefCache = {};
+                        for (const [colName, dbColumnName] of joinColumnNameMap) {
+                            Object.defineProperty(sub, colName, {
+                                get() {
+                                    let cached = joinFieldRefCache[colName];
+                                    if (!cached) {
+                                        cached = joinFieldRefCache[colName] = {
+                                            __fieldName: colName,
+                                            __dbColumnName: dbColumnName,
+                                            __tableAlias: joinAlias,
+                                        };
+                                    }
+                                    return cached;
+                                },
+                                enumerable: true,
+                                configurable: true,
+                            });
                         }
-                        return cached;
-                    },
-                    enumerable: true,
-                    configurable: true,
-                });
-            }
+                    }
+                    return sub;
+                },
+                enumerable: true,
+                configurable: true,
+            };
         }
         // Performance: Use pre-computed relation entries
         const relationEntries = getRelationEntriesForSchema(this.schema);
+        // Values captured at descriptor-build time — identical for every row of this
+        // signature (the registry is the process-wide schema registry).
+        const schemaRegistry = this.schemaRegistry;
+        const sourceTableName = this.schema.name;
         // Add relations as CollectionQueryBuilder or ReferenceQueryBuilder
         for (const [relName, relConfig] of relationEntries) {
             // Try to get target schema from registry (preferred, has full relations) or cached schema
             let targetSchema;
-            if (this.schemaRegistry) {
-                targetSchema = this.schemaRegistry.get(relConfig.targetTable);
+            if (schemaRegistry) {
+                targetSchema = schemaRegistry.get(relConfig.targetTable);
             }
             if (!targetSchema) {
                 // Performance: Use cached target schema
@@ -3429,36 +3550,36 @@ ${joinClauses.join('\n')}`;
             }
             if (relConfig.type === 'many') {
                 // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
-                Object.defineProperty(mock, relName, {
+                descriptors[relName] = {
                     get: () => {
-                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema, // Pass the target schema directly
-                        this.schemaRegistry, // Pass schema registry for nested resolution
+                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', sourceTableName, targetSchema, // Pass the target schema directly
+                        schemaRegistry, // Pass schema registry for nested resolution
                         undefined, relConfig.foreignKeys, // Propagate composite FK / literal predicates
                         relConfig.matches);
                     },
                     enumerable: false,
                     configurable: true,
-                });
+                };
             }
             else {
                 // For single reference (many-to-one), create a ReferenceQueryBuilder
                 // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
-                Object.defineProperty(mock, relName, {
+                descriptors[relName] = {
                     get: () => {
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema, // Pass the target schema directly
-                        this.schemaRegistry, // Pass schema registry for nested resolution
+                        schemaRegistry, // Pass schema registry for nested resolution
                         [], // Empty navigation path for first level navigation
-                        this.schema.name // Pass source table name for lateral join correlation
+                        sourceTableName // Pass source table name for lateral join correlation
                         );
                         // Return a mock object that exposes the target table's columns
                         return refBuilder.createMockTargetRow();
                     },
                     enumerable: false,
                     configurable: true,
-                });
+                };
             }
         }
-        return mock;
+        return descriptors;
     }
     /**
      * Create a proxy that wraps selected values and returns FieldRefs for property access
@@ -5503,7 +5624,7 @@ ${joinClauses.join('\n')}`;
             };
             // Analyze the selector to extract nested queries
             const mockRow = this._createMockRow();
-            const selectionResult = this.selector(mockRow);
+            const selectionResult = (0, exports.materializeMockSelection)(this.selector(mockRow));
             // Build the query
             const { sql } = this.buildQuery(selectionResult, context);
             // Update the outer context's param counter
@@ -5664,13 +5785,12 @@ class ReferenceQueryBuilder {
         // Build a mapper lookup for columns (only when needed)
         const columnMappers = {};
         const columnSqlTypes = {};
-        for (const [colName, colBuilder] of Object.entries(this.targetTableSchema.columns)) {
-            const config = colBuilder.build();
-            if (config.mapper) {
-                columnMappers[colName] = config.mapper;
+        for (const [colName, meta] of getSchemaColumnMeta(this.targetTableSchema)) {
+            if (meta.mapper) {
+                columnMappers[colName] = meta.mapper;
             }
-            if (config.type) {
-                columnSqlTypes[colName] = config.type;
+            if (meta.type) {
+                columnSqlTypes[colName] = meta.type;
             }
         }
         const sourceTable = this.targetTable; // Actual table name for schema lookup
@@ -5877,74 +5997,16 @@ class CollectionQueryBuilder {
             return this._cachedMockItem;
         }
         if (this.targetTableSchema) {
-            // If we have schema information, create a properly typed mock
-            const mock = {};
-            // Performance: Use pre-computed column name map if available
-            const columnNameMap = getColumnNameMapForSchema(this.targetTableSchema);
-            // Performance: Lazy-cache FieldRef objects
-            const fieldRefCache = {};
-            // Add columns - include tableAlias for unambiguous column references in WHERE clauses
-            // Use a special marker alias for the collection's own table that can be rewritten later
-            // This allows distinguishing between outer table references and inner collection references
-            // when both target the same table (e.g., post.user.posts where both are "posts" table)
-            const tableAlias = `__collection_${this.targetTable}__`;
-            for (const [colName, dbColumnName] of columnNameMap) {
-                Object.defineProperty(mock, colName, {
-                    get() {
-                        let cached = fieldRefCache[colName];
-                        if (!cached) {
-                            cached = fieldRefCache[colName] = {
-                                __fieldName: colName,
-                                __dbColumnName: dbColumnName,
-                                __tableAlias: tableAlias, // Include table alias for unambiguous references
-                            };
-                        }
-                        return cached;
-                    },
-                    enumerable: true,
-                    configurable: true,
-                });
-            }
-            // Add navigation properties (both collections and references)
-            if (this.targetTableSchema.relations) {
-                for (const [relName, relConfig] of Object.entries(this.targetTableSchema.relations)) {
-                    if (relConfig.type === 'many') {
-                        // Collection navigation
-                        // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
-                        Object.defineProperty(mock, relName, {
-                            get: () => {
-                                // Don't call build() - it returns schema without relations
-                                const fk = relConfig.foreignKey || relConfig.foreignKeys?.[0] || '';
-                                return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, this.targetTable, undefined, // Don't pass schema, force registry lookup
-                                this.schemaRegistry, // Pass schema registry for nested resolution
-                                // No navigation path needed here - direct collection access from parent
-                                undefined, relConfig.foreignKeys, // Propagate composite FK / literal predicates
-                                relConfig.matches);
-                            },
-                            enumerable: false,
-                            configurable: true,
-                        });
-                    }
-                    else {
-                        // Reference navigation
-                        // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
-                        Object.defineProperty(mock, relName, {
-                            get: () => {
-                                // Don't call build() - it returns schema without relations
-                                // Instead, pass undefined and let ReferenceQueryBuilder look it up from registry
-                                const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, undefined, // Don't pass schema, force registry lookup
-                                this.schemaRegistry, // Pass schema registry for nested resolution
-                                [], // Empty navigation path - this is the first reference in the chain
-                                this.targetTable // Source alias is this collection's target table
-                                );
-                                return refBuilder.createMockTargetRow();
-                            },
-                            enumerable: false,
-                            configurable: true,
-                        });
-                    }
-                }
-            }
+            // Prototype-level cache — same pattern as the root mock and
+            // ReferenceQueryBuilder.createMockTargetRow (see MockRowCache): the getters are
+            // fully determined by the target schema, so every collection item mock of the same
+            // table shares one prebuilt prototype and a new item is `Object.create` plus its
+            // FieldRef slot — O(1) instead of one property definition per column+relation per
+            // `.where()`/`.select()`/`.orderBy()` call. Opt-in via the same static switch; OFF
+            // = fresh prototype per item (the pre-0.4.70 behaviour).
+            const prototype = mock_row_cache_1.MockRowCache.getOrBuild(`citem|${this.targetTable}`, () => Object.defineProperties({}, this.buildMockItemDescriptors()));
+            const mock = Object.create(prototype);
+            mock[MOCK_ROW_FIELD_REFS] = {};
             // Cache the mock for reuse
             this._cachedMockItem = mock;
             return mock;
@@ -5954,6 +6016,85 @@ class CollectionQueryBuilder {
             return createNestedFieldRefProxy(this.targetTable);
         }
     }
+    /**
+     * Builds the shared property-descriptor map for {@link createMockItem}'s cached path.
+     * The getters read per-row state through `this`-bound symbol slots; values captured at
+     * build time are signature-constants identical for every item mock of the table.
+     */
+    buildMockItemDescriptors() {
+        // Performance: Use pre-computed column name map if available
+        const columnNameMap = getColumnNameMapForSchema(this.targetTableSchema);
+        // Add columns - include tableAlias for unambiguous column references in WHERE clauses
+        // Use a special marker alias for the collection's own table that can be rewritten later
+        // This allows distinguishing between outer table references and inner collection references
+        // when both target the same table (e.g., post.user.posts where both are "posts" table)
+        const tableAlias = `__collection_${this.targetTable}__`;
+        const descriptors = {};
+        for (const [colName, dbColumnName] of columnNameMap) {
+            descriptors[colName] = {
+                get() {
+                    const slots = this;
+                    const fieldRefCache = slots[MOCK_ROW_FIELD_REFS] ?? (slots[MOCK_ROW_FIELD_REFS] = {});
+                    let cached = fieldRefCache[colName];
+                    if (!cached) {
+                        cached = fieldRefCache[colName] = {
+                            __fieldName: colName,
+                            __dbColumnName: dbColumnName,
+                            __tableAlias: tableAlias, // Include table alias for unambiguous references
+                        };
+                    }
+                    return cached;
+                },
+                enumerable: true,
+                configurable: true,
+            };
+        }
+        // Values captured at descriptor-build time — identical for every item of this
+        // signature (the registry is the process-wide schema registry).
+        const targetTable = this.targetTable;
+        const schemaRegistry = this.schemaRegistry;
+        // Add navigation properties (both collections and references)
+        if (this.targetTableSchema.relations) {
+            for (const [relName, relConfig] of Object.entries(this.targetTableSchema.relations)) {
+                if (relConfig.type === 'many') {
+                    // Collection navigation
+                    // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
+                    descriptors[relName] = {
+                        get: () => {
+                            // Don't call build() - it returns schema without relations
+                            const fk = relConfig.foreignKey || relConfig.foreignKeys?.[0] || '';
+                            return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, targetTable, undefined, // Don't pass schema, force registry lookup
+                            schemaRegistry, // Pass schema registry for nested resolution
+                            // No navigation path needed here - direct collection access from parent
+                            undefined, relConfig.foreignKeys, // Propagate composite FK / literal predicates
+                            relConfig.matches);
+                        },
+                        enumerable: false,
+                        configurable: true,
+                    };
+                }
+                else {
+                    // Reference navigation
+                    // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
+                    descriptors[relName] = {
+                        get: () => {
+                            // Don't call build() - it returns schema without relations
+                            // Instead, pass undefined and let ReferenceQueryBuilder look it up from registry
+                            const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, undefined, // Don't pass schema, force registry lookup
+                            schemaRegistry, // Pass schema registry for nested resolution
+                            [], // Empty navigation path - this is the first reference in the chain
+                            targetTable // Source alias is this collection's target table
+                            );
+                            return refBuilder.createMockTargetRow();
+                        },
+                        enumerable: false,
+                        configurable: true,
+                    };
+                }
+            }
+        }
+        return descriptors;
+    }
     /**
      * Limit collection items
      */
@@ -6524,6 +6665,19 @@ class CollectionQueryBuilder {
      * Uses BFS to find the shortest path through the schema graph
      */
     findNavigationPath(targetAlias, joinedSchemas, _startSchema) {
+        if (!this.schemaRegistry) {
+            return [];
+        }
+        // Memoised per registry — the BFS below depends only on the target alias and the ORDERED
+        // joined alias→table pairs (order decides which of several equal-length paths wins), so
+        // the same query shape resolves to the same path on every build. See NavigationPathCache.
+        const signature = `${targetAlias}|${[...joinedSchemas]
+            .map(([alias, schema]) => `${alias}:${schema.schema ?? ''}.${schema.name}`)
+            .join(',')}`;
+        return navigation_path_cache_1.NavigationPathCache.getOrBuild(this.schemaRegistry, signature, () => this.computeNavigationPath(targetAlias, joinedSchemas));
+    }
+    /** The uncached BFS behind {@link findNavigationPath}. */
+    computeNavigationPath(targetAlias, joinedSchemas) {
         if (!this.schemaRegistry) {
             return [];
         }
@@ -6745,7 +6899,7 @@ class CollectionQueryBuilder {
         // (field collection, aggregate-expression discovery, navigation-join detection) all
         // need to walk the same selection, and re-invoking the selector is expensive
         // (rebuilds proxy mocks and any nested CollectionQueryBuilder instances).
-        const selectorResult = this.selector ? this.selector(this.createMockItem()) : undefined;
+        const selectorResult = this.selector ? (0, exports.materializeMockSelection)(this.selector(this.createMockItem())) : undefined;
         // Step 1: Build field selection configuration
         if (this.selector) {
             const selectedFields = selectorResult;
@@ -6822,9 +6976,8 @@ class CollectionQueryBuilder {
             let dbToPropertyMap = null;
             if (this.targetTableSchema) {
                 dbToPropertyMap = new Map();
-                for (const [propName, colBuilder] of Object.entries(this.targetTableSchema.columns)) {
-                    const config = colBuilder.build();
-                    dbToPropertyMap.set(config.name, propName);
+                for (const [propName, meta] of getSchemaColumnMeta(this.targetTableSchema)) {
+                    dbToPropertyMap.set(meta.name, propName);
                 }
             }
             const orderPartsDb = this.orderByFields.map(({ field, direction }) => {