@zintrust/trace 0.4.75

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @zintrust/trace — public API surface.
+ *
+ * Zero side-effects. Import watchers, storage, dashboard, and config
+ * individually. For full auto-initialisation, use:
+ *   import '@zintrust/trace/register';
+ */
+export { TraceConfig } from './config';
+export { TraceStorage } from './storage';
+export type { ITraceStorage } from './storage';
+export { TraceContext } from './context';
+export { registerTraceDashboard, registerTraceRoutes } from './dashboard/routes';
+export type { TraceDashboardOptions, TraceDashboardRegistrationOptions } from './dashboard/routes';
+export { AuthWatcher } from './watchers/AuthWatcher';
+export { BatchWatcher } from './watchers/BatchWatcher';
+export { CacheWatcher } from './watchers/CacheWatcher';
+export { CommandWatcher } from './watchers/CommandWatcher';
+export { DumpWatcher } from './watchers/DumpWatcher';
+export { EventWatcher } from './watchers/EventWatcher';
+export { ExceptionWatcher } from './watchers/ExceptionWatcher';
+export { GateWatcher } from './watchers/GateWatcher';
+export { HttpClientWatcher } from './watchers/HttpClientWatcher';
+export { HttpWatcher } from './watchers/HttpWatcher';
+export { JobWatcher } from './watchers/JobWatcher';
+export { LogWatcher } from './watchers/LogWatcher';
+export { MailWatcher } from './watchers/MailWatcher';
+export { MiddlewareWatcher } from './watchers/MiddlewareWatcher';
+export { ModelWatcher } from './watchers/ModelWatcher';
+export { NotificationWatcher } from './watchers/NotificationWatcher';
+export { QueryWatcher } from './watchers/QueryWatcher';
+export { RedisWatcher } from './watchers/RedisWatcher';
+export { ScheduleWatcher } from './watchers/ScheduleWatcher';
+export { ViewWatcher } from './watchers/ViewWatcher';
+export { EntryType } from './types';
+export type { AuthContent, BatchContent, CacheContent, ClientRequestContent, CommandContent, DumpContent, EntryTypeValue, EventContent, ExceptionContent, GateContent, ITraceConfig, ITraceEntry, ITraceWatcher, ITraceWatcherConfig, JobContent, LogContent, MailContent, MiddlewareContent, ModelContent, NotificationContent, QueryContent, RedactionConfig, RedisContent, RequestContent, ScheduleContent, TraceConfigOverrides, ViewContent, WatcherToggles, } from './types';

package/dist/index.js

@@ -0,0 +1,50 @@
+/**
+ * @zintrust/trace — public API surface.
+ *
+ * Zero side-effects. Import watchers, storage, dashboard, and config
+ * individually. For full auto-initialisation, use:
+ *   import '@zintrust/trace/register';
+ */
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+export { TraceConfig } from './config';
+// ---------------------------------------------------------------------------
+// Storage
+// ---------------------------------------------------------------------------
+export { TraceStorage } from './storage';
+// ---------------------------------------------------------------------------
+// Context
+// ---------------------------------------------------------------------------
+export { TraceContext } from './context';
+// ---------------------------------------------------------------------------
+// Dashboard
+// ---------------------------------------------------------------------------
+export { registerTraceDashboard, registerTraceRoutes } from './dashboard/routes';
+// ---------------------------------------------------------------------------
+// Watchers (named re-exports for use with custom wiring)
+// ---------------------------------------------------------------------------
+export { AuthWatcher } from './watchers/AuthWatcher';
+export { BatchWatcher } from './watchers/BatchWatcher';
+export { CacheWatcher } from './watchers/CacheWatcher';
+export { CommandWatcher } from './watchers/CommandWatcher';
+export { DumpWatcher } from './watchers/DumpWatcher';
+export { EventWatcher } from './watchers/EventWatcher';
+export { ExceptionWatcher } from './watchers/ExceptionWatcher';
+export { GateWatcher } from './watchers/GateWatcher';
+export { HttpClientWatcher } from './watchers/HttpClientWatcher';
+export { HttpWatcher } from './watchers/HttpWatcher';
+export { JobWatcher } from './watchers/JobWatcher';
+export { LogWatcher } from './watchers/LogWatcher';
+export { MailWatcher } from './watchers/MailWatcher';
+export { MiddlewareWatcher } from './watchers/MiddlewareWatcher';
+export { ModelWatcher } from './watchers/ModelWatcher';
+export { NotificationWatcher } from './watchers/NotificationWatcher';
+export { QueryWatcher } from './watchers/QueryWatcher';
+export { RedisWatcher } from './watchers/RedisWatcher';
+export { ScheduleWatcher } from './watchers/ScheduleWatcher';
+export { ViewWatcher } from './watchers/ViewWatcher';
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+export { EntryType } from './types';

package/dist/migrations/20260331000001_create_zin_debugger_entries_table.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Migration: CreateZinDebuggerEntriesTable
+ * Creates the main entries table for @zintrust/system-debugger
+ */
+import { type IDatabase } from '@zintrust/core';
+export interface Migration {
+    up(db: IDatabase): Promise<void>;
+    down(db: IDatabase): Promise<void>;
+}
+export declare const migration: Migration;

package/dist/migrations/20260331000001_create_zin_debugger_entries_table.js

@@ -0,0 +1,28 @@
+/**
+ * Migration: CreateZinDebuggerEntriesTable
+ * Creates the main entries table for @zintrust/system-debugger
+ */
+import { MigrationSchema } from '@zintrust/core';
+export const migration = {
+    async up(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.create('zin_debugger_entries', (table) => {
+            table.id();
+            table.uuid('uuid').unique();
+            table.string('batch_id');
+            table.string('family_hash').nullable();
+            table.string('type');
+            table.text('content');
+            table.boolean('is_latest').default(true);
+            table.integer('created_at');
+            table.index('batch_id');
+            table.index('family_hash');
+            table.index('created_at');
+            table.index(['type', 'is_latest']);
+        });
+    },
+    async down(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.dropIfExists('zin_debugger_entries');
+    },
+};

package/dist/migrations/20260331000002_create_zin_debugger_entries_tags_table.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Migration: CreateZinDebuggerEntriesTagsTable
+ * Creates the tag join table for @zintrust/system-debugger
+ */
+import { type IDatabase } from '@zintrust/core';
+export interface Migration {
+    up(db: IDatabase): Promise<void>;
+    down(db: IDatabase): Promise<void>;
+}
+export declare const migration: Migration;

package/dist/migrations/20260331000002_create_zin_debugger_entries_tags_table.js

@@ -0,0 +1,21 @@
+/**
+ * Migration: CreateZinDebuggerEntriesTagsTable
+ * Creates the tag join table for @zintrust/system-debugger
+ */
+import { MigrationSchema } from '@zintrust/core';
+export const migration = {
+    async up(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.create('zin_debugger_entries_tags', (table) => {
+            table.string('entry_uuid');
+            table.string('tag');
+            table.unique(['entry_uuid', 'tag']);
+            table.index('tag');
+            table.foreign('entry_uuid').references('uuid').on('zin_debugger_entries').onDelete('CASCADE');
+        });
+    },
+    async down(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.dropIfExists('zin_debugger_entries_tags');
+    },
+};

package/dist/migrations/20260331000003_create_zin_debugger_monitoring_table.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Migration: CreateZinDebuggerMonitoringTable
+ * Creates the tag watchlist table for @zintrust/system-debugger
+ */
+import { type IDatabase } from '@zintrust/core';
+export interface Migration {
+    up(db: IDatabase): Promise<void>;
+    down(db: IDatabase): Promise<void>;
+}
+export declare const migration: Migration;

package/dist/migrations/20260331000003_create_zin_debugger_monitoring_table.js

@@ -0,0 +1,17 @@
+/**
+ * Migration: CreateZinDebuggerMonitoringTable
+ * Creates the tag watchlist table for @zintrust/system-debugger
+ */
+import { MigrationSchema } from '@zintrust/core';
+export const migration = {
+    async up(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.create('zin_debugger_monitoring', (table) => {
+            table.string('tag').primary();
+        });
+    },
+    async down(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.dropIfExists('zin_debugger_monitoring');
+    },
+};

package/dist/migrations/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Migrations index for @zintrust/system-debugger
+ * Export all migrations as an ordered array.
+ */
+export type { Migration } from './20260331000001_create_zin_debugger_entries_table';
+export declare const migrations: import("./20260331000001_create_zin_debugger_entries_table").Migration[];

package/dist/migrations/index.js

@@ -0,0 +1,4 @@
+import { migration as createEntries } from './20260331000001_create_zin_debugger_entries_table.js';
+import { migration as createEntriesTags } from './20260331000002_create_zin_debugger_entries_tags_table.js';
+import { migration as createMonitoring } from './20260331000003_create_zin_debugger_monitoring_table.js';
+export const migrations = [createEntries, createEntriesTags, createMonitoring];

package/dist/plugin.d.ts

@@ -0,0 +1 @@
+export type {};

package/dist/plugin.js

@@ -0,0 +1,3 @@
+const globalTracePluginState = globalThis;
+globalTracePluginState.__zintrust_system_trace_plugin_requested__ = true;
+export {};

package/dist/register.d.ts

@@ -0,0 +1 @@
+export type {};

package/dist/register.js

@@ -0,0 +1,140 @@
+/**
+ * @zintrust/trace register side-effect module.
+ *
+ * For plugin-file activation, prefer:
+ *   import '@zintrust/trace/plugin';
+ *
+ * The framework boot layer will lazy-load this register module once the app
+ * runtime is ready. Importing this file directly is still supported for
+ * advanced manual bootstrap flows that intentionally activate the trace
+ * after databases and the kernel are available.
+ *
+ * Config is read from environment variables (TRACE_* keys) matching
+ * the defaults in TraceConfig. For custom overrides supply them via
+ * calling `initTrace(overrides)` instead.
+ *
+ * Routes are NOT auto-mounted here. Wire the dashboard into your router:
+ *   import { registerTraceDashboard } from '@zintrust/trace/ui';
+ *   registerTraceDashboard(router, {
+ *     middleware: ['admin'],
+ *   });
+ */
+import { TraceConfig } from './config';
+import { TraceContext } from './context';
+import { TraceStorage } from './storage';
+const globalTraceRegisterState = globalThis;
+globalTraceRegisterState.__zintrust_system_trace_plugin_requested__ = true;
+const traceAlreadyInitialized = globalTraceRegisterState.__zintrust_system_trace_register_initialized__ === true;
+if (!traceAlreadyInitialized) {
+    globalTraceRegisterState.__zintrust_system_trace_register_initialized__ = true;
+}
+const importCore = async () => {
+    try {
+        return await import('@zintrust/core');
+    }
+    catch {
+        return {};
+    }
+};
+const resolveRegisterMiddleware = () => {
+    const globalMiddlewareRegistrarState = globalThis;
+    return (middleware) => {
+        const registerMiddleware = globalMiddlewareRegistrarState.__zintrust_register_global_middleware__;
+        if (typeof registerMiddleware === 'function') {
+            registerMiddleware(middleware);
+            return;
+        }
+        globalMiddlewareRegistrarState.__zintrust_pending_global_middlewares__ ??= [];
+        globalMiddlewareRegistrarState.__zintrust_pending_global_middlewares__.push(middleware);
+    };
+};
+const resolveTraceConnectionName = (env, configuredConnection) => {
+    const resolveDefaultConnection = () => {
+        const defaultConnection = env?.get('DB_CONNECTION', '').trim() ?? '';
+        if (defaultConnection === '' || defaultConnection === 'default')
+            return 'default';
+        return defaultConnection;
+    };
+    const explicitConnection = configuredConnection?.trim();
+    if (explicitConnection !== undefined && explicitConnection !== '') {
+        return explicitConnection === 'default' ? resolveDefaultConnection() : explicitConnection;
+    }
+    return resolveDefaultConnection();
+};
+const core = (await importCore());
+const Env = core.Env;
+if (!traceAlreadyInitialized && Env) {
+    const enabled = Env.getBool('TRACE_ENABLED', false);
+    if (enabled) {
+        const connection = Env.get('TRACE_DB_CONNECTION', '') || undefined;
+        const pruneAfterHours = Env.getInt('TRACE_PRUNE_HOURS', 24);
+        const slowQueryThreshold = Env.getInt('TRACE_SLOW_QUERY_MS', 100);
+        const logMinLevel = Env.get('TRACE_LOG_LEVEL', 'info');
+        const config = TraceConfig.merge({
+            enabled,
+            connection,
+            pruneAfterHours,
+            slowQueryThreshold,
+            logMinLevel,
+        });
+        const db = core.useDatabase?.(undefined, resolveTraceConnectionName(Env, connection));
+        if (db) {
+            const storage = TraceStorage.resolveStorage(db);
+            if (core.RequestContext) {
+                TraceContext.setRequestContextImpl(core.RequestContext);
+            }
+            const [{ HttpWatcher }, { QueryWatcher }, { LogWatcher }, { ExceptionWatcher }, { JobWatcher }, { CacheWatcher }, { ScheduleWatcher }, { MailWatcher }, { AuthWatcher }, { EventWatcher }, { ModelWatcher }, { NotificationWatcher }, { RedisWatcher }, { GateWatcher }, { MiddlewareWatcher }, { CommandWatcher }, { BatchWatcher }, { DumpWatcher }, { ViewWatcher }, { HttpClientWatcher },] = await Promise.all([
+                import('./watchers/HttpWatcher'),
+                import('./watchers/QueryWatcher'),
+                import('./watchers/LogWatcher'),
+                import('./watchers/ExceptionWatcher'),
+                import('./watchers/JobWatcher'),
+                import('./watchers/CacheWatcher'),
+                import('./watchers/ScheduleWatcher'),
+                import('./watchers/MailWatcher'),
+                import('./watchers/AuthWatcher'),
+                import('./watchers/EventWatcher'),
+                import('./watchers/ModelWatcher'),
+                import('./watchers/NotificationWatcher'),
+                import('./watchers/RedisWatcher'),
+                import('./watchers/GateWatcher'),
+                import('./watchers/MiddlewareWatcher'),
+                import('./watchers/CommandWatcher'),
+                import('./watchers/BatchWatcher'),
+                import('./watchers/DumpWatcher'),
+                import('./watchers/ViewWatcher'),
+                import('./watchers/HttpClientWatcher'),
+            ]);
+            const watcherArgs = { storage, config, db };
+            HttpWatcher.register({ ...watcherArgs, registerMiddleware: resolveRegisterMiddleware() });
+            QueryWatcher.register(watcherArgs);
+            LogWatcher.register(watcherArgs);
+            ExceptionWatcher.register(watcherArgs);
+            JobWatcher.register(watcherArgs);
+            CacheWatcher.register(watcherArgs);
+            ScheduleWatcher.register(watcherArgs);
+            MailWatcher.register(watcherArgs);
+            AuthWatcher.register(watcherArgs);
+            EventWatcher.register(watcherArgs);
+            ModelWatcher.register(watcherArgs);
+            NotificationWatcher.register(watcherArgs);
+            RedisWatcher.register(watcherArgs);
+            GateWatcher.register(watcherArgs);
+            MiddlewareWatcher.register(watcherArgs);
+            CommandWatcher.register(watcherArgs);
+            BatchWatcher.register(watcherArgs);
+            DumpWatcher.register(watcherArgs);
+            ViewWatcher.register(watcherArgs);
+            HttpClientWatcher.register(watcherArgs);
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.warn('[trace] Could not resolve database connection - skipping init.');
+        }
+    }
+}
+else if (!traceAlreadyInitialized) {
+    // Running outside a ZinTrust project - skip init silently.
+    // eslint-disable-next-line no-console
+    console.warn('[trace] @zintrust/core not found - trace will not be activated.');
+}

package/dist/storage/DebuggerStorage.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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

@@ -0,0 +1,195 @@
+import { familyHash } from '../utils/familyHash';
+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 });

package/dist/storage/TraceStorage.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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';