@zintrust/core 0.4.75 → 0.4.77

package/src/cli/commands/{DebuggerCommands.js → TraceCommands.js}

@@ -14,22 +14,42 @@ import { createRequire } from '../../node-singletons/module.js';
 import * as path from '../../node-singletons/path.js';
 import { Database } from '../../orm/Database.js';
 import { DatabaseAdapterRegistry } from '../../orm/DatabaseAdapterRegistry.js';
-const loadDebuggerModule = async () => {
+const loadTraceModule = async () => {
     try {
-        return (await import('@zintrust/system-debugger'));
+        return (await import('@zintrust/trace'));
     }
     catch (error) {
-        Logger.error('Failed to load optional package "@zintrust/system-debugger"', error);
-        throw ErrorFactory.createCliError('Package "@zintrust/system-debugger" is not installed. Add it to your project first.');
+        Logger.error('Failed to load optional package "@zintrust/trace"', error);
+        throw ErrorFactory.createCliError('Package "@zintrust/trace" is not installed. Add it to your project first.');
     }
 };
-const addPruneOptions = (command) => {
+const addD1DatabaseOptions = (command) => {
     command
-        .option('--hours <number>', 'Remove entries older than N hours (default: from config)', '')
         .option('--local', 'D1 only: run against local D1 database')
         .option('--remote', 'D1 only: run against remote D1 database')
-        .option('--database <name>', 'D1 only: Wrangler D1 database binding name')
+        .option('--database <name>', 'D1 only: Wrangler D1 database binding name');
+};
+const createTraceCommand = (config) => {
+    const command = BaseCommand.create({
+        name: config.name,
+        description: config.description,
+        addOptions: config.addOptions,
+        execute: async (options) => config.execute(options, command),
+    });
+    return command;
+};
+const resolveNamedTraceConnection = (name) => {
+    const connections = databaseConfig.connections;
+    return {
+        name,
+        config: connections[name] ?? databaseConfig.getConnection(),
+    };
+};
+const addPruneOptions = (command) => {
+    command
+        .option('--hours <number>', 'Remove entries older than N hours (default: from config)', '')
         .option('--keep-exceptions', 'Keep exception entries regardless of age', false);
+    addD1DatabaseOptions(command);
 };
 const addMigrateOptions = (command) => {
     command
@@ -40,16 +60,14 @@ const addMigrateOptions = (command) => {
         .option('--step <number>', 'Number of batches to rollback (use with --rollback)', '1')
         .option('--force', 'Skip production confirmation (allow unsafe operations in production)')
         .option('--all', 'Run migrations for all configured database connections')
-        .option('--connection <name>', 'Use a specific database connection for debugger migrations')
-        .option('--local', 'D1 only: run against local D1 database')
-        .option('--remote', 'D1 only: run against remote D1 database')
-        .option('--database <name>', 'D1 only: Wrangler D1 database binding name')
+        .option('--connection <name>', 'Use a specific database connection for trace migrations')
         .option('--no-interactive', 'Disable interactive prompts (useful for CI/CD)');
+    addD1DatabaseOptions(command);
 };
 const resolveDashboardBasePath = () => {
-    const raw = readEnvString('DEBUGGER_BASE_PATH').trim();
+    const raw = readEnvString('TRACE_BASE_PATH').trim();
     if (raw === '')
-        return '/debugger';
+        return '/trace';
     return raw.startsWith('/') ? raw : `/${raw}`;
 };
 const resolveDashboardUrl = () => {
@@ -57,7 +75,7 @@ const resolveDashboardUrl = () => {
     const port = readEnvString('PORT').trim() || readEnvString('APP_PORT').trim() || '7777';
     return `http://${host}:${port}${resolveDashboardBasePath()}`;
 };
-const resolveDebuggerMigrationTargetFromResolvedPath = (resolvedPath) => {
+const resolveTraceMigrationTargetFromResolvedPath = (resolvedPath) => {
     const extension = path.extname(resolvedPath).toLowerCase();
     const dir = path.dirname(resolvedPath);
     if (extension === '.js' || extension === '.mjs' || extension === '.cjs') {
@@ -77,25 +95,25 @@ const resolveDebuggerMigrationTargetFromResolvedPath = (resolvedPath) => {
                 extension: candidateExt.slice(1),
             };
         }
-        throw ErrorFactory.createCliError('Installed package "@zintrust/system-debugger" exposes TypeScript-only migrations. Upgrade to a version that publishes runnable JavaScript migrations.');
+        throw ErrorFactory.createCliError('Installed package "@zintrust/trace" exposes TypeScript-only migrations. Upgrade to a version that publishes runnable JavaScript migrations.');
     }
     return {
         dir,
         extension: databaseConfig.migrations.extension,
     };
 };
-const resolveDebuggerMigrationTarget = () => {
+const resolveTraceMigrationTarget = () => {
     const requireFromProject = createRequire(path.join(process.cwd(), 'package.json'));
     try {
-        const resolved = requireFromProject.resolve('@zintrust/system-debugger/migrations');
-        return resolveDebuggerMigrationTargetFromResolvedPath(resolved);
+        const resolved = requireFromProject.resolve('@zintrust/trace/migrations');
+        return resolveTraceMigrationTargetFromResolvedPath(resolved);
     }
     catch (error) {
         if (error instanceof Error && error.message.includes('TypeScript-only migrations')) {
             throw error;
         }
         return {
-            dir: path.join(process.cwd(), 'packages', 'system-debugger', 'migrations'),
+            dir: path.join(process.cwd(), 'packages', 'trace', 'migrations'),
             extension: 'ts',
         };
     }
@@ -127,17 +145,17 @@ const normalizeConnectionName = (value) => {
     }
     return normalized;
 };
-const resolveDebuggerConnectionName = (options) => {
+const resolveTraceConnectionName = (options) => {
     if (isNonEmptyString(options['connection'])) {
         return normalizeConnectionName(String(options['connection']));
     }
-    return normalizeConnectionName(readEnvString('DEBUGGER_DB_CONNECTION').trim());
+    return normalizeConnectionName(readEnvString('TRACE_DB_CONNECTION').trim());
 };
-const withConfiguredDebuggerConnection = (options, configuredConnection) => {
+const withConfiguredTraceConnection = (options, configuredConnection) => {
     if (isNonEmptyString(options['connection'])) {
         return {
             ...options,
-            connection: resolveDebuggerConnectionName(options),
+            connection: resolveTraceConnectionName(options),
         };
     }
     if (isNonEmptyString(configuredConnection)) {
@@ -148,11 +166,11 @@ const withConfiguredDebuggerConnection = (options, configuredConnection) => {
     }
     return {
         ...options,
-        connection: resolveDebuggerConnectionName(options),
+        connection: resolveTraceConnectionName(options),
     };
 };
-const resolveDebuggerConnectionConfig = (options) => {
-    const selected = resolveDebuggerConnectionName(options);
+const resolveTraceConnectionConfig = (options) => {
+    const selected = resolveTraceConnectionName(options);
     const connections = databaseConfig.connections;
     return connections[selected] ?? databaseConfig.getConnection();
 };
@@ -229,13 +247,13 @@ const buildStatsFromTableRows = (rows) => {
     }
     return stats;
 };
-const withSqlDebuggerStorage = async (options, callback) => {
-    const { DebuggerStorage } = await loadDebuggerModule();
-    const conn = resolveDebuggerConnectionConfig(options);
+const withSqlTraceStorage = async (options, callback) => {
+    const { TraceStorage } = await loadTraceModule();
+    const conn = resolveTraceConnectionConfig(options);
     const db = Database.create(mapConnectionToOrmConfig(conn));
     await db.connect();
     try {
-        const storage = DebuggerStorage.resolveStorage(db);
+        const storage = TraceStorage.resolveStorage(db);
         return await callback(storage);
     }
     finally {
@@ -246,7 +264,7 @@ const executeD1Stats = (options) => {
     const output = WranglerD1.executeSql({
         dbName: getD1DatabaseName(options),
         isLocal: resolveD1ExecutionMode(options),
-        sql: 'SELECT type, COUNT(*) as cnt FROM zin_debugger_entries GROUP BY type ORDER BY type',
+        sql: 'SELECT type, COUNT(*) as cnt FROM zin_trace_entries GROUP BY type ORDER BY type',
     });
     const payload = extractWranglerJson(output);
     if (payload !== null) {
@@ -277,49 +295,49 @@ const isBuiltInDriver = (driver) => driver === 'sqlite' ||
     driver === 'd1-remote';
 const isDestructiveAction = (options) => options['fresh'] === true || options['reset'] === true || options['rollback'] === true;
 const executePrune = async (options) => {
-    const { DebuggerConfig } = await loadDebuggerModule();
-    const config = DebuggerConfig.merge();
-    const resolvedOptions = withConfiguredDebuggerConnection(options, config.connection);
+    const { TraceConfig } = await loadTraceModule();
+    const config = TraceConfig.merge();
+    const resolvedOptions = withConfiguredTraceConnection(options, config.connection);
     const hours = typeof options['hours'] === 'string' && options['hours'] !== ''
         ? Number.parseInt(options['hours'], 10)
         : config.pruneAfterHours;
     const olderThanMs = hours * 60 * 60 * 1000;
     const keepExceptions = options['keepExceptions'] === true;
-    const conn = resolveDebuggerConnectionConfig(resolvedOptions);
+    const conn = resolveTraceConnectionConfig(resolvedOptions);
     const threshold = Date.now() - olderThanMs;
     const pruneSql = keepExceptions
-        ? `DELETE FROM zin_debugger_entries WHERE created_at < ${String(threshold)} AND type != 'exception'`
-        : `DELETE FROM zin_debugger_entries WHERE created_at < ${String(threshold)}`;
-    Logger.info(`Pruning debugger entries older than ${hours}h...`);
+        ? `DELETE FROM zin_trace_entries WHERE created_at < ${String(threshold)} AND type != 'exception'`
+        : `DELETE FROM zin_trace_entries WHERE created_at < ${String(threshold)}`;
+    Logger.info(`Pruning trace entries older than ${hours}h...`);
     const deleted = isD1ConnectionDriver(conn.driver)
         ? executeD1Delete(options, pruneSql)
-        : await withSqlDebuggerStorage(resolvedOptions, async (storage) => storage.prune(olderThanMs, keepExceptions));
+        : await withSqlTraceStorage(resolvedOptions, async (storage) => storage.prune(olderThanMs, keepExceptions));
     Logger.info(`Done - removed ${deleted} entries.`);
 };
 const executeClear = async (options) => {
-    const { DebuggerConfig } = await loadDebuggerModule();
-    const config = DebuggerConfig.merge();
-    const resolvedOptions = withConfiguredDebuggerConnection(options, config.connection);
-    const conn = resolveDebuggerConnectionConfig(resolvedOptions);
-    Logger.info('Clearing all debugger entries...');
+    const { TraceConfig } = await loadTraceModule();
+    const config = TraceConfig.merge();
+    const resolvedOptions = withConfiguredTraceConnection(options, config.connection);
+    const conn = resolveTraceConnectionConfig(resolvedOptions);
+    Logger.info('Clearing all trace entries...');
     if (isD1ConnectionDriver(conn.driver)) {
-        executeD1Delete(options, 'DELETE FROM zin_debugger_entries');
+        executeD1Delete(options, 'DELETE FROM zin_trace_entries');
     }
     else {
-        await withSqlDebuggerStorage(resolvedOptions, async (storage) => storage.clear());
+        await withSqlTraceStorage(resolvedOptions, async (storage) => storage.clear());
     }
     Logger.info('Done - all entries cleared.');
 };
 const executeStatus = async (options, cmd) => {
-    const { DebuggerConfig } = await loadDebuggerModule();
-    const config = DebuggerConfig.merge();
-    const resolvedOptions = withConfiguredDebuggerConnection(options, config.connection);
-    const connection = resolveDebuggerConnectionName(resolvedOptions);
-    const conn = resolveDebuggerConnectionConfig(resolvedOptions);
+    const { TraceConfig } = await loadTraceModule();
+    const config = TraceConfig.merge();
+    const resolvedOptions = withConfiguredTraceConnection(options, config.connection);
+    const connection = resolveTraceConnectionName(resolvedOptions);
+    const conn = resolveTraceConnectionConfig(resolvedOptions);
     const stats = isD1ConnectionDriver(conn.driver)
         ? executeD1Stats(options)
-        : await withSqlDebuggerStorage(resolvedOptions, async (storage) => storage.stats());
-    cmd.info(`Debugger enabled via env: ${readEnvString('DEBUGGER_ENABLED').trim() || 'false'}`);
+        : await withSqlTraceStorage(resolvedOptions, async (storage) => storage.stats());
+    cmd.info(`Trace enabled via env: ${readEnvString('TRACE_ENABLED').trim() || 'false'}`);
     cmd.info(`Connection: ${connection}`);
     cmd.info(`Prune after hours: ${String(config.pruneAfterHours)}`);
     cmd.info(`Expected dashboard URL (if mounted): ${resolveDashboardUrl()}`);
@@ -335,7 +353,7 @@ const executeStatus = async (options, cmd) => {
 const printMigrationStatus = async (migrator, cmd) => {
     const rows = await migrator.status();
     if (rows.length === 0) {
-        cmd.info('No debugger migrations found.');
+        cmd.info('No trace migrations found.');
         return;
     }
     for (const row of rows) {
@@ -344,13 +362,13 @@ const printMigrationStatus = async (migrator, cmd) => {
         cmd.info(`${tag}: ${row.name}${extra}`);
     }
 };
-const applyDebuggerMigrations = async (migrator, cmd) => {
+const applyTraceMigrations = async (migrator, cmd) => {
     const result = await migrator.migrate();
     if (result.appliedNames.length === 0) {
-        cmd.info('No pending debugger migrations.');
+        cmd.info('No pending trace migrations.');
         return;
     }
-    cmd.success('Debugger migrations applied.');
+    cmd.success('Trace migrations applied.');
     for (const name of result.appliedNames) {
         cmd.info(`\u2713 ${name}`);
     }
@@ -363,21 +381,21 @@ const runMigrationActions = async (migrator, options, cmd, driver) => {
     }
     if (options['fresh'] === true) {
         await migrator.fresh();
-        cmd.success('Debugger migrations applied (fresh).');
+        cmd.success('Trace migrations applied (fresh).');
         return;
     }
     if (options['reset'] === true) {
         await migrator.resetAll();
-        cmd.success('Debugger migrations reset.');
+        cmd.success('Trace migrations reset.');
         return;
     }
     if (options['rollback'] === true) {
         const steps = parseRollbackSteps(options);
         const result = await migrator.rollbackLastBatch(steps);
-        cmd.success(`Debugger migrations rolled back (${result.rolledBack}).`);
+        cmd.success(`Trace migrations rolled back (${result.rolledBack}).`);
         return;
     }
-    await applyDebuggerMigrations(migrator, cmd);
+    await applyTraceMigrations(migrator, cmd);
 };
 const runMigrationsForConnection = async (conn, options, cmd, interactive) => {
     const destructive = isDestructiveAction(options);
@@ -386,7 +404,7 @@ const runMigrationsForConnection = async (conn, options, cmd, interactive) => {
         interactive,
         destructive,
         force: options['force'] === true,
-        message: 'NODE_ENV=production. Continue running debugger migrations?',
+        message: 'NODE_ENV=production. Continue running trace migrations?',
     });
     if (!proceed)
         return;
@@ -400,9 +418,9 @@ const runMigrationsForConnection = async (conn, options, cmd, interactive) => {
             options['fresh'] === true ||
             options['reset'] === true ||
             options['rollback'] === true) {
-            throw ErrorFactory.createCliError('D1-backed debugger migrations currently support apply only. Run `zin migrate:debugger --local|--remote` without status or rollback flags.');
+            throw ErrorFactory.createCliError('D1-backed trace migrations currently support apply only. Run `zin migrate:trace --local|--remote` without status or rollback flags.');
         }
-        const migrationTarget = resolveDebuggerMigrationTarget();
+        const migrationTarget = resolveTraceMigrationTarget();
         const projectRoot = process.cwd();
         const dbName = getD1DatabaseName(options);
         const isLocal = options['local'] === true || options['remote'] !== true;
@@ -418,14 +436,14 @@ const runMigrationsForConnection = async (conn, options, cmd, interactive) => {
         if (output !== '') {
             cmd.info(output);
         }
-        cmd.success('Debugger D1 migrations applied.');
+        cmd.success('Trace D1 migrations applied.');
         return;
     }
     const ormConfig = mapConnectionToOrmConfig(conn);
     const db = Database.create(ormConfig);
     await db.connect();
     try {
-        const migrationTarget = resolveDebuggerMigrationTarget();
+        const migrationTarget = resolveTraceMigrationTarget();
         const migrator = Migrator.create({
             db,
             projectRoot: process.cwd(),
@@ -447,7 +465,7 @@ const runMigrationsForConnection = async (conn, options, cmd, interactive) => {
         await db.disconnect();
     }
 };
-const executeMigrateDebugger = async (options, cmd) => {
+const executeMigrateTrace = async (options, cmd) => {
     const interactive = getInteractive(options);
     const targets = [];
     if (options['all'] === true) {
@@ -456,20 +474,10 @@ const executeMigrateDebugger = async (options, cmd) => {
         }
     }
     else if (isNonEmptyString(options['connection'])) {
-        const selected = String(options['connection']).trim();
-        const connections = databaseConfig.connections;
-        targets.push({
-            name: selected,
-            config: connections[selected] ?? databaseConfig.getConnection(),
-        });
+        targets.push(resolveNamedTraceConnection(String(options['connection']).trim()));
     }
     else {
-        const selected = readEnvString('DEBUGGER_DB_CONNECTION').trim() || 'default';
-        const connections = databaseConfig.connections;
-        targets.push({
-            name: selected,
-            config: connections[selected] ?? databaseConfig.getConnection(),
-        });
+        targets.push(resolveNamedTraceConnection(readEnvString('TRACE_DB_CONNECTION').trim() || 'default'));
     }
     let sequence = Promise.resolve();
     for (const { name, config } of targets) {
@@ -488,49 +496,33 @@ const createProvider = (name, getCommand) => {
         getCommand: () => getCommand().getCommand(),
     });
 };
-export const DebuggerCommands = Object.freeze({
-    createDebuggerPruneCommand: () => BaseCommand.create({
-        name: 'debugger:prune',
-        description: 'Prune old entries from the debugger storage',
+export const TraceCommands = Object.freeze({
+    createTracePruneCommand: () => createTraceCommand({
+        name: 'trace:prune',
+        description: 'Prune old entries from the trace storage',
         addOptions: addPruneOptions,
-        execute: executePrune,
+        execute: async (options) => executePrune(options),
     }),
-    createDebuggerClearCommand: () => BaseCommand.create({
-        name: 'debugger:clear',
-        description: 'Clear all entries from the debugger storage',
-        addOptions: (command) => {
-            command
-                .option('--local', 'D1 only: run against local D1 database')
-                .option('--remote', 'D1 only: run against remote D1 database')
-                .option('--database <name>', 'D1 only: Wrangler D1 database binding name');
-        },
+    createTraceClearCommand: () => createTraceCommand({
+        name: 'trace:clear',
+        description: 'Clear all entries from the trace storage',
+        addOptions: addD1DatabaseOptions,
         execute: async (options) => executeClear(options),
     }),
-    createDebuggerStatusCommand: () => {
-        const cmd = BaseCommand.create({
-            name: 'debugger:status',
-            description: 'Show debugger storage stats and dashboard location',
-            addOptions: (command) => {
-                command
-                    .option('--local', 'D1 only: run against local D1 database')
-                    .option('--remote', 'D1 only: run against remote D1 database')
-                    .option('--database <name>', 'D1 only: Wrangler D1 database binding name');
-            },
-            execute: async (options) => executeStatus(options, cmd),
-        });
-        return cmd;
-    },
-    createDebuggerMigrateCommand: () => {
-        const cmd = BaseCommand.create({
-            name: 'migrate:debugger',
-            description: 'Run debugger package migrations',
-            addOptions: addMigrateOptions,
-            execute: async (options) => executeMigrateDebugger(options, cmd),
-        });
-        return cmd;
-    },
-    createDebuggerPruneProvider: () => createProvider('debugger:prune', DebuggerCommands.createDebuggerPruneCommand),
-    createDebuggerClearProvider: () => createProvider('debugger:clear', DebuggerCommands.createDebuggerClearCommand),
-    createDebuggerStatusProvider: () => createProvider('debugger:status', DebuggerCommands.createDebuggerStatusCommand),
-    createDebuggerMigrateProvider: () => createProvider('migrate:debugger', DebuggerCommands.createDebuggerMigrateCommand),
+    createTraceStatusCommand: () => createTraceCommand({
+        name: 'trace:status',
+        description: 'Show trace storage stats and dashboard location',
+        addOptions: addD1DatabaseOptions,
+        execute: executeStatus,
+    }),
+    createTraceMigrateCommand: () => createTraceCommand({
+        name: 'migrate:trace',
+        description: 'Run trace package migrations',
+        addOptions: addMigrateOptions,
+        execute: executeMigrateTrace,
+    }),
+    createTracePruneProvider: () => createProvider('trace:prune', TraceCommands.createTracePruneCommand),
+    createTraceClearProvider: () => createProvider('trace:clear', TraceCommands.createTraceClearCommand),
+    createTraceStatusProvider: () => createProvider('trace:status', TraceCommands.createTraceStatusCommand),
+    createTraceMigrateProvider: () => createProvider('migrate:trace', TraceCommands.createTraceMigrateCommand),
 });

package/src/cli/commands/index.d.ts

@@ -8,7 +8,6 @@ export { ContainerWorkersCommand } from '../commands/ContainerWorkersCommand';
 export { AddMigrationCommand, CreateCommand, CreateMigrationCommand, } from '../commands/CreateCommand';
 export { D1ProxyCommand } from '../commands/D1ProxyCommand';
 export { DebugCommand } from '../commands/DebugCommand';
-export { DebuggerCommands } from '../commands/DebuggerCommands';
 export { JwtDevCommand } from '../commands/JwtDevCommand';
 export { KvProxyCommand } from '../commands/KvProxyCommand';
 export { LogsCleanupCommand } from '../commands/LogsCleanupCommand';
@@ -26,5 +25,6 @@ export { RoutesCommand } from '../commands/RoutesCommand';
 export { SecretsCommand } from '../commands/SecretsCommand';
 export { StartCommand } from '../commands/StartCommand';
 export { TemplatesCommand } from '../commands/TemplatesCommand';
+export { TraceCommands } from '../commands/TraceCommands';
 export { WranglerDevVarsCommand } from '../commands/WranglerDevVarsCommand';
 //# sourceMappingURL=index.d.ts.map

package/src/cli/commands/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,sBAAsB,GACvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,+BAA+B,EAAE,MAAM,+CAA+C,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,sBAAsB,GACvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,+BAA+B,EAAE,MAAM,+CAA+C,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC"}

package/src/cli/commands/index.js

@@ -8,7 +8,6 @@ export { ContainerWorkersCommand } from '../commands/ContainerWorkersCommand.js'
 export { AddMigrationCommand, CreateCommand, CreateMigrationCommand, } from '../commands/CreateCommand.js';
 export { D1ProxyCommand } from '../commands/D1ProxyCommand.js';
 export { DebugCommand } from '../commands/DebugCommand.js';
-export { DebuggerCommands } from '../commands/DebuggerCommands.js';
 export { JwtDevCommand } from '../commands/JwtDevCommand.js';
 export { KvProxyCommand } from '../commands/KvProxyCommand.js';
 export { LogsCleanupCommand } from '../commands/LogsCleanupCommand.js';
@@ -26,4 +25,5 @@ export { RoutesCommand } from '../commands/RoutesCommand.js';
 export { SecretsCommand } from '../commands/SecretsCommand.js';
 export { StartCommand } from '../commands/StartCommand.js';
 export { TemplatesCommand } from '../commands/TemplatesCommand.js';
+export { TraceCommands } from '../commands/TraceCommands.js';
 export { WranglerDevVarsCommand } from '../commands/WranglerDevVarsCommand.js';

package/src/cli/index.d.ts

@@ -4,13 +4,12 @@
  */
 export { BaseCommand, type CommandOptions } from './BaseCommand';
 export { CLI } from './CLI';
-export { EXIT_CODES, ErrorHandler } from './ErrorHandler';
+export { ErrorHandler, EXIT_CODES } from './ErrorHandler';
 export { PromptHelper, type PromptOptions } from './PromptHelper';
 export { AddCommand } from './commands/AddCommand';
 export { ConfigCommand } from './commands/ConfigCommand';
 export { D1ProxyCommand } from './commands/D1ProxyCommand';
 export { DebugCommand } from './commands/DebugCommand';
-export { DebuggerCommands } from './commands/DebuggerCommands';
 export { KvProxyCommand } from './commands/KvProxyCommand';
 export { MigrateCommand } from './commands/MigrateCommand';
 export { MySqlProxyCommand } from './commands/MySqlProxyCommand';
@@ -19,5 +18,6 @@ export { PostgresProxyCommand } from './commands/PostgresProxyCommand';
 export { ProxyCommand } from './commands/ProxyCommand';
 export { RedisProxyCommand } from './commands/RedisProxyCommand';
 export { SecretsCommand } from './commands/SecretsCommand';
+export { TraceCommands } from './commands/TraceCommands';
 export { WorkerCommands } from './commands/WorkerCommands';
 //# sourceMappingURL=index.d.ts.map

package/src/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGrE,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGrE,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC"}

package/src/cli/index.js

@@ -4,14 +4,13 @@
  */
 export { BaseCommand } from './BaseCommand.js';
 export { CLI } from './CLI.js';
-export { EXIT_CODES, ErrorHandler } from './ErrorHandler.js';
+export { ErrorHandler, EXIT_CODES } from './ErrorHandler.js';
 export { PromptHelper } from './PromptHelper.js';
 // Export commands
 export { AddCommand } from './commands/AddCommand.js';
 export { ConfigCommand } from './commands/ConfigCommand.js';
 export { D1ProxyCommand } from './commands/D1ProxyCommand.js';
 export { DebugCommand } from './commands/DebugCommand.js';
-export { DebuggerCommands } from './commands/DebuggerCommands.js';
 export { KvProxyCommand } from './commands/KvProxyCommand.js';
 export { MigrateCommand } from './commands/MigrateCommand.js';
 export { MySqlProxyCommand } from './commands/MySqlProxyCommand.js';
@@ -20,4 +19,5 @@ export { PostgresProxyCommand } from './commands/PostgresProxyCommand.js';
 export { ProxyCommand } from './commands/ProxyCommand.js';
 export { RedisProxyCommand } from './commands/RedisProxyCommand.js';
 export { SecretsCommand } from './commands/SecretsCommand.js';
+export { TraceCommands } from './commands/TraceCommands.js';
 export { WorkerCommands } from './commands/WorkerCommands.js';

package/src/cli.d.ts

@@ -2,7 +2,7 @@ export { BaseCommand } from './cli/BaseCommand';
 export type { CommandOptions } from './cli/BaseCommand';
 export { CLI } from './cli/CLI';
 export { ErrorHandler, EXIT_CODES } from './cli/ErrorHandler';
-export { DebuggerCommands } from './cli/commands/DebuggerCommands';
+export { TraceCommands } from './cli/commands/TraceCommands';
 export { WorkerCommands } from './cli/commands/WorkerCommands';
 export { OptionalCliCommandRegistry } from './cli/OptionalCliCommandRegistry';
 export type { CliCommandProvider } from './cli/OptionalCliCommandRegistry';

package/src/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAC7E,YAAY,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAC7E,YAAY,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC"}

package/src/cli.js

@@ -2,6 +2,6 @@
 export { BaseCommand } from './cli/BaseCommand.js';
 export { CLI } from './cli/CLI.js';
 export { ErrorHandler, EXIT_CODES } from './cli/ErrorHandler.js';
-export { DebuggerCommands } from './cli/commands/DebuggerCommands.js';
+export { TraceCommands } from './cli/commands/TraceCommands.js';
 export { WorkerCommands } from './cli/commands/WorkerCommands.js';
 export { OptionalCliCommandRegistry } from './cli/OptionalCliCommandRegistry.js';

package/src/config/logging/KvLogger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KvLogger.d.ts","sourceRoot":"","sources":["../../../../src/config/logging/KvLogger.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,MAAM,MAAM,UAAU,GAAG;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AA2IF,eAAO,MAAM,QAAQ;mBACE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;EAkB/C,CAAC;AAEH,eAAe,QAAQ,CAAC"}
+{"version":3,"file":"KvLogger.d.ts","sourceRoot":"","sources":["../../../../src/config/logging/KvLogger.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,MAAM,MAAM,UAAU,GAAG;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAiKF,eAAO,MAAM,QAAQ;mBACE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;EAa/C,CAAC;AAEH,eAAe,QAAQ,CAAC"}

package/src/config/logging/KvLogger.js

@@ -46,6 +46,7 @@ const buildKey = (timestampIso) => {
 let buffer = [];
 let flushTimer;
 let flushPromise;
+let resolveScheduledFlush;
 const scheduleFlush = async () => {
     if (flushPromise !== undefined)
         return flushPromise;
@@ -57,6 +58,7 @@ const scheduleFlush = async () => {
                 await flushNow();
             }
             finally {
+                resolveScheduledFlush = undefined;
                 resolve(undefined);
             }
         };
@@ -65,6 +67,7 @@ const scheduleFlush = async () => {
             void run();
             return;
         }
+        resolveScheduledFlush = resolve;
         flushTimer = globalThis.setTimeout(() => {
             flushTimer = undefined;
             void run();
@@ -122,6 +125,20 @@ const flushSoon = async () => {
     });
     return flushPromise;
 };
+const flushImmediately = async () => {
+    const pendingResolve = resolveScheduledFlush;
+    if (flushTimer !== undefined) {
+        globalThis.clearTimeout(flushTimer);
+        flushTimer = undefined;
+        resolveScheduledFlush = undefined;
+        flushPromise = undefined;
+    }
+    const immediatePromise = flushSoon();
+    if (pendingResolve !== undefined) {
+        void immediatePromise.finally(() => pendingResolve());
+    }
+    return immediatePromise;
+};
 export const KvLogger = Object.freeze({
     async enqueue(event) {
         if (!isEnabled())
@@ -130,12 +147,7 @@ export const KvLogger = Object.freeze({
         // Basic size guard: flush if it gets too large
         const maxBatch = 100;
         if (buffer.length >= maxBatch) {
-            // Cancel scheduled flush and flush immediately
-            if (flushTimer !== undefined) {
-                globalThis.clearTimeout(flushTimer);
-                flushTimer = undefined;
-            }
-            return flushSoon();
+            return flushImmediately();
         }
         return scheduleFlush();
     },