@dbx-tools/appkit 0.9.93 → 0.9.99

package/README.md

@@ -20,6 +20,8 @@ without taking on a heavier feature package.
   `Context` values.
 - Lakebase cache-schema provisioning for deployments where the app identity must
   be granted access before persistent cache initialization.
+- AppKit-global filesystem caching with user-isolated bounded L1 state,
+  cross-user invalidation, and stable framework filesystem sources.
 - An interceptor context on `createApp` (`interceptor?: Interceptor | Interceptor[]`)
   that hands add-ons the computed env, AppKit lifecycle hooks (`onLifecycle`, using
   AppKit's own `setup:complete` / `server:ready` / `shutdown` vocabulary).
@@ -136,6 +138,44 @@ The injected persistent storage includes a bounded process-local L1 powered by
 expiry, deletion, and clear operations remain coherent with the persistent
 store.
 
+## Filesystem Cache Plugin
+
+Register `filesCache()` when provider-backed filesystems should share one
+AppKit-lifecycle cache:
+
+```ts
+import { filesCache } from "@dbx-tools/appkit/files-cache";
+import { server } from "@databricks/appkit";
+import { appkit } from "@dbx-tools/appkit";
+
+await appkit.createApp({
+  plugins: [server(), filesCache()],
+});
+```
+
+The plugin exposes `forScope({ host, workspaceId?, userKey, ttlMs? })`, which
+returns the `FileSystemCache` consumed by `@dbx-tools/shared-fs` `fs.cache()`.
+Values are isolated by host, optional workspace id, and attributed user. A
+batched invalidation clears matching keys across active user scopes without
+sharing authorization-sensitive values.
+
+`forFileSystem(scope, { paths, key? }, load)` retains one framework filesystem
+source for the same user and actual mounted paths. `key` separates framework
+instances that use different policies over the same paths. This gives frameworks
+such as Mastra a stable source identity across page refreshes and turns without
+introducing a second parsed catalogue cache.
+
+Values and retained filesystem sources use a bounded process-local `lru-cache`.
+Nothing is written to Lakebase or another persistent store. App restarts and
+replica changes begin with a cold filesystem cache.
+
+This cache is intentionally separate from AppKit's exported `CacheManager`.
+`CacheManager` owns the application cache and may use Lakebase with an internal
+process-local L1; that L1 is not a public standalone store, and cache writes can
+flow through to persistent storage. `FilesCachePlugin` therefore remains the
+single app-lifetime owner for local-only filesystem values rather than reaching
+into AppKit internals or creating one cache per workspace.
+
 `lakebaseResolver.resolveLakebaseConnection()` accepts:
 
 | Option       | Type                                 | Default                                  | Description                                                                                                    |

package/index.ts

@@ -3,12 +3,13 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit";
-export const PACKAGE_VERSION = "0.9.93";
+export const PACKAGE_VERSION = "0.9.99";
 export * as appkit from "./src/appkit.ts";
 export * as brandContext from "./src/brand-context.ts";
 export * as bundle from "./src/bundle.ts";
 export * as childProcess from "./src/child-process.ts";
 export * as databricks from "./src/databricks.ts";
+export * as filesCache from "./src/files-cache.ts";
 export * as identity from "./src/identity.ts";
 export * as interceptor from "./src/interceptor.ts";
 export * as lakebaseResolver from "./src/lakebase-resolver.ts";
@@ -26,6 +27,8 @@ export type { BundleValidateJson, ConfigFile, ConfigMapValue, ConfigSource, Reso
 export { AppKitChildProcess } from "./src/child-process.ts";
 export type { AppKitSpawnArgs, AppKitChildProcessHealthCheckContext, AppKitChildProcessHealthCheck, AppKitChildProcessOptions, AppKitChildProcessRunOptions } from "./src/child-process.ts";
 export type { ContextLike } from "./src/databricks.ts";
+export { FilesCacheManager, FilesCachePlugin } from "./src/files-cache.ts";
+export type { FilesCachePluginConfig, FilesCacheScope, FilesCacheSourceIdentity, FilesCacheExports } from "./src/files-cache.ts";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES, DEFAULT_IDENTITY_MODE } from "./src/identity.ts";
 export type { IdentityMode, HeaderBearing } from "./src/identity.ts";
 export { LifecycleBridgePlugin, lifecycleBridge } from "./src/interceptor.ts";

package/lib/index.d.ts

@@ -1,10 +1,11 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/appkit";
-export declare const PACKAGE_VERSION = "0.9.93";
+export declare const PACKAGE_VERSION = "0.9.99";
 export * as appkit from "./src/appkit.ts";
 export * as brandContext from "./src/brand-context.ts";
 export * as bundle from "./src/bundle.ts";
 export * as childProcess from "./src/child-process.ts";
 export * as databricks from "./src/databricks.ts";
+export * as filesCache from "./src/files-cache.ts";
 export * as identity from "./src/identity.ts";
 export * as interceptor from "./src/interceptor.ts";
 export * as lakebaseResolver from "./src/lakebase-resolver.ts";
@@ -22,6 +23,8 @@ export type { BundleValidateJson, ConfigFile, ConfigMapValue, ConfigSource, Reso
 export { AppKitChildProcess } from "./src/child-process.ts";
 export type { AppKitSpawnArgs, AppKitChildProcessHealthCheckContext, AppKitChildProcessHealthCheck, AppKitChildProcessOptions, AppKitChildProcessRunOptions } from "./src/child-process.ts";
 export type { ContextLike } from "./src/databricks.ts";
+export { FilesCacheManager, FilesCachePlugin } from "./src/files-cache.ts";
+export type { FilesCachePluginConfig, FilesCacheScope, FilesCacheSourceIdentity, FilesCacheExports } from "./src/files-cache.ts";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES, DEFAULT_IDENTITY_MODE } from "./src/identity.ts";
 export type { IdentityMode, HeaderBearing } from "./src/identity.ts";
 export { LifecycleBridgePlugin, lifecycleBridge } from "./src/interceptor.ts";

package/lib/index.js

@@ -2,12 +2,13 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit";
-export const PACKAGE_VERSION = "0.9.93";
+export const PACKAGE_VERSION = "0.9.99";
 export * as appkit from "./src/appkit.js";
 export * as brandContext from "./src/brand-context.js";
 export * as bundle from "./src/bundle.js";
 export * as childProcess from "./src/child-process.js";
 export * as databricks from "./src/databricks.js";
+export * as filesCache from "./src/files-cache.js";
 export * as identity from "./src/identity.js";
 export * as interceptor from "./src/interceptor.js";
 export * as lakebaseResolver from "./src/lakebase-resolver.js";
@@ -21,8 +22,9 @@ export * as toolProvider from "./src/tool-provider.js";
 export * as toolkitEntries from "./src/toolkit-entries.js";
 export { bundleAppResourceSchema, flattenAppYamlEnv, flattenAppEnv, getBundlePath } from "./src/bundle.js";
 export { AppKitChildProcess } from "./src/child-process.js";
+export { FilesCacheManager, FilesCachePlugin } from "./src/files-cache.js";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES, DEFAULT_IDENTITY_MODE } from "./src/identity.js";
 export { LifecycleBridgePlugin, lifecycleBridge } from "./src/interceptor.js";
 export { SSL_MODES } from "./src/pgaddress.js";
 export { ToolRegistryPlugin } from "./src/tool-provider.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxtQkFBbUIsQ0FBQztBQUN0RCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsUUFBUSxDQUFDO0FBQ3hDLE9BQU8sS0FBSyxNQUFNLE1BQU0saUJBQWlCLENBQUM7QUFDMUMsT0FBTyxLQUFLLFlBQVksTUFBTSx3QkFBd0IsQ0FBQztBQUN2RCxPQUFPLEtBQUssTUFBTSxNQUFNLGlCQUFpQixDQUFDO0FBQzFDLE9BQU8sS0FBSyxZQUFZLE1BQU0sd0JBQXdCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFVBQVUsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEtBQUssVUFBVSxNQUFNLHNCQUFzQixDQUFDO0FBQ25ELE9BQU8sS0FBSyxRQUFRLE1BQU0sbUJBQW1CLENBQUM7QUFDOUMsT0FBTyxLQUFLLFdBQVcsTUFBTSxzQkFBc0IsQ0FBQztBQUNwRCxPQUFPLEtBQUssZ0JBQWdCLE1BQU0sNEJBQTRCLENBQUM7QUFDL0QsT0FBTyxLQUFLLFNBQVMsTUFBTSxvQkFBb0IsQ0FBQztBQUNoRCxPQUFPLEtBQUssU0FBUyxNQUFNLG9CQUFvQixDQUFDO0FBQ2hELE9BQU8sS0FBSyxlQUFlLE1BQU0sMkJBQTJCLENBQUM7QUFDN0QsT0FBTyxLQUFLLGNBQWMsTUFBTSwwQkFBMEIsQ0FBQztBQUMzRCxPQUFPLEtBQUssU0FBUyxNQUFNLG9CQUFvQixDQUFDO0FBQ2hELE9BQU8sS0FBSyxXQUFXLE1BQU0sdUJBQXVCLENBQUM7QUFDckQsT0FBTyxLQUFLLFlBQVksTUFBTSx3QkFBd0IsQ0FBQztBQUN2RCxPQUFPLEtBQUssY0FBYyxNQUFNLDBCQUEwQixDQUFDO0FBRTNELE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxpQkFBaUIsRUFBRSxhQUFhLEVBQUUsYUFBYSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFM0csT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFHNUQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLGdCQUFnQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFM0UsT0FBTyxFQUFFLG1CQUFtQixFQUFFLGNBQWMsRUFBRSxpQkFBaUIsRUFBRSxjQUFjLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUVsSSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsZUFBZSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFJOUUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBSy9DLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfSURFTlRJRklFUiA9IFwiQGRieC10b29scy9hcHBraXRcIjtcbmV4cG9ydCBjb25zdCBQQUNLQUdFX1ZFUlNJT04gPSBcIjAuOS45OVwiO1xuZXhwb3J0ICogYXMgYXBwa2l0IGZyb20gXCIuL3NyYy9hcHBraXQudHNcIjtcbmV4cG9ydCAqIGFzIGJyYW5kQ29udGV4dCBmcm9tIFwiLi9zcmMvYnJhbmQtY29udGV4dC50c1wiO1xuZXhwb3J0ICogYXMgYnVuZGxlIGZyb20gXCIuL3NyYy9idW5kbGUudHNcIjtcbmV4cG9ydCAqIGFzIGNoaWxkUHJvY2VzcyBmcm9tIFwiLi9zcmMvY2hpbGQtcHJvY2Vzcy50c1wiO1xuZXhwb3J0ICogYXMgZGF0YWJyaWNrcyBmcm9tIFwiLi9zcmMvZGF0YWJyaWNrcy50c1wiO1xuZXhwb3J0ICogYXMgZmlsZXNDYWNoZSBmcm9tIFwiLi9zcmMvZmlsZXMtY2FjaGUudHNcIjtcbmV4cG9ydCAqIGFzIGlkZW50aXR5IGZyb20gXCIuL3NyYy9pZGVudGl0eS50c1wiO1xuZXhwb3J0ICogYXMgaW50ZXJjZXB0b3IgZnJvbSBcIi4vc3JjL2ludGVyY2VwdG9yLnRzXCI7XG5leHBvcnQgKiBhcyBsYWtlYmFzZVJlc29sdmVyIGZyb20gXCIuL3NyYy9sYWtlYmFzZS1yZXNvbHZlci50c1wiO1xuZXhwb3J0ICogYXMgbWlncmF0aW9uIGZyb20gXCIuL3NyYy9taWdyYXRpb24udHNcIjtcbmV4cG9ydCAqIGFzIHBnYWRkcmVzcyBmcm9tIFwiLi9zcmMvcGdhZGRyZXNzLnRzXCI7XG5leHBvcnQgKiBhcyBwbHVnaW5FeGVjdXRpb24gZnJvbSBcIi4vc3JjL3BsdWdpbi1leGVjdXRpb24udHNcIjtcbmV4cG9ydCAqIGFzIHBsdWdpblJlZ2lzdHJ5IGZyb20gXCIuL3NyYy9wbHVnaW4tcmVnaXN0cnkudHNcIjtcbmV4cG9ydCAqIGFzIHByb3Zpc2lvbiBmcm9tIFwiLi9zcmMvcHJvdmlzaW9uLnRzXCI7XG5leHBvcnQgKiBhcyByZXF1ZXN0VGFncyBmcm9tIFwiLi9zcmMvcmVxdWVzdC10YWdzLnRzXCI7XG5leHBvcnQgKiBhcyB0b29sUHJvdmlkZXIgZnJvbSBcIi4vc3JjL3Rvb2wtcHJvdmlkZXIudHNcIjtcbmV4cG9ydCAqIGFzIHRvb2xraXRFbnRyaWVzIGZyb20gXCIuL3NyYy90b29sa2l0LWVudHJpZXMudHNcIjtcbmV4cG9ydCB0eXBlIHsgQXV0b0NvbmZpZ3VyZU1vZGUsIENyZWF0ZUFwcENvbmZpZywgRXhlY3V0aW9uQ29udGV4dExpa2UsIFdvcmtzcGFjZUNsaWVudExpa2UgfSBmcm9tIFwiLi9zcmMvYXBwa2l0LnRzXCI7XG5leHBvcnQgeyBidW5kbGVBcHBSZXNvdXJjZVNjaGVtYSwgZmxhdHRlbkFwcFlhbWxFbnYsIGZsYXR0ZW5BcHBFbnYsIGdldEJ1bmRsZVBhdGggfSBmcm9tIFwiLi9zcmMvYnVuZGxlLnRzXCI7XG5leHBvcnQgdHlwZSB7IEJ1bmRsZVZhbGlkYXRlSnNvbiwgQ29uZmlnRmlsZSwgQ29uZmlnTWFwVmFsdWUsIENvbmZpZ1NvdXJjZSwgUmVzb2x2ZUNvbmZpZ1ZhbHVlT3B0aW9ucyB9IGZyb20gXCIuL3NyYy9idW5kbGUudHNcIjtcbmV4cG9ydCB7IEFwcEtpdENoaWxkUHJvY2VzcyB9IGZyb20gXCIuL3NyYy9jaGlsZC1wcm9jZXNzLnRzXCI7XG5leHBvcnQgdHlwZSB7IEFwcEtpdFNwYXduQXJncywgQXBwS2l0Q2hpbGRQcm9jZXNzSGVhbHRoQ2hlY2tDb250ZXh0LCBBcHBLaXRDaGlsZFByb2Nlc3NIZWFsdGhDaGVjaywgQXBwS2l0Q2hpbGRQcm9jZXNzT3B0aW9ucywgQXBwS2l0Q2hpbGRQcm9jZXNzUnVuT3B0aW9ucyB9IGZyb20gXCIuL3NyYy9jaGlsZC1wcm9jZXNzLnRzXCI7XG5leHBvcnQgdHlwZSB7IENvbnRleHRMaWtlIH0gZnJvbSBcIi4vc3JjL2RhdGFicmlja3MudHNcIjtcbmV4cG9ydCB7IEZpbGVzQ2FjaGVNYW5hZ2VyLCBGaWxlc0NhY2hlUGx1Z2luIH0gZnJvbSBcIi4vc3JjL2ZpbGVzLWNhY2hlLnRzXCI7XG5leHBvcnQgdHlwZSB7IEZpbGVzQ2FjaGVQbHVnaW5Db25maWcsIEZpbGVzQ2FjaGVTY29wZSwgRmlsZXNDYWNoZVNvdXJjZUlkZW50aXR5LCBGaWxlc0NhY2hlRXhwb3J0cyB9IGZyb20gXCIuL3NyYy9maWxlcy1jYWNoZS50c1wiO1xuZXhwb3J0IHsgQUNDRVNTX1RPS0VOX0hFQURFUiwgVVNFUl9JRF9IRUFERVIsIFVTRVJfRU1BSUxfSEVBREVSLCBJREVOVElUWV9NT0RFUywgREVGQVVMVF9JREVOVElUWV9NT0RFIH0gZnJvbSBcIi4vc3JjL2lkZW50aXR5LnRzXCI7XG5leHBvcnQgdHlwZSB7IElkZW50aXR5TW9kZSwgSGVhZGVyQmVhcmluZyB9IGZyb20gXCIuL3NyYy9pZGVudGl0eS50c1wiO1xuZXhwb3J0IHsgTGlmZWN5Y2xlQnJpZGdlUGx1Z2luLCBsaWZlY3ljbGVCcmlkZ2UgfSBmcm9tIFwiLi9zcmMvaW50ZXJjZXB0b3IudHNcIjtcbmV4cG9ydCB0eXBlIHsgTGlmZWN5Y2xlRXZlbnQsIExpZmVjeWNsZUhhbmRsZXIsIFJlc29sdmVkQXBwRW52LCBJbnRlcmNlcHRvckNvbnRleHQsIEludGVyY2VwdG9yLCBJbnRlcmNlcHRvclJ1bnRpbWUgfSBmcm9tIFwiLi9zcmMvaW50ZXJjZXB0b3IudHNcIjtcbmV4cG9ydCB0eXBlIHsgTGFrZWJhc2VSZXNvbHZlcklucHV0cywgTGFrZWJhc2VDb25uZWN0aW9uIH0gZnJvbSBcIi4vc3JjL2xha2ViYXNlLXJlc29sdmVyLnRzXCI7XG5leHBvcnQgdHlwZSB7IE93bmVyc2hpcE1pZ3JhdGlvbkVycm9yT3B0aW9ucyB9IGZyb20gXCIuL3NyYy9taWdyYXRpb24udHNcIjtcbmV4cG9ydCB7IFNTTF9NT0RFUyB9IGZyb20gXCIuL3NyYy9wZ2FkZHJlc3MudHNcIjtcbmV4cG9ydCB0eXBlIHsgU3NsTW9kZSwgUGFyc2VkQWRkcmVzcywgTGFrZWJhc2VDb25uZWN0aW9uSW5wdXRzIH0gZnJvbSBcIi4vc3JjL3BnYWRkcmVzcy50c1wiO1xuZXhwb3J0IHR5cGUgeyBSdW5QbHVnaW5FeGVjdXRpb25PcHRpb25zIH0gZnJvbSBcIi4vc3JjL3BsdWdpbi1leGVjdXRpb24udHNcIjtcbmV4cG9ydCB0eXBlIHsgUGx1Z2luQ29udGV4dExpa2UgfSBmcm9tIFwiLi9zcmMvcGx1Z2luLXJlZ2lzdHJ5LnRzXCI7XG5leHBvcnQgdHlwZSB7IFJlcXVlc3RUYWdWYWx1ZSB9IGZyb20gXCIuL3NyYy9yZXF1ZXN0LXRhZ3MudHNcIjtcbmV4cG9ydCB7IFRvb2xSZWdpc3RyeVBsdWdpbiB9IGZyb20gXCIuL3NyYy90b29sLXByb3ZpZGVyLnRzXCI7XG5leHBvcnQgdHlwZSB7IEFnZW50VG9vbEV4ZWN1dGlvbkNvbnRleHQgfSBmcm9tIFwiLi9zcmMvdG9vbC1wcm92aWRlci50c1wiO1xuIl19

package/lib/src/_cache-storage.d.ts

@@ -27,6 +27,7 @@ export interface L1CacheStorageOptions {
 }
 /** AppKit's internal persistent storage surface. */
 export type PersistentStorageBase = CacheStorage & {
+    cleanupExpired?(): Promise<number>;
     initialize(): Promise<void>;
     initialized: boolean;
     schemaName?: string;
@@ -47,6 +48,8 @@ export declare class L1CacheStorage implements CacheStorage {
     isPersistent(): boolean;
     healthCheck(): Promise<boolean>;
     close(): Promise<void>;
+    /** Forward AppKit's runtime-only persistent cleanup hook when available. */
+    cleanupExpired(): Promise<number>;
     private retain;
 }
 /**

package/lib/src/_cache-storage.js

@@ -73,6 +73,11 @@ export class L1CacheStorage {
         this.entries.clear();
         await this.storage.close();
     }
+    /** Forward AppKit's runtime-only persistent cleanup hook when available. */
+    async cleanupExpired() {
+        const cleanup = this.storage.cleanupExpired;
+        return cleanup ? cleanup.call(this.storage) : 0;
+    }
     retain(key, entry) {
         const ttl = entry.expiry - Date.now();
         if (ttl > 0)
@@ -227,4 +232,4 @@ export async function createSoftPersistentStorage(cache) {
         return undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_cache-storage.js","sourceRoot":"","sources":["../../src/_cache-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAoB,MAAM,oBAAoB,CAAC;AAC9F,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AAE/D,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;AA6B3C,IAAI,qBAAqB,GAAoD,IAAI,CAAC;AAElF,gFAAgF;AAChF,MAAM,OAAO,cAAc;IAIN;IAHF,OAAO,CAA+B;IAEvD,YACmB,OAAqB,EACtC,UAAiC,EAAE;QADlB,YAAO,GAAP,OAAO,CAAc;QAGtC,IAAI,CAAC,OAAO,GAAG,IAAI,QAAQ,CAAC;YAC1B,GAAG,EAAE,aAAa,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,EAAE,YAAY,CAAC;YAC3D,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI,EAAE,UAAU,CAAC;YACtE,eAAe,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,EAAE,KAAK,CAAC;SAC1D,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,GAAG,CAAI,GAAW;QACtB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpC,IAAI,KAAK;YAAE,OAAO,KAAsB,CAAC;QACzC,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAI,GAAG,CAAC,CAAC;QACjD,IAAI,SAAS,IAAI,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE;YAAE,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;QAC5E,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,KAAK,CAAC,GAAG,CAAI,GAAW,EAAE,KAAoB;QAC5C,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACnC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC1B,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,GAAW;QACtB,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,KAAK;QACT,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,GAAW;QACnB,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAO,IAAI,CAAC;QACvC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC/B,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;IAC7B,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;IACrC,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;IACpC,CAAC;IAED,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACrB,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IAC7B,CAAC;IAEO,MAAM,CAAI,GAAW,EAAE,KAAoB;QACjD,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACtC,IAAI,GAAG,GAAG,CAAC;YAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IACrD,CAAC;CACF;AAED,SAAS,aAAa,CAAC,KAAyB,EAAE,QAAgB,EAAE,IAAY;IAC9E,MAAM,QAAQ,GAAG,KAAK,IAAI,QAAQ,CAAC;IACnC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,QAAQ,IAAI,CAAC,EAAE,CAAC;QAChD,MAAM,IAAI,UAAU,CAAC,GAAG,IAAI,mCAAmC,CAAC,CAAC;IACnE,CAAC;IACD,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;AAC9B,CAAC;AAED,SAAS,YAAY,CAAC,GAAW,EAAE,KAAiB;IAClD,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,MAAM,CAAC,gBAAgB,CAAC;IACjC,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB;IACnC,IAAI,qBAAqB,KAAK,IAAI,EAAE,CAAC;QACnC,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IACD,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC/C,MAAM,UAAU,GAAG,IAAI,CACrB,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,EAC9C,6BAA6B,CAC9B,CAAC;QACF,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,iBACO,CAAC;QAC3C,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,MAAM,CAAC,KAAK,CAAC,2DAA2D,CAAC,CAAC;YAC1E,qBAAqB,GAAG,SAAS,CAAC;YAClC,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,qBAAqB,GAAG,MAAM,CAAC;QAC/B,OAAO,MAAM,CAAC;IAChB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,+DAA+D,EAAE;YAC5E,KAAK,EAAE,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC;SACpC,CAAC,CAAC;QACH,qBAAqB,GAAG,SAAS,CAAC;QAClC,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,uBAAuB,CACpC,OAA8B,EAC9B,IAAkB;IAElB,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,CAAC,OAAO,CAAC,SAAS;QAAE,OAAO,KAAK,CAAC;IAC5D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAC7B;;;yEAGqE,EACrE,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC,SAAS,CAAC,CACxC,CAAC;IACF,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK;QAAE,OAAO,KAAK,CAAC;IAClD,MAAM,CAAC,IAAI,CAAC,mEAAmE,EAAE;QAC/E,MAAM,EAAE,OAAO,CAAC,UAAU;QAC1B,KAAK,EAAE,OAAO,CAAC,SAAS;KACzB,CAAC,CAAC;IACH,OAAO,IAAI,CAAC;AACd,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,gBAAgB,CAC9B,OAA8B,EAC9B,cAAuC;IAEvC,MAAM,kBAAkB,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC5D,IAAI,eAA0C,CAAC;IAE/C,OAAO,CAAC,UAAU,GAAG,KAAK,IAAI,EAAE;QAC9B,IAAI,OAAO,CAAC,WAAW;YAAE,OAAO;QAChC,eAAe,KAAK,CAAC,KAAK,IAAI,EAAE;YAC9B,IAAI,CAAC;gBACH,IAAI,CAAC,CAAC,MAAM,cAAc,EAAE,EAAE,CAAC;oBAAE,MAAM,kBAAkB,EAAE,CAAC;YAC9D,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IACE,CAAC,6BAA6B,CAAC,GAAG,EAAE;oBAClC,KAAK,EAAE,eAAe;oBACtB,MAAM;oBACN,KAAK,EAAE,mCAAmC;iBAC3C,CAAC,EACF,CAAC;oBACD,MAAM,GAAG,CAAC;gBACZ,CAAC;YACH,CAAC;QACH,CAAC,CAAC,EAAE,CAAC;QACL,IAAI,CAAC;YACH,MAAM,eAAe,CAAC;YACtB,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;QAC7B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,eAAe,GAAG,SAAS,CAAC;YAC5B,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED,mFAAmF;AACnF,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,OAA8B;IAC/D,MAAM,GAAG,GAAG,yBAAyB,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;IACjD,IAAI,CAAC;QACH,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;QACpE,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,MAAM,EAAE,KAAK,KAAK,GAAG,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;IACH,CAAC;YAAS,CAAC;QACT,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IACnD,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAC/C,KAA8B;IAE9B,MAAM,iBAAiB,GAAG,qBAAqB,EAAE,CAAC;IAClD,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACvB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,IAA8B,CAAC;IACnC,IAAI,CAAC;QACH,MAAM,WAAW,GAAG,kBAAkB,CACpC,yBAAyB,CAAC,EAAE,eAAe,EAAE,kBAAkB,CAAC,EAAE,CAAC,EAAE,CAAC,CACvE,CAAC;QACF,IAAI,GAAG,WAAW,CAAC;QACnB,MAAM,OAAO,GAAG,IAAI,iBAAiB,CAAC,KAAK,IAAI,EAAE,EAAE,WAAW,CAAC,CAAC;QAChE,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,uBAAuB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC;QAC/E,IAAI,CAAC,CAAC,MAAM,OAAO,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;YACnC,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;YACtC,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,MAAM,OAAO,CAAC,UAAU,EAAE,CAAC;QAC3B,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;QAC5B,OAAO,IAAI,cAAc,CAAC,OAAO,EAAE;YACjC,QAAQ,EAAE,KAAK,EAAE,QAAQ;YACzB,UAAU,EAAE,KAAK,EAAE,OAAO;SAC3B,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,mCAAmC,EAAE;YAChD,KAAK,EAAE,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC;SACpC,CAAC,CAAC;QACH,IAAI,IAAI,EAAE,CAAC;YACT,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC","sourcesContent":["/**\n * Soft-fail Lakebase cache storage for AppKit's persistent cache.\n *\n * AppKit's `PersistentStorage.initialize()` runs DDL migrations and throws on\n * any step failure. With `cache.strictPersistence: true` that throw makes\n * `CacheManager` silently disable the cache. This wraps the same storage,\n * still runs its migrations, but logs a failed step instead of throwing so a\n * usable table keeps serving.\n *\n * `PersistentStorage` is not on AppKit's public export map. The deep load is\n * lazy and best-effort: if the installed AppKit layout changes, this returns\n * `undefined` and `createApp` leaves AppKit on its default cache path.\n *\n * @module\n */\n\nimport { createRequire } from \"node:module\";\nimport { dirname, join } from \"node:path\";\nimport { createLakebasePool, getWorkspaceClient, type CacheConfig } from \"@databricks/appkit\";\nimport { postgresConnectionOptions } from \"@dbx-tools/postgres\";\nimport { errorUtils, hash, log } from \"@dbx-tools/shared-core\";\nimport { LRUCache } from \"lru-cache\";\nimport { handleOwnershipMigrationError } from \"./migration.ts\";\n\nconst logger = log.logger(\"cache-storage\");\n\ntype LakebasePool = ReturnType<typeof createLakebasePool>;\ntype CacheStorage = NonNullable<CacheConfig[\"storage\"]>;\n\ninterface CacheEntry<T = unknown> {\n  expiry: number;\n  value: T;\n}\n\n/** Bounds for the process-local cache layered over persistent AppKit storage. */\nexport interface L1CacheStorageOptions {\n  maxBytes?: number;\n  maxEntries?: number;\n}\n\n/** AppKit's internal persistent storage surface. */\nexport type PersistentStorageBase = CacheStorage & {\n  initialize(): Promise<void>;\n  initialized: boolean;\n  schemaName?: string;\n  tableName?: string;\n};\n\ntype PersistentStorageConstructor = new (\n  config: CacheConfig,\n  pool: LakebasePool,\n) => PersistentStorageBase;\n\nlet persistentStorageCtor: PersistentStorageConstructor | undefined | null = null;\n\n/** Process-local LRU that avoids a persistent cache query on every warm hit. */\nexport class L1CacheStorage implements CacheStorage {\n  private readonly entries: LRUCache<string, CacheEntry>;\n\n  constructor(\n    private readonly storage: CacheStorage,\n    options: L1CacheStorageOptions = {},\n  ) {\n    this.entries = new LRUCache({\n      max: positiveBound(options.maxEntries, 1_000, \"maxEntries\"),\n      maxSize: positiveBound(options.maxBytes, 64 * 1024 * 1024, \"maxBytes\"),\n      sizeCalculation: (entry, key) => retainedSize(key, entry),\n    });\n  }\n\n  async get<T>(key: string): Promise<CacheEntry<T> | null> {\n    const local = this.entries.get(key);\n    if (local) return local as CacheEntry<T>;\n    const persisted = await this.storage.get<T>(key);\n    if (persisted && persisted.expiry > Date.now()) this.retain(key, persisted);\n    return persisted;\n  }\n\n  async set<T>(key: string, entry: CacheEntry<T>): Promise<void> {\n    await this.storage.set(key, entry);\n    this.retain(key, entry);\n  }\n\n  async delete(key: string): Promise<void> {\n    await this.storage.delete(key);\n    this.entries.delete(key);\n  }\n\n  async clear(): Promise<void> {\n    await this.storage.clear();\n    this.entries.clear();\n  }\n\n  async has(key: string): Promise<boolean> {\n    if (this.entries.has(key)) return true;\n    return this.storage.has(key);\n  }\n\n  size(): Promise<number> {\n    return this.storage.size();\n  }\n\n  isPersistent(): boolean {\n    return this.storage.isPersistent();\n  }\n\n  healthCheck(): Promise<boolean> {\n    return this.storage.healthCheck();\n  }\n\n  async close(): Promise<void> {\n    this.entries.clear();\n    await this.storage.close();\n  }\n\n  private retain<T>(key: string, entry: CacheEntry<T>): void {\n    const ttl = entry.expiry - Date.now();\n    if (ttl > 0) this.entries.set(key, entry, { ttl });\n  }\n}\n\nfunction positiveBound(value: number | undefined, fallback: number, name: string): number {\n  const resolved = value ?? fallback;\n  if (!Number.isFinite(resolved) || resolved <= 0) {\n    throw new RangeError(`${name} must be a finite positive number`);\n  }\n  return Math.floor(resolved);\n}\n\nfunction retainedSize(key: string, entry: CacheEntry): number {\n  try {\n    return Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(entry));\n  } catch {\n    return Number.MAX_SAFE_INTEGER;\n  }\n}\n\n/**\n * Lazily resolve AppKit's internal `PersistentStorage` constructor. `null`\n * means not attempted yet; `undefined` means the lookup already failed.\n */\nexport function loadPersistentStorage(): PersistentStorageConstructor | undefined {\n  if (persistentStorageCtor !== null) {\n    return persistentStorageCtor;\n  }\n  try {\n    const require = createRequire(import.meta.url);\n    const modulePath = join(\n      dirname(require.resolve(\"@databricks/appkit\")),\n      \"cache/storage/persistent.js\",\n    );\n    const loaded = require(modulePath).PersistentStorage as\n      PersistentStorageConstructor | undefined;\n    if (typeof loaded !== \"function\") {\n      logger.debug(\"soft persistent cache skipped (PersistentStorage missing)\");\n      persistentStorageCtor = undefined;\n      return undefined;\n    }\n    persistentStorageCtor = loaded;\n    return loaded;\n  } catch (err) {\n    logger.debug(\"soft persistent cache skipped (PersistentStorage unavailable)\", {\n      error: errorUtils.errorMessage(err),\n    });\n    persistentStorageCtor = undefined;\n    return undefined;\n  }\n}\n\n/**\n * Whether an existing cache table belongs to another role.\n *\n * PostgreSQL allows granted reads/writes but reserves index DDL for the table\n * owner. Skip AppKit migrations in that case; {@link probeStorage} still proves\n * the existing table can serve the cache before it is accepted.\n */\nasync function tableOwnedByAnotherRole(\n  storage: PersistentStorageBase,\n  pool: LakebasePool,\n): Promise<boolean> {\n  if (!storage.schemaName || !storage.tableName) return false;\n  const result = await pool.query(\n    `SELECT pg_get_userbyid(c.relowner) = current_user AS owned\n     FROM pg_class c\n     JOIN pg_namespace n ON n.oid = c.relnamespace\n     WHERE n.nspname = $1 AND c.relname = $2 AND c.relkind IN ('r', 'p')`,\n    [storage.schemaName, storage.tableName],\n  );\n  if (result.rows[0]?.owned !== false) return false;\n  logger.warn(\"persistent cache migrations skipped (table owned by another role)\", {\n    schema: storage.schemaName,\n    table: storage.tableName,\n  });\n  return true;\n}\n\n/** Soften `initialize()` so an ownership-only migration failure is not fatal. */\nexport function softenInitialize(\n  storage: PersistentStorageBase,\n  skipMigrations?: () => Promise<boolean>,\n): void {\n  const originalInitialize = storage.initialize.bind(storage);\n  let softInitPromise: Promise<void> | undefined;\n\n  storage.initialize = async () => {\n    if (storage.initialized) return;\n    softInitPromise ??= (async () => {\n      try {\n        if (!(await skipMigrations?.())) await originalInitialize();\n      } catch (err) {\n        if (\n          !handleOwnershipMigrationError(err, {\n            scope: \"cache-storage\",\n            logger,\n            event: \"persistent cache migration failed\",\n          })\n        ) {\n          throw err;\n        }\n      }\n    })();\n    try {\n      await softInitPromise;\n      storage.initialized = true;\n    } catch (err) {\n      softInitPromise = undefined;\n      throw err;\n    }\n  };\n}\n\n/** Verify the migrated cache table can serve the reads and writes AppKit needs. */\nexport async function probeStorage(storage: PersistentStorageBase): Promise<void> {\n  const key = `dbx-tools:cache-probe:${hash.id()}`;\n  try {\n    await storage.set(key, { value: key, expiry: Date.now() + 60_000 });\n    const result = await storage.get(key);\n    if (result?.value !== key) {\n      throw new Error(\"persistent cache probe returned an unexpected value\");\n    }\n  } finally {\n    await storage.delete(key).catch(() => undefined);\n  }\n}\n\n/**\n * Build a soft-fail Lakebase cache storage when a pool can be created and\n * AppKit's PersistentStorage can be loaded. Returns `undefined` otherwise so\n * AppKit can fall through to its normal cache path.\n */\nexport async function createSoftPersistentStorage(\n  cache: CacheConfig | undefined,\n): Promise<CacheStorage | undefined> {\n  const PersistentStorage = loadPersistentStorage();\n  if (!PersistentStorage) {\n    return undefined;\n  }\n\n  let pool: LakebasePool | undefined;\n  try {\n    const createdPool = createLakebasePool(\n      postgresConnectionOptions({ workspaceClient: getWorkspaceClient({}) }),\n    );\n    pool = createdPool;\n    const storage = new PersistentStorage(cache ?? {}, createdPool);\n    softenInitialize(storage, () => tableOwnedByAnotherRole(storage, createdPool));\n    if (!(await storage.healthCheck())) {\n      await storage.close().catch(() => {});\n      return undefined;\n    }\n    await storage.initialize();\n    await probeStorage(storage);\n    return new L1CacheStorage(storage, {\n      maxBytes: cache?.maxBytes,\n      maxEntries: cache?.maxSize,\n    });\n  } catch (err) {\n    logger.debug(\"soft persistent cache unavailable\", {\n      error: errorUtils.errorMessage(err),\n    });\n    if (pool) {\n      await pool.end().catch(() => {});\n    }\n    return undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_cache-storage.js","sourceRoot":"","sources":["../../src/_cache-storage.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Soft-fail Lakebase cache storage for AppKit's persistent cache.\n *\n * AppKit's `PersistentStorage.initialize()` runs DDL migrations and throws on\n * any step failure. With `cache.strictPersistence: true` that throw makes\n * `CacheManager` silently disable the cache. This wraps the same storage,\n * still runs its migrations, but logs a failed step instead of throwing so a\n * usable table keeps serving.\n *\n * `PersistentStorage` is not on AppKit's public export map. The deep load is\n * lazy and best-effort: if the installed AppKit layout changes, this returns\n * `undefined` and `createApp` leaves AppKit on its default cache path.\n *\n * @module\n */\n\nimport { createRequire } from \"node:module\";\nimport { dirname, join } from \"node:path\";\nimport { createLakebasePool, getWorkspaceClient, type CacheConfig } from \"@databricks/appkit\";\nimport { postgresConnectionOptions } from \"@dbx-tools/postgres\";\nimport { errorUtils, hash, log } from \"@dbx-tools/shared-core\";\nimport { LRUCache } from \"lru-cache\";\nimport { handleOwnershipMigrationError } from \"./migration.ts\";\n\nconst logger = log.logger(\"cache-storage\");\n\ntype LakebasePool = ReturnType<typeof createLakebasePool>;\ntype CacheStorage = NonNullable<CacheConfig[\"storage\"]>;\n\ninterface CacheEntry<T = unknown> {\n  expiry: number;\n  value: T;\n}\n\n/** Bounds for the process-local cache layered over persistent AppKit storage. */\nexport interface L1CacheStorageOptions {\n  maxBytes?: number;\n  maxEntries?: number;\n}\n\n/** AppKit's internal persistent storage surface. */\nexport type PersistentStorageBase = CacheStorage & {\n  cleanupExpired?(): Promise<number>;\n  initialize(): Promise<void>;\n  initialized: boolean;\n  schemaName?: string;\n  tableName?: string;\n};\n\ntype PersistentStorageConstructor = new (\n  config: CacheConfig,\n  pool: LakebasePool,\n) => PersistentStorageBase;\n\nlet persistentStorageCtor: PersistentStorageConstructor | undefined | null = null;\n\n/** Process-local LRU that avoids a persistent cache query on every warm hit. */\nexport class L1CacheStorage implements CacheStorage {\n  private readonly entries: LRUCache<string, CacheEntry>;\n\n  constructor(\n    private readonly storage: CacheStorage,\n    options: L1CacheStorageOptions = {},\n  ) {\n    this.entries = new LRUCache({\n      max: positiveBound(options.maxEntries, 1_000, \"maxEntries\"),\n      maxSize: positiveBound(options.maxBytes, 64 * 1024 * 1024, \"maxBytes\"),\n      sizeCalculation: (entry, key) => retainedSize(key, entry),\n    });\n  }\n\n  async get<T>(key: string): Promise<CacheEntry<T> | null> {\n    const local = this.entries.get(key);\n    if (local) return local as CacheEntry<T>;\n    const persisted = await this.storage.get<T>(key);\n    if (persisted && persisted.expiry > Date.now()) this.retain(key, persisted);\n    return persisted;\n  }\n\n  async set<T>(key: string, entry: CacheEntry<T>): Promise<void> {\n    await this.storage.set(key, entry);\n    this.retain(key, entry);\n  }\n\n  async delete(key: string): Promise<void> {\n    await this.storage.delete(key);\n    this.entries.delete(key);\n  }\n\n  async clear(): Promise<void> {\n    await this.storage.clear();\n    this.entries.clear();\n  }\n\n  async has(key: string): Promise<boolean> {\n    if (this.entries.has(key)) return true;\n    return this.storage.has(key);\n  }\n\n  size(): Promise<number> {\n    return this.storage.size();\n  }\n\n  isPersistent(): boolean {\n    return this.storage.isPersistent();\n  }\n\n  healthCheck(): Promise<boolean> {\n    return this.storage.healthCheck();\n  }\n\n  async close(): Promise<void> {\n    this.entries.clear();\n    await this.storage.close();\n  }\n\n  /** Forward AppKit's runtime-only persistent cleanup hook when available. */\n  async cleanupExpired(): Promise<number> {\n    const cleanup = (\n      this.storage as CacheStorage & {\n        cleanupExpired?: () => Promise<number>;\n      }\n    ).cleanupExpired;\n    return cleanup ? cleanup.call(this.storage) : 0;\n  }\n\n  private retain<T>(key: string, entry: CacheEntry<T>): void {\n    const ttl = entry.expiry - Date.now();\n    if (ttl > 0) this.entries.set(key, entry, { ttl });\n  }\n}\n\nfunction positiveBound(value: number | undefined, fallback: number, name: string): number {\n  const resolved = value ?? fallback;\n  if (!Number.isFinite(resolved) || resolved <= 0) {\n    throw new RangeError(`${name} must be a finite positive number`);\n  }\n  return Math.floor(resolved);\n}\n\nfunction retainedSize(key: string, entry: CacheEntry): number {\n  try {\n    return Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(entry));\n  } catch {\n    return Number.MAX_SAFE_INTEGER;\n  }\n}\n\n/**\n * Lazily resolve AppKit's internal `PersistentStorage` constructor. `null`\n * means not attempted yet; `undefined` means the lookup already failed.\n */\nexport function loadPersistentStorage(): PersistentStorageConstructor | undefined {\n  if (persistentStorageCtor !== null) {\n    return persistentStorageCtor;\n  }\n  try {\n    const require = createRequire(import.meta.url);\n    const modulePath = join(\n      dirname(require.resolve(\"@databricks/appkit\")),\n      \"cache/storage/persistent.js\",\n    );\n    const loaded = require(modulePath).PersistentStorage as\n      PersistentStorageConstructor | undefined;\n    if (typeof loaded !== \"function\") {\n      logger.debug(\"soft persistent cache skipped (PersistentStorage missing)\");\n      persistentStorageCtor = undefined;\n      return undefined;\n    }\n    persistentStorageCtor = loaded;\n    return loaded;\n  } catch (err) {\n    logger.debug(\"soft persistent cache skipped (PersistentStorage unavailable)\", {\n      error: errorUtils.errorMessage(err),\n    });\n    persistentStorageCtor = undefined;\n    return undefined;\n  }\n}\n\n/**\n * Whether an existing cache table belongs to another role.\n *\n * PostgreSQL allows granted reads/writes but reserves index DDL for the table\n * owner. Skip AppKit migrations in that case; {@link probeStorage} still proves\n * the existing table can serve the cache before it is accepted.\n */\nasync function tableOwnedByAnotherRole(\n  storage: PersistentStorageBase,\n  pool: LakebasePool,\n): Promise<boolean> {\n  if (!storage.schemaName || !storage.tableName) return false;\n  const result = await pool.query(\n    `SELECT pg_get_userbyid(c.relowner) = current_user AS owned\n     FROM pg_class c\n     JOIN pg_namespace n ON n.oid = c.relnamespace\n     WHERE n.nspname = $1 AND c.relname = $2 AND c.relkind IN ('r', 'p')`,\n    [storage.schemaName, storage.tableName],\n  );\n  if (result.rows[0]?.owned !== false) return false;\n  logger.warn(\"persistent cache migrations skipped (table owned by another role)\", {\n    schema: storage.schemaName,\n    table: storage.tableName,\n  });\n  return true;\n}\n\n/** Soften `initialize()` so an ownership-only migration failure is not fatal. */\nexport function softenInitialize(\n  storage: PersistentStorageBase,\n  skipMigrations?: () => Promise<boolean>,\n): void {\n  const originalInitialize = storage.initialize.bind(storage);\n  let softInitPromise: Promise<void> | undefined;\n\n  storage.initialize = async () => {\n    if (storage.initialized) return;\n    softInitPromise ??= (async () => {\n      try {\n        if (!(await skipMigrations?.())) await originalInitialize();\n      } catch (err) {\n        if (\n          !handleOwnershipMigrationError(err, {\n            scope: \"cache-storage\",\n            logger,\n            event: \"persistent cache migration failed\",\n          })\n        ) {\n          throw err;\n        }\n      }\n    })();\n    try {\n      await softInitPromise;\n      storage.initialized = true;\n    } catch (err) {\n      softInitPromise = undefined;\n      throw err;\n    }\n  };\n}\n\n/** Verify the migrated cache table can serve the reads and writes AppKit needs. */\nexport async function probeStorage(storage: PersistentStorageBase): Promise<void> {\n  const key = `dbx-tools:cache-probe:${hash.id()}`;\n  try {\n    await storage.set(key, { value: key, expiry: Date.now() + 60_000 });\n    const result = await storage.get(key);\n    if (result?.value !== key) {\n      throw new Error(\"persistent cache probe returned an unexpected value\");\n    }\n  } finally {\n    await storage.delete(key).catch(() => undefined);\n  }\n}\n\n/**\n * Build a soft-fail Lakebase cache storage when a pool can be created and\n * AppKit's PersistentStorage can be loaded. Returns `undefined` otherwise so\n * AppKit can fall through to its normal cache path.\n */\nexport async function createSoftPersistentStorage(\n  cache: CacheConfig | undefined,\n): Promise<CacheStorage | undefined> {\n  const PersistentStorage = loadPersistentStorage();\n  if (!PersistentStorage) {\n    return undefined;\n  }\n\n  let pool: LakebasePool | undefined;\n  try {\n    const createdPool = createLakebasePool(\n      postgresConnectionOptions({ workspaceClient: getWorkspaceClient({}) }),\n    );\n    pool = createdPool;\n    const storage = new PersistentStorage(cache ?? {}, createdPool);\n    softenInitialize(storage, () => tableOwnedByAnotherRole(storage, createdPool));\n    if (!(await storage.healthCheck())) {\n      await storage.close().catch(() => {});\n      return undefined;\n    }\n    await storage.initialize();\n    await probeStorage(storage);\n    return new L1CacheStorage(storage, {\n      maxBytes: cache?.maxBytes,\n      maxEntries: cache?.maxSize,\n    });\n  } catch (err) {\n    logger.debug(\"soft persistent cache unavailable\", {\n      error: errorUtils.errorMessage(err),\n    });\n    if (pool) {\n      await pool.end().catch(() => {});\n    }\n    return undefined;\n  }\n}\n"]}

package/lib/src/files-cache.d.ts

@@ -0,0 +1,88 @@
+/**
+ * AppKit-global filesystem cache with user-isolated process-local LRU values.
+ *
+ * @module
+ */
+import { Plugin, type BasePluginConfig } from "@databricks/appkit";
+import { type FileSystemCache } from "@dbx-tools/shared-fs";
+/** Configuration for the AppKit files-cache plugin. */
+export interface FilesCachePluginConfig extends BasePluginConfig {
+    /** Default entry TTL in milliseconds. Defaults to 60 seconds. */
+    ttlMs?: number;
+    /** Invalidation debounce window in milliseconds. Defaults to 25ms. */
+    invalidationBatchMs?: number;
+    /** Maximum entries retained in each user L1. Defaults to 1,000. */
+    maxEntries?: number;
+    /** Maximum retained bytes in each user L1. Defaults to 64 MiB. */
+    maxBytes?: number;
+    /** Maximum active user scopes retained by the process. Defaults to 256. */
+    maxScopes?: number;
+}
+/** Identity for one authorization-safe filesystem cache scope. */
+export interface FilesCacheScope {
+    /** Databricks workspace host. */
+    host: string;
+    /** Attributed user identifier used to isolate values. */
+    userKey: string;
+    /** Optional workspace identifier included in shared invalidation scope. */
+    workspaceId?: string;
+    /** Optional per-scope entry TTL override in milliseconds. */
+    ttlMs?: number;
+}
+/** Stable identity for a framework filesystem source retained within one user scope. */
+export interface FilesCacheSourceIdentity {
+    /** Actual mounted filesystem paths represented by the source. */
+    paths: readonly string[];
+    /** Workspace-instance key separating sources with different policies over the same paths. */
+    key?: string;
+}
+/** Public exports from {@link FilesCachePlugin}. */
+export interface FilesCacheExports {
+    /** Resolve one user-isolated filesystem cache. */
+    forScope(scope: FilesCacheScope): Promise<FileSystemCache>;
+    /** Resolve one app-lifetime filesystem source for a user and its actual mounted paths. */
+    forFileSystem<T extends object>(scope: FilesCacheScope, identity: FilesCacheSourceIdentity, load: () => T | Promise<T>): Promise<T>;
+    /** Flush pending invalidation batches. */
+    flush(): Promise<void>;
+}
+/** Process-local filesystem cache manager. */
+export declare class FilesCacheManager {
+    private readonly config;
+    private readonly groups;
+    private readonly scopes;
+    constructor(config?: FilesCachePluginConfig);
+    /** Return one user-isolated cache within a host/workspace invalidation group. */
+    forScope(input: FilesCacheScope): Promise<FileSystemCache>;
+    /** Retain one stable framework filesystem source for the scope and mounted paths. */
+    forFileSystem<T extends object>(input: FilesCacheScope, identity: FilesCacheSourceIdentity, load: () => T | Promise<T>): Promise<T>;
+    private resolveScopeState;
+    /** Flush every pending invalidation batch. */
+    flush(): Promise<void>;
+    /** Flush state and release all process-local entries and timers. */
+    close(): Promise<void>;
+    private group;
+    private createScope;
+    private read;
+    private keys;
+    private queueInvalidation;
+    private flushInvalidations;
+}
+/** AppKit plugin that owns process-local filesystem LRU caches. */
+export declare class FilesCachePlugin extends Plugin<FilesCachePluginConfig> {
+    static manifest: {
+        name: "files-cache";
+        displayName: string;
+        description: string;
+        stability: "beta";
+        resources: {
+            required: never[];
+            optional: never[];
+        };
+    };
+    private manager?;
+    setup(): Promise<void>;
+    exports(): FilesCacheExports;
+    private requireManager;
+}
+/** AppKit registration factory for {@link FilesCachePlugin}. */
+export declare const filesCache: import("@databricks/appkit").ToPlugin<typeof FilesCachePlugin, FilesCachePluginConfig, "files-cache">;

package/lib/src/files-cache.js

@@ -0,0 +1,230 @@
+/**
+ * AppKit-global filesystem cache with user-isolated process-local LRU values.
+ *
+ * @module
+ */
+import { Plugin, toPlugin } from "@databricks/appkit";
+import { errorUtils, log, object } from "@dbx-tools/shared-core";
+import { posixPath } from "@dbx-tools/shared-fs";
+import { LRUCache } from "lru-cache";
+const DEFAULT_TTL_MS = 60_000;
+const DEFAULT_INVALIDATION_BATCH_MS = 25;
+const DEFAULT_MAX_ENTRIES = 1_000;
+const DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
+const DEFAULT_MAX_SCOPES = 256;
+const logger = log.logger("files-cache");
+/** Process-local filesystem cache manager. */
+export class FilesCacheManager {
+    config;
+    groups = new Map();
+    scopes;
+    constructor(config = {}) {
+        this.config = {
+            ttlMs: positiveDuration(config.ttlMs, DEFAULT_TTL_MS, "ttlMs"),
+            invalidationBatchMs: positiveDuration(config.invalidationBatchMs, DEFAULT_INVALIDATION_BATCH_MS, "invalidationBatchMs"),
+            maxEntries: positiveInteger(config.maxEntries, DEFAULT_MAX_ENTRIES, "maxEntries"),
+            maxBytes: positiveInteger(config.maxBytes, DEFAULT_MAX_BYTES, "maxBytes"),
+            maxScopes: positiveInteger(config.maxScopes, DEFAULT_MAX_SCOPES, "maxScopes"),
+        };
+        this.scopes = new LRUCache({
+            max: this.config.maxScopes,
+            dispose: (state) => {
+                state.group.scopes.delete(state);
+            },
+        });
+    }
+    /** Return one user-isolated cache within a host/workspace invalidation group. */
+    async forScope(input) {
+        return (await this.resolveScopeState(input)).cache;
+    }
+    /** Retain one stable framework filesystem source for the scope and mounted paths. */
+    async forFileSystem(input, identity, load) {
+        const state = await this.resolveScopeState(input);
+        const paths = identity.paths.map((path) => posixPath.normalizeRoot(path));
+        if (paths.length === 0)
+            throw new TypeError("Filesystem source paths must not be empty");
+        const sourceKey = object.toStableKey({ paths, key: identity.key });
+        let source = state.sources.get(sourceKey);
+        if (!source) {
+            source = Promise.resolve(load());
+            state.sources.set(sourceKey, source);
+        }
+        try {
+            return (await source);
+        }
+        catch (error) {
+            if (state.sources.get(sourceKey) === source)
+                state.sources.delete(sourceKey);
+            throw error;
+        }
+    }
+    async resolveScopeState(input) {
+        const scope = resolveScope(input, this.config.ttlMs);
+        const scopeKey = object.toStableKey({
+            host: scope.host,
+            userKey: scope.userKey,
+            workspaceId: scope.workspaceId,
+        });
+        let state = this.scopes.get(scopeKey);
+        if (!state) {
+            const group = this.group(scope);
+            state = this.createScope(scope, group);
+            group.scopes.add(state);
+            this.scopes.set(scopeKey, state);
+        }
+        return state;
+    }
+    /** Flush every pending invalidation batch. */
+    async flush() {
+        await Promise.all([...this.groups.values()].map((group) => this.flushInvalidations(group)));
+    }
+    /** Flush state and release all process-local entries and timers. */
+    async close() {
+        for (const group of this.groups.values()) {
+            if (group.timer)
+                clearTimeout(group.timer);
+            group.timer = undefined;
+        }
+        await this.flush();
+        this.scopes.clear();
+        this.groups.clear();
+    }
+    group(scope) {
+        const key = object.toStableKey({
+            host: scope.host,
+            workspaceId: scope.workspaceId,
+        });
+        const existing = this.groups.get(key);
+        if (existing)
+            return existing;
+        const group = {
+            pending: new Set(),
+            scopes: new Set(),
+        };
+        this.groups.set(key, group);
+        return group;
+    }
+    createScope(scope, group) {
+        const state = {};
+        state.scope = scope;
+        state.group = group;
+        state.entries = new LRUCache({
+            max: this.config.maxEntries,
+            maxSize: this.config.maxBytes,
+            sizeCalculation: (entry, cacheKey) => retainedSize(cacheKey, entry),
+        });
+        state.sources = new Map();
+        state.cache = {
+            read: (cacheKey, load) => this.read(state, cacheKey, load),
+            invalidate: (cacheKey) => this.queueInvalidation(state, cacheKey),
+            keys: () => this.keys(state),
+        };
+        return state;
+    }
+    async read(state, key, load) {
+        if (!state.group.pending.has(key)) {
+            const retained = state.entries.get(key);
+            if (retained)
+                return retained.value;
+        }
+        const value = await load();
+        state.entries.set(key, { value }, { ttl: state.scope.ttlMs });
+        return value;
+    }
+    *keys(state) {
+        for (const key of state.entries.keys()) {
+            if (!state.group.pending.has(key))
+                yield key;
+        }
+    }
+    queueInvalidation(state, key) {
+        state.group.pending.add(key);
+        if (state.group.timer)
+            return;
+        state.group.timer = setTimeout(() => {
+            state.group.timer = undefined;
+            void this.flushInvalidations(state.group).catch((error) => {
+                logger.warn("filesystem cache invalidation batch failed", {
+                    error: errorUtils.errorMessage(error),
+                });
+            });
+        }, this.config.invalidationBatchMs);
+        state.group.timer.unref?.();
+    }
+    async flushInvalidations(group) {
+        if (group.timer)
+            clearTimeout(group.timer);
+        group.timer = undefined;
+        if (group.pending.size === 0)
+            return;
+        const keys = [...group.pending];
+        group.pending.clear();
+        for (const state of group.scopes) {
+            for (const key of keys)
+                state.entries.delete(key);
+        }
+    }
+}
+/** AppKit plugin that owns process-local filesystem LRU caches. */
+export class FilesCachePlugin extends Plugin {
+    static manifest = {
+        name: "files-cache",
+        displayName: "Files Cache",
+        description: "Provides bounded user-scoped process-local filesystem caches.",
+        stability: "beta",
+        resources: { required: [], optional: [] },
+    };
+    manager;
+    async setup() {
+        this.manager = new FilesCacheManager(this.config);
+        this.context?.onLifecycle("shutdown", () => this.manager?.close());
+    }
+    exports() {
+        return {
+            forScope: (scope) => this.requireManager().forScope(scope),
+            forFileSystem: (scope, identity, load) => this.requireManager().forFileSystem(scope, identity, load),
+            flush: () => this.requireManager().flush(),
+        };
+    }
+    requireManager() {
+        if (!this.manager)
+            throw new Error("Files cache plugin has not completed setup");
+        return this.manager;
+    }
+}
+/** AppKit registration factory for {@link FilesCachePlugin}. */
+export const filesCache = toPlugin(FilesCachePlugin);
+function resolveScope(input, defaultTtlMs) {
+    const host = input.host.trim().replace(/\/+$/, "");
+    const userKey = input.userKey.trim();
+    const workspaceId = input.workspaceId?.trim() || undefined;
+    if (!host)
+        throw new TypeError("Files cache scope host must not be blank");
+    if (!userKey)
+        throw new TypeError("Files cache scope userKey must not be blank");
+    return {
+        host,
+        userKey,
+        ...(workspaceId ? { workspaceId } : {}),
+        ttlMs: positiveDuration(input.ttlMs, defaultTtlMs, "scope.ttlMs"),
+    };
+}
+function positiveDuration(value, fallback, name) {
+    const resolved = value ?? fallback;
+    if (!Number.isFinite(resolved) || resolved <= 0) {
+        throw new RangeError(`${name} must be a finite positive number`);
+    }
+    return resolved;
+}
+function positiveInteger(value, fallback, name) {
+    return Math.floor(positiveDuration(value, fallback, name));
+}
+function retainedSize(key, entry) {
+    try {
+        return Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(entry.value));
+    }
+    catch {
+        return Number.MAX_SAFE_INTEGER;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"files-cache.js","sourceRoot":"","sources":["../../src/files-cache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit-global filesystem cache with user-isolated process-local LRU values.\n *\n * @module\n */\n\nimport { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from \"@databricks/appkit\";\nimport { errorUtils, log, object } from \"@dbx-tools/shared-core\";\nimport { posixPath, type CacheValue, type FileSystemCache } from \"@dbx-tools/shared-fs\";\nimport { LRUCache } from \"lru-cache\";\n\nconst DEFAULT_TTL_MS = 60_000;\nconst DEFAULT_INVALIDATION_BATCH_MS = 25;\nconst DEFAULT_MAX_ENTRIES = 1_000;\nconst DEFAULT_MAX_BYTES = 64 * 1024 * 1024;\nconst DEFAULT_MAX_SCOPES = 256;\nconst logger = log.logger(\"files-cache\");\n\ninterface RetainedEntry {\n  value: CacheValue;\n}\n\ninterface ScopeState {\n  cache: FileSystemCache;\n  entries: LRUCache<string, RetainedEntry>;\n  group: GroupState;\n  scope: ResolvedFilesCacheScope;\n  sources: Map<string, Promise<object>>;\n}\n\ninterface GroupState {\n  pending: Set<string>;\n  scopes: Set<ScopeState>;\n  timer?: ReturnType<typeof setTimeout>;\n}\n\ninterface ResolvedFilesCacheConfig {\n  invalidationBatchMs: number;\n  maxBytes: number;\n  maxEntries: number;\n  maxScopes: number;\n  ttlMs: number;\n}\n\ninterface ResolvedFilesCacheScope {\n  host: string;\n  ttlMs: number;\n  userKey: string;\n  workspaceId?: string;\n}\n\n/** Configuration for the AppKit files-cache plugin. */\nexport interface FilesCachePluginConfig extends BasePluginConfig {\n  /** Default entry TTL in milliseconds. Defaults to 60 seconds. */\n  ttlMs?: number;\n  /** Invalidation debounce window in milliseconds. Defaults to 25ms. */\n  invalidationBatchMs?: number;\n  /** Maximum entries retained in each user L1. Defaults to 1,000. */\n  maxEntries?: number;\n  /** Maximum retained bytes in each user L1. Defaults to 64 MiB. */\n  maxBytes?: number;\n  /** Maximum active user scopes retained by the process. Defaults to 256. */\n  maxScopes?: number;\n}\n\n/** Identity for one authorization-safe filesystem cache scope. */\nexport interface FilesCacheScope {\n  /** Databricks workspace host. */\n  host: string;\n  /** Attributed user identifier used to isolate values. */\n  userKey: string;\n  /** Optional workspace identifier included in shared invalidation scope. */\n  workspaceId?: string;\n  /** Optional per-scope entry TTL override in milliseconds. */\n  ttlMs?: number;\n}\n\n/** Stable identity for a framework filesystem source retained within one user scope. */\nexport interface FilesCacheSourceIdentity {\n  /** Actual mounted filesystem paths represented by the source. */\n  paths: readonly string[];\n  /** Workspace-instance key separating sources with different policies over the same paths. */\n  key?: string;\n}\n\n/** Public exports from {@link FilesCachePlugin}. */\nexport interface FilesCacheExports {\n  /** Resolve one user-isolated filesystem cache. */\n  forScope(scope: FilesCacheScope): Promise<FileSystemCache>;\n  /** Resolve one app-lifetime filesystem source for a user and its actual mounted paths. */\n  forFileSystem<T extends object>(\n    scope: FilesCacheScope,\n    identity: FilesCacheSourceIdentity,\n    load: () => T | Promise<T>,\n  ): Promise<T>;\n  /** Flush pending invalidation batches. */\n  flush(): Promise<void>;\n}\n\n/** Process-local filesystem cache manager. */\nexport class FilesCacheManager {\n  private readonly config: ResolvedFilesCacheConfig;\n  private readonly groups = new Map<string, GroupState>();\n  private readonly scopes: LRUCache<string, ScopeState>;\n\n  constructor(config: FilesCachePluginConfig = {}) {\n    this.config = {\n      ttlMs: positiveDuration(config.ttlMs, DEFAULT_TTL_MS, \"ttlMs\"),\n      invalidationBatchMs: positiveDuration(\n        config.invalidationBatchMs,\n        DEFAULT_INVALIDATION_BATCH_MS,\n        \"invalidationBatchMs\",\n      ),\n      maxEntries: positiveInteger(config.maxEntries, DEFAULT_MAX_ENTRIES, \"maxEntries\"),\n      maxBytes: positiveInteger(config.maxBytes, DEFAULT_MAX_BYTES, \"maxBytes\"),\n      maxScopes: positiveInteger(config.maxScopes, DEFAULT_MAX_SCOPES, \"maxScopes\"),\n    };\n    this.scopes = new LRUCache({\n      max: this.config.maxScopes,\n      dispose: (state) => {\n        state.group.scopes.delete(state);\n      },\n    });\n  }\n\n  /** Return one user-isolated cache within a host/workspace invalidation group. */\n  async forScope(input: FilesCacheScope): Promise<FileSystemCache> {\n    return (await this.resolveScopeState(input)).cache;\n  }\n\n  /** Retain one stable framework filesystem source for the scope and mounted paths. */\n  async forFileSystem<T extends object>(\n    input: FilesCacheScope,\n    identity: FilesCacheSourceIdentity,\n    load: () => T | Promise<T>,\n  ): Promise<T> {\n    const state = await this.resolveScopeState(input);\n    const paths = identity.paths.map((path) => posixPath.normalizeRoot(path));\n    if (paths.length === 0) throw new TypeError(\"Filesystem source paths must not be empty\");\n    const sourceKey = object.toStableKey({ paths, key: identity.key });\n    let source = state.sources.get(sourceKey);\n    if (!source) {\n      source = Promise.resolve(load());\n      state.sources.set(sourceKey, source);\n    }\n    try {\n      return (await source) as T;\n    } catch (error) {\n      if (state.sources.get(sourceKey) === source) state.sources.delete(sourceKey);\n      throw error;\n    }\n  }\n\n  private async resolveScopeState(input: FilesCacheScope): Promise<ScopeState> {\n    const scope = resolveScope(input, this.config.ttlMs);\n    const scopeKey = object.toStableKey({\n      host: scope.host,\n      userKey: scope.userKey,\n      workspaceId: scope.workspaceId,\n    });\n    let state = this.scopes.get(scopeKey);\n    if (!state) {\n      const group = this.group(scope);\n      state = this.createScope(scope, group);\n      group.scopes.add(state);\n      this.scopes.set(scopeKey, state);\n    }\n    return state;\n  }\n\n  /** Flush every pending invalidation batch. */\n  async flush(): Promise<void> {\n    await Promise.all([...this.groups.values()].map((group) => this.flushInvalidations(group)));\n  }\n\n  /** Flush state and release all process-local entries and timers. */\n  async close(): Promise<void> {\n    for (const group of this.groups.values()) {\n      if (group.timer) clearTimeout(group.timer);\n      group.timer = undefined;\n    }\n    await this.flush();\n    this.scopes.clear();\n    this.groups.clear();\n  }\n\n  private group(scope: ResolvedFilesCacheScope): GroupState {\n    const key = object.toStableKey({\n      host: scope.host,\n      workspaceId: scope.workspaceId,\n    });\n    const existing = this.groups.get(key);\n    if (existing) return existing;\n    const group: GroupState = {\n      pending: new Set(),\n      scopes: new Set(),\n    };\n    this.groups.set(key, group);\n    return group;\n  }\n\n  private createScope(scope: ResolvedFilesCacheScope, group: GroupState): ScopeState {\n    const state = {} as ScopeState;\n    state.scope = scope;\n    state.group = group;\n    state.entries = new LRUCache({\n      max: this.config.maxEntries,\n      maxSize: this.config.maxBytes,\n      sizeCalculation: (entry, cacheKey) => retainedSize(cacheKey, entry),\n    });\n    state.sources = new Map();\n    state.cache = {\n      read: <T extends CacheValue>(cacheKey: string, load: () => T | Promise<T>) =>\n        this.read(state, cacheKey, load),\n      invalidate: (cacheKey: string) => this.queueInvalidation(state, cacheKey),\n      keys: () => this.keys(state),\n    };\n    return state;\n  }\n\n  private async read<T extends CacheValue>(\n    state: ScopeState,\n    key: string,\n    load: () => T | Promise<T>,\n  ): Promise<T> {\n    if (!state.group.pending.has(key)) {\n      const retained = state.entries.get(key);\n      if (retained) return retained.value as T;\n    }\n    const value = await load();\n    state.entries.set(key, { value }, { ttl: state.scope.ttlMs });\n    return value;\n  }\n\n  private *keys(state: ScopeState): Iterable<string> {\n    for (const key of state.entries.keys()) {\n      if (!state.group.pending.has(key)) yield key;\n    }\n  }\n\n  private queueInvalidation(state: ScopeState, key: string): void {\n    state.group.pending.add(key);\n    if (state.group.timer) return;\n    state.group.timer = setTimeout(() => {\n      state.group.timer = undefined;\n      void this.flushInvalidations(state.group).catch((error) => {\n        logger.warn(\"filesystem cache invalidation batch failed\", {\n          error: errorUtils.errorMessage(error),\n        });\n      });\n    }, this.config.invalidationBatchMs);\n    state.group.timer.unref?.();\n  }\n\n  private async flushInvalidations(group: GroupState): Promise<void> {\n    if (group.timer) clearTimeout(group.timer);\n    group.timer = undefined;\n    if (group.pending.size === 0) return;\n    const keys = [...group.pending];\n    group.pending.clear();\n    for (const state of group.scopes) {\n      for (const key of keys) state.entries.delete(key);\n    }\n  }\n}\n\n/** AppKit plugin that owns process-local filesystem LRU caches. */\nexport class FilesCachePlugin extends Plugin<FilesCachePluginConfig> {\n  static manifest = {\n    name: \"files-cache\",\n    displayName: \"Files Cache\",\n    description: \"Provides bounded user-scoped process-local filesystem caches.\",\n    stability: \"beta\",\n    resources: { required: [], optional: [] },\n  } satisfies PluginManifest<\"files-cache\">;\n\n  private manager?: FilesCacheManager;\n\n  override async setup(): Promise<void> {\n    this.manager = new FilesCacheManager(this.config);\n    this.context?.onLifecycle(\"shutdown\", () => this.manager?.close());\n  }\n\n  override exports(): FilesCacheExports {\n    return {\n      forScope: (scope) => this.requireManager().forScope(scope),\n      forFileSystem: (scope, identity, load) =>\n        this.requireManager().forFileSystem(scope, identity, load),\n      flush: () => this.requireManager().flush(),\n    };\n  }\n\n  private requireManager(): FilesCacheManager {\n    if (!this.manager) throw new Error(\"Files cache plugin has not completed setup\");\n    return this.manager;\n  }\n}\n\n/** AppKit registration factory for {@link FilesCachePlugin}. */\nexport const filesCache = toPlugin(FilesCachePlugin);\n\nfunction resolveScope(input: FilesCacheScope, defaultTtlMs: number): ResolvedFilesCacheScope {\n  const host = input.host.trim().replace(/\\/+$/, \"\");\n  const userKey = input.userKey.trim();\n  const workspaceId = input.workspaceId?.trim() || undefined;\n  if (!host) throw new TypeError(\"Files cache scope host must not be blank\");\n  if (!userKey) throw new TypeError(\"Files cache scope userKey must not be blank\");\n  return {\n    host,\n    userKey,\n    ...(workspaceId ? { workspaceId } : {}),\n    ttlMs: positiveDuration(input.ttlMs, defaultTtlMs, \"scope.ttlMs\"),\n  };\n}\n\nfunction positiveDuration(value: number | undefined, fallback: number, name: string): number {\n  const resolved = value ?? fallback;\n  if (!Number.isFinite(resolved) || resolved <= 0) {\n    throw new RangeError(`${name} must be a finite positive number`);\n  }\n  return resolved;\n}\n\nfunction positiveInteger(value: number | undefined, fallback: number, name: string): number {\n  return Math.floor(positiveDuration(value, fallback, name));\n}\n\nfunction retainedSize(key: string, entry: RetainedEntry): number {\n  try {\n    return Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(entry.value));\n  } catch {\n    return Number.MAX_SAFE_INTEGER;\n  }\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/_auto-configure.ts","../src/_cache-storage.ts","../src/appkit.ts","../src/brand-context.ts","../src/bundle.ts","../src/child-process.ts","../src/databricks.ts","../src/identity.ts","../src/interceptor.ts","../src/lakebase-resolver.ts","../src/migration.ts","../src/pgaddress.ts","../src/plugin-execution.ts","../src/plugin-registry.ts","../src/provision.ts","../src/request-tags.ts","../src/tool-provider.ts","../src/toolkit-entries.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/_auto-configure.ts","../src/_cache-storage.ts","../src/appkit.ts","../src/brand-context.ts","../src/bundle.ts","../src/child-process.ts","../src/databricks.ts","../src/files-cache.ts","../src/identity.ts","../src/interceptor.ts","../src/lakebase-resolver.ts","../src/migration.ts","../src/pgaddress.ts","../src/plugin-execution.ts","../src/plugin-registry.ts","../src/provision.ts","../src/request-tags.ts","../src/tool-provider.ts","../src/toolkit-entries.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -20,7 +20,7 @@
   },
   "devDependencies": {
     "@databricks/appkit": "0.81.0",
-    "@dbx-tools/projen": "^0.9.93",
+    "@dbx-tools/projen": "^0.9.99",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3",
     "vitest": "3.2.4"
@@ -30,11 +30,12 @@
   },
   "dependencies": {
     "@databricks/sdk-experimental": "^0.17.0",
-    "@dbx-tools/auth": "^0.9.93",
-    "@dbx-tools/core": "^0.9.93",
-    "@dbx-tools/lakebase": "^0.9.93",
-    "@dbx-tools/postgres": "^0.9.93",
-    "@dbx-tools/shared-core": "^0.9.93",
+    "@dbx-tools/auth": "^0.9.99",
+    "@dbx-tools/core": "^0.9.99",
+    "@dbx-tools/lakebase": "^0.9.99",
+    "@dbx-tools/postgres": "^0.9.99",
+    "@dbx-tools/shared-core": "^0.9.99",
+    "@dbx-tools/shared-fs": "^0.9.99",
     "lru-cache": "11.5.3",
     "zod": "4.3.6"
   },
@@ -69,6 +70,10 @@
         "types": "./lib/src/databricks.d.ts",
         "default": "./lib/src/databricks.js"
       },
+      "./files-cache": {
+        "types": "./lib/src/files-cache.d.ts",
+        "default": "./lib/src/files-cache.js"
+      },
       "./identity": {
         "types": "./lib/src/identity.d.ts",
         "default": "./lib/src/identity.js"
@@ -116,7 +121,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.93",
+  "version": "0.9.99",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [
@@ -149,6 +154,10 @@
       "types": "./lib/src/databricks.d.ts",
       "default": "./lib/src/databricks.js"
     },
+    "./files-cache": {
+      "types": "./lib/src/files-cache.d.ts",
+      "default": "./lib/src/files-cache.js"
+    },
     "./identity": {
       "types": "./lib/src/identity.d.ts",
       "default": "./lib/src/identity.js"

package/src/_cache-storage.ts

@@ -40,6 +40,7 @@ export interface L1CacheStorageOptions {
 
 /** AppKit's internal persistent storage surface. */
 export type PersistentStorageBase = CacheStorage & {
+  cleanupExpired?(): Promise<number>;
   initialize(): Promise<void>;
   initialized: boolean;
   schemaName?: string;
@@ -113,6 +114,16 @@ export class L1CacheStorage implements CacheStorage {
     await this.storage.close();
   }
 
+  /** Forward AppKit's runtime-only persistent cleanup hook when available. */
+  async cleanupExpired(): Promise<number> {
+    const cleanup = (
+      this.storage as CacheStorage & {
+        cleanupExpired?: () => Promise<number>;
+      }
+    ).cleanupExpired;
+    return cleanup ? cleanup.call(this.storage) : 0;
+  }
+
   private retain<T>(key: string, entry: CacheEntry<T>): void {
     const ttl = entry.expiry - Date.now();
     if (ttl > 0) this.entries.set(key, entry, { ttl });

package/src/files-cache.ts

@@ -0,0 +1,334 @@
+/**
+ * AppKit-global filesystem cache with user-isolated process-local LRU values.
+ *
+ * @module
+ */
+
+import { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from "@databricks/appkit";
+import { errorUtils, log, object } from "@dbx-tools/shared-core";
+import { posixPath, type CacheValue, type FileSystemCache } from "@dbx-tools/shared-fs";
+import { LRUCache } from "lru-cache";
+
+const DEFAULT_TTL_MS = 60_000;
+const DEFAULT_INVALIDATION_BATCH_MS = 25;
+const DEFAULT_MAX_ENTRIES = 1_000;
+const DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
+const DEFAULT_MAX_SCOPES = 256;
+const logger = log.logger("files-cache");
+
+interface RetainedEntry {
+  value: CacheValue;
+}
+
+interface ScopeState {
+  cache: FileSystemCache;
+  entries: LRUCache<string, RetainedEntry>;
+  group: GroupState;
+  scope: ResolvedFilesCacheScope;
+  sources: Map<string, Promise<object>>;
+}
+
+interface GroupState {
+  pending: Set<string>;
+  scopes: Set<ScopeState>;
+  timer?: ReturnType<typeof setTimeout>;
+}
+
+interface ResolvedFilesCacheConfig {
+  invalidationBatchMs: number;
+  maxBytes: number;
+  maxEntries: number;
+  maxScopes: number;
+  ttlMs: number;
+}
+
+interface ResolvedFilesCacheScope {
+  host: string;
+  ttlMs: number;
+  userKey: string;
+  workspaceId?: string;
+}
+
+/** Configuration for the AppKit files-cache plugin. */
+export interface FilesCachePluginConfig extends BasePluginConfig {
+  /** Default entry TTL in milliseconds. Defaults to 60 seconds. */
+  ttlMs?: number;
+  /** Invalidation debounce window in milliseconds. Defaults to 25ms. */
+  invalidationBatchMs?: number;
+  /** Maximum entries retained in each user L1. Defaults to 1,000. */
+  maxEntries?: number;
+  /** Maximum retained bytes in each user L1. Defaults to 64 MiB. */
+  maxBytes?: number;
+  /** Maximum active user scopes retained by the process. Defaults to 256. */
+  maxScopes?: number;
+}
+
+/** Identity for one authorization-safe filesystem cache scope. */
+export interface FilesCacheScope {
+  /** Databricks workspace host. */
+  host: string;
+  /** Attributed user identifier used to isolate values. */
+  userKey: string;
+  /** Optional workspace identifier included in shared invalidation scope. */
+  workspaceId?: string;
+  /** Optional per-scope entry TTL override in milliseconds. */
+  ttlMs?: number;
+}
+
+/** Stable identity for a framework filesystem source retained within one user scope. */
+export interface FilesCacheSourceIdentity {
+  /** Actual mounted filesystem paths represented by the source. */
+  paths: readonly string[];
+  /** Workspace-instance key separating sources with different policies over the same paths. */
+  key?: string;
+}
+
+/** Public exports from {@link FilesCachePlugin}. */
+export interface FilesCacheExports {
+  /** Resolve one user-isolated filesystem cache. */
+  forScope(scope: FilesCacheScope): Promise<FileSystemCache>;
+  /** Resolve one app-lifetime filesystem source for a user and its actual mounted paths. */
+  forFileSystem<T extends object>(
+    scope: FilesCacheScope,
+    identity: FilesCacheSourceIdentity,
+    load: () => T | Promise<T>,
+  ): Promise<T>;
+  /** Flush pending invalidation batches. */
+  flush(): Promise<void>;
+}
+
+/** Process-local filesystem cache manager. */
+export class FilesCacheManager {
+  private readonly config: ResolvedFilesCacheConfig;
+  private readonly groups = new Map<string, GroupState>();
+  private readonly scopes: LRUCache<string, ScopeState>;
+
+  constructor(config: FilesCachePluginConfig = {}) {
+    this.config = {
+      ttlMs: positiveDuration(config.ttlMs, DEFAULT_TTL_MS, "ttlMs"),
+      invalidationBatchMs: positiveDuration(
+        config.invalidationBatchMs,
+        DEFAULT_INVALIDATION_BATCH_MS,
+        "invalidationBatchMs",
+      ),
+      maxEntries: positiveInteger(config.maxEntries, DEFAULT_MAX_ENTRIES, "maxEntries"),
+      maxBytes: positiveInteger(config.maxBytes, DEFAULT_MAX_BYTES, "maxBytes"),
+      maxScopes: positiveInteger(config.maxScopes, DEFAULT_MAX_SCOPES, "maxScopes"),
+    };
+    this.scopes = new LRUCache({
+      max: this.config.maxScopes,
+      dispose: (state) => {
+        state.group.scopes.delete(state);
+      },
+    });
+  }
+
+  /** Return one user-isolated cache within a host/workspace invalidation group. */
+  async forScope(input: FilesCacheScope): Promise<FileSystemCache> {
+    return (await this.resolveScopeState(input)).cache;
+  }
+
+  /** Retain one stable framework filesystem source for the scope and mounted paths. */
+  async forFileSystem<T extends object>(
+    input: FilesCacheScope,
+    identity: FilesCacheSourceIdentity,
+    load: () => T | Promise<T>,
+  ): Promise<T> {
+    const state = await this.resolveScopeState(input);
+    const paths = identity.paths.map((path) => posixPath.normalizeRoot(path));
+    if (paths.length === 0) throw new TypeError("Filesystem source paths must not be empty");
+    const sourceKey = object.toStableKey({ paths, key: identity.key });
+    let source = state.sources.get(sourceKey);
+    if (!source) {
+      source = Promise.resolve(load());
+      state.sources.set(sourceKey, source);
+    }
+    try {
+      return (await source) as T;
+    } catch (error) {
+      if (state.sources.get(sourceKey) === source) state.sources.delete(sourceKey);
+      throw error;
+    }
+  }
+
+  private async resolveScopeState(input: FilesCacheScope): Promise<ScopeState> {
+    const scope = resolveScope(input, this.config.ttlMs);
+    const scopeKey = object.toStableKey({
+      host: scope.host,
+      userKey: scope.userKey,
+      workspaceId: scope.workspaceId,
+    });
+    let state = this.scopes.get(scopeKey);
+    if (!state) {
+      const group = this.group(scope);
+      state = this.createScope(scope, group);
+      group.scopes.add(state);
+      this.scopes.set(scopeKey, state);
+    }
+    return state;
+  }
+
+  /** Flush every pending invalidation batch. */
+  async flush(): Promise<void> {
+    await Promise.all([...this.groups.values()].map((group) => this.flushInvalidations(group)));
+  }
+
+  /** Flush state and release all process-local entries and timers. */
+  async close(): Promise<void> {
+    for (const group of this.groups.values()) {
+      if (group.timer) clearTimeout(group.timer);
+      group.timer = undefined;
+    }
+    await this.flush();
+    this.scopes.clear();
+    this.groups.clear();
+  }
+
+  private group(scope: ResolvedFilesCacheScope): GroupState {
+    const key = object.toStableKey({
+      host: scope.host,
+      workspaceId: scope.workspaceId,
+    });
+    const existing = this.groups.get(key);
+    if (existing) return existing;
+    const group: GroupState = {
+      pending: new Set(),
+      scopes: new Set(),
+    };
+    this.groups.set(key, group);
+    return group;
+  }
+
+  private createScope(scope: ResolvedFilesCacheScope, group: GroupState): ScopeState {
+    const state = {} as ScopeState;
+    state.scope = scope;
+    state.group = group;
+    state.entries = new LRUCache({
+      max: this.config.maxEntries,
+      maxSize: this.config.maxBytes,
+      sizeCalculation: (entry, cacheKey) => retainedSize(cacheKey, entry),
+    });
+    state.sources = new Map();
+    state.cache = {
+      read: <T extends CacheValue>(cacheKey: string, load: () => T | Promise<T>) =>
+        this.read(state, cacheKey, load),
+      invalidate: (cacheKey: string) => this.queueInvalidation(state, cacheKey),
+      keys: () => this.keys(state),
+    };
+    return state;
+  }
+
+  private async read<T extends CacheValue>(
+    state: ScopeState,
+    key: string,
+    load: () => T | Promise<T>,
+  ): Promise<T> {
+    if (!state.group.pending.has(key)) {
+      const retained = state.entries.get(key);
+      if (retained) return retained.value as T;
+    }
+    const value = await load();
+    state.entries.set(key, { value }, { ttl: state.scope.ttlMs });
+    return value;
+  }
+
+  private *keys(state: ScopeState): Iterable<string> {
+    for (const key of state.entries.keys()) {
+      if (!state.group.pending.has(key)) yield key;
+    }
+  }
+
+  private queueInvalidation(state: ScopeState, key: string): void {
+    state.group.pending.add(key);
+    if (state.group.timer) return;
+    state.group.timer = setTimeout(() => {
+      state.group.timer = undefined;
+      void this.flushInvalidations(state.group).catch((error) => {
+        logger.warn("filesystem cache invalidation batch failed", {
+          error: errorUtils.errorMessage(error),
+        });
+      });
+    }, this.config.invalidationBatchMs);
+    state.group.timer.unref?.();
+  }
+
+  private async flushInvalidations(group: GroupState): Promise<void> {
+    if (group.timer) clearTimeout(group.timer);
+    group.timer = undefined;
+    if (group.pending.size === 0) return;
+    const keys = [...group.pending];
+    group.pending.clear();
+    for (const state of group.scopes) {
+      for (const key of keys) state.entries.delete(key);
+    }
+  }
+}
+
+/** AppKit plugin that owns process-local filesystem LRU caches. */
+export class FilesCachePlugin extends Plugin<FilesCachePluginConfig> {
+  static manifest = {
+    name: "files-cache",
+    displayName: "Files Cache",
+    description: "Provides bounded user-scoped process-local filesystem caches.",
+    stability: "beta",
+    resources: { required: [], optional: [] },
+  } satisfies PluginManifest<"files-cache">;
+
+  private manager?: FilesCacheManager;
+
+  override async setup(): Promise<void> {
+    this.manager = new FilesCacheManager(this.config);
+    this.context?.onLifecycle("shutdown", () => this.manager?.close());
+  }
+
+  override exports(): FilesCacheExports {
+    return {
+      forScope: (scope) => this.requireManager().forScope(scope),
+      forFileSystem: (scope, identity, load) =>
+        this.requireManager().forFileSystem(scope, identity, load),
+      flush: () => this.requireManager().flush(),
+    };
+  }
+
+  private requireManager(): FilesCacheManager {
+    if (!this.manager) throw new Error("Files cache plugin has not completed setup");
+    return this.manager;
+  }
+}
+
+/** AppKit registration factory for {@link FilesCachePlugin}. */
+export const filesCache = toPlugin(FilesCachePlugin);
+
+function resolveScope(input: FilesCacheScope, defaultTtlMs: number): ResolvedFilesCacheScope {
+  const host = input.host.trim().replace(/\/+$/, "");
+  const userKey = input.userKey.trim();
+  const workspaceId = input.workspaceId?.trim() || undefined;
+  if (!host) throw new TypeError("Files cache scope host must not be blank");
+  if (!userKey) throw new TypeError("Files cache scope userKey must not be blank");
+  return {
+    host,
+    userKey,
+    ...(workspaceId ? { workspaceId } : {}),
+    ttlMs: positiveDuration(input.ttlMs, defaultTtlMs, "scope.ttlMs"),
+  };
+}
+
+function positiveDuration(value: number | undefined, fallback: number, name: string): number {
+  const resolved = value ?? fallback;
+  if (!Number.isFinite(resolved) || resolved <= 0) {
+    throw new RangeError(`${name} must be a finite positive number`);
+  }
+  return resolved;
+}
+
+function positiveInteger(value: number | undefined, fallback: number, name: string): number {
+  return Math.floor(positiveDuration(value, fallback, name));
+}
+
+function retainedSize(key: string, entry: RetainedEntry): number {
+  try {
+    return Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(entry.value));
+  } catch {
+    return Number.MAX_SAFE_INTEGER;
+  }
+}