@@ -2101,6 +2101,35 @@ export class ObjectQL implements IObjectQLEngine {
     return SecurityResolversFacet.serveFormulaField.call(securityResolversHost.of(this), objectName, record, field, context);
   }
 
+  /**
+   * [#29961] The values `object`'s stored computed fields ({@link planStoredExpressions})
+   * take over rows ALREADY stored, computed and served exactly as a write
+   * computes them: the declared option labels, the one hop, and the `can()`
+   * map, under `context`. Index-aligned with `rows`, keyed by every stored
+   * computed field the object declares; evaluated over copies, writes nothing.
+   *
+   * For a row that never went through a write since its field was declared —
+   * `os migrate stored-expressions` (`stored-expression-backfill.ts`) and the
+   * boot advisory it shares. A field that does not evaluate computes `null`,
+   * the write's answer, and is told to `onFault` when given (else the engine's
+   * once-per-field report).
+   */
+  async computeStoredExpressionsOver(
+    object: string,
+    rows: ReadonlyArray<Record<string, unknown>>,
+    context?: ExecutionContext,
+    onFault?: (field: string, message: string) => void,
+  ): Promise<Array<Record<string, unknown>>> {
+    const schema = this._registry.getObject(object);
+    const resolution = this.permissionResolution(context);
+    return computeStoredExpressions(planStoredExpressions(schema), rows, context, {
+      permissionsFor: (plan, records) => this.resolveFormulaPermissions(object, plan, records, context, resolution),
+      onFault: onFault ? (field, error) => onFault(field, error.message) : this.formulaFaultSink(object),
+      relatedFor: (plan, records) => this.resolveFormulaRelated(schema, plan, records, context),
+      optionLabelsFor: (plan) => declaredOptionLabels(schema, plan),
+    });
+  }
+
   private formulaOptionLabels(
     schema: unknown,
     plan: FormulaPlanEntry[],
 
@@ -531,6 +531,26 @@ export type {
     SummaryBackfillLogger,
     SummaryBackfillOptions,
 } from './summary-backfill.js';
+// [#29961] The backfill behind `os migrate stored-expressions`: stored computed
+// fields over rows no write has computed since the field was declared, and the
+// boot advisory naming it. Same split as the roll-up backfill above.
+export {
+    backfillStoredExpressions,
+    formatStoredExpressionBackfillReport,
+    storedExpressionBackfillComplete,
+    announceStoredExpressionHoles,
+    sampleStoredExpressionHoles,
+} from './stored-expression-backfill.js';
+export type {
+    StoredExpressionBackfillReport,
+    StoredExpressionBackfillFieldOutcome,
+    StoredExpressionBackfillFailure,
+    StoredExpressionFault,
+    StoredExpressionBackfillEngine,
+    StoredExpressionBackfillLogger,
+    StoredExpressionBackfillOptions,
+    StoredExpressionHoleSample,
+} from './stored-expression-backfill.js';
 // [ADR-0144, ruling 6492000994] The explicit code backfill behind
 // `os migrate record-currency-codes`: rows stored before an amount switched to
 // `currencyMode: 'record'`. Same split as the roll-up backfill above.
 
@@ -34,6 +34,7 @@ import { applyProtection } from '@objectstack/spec/shared';
 import { isFederatedObject } from './federated-object.js';
 // [#22070] The builtin audit stamps are wrapped like a bound hook but registered in code.
 import { wrapDeclarativeHook } from './hook-wrappers.js';
+import { announceStoredExpressionHoles } from './stored-expression-backfill.js';
 import { LifecycleService } from './lifecycle/lifecycle-service.js';
 import { lifecycleSettingsManifest } from './lifecycle/lifecycle-settings.js';
 import type { DanglingReferenceAuditOptions } from './integrity/dangling-reference-audit.js';
@@ -1196,6 +1197,13 @@ export class ObjectQLPlugin implements Plugin {
         );
         if (unservable) throw unservable;
         await this.ql?.announceOpenMigrationGates();
+        // [#29961] A stored computed field declared on an object that already
+        // held rows is NULL on them until each is next written: name the
+        // fields and `os migrate stored-expressions`. Here, beside the gate
+        // advisory, for its reason: schema sync has run and every object is
+        // registered. A bounded sample read that writes nothing and never fails
+        // the boot (`stored-expression-backfill.ts`).
+        if (this.ql) await announceStoredExpressionHoles(this.ql, ctx.logger);
     });
     ctx.hook('metadata:reloaded', async (payload?: unknown) => {
         await this.resyncAuthoredHooks(ctx);