@cat-factory/caching 0.17.1 → 0.18.0

package/README.md

@@ -31,25 +31,80 @@ consume through the kernel `AppCaches` port, implemented on
   only the in-memory machinery. The Redis notification classes are loaded dynamically
   by the Node facade alone, behind `REDIS_URL`.
 
-## The Cloudflare Worker profile (`ISOLATE_SAFE_APP_CACHES_PROFILE`)
+## The Cloudflare Worker profiles
 
-A Worker isolate has no cross-isolate invalidation bus and no Redis, so a TTL'd
+A Worker isolate has no cross-isolate invalidation bus and no Redis, so a bare TTL'd
 in-isolate cache over **mutable cross-instance state** would serve stale data after a
-write processed by another isolate: a correctness bug, not an optimization. The
-Worker therefore wires the isolate-safe profile: caches of mutable state are
-configured **pass-through** (`enabled: false`; every read runs its load), and only
-caches of immutable or self-verifying entries (sha-pinned repo reads, static
-catalogs) get real TTLs. Distributed invalidation is a
-genuine Node-only concern, not a facade-parity gap: the Worker's cross-instance state
-already lives in globally-addressed Durable Objects / D1. Revisit only if a
-per-isolate staleness bug actually surfaces.
+write processed by another isolate: a correctness bug, not an optimization. Push is
+structurally unavailable there (an isolate holds no subscription between requests), so
+the Worker has two stances, selected by whether its `CACHE_GENERATIONS` Durable Object
+binding exists:
+
+- **`ISOLATE_SAFE_APP_CACHES_PROFILE`** (the fallback, and prior behaviour): caches of
+  mutable state are **pass-through** (`enabled: false`; every read runs its load), and
+  only caches of immutable or self-verifying entries (sha-pinned repo reads, external
+  documents re-validated by a version probe) get real TTLs.
+- **`ISOLATE_COHERENT_APP_CACHES_PROFILE`**: the isolate-safe profile plus
+  **pull-coherent** caches. A coherent cache keeps a real TTL, and its profile entry
+  carries a `coherencyWindowMsecs`: a read whose group snapshot is older than the
+  window re-reads the injected `CacheGenerationStore` (one monotonic counter per
+  (cache, group), one round trip per group serving every coherent cache) and, on a
+  moved counter, applies layered-loader 16.1's local, fencing, non-publishing
+  `applyRemoteInvalidation*` primitives before serving. Every invalidation site bumps
+  the directory right after its local invalidation, awaited by the write path.
+  Cross-isolate staleness is bounded by the window (5s on the pilot), instead of
+  indefinite (a bare TTL) or zero-at-the-cost-of-every-read (pass-through).
+
+Error posture, deliberately asymmetric: a probe failure fails CLOSED (the read
+invalidates locally and loads fresh, so a directory outage degrades to pass-through
+performance, never staleness); a bump failure fails OPEN (the write and its local
+invalidation already happened; peers heal at the TTL, and
+`cache.coherency_bump_failure` is the visible trace). `createAppCaches` refuses a
+profile that sets a window on an enabled cache with no `generationStore` wired.
+
+A coherent cache also declares whether it ever invalidates CACHE-WIDE, with
+`cacheWideInvalidation`. Only a cache that does needs the reserved `'*'` epoch counter
+probed beside its own group, and that shard is ONE globally placed Durable Object, so a
+cache with no `invalidateAll` call site would be paying a cross-colo round trip that
+structurally cannot return news. It is declared rather than inferred, and `invalidateAll`
+on a coherent cache that did not declare it THROWS: dropping the entries here while every
+peer keeps serving theirs to the TTL is exactly the hole the flag exists to close.
+
+## Isolate runtimes: nothing may cross an invocation
+
+Two rules, both from the same fact: on Cloudflare, I/O is scoped to the invocation that
+created it, and an invocation that touches another's I/O is **destroyed** with "Cannot
+perform I/O on behalf of a different request", at the runtime level, where no `catch` in
+the joining code can see it.
+
+- **Background work is adopted by the CURRENT invocation.** Pass `scheduleBackgroundWork`
+  and hand the promise to `ctx.waitUntil`, resolving the context at call time rather than
+  closing over one (the Worker reads the ambient ExecutionContext off an
+  AsyncLocalStorage; see `runtimes/cloudflare/src/infrastructure/appCachesHost.ts`).
+- **In-flight promises are never shared between invocations.** This is what
+  `currentInvocation` is for. The bag is one per ISOLATE, which is what makes its entries
+  caches rather than per-invocation memos, but it also puts layered-loader's in-flight
+  load map (and the coherency probe's) in reach of a second concurrent invocation on every
+  same-key miss. Supplying `currentInvocation` moves the MISS path onto per-invocation
+  loads: reads still serve from the isolate-scoped in-memory tier and a hit still schedules
+  its preemptive refresh, but a miss loads for itself rather than joining a promise it
+  cannot safely await. Within one invocation the coalescing is kept, and an invocation the
+  runtime cannot name (a Workflows step, which has no ExecutionContext) coalesces with
+  nothing, because two loads that cannot be told apart must be assumed to be different
+  contexts. Node supplies nothing here and keeps layered-loader's own load path unchanged.
+
+Because a miss now publishes outside the loader, that publish is fenced locally: an
+invalidation landing while a load is in flight discards the late write instead of
+resurrecting the entry it dropped (the caller still receives the value it loaded).
 
 `fragmentDocumentBody` is the first self-verifying cache that stays **enabled** on the
-Worker: its entries are external Confluence/Notion/GitHub/… page content re-validated
-by the source's cheap version probe (`ttlLeftBeforeRefreshInMsecs` + `isStillCurrent`),
-so a peer isolate's cached body self-heals within the refresh window without an
-invalidation bus: its staleness is bounded by the probe, exactly like a sha-pinned
-read. Only `fragmentCatalog`, which mirrors our own mutable D1 rows, passes through.
+Worker even without the directory: its entries are external Confluence/Notion/GitHub/…
+page content re-validated by the source's cheap version probe
+(`ttlLeftBeforeRefreshInMsecs` + `isStillCurrent`), so a peer isolate's cached body
+self-heals within the refresh window without an invalidation bus.
+`workspaceSettings` is the pull-coherency pilot (one invalidation site, no
+`invalidateAll`, hot on the Worker); further flips are one profile row each, in their
+own slice.
 
 ## Named caches
 
@@ -68,8 +123,14 @@ import { createAppCaches } from '@cat-factory/caching'
 // Node facade (multi-node): inject the Redis-backed notification pair factory.
 const caches = createAppCaches({ notificationPairFactory, logger })
 
-// Cloudflare Worker: the isolate-safe profile.
-const caches = createAppCaches({ profile: ISOLATE_SAFE_APP_CACHES_PROFILE })
+// Cloudflare Worker: the module-scope host picks the coherent profile when the
+// CACHE_GENERATIONS Durable Object is bound, else the isolate-safe fallback
+// (runtimes/cloudflare/src/infrastructure/appCachesHost.ts).
+const caches = createAppCaches({
+  profile: ISOLATE_COHERENT_APP_CACHES_PROFILE,
+  generationStore, // DO-backed on the Worker; any CacheGenerationStore elsewhere
+  scheduleBackgroundWork, // adopt detached refreshes onto ctx.waitUntil
+})
 
 // A consuming service reads through its named handle…
 const catalog = await caches.fragmentCatalog.get(key, workspaceId, () => loadCatalog())

package/dist/appCaches.d.ts

@@ -1,5 +1,6 @@
 import type { AppCaches, Logger, OperationalMetrics } from '@cat-factory/kernel';
-import type { AbstractNotificationConsumer, GroupNotificationPublisher, InMemoryGroupCache } from 'layered-loader/core';
+import type { AbstractNotificationConsumer, BackgroundWorkScheduler, GroupNotificationPublisher, InMemoryGroupCache } from 'layered-loader/core';
+import type { CacheGenerationStore } from './generationCoherency.js';
 /** Per-cache tuning knobs; a facade passes a profile so TTLs can differ per runtime. */
 export interface GroupCacheProfile {
     /**
@@ -25,6 +26,30 @@ export interface GroupCacheProfile {
      * cost as much as the load).
      */
     ttlLeftBeforeRefreshInMsecs?: number;
+    /**
+     * Pull-coherency probe cadence, for an enabled cache of our own mutable state on a runtime
+     * with no push bus (the Worker): a read whose group snapshot in the injected
+     * {@link CacheGenerationStore} is older than this re-reads the directory before serving,
+     * applying the group invalidation locally on a moved counter. Bounds cross-isolate staleness
+     * at roughly this window. Requires `generationStore`: {@link createAppCaches} REFUSES a
+     * profile that sets it on an enabled cache without one, because an enabled TTL'd cache of
+     * mutable state with no coherency mechanism is the exact bug the isolate-safe profile
+     * exists to prevent.
+     */
+    coherencyWindowMsecs?: number;
+    /**
+     * Declares that this cache's owning service calls {@link GroupCacheHandle.invalidateAll}.
+     *
+     * Only meaningful together with `coherencyWindowMsecs`, and it costs something real: a
+     * cache-wide invalidation rides the reserved epoch counter, whose shard is ONE globally
+     * placed Durable Object, so declaring this puts a cross-colo probe on the cache's read path.
+     * A cache with no `invalidateAll` call site leaves it off and probes only its own group.
+     *
+     * Getting it wrong cannot go quiet: `invalidateAll` on a coherent cache that did NOT declare
+     * it THROWS, because dropping the entries locally while peers keep serving them for a full
+     * TTL is the failure this flag exists to prevent.
+     */
+    cacheWideInvalidation?: boolean;
 }
 /** One profile entry per named cache in the kernel {@link AppCaches} bag. */
 export interface AppCachesProfile {
@@ -62,8 +87,32 @@ export declare const DEFAULT_APP_CACHES_PROFILE: AppCachesProfile;
  * lets sha-pinned reads keep a TTL on the Worker) — its staleness is bounded by the
  * probe, not indefinite. Only `fragmentCatalog`, which mirrors our own mutable D1
  * state, must pass through.
+ *
+ * Every ENABLED entry below is read against ONE FACT that the numbers on the Node profile were
+ * not chosen for: the Worker's bag is one per ISOLATE (`appCachesHost.ts`), so an entry lives
+ * its whole TTL across requests. It used to be rebuilt per invocation, which quietly capped
+ * every one of these at the length of a single wake. The two probe-backed slices therefore
+ * widen their refresh window to cover the full TTL here (see each entry); the two that have no
+ * probe keep their TTL as the entire bound, which their own numbers were already sized as:
+ * `linkedDocumentVersion` at 60s, and `ssoDiscovery` at 15 minutes of EXTERNAL state that
+ * additionally self-heals on an unknown `kid`.
  */
 export declare const ISOLATE_SAFE_APP_CACHES_PROFILE: AppCachesProfile;
+/**
+ * The isolate-safe profile plus the caches the generation directory makes coherent: selected
+ * by the Worker ONLY when its `CACHE_GENERATIONS` Durable Object binding exists (and so a
+ * {@link CacheGenerationStore} is injected); with no binding the Worker keeps the pass-through
+ * stance above. Flipping a cache here means giving it a real TTL on the Worker with a
+ * generation probe bounding its cross-isolate staleness at `coherencyWindowMsecs`; the cache's
+ * EVERY invalidation site then also bumps the directory (the handle does both together).
+ *
+ * `workspaceSettings` is the pilot: exactly one invalidation site
+ * (`WorkspaceSettingsService.update`), no `invalidateAll`, and hot on the Worker (read per
+ * recorded LLM call, per task-limit guard, per pricing resolution, each a live D1 read
+ * today). Further flips are one profile row each, in their own slice
+ * (docs/initiatives/caching-layer.md).
+ */
+export declare const ISOLATE_COHERENT_APP_CACHES_PROFILE: AppCachesProfile;
 /**
  * A per-cache invalidation-notification pair (layered-loader's group publisher +
  * consumer). Produced by the facade's factory — Redis-backed in a multi-node Node
@@ -93,6 +142,30 @@ export interface CreateAppCachesOptions {
      * two states with identical latency graphs and opposite fixes. Absent ⇒ uncounted.
      */
     operationalMetrics?: OperationalMetrics;
+    /**
+     * The shared generation directory backing every profile entry with a
+     * `coherencyWindowMsecs` (see that field's doc). One directory serves the whole bag, so all
+     * coherent caches share each group's probe. Absent ⇒ no entry may set a window.
+     */
+    generationStore?: CacheGenerationStore;
+    /**
+     * Adopter for the work the loaders start and do not await (preemptive refreshes, staleness
+     * probes, notification publishes). On Node the default detached run is correct; an isolate
+     * runtime hands the promise to the current request's `ctx.waitUntil` instead, because I/O
+     * there is scoped to the request that created it. The promise always settles fulfilled.
+     */
+    scheduleBackgroundWork?: BackgroundWorkScheduler;
+    /**
+     * Supplied ONLY by an isolate runtime (the Worker): returns an object identifying the
+     * invocation currently being served, or `undefined` outside a bracketed entry point.
+     *
+     * Its presence switches every cache MISS off layered-loader's shared load path and onto the
+     * per-invocation one in {@link InvocationScopedLoads}, because the bag is one per ISOLATE
+     * and workerd destroys, uncatchably, any invocation that awaits a promise another one
+     * created. Absent (Node, where one process serves every request out of one I/O context) ⇒
+     * the loader's own coalescing is kept, unchanged.
+     */
+    currentInvocation?: () => object | undefined;
 }
 /**
  * Build the app-owned cache bag. Called once per process by a facade's

package/dist/appCaches.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"appCaches.d.ts","sourceRoot":"","sources":["../src/appCaches.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,SAAS,EAOT,MAAM,EAUN,kBAAkB,EACnB,MAAM,qBAAqB,CAAA;AAO5B,OAAO,KAAK,EACV,4BAA4B,EAC5B,0BAA0B,EAC1B,kBAAkB,EAEnB,MAAM,qBAAqB,CAAA;AAwB5B,wFAAwF;AACxF,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,OAAO,EAAE,OAAO,CAAA;IAChB,mFAAmF;IACnF,UAAU,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAA;IACjB,6CAA6C;IAC7C,gBAAgB,EAAE,MAAM,CAAA;IACxB;;;;;;;;OAQG;IACH,2BAA2B,CAAC,EAAE,MAAM,CAAA;CACrC;AAED,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,iBAAiB,CAAA;IAClC,YAAY,EAAE,iBAAiB,CAAA;IAC/B,0BAA0B,EAAE,iBAAiB,CAAA;IAC7C,oBAAoB,EAAE,iBAAiB,CAAA;IACvC,qBAAqB,EAAE,iBAAiB,CAAA;IACxC,cAAc,EAAE,iBAAiB,CAAA;IACjC,SAAS,EAAE,iBAAiB,CAAA;IAC5B,kBAAkB,EAAE,iBAAiB,CAAA;IACrC,eAAe,EAAE,iBAAiB,CAAA;IAClC,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,kBAAkB,EAAE,iBAAiB,CAAA;IACrC,eAAe,EAAE,iBAAiB,CAAA;IAClC,WAAW,EAAE,iBAAiB,CAAA;IAC9B,oBAAoB,EAAE,iBAAiB,CAAA;IACvC,UAAU,EAAE,iBAAiB,CAAA;IAC7B,WAAW,EAAE,iBAAiB,CAAA;IAC9B,eAAe,EAAE,iBAAiB,CAAA;IAClC,qBAAqB,EAAE,iBAAiB,CAAA;IACxC,YAAY,EAAE,iBAAiB,CAAA;CAChC;AAED,wEAAwE;AACxE,eAAO,MAAM,0BAA0B,EAAE,gBAiJxC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,+BAA+B,EAAE,gBA2E7C,CAAA;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,SAAS,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAAA;IACxC,QAAQ,EAAE,4BAA4B,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAA;CACjE;AAED;;;;;GAKG;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,EAC3C,SAAS,EAAE,MAAM,KACd,uBAAuB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAA;AAE3C,MAAM,WAAW,sBAAsB;IACrC,0EAA0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAA;IACnC,2EAA2E;IAC3E,uBAAuB,CAAC,EAAE,4BAA4B,CAAA;IACtD,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAA;CACxC;AAmHD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,SAAS,CAqI/E"}
+{"version":3,"file":"appCaches.d.ts","sourceRoot":"","sources":["../src/appCaches.ts"],"names":[],"mappings":"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"}

package/dist/appCaches.js

@@ -4,6 +4,8 @@ import { noopOperationalMetrics } from '@cat-factory/kernel';
 // notification wiring — the Worker imports this package too. The package root re-exports
 // the Redis surface as well, so it is NOT interchangeable with this import; keep it `/core`.
 import { GroupLoader } from 'layered-loader/core';
+import { CACHE_EPOCH_GROUP, GroupGenerationTracker } from './generationCoherency.js';
+import { InvocationScopedLoads } from './invocationScopedLoads.js';
 /**
  * layered-loader logs its background failures through a pino-shaped `error(obj, msg?)`.
  * The platform's own convention is message-first (`kernel`'s {@link Logger}), so the
@@ -23,7 +25,15 @@ function asLayeredLoaderLogger(logger) {
 export const DEFAULT_APP_CACHES_PROFILE = {
     // One merged catalog per workspace; the key varies only when the workspace's
     // account changes, so a small per-group bound is plenty.
-    fragmentCatalog: { enabled: true, ttlInMsecs: 5 * 60_000, maxGroups: 500, maxItemsPerGroup: 4 },
+    fragmentCatalog: {
+        enabled: true,
+        ttlInMsecs: 5 * 60_000,
+        maxGroups: 500,
+        maxItemsPerGroup: 4,
+        // `FragmentLibraryService` drops the whole cache on an ACCOUNT-tier write (it spans every
+        // workspace in the account), so this cache needs the epoch counter wherever it runs coherent.
+        cacheWideInvalidation: true,
+    },
     // One repo-sourced skill catalog per account, keyed by account id (one entry per group).
     // Invalidation-driven (the skill-source sync drops the group after a change); no version
     // probe — a DB read as the probe would cost as much as the DB read as the load.
@@ -36,6 +46,8 @@ export const DEFAULT_APP_CACHES_PROFILE = {
         ttlInMsecs: 5 * 60_000,
         maxGroups: 500,
         maxItemsPerGroup: 1,
+        // Same account-tier blast radius as `fragmentCatalog`, which it mirrors.
+        cacheWideInvalidation: true,
     },
     // The live external body of a document-backed fragment, grouped by workspace and
     // keyed per document. Self-verifying: an entry entering the last minute of its TTL
@@ -145,13 +157,22 @@ export const DEFAULT_APP_CACHES_PROFILE = {
     // invalidation-driven, no version probe. A SHORT 60s TTL: it's the freshness backstop only (the
     // roster/access-mode/account-membership writes invalidate on commit), and it bounds how long a
     // just-revoked member keeps read access on the rare path an invalidation is missed.
-    workspaceAccess: { enabled: true, ttlInMsecs: 60_000, maxGroups: 2000, maxItemsPerGroup: 256 },
+    workspaceAccess: {
+        enabled: true,
+        ttlInMsecs: 60_000,
+        maxGroups: 2000,
+        maxItemsPerGroup: 256,
+        // An account-membership change alters access to potentially every board, so `AccountService`
+        // drops the whole cache rather than enumerating them.
+        cacheWideInvalidation: true,
+    },
     // One session generation per user, grouped AND keyed by user id (one entry per group), read on
     // every authenticated request. `maxGroups` is therefore sized against CONCURRENTLY ACTIVE users
     // rather than registered ones, and each entry is a single small number. The 60s TTL is the
     // freshness backstop only, exactly as on `workspaceAccess` above: a bump invalidates the key on
     // commit, and the TTL bounds how long a revoked bearer survives on the rare path where an
-    // invalidation is missed (a peer replica with no notification bus wired).
+    // invalidation is missed (a peer replica with no notification bus wired). Every invalidation
+    // site is per-user, so it needs no cache-wide epoch probe.
     userSessionGeneration: {
         enabled: true,
         ttlInMsecs: 60_000,
@@ -178,6 +199,15 @@ export const DEFAULT_APP_CACHES_PROFILE = {
  * lets sha-pinned reads keep a TTL on the Worker) — its staleness is bounded by the
  * probe, not indefinite. Only `fragmentCatalog`, which mirrors our own mutable D1
  * state, must pass through.
+ *
+ * Every ENABLED entry below is read against ONE FACT that the numbers on the Node profile were
+ * not chosen for: the Worker's bag is one per ISOLATE (`appCachesHost.ts`), so an entry lives
+ * its whole TTL across requests. It used to be rebuilt per invocation, which quietly capped
+ * every one of these at the length of a single wake. The two probe-backed slices therefore
+ * widen their refresh window to cover the full TTL here (see each entry); the two that have no
+ * probe keep their TTL as the entire bound, which their own numbers were already sized as:
+ * `linkedDocumentVersion` at 60s, and `ssoDiscovery` at 15 minutes of EXTERNAL state that
+ * additionally self-heals on an unknown `kid`.
  */
 export const ISOLATE_SAFE_APP_CACHES_PROFILE = {
     fragmentCatalog: { ...DEFAULT_APP_CACHES_PROFILE.fragmentCatalog, enabled: false },
@@ -189,7 +219,18 @@ export const ISOLATE_SAFE_APP_CACHES_PROFILE = {
         ...DEFAULT_APP_CACHES_PROFILE.foundationalServiceCatalog,
         enabled: false,
     },
-    fragmentDocumentBody: { ...DEFAULT_APP_CACHES_PROFILE.fragmentDocumentBody },
+    fragmentDocumentBody: {
+        ...DEFAULT_APP_CACHES_PROFILE.fragmentDocumentBody,
+        // The refresh window covers the WHOLE TTL here, unlike the Node profile's last minute of
+        // five. The bag is one per ISOLATE, so an entry now lives its full TTL across requests
+        // rather than being rebuilt per wake as it was when these numbers were chosen; with a
+        // window of one minute, the first four served unprobed. Since the claim that keeps this
+        // cache enabled on the Worker at all is "a peer isolate's copy self-heals within the
+        // refresh window", the window has to BE the lifetime. The probe is the source's cheap
+        // version check, deduped per (group, key) while one is in flight, so a read pays at most
+        // one of them and never waits on it.
+        ttlLeftBeforeRefreshInMsecs: DEFAULT_APP_CACHES_PROFILE.fragmentDocumentBody.ttlInMsecs,
+    },
     // Stays ENABLED here for the same reason, one step further: the entry IS an external source's
     // version token, so it is neither our own mutable state nor in need of a probe to re-validate — a
     // peer isolate's copy self-heals when its 60s TTL lapses. Passing through instead would put a live
@@ -206,7 +247,15 @@ export const ISOLATE_SAFE_APP_CACHES_PROFILE = {
     // file self-heals within the refresh window without an invalidation bus — its staleness is
     // bounded by the probe, not indefinite. The same reasoning that keeps `fragmentDocumentBody`
     // on; only caches of our own mutable D1 state (`fragmentCatalog`/`repoProjection`) pass through.
-    repoFiles: { ...DEFAULT_APP_CACHES_PROFILE.repoFiles },
+    repoFiles: {
+        ...DEFAULT_APP_CACHES_PROFILE.repoFiles,
+        // Same reasoning as `fragmentDocumentBody` above, and this is the slice where it bites
+        // hardest: the entries are repo FILE CONTENT, so an unprobed window is a post-op reading
+        // pre-commit files that the per-invocation bag made impossible. The `headSha` probe is one
+        // cheap call per branch, so covering the whole TTL with it is what makes "bounded by the
+        // probe, not indefinite" true now that entries outlive the request that loaded them.
+        ttlLeftBeforeRefreshInMsecs: DEFAULT_APP_CACHES_PROFILE.repoFiles.ttlInMsecs,
+    },
     // Pass-through for the same reason: the account policy is our own mutable D1 state
     // with no cross-isolate invalidation bus on the Worker.
     accountModelPolicy: { ...DEFAULT_APP_CACHES_PROFILE.accountModelPolicy, enabled: false },
@@ -255,13 +304,56 @@ export const ISOLATE_SAFE_APP_CACHES_PROFILE = {
     // them.
     ssoDiscovery: { ...DEFAULT_APP_CACHES_PROFILE.ssoDiscovery },
 };
+/**
+ * The isolate-safe profile plus the caches the generation directory makes coherent: selected
+ * by the Worker ONLY when its `CACHE_GENERATIONS` Durable Object binding exists (and so a
+ * {@link CacheGenerationStore} is injected); with no binding the Worker keeps the pass-through
+ * stance above. Flipping a cache here means giving it a real TTL on the Worker with a
+ * generation probe bounding its cross-isolate staleness at `coherencyWindowMsecs`; the cache's
+ * EVERY invalidation site then also bumps the directory (the handle does both together).
+ *
+ * `workspaceSettings` is the pilot: exactly one invalidation site
+ * (`WorkspaceSettingsService.update`), no `invalidateAll`, and hot on the Worker (read per
+ * recorded LLM call, per task-limit guard, per pricing resolution, each a live D1 read
+ * today). Further flips are one profile row each, in their own slice
+ * (docs/initiatives/caching-layer.md).
+ */
+export const ISOLATE_COHERENT_APP_CACHES_PROFILE = {
+    ...ISOLATE_SAFE_APP_CACHES_PROFILE,
+    workspaceSettings: {
+        ...DEFAULT_APP_CACHES_PROFILE.workspaceSettings,
+        coherencyWindowMsecs: 5_000,
+        // The TTL is SHORTER here than the 5 minutes the Node profile carries, and it is sized for
+        // a specific job: it is the backstop for a FAILED bump. The probe window bounds staleness
+        // at ~5s only while the directory is reachable; when a writer's bump fails the mechanism
+        // fails OPEN (the write already committed, so refusing it would be worse) and peers learn
+        // nothing until their entry expires, so the TTL, not the window, is the real bound in
+        // that case. This row carries `allowInitiatorPat`, `storeAgentContext` and the spend caps,
+        // where the failure mode is a revoked permission still being honoured, so the honest
+        // number is the one an operator would accept for a REVOCATION, not for a settings edit.
+        ttlInMsecs: 60_000,
+    },
+};
 class LayeredGroupCacheHandle {
     name;
-    metrics;
     loader;
-    constructor(name, profile, notifications, logger, metrics = noopOperationalMetrics) {
+    /** Set only for an enabled cache whose profile carries a `coherencyWindowMsecs`. */
+    coherency;
+    metrics;
+    /** Set only on an isolate runtime; see {@link CreateAppCachesOptions.currentInvocation}. */
+    invocationLoads;
+    enabled;
+    /** See {@link GroupCacheProfile.cacheWideInvalidation}. */
+    cacheWideInvalidation;
+    constructor(name, profile, deps) {
         this.name = name;
-        this.metrics = metrics;
+        const { notifications, logger, coherency, scheduleBackgroundWork } = deps;
+        this.metrics = deps.metrics ?? noopOperationalMetrics;
+        this.enabled = profile.enabled;
+        this.cacheWideInvalidation = profile.cacheWideInvalidation ?? false;
+        this.invocationLoads = deps.currentInvocation
+            ? new InvocationScopedLoads(deps.currentInvocation)
+            : undefined;
         this.loader = new GroupLoader({
             inMemoryCache: profile.enabled
                 ? {
@@ -307,6 +399,26 @@ class LayeredGroupCacheHandle {
                 }
                 : {}),
             ...(logger ? { logger: asLayeredLoaderLogger(logger) } : {}),
+            ...(scheduleBackgroundWork ? { scheduleBackgroundWork } : {}),
+        });
+        this.coherency = coherency?.tracker;
+        // The 16.1 apply-remote primitives are handed over BOUND: synchronous, purely local,
+        // non-publishing, and fencing (an in-flight load cannot write its pre-invalidation
+        // snapshot back), which is exactly what a probe-detected peer change must apply.
+        coherency?.tracker.register({
+            cacheName: name,
+            windowMsecs: coherency.windowMsecs,
+            probesEpoch: this.cacheWideInvalidation,
+            applyRemoteInvalidationForGroup: (group) => {
+                // The invocation-scoped load path publishes outside the loader, so it needs the same
+                // news the loader's own fences get: a peer's invalidation must void an in-flight load.
+                this.invocationLoads?.noteInvalidation();
+                this.loader.applyRemoteInvalidationForGroup(group);
+            },
+            applyRemoteInvalidation: () => {
+                this.invocationLoads?.noteInvalidation();
+                this.loader.applyRemoteInvalidation();
+            },
         });
     }
     async get(key, group, load, isStillCurrent) {
@@ -316,6 +428,15 @@ class LayeredGroupCacheHandle {
         // that lands inside a probe-refresh window can trigger a BACKGROUND reload, and if that
         // reload's load closure runs before this await resolves it is attributed to this read. So
         // the hit rate on a probe-refreshed cache is a floor, never an overstatement.
+        // Pull coherency runs BEFORE the loader read: inside the window it resolves with no I/O,
+        // past it one shared probe re-reads the generation directory and locally invalidates what
+        // moved, so the loader read below never serves an entry a peer already invalidated more
+        // than the window ago. Never rejects (probe failure fails closed inside the tracker).
+        if (this.coherency)
+            await this.coherency.ensureFresh(this.name, group);
+        if (this.invocationLoads) {
+            return this.getWithoutCrossInvocationJoin(this.invocationLoads, key, group, load, isStillCurrent);
+        }
         let loaderRan = false;
         const countedLoad = () => {
             loaderRan = true;
@@ -328,14 +449,64 @@ class LayeredGroupCacheHandle {
         this.metrics.increment(loaderRan ? 'cache.miss' : 'cache.hit', { cache: this.name });
         return value;
     }
-    invalidate(key, group) {
-        return this.loader.invalidateCacheFor(key, group);
+    /**
+     * The isolate-runtime read: the same two tiers as the loader's own `get`, but split so the
+     * MISS half never enters layered-loader's shared load path, whose in-flight map is the one
+     * piece of the isolate-scoped bag that would hand this invocation a promise created by
+     * another (see {@link InvocationScopedLoads}).
+     *
+     * The HIT half still goes through the loader, so an entry entering its refresh window keeps
+     * scheduling the preemptive reload / staleness probe exactly as before: that read only
+     * INSPECTS the in-flight map, it never awaits what it finds there.
+     */
+    async getWithoutCrossInvocationJoin(invocationLoads, key, group, load, isStillCurrent) {
+        const params = { key, load, ...(isStillCurrent ? { isStillCurrent } : {}) };
+        // `undefined` is the miss; `null` is a legitimately cached resolved-but-empty value.
+        const cached = this.loader.getInMemoryOnly(params, group);
+        if (cached !== undefined) {
+            this.metrics.increment('cache.hit', { cache: this.name });
+            return cached;
+        }
+        // NUL-separated, so no group/key pair can ever spell another pair's composite.
+        const composite = `${group}\u0000${key}`;
+        const { value, loaded } = await invocationLoads.run(composite, load, (fresh) => 
+        // A pass-through cache has no in-memory tier to publish into: every read loads, which is
+        // what `enabled: false` means. Publishing would be a no-op through the loader's noop
+        // cache, but saying so here keeps the pass-through stance readable.
+        this.enabled ? this.loader.forceSetValueForGroup(key, fresh, group) : Promise.resolve());
+        this.metrics.increment(loaded ? 'cache.miss' : 'cache.hit', { cache: this.name });
+        return value;
+    }
+    // Each invalidation bumps the generation directory AFTER the local invalidation resolves,
+    // and the write path awaits both, so "invalidate right after the write commits" spans the
+    // peers' view too. A single-key invalidation bumps its whole GROUP's counter: coarser than
+    // the local drop (peers re-load the group once), but the directory then never needs per-key
+    // state, and every coherent cache today keys group == key anyway. A bump failure fails open
+    // inside the tracker (peers heal at the TTL), so none of these can turn a committed write
+    // into a thrown request.
+    async invalidate(key, group) {
+        this.invocationLoads?.noteInvalidation();
+        await this.loader.invalidateCacheFor(key, group);
+        await this.coherency?.noteLocalInvalidation(this.name, group);
     }
-    invalidateGroup(group) {
-        return this.loader.invalidateCacheForGroup(group);
+    async invalidateGroup(group) {
+        this.invocationLoads?.noteInvalidation();
+        await this.loader.invalidateCacheForGroup(group);
+        await this.coherency?.noteLocalInvalidation(this.name, group);
     }
-    invalidateAll() {
-        return this.loader.invalidateCache();
+    async invalidateAll() {
+        if (this.coherency && !this.cacheWideInvalidation) {
+            // Refused rather than half-applied: without the declaration peers never probe the epoch
+            // counter, so this call would drop the entries on THIS instance while every other one
+            // kept serving them until their TTL, a coherency hole that looks like a working
+            // invalidation from the caller's side.
+            throw new Error(`cache '${this.name}' called invalidateAll() but its profile does not set ` +
+                `cacheWideInvalidation, so peer instances never probe the epoch counter this would ` +
+                `bump. Set it on the profile entry (it turns the epoch probe on for this cache).`);
+        }
+        this.invocationLoads?.noteInvalidation();
+        await this.loader.invalidateCache();
+        await this.coherency?.noteLocalInvalidation(this.name, CACHE_EPOCH_GROUP);
     }
     /** Releases the notification pair's resources along with the loader. */
     close() {
@@ -350,25 +521,36 @@ class LayeredGroupCacheHandle {
  */
 export function createAppCaches(options = {}) {
     const profile = { ...DEFAULT_APP_CACHES_PROFILE, ...options.profile };
-    const fragmentCatalog = buildGroupCache('fragment-catalog', profile.fragmentCatalog, options);
-    const skillCatalog = buildGroupCache('skill-catalog', profile.skillCatalog, options);
-    const foundationalServiceCatalog = buildGroupCache('foundational-service-catalog', profile.foundationalServiceCatalog, options);
-    const fragmentDocumentBody = buildGroupCache('fragment-document-body', profile.fragmentDocumentBody, options);
-    const linkedDocumentVersion = buildGroupCache('linked-document-version', profile.linkedDocumentVersion, options);
-    const repoProjection = buildGroupCache('repo-projection', profile.repoProjection, options);
-    const repoFiles = buildGroupCache('repo-files', profile.repoFiles, options);
-    const accountModelPolicy = buildGroupCache('account-model-policy', profile.accountModelPolicy, options);
-    const accountSettings = buildGroupCache('account-settings', profile.accountSettings, options);
-    const workspaceSettings = buildGroupCache('workspace-settings', profile.workspaceSettings, options);
-    const accountBudgetLimit = buildGroupCache('account-budget-limit', profile.accountBudgetLimit, options);
-    const userBudgetLimit = buildGroupCache('user-budget-limit', profile.userBudgetLimit, options);
-    const viewerRepos = buildGroupCache('viewer-repos', profile.viewerRepos, options);
-    const patInstallationRepos = buildGroupCache('pat-installation-repos', profile.patInstallationRepos, options);
-    const riskPolicy = buildGroupCache('risk-policy', profile.riskPolicy, options);
-    const modelPreset = buildGroupCache('model-preset', profile.modelPreset, options);
-    const workspaceAccess = buildGroupCache('workspace-access', profile.workspaceAccess, options);
-    const userSessionGeneration = buildGroupCache('user-session-generation', profile.userSessionGeneration, options);
-    const ssoDiscovery = buildGroupCache('sso-discovery', profile.ssoDiscovery, options);
+    assertCoherencyWirable(profile, options);
+    // One tracker serves the whole bag, so every coherent cache shares each group's probe.
+    const tracker = options.generationStore
+        ? new GroupGenerationTracker(options.generationStore, {
+            ...(options.logger ? { logger: options.logger } : {}),
+            ...(options.operationalMetrics ? { metrics: options.operationalMetrics } : {}),
+            // The probe is a Durable Object round trip, so its in-flight promise is subject to the
+            // same cross-invocation rule as a load: coalesce within one invocation, never across.
+            ...(options.currentInvocation ? { currentInvocation: options.currentInvocation } : {}),
+        })
+        : undefined;
+    const fragmentCatalog = buildGroupCache('fragment-catalog', profile.fragmentCatalog, options, tracker);
+    const skillCatalog = buildGroupCache('skill-catalog', profile.skillCatalog, options, tracker);
+    const foundationalServiceCatalog = buildGroupCache('foundational-service-catalog', profile.foundationalServiceCatalog, options, tracker);
+    const fragmentDocumentBody = buildGroupCache('fragment-document-body', profile.fragmentDocumentBody, options, tracker);
+    const linkedDocumentVersion = buildGroupCache('linked-document-version', profile.linkedDocumentVersion, options, tracker);
+    const repoProjection = buildGroupCache('repo-projection', profile.repoProjection, options, tracker);
+    const repoFiles = buildGroupCache('repo-files', profile.repoFiles, options, tracker);
+    const accountModelPolicy = buildGroupCache('account-model-policy', profile.accountModelPolicy, options, tracker);
+    const accountSettings = buildGroupCache('account-settings', profile.accountSettings, options, tracker);
+    const workspaceSettings = buildGroupCache('workspace-settings', profile.workspaceSettings, options, tracker);
+    const accountBudgetLimit = buildGroupCache('account-budget-limit', profile.accountBudgetLimit, options, tracker);
+    const userBudgetLimit = buildGroupCache('user-budget-limit', profile.userBudgetLimit, options, tracker);
+    const viewerRepos = buildGroupCache('viewer-repos', profile.viewerRepos, options, tracker);
+    const patInstallationRepos = buildGroupCache('pat-installation-repos', profile.patInstallationRepos, options, tracker);
+    const riskPolicy = buildGroupCache('risk-policy', profile.riskPolicy, options, tracker);
+    const modelPreset = buildGroupCache('model-preset', profile.modelPreset, options, tracker);
+    const workspaceAccess = buildGroupCache('workspace-access', profile.workspaceAccess, options, tracker);
+    const userSessionGeneration = buildGroupCache('user-session-generation', profile.userSessionGeneration, options, tracker);
+    const ssoDiscovery = buildGroupCache('sso-discovery', profile.ssoDiscovery, options, tracker);
     return {
         fragmentCatalog,
         skillCatalog,
@@ -414,8 +596,36 @@ export function createAppCaches(options = {}) {
         },
     };
 }
-function buildGroupCache(name, profile, options) {
+/**
+ * An enabled cache with a coherency window but no directory to probe would be a TTL'd cache
+ * of mutable state with no invalidation reaching it, the exact bug the isolate-safe profile
+ * exists to prevent, so the combination is refused at construction, not degraded.
+ */
+function assertCoherencyWirable(profile, options) {
+    if (options.generationStore)
+        return;
+    for (const [name, entry] of Object.entries(profile)) {
+        if (entry.enabled && entry.coherencyWindowMsecs !== undefined) {
+            throw new Error(`cache '${name}' sets coherencyWindowMsecs but createAppCaches got no generationStore; ` +
+                `wire one or drop the window (an enabled TTL'd cache of mutable state with no ` +
+                `coherency mechanism would serve stale data after a peer's write)`);
+        }
+    }
+}
+function buildGroupCache(name, profile, options, tracker) {
     const notifications = profile.enabled ? options.notificationPairFactory?.(name) : undefined;
-    return new LayeredGroupCacheHandle(name, profile, notifications, options.logger, options.operationalMetrics);
+    const coherency = tracker && profile.enabled && profile.coherencyWindowMsecs !== undefined
+        ? { tracker, windowMsecs: profile.coherencyWindowMsecs }
+        : undefined;
+    return new LayeredGroupCacheHandle(name, profile, {
+        ...(notifications ? { notifications } : {}),
+        ...(options.logger ? { logger: options.logger } : {}),
+        ...(options.operationalMetrics ? { metrics: options.operationalMetrics } : {}),
+        ...(coherency ? { coherency } : {}),
+        ...(options.scheduleBackgroundWork
+            ? { scheduleBackgroundWork: options.scheduleBackgroundWork }
+            : {}),
+        ...(options.currentInvocation ? { currentInvocation: options.currentInvocation } : {}),
+    });
 }
 //# sourceMappingURL=appCaches.js.map

package/dist/appCaches.js.map

@@ -1 +1 @@
-{"version":3,"file":"appCaches.js","sourceRoot":"","sources":["../src/appCaches.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"appCaches.js","sourceRoot":"","sources":["../src/appCaches.ts"],"names":[],"mappings":"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"}

package/dist/generationCoherency.d.ts

@@ -0,0 +1,116 @@
+import type { Logger, OperationalMetrics } from '@cat-factory/kernel';
+/**
+ * One shared, cross-instance generation directory. The contract every implementation must
+ * honour: counters are MONOTONIC per (cache, group) and a group's counters are readable in
+ * ONE round trip: the batched read is what lets every coherent cache share a single probe
+ * per group per window. On the Worker this is a Durable Object namespace sharded by group;
+ * tests inject an in-memory fake.
+ */
+export interface CacheGenerationStore {
+    /**
+     * Every cache's generation counter for one group. A cache absent from the result has
+     * generation 0 (never bumped).
+     */
+    getGenerations(group: string): Promise<Record<string, number>>;
+    /** Increment one cache's counter for a group; resolves to the NEW generation. */
+    bump(cacheName: string, group: string): Promise<number>;
+}
+/**
+ * The reserved group that carries cache-WIDE invalidation (`invalidateAll`) as an epoch
+ * counter, so the store interface stays two methods. It is probed beside the real group on
+ * its own timestamp, and a moved epoch maps to a full local clear.
+ */
+export declare const CACHE_EPOCH_GROUP = "*";
+/** What one coherent cache hands the tracker: its identity, cadence, and the 16.1 primitives. */
+export interface CoherentCacheRegistration {
+    cacheName: string;
+    /** Probe cadence; a group snapshot older than this re-reads the directory before serving. */
+    windowMsecs: number;
+    /**
+     * Whether this cache ever invalidates CACHE-WIDE, and so needs the reserved epoch group
+     * probed beside its own.
+     *
+     * Declared per cache because the epoch shard is ONE globally-placed Durable Object: probing
+     * it is a cross-colo round trip awaited on the read path of every isolate, and a cache with
+     * no `invalidateAll` call site can never move that counter, so it would be a round trip that
+     * structurally cannot return news. Declared rather than inferred from call sites, and the
+     * handle REFUSES an undeclared `invalidateAll` rather than dropping entries locally while
+     * peers keep serving them.
+     */
+    probesEpoch: boolean;
+    /** layered-loader's local, fencing, non-publishing group invalidation. */
+    applyRemoteInvalidationForGroup(group: string): void;
+    /** Its cache-wide form, for a moved epoch. */
+    applyRemoteInvalidation(): void;
+}
+export interface GroupGenerationTrackerOptions {
+    logger?: Logger;
+    metrics?: OperationalMetrics;
+    now?: () => number;
+    /**
+     * Supplied ONLY by an isolate runtime; see `CreateAppCachesOptions.currentInvocation`. It
+     * decides which in-flight probes may be joined. Absent ⇒ every probe coalesces, which is
+     * correct wherever one I/O context serves everything.
+     */
+    currentInvocation?: () => object | undefined;
+    /**
+     * LRU bound on per-group bookkeeping. Evicting a group loses its baselines, which the next
+     * probe treats as "possibly missed a bump" and re-invalidates (an over-invalidation, never
+     * a stale serve), so the bound trades a little re-loading for bounded memory.
+     */
+    maxTrackedGroups?: number;
+}
+/**
+ * The per-instance bookkeeping half of the scheme: which generation each (cache, group) was
+ * last seen at, when each group was last probed, and the application of a moved counter onto
+ * the registered caches. One tracker serves the whole cache bag, so all coherent caches share
+ * each group's probe.
+ *
+ * Error posture, deliberately asymmetric:
+ * - a PROBE failure fails CLOSED: the affected caches are locally invalidated and the read
+ *   loads fresh, so a directory outage degrades to pass-through performance, never to serving
+ *   stale (`container.ts`'s "a stale-serving cache would be a correctness bug" stance);
+ * - a BUMP failure fails OPEN: the write and its local invalidation already happened, peers
+ *   heal at the cache TTL, and the counter + warn line are the visible trace.
+ */
+export declare class GroupGenerationTracker {
+    private readonly store;
+    private readonly registrations;
+    private readonly groups;
+    /** Held outside the LRU map: the epoch baseline must never be evicted. */
+    private readonly epoch;
+    private readonly log;
+    private readonly metrics;
+    private readonly now;
+    private readonly maxTrackedGroups;
+    private readonly currentInvocation;
+    constructor(store: CacheGenerationStore, options?: GroupGenerationTrackerOptions);
+    register(registration: CoherentCacheRegistration): void;
+    /**
+     * Called by a coherent handle before its read. Resolves without I/O while the group's (and
+     * the epoch's) snapshot is inside the calling cache's window; otherwise one coalesced store
+     * round trip refreshes every registered cache's view of the group. Never rejects.
+     */
+    ensureFresh(cacheName: string, group: string): Promise<void>;
+    /**
+     * Called by a coherent handle AFTER its local invalidation, awaited by the write path so
+     * "invalidate right after the write commits" spans the directory too. The returned
+     * generation is max-merged into the baseline, so the writing instance's next probe does not
+     * read its own bump as a peer's change and re-invalidate what it just reloaded.
+     */
+    noteLocalInvalidation(cacheName: string, group: string): Promise<void>;
+    private isStale;
+    /** LRU-touch the group's state, evicting the oldest when over the bound. */
+    private touchGroup;
+    private probe;
+    private runProbe;
+    /**
+     * The caches one probe speaks for. A GROUP probe speaks for every registered cache (they
+     * share the group's shard, which is what makes the batched read worth doing); an EPOCH probe
+     * speaks only for those that declared a cache-wide invalidation path, so a cache that opted
+     * out is neither invalidated by it nor has its baseline moved by it.
+     */
+    private affectedBy;
+    private applyInvalidation;
+}
+//# sourceMappingURL=generationCoherency.d.ts.map

package/dist/generationCoherency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generationCoherency.d.ts","sourceRoot":"","sources":["../src/generationCoherency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAgBrE;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC9D,iFAAiF;IACjF,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CACxD;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAA;AAEpC,iGAAiG;AACjG,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAA;IACjB,6FAA6F;IAC7F,WAAW,EAAE,MAAM,CAAA;IACnB;;;;;;;;;;OAUG;IACH,WAAW,EAAE,OAAO,CAAA;IACpB,0EAA0E;IAC1E,+BAA+B,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpD,8CAA8C;IAC9C,uBAAuB,IAAI,IAAI,CAAA;CAChC;AAuBD,MAAM,WAAW,6BAA6B;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,kBAAkB,CAAA;IAC5B,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;IAClB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,MAAM,GAAG,SAAS,CAAA;IAC5C;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAsB;IAgB/B,OAAO,CAAC,QAAQ,CAAC,KAAK;IAfxB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA+C;IAC7E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,0EAA0E;IAC1E,OAAO,CAAC,QAAQ,CAAC,KAAK,CAIrB;IACD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAoB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAc;IAClC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAQ;IACzC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA0B;IAE5D,YACmB,KAAK,EAAE,oBAAoB,EAC5C,OAAO,GAAE,6BAAkC,EAO5C;IAED,QAAQ,CAAC,YAAY,EAAE,yBAAyB,GAAG,IAAI,CAEtD;IAED;;;;OAIG;IACG,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYjE;IAED;;;;;OAKG;IACG,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAa3E;IAED,OAAO,CAAC,OAAO;IAIf,4EAA4E;IAC5E,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,KAAK;YAgBC,QAAQ;IAoCtB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAKlB,OAAO,CAAC,iBAAiB;CAQ1B"}

package/dist/generationCoherency.js

@@ -0,0 +1,188 @@
+import { describeError, noopOperationalMetrics } from '@cat-factory/kernel';
+/**
+ * The reserved group that carries cache-WIDE invalidation (`invalidateAll`) as an epoch
+ * counter, so the store interface stays two methods. It is probed beside the real group on
+ * its own timestamp, and a moved epoch maps to a full local clear.
+ */
+export const CACHE_EPOCH_GROUP = '*';
+/**
+ * The stand-in invocation for a runtime that has no such concept: one process serving every
+ * request out of one I/O context, so every probe belongs to the same "invocation" and
+ * coalescing behaves exactly as it did before the distinction existed.
+ */
+const SINGLE_INVOCATION = { runtime: 'single-context' };
+/**
+ * The per-instance bookkeeping half of the scheme: which generation each (cache, group) was
+ * last seen at, when each group was last probed, and the application of a moved counter onto
+ * the registered caches. One tracker serves the whole cache bag, so all coherent caches share
+ * each group's probe.
+ *
+ * Error posture, deliberately asymmetric:
+ * - a PROBE failure fails CLOSED: the affected caches are locally invalidated and the read
+ *   loads fresh, so a directory outage degrades to pass-through performance, never to serving
+ *   stale (`container.ts`'s "a stale-serving cache would be a correctness bug" stance);
+ * - a BUMP failure fails OPEN: the write and its local invalidation already happened, peers
+ *   heal at the cache TTL, and the counter + warn line are the visible trace.
+ */
+export class GroupGenerationTracker {
+    store;
+    registrations = new Map();
+    groups = new Map();
+    /** Held outside the LRU map: the epoch baseline must never be evicted. */
+    epoch = {
+        lastProbeAt: undefined,
+        generations: new Map(),
+        inflight: undefined,
+    };
+    log;
+    metrics;
+    now;
+    maxTrackedGroups;
+    currentInvocation;
+    constructor(store, options = {}) {
+        this.store = store;
+        this.log = options.logger;
+        this.metrics = options.metrics ?? noopOperationalMetrics;
+        this.now = options.now ?? Date.now;
+        this.maxTrackedGroups = options.maxTrackedGroups ?? 2000;
+        this.currentInvocation = options.currentInvocation ?? (() => SINGLE_INVOCATION);
+    }
+    register(registration) {
+        this.registrations.set(registration.cacheName, registration);
+    }
+    /**
+     * Called by a coherent handle before its read. Resolves without I/O while the group's (and
+     * the epoch's) snapshot is inside the calling cache's window; otherwise one coalesced store
+     * round trip refreshes every registered cache's view of the group. Never rejects.
+     */
+    async ensureFresh(cacheName, group) {
+        const registration = this.registrations.get(cacheName);
+        if (!registration)
+            return;
+        const probes = [];
+        const groupState = this.touchGroup(group);
+        if (this.isStale(groupState, registration.windowMsecs)) {
+            probes.push(this.probe(groupState, group));
+        }
+        if (registration.probesEpoch && this.isStale(this.epoch, registration.windowMsecs)) {
+            probes.push(this.probe(this.epoch, CACHE_EPOCH_GROUP));
+        }
+        if (probes.length > 0)
+            await Promise.all(probes);
+    }
+    /**
+     * Called by a coherent handle AFTER its local invalidation, awaited by the write path so
+     * "invalidate right after the write commits" spans the directory too. The returned
+     * generation is max-merged into the baseline, so the writing instance's next probe does not
+     * read its own bump as a peer's change and re-invalidate what it just reloaded.
+     */
+    async noteLocalInvalidation(cacheName, group) {
+        try {
+            const generation = await this.store.bump(cacheName, group);
+            const state = group === CACHE_EPOCH_GROUP ? this.epoch : this.touchGroup(group);
+            mergeGeneration(state, cacheName, generation);
+        }
+        catch (error) {
+            this.metrics.increment('cache.coherency_bump_failure', { cache: cacheName });
+            this.log?.warn('cache coherency bump failed; peers heal at the cache TTL', {
+                cache: cacheName,
+                group,
+                ...describeError(error),
+            });
+        }
+    }
+    isStale(state, windowMsecs) {
+        return state.lastProbeAt === undefined || this.now() - state.lastProbeAt >= windowMsecs;
+    }
+    /** LRU-touch the group's state, evicting the oldest when over the bound. */
+    touchGroup(group) {
+        let state = this.groups.get(group);
+        if (state) {
+            this.groups.delete(group);
+        }
+        else {
+            state = { lastProbeAt: undefined, generations: new Map(), inflight: undefined };
+        }
+        this.groups.set(group, state);
+        if (this.groups.size > this.maxTrackedGroups) {
+            const oldest = this.groups.keys().next().value;
+            if (oldest !== undefined)
+                this.groups.delete(oldest);
+        }
+        return state;
+    }
+    probe(state, group) {
+        const invocation = this.currentInvocation();
+        const inflight = state.inflight;
+        // `undefined` never matches, not even itself: an invocation the runtime cannot name is one
+        // this probe cannot prove it shares an I/O context with, and joining wrongly is fatal where
+        // starting a second probe merely costs a round trip.
+        if (inflight && invocation !== undefined && inflight.invocation === invocation) {
+            return inflight.promise;
+        }
+        const promise = this.runProbe(state, group).finally(() => {
+            if (state.inflight?.promise === promise)
+                state.inflight = undefined;
+        });
+        state.inflight = { invocation, promise };
+        return promise;
+    }
+    async runProbe(state, group) {
+        const scope = group === CACHE_EPOCH_GROUP ? 'epoch' : 'group';
+        try {
+            const fetched = await this.store.getGenerations(group);
+            this.metrics.increment('cache.coherency_probe', { scope });
+            for (const registration of this.affectedBy(scope)) {
+                const generation = fetched[registration.cacheName] ?? 0;
+                // Counters are monotonic, so only a HIGHER generation is a peer's change: a lower one
+                // can only be a store read racing this instance's own concurrent bump. An evicted or
+                // never-seen baseline reads as 0, so any bump that ever happened re-invalidates,
+                // over-invalidation, never a stale serve.
+                const changed = generation > (state.generations.get(registration.cacheName) ?? 0);
+                if (changed) {
+                    this.applyInvalidation(registration, scope, group);
+                    this.metrics.increment('cache.coherency_invalidation', {
+                        cache: registration.cacheName,
+                    });
+                }
+                mergeGeneration(state, registration.cacheName, generation);
+            }
+            state.lastProbeAt = this.now();
+        }
+        catch (error) {
+            // Fail CLOSED: invalidate locally and leave the window stale, so reads load fresh (and
+            // re-probe) until the directory answers again: pass-through performance, zero staleness.
+            this.metrics.increment('cache.coherency_probe_failure', { scope });
+            for (const registration of this.affectedBy(scope)) {
+                this.applyInvalidation(registration, scope, group);
+            }
+            this.log?.warn('cache coherency probe failed; affected reads load fresh', {
+                scope,
+                group,
+                ...describeError(error),
+            });
+        }
+    }
+    /**
+     * The caches one probe speaks for. A GROUP probe speaks for every registered cache (they
+     * share the group's shard, which is what makes the batched read worth doing); an EPOCH probe
+     * speaks only for those that declared a cache-wide invalidation path, so a cache that opted
+     * out is neither invalidated by it nor has its baseline moved by it.
+     */
+    affectedBy(scope) {
+        const all = [...this.registrations.values()];
+        return scope === 'epoch' ? all.filter((registration) => registration.probesEpoch) : all;
+    }
+    applyInvalidation(registration, scope, group) {
+        if (scope === 'epoch')
+            registration.applyRemoteInvalidation();
+        else
+            registration.applyRemoteInvalidationForGroup(group);
+    }
+}
+function mergeGeneration(state, cacheName, generation) {
+    const current = state.generations.get(cacheName) ?? 0;
+    if (generation > current)
+        state.generations.set(cacheName, generation);
+}
+//# sourceMappingURL=generationCoherency.js.map

package/dist/generationCoherency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generationCoherency.js","sourceRoot":"","sources":["../src/generationCoherency.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -1,3 +1,6 @@
-export { createAppCaches, DEFAULT_APP_CACHES_PROFILE, ISOLATE_SAFE_APP_CACHES_PROFILE, } from './appCaches.js';
+export { createAppCaches, DEFAULT_APP_CACHES_PROFILE, ISOLATE_COHERENT_APP_CACHES_PROFILE, ISOLATE_SAFE_APP_CACHES_PROFILE, } from './appCaches.js';
 export type { AppCachesProfile, CreateAppCachesOptions, GroupCacheNotifications, GroupCacheProfile, GroupNotificationPairFactory, } from './appCaches.js';
+export { CACHE_EPOCH_GROUP } from './generationCoherency.js';
+export type { CacheGenerationStore } from './generationCoherency.js';
+export type { BackgroundWorkMeta, BackgroundWorkScheduler } from 'layered-loader/core';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,0BAA0B,EAC1B,+BAA+B,GAChC,MAAM,gBAAgB,CAAA;AACvB,YAAY,EACV,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,4BAA4B,GAC7B,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,0BAA0B,EAC1B,mCAAmC,EACnC,+BAA+B,GAChC,MAAM,gBAAgB,CAAA;AACvB,YAAY,EACV,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,4BAA4B,GAC7B,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,YAAY,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAIpE,YAAY,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/index.js

@@ -1,2 +1,3 @@
-export { createAppCaches, DEFAULT_APP_CACHES_PROFILE, ISOLATE_SAFE_APP_CACHES_PROFILE, } from './appCaches.js';
+export { createAppCaches, DEFAULT_APP_CACHES_PROFILE, ISOLATE_COHERENT_APP_CACHES_PROFILE, ISOLATE_SAFE_APP_CACHES_PROFILE, } from './appCaches.js';
+export { CACHE_EPOCH_GROUP } from './generationCoherency.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,0BAA0B,EAC1B,+BAA+B,GAChC,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,0BAA0B,EAC1B,mCAAmC,EACnC,+BAA+B,GAChC,MAAM,gBAAgB,CAAA;AAQvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/invocationScopedLoads.d.ts

@@ -0,0 +1,38 @@
+/** The outcome of one guarded read, so the caller keeps owning its hit/miss accounting. */
+export interface InvocationScopedLoadResult<T> {
+    value: T;
+    /** Whether THIS caller ran the load, as opposed to joining one already in flight. */
+    loaded: boolean;
+}
+/**
+ * Per-invocation coalescing of cache-miss loads, plus the local fence their publish needs.
+ *
+ * One instance per cache handle. `currentInvocation` returns an object identifying the
+ * invocation being served, or `undefined` outside any bracketed entry point (a Workflows step,
+ * which has no ExecutionContext). An absent invocation coalesces with NOTHING, because
+ * two loads that cannot be told apart must be assumed to belong to different contexts.
+ */
+export declare class InvocationScopedLoads<T> {
+    private readonly currentInvocation;
+    /**
+     * In-flight loads, partitioned by invocation so a lookup can never return another
+     * invocation's promise. Weak, so an invocation's partition is collected with it: an entry
+     * point that ends mid-load leaks neither the map nor the promise.
+     */
+    private readonly inFlight;
+    /** Monotonic; every invalidation of this cache bumps it. See {@link loadAndPublish}. */
+    private invalidations;
+    constructor(currentInvocation: () => object | undefined);
+    /**
+     * Record that this cache was invalidated, from any source: its own write path, or a
+     * coherency probe applying a peer's. Breaks the fence for every load currently in flight.
+     */
+    noteInvalidation(): void;
+    /**
+     * Run (or join, within this same invocation only) the load for one cache key, publishing the
+     * result through `publish` when the fence holds.
+     */
+    run(cacheKey: string, load: () => Promise<T>, publish: (value: T) => Promise<void>): Promise<InvocationScopedLoadResult<T>>;
+    private loadAndPublish;
+}
+//# sourceMappingURL=invocationScopedLoads.d.ts.map

package/dist/invocationScopedLoads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invocationScopedLoads.d.ts","sourceRoot":"","sources":["../src/invocationScopedLoads.ts"],"names":[],"mappings":"AAmBA,2FAA2F;AAC3F,MAAM,WAAW,0BAA0B,CAAC,CAAC;IAC3C,KAAK,EAAE,CAAC,CAAA;IACR,qFAAqF;IACrF,MAAM,EAAE,OAAO,CAAA;CAChB;AAED;;;;;;;GAOG;AACH,qBAAa,qBAAqB,CAAC,CAAC;IAUtB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAT9C;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiD;IAC1E,wFAAwF;IACxF,OAAO,CAAC,aAAa,CAAI;IAEzB,YAA6B,iBAAiB,EAAE,MAAM,MAAM,GAAG,SAAS,EAAI;IAE5E;;;OAGG;IACH,gBAAgB,IAAI,IAAI,CAEvB;IAED;;;OAGG;IACG,GAAG,CACP,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACtB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GACnC,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAqBxC;YAEa,cAAc;CAc7B"}

package/dist/invocationScopedLoads.js

@@ -0,0 +1,87 @@
+// Load scoping for ISOLATE runtimes, where a promise may not outlive the invocation that
+// created it.
+//
+// On Cloudflare Workers every invocation gets its own I/O context, and a promise created while
+// serving one may never be awaited by another: workerd destroys the joining invocation with
+// "Cannot perform I/O on behalf of a different request". That fault is raised at the RUNTIME
+// level, so the joining code cannot catch it: its work simply disappears, which is why this
+// cannot be handled where it surfaces and has to be made impossible instead.
+//
+// The app cache bag is one per ISOLATE (that is what makes the entries caches rather than
+// per-invocation memos), so layered-loader's in-flight load coalescing (`runningLoads`) would
+// hand exactly such a promise to a second concurrent invocation on every same-key MISS. This
+// guard keeps the coalescing where it is safe (within ONE invocation, which is the common case
+// it exists for: a batch read issuing the same key twice) and removes it where it is not.
+//
+// Nothing here is needed on Node, where one process serves every request out of one I/O
+// context; a facade that supplies no `currentInvocation` keeps layered-loader's own load path
+// unchanged.
+/**
+ * Per-invocation coalescing of cache-miss loads, plus the local fence their publish needs.
+ *
+ * One instance per cache handle. `currentInvocation` returns an object identifying the
+ * invocation being served, or `undefined` outside any bracketed entry point (a Workflows step,
+ * which has no ExecutionContext). An absent invocation coalesces with NOTHING, because
+ * two loads that cannot be told apart must be assumed to belong to different contexts.
+ */
+export class InvocationScopedLoads {
+    currentInvocation;
+    /**
+     * In-flight loads, partitioned by invocation so a lookup can never return another
+     * invocation's promise. Weak, so an invocation's partition is collected with it: an entry
+     * point that ends mid-load leaks neither the map nor the promise.
+     */
+    inFlight = new WeakMap();
+    /** Monotonic; every invalidation of this cache bumps it. See {@link loadAndPublish}. */
+    invalidations = 0;
+    constructor(currentInvocation) {
+        this.currentInvocation = currentInvocation;
+    }
+    /**
+     * Record that this cache was invalidated, from any source: its own write path, or a
+     * coherency probe applying a peer's. Breaks the fence for every load currently in flight.
+     */
+    noteInvalidation() {
+        this.invalidations += 1;
+    }
+    /**
+     * Run (or join, within this same invocation only) the load for one cache key, publishing the
+     * result through `publish` when the fence holds.
+     */
+    async run(cacheKey, load, publish) {
+        const invocation = this.currentInvocation();
+        if (!invocation) {
+            return { value: await this.loadAndPublish(load, publish), loaded: true };
+        }
+        let partition = this.inFlight.get(invocation);
+        if (!partition) {
+            partition = new Map();
+            this.inFlight.set(invocation, partition);
+        }
+        const joined = partition.get(cacheKey);
+        // Safe to await: this promise was created while serving THIS invocation.
+        if (joined)
+            return { value: await joined, loaded: false };
+        const loading = this.loadAndPublish(load, publish);
+        partition.set(cacheKey, loading);
+        try {
+            return { value: await loading, loaded: true };
+        }
+        finally {
+            partition.delete(cacheKey);
+        }
+    }
+    async loadAndPublish(load, publish) {
+        const fence = this.invalidations;
+        const value = await load();
+        // Publish only when no invalidation landed while the load was running, or a late write
+        // would resurrect the entry that invalidation dropped. layered-loader fences its own load
+        // path this way (`backgroundWriteFences`); this path is ours, so the fence is ours too.
+        // The counter is cache-WIDE rather than per key, so an unrelated invalidation costs one
+        // skipped cache write: over-invalidation, never a stale serve.
+        if (this.invalidations === fence)
+            await publish(value);
+        return value;
+    }
+}
+//# sourceMappingURL=invocationScopedLoads.js.map

package/dist/invocationScopedLoads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invocationScopedLoads.js","sourceRoot":"","sources":["../src/invocationScopedLoads.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,cAAc;AACd,EAAE;AACF,+FAA+F;AAC/F,4FAA4F;AAC5F,6FAA6F;AAC7F,4FAA4F;AAC5F,6EAA6E;AAC7E,EAAE;AACF,0FAA0F;AAC1F,8FAA8F;AAC9F,6FAA6F;AAC7F,+FAA+F;AAC/F,0FAA0F;AAC1F,EAAE;AACF,wFAAwF;AACxF,8FAA8F;AAC9F,aAAa;AASb;;;;;;;GAOG;AACH,MAAM,OAAO,qBAAqB;IAUH,iBAAiB;IAT9C;;;;OAIG;IACc,QAAQ,GAAG,IAAI,OAAO,EAAmC,CAAA;IAC1E,wFAAwF;IAChF,aAAa,GAAG,CAAC,CAAA;IAEzB,YAA6B,iBAA2C;iCAA3C,iBAAiB;IAA6B,CAAC;IAE5E;;;OAGG;IACH,gBAAgB;QACd,IAAI,CAAC,aAAa,IAAI,CAAC,CAAA;IACzB,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,GAAG,CACP,QAAgB,EAChB,IAAsB,EACtB,OAAoC;QAEpC,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAA;QAC3C,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,OAAO,EAAE,KAAK,EAAE,MAAM,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAA;QAC1E,CAAC;QACD,IAAI,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;QAC7C,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,SAAS,GAAG,IAAI,GAAG,EAAE,CAAA;YACrB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,EAAE,SAAS,CAAC,CAAA;QAC1C,CAAC;QACD,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QACtC,yEAAyE;QACzE,IAAI,MAAM;YAAE,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAA;QAEzD,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;QAClD,SAAS,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;QAChC,IAAI,CAAC;YACH,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAA;QAC/C,CAAC;gBAAS,CAAC;YACT,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;QAC5B,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,cAAc,CAC1B,IAAsB,EACtB,OAAoC;QAEpC,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAA;QAChC,MAAM,KAAK,GAAG,MAAM,IAAI,EAAE,CAAA;QAC1B,uFAAuF;QACvF,0FAA0F;QAC1F,wFAAwF;QACxF,wFAAwF;QACxF,+DAA+D;QAC/D,IAAI,IAAI,CAAC,aAAa,KAAK,KAAK;YAAE,MAAM,OAAO,CAAC,KAAK,CAAC,CAAA;QACtD,OAAO,KAAK,CAAA;IACd,CAAC;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/caching",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "description": "The app-level caching seam for the Agent Architecture Board (docs/initiatives/caching-layer.md): createAppCaches builds the named, typed in-memory read-through caches (layered-loader) the services consume via the kernel AppCaches port, with optional distributed invalidation over an injected Redis notification pair. Redis is only ever an invalidation bus, never a data tier.",
   "repository": {
     "type": "git",
@@ -24,8 +24,8 @@
     "access": "public"
   },
   "dependencies": {
-    "layered-loader": "^16.0.0",
-    "@cat-factory/kernel": "0.260.0"
+    "layered-loader": "^16.1.0",
+    "@cat-factory/kernel": "0.261.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",