@zintrust/trace 1.8.1 → 2.0.1

package/README.md

@@ -91,6 +91,30 @@ import serviceManifest from './bootstrap/service-manifest';
 ProjectRuntime.set({ serviceManifest });
 ```
 
+#### Cloudflare Workers waitUntil Support
+
+For reliable trace persistence in Cloudflare Workers, set the execution context in your Worker fetch handler:
+
+```ts
+// src/worker.ts or your Worker entrypoint
+import { BackgroundTaskScheduler } from '@zintrust/trace';
+
+export default {
+  async fetch(request, env, ctx) {
+    // Enable reliable trace persistence via ctx.waitUntil()
+    BackgroundTaskScheduler.setExecutionContext(ctx);
+
+    // Initialize and run your ZinTrust app
+    const app = createApp();
+    await app.boot();
+
+    return app.handle(request);
+  },
+};
+```
+
+This ensures trace writes complete reliably even after the HTTP response is sent. Without this, trace writes may be lost in Workers environments. See [docs/WORKER_WAITUNTIL_SUPPORT.md](./docs/WORKER_WAITUNTIL_SUPPORT.md) for details.
+
 Why this is the preferred path:
 
 - The plugin files are the framework-owned opt-in point that ZinTrust already auto-loads during boot.

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export type { ITraceStorage } from './storage';
 export { TraceContentBudget } from './storage/TraceContentBudget';
 export { TraceContentRedaction } from './storage/TraceContentRedaction';
 export { TraceContext } from './context';
+export { BackgroundTaskScheduler } from './runtime/BackgroundTaskScheduler';
 export { registerTraceDashboard, registerTraceRoutes } from './dashboard/routes';
 export type { TraceDashboardOptions, TraceDashboardRegistrationOptions } from './dashboard/routes';
 export { registerTraceIngestGateway, TraceIngestGateway } from './ingest/TraceIngestGateway';

package/dist/index.js

@@ -21,6 +21,10 @@ export { TraceContentRedaction } from './storage/TraceContentRedaction.js';
 // ---------------------------------------------------------------------------
 export { TraceContext } from './context.js';
 // ---------------------------------------------------------------------------
+// Runtime
+// ---------------------------------------------------------------------------
+export { BackgroundTaskScheduler } from './runtime/BackgroundTaskScheduler.js';
+// ---------------------------------------------------------------------------
 // Dashboard
 // ---------------------------------------------------------------------------
 export { registerTraceDashboard, registerTraceRoutes } from './dashboard/routes.js';

package/dist/register.js

@@ -21,6 +21,7 @@
  */
 import { TraceConfig } from './config.js';
 import { TraceContext } from './context.js';
+import { BackgroundTaskScheduler } from './runtime/BackgroundTaskScheduler.js';
 import { ProxyTraceStorage, TraceServiceTag, TraceStorage } from './storage/index.js';
 import { TraceContentBudget } from './storage/TraceContentBudget.js';
 import { TraceContentRedaction } from './storage/TraceContentRedaction.js';
@@ -319,7 +320,14 @@ const createTraceWatcherArgs = async (core, Env, config) => {
         connectionName: resolvedConnectionName,
         logger: core.Logger,
     });
-    return { storage, config, db: observedDb };
+    return {
+        storage,
+        config,
+        db: observedDb,
+        scheduleBackgroundTask: (task) => {
+            BackgroundTaskScheduler.schedule(task);
+        },
+    };
 };
 const registerTraceWatchers = async (watcherArgs) => {
     const [{ HttpWatcher }, { QueryWatcher }, { LogWatcher }, { ExceptionWatcher }, { JobWatcher }, { CacheWatcher }, { ScheduleWatcher }, { MailWatcher }, { AuthWatcher }, { EventWatcher }, { ModelWatcher }, { NotificationWatcher }, { RedisWatcher }, { GateWatcher }, { MiddlewareWatcher }, { CommandWatcher }, { BatchWatcher }, { DumpWatcher }, { ViewWatcher }, { HttpClientWatcher },] = await Promise.all([

package/dist/runtime/BackgroundTaskScheduler.d.ts

@@ -0,0 +1,38 @@
+/**
+ * BackgroundTaskScheduler — runtime-agnostic background task scheduling.
+ * Maps to ctx.waitUntil() in Cloudflare Workers, normal promises in Node.
+ */
+type ExecutionContext = {
+    waitUntil(promise: Promise<unknown>): void;
+};
+type BackgroundTaskScheduler = {
+    schedule(task: Promise<void>): void;
+    isAvailable(): boolean;
+};
+export declare const BackgroundTaskScheduler: Readonly<{
+    /**
+     * Set the Worker execution context for waitUntil support.
+     * Call this from your Cloudflare Worker fetch handler:
+     *   BackgroundTaskScheduler.setExecutionContext(ctx);
+     */
+    setExecutionContext(ctx: ExecutionContext): void;
+    /**
+     * Get the current scheduler instance.
+     */
+    getScheduler(): BackgroundTaskScheduler;
+    /**
+     * Schedule a background task.
+     * In Workers: uses ctx.waitUntil() if context is set
+     * In Node: fire-and-forget with error suppression
+     */
+    schedule(task: Promise<void>): void;
+    /**
+     * Check if a proper scheduler is available (i.e., Workers context is set).
+     */
+    isAvailable(): boolean;
+    /**
+     * Reset the scheduler (useful for testing).
+     */
+    reset(): void;
+}>;
+export {};

package/dist/runtime/BackgroundTaskScheduler.js

@@ -0,0 +1,105 @@
+/**
+ * BackgroundTaskScheduler — runtime-agnostic background task scheduling.
+ * Maps to ctx.waitUntil() in Cloudflare Workers, normal promises in Node.
+ */
+let _executionContext;
+let _scheduler;
+const isCloudflareRuntime = () => {
+    const globalRef = typeof globalThis === 'undefined' ? undefined : globalThis;
+    if (!globalRef)
+        return false;
+    // @ts-ignore - navigator is available in workers
+    if (typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers') {
+        return true;
+    }
+    return (typeof globalRef.caches !== 'undefined' ||
+        typeof globalRef.WebSocketPair === 'function' ||
+        typeof globalRef.CF !== 'undefined');
+};
+const createWorkerScheduler = (ctx) => {
+    return Object.freeze({
+        schedule(task) {
+            ctx.waitUntil(task);
+        },
+        isAvailable() {
+            return true;
+        },
+    });
+};
+const createNodeScheduler = () => {
+    return Object.freeze({
+        schedule(task) {
+            // In Node, fire-and-forget is acceptable since the process doesn't terminate
+            // like Workers do. We still catch errors to prevent unhandled rejections.
+            task.catch(() => {
+                // Silently ignore background task errors to avoid noise
+                // The individual watchers handle their own error logging
+            });
+        },
+        isAvailable() {
+            return true;
+        },
+    });
+};
+const createFallbackScheduler = () => {
+    return Object.freeze({
+        schedule(task) {
+            // Fallback: fire-and-forget with error suppression
+            task.catch(() => undefined);
+        },
+        isAvailable() {
+            return false;
+        },
+    });
+};
+export const BackgroundTaskScheduler = Object.freeze({
+    /**
+     * Set the Worker execution context for waitUntil support.
+     * Call this from your Cloudflare Worker fetch handler:
+     *   BackgroundTaskScheduler.setExecutionContext(ctx);
+     */
+    setExecutionContext(ctx) {
+        _executionContext = ctx;
+        _scheduler = createWorkerScheduler(ctx);
+    },
+    /**
+     * Get the current scheduler instance.
+     */
+    getScheduler() {
+        if (_scheduler)
+            return _scheduler;
+        if (_executionContext) {
+            _scheduler = createWorkerScheduler(_executionContext);
+            return _scheduler;
+        }
+        if (isCloudflareRuntime()) {
+            // We're in Workers but no context was set - use fallback
+            _scheduler = createFallbackScheduler();
+            return _scheduler;
+        }
+        // Node.js or other runtime
+        _scheduler = createNodeScheduler();
+        return _scheduler;
+    },
+    /**
+     * Schedule a background task.
+     * In Workers: uses ctx.waitUntil() if context is set
+     * In Node: fire-and-forget with error suppression
+     */
+    schedule(task) {
+        this.getScheduler().schedule(task);
+    },
+    /**
+     * Check if a proper scheduler is available (i.e., Workers context is set).
+     */
+    isAvailable() {
+        return this.getScheduler().isAvailable();
+    },
+    /**
+     * Reset the scheduler (useful for testing).
+     */
+    reset() {
+        _executionContext = undefined;
+        _scheduler = undefined;
+    },
+});

package/dist/types.d.ts

@@ -272,6 +272,8 @@ export interface ITraceWatcherConfig {
     db?: IDatabase;
     /** Optional: provide to allow HttpWatcher to register as global middleware. */
     registerMiddleware?: (fn: (req: unknown, res: unknown, next: () => Promise<void>) => Promise<void>) => void;
+    /** Optional: schedule a background task (maps to ctx.waitUntil in Workers, normal promise in Node). */
+    scheduleBackgroundTask?: (task: Promise<void>) => void;
 }
 export interface ITraceWatcher {
     register(opts: ITraceWatcherConfig): () => void;

package/dist/watchers/ExceptionWatcher.js

@@ -35,6 +35,7 @@ const buildContent = (err, context) => {
     };
 };
 let _storage = null;
+let _scheduleBackgroundTask = null;
 let _listenerRefCount = 0;
 let _ignoreRoutes = [];
 let _ignorePaths = [];
@@ -72,7 +73,7 @@ const captureException = (err, context) => {
     const content = buildContent(err, context);
     const hash = familyHash(`${content.class}:${content.file}:${content.line}`);
     const uuid = crypto.randomUUID();
-    storage
+    const writePromise = storage
         .writeEntry({
         uuid,
         batchId: context?.batchId ?? TraceContext.getBatchId(),
@@ -85,13 +86,19 @@ const captureException = (err, context) => {
     })
         .then(() => storage.markFamilyStale(hash, uuid))
         .catch(() => undefined);
+    // Use background task scheduler if available (Workers waitUntil support)
+    if (_scheduleBackgroundTask) {
+        _scheduleBackgroundTask(writePromise);
+    }
+    // Otherwise, the promise is already fire-and-forget with error suppression
 };
 export const ExceptionWatcher = Object.freeze({
     capture: captureException,
-    register({ storage, config }) {
+    register({ storage, config, scheduleBackgroundTask }) {
         if (config.watchers.exception === false)
             return () => undefined;
         _storage = storage;
+        _scheduleBackgroundTask = scheduleBackgroundTask ?? null;
         _ignoreRoutes = config.ignoreRoutes;
         _ignorePaths = config.ignorePaths;
         if (_listenerRefCount === 0) {
@@ -104,6 +111,7 @@ export const ExceptionWatcher = Object.freeze({
                 unregisterProcessListeners();
             }
             _storage = null;
+            _scheduleBackgroundTask = null;
             _ignoreRoutes = [];
             _ignorePaths = [];
         };

package/dist/watchers/HttpClientWatcher.js

@@ -4,6 +4,7 @@ import { AuthTag } from '../utils/authTag.js';
 import { redactHeaders, redactUnknown } from '../utils/redact.js';
 import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
+let _scheduleBackgroundTask = null;
 let _redactHeaderNames = [];
 let _redactBodyFields = [];
 let _ignoreRoutes = [];
@@ -126,7 +127,7 @@ const emit = ({ source, method, url, requestHeaders, responseStatus, duration, r
         responseBody,
         error,
     }, sourceRule, normalizedSource);
-    _storage
+    const writePromise = _storage
         .writeEntry({
         uuid: crypto.randomUUID(),
         batchId: TraceContext.getBatchId(),
@@ -137,13 +138,19 @@ const emit = ({ source, method, url, requestHeaders, responseStatus, duration, r
         createdAt: TraceContext.now(),
     })
         .catch(() => undefined);
+    // Use background task scheduler if available (Workers waitUntil support)
+    if (_scheduleBackgroundTask) {
+        _scheduleBackgroundTask(writePromise);
+    }
+    // Otherwise, the promise is already fire-and-forget with error suppression
 };
 export const HttpClientWatcher = Object.freeze({
     emit,
-    register({ storage, config }) {
+    register({ storage, config, scheduleBackgroundTask }) {
         if (!isWatcherEnabled(config.watchers.clientRequest))
             return () => undefined;
         _storage = storage;
+        _scheduleBackgroundTask = scheduleBackgroundTask ?? null;
         _clientRequestWatcher =
             typeof config.watchers.clientRequest === 'object' && config.watchers.clientRequest !== null
                 ? config.watchers.clientRequest
@@ -154,6 +161,7 @@ export const HttpClientWatcher = Object.freeze({
         _ignorePaths = config.ignorePaths;
         return () => {
             _storage = null;
+            _scheduleBackgroundTask = null;
             _clientRequestWatcher = undefined;
             _redactBodyFields = [];
             _ignoreRoutes = [];

package/dist/watchers/HttpWatcher.js

@@ -130,7 +130,7 @@ const shouldIgnore = (req, config) => {
 };
 const isWatcherEnabled = (config) => config.watchers.request !== false;
 export const HttpWatcher = Object.freeze({
-    register({ storage, config, registerMiddleware }) {
+    register({ storage, config, registerMiddleware, scheduleBackgroundTask, }) {
         if (!isWatcherEnabled(config))
             return () => undefined;
         if (!registerMiddleware)
@@ -162,14 +162,22 @@ export const HttpWatcher = Object.freeze({
                     isLatest: true,
                     createdAt: TraceContext.now(),
                 };
-                storage.writeEntry(entry).catch((error) => {
+                const writePromise = storage.writeEntry(entry).catch((error) => {
                     Logger.warn('[trace] HttpWatcher writeEntry failed', {
                         method: content.method,
                         uri: content.uri,
                         entryUuid: entry.uuid,
                         error: error instanceof Error ? error.message : String(error),
                     });
-                }); // fire-and-forget
+                });
+                // Use background task scheduler if available (Workers waitUntil support)
+                if (scheduleBackgroundTask) {
+                    scheduleBackgroundTask(writePromise);
+                }
+                else {
+                    // Fallback to fire-and-forget for backward compatibility
+                    writePromise.catch(() => undefined);
+                }
             };
             const completionHandler = registerCompletionHandler(response, persistEntry);
             await next();

package/dist/watchers/LogWatcher.js

@@ -54,7 +54,7 @@ const shouldSkipTraceInfrastructureLog = (message, context) => {
         isTraceStorageQueryLog(message, context));
 };
 export const LogWatcher = Object.freeze({
-    register({ storage, config }) {
+    register({ storage, config, scheduleBackgroundTask }) {
         if (config.watchers.log === false)
             return () => undefined;
         const minPriority = LEVEL_PRIORITY[config.logMinLevel] ?? 1;
@@ -75,7 +75,7 @@ export const LogWatcher = Object.freeze({
                 context: context ?? undefined,
                 hostname: TraceContext.getHostname(),
             };
-            storage
+            const writePromise = storage
                 .writeEntry({
                 uuid: crypto.randomUUID(),
                 batchId: TraceContext.getBatchId(),
@@ -86,6 +86,11 @@ export const LogWatcher = Object.freeze({
                 createdAt: TraceContext.now(),
             })
                 .catch(() => undefined);
+            // Use background task scheduler if available (Workers waitUntil support)
+            if (scheduleBackgroundTask) {
+                scheduleBackgroundTask(writePromise);
+            }
+            // Otherwise, the promise is already fire-and-forget with error suppression
         });
         return unsubscribe;
     },

package/dist/watchers/QueryWatcher.js

@@ -7,6 +7,7 @@ import { EntryType } from '../types.js';
 import { AuthTag } from '../utils/authTag.js';
 let _storage = null;
 let _config = null;
+let _scheduleBackgroundTask = null;
 const bindingsInterpolated = (sql, params) => {
     // Inline params for display only — safe, not for re-execution.
     let i = 0;
@@ -51,7 +52,7 @@ const emit = (query, params, duration, connection = 'default') => {
     const tags = AuthTag.append([]);
     if (slow)
         tags.push('slow');
-    _storage
+    const writePromise = _storage
         .writeEntry({
         uuid: crypto.randomUUID(),
         batchId,
@@ -63,16 +64,22 @@ const emit = (query, params, duration, connection = 'default') => {
         createdAt: TraceContext.now(),
     })
         .catch(() => undefined);
+    // Use background task scheduler if available (Workers waitUntil support)
+    if (_scheduleBackgroundTask) {
+        _scheduleBackgroundTask(writePromise);
+    }
+    // Otherwise, the promise is already fire-and-forget with error suppression
 };
 export const QueryWatcher = Object.freeze({
     emit,
-    register({ storage, config, db: injectedDb }) {
+    register({ storage, config, db: injectedDb, scheduleBackgroundTask, }) {
         if (config.watchers.query === false)
             return () => undefined;
         if (!injectedDb)
             return () => undefined; // no db available
         _storage = storage;
         _config = config;
+        _scheduleBackgroundTask = scheduleBackgroundTask ?? null;
         const db = injectedDb;
         const handler = (query, params, duration) => {
             emit(query, params, duration);
@@ -81,6 +88,7 @@ export const QueryWatcher = Object.freeze({
         return () => {
             _storage = null;
             _config = null;
+            _scheduleBackgroundTask = null;
             db.offAfterQuery?.(handler);
         };
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/trace",
-  "version": "1.8.1",
+  "version": "2.0.1",
   "description": "Trace assistant for ZinTrust: logs requests, queries, exceptions, jobs, and more.",
   "private": false,
   "type": "module",

package/dist/build-manifest.json

@@ -1,453 +0,0 @@
-{
-  "name": "@zintrust/trace",
-  "version": "1.6.4",
-  "buildDate": "2026-04-30T15:30:37.643Z",
-  "buildEnvironment": {
-    "node": "v25.6.1",
-    "platform": "darwin",
-    "arch": "arm64"
-  },
-  "git": {
-    "commit": "f235df8b",
-    "branch": "release"
-  },
-  "package": {
-    "engines": {
-      "node": ">=20.0.0"
-    },
-    "dependencies": [],
-    "peerDependencies": [
-      "@zintrust/core"
-    ]
-  },
-  "files": {
-    "TraceConnection.d.ts": {
-      "size": 1500,
-      "sha256": "0748601bebff011a0b3dbab736617d5e3dffe4af671f4b6f7af03012d58e5464"
-    },
-    "TraceConnection.js": {
-      "size": 4640,
-      "sha256": "c51cc312046b6b2bbe1673f1ff9508425cc7140a1d2341907f67aa36069c09f9"
-    },
-    "build-manifest.json": {
-      "size": 15912,
-      "sha256": "6732e16044ffbcb77bf9873cf30a671007b5acc4aa2f3edf5071da667d4df534"
-    },
-    "cli-register.d.ts": {
-      "size": 255,
-      "sha256": "da8d689fe5ef32e97e755f28017e4d3cb1aa63489073a71907ea41ad5761ede9"
-    },
-    "cli-register.js": {
-      "size": 1123,
-      "sha256": "c6de87d0a73df7ac66e18ecdc6f758b2652ec3abe9698e43620cf41135b33e4b"
-    },
-    "config.d.ts": {
-      "size": 470,
-      "sha256": "b034cbef0c71fb868071363624ef7a9f8d7acc20f8be8c895dd5db5a75e81f37"
-    },
-    "config.js": {
-      "size": 10503,
-      "sha256": "4514e95067194c7afacb1202a8f1caffc64a400dd995cf809301b1a51a67da38"
-    },
-    "context.d.ts": {
-      "size": 596,
-      "sha256": "4b8dade537b29dae3942d02c22e535f3b1ba1f0f6142e3a74203d4fa962a412b"
-    },
-    "context.js": {
-      "size": 2520,
-      "sha256": "00a82a58e18fb33934f449a9fb379a2f90023570ceed1676eae0aed59b02ddeb"
-    },
-    "dashboard/handlers.d.ts": {
-      "size": 993,
-      "sha256": "430f5b294d960e13e2ec39ed5c22f6655f85c46c2de9455c222505c67298ec6a"
-    },
-    "dashboard/handlers.js": {
-      "size": 10011,
-      "sha256": "a5f7f3d624a844df27ddc9d4908e73d91a4aac9b2aac1aefff1f391913353897"
-    },
-    "dashboard/routes.d.ts": {
-      "size": 997,
-      "sha256": "0ac87bc54e57978e8a9ac5924d248e1f984927bb6c819ea5528ab1179b0b50b8"
-    },
-    "dashboard/routes.js": {
-      "size": 2501,
-      "sha256": "06f0bf42214ed7691907443c0a1d5a4d8c3db3ce3f7b8269ba401ff421a54dfd"
-    },
-    "dashboard/ui.d.ts": {
-      "size": 117,
-      "sha256": "4862b41e0477f01afa0dbb446d4553b65c22ed774cd1e2db3489059ced392f94"
-    },
-    "dashboard/ui.js": {
-      "size": 84221,
-      "sha256": "b260cd17012cd5bf5f24f24eb8958d0cf79bed1d976412def3706f960b3aefa6"
-    },
-    "index.d.ts": {
-      "size": 2693,
-      "sha256": "901aaefe88fb2cc1e7771cd541f41ebcfe6443390bd66905eacbda51f1a6f73d"
-    },
-    "index.js": {
-      "size": 3421,
-      "sha256": "ee5aca20d1e6d980fa0b2c02e4832c35e8a18fff9fe63a7bf6a26ae8f734d377"
-    },
-    "ingest/TraceIngestGateway.d.ts": {
-      "size": 786,
-      "sha256": "3a0a46fa5bbf5367047214533ec0ee92a171ee35a60d25c197eea1eed1ff0f65"
-    },
-    "ingest/TraceIngestGateway.js": {
-      "size": 10936,
-      "sha256": "c95f0e42f1294d8ae2e406a5910f8e74044c2b586e82e726876d75ddfafef27e"
-    },
-    "migrations/20260331000001_create_zin_trace_entries_table.d.ts": {
-      "size": 304,
-      "sha256": "7d99b4d7c02855d6e68ad87e39dffff5fec83a406bdf2414665c23ba3ce8711d"
-    },
-    "migrations/20260331000001_create_zin_trace_entries_table.js": {
-      "size": 955,
-      "sha256": "6aa54f3a6a95a78714e9b14d7f6adb4e94e9420e4e17ac467b43fef12bbc2583"
-    },
-    "migrations/20260331000002_create_zin_trace_entries_tags_table.d.ts": {
-      "size": 304,
-      "sha256": "6d07c135b0fa34acbda2f7f0788e4db657b00ba7c7459e2b203c8ded9c55b9dc"
-    },
-    "migrations/20260331000002_create_zin_trace_entries_tags_table.js": {
-      "size": 737,
-      "sha256": "614280fc7f3a5826c3e8334e2a38d707b562217fb68a660aff0d9a6c072f7b2a"
-    },
-    "migrations/20260331000003_create_zin_trace_monitoring_table.d.ts": {
-      "size": 308,
-      "sha256": "019e84f70cedf363eaf85a115d935abed841627b4a31d7fa34131352d402187a"
-    },
-    "migrations/20260331000003_create_zin_trace_monitoring_table.js": {
-      "size": 522,
-      "sha256": "dd80ea1fdfe6ea7f57330b2dff530d97ee8054081436f41bbf234b814cb1df19"
-    },
-    "migrations/20260407193000_widen_trace_created_at_for_sql.d.ts": {
-      "size": 335,
-      "sha256": "6e9c826a08a983927d9e801b2740f58d0cf6fbf7bff02ee5c1fd01227f73b741"
-    },
-    "migrations/20260407193000_widen_trace_created_at_for_sql.js": {
-      "size": 1185,
-      "sha256": "1de9d8e4a91ffeaed4a0bc5cf942e428cd76bdb6b65bc67fa76ef62f3c99e94d"
-    },
-    "migrations/index.d.ts": {
-      "size": 280,
-      "sha256": "0ba7bc9421754ff489f6947463c13e7e9c80558eb6611a818f3baab3b518a502"
-    },
-    "migrations/index.js": {
-      "size": 500,
-      "sha256": "6118c5f4e01ecd73208425253caa3a17e4304ff6f9f00ac7afc18785684e9e85"
-    },
-    "plugin.d.ts": {
-      "size": 16,
-      "sha256": "71d366165dd36f1675aa253a76262b226fb6c62e5ab632746b8aea61c0c625fc"
-    },
-    "plugin.js": {
-      "size": 128,
-      "sha256": "2d05bec517f57634276220b8a946125059fe0e320c42295b4f5a985431bb3d1c"
-    },
-    "register.d.ts": {
-      "size": 72,
-      "sha256": "535869aa1bfcdf0ec26fad27d7f18bb8822bc586c38fcc5ffdde5274ecbea17e"
-    },
-    "register.js": {
-      "size": 19680,
-      "sha256": "042a7585e68a8a676e25f33c9a176c6f263bccb4a63090b4d2cea52b9bcdd193"
-    },
-    "storage/DebuggerStorage.d.ts": {
-      "size": 517,
-      "sha256": "c9c215aaa414f7b0c1fec6c82b054fc52bdf97af58f96f35c7f96672fb859c31"
-    },
-    "storage/DebuggerStorage.js": {
-      "size": 7442,
-      "sha256": "5ecce0fcfcf695df587a7b90a7a5c7efd2e64ad13c9f2d104b392f89f34f0dc4"
-    },
-    "storage/ProxyTraceStorage.d.ts": {
-      "size": 339,
-      "sha256": "9c724ff342dfe82da12e7cce95593f6623faa80c40f97593719b8e78e95f266d"
-    },
-    "storage/ProxyTraceStorage.js": {
-      "size": 4330,
-      "sha256": "672c95ed022504b2e5be62f3c2b31bac168ac06158d793dd020f7e38907e8f64"
-    },
-    "storage/TraceContentBudget.d.ts": {
-      "size": 1306,
-      "sha256": "606a37af0a4aef4866c22cc727f67f485c43181b40eb831e1920b8b90fdaf503"
-    },
-    "storage/TraceContentBudget.js": {
-      "size": 11495,
-      "sha256": "8ed670773814f7b86b916c43ac43b048defc6a102593d808dfb4c8cf7606edf3"
-    },
-    "storage/TraceContentRedaction.d.ts": {
-      "size": 207,
-      "sha256": "2fd7b317c5ee87d8ecaa6467a75959499673ef374fec3ecfaa7911c4f3d5c83c"
-    },
-    "storage/TraceContentRedaction.js": {
-      "size": 1083,
-      "sha256": "127aa026f155c47361d3b44021138157cb2743f5e02e044ce6df66cc693cc3cb"
-    },
-    "storage/TraceEntryFiltering.d.ts": {
-      "size": 196,
-      "sha256": "a1158cedb4e4e749658127086e138e47886422366a697619d6ea9bd3338066e6"
-    },
-    "storage/TraceEntryFiltering.js": {
-      "size": 1579,
-      "sha256": "a096b0fadf21cd692e554e6ca7789f08759cffe1c690845cb33c5876c8587cc5"
-    },
-    "storage/TraceServiceTag.d.ts": {
-      "size": 224,
-      "sha256": "35d93c82d6db80071946adaa8e40d012408b469949f1002f85ae3fd20b0a70c8"
-    },
-    "storage/TraceServiceTag.js": {
-      "size": 1916,
-      "sha256": "1ddad82563c98ddbb4033e9b8fb31901d635cffa7024d499a896f0d7a6d00900"
-    },
-    "storage/TraceStorage.d.ts": {
-      "size": 517,
-      "sha256": "c9c215aaa414f7b0c1fec6c82b054fc52bdf97af58f96f35c7f96672fb859c31"
-    },
-    "storage/TraceStorage.js": {
-      "size": 15322,
-      "sha256": "95179a66f0774fb6c1622e7477d6e1420e374116800a6a0c60e14de9bd4c4c5c"
-    },
-    "storage/TraceWriteDiagnostics.d.ts": {
-      "size": 581,
-      "sha256": "5f49df97a830ad895653fa4a18b3a1b31ca4a5066d6f8150ee02dca013e16397"
-    },
-    "storage/TraceWriteDiagnostics.js": {
-      "size": 7041,
-      "sha256": "6fc34e6e52a9b463db0967dba4aec4c8c706b6978c496f568637ffc15327279a"
-    },
-    "storage/index.d.ts": {
-      "size": 210,
-      "sha256": "bb4c3a0c73eb3e2629dd1a1dbc29eecedd1910a37b221357cc7981ced320bdeb"
-    },
-    "storage/index.js": {
-      "size": 166,
-      "sha256": "ed5e83e108cd15f9a3976be71e966bdf0c44d8e0266d1d2dbad189f0885ad501"
-    },
-    "types.d.ts": {
-      "size": 10037,
-      "sha256": "68a2de953af2fce1a12447078177ff886f10e853c760378e13478b2558648868"
-    },
-    "types.js": {
-      "size": 696,
-      "sha256": "1cc1b7f7ff4760e6b4ccd642f6aa2f35453c4f40e6a360c3a525304729407836"
-    },
-    "ui.d.ts": {
-      "size": 382,
-      "sha256": "d8b33d77c1c6ccd82e140db83a1bf57edb4d62c03cd15360c2c2d70bd2b392ee"
-    },
-    "ui.js": {
-      "size": 285,
-      "sha256": "3a3cef493f0b9789a7198da620fd7e72ea2377fed3eba25572bb0d222155a446"
-    },
-    "utils/authTag.d.ts": {
-      "size": 150,
-      "sha256": "db7ed89155df453650ad2805d8cd7069a70b14eacac2d97c4b0bebd45df4bdd4"
-    },
-    "utils/authTag.js": {
-      "size": 534,
-      "sha256": "0c506812967c17548162ce0f28d96089b023865883ee8cfd0824a94084580afb"
-    },
-    "utils/entryFilter.d.ts": {
-      "size": 183,
-      "sha256": "a7809e98f76b4e326262c26b0e43e278b1c50ac0b35fee145e3e6006357dc700"
-    },
-    "utils/entryFilter.js": {
-      "size": 4123,
-      "sha256": "de2690c6e5852969083387b469fd2e12f10470c6eee81120154437cd8d8f3555"
-    },
-    "utils/familyHash.d.ts": {
-      "size": 60,
-      "sha256": "c94f85390c52470df6946a39576c720ea92c89797ae62fff913191c45580248f"
-    },
-    "utils/familyHash.js": {
-      "size": 266,
-      "sha256": "f60526423e69fa5c461b0f5d8dac90b1f0c18149609cd1109226f1c8d985f223"
-    },
-    "utils/redact.d.ts": {
-      "size": 449,
-      "sha256": "b72d01ebac46a984d314905b14de5b05c3f9c27141e460c5305dd16e347f5a13"
-    },
-    "utils/redact.js": {
-      "size": 2646,
-      "sha256": "4e82eaa3bb48f9d621b70f69519b0615d992068eb9f836beaf6df6c2382c2cff"
-    },
-    "utils/requestFilter.d.ts": {
-      "size": 398,
-      "sha256": "fb214bde16e970c58ac23a32b51def87157a495a89e70ad6a1aa9e28c8c721c4"
-    },
-    "utils/requestFilter.js": {
-      "size": 1947,
-      "sha256": "214855796b6dbe524a357355fb7c9c8fd0fa9705d9163f7ad0882f463e0ae5b1"
-    },
-    "utils/stackFrame.d.ts": {
-      "size": 149,
-      "sha256": "55008bb0bf16e96c7b4f706fa3aa2d3a5bb3a68d0b8bcbd046d23462a7f620e8"
-    },
-    "utils/stackFrame.js": {
-      "size": 1413,
-      "sha256": "ca651d04eaea48a240ec7c5714a0f8f1d92f2fcdaa6e735df0009b56de8c29ed"
-    },
-    "watchers/AuthWatcher.d.ts": {
-      "size": 225,
-      "sha256": "b062850fa3edd3d58bb293025b1dfc5491e39807b3ab3e4cc1c1aaa31316a7a3"
-    },
-    "watchers/AuthWatcher.js": {
-      "size": 1437,
-      "sha256": "c47cca14113fed3825610c9a5a28a4ef7b99ea238952b3df48a997d63eab6fd2"
-    },
-    "watchers/BatchWatcher.d.ts": {
-      "size": 277,
-      "sha256": "b1870a793f2dc7ed22705c8a2a6b6f970fa1bcd0229dbf12f185323b35f3bdcf"
-    },
-    "watchers/BatchWatcher.js": {
-      "size": 1338,
-      "sha256": "113a1077d267734335483cdc48bf94e929edb11f5a0f3f83234bd4e7da8bf6ef"
-    },
-    "watchers/CacheWatcher.d.ts": {
-      "size": 314,
-      "sha256": "19b5f6fe4f0fc8f3df6762f4f46d36f198c7c7d7da8d3d23e5c8f124462e8cf7"
-    },
-    "watchers/CacheWatcher.js": {
-      "size": 2067,
-      "sha256": "8e038d3d72fcd69286674ec06b916389872eaa393dc7bfb8667b0979a68115a4"
-    },
-    "watchers/CommandWatcher.d.ts": {
-      "size": 267,
-      "sha256": "f1b3a3253e7265c7b56a74ba674cd23426ea5227a33abb1bde0d941e2a02e894"
-    },
-    "watchers/CommandWatcher.js": {
-      "size": 1553,
-      "sha256": "b341c7a0ad2a1d8d6d21e5a14b8151d904194d292c8ef1f3a80cf8d507fc3f2a"
-    },
-    "watchers/DumpWatcher.d.ts": {
-      "size": 308,
-      "sha256": "13f81df217258b0827027cbba35b5ad549453fe2709bd4fcc66d845b065500ec"
-    },
-    "watchers/DumpWatcher.js": {
-      "size": 1441,
-      "sha256": "36ea2e9a6c73dc96e75d31fd3c2710548ebfd0a651bab0dde185c33d611be079"
-    },
-    "watchers/EventWatcher.d.ts": {
-      "size": 223,
-      "sha256": "f5a173b0f92490e417d175011d4191d8eafe9ff75d712adb55cece5368753ef6"
-    },
-    "watchers/EventWatcher.js": {
-      "size": 1299,
-      "sha256": "832d5db66433f685eea7a3da208fb226b62eb49c22f94619762962a04e58b122"
-    },
-    "watchers/ExceptionWatcher.d.ts": {
-      "size": 311,
-      "sha256": "0f58c50fd77704151399ca6cb6ec7890a9aef86afe28235951971f8cc9c1d600"
-    },
-    "watchers/ExceptionWatcher.js": {
-      "size": 3816,
-      "sha256": "52d21188c499fa409fa50691fee3d27ea08ad93b26199d9a42c08e76217d6de2"
-    },
-    "watchers/GateWatcher.d.ts": {
-      "size": 262,
-      "sha256": "2fb8699f8679d2442aa322d40fb5cd4bb4e944804bdc6b094a9daf406a407abf"
-    },
-    "watchers/GateWatcher.js": {
-      "size": 1330,
-      "sha256": "e3666b5d65ead0ccd3fe7a6d684d3245dda9d3ddd6da393e0afa028585f08679"
-    },
-    "watchers/HttpClientWatcher.d.ts": {
-      "size": 346,
-      "sha256": "dfb13bba526d5338e4dcd7a5aa0f72a61a03d9e2f6a250250c0bb8f0054c9712"
-    },
-    "watchers/HttpClientWatcher.js": {
-      "size": 5898,
-      "sha256": "320b5a264f26bfeb29ba9246ffa65b79e244db715a4614d69a1425364062d5f9"
-    },
-    "watchers/HttpWatcher.d.ts": {
-      "size": 96,
-      "sha256": "ce9a95a670f755193fd74ce721dbfa4b30f20c879a6566ebb35229b3b2435429"
-    },
-    "watchers/HttpWatcher.js": {
-      "size": 6152,
-      "sha256": "b5af31b46a9a8754f6032fde78fc46e9ad7221977a0bfbbaa26e13214951ea0f"
-    },
-    "watchers/JobWatcher.d.ts": {
-      "size": 441,
-      "sha256": "097c043678ac6b218096c9b04bc5922fc8ed2a31e9f53abc36f6e0d6f63180f0"
-    },
-    "watchers/JobWatcher.js": {
-      "size": 3317,
-      "sha256": "494646d87c71d1fbf069835fcf10c56dec7b449e2fc1b24e0c82d511aba085e4"
-    },
-    "watchers/LogWatcher.d.ts": {
-      "size": 95,
-      "sha256": "f3ddc5f8b58c6c86ac6b464dd48e5a55e79ab2bf2e735feacffc7480e4ccc0c4"
-    },
-    "watchers/LogWatcher.js": {
-      "size": 3290,
-      "sha256": "0297479465b25f93ab0b11bfd6c2083afe9023fdddaa1b7841d12d68b294fa3e"
-    },
-    "watchers/MailWatcher.d.ts": {
-      "size": 244,
-      "sha256": "5031b96ef8e64a6d376576e8cddf1c2560f22432a78f1d2be55f7cea6bff4547"
-    },
-    "watchers/MailWatcher.js": {
-      "size": 1766,
-      "sha256": "2b583137bb9800901a7ae70cc1af6e9f8763215f0f05f170af9cfb4556530780"
-    },
-    "watchers/MiddlewareWatcher.d.ts": {
-      "size": 259,
-      "sha256": "5a28b472c835bd0f79ec9d3670516544bc5b6da9f1f1bed5159be0cba39304a1"
-    },
-    "watchers/MiddlewareWatcher.js": {
-      "size": 1510,
-      "sha256": "4ed2a81d8f7b7984f572d1bea16abd7a40a896de789e668def961e32bb8eea7f"
-    },
-    "watchers/ModelWatcher.d.ts": {
-      "size": 285,
-      "sha256": "4c05112af855a92b3f3f97c6b61bf1b07444bcb7d5a17f3e0ae19da4a85faf1c"
-    },
-    "watchers/ModelWatcher.js": {
-      "size": 1492,
-      "sha256": "ae4151b422eb73500f981c799e5a261d7349ad36b4be060a56e5ad7944e85cae"
-    },
-    "watchers/NotificationWatcher.d.ts": {
-      "size": 274,
-      "sha256": "a1d918122c5db9a7f27fdf78c0c14a61f6e1213748ee6f9b06f976f33589dc33"
-    },
-    "watchers/NotificationWatcher.js": {
-      "size": 1808,
-      "sha256": "06bbc437a9e5ec29252e365fa4707e68ae9348b3f755094c14f0e18c99dad3ed"
-    },
-    "watchers/QueryWatcher.d.ts": {
-      "size": 240,
-      "sha256": "5d5046c65e5b683369c7709f1acd09b60aec3e7f44748fd1baeb35498836465b"
-    },
-    "watchers/QueryWatcher.js": {
-      "size": 2855,
-      "sha256": "dcb9fe2049e71b5fc850286758737d80738a07dd470d96f36e418d4f54e16263"
-    },
-    "watchers/RedisWatcher.d.ts": {
-      "size": 294,
-      "sha256": "0a0f0ef387cb02a20cb9a4308a87b48dbfbf1076b7e3090801fef7c9c794ec84"
-    },
-    "watchers/RedisWatcher.js": {
-      "size": 1349,
-      "sha256": "bcafbadbbc6caa85284a384efa8894895c077588ebb5fb45f0f966d869caf960"
-    },
-    "watchers/ScheduleWatcher.d.ts": {
-      "size": 291,
-      "sha256": "1d049cfc2472876bf11c4d091c2a889b948bfb2ac714da2aed8affd965f311a6"
-    },
-    "watchers/ScheduleWatcher.js": {
-      "size": 1393,
-      "sha256": "f653c3728d928b253b7f4fd4e1afd228bedf4ce32c52f107effa99aa026ada45"
-    },
-    "watchers/ViewWatcher.d.ts": {
-      "size": 202,
-      "sha256": "980ac30b405d135cd754de1462722147944a37b4f5271ce769afb6b71fa748b1"
-    },
-    "watchers/ViewWatcher.js": {
-      "size": 1180,
-      "sha256": "9af344802c5973a020487e261009e8d1a19a74b78ba7b388d33ce50687277c81"
-    }
-  }
-}

package/dist/storage/DebuggerStorage.d.ts

@@ -1,13 +0,0 @@
-/**
- * TraceStorage — sealed namespace wrapping the D1/SQLite driver.
- * Resolves the correct IDatabase from the app config, then delegates all
- * read/write operations to the trace storage facade.
- */
-import type { IDatabase } from '@zintrust/core';
-import type { ITraceStorage } from '../types';
-export declare const TraceStorage: Readonly<{
-    resolveStorage: (db: IDatabase) => ITraceStorage;
-    reset: () => void;
-    familyHash: (input: string) => string;
-}>;
-export { type ITraceStorage } from '../types';

package/dist/storage/DebuggerStorage.js

@@ -1,195 +0,0 @@
-import { familyHash } from '../utils/familyHash.js';
-const TABLE_ENTRIES = 'zin_trace_entries';
-const TABLE_TAGS = 'zin_trace_entries_tags';
-const TABLE_MONITORING = 'zin_trace_monitoring';
-const generateUuid = () => crypto.randomUUID();
-const rowToEntry = (row, tags) => ({
-    uuid: row.uuid,
-    batchId: row.batch_id,
-    familyHash: row.family_hash ?? undefined,
-    type: row.type,
-    content: JSON.parse(row.content),
-    tags,
-    isLatest: Boolean(row.is_latest),
-    createdAt: row.created_at,
-});
-const insertTags = async (db, uuid, tags) => {
-    if (tags.length === 0)
-        return;
-    await Promise.all(tags.map(async (tag) => {
-        await db.execute(`INSERT OR IGNORE INTO ${TABLE_TAGS} (entry_uuid, tag) VALUES (?, ?)`, [
-            uuid,
-            tag,
-        ]);
-    }));
-};
-const buildEntryFilters = (opts) => {
-    const conditions = [];
-    const params = [];
-    if (opts.type) {
-        conditions.push('e.type = ?');
-        params.push(opts.type);
-    }
-    if (opts.batchId) {
-        conditions.push('e.batch_id = ?');
-        params.push(opts.batchId);
-    }
-    if (opts.from) {
-        conditions.push('e.created_at >= ?');
-        params.push(opts.from);
-    }
-    if (opts.to) {
-        conditions.push('e.created_at <= ?');
-        params.push(opts.to);
-    }
-    let joinClause = '';
-    if (opts.tag) {
-        joinClause = `INNER JOIN ${TABLE_TAGS} t ON t.entry_uuid = e.uuid AND t.tag = ?`;
-        params.unshift(opts.tag);
-    }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-    const countParams = opts.tag ? [opts.tag, ...params.slice(1)] : [...params];
-    return { joinClause, whereClause, params, countParams };
-};
-const loadTagsByUuid = async (db, uuids) => {
-    const tagsByUuid = new Map();
-    if (uuids.length === 0)
-        return tagsByUuid;
-    const tagRows = (await db.query(`SELECT entry_uuid, tag FROM ${TABLE_TAGS} WHERE entry_uuid IN (${uuids.map(() => '?').join(',')})`, uuids));
-    for (const tagRow of tagRows) {
-        const tags = tagsByUuid.get(tagRow.entry_uuid) ?? [];
-        tags.push(tagRow.tag);
-        tagsByUuid.set(tagRow.entry_uuid, tags);
-    }
-    return tagsByUuid;
-};
-// The storage facade intentionally groups related DB operations in one factory.
-// eslint-disable-next-line max-lines-per-function
-const createStorage = (db) => {
-    const writeEntry = async (entry) => {
-        const uuid = entry.uuid || generateUuid();
-        await db.execute(`INSERT INTO ${TABLE_ENTRIES} (uuid, batch_id, family_hash, type, content, is_latest, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`, [
-            uuid,
-            entry.batchId,
-            entry.familyHash ?? null,
-            entry.type,
-            JSON.stringify(entry.content),
-            entry.isLatest ? 1 : 0,
-            entry.createdAt,
-        ]);
-        await insertTags(db, uuid, entry.tags);
-    };
-    const updateEntry = async (uuid, patch) => {
-        const sets = [];
-        const params = [];
-        if (patch.content !== undefined) {
-            sets.push('content = ?');
-            params.push(JSON.stringify(patch.content));
-        }
-        if (patch.isLatest !== undefined) {
-            sets.push('is_latest = ?');
-            params.push(patch.isLatest ? 1 : 0);
-        }
-        if (sets.length === 0)
-            return;
-        params.push(uuid);
-        await db.execute(`UPDATE ${TABLE_ENTRIES} SET ${sets.join(', ')} WHERE uuid = ?`, params);
-    };
-    const markFamilyStale = async (hash, exceptUuid) => {
-        await db.execute(`UPDATE ${TABLE_ENTRIES} SET is_latest = 0
-       WHERE family_hash = ? AND uuid != ? AND is_latest = 1`, [hash, exceptUuid]);
-    };
-    const queryEntries = async (opts) => {
-        const page = opts.page ?? 1;
-        const perPage = opts.perPage ?? 50;
-        const offset = (page - 1) * perPage;
-        const { joinClause, whereClause, params, countParams } = buildEntryFilters(opts);
-        const countResult = (await db.queryOne(`SELECT COUNT(*) as cnt FROM ${TABLE_ENTRIES} e ${joinClause} ${whereClause}`, countParams));
-        const total = countResult?.cnt ?? 0;
-        const rows = (await db.query(`SELECT e.id, e.uuid, e.batch_id, e.family_hash, e.type, e.content, e.is_latest, e.created_at
-       FROM ${TABLE_ENTRIES} e ${joinClause} ${whereClause}
-       ORDER BY e.created_at DESC, e.id DESC
-       LIMIT ? OFFSET ?`, [...params, perPage, offset]));
-        const tagsByUuid = await loadTagsByUuid(db, rows.map((row) => row.uuid));
-        return {
-            data: rows.map((row) => rowToEntry(row, tagsByUuid.get(row.uuid) ?? [])),
-            total,
-        };
-    };
-    const getEntry = async (uuid) => {
-        const row = (await db.queryOne(`SELECT id, uuid, batch_id, family_hash, type, content, is_latest, created_at
-       FROM ${TABLE_ENTRIES}
-       WHERE uuid = ?`, [uuid]));
-        if (!row)
-            return null;
-        const tags = (await db.query(`SELECT tag FROM ${TABLE_TAGS} WHERE entry_uuid = ?`, [
-            uuid,
-        ]));
-        return rowToEntry(row, tags.map((tag) => tag.tag));
-    };
-    const getBatch = async (batchId) => {
-        const rows = (await db.query(`SELECT id, uuid, batch_id, family_hash, type, content, is_latest, created_at
-       FROM ${TABLE_ENTRIES}
-       WHERE batch_id = ?
-       ORDER BY created_at ASC, id ASC`, [batchId]));
-        if (rows.length === 0)
-            return [];
-        const tagsByUuid = await loadTagsByUuid(db, rows.map((row) => row.uuid));
-        return rows.map((row) => rowToEntry(row, tagsByUuid.get(row.uuid) ?? []));
-    };
-    const prune = async (olderThanMs, keepExceptions = false) => {
-        const countResult = (await db.queryOne(`SELECT COUNT(*) as cnt FROM ${TABLE_ENTRIES}
-       WHERE created_at < ?
-       ${keepExceptions ? "AND type != 'exception'" : ''}`, [olderThanMs]));
-        const deleted = countResult?.cnt ?? 0;
-        if (deleted === 0)
-            return 0;
-        await db.execute(`DELETE FROM ${TABLE_ENTRIES}
-       WHERE created_at < ?
-       ${keepExceptions ? "AND type != 'exception'" : ''}`, [olderThanMs]);
-        return deleted;
-    };
-    const clear = async () => {
-        await db.execute(`DELETE FROM ${TABLE_ENTRIES}`, []);
-    };
-    const getMonitoring = async () => {
-        const rows = (await db.query(`SELECT tag FROM ${TABLE_MONITORING}`, []));
-        return rows.map((row) => row.tag);
-    };
-    const addMonitoring = async (tag) => {
-        await db.execute(`INSERT OR IGNORE INTO ${TABLE_MONITORING} (tag) VALUES (?)`, [tag]);
-    };
-    const removeMonitoring = async (tag) => {
-        await db.execute(`DELETE FROM ${TABLE_MONITORING} WHERE tag = ?`, [tag]);
-    };
-    const stats = async () => {
-        const rows = (await db.query(`SELECT type, COUNT(*) as cnt FROM ${TABLE_ENTRIES} GROUP BY type`, []));
-        const output = {};
-        for (const row of rows) {
-            output[row.type] = row.cnt;
-        }
-        return output;
-    };
-    return {
-        writeEntry,
-        updateEntry,
-        markFamilyStale,
-        queryEntries,
-        getEntry,
-        getBatch,
-        prune,
-        clear,
-        getMonitoring,
-        addMonitoring,
-        removeMonitoring,
-        stats,
-    };
-};
-const resolveStorage = (db) => {
-    return createStorage(db);
-};
-const reset = () => {
-    return;
-};
-export const TraceStorage = Object.freeze({ resolveStorage, reset, familyHash });