@memberjunction/core 6.1.0-edge.0 → 6.1.0-edge.2

package/dist/generic/localCacheManager.d.ts

@@ -64,7 +64,18 @@ export interface CacheStats {
  * to prevent data inconsistency.
  */
 export interface CachedRunViewData {
-    /** The cached result rows */
+    /**
+     * The cached result rows.
+     *
+     * ⚠️ These rows are SHARED: under a reference-sharing storage provider (see
+     * `ILocalStorageProvider.SharesReferences`) they are the same objects held by every reader
+     * of this slot, and they are deep-frozen at write time. Mutating one corrupts process-wide
+     * state and throws a `TypeError`. Build a new array / new rows instead.
+     *
+     * Deliberately typed mutable rather than `readonly`: the runtime freeze is the enforcement,
+     * and a `readonly` marker here would be a compile break for existing downstream code that
+     * reads cache entries — without adding protection the freeze does not already provide.
+     */
     results: unknown[];
     /** The maximum __mj_UpdatedAt timestamp from the results */
     maxUpdatedAt: string;
@@ -79,13 +90,24 @@ export interface CachedRunViewData {
      * Backward-compatible: entries without this field are served normally (no regression).
      */
     schemaHash?: string;
+    /**
+     * Set when the slot was written with {@link CacheWriteOptions.ProviderInternalScaffolding}.
+     * Persisted so that in-place slot maintenance (`storeCachedResults`, driven by BaseEntity
+     * save/delete events) can carry the exemption FORWARD. Without it, the first save event
+     * touching a scaffolding slot would freeze it and break the owner that mutates those rows.
+     */
+    providerInternalScaffolding?: boolean;
 }
 /**
  * Return type for GetRunViewResult and ApplyDifferentialUpdate.
  * Includes rowCount (derived from results.length) and totalRowCount (from the database).
  */
 export interface CachedRunViewResult {
-    /** The cached result rows */
+    /**
+     * The cached result rows — shared and deep-frozen; see {@link CachedRunViewData.results}.
+     * Callers that need to transform rows (e.g. GraphQL transport field renaming) must map
+     * onto copies: `results.map(r => ({ ...r }))`.
+     */
     results: unknown[];
     /** The maximum __mj_UpdatedAt timestamp from the results */
     maxUpdatedAt: string;
@@ -102,6 +124,36 @@ export interface CachedRunViewResult {
      * permanently disabling post-migration drift detection for that slot.
      */
     schemaHash?: string;
+    /**
+     * Surfaced from the stored payload so in-place maintenance can carry the freeze exemption
+     * forward. See {@link CachedRunViewData.providerInternalScaffolding}.
+     */
+    providerInternalScaffolding?: boolean;
+}
+/**
+ * Per-write options for the cache write methods.
+ */
+export interface CacheWriteOptions {
+    /**
+     * Declares that this slot is **provider-internal scaffolding**: the provider doing the
+     * write is its only consumer, and the rows are transient input to that provider's own
+     * assembly step rather than data served to arbitrary callers.
+     *
+     * Such slots are exempt from the defensive deep-freeze. The freeze exists to stop
+     * *consumers* from corrupting shared rows they were handed; it buys nothing for rows with
+     * a single owner, and it would break owners that legitimately use those rows as scratch
+     * space.
+     *
+     * The motivating case is metadata bootstrap: `GetDatasetByName` caches each dataset item
+     * through this cache, and `PostProcessEntityMetadata` then hydrates a graph by sorting the
+     * row array in place and attaching child collections onto each entity/field row. Freezing
+     * those rows makes `GetAllMetadata()` throw and the process boots with no metadata at all.
+     *
+     * **Do not set this to avoid fixing a mutation.** If the rows reach anything other than
+     * the writing provider, the correct fix is for the mutator to copy first. Defaults to
+     * `false` — caller-facing results are always frozen.
+     */
+    ProviderInternalScaffolding?: boolean;
 }
 /**
  * Configuration for the LocalCacheManager
@@ -248,6 +300,12 @@ export declare class LocalCacheManager extends BaseSingleton<LocalCacheManager>
      */
     static get Instance(): LocalCacheManager;
     private _storageProvider;
+    /**
+     * Whether the active storage provider hands back live object references, resolved once at
+     * initialization — from the provider's declared {@link ILocalStorageProvider.SharesReferences}
+     * when it states one, otherwise measured empirically. Gates the defensive deep-freeze.
+     */
+    private _sharesReferences;
     private _registry;
     private _initialized;
     private _initializePromise;
@@ -280,6 +338,23 @@ export declare class LocalCacheManager extends BaseSingleton<LocalCacheManager>
      * @returns A promise that resolves when initialization is complete
      */
     Initialize(storageProvider: ILocalStorageProvider, config?: Partial<LocalCacheManagerConfig>): Promise<void>;
+    /**
+     * Decides whether the storage provider hands back live object references — the condition
+     * that makes the defensive deep-freeze necessary.
+     *
+     * Prefers the provider's declared {@link ILocalStorageProvider.SharesReferences}. When a
+     * provider does not state one (any implementation written before that property existed),
+     * MEASURE it rather than guessing: store a sentinel object, read it back, and compare
+     * identity. A reference-sharing store returns the very same object; anything with a
+     * serialization or structured-clone boundary returns a copy. This is what keeps the
+     * property optional — an external provider that never declares it still gets the correct
+     * protection instead of silently losing it to a falsy default.
+     *
+     * Fails closed to `false` if the probe cannot complete (a provider whose backing store is
+     * not ready at init): that matches the pre-freeze behavior rather than immobilizing rows
+     * for a provider we could not classify.
+     */
+    private resolveSharesReferences;
     /**
      * Internal initialization logic - only called once by the first caller
      */
@@ -609,7 +684,8 @@ export declare class LocalCacheManager extends BaseSingleton<LocalCacheManager>
      *
      * @param name - The dataset name
      * @param itemFilters - Optional filters applied to the dataset
-     * @param dataset - The dataset result to cache
+     * @param dataset - The dataset result to cache. Deep-frozen on reference-sharing storage,
+     *                  like every other cache write funnel — see below.
      * @param keyPrefix - Prefix for the cache key (typically includes connection info)
      */
     SetDataset(name: string, itemFilters: DatasetItemFilterType[] | undefined, dataset: DatasetResultType, keyPrefix: string): Promise<void>;
@@ -669,7 +745,7 @@ export declare class LocalCacheManager extends BaseSingleton<LocalCacheManager>
      *   pre-RLS format so normal cache sharing is preserved and no existing entries are invalidated.
      * @returns A unique, human-readable fingerprint string
      */
-    GenerateRunViewFingerprint(params: RunViewParams, connectionPrefix?: string, rlsWhereClause?: string): string;
+    GenerateRunViewFingerprint(params: RunViewParams, connectionPrefix?: string, rlsWhereClause?: string, datasetSegment?: string): string;
     /**
      * Generates a hash string representing the aggregate expressions.
      * This ensures different aggregate configurations get different fingerprints.
@@ -711,6 +787,41 @@ export declare class LocalCacheManager extends BaseSingleton<LocalCacheManager>
      * @returns The schema hash string, or undefined if the entity can't be resolved
      */
     ComputeSchemaHash(provider: IMetadataProvider | undefined, entityName: string): string | undefined;
+    /**
+     * Deep-freezes an about-to-be-stored cache payload when — and only when — the active
+     * storage provider hands out live object references
+     * ({@link ILocalStorageProvider.SharesReferences}).
+     *
+     * This is the cache's structural defense against consumer corruption. Under a
+     * reference-sharing provider the rows a caller receives ARE the cached rows, in both
+     * directions: on a hit the reader gets the stored array, and on a miss the cache stored
+     * the caller's own array. Any in-place mutation therefore edits process-wide state. One
+     * such mutation shipped as a P1 (a resolver renamed `__mj_CreatedAt` to its GraphQL
+     * transport alias in place, so every later read served rows `BaseEntity.SetMany`
+     * rejects). Freezing makes that failure immediate and attributable — a `TypeError` at
+     * the offending line — instead of silent corruption, and costs nothing per cache hit.
+     *
+     * On serializing providers this is a no-op: their stored data is already isolated, and
+     * freezing would only immobilize the caller's own rows for no safety gain.
+     *
+     * @param payload - The envelope being handed to the storage provider. Frozen in place;
+     *                  the same reference is returned for call-site convenience.
+     */
+    /**
+     * Whether the CURRENTLY-INSTALLED provider hands back live references.
+     *
+     * Prefers the active provider's own declaration, read live on each call — a property read,
+     * so it costs nothing on the write path, and it stays correct no matter how many times the
+     * provider is swapped or which code path does the swapping. `_sharesReferences` (resolved at
+     * `Initialize`/`SetStorageProvider`) is the fallback for providers that declare nothing, where
+     * the answer can only come from the async probe and therefore cannot be recomputed here.
+     *
+     * Belt-and-braces with the re-resolution in {@link SetStorageProvider}: that keeps the probed
+     * value correct across swaps, and this keeps DECLARED providers correct even if some future
+     * swap site forgets to re-resolve.
+     */
+    private activeProviderSharesReferences;
+    private freezeRowDataIfProviderSharesReferences;
     /**
      * Stores a RunView result in the cache.
      *
@@ -727,8 +838,11 @@ export declare class LocalCacheManager extends BaseSingleton<LocalCacheManager>
      *   AllowCaching gating in multi-provider scenarios (parallel client connections to multiple
      *   servers). Falls back to `Metadata.Provider` (global default) when omitted, which is fine
      *   for single-provider apps but wrong when AllowCaching differs across servers.
+     * @param ttlMs - Optional time-based expiry (required for external-data-source entities).
+     * @param options - See {@link CacheWriteOptions}. Pass `{ ProviderInternalScaffolding: true }`
+     *   only for slots the writing provider is the sole consumer of.
      */
-    SetRunViewResult(fingerprint: string, params: RunViewParams, results: unknown[], maxUpdatedAt: string, aggregateResults?: AggregateResult[], totalRowCount?: number, provider?: IMetadataProvider, ttlMs?: number): Promise<void>;
+    SetRunViewResult(fingerprint: string, params: RunViewParams, results: unknown[], maxUpdatedAt: string, aggregateResults?: AggregateResult[], totalRowCount?: number, provider?: IMetadataProvider, ttlMs?: number, options?: CacheWriteOptions): Promise<void>;
     /**
      * Retrieves a cached RunView result.
      *
@@ -887,6 +1001,10 @@ export declare class LocalCacheManager extends BaseSingleton<LocalCacheManager>
      * @returns The cached results, maxUpdatedAt, rowCount, and queryId, or null if not found
      */
     GetRunQueryResult(fingerprint: string): Promise<{
+        /**
+         * The cached result rows — shared and deep-frozen under a reference-sharing storage
+         * provider, exactly like {@link CachedRunViewData.results}. Do not mutate.
+         */
         results: unknown[];
         maxUpdatedAt: string;
         rowCount: number;

package/dist/generic/localCacheManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localCacheManager.d.ts","sourceRoot":"","sources":["../../src/generic/localCacheManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAyB,MAAM,wBAAwB,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACnI,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtE,OAAO,EAAc,eAAe,EAAE,MAAM,cAAc,CAAC;AAE3D,OAAO,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAW5D;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,kBAAkB;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,0BAA0B;IAC1B,IAAI,EAAE,cAAc,CAAC;IACrB,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,sBAAsB;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,qCAAqC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,cAAc,EAAE,MAAM,CAAC;IACvB,oCAAoC;IACpC,MAAM,EAAE,MAAM,CAAC,cAAc,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACrE,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAC9B,6BAA6B;IAC7B,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,4DAA4D;IAC5D,YAAY,EAAE,MAAM,CAAC;IACrB,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;IACrC,+FAA+F;IAC/F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAChC,6BAA6B;IAC7B,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,4DAA4D;IAC5D,YAAY,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;IACrC,yFAAyF;IACzF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC,iCAAiC;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,mDAAmD;IACnD,YAAY,EAAE,MAAM,CAAC;IACrB,0FAA0F;IAC1F,YAAY,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,cAAc,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IACvC;;;;OAIG;IACH,0BAA0B,EAAE,MAAM,CAAC;IACnC;;;;;;;;;OASG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAC/B;;;;;OAKG;IACH,uBAAuB,EAAE,MAAM,CAAC;IAChC;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAC;CAC3B;AAqBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,iBAAiB;IAC9B;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;;OAKG;IACH,MAAM,EAAE,KAAK,GAAG,SAAS,GAAG,kBAAkB,CAAC;IAE/C;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAMD;;;GAGG;AACH,eAAO,MAAM,aAAa;IACtB,gCAAgC;;IAEhC,iCAAiC;;IAEjC,gCAAgC;;IAEhC,yBAAyB;;IAEzB,8CAA8C;;CAExC,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAM7E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,iBAAkB,SAAQ,aAAa,CAAC,iBAAiB,CAAC;IACnE;;OAEG;IACH,WAAkB,QAAQ,IAAI,iBAAiB,CAE9C;IAED,OAAO,CAAC,gBAAgB,CAAsC;IAC9D,OAAO,CAAC,SAAS,CAA0C;IAC3D,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,kBAAkB,CAA8B;IACxD,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,OAAO,CAAkD;IAEjE;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB,CAAoC;IAE7D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA2B;IAExD;;;;OAIG;IACH,OAAO,CAAC,uBAAuB,CAAuC;IAEtE,SAAS;IAQT;;;;;;;;;;OAUG;IACI,UAAU,CACb,eAAe,EAAE,qBAAqB,EACtC,MAAM,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC,GAC1C,OAAO,CAAC,IAAI,CAAC;IAiBhB;;OAEG;YACW,YAAY;IAoB1B;;OAEG;IACH,IAAW,aAAa,IAAI,OAAO,CAElC;IAED;;OAEG;IACH,IAAW,MAAM,IAAI,uBAAuB,CAE3C;IAED;;OAEG;IACI,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,uBAAuB,CAAC,GAAG,IAAI;IAInE;;;;;;OAMG;IACI,yBAAyB,CAAC,UAAU,EAAE;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO;IAIhF;;;;;;;;;OASG;IACU,kBAAkB,CAAC,WAAW,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqClF;;;;;;;;;OASG;IACH,SAAS,CAAC,4BAA4B,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAK1E;;;;;OAKG;IACH,SAAS,CAAC,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAS7D;;;;;;;;;;;;;;;;;;OAkBG;IACH,SAAS,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO;IAM9C;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO;IAMjD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO;IAMjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO;IA6BvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,SAAS,CAAC,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAa3D;;;;;;;OAOG;IACH,OAAO,CAAC,uBAAuB;IAoB/B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IASxB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAY7B;;;OAGG;IACI,wBAAwB,CAAC,UAAU,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;IAIxE;;;;;;OAMG;YACW,4BAA4B;IA0B1C;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;IA2BnC;;;;;;;OAOG;cACa,qBAAqB,CAAC,WAAW,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA4DlF;;;;;OAKG;cACa,2BAA2B,CAAC,WAAW,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAqHxF;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAWjC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAKhC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAO;IAE5C;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IASnB,iHAAiH;IACjH,OAAO,CAAC,wBAAwB;IAUhC;;;OAGG;YACW,gCAAgC;IAyC9C;;;;OAIG;IACH,OAAO,CAAC,gBAAgB,CAAmE;IAE3F;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,sBAAsB,CACzB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC7C,MAAM,IAAI;IAiBb;;;;;;;;;;;;;OAaG;IACI,mBAAmB,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAgC1D;;;OAGG;IACH,IAAW,mBAAmB,IAAI,MAAM,CAEvC;IAMD;;;;;;;OAOG;IACU,UAAU,CACnB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,qBAAqB,EAAE,GAAG,SAAS,EAChD,OAAO,EAAE,iBAAiB,EAC1B,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC;IAiChB;;;;;;;OAOG;IACU,UAAU,CACnB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,qBAAqB,EAAE,GAAG,SAAS,EAChD,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAsBpC;;;;;;;OAOG;IACU,mBAAmB,CAC5B,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,qBAAqB,EAAE,GAAG,SAAS,EAChD,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAevB;;;;;;OAMG;IACU,YAAY,CACrB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,qBAAqB,EAAE,GAAG,SAAS,EAChD,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC;IAchB;;;;;;;OAOG;IACU,eAAe,CACxB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,qBAAqB,EAAE,GAAG,SAAS,EAChD,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,OAAO,CAAC;IAiBnB;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,0BAA0B,CAAC,MAAM,EAAE,aAAa,EAAE,gBAAgB,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM;IAgGpH;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAc7B;;;;;;;;;;;;;;;OAeG;IACI,gCAAgC,CACnC,aAAa,EAAE,eAAe,EAAE,GAAG,SAAS,EAC5C,mBAAmB,EAAE,mBAAmB,EAAE,GAAG,SAAS,GACvD,eAAe,EAAE,GAAG,SAAS;IAyBhC;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAUlB;;;;;;;OAOG;IACI,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAczG;;;;;;;;;;;;;;;;OAgBG;IACU,gBAAgB,CACzB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,OAAO,EAAE,EAClB,YAAY,EAAE,MAAM,EACpB,gBAAgB,CAAC,EAAE,eAAe,EAAE,EACpC,aAAa,CAAC,EAAE,MAAM,EACtB,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,KAAK,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAiIhB;;;;;;;OAOG;IACU,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAcvF;;;;;;;;;;;;;;;;;;;;OAoBG;IACU,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAC,CAAC;IAyBxG;;;;;;;;OAQG;IACH,OAAO,CAAC,8BAA8B;IA0CtC;;;;OAIG;IACU,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxE;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,uBAAuB,CAChC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,OAAO,EAAE,EACtB,gBAAgB,EAAE,MAAM,EAAE,EAC1B,mBAAmB,EAAE,MAAM,EAC3B,eAAe,EAAE,MAAM,EACvB,cAAc,CAAC,EAAE,MAAM,EACvB,gBAAgB,CAAC,EAAE,eAAe,EAAE,EACpC,QAAQ,CAAC,EAAE,iBAAiB,GAC7B,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAqHtC;;;;;;;;;;OAUG;YACW,mBAAmB;IAmBjC;;;;;;OAMG;IACU,kBAAkB,CAC3B,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,GAAG,EAAE,YAAY,EACjB,eAAe,EAAE,MAAM,GACxB,OAAO,CAAC,OAAO,CAAC;IAuCnB;;;;;;;;OAQG;IACU,kBAAkB,CAC3B,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,YAAY,EACjB,eAAe,EAAE,MAAM,GACxB,OAAO,CAAC,OAAO,CAAC;IAuCnB;;;;;;;;;;;;;OAaG;YACW,kBAAkB;IAkDhC;;;;;OAKG;IACU,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA2BtE;;;;;;;;;;;OAWG;IACI,2BAA2B,CAC9B,OAAO,CAAC,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,gBAAgB,CAAC,EAAE,MAAM,EACzB,YAAY,CAAC,EAAE,MAAM,GACtB,MAAM;IAwBT;;;;;;;;;;OAUG;IACU,iBAAiB,CAC1B,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,EAAE,EAClB,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,EAChB,KAAK,CAAC,EAAE,MAAM,EACd,eAAe,CAAC,EAAE,MAAM,GACzB,OAAO,CAAC,IAAI,CAAC;IAgDhB;;;;;OAKG;IACU,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;QACzD,OAAO,EAAE,OAAO,EAAE,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,uFAAuF;QACvF,eAAe,CAAC,EAAE,MAAM,CAAC;KAC5B,GAAG,IAAI,CAAC;IA+CT;;;;OAIG;IACU,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWzE;;;;;OAKG;IACU,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwBpE;;;;;;OAMG;IACU,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;QAC9D,YAAY,EAAE,MAAM,CAAC;QACrB,QAAQ,EAAE,MAAM,CAAC;KACpB,GAAG,IAAI,CAAC;IAcT;;OAEG;IACI,aAAa,IAAI,cAAc,EAAE;IAIxC;;;;OAIG;IACI,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,cAAc,EAAE;IAI/D;;OAEG;IACI,QAAQ,IAAI,UAAU;IAyB7B;;OAEG;IACI,UAAU,IAAI,MAAM;IAS3B;;;;;OAKG;IACU,WAAW,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;IAsB/D;;;;OAIG;IACU,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC;IAsBxC;;OAEG;IACI,UAAU,IAAI,IAAI;IAQzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAa1B;;OAEG;IACH,OAAO,CAAC,eAAe;IAWvB;;OAEG;IACH,OAAO,CAAC,aAAa;IAMrB;;OAEG;IACH,OAAO,CAAC,eAAe;IAKvB;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;OAEG;YACW,YAAY;IAsB1B,OAAO,CAAC,eAAe,CAA8C;IAErE;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAShC;;OAEG;YACW,eAAe;IAW7B;;OAEG;IACH,OAAO,CAAC,YAAY;IAKpB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,mBAAmB;IAqC3B;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAM3B;;OAEG;YACW,aAAa;IAe3B;;OAEG;YACW,KAAK;IAoDnB;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAMjC;;;;;OAKG;YACW,2BAA2B;IAuCzC;;OAEG;IACH,OAAO,CAAC,WAAW,CAA+C;IAElE;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAkB1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;;OAGG;YACW,gBAAgB;CAyCjC"}
+{"version":3,"file":"localCacheManager.d.ts","sourceRoot":"","sources":["../../src/generic/localCacheManager.ts"],"names":[],"mappings":"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"}

package/dist/generic/localCacheManager.js

@@ -7,6 +7,50 @@ import { CompositeKey, KeyValuePair } from "./compositeKey.js";
 function LogStatusVerbose(message) {
     LogStatusEx({ message, verboseOnly: true });
 }
+/**
+ * Recursively freezes a value that is about to enter the cache, so consumers holding the
+ * same reference cannot mutate shared state.
+ *
+ * Only invoked when the storage provider reports
+ * {@link ILocalStorageProvider.SharesReferences} — a serializing backend (IndexedDB,
+ * localStorage, Redis, MMKV) already isolates stored data, and freezing there would
+ * needlessly immobilize the caller's own rows.
+ *
+ * Freezing the ARRAY matters as much as the rows: `results.sort()` / `.push()` on a live
+ * cache array silently reorders or grows the cached slot for every later reader.
+ *
+ * Freezes BEFORE recursing, so the `isFrozen` short-circuit both skips already-frozen
+ * subtrees (cheap re-entry for in-place slot maintenance, which carries existing rows
+ * forward by reference) and terminates cycles.
+ *
+ * Two value kinds are skipped, not frozen — accepted residuals:
+ * - Binary payloads (`Buffer`/TypedArray/`ArrayBuffer`, e.g. `varbinary` columns): the spec
+ *   makes `Object.freeze` THROW on a non-empty view, so attempting it would turn a cache
+ *   write into a crash.
+ * - `Date` internal slots: `Object.freeze` cannot protect them — `setHours` and friends
+ *   still work.
+ */
+function deepFreezeCacheValue(value, visited = new WeakSet()) {
+    if (value === null || typeof value !== 'object'
+        || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+        return value;
+    }
+    // Cycle termination and re-entry short-circuit key off an explicit visited set rather than
+    // `Object.isFrozen`. Those are not the same test: an object frozen SHALLOWLY by someone else
+    // (a caller that ran `Object.freeze(row)` before handing it over) reports frozen while its
+    // nested values are still writable, so keying off isFrozen would skip the whole subtree and
+    // leave shared state mutable. Already-frozen objects are cheap to re-freeze; unvisited
+    // children are the thing that must not be skipped.
+    if (visited.has(value)) {
+        return value;
+    }
+    visited.add(value);
+    Object.freeze(value);
+    for (const nested of Object.values(value)) {
+        deepFreezeCacheValue(nested, visited);
+    }
+    return value;
+}
 // ============================================================================
 // DEFAULT CONFIGURATION
 // ============================================================================
@@ -76,6 +120,12 @@ export class LocalCacheManager extends BaseSingleton {
     constructor() {
         super();
         this._storageProvider = null;
+        /**
+         * Whether the active storage provider hands back live object references, resolved once at
+         * initialization — from the provider's declared {@link ILocalStorageProvider.SharesReferences}
+         * when it states one, otherwise measured empirically. Gates the defensive deep-freeze.
+         */
+        this._sharesReferences = false;
         this._registry = new Map();
         this._initialized = false;
         this._initializePromise = null;
@@ -138,14 +188,64 @@ export class LocalCacheManager extends BaseSingleton {
         this._initializePromise = this.doInitialize(storageProvider, config);
         return this._initializePromise;
     }
+    /**
+     * Decides whether the storage provider hands back live object references — the condition
+     * that makes the defensive deep-freeze necessary.
+     *
+     * Prefers the provider's declared {@link ILocalStorageProvider.SharesReferences}. When a
+     * provider does not state one (any implementation written before that property existed),
+     * MEASURE it rather than guessing: store a sentinel object, read it back, and compare
+     * identity. A reference-sharing store returns the very same object; anything with a
+     * serialization or structured-clone boundary returns a copy. This is what keeps the
+     * property optional — an external provider that never declares it still gets the correct
+     * protection instead of silently losing it to a falsy default.
+     *
+     * Fails closed to `false` if the probe cannot complete (a provider whose backing store is
+     * not ready at init): that matches the pre-freeze behavior rather than immobilizing rows
+     * for a provider we could not classify.
+     */
+    async resolveSharesReferences(storageProvider) {
+        if (typeof storageProvider.SharesReferences === 'boolean') {
+            return storageProvider.SharesReferences;
+        }
+        const probeKey = '__mj_sharesreferences_probe__';
+        const sentinel = { probe: true };
+        try {
+            await storageProvider.SetItem(probeKey, sentinel, CacheCategory.Default);
+            const readBack = await storageProvider.GetItem(probeKey, CacheCategory.Default);
+            const shares = readBack === sentinel;
+            LogStatusVerbose(`[CACHE-INIT] Storage provider "${storageProvider.constructor?.name ?? 'unknown'}" did not declare ` +
+                `SharesReferences; probed it as ${shares} (freeze-on-write ${shares ? 'ENABLED' : 'disabled'}).`);
+            return shares;
+        }
+        catch (e) {
+            LogError(`LocalCacheManager: could not probe SharesReferences on the storage provider; ` +
+                `assuming it isolates (freeze-on-write disabled). Declare SharesReferences to be explicit. ${e}`);
+            return false;
+        }
+        finally {
+            try {
+                await storageProvider.Remove(probeKey, CacheCategory.Default);
+            }
+            catch {
+                /* best-effort cleanup — a leftover probe key is harmless */
+            }
+        }
+    }
     /**
      * Internal initialization logic - only called once by the first caller
      */
     async doInitialize(storageProvider, config) {
-        this._storageProvider = storageProvider;
         if (config) {
             this._config = { ...this._config, ...config };
         }
+        // Resolve the freeze decision BEFORE publishing the provider. The probe awaits I/O, and
+        // `_storageProvider` is what every write path reads to decide whether to freeze — so
+        // assigning it first opens a window where writes see the new provider paired with the
+        // PREVIOUS provider's (or the default `false`) freeze decision. Same ordering bug that
+        // `SetStorageProvider` had; fixed here too rather than left as the one asymmetric path.
+        this._sharesReferences = await this.resolveSharesReferences(storageProvider);
+        this._storageProvider = storageProvider;
         await this.loadRegistry();
         this._initialized = true;
         // Start periodic eviction sweep for TTL-expired entries
@@ -193,12 +293,24 @@ export class LocalCacheManager extends BaseSingleton {
      * @param newProvider - The new storage provider to use
      */
     async SetStorageProvider(newProvider) {
+        // The freeze decision belongs to the ACTIVE provider, not to whichever one happened to be
+        // installed at Initialize. MJAPI initializes on the in-memory provider during engine
+        // loading and swaps to Redis afterward, so these two have OPPOSITE reference semantics on
+        // every Redis deployment — carrying the old answer forward means freezing rows Redis has
+        // already isolated (all of the hazard, none of the protection), or, on the reverse swap,
+        // silently dropping the protection.
+        //
+        // Resolved BEFORE `_storageProvider` is published in both branches: the probe awaits I/O,
+        // and write paths read `_storageProvider` to decide whether to freeze, so publishing first
+        // would pair the new provider with the old provider's decision for the duration of the probe.
         if (!this._initialized) {
             // Not yet initialized — just set the provider and return
+            this._sharesReferences = await this.resolveSharesReferences(newProvider);
             this._storageProvider = newProvider;
             return;
         }
         const oldProvider = this._storageProvider;
+        this._sharesReferences = await this.resolveSharesReferences(newProvider);
         this._storageProvider = newProvider;
         // Migrate existing cached data from old provider to new provider
         const entries = this.GetAllEntries();
@@ -932,7 +1044,8 @@ export class LocalCacheManager extends BaseSingleton {
      *
      * @param name - The dataset name
      * @param itemFilters - Optional filters applied to the dataset
-     * @param dataset - The dataset result to cache
+     * @param dataset - The dataset result to cache. Deep-frozen on reference-sharing storage,
+     *                  like every other cache write funnel — see below.
      * @param keyPrefix - Prefix for the cache key (typically includes connection info)
      */
     async SetDataset(name, itemFilters, dataset, keyPrefix) {
@@ -942,6 +1055,17 @@ export class LocalCacheManager extends BaseSingleton {
         // Estimate size from a string representation (used only for cache eviction
         // accounting; the actual stored value is the native object).
         const sizeBytes = this.estimateSize(JSON.stringify(dataset));
+        // Fourth write funnel, held to the same contract as SetRunViewResult /
+        // SetRunQueryResult / storeCachedResults. `GetDataset` hands this object straight back
+        // out, so on a reference-sharing provider every reader shares it — the same exposure the
+        // other three close. It has no in-repo caller today (GetDatasetByName caches per ITEM via
+        // SetRunViewResult), but it is exported public API, so an external caller would otherwise
+        // get an unprotected slot with no indication that it differs from the documented rule.
+        //
+        // Frozen BEFORE the awaited eviction below, for the same reason as the other funnels: a
+        // yield point between the decision to cache and the freeze is a window in which the
+        // caller can still mutate what is about to become shared state.
+        this.freezeRowDataIfProviderSharesReferences(dataset);
         // Check if we need to evict entries
         await this.evictIfNeeded(sizeBytes);
         try {
@@ -1078,7 +1202,7 @@ export class LocalCacheManager extends BaseSingleton {
      *   pre-RLS format so normal cache sharing is preserved and no existing entries are invalidated.
      * @returns A unique, human-readable fingerprint string
      */
-    GenerateRunViewFingerprint(params, connectionPrefix, rlsWhereClause) {
+    GenerateRunViewFingerprint(params, connectionPrefix, rlsWhereClause, datasetSegment) {
         const entity = params.EntityName?.trim() || 'Unknown';
         const rawFilter = params.ExtraFilter;
         const filter = (typeof rawFilter === 'string' ? rawFilter : rawFilter ? JSON.stringify(rawFilter) : '').trim();
@@ -1158,6 +1282,25 @@ export class LocalCacheManager extends BaseSingleton {
         if (viewKey.length > 0) {
             parts.push(`vw:${viewKey}`);
         }
+        // Dataset namespace. `GetDatasetByName` caches each dataset ITEM's rows through this same
+        // builder, supplying only entity + the item's WhereClause — and every shipped item has a
+        // NULL WhereClause, so without this segment a dataset item emits the identical fingerprint
+        // to a plain unfiltered read of the same entity and the two silently share one slot. That
+        // is not merely a stale-data risk: the MJ_Metadata dataset writes its rows with
+        // `ProviderInternalScaffolding` (deliberately UNFROZEN, because bootstrap rearranges them
+        // in place), so the shared slot hands ordinary callers unprotected rows for the hottest
+        // entities in the process — and, in the other direction, an ordinary read repopulating an
+        // evicted slot stores it FROZEN and the next metadata refresh throws.
+        //
+        // Dataset items may also project columns (`DatasetItem.Columns`), where a RunView slot is
+        // always the full field set — so the two are not interchangeable in shape either.
+        //
+        // Appended ONLY when supplied, so ordinary reads keep their exact pre-existing key and no
+        // existing cache entry is invalidated by this change.
+        const dataset = (datasetSegment ?? '').trim();
+        if (dataset.length > 0) {
+            parts.push(`ds:${dataset}`);
+        }
         // Only include connection if provided
         if (connection) {
             parts.push(connection);
@@ -1260,6 +1403,64 @@ export class LocalCacheManager extends BaseSingleton {
             return undefined;
         }
     }
+    /**
+     * Deep-freezes an about-to-be-stored cache payload when — and only when — the active
+     * storage provider hands out live object references
+     * ({@link ILocalStorageProvider.SharesReferences}).
+     *
+     * This is the cache's structural defense against consumer corruption. Under a
+     * reference-sharing provider the rows a caller receives ARE the cached rows, in both
+     * directions: on a hit the reader gets the stored array, and on a miss the cache stored
+     * the caller's own array. Any in-place mutation therefore edits process-wide state. One
+     * such mutation shipped as a P1 (a resolver renamed `__mj_CreatedAt` to its GraphQL
+     * transport alias in place, so every later read served rows `BaseEntity.SetMany`
+     * rejects). Freezing makes that failure immediate and attributable — a `TypeError` at
+     * the offending line — instead of silent corruption, and costs nothing per cache hit.
+     *
+     * On serializing providers this is a no-op: their stored data is already isolated, and
+     * freezing would only immobilize the caller's own rows for no safety gain.
+     *
+     * @param payload - The envelope being handed to the storage provider. Frozen in place;
+     *                  the same reference is returned for call-site convenience.
+     */
+    /**
+     * Whether the CURRENTLY-INSTALLED provider hands back live references.
+     *
+     * Prefers the active provider's own declaration, read live on each call — a property read,
+     * so it costs nothing on the write path, and it stays correct no matter how many times the
+     * provider is swapped or which code path does the swapping. `_sharesReferences` (resolved at
+     * `Initialize`/`SetStorageProvider`) is the fallback for providers that declare nothing, where
+     * the answer can only come from the async probe and therefore cannot be recomputed here.
+     *
+     * Belt-and-braces with the re-resolution in {@link SetStorageProvider}: that keeps the probed
+     * value correct across swaps, and this keeps DECLARED providers correct even if some future
+     * swap site forgets to re-resolve.
+     */
+    activeProviderSharesReferences() {
+        const declared = this._storageProvider?.SharesReferences;
+        return typeof declared === 'boolean' ? declared : this._sharesReferences;
+    }
+    freezeRowDataIfProviderSharesReferences(payload) {
+        if (!this.activeProviderSharesReferences()) {
+            return payload;
+        }
+        try {
+            return deepFreezeCacheValue(payload);
+        }
+        catch (e) {
+            // The freeze is protective, never load-bearing — an exotic value Object.freeze
+            // rejects (beyond the guarded binary kinds) must degrade to a stored write rather
+            // than taking down the read path it defends.
+            //
+            // The payload is PARTIALLY frozen at this point and cannot be un-frozen: the walk
+            // freezes parent-first, so everything visited before the throw is already immutable.
+            // Say that plainly instead of claiming "unfrozen" — an operator debugging a
+            // downstream TypeError needs to know the entry is a mix, not a clean opt-out.
+            LogError(`LocalCacheManager: freeze-on-write failed partway; storing the entry with ` +
+                `whatever was frozen before the failure (partial protection, not none). ${e}`);
+            return payload;
+        }
+    }
     /**
      * Stores a RunView result in the cache.
      *
@@ -1276,8 +1477,11 @@ export class LocalCacheManager extends BaseSingleton {
      *   AllowCaching gating in multi-provider scenarios (parallel client connections to multiple
      *   servers). Falls back to `Metadata.Provider` (global default) when omitted, which is fine
      *   for single-provider apps but wrong when AllowCaching differs across servers.
+     * @param ttlMs - Optional time-based expiry (required for external-data-source entities).
+     * @param options - See {@link CacheWriteOptions}. Pass `{ ProviderInternalScaffolding: true }`
+     *   only for slots the writing provider is the sole consumer of.
      */
-    async SetRunViewResult(fingerprint, params, results, maxUpdatedAt, aggregateResults, totalRowCount, provider, ttlMs) {
+    async SetRunViewResult(fingerprint, params, results, maxUpdatedAt, aggregateResults, totalRowCount, provider, ttlMs, options) {
         if (!this._storageProvider || !this._config.enabled)
             return;
         // Keyset (AfterKey) queries are inherently single-use — each call uses a different
@@ -1336,6 +1540,10 @@ export class LocalCacheManager extends BaseSingleton {
         }
         // Persist results, maxUpdatedAt, aggregateResults, totalRowCount, and schemaHash
         const data = { results, maxUpdatedAt };
+        if (options?.ProviderInternalScaffolding) {
+            // Persisted so event-driven in-place maintenance carries the exemption forward.
+            data.providerInternalScaffolding = true;
+        }
         if (aggregateResults && aggregateResults.length > 0) {
             data.aggregateResults = aggregateResults;
         }
@@ -1361,10 +1569,23 @@ export class LocalCacheManager extends BaseSingleton {
             LogStatusEx({ message: `[CACHE-WRITE-GATE] Skipping cache write for "${params.EntityName || fingerprint.substring(0, 60)}" — estimated entry size ${sizeBytes} bytes exceeds per-entry cap (${this._config.maxEntryPercentOfCache}% of ${this._config.maxSizeBytes} byte budget)` });
             return;
         }
-        // Per-entity memory limit: evict oldest entries for this entity if over budget
+        // The oversized gate above is the ONLY step that can decline this write, and it is
+        // synchronous — so by here the row set is definitely becoming shared state, and it is
+        // frozen with no intervening yield point. That ordering is load-bearing: the eviction
+        // steps below are awaited, and callers hold this very array while they run (the
+        // smart-cache stale leg does not await this method at all). Freezing after them leaves
+        // a window in which shared rows are handed out still mutable — and `BaseEntity`
+        // samples `Object.isFrozen` once at load, so a freeze arriving mid-construction makes
+        // a later field READ throw. Declining writes still leave the caller's rows mutable,
+        // because the decline happens before this point.
+        if (!options?.ProviderInternalScaffolding) {
+            this.freezeRowDataIfProviderSharesReferences(data);
+        }
+        // Per-entity memory limit: evict oldest entries for this entity if over budget.
+        // Evicts OTHER entries only — it cannot cancel this write.
         const entityName = params.EntityName || 'Unknown';
         await this.enforcePerEntityMemoryLimit(entityName, sizeBytes);
-        // Check if we need to evict entries (global budget)
+        // Check if we need to evict entries (global budget). Also eviction-only.
         await this.evictIfNeeded(sizeBytes);
         try {
             // Native object storage — IDB structured-clones, localStorage / Redis serialize internally.
@@ -1504,6 +1725,8 @@ export class LocalCacheManager extends BaseSingleton {
             totalRowCount: parsed.totalRowCount,
             // Surfaced so in-place maintenance can carry it forward on rewrite (B38).
             schemaHash: parsed.schemaHash,
+            // Same carry-forward rationale: a maintained scaffolding slot must stay exempt.
+            providerInternalScaffolding: parsed.providerInternalScaffolding,
         };
         if (parsed.aggregateResults) {
             result.aggregateResults = parsed.aggregateResults;
@@ -1717,7 +1940,8 @@ export class LocalCacheManager extends BaseSingleton {
                 // Upsert the entity (add or replace)
                 resultMap.set(keyStr, entityData);
                 const updatedResults = Array.from(resultMap.values());
-                return await this.storeCachedResults(fingerprint, updatedResults, newMaxUpdatedAt, { totalRowCount: cached.totalRowCount, rowCount: cached.results.length, schemaHash: cached.schemaHash });
+                return await this.storeCachedResults(fingerprint, updatedResults, newMaxUpdatedAt, { totalRowCount: cached.totalRowCount, rowCount: cached.results.length, schemaHash: cached.schemaHash,
+                    providerInternalScaffolding: cached.providerInternalScaffolding });
             }
             catch (e) {
                 LogError(`LocalCacheManager.UpsertSingleEntity failed: ${e}`);
@@ -1759,7 +1983,8 @@ export class LocalCacheManager extends BaseSingleton {
                 }
                 resultMap.delete(keyStr);
                 const updatedResults = Array.from(resultMap.values());
-                return await this.storeCachedResults(fingerprint, updatedResults, newMaxUpdatedAt, { totalRowCount: cached.totalRowCount, rowCount: cached.results.length, schemaHash: cached.schemaHash });
+                return await this.storeCachedResults(fingerprint, updatedResults, newMaxUpdatedAt, { totalRowCount: cached.totalRowCount, rowCount: cached.results.length, schemaHash: cached.schemaHash,
+                    providerInternalScaffolding: cached.providerInternalScaffolding });
             }
             catch (e) {
                 LogError(`LocalCacheManager.RemoveSingleEntity failed: ${e}`);
@@ -1800,6 +2025,12 @@ export class LocalCacheManager extends BaseSingleton {
         if (prior?.schemaHash) {
             data.schemaHash = prior.schemaHash;
         }
+        // Carry the freeze exemption forward too — a scaffolding slot that gets maintained in
+        // place must not silently become frozen, or the owner that mutates those rows breaks on
+        // the next read (for the metadata dataset that means booting with no metadata).
+        if (prior?.providerInternalScaffolding) {
+            data.providerInternalScaffolding = true;
+        }
         // Aggregates are deliberately NOT carried here — see hasAggregates(): an aggregate-bearing
         // slot is invalidated on mutation rather than maintained, so this path never runs for one.
         if (prior?.totalRowCount != null) {
@@ -1810,6 +2041,13 @@ export class LocalCacheManager extends BaseSingleton {
         // value is the native object. This runs on every save/delete event per matching
         // unfiltered fingerprint, so avoiding a full serialization here matters most.
         const sizeBytes = this.estimateResultsSize(updatedResults);
+        // Second write funnel — this path bypasses SetRunViewResult entirely, so it must
+        // freeze too. Rows carried forward from the prior slot are already frozen (the
+        // isFrozen short-circuit makes re-entry cheap); what this catches is the NEW array
+        // and the freshly upserted row. Scaffolding slots stay exempt (see above).
+        if (!prior?.providerInternalScaffolding) {
+            this.freezeRowDataIfProviderSharesReferences(data);
+        }
         await this._storageProvider.SetItem(fingerprint, data, CacheCategory.RunViewCache);
         const existingEntry = this._registry.get(fingerprint);
         if (existingEntry) {
@@ -1911,7 +2149,14 @@ export class LocalCacheManager extends BaseSingleton {
             LogStatusEx({ message: `[CACHE-WRITE-GATE] Skipping cache write for query "${queryName}" — estimated entry size ${sizeBytes} bytes exceeds per-entry cap (${this._config.maxEntryPercentOfCache}% of ${this._config.maxSizeBytes} byte budget)` });
             return;
         }
-        // Check if we need to evict entries
+        // Same reference-sharing exposure as the RunView path (GetRunQueryResult hands
+        // `results` straight back out) — closed here rather than waiting for a mutator to
+        // find it. Placed immediately after the only declining gate and BEFORE the awaited
+        // eviction below, for the same reason as SetRunViewResult: callers of this method do
+        // not always await it, so any yield point before the freeze is a window in which the
+        // caller can still mutate the rows the cache is about to store.
+        this.freezeRowDataIfProviderSharesReferences(data);
+        // Check if we need to evict entries. Evicts OTHER entries only — cannot cancel this write.
         await this.evictIfNeeded(sizeBytes);
         const now = Date.now();
         const expiresAt = ttlMs ? now + ttlMs : undefined;