@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/telemetry/events/version.js

@@ -12,12 +12,12 @@ const EVENT_VERSION = 'NEXT_CLI_SESSION_STARTED';
 function eventCliSession(nextConfig, event) {
     var _nextConfig_experimental, _nextConfig_experimental_staleTimes, _nextConfig_experimental_staleTimes1, _nextConfig_reactCompiler, _nextConfig_reactCompiler1;
     // This should be an invariant, if it fails our build tooling is broken.
-    if (typeof "16.3.8" !== 'string') {
+    if (typeof "16.4.1" !== 'string') {
         return [];
     }
     const { images, i18n } = nextConfig || {};
     const payload = {
-        nextVersion: "16.3.8",
+        nextVersion: "16.4.1",
         nodeVersion: process.version,
         cliCommand: event.cliCommand,
         isSrcDir: event.isSrcDir,

package/app/node_modules/next/dist/telemetry/post-telemetry-payload.js

@@ -27,11 +27,7 @@ function postNextTelemetryPayload(payload, signal) {
             signal
         }).then((res)=>{
             if (!res.ok) {
-                const err = Object.defineProperty(new Error(res.statusText), "__NEXT_ERROR_CODE", {
-                    value: "E394",
-                    enumerable: false,
-                    configurable: true
-                });
+                const err = new Error(res.statusText);
                 err.response = res;
                 throw err;
             }

package/app/node_modules/next/dist/telemetry/storage.js

@@ -86,7 +86,7 @@ function getStorageDirectory(distDir) {
     return undefined;
 }
 class Telemetry {
-    constructor({ distDir }){
+    constructor({ distDir, skipNotify = false }){
         this.notify = ()=>{
             if (this.isDisabled || !this.conf) {
                 return;
@@ -157,27 +157,32 @@ class Telemetry {
         // writes current events to disk and spawns separate
         // detached process to submit the records without blocking
         // the main process from exiting
-        this.flushDetached = (mode, dir)=>{
-            const allEvents = [];
-            this.queue.forEach((item)=>{
-                try {
-                    var _item__controller;
-                    (_item__controller = item._controller) == null ? void 0 : _item__controller.abort();
-                    allEvents.push(...item._events);
-                } catch (_) {
-                // if we fail to abort ignore this event
-                }
-            });
+        this.flushDetached = ({ mode, dir, distDir, events })=>{
+            // Nudges detach only their own events; shutdown flushes the full queue.
+            const allEvents = events ?? [];
+            if (events === null) {
+                this.queue.forEach((item)=>{
+                    try {
+                        var _item__controller;
+                        (_item__controller = item._controller) == null ? void 0 : _item__controller.abort();
+                        allEvents.push(...item._events);
+                    } catch (_) {
+                    // if we fail to abort ignore this event
+                    }
+                });
+            }
             if (allEvents.length === 0) {
                 // No events to flush
                 return;
             }
-            _fs.default.mkdirSync(this.distDir, {
+            // Builds preserve cache while cleaning distDir, so detached batches survive cleanup.
+            const eventsDirectory = _path.default.join(this.distDir, 'cache');
+            _fs.default.mkdirSync(eventsDirectory, {
                 recursive: true
             });
-            // Use unique filename per process to avoid race conditions between parent/child
-            const eventsFile = `_events_${process.pid}.json`;
-            _fs.default.writeFileSync(_path.default.join(this.distDir, eventsFile), JSON.stringify(allEvents));
+            // Each flush owns its file so a later shutdown flush cannot replace a nudge batch.
+            const eventsFile = `_events_${process.pid}_${(0, _crypto.randomBytes)(8).toString('hex')}.json`;
+            _fs.default.writeFileSync(_path.default.join(eventsDirectory, eventsFile), JSON.stringify(allEvents));
             // Note: cross-spawn is not used here as it causes
             // a new command window to appear when we don't want it to
             const child_process = require('child_process');
@@ -188,7 +193,10 @@ class Telemetry {
                 require.resolve('./detached-flush'),
                 mode,
                 dir,
-                eventsFile
+                eventsFile,
+                ...distDir ? [
+                    distDir
+                ] : []
             ], {
                 detached: !this.NEXT_TELEMETRY_DEBUG,
                 windowsHide: true,
@@ -245,8 +253,10 @@ class Telemetry {
                         fields: payload
                     }))
             }, postController.signal);
+            // Bound delivery even when callers await record/flush; retries share this deadline.
+            const timeout = setTimeout(()=>postController.abort(), 5000);
             res._controller = postController;
-            return res;
+            return res.finally(()=>clearTimeout(timeout));
         };
         // Read in the constructor so that .env can be loaded before reading
         const { NEXT_TELEMETRY_DISABLED, NEXT_TELEMETRY_DEBUG } = process.env;
@@ -267,7 +277,9 @@ class Telemetry {
         }
         this.sessionId = (0, _crypto.randomBytes)(32).toString('hex');
         this.queue = new Set();
-        this.notify();
+        if (!skipNotify) {
+            this.notify();
+        }
     }
     get anonymousId() {
         const val = this.conf && this.conf.get(TELEMETRY_KEY_ID);

package/app/node_modules/next/dist/trace/report/index.js

@@ -21,8 +21,11 @@ class MultiReporter {
         this.reporters = [];
         this.reporters = reporters;
     }
-    async flushAll(opts) {
-        await Promise.all(this.reporters.map((reporter)=>reporter.flushAll(opts)));
+    flushAll() {
+        this.reporters.forEach((reporter)=>reporter.flushAll());
+    }
+    close() {
+        this.reporters.forEach((reporter)=>reporter.close == null ? void 0 : reporter.close.call(reporter));
     }
     report(event) {
         this.reporters.forEach((reporter)=>reporter.report(event));

package/app/node_modules/next/dist/trace/report/to-json-build.js

@@ -24,9 +24,11 @@ const allowlistedEvents = new Set([
     'adapter-handle-build-complete',
     'output-standalone',
     'telemetry-flush',
-    'turbopack-build-events',
     'turbopack-persistence',
-    'turbopack-compaction'
+    'turbopack-compaction',
+    'turbopack-module-graph',
+    'turbopack-write-entrypoints',
+    'turbopack-emit'
 ]);
 const _default = (0, _tojson.createJsonReporter)({
     filename: 'trace-build',

package/app/node_modules/next/dist/trace/report/to-json.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    batcher: null,
     createJsonReporter: null,
     default: null
 });
@@ -14,9 +13,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    batcher: function() {
-        return batcher;
-    },
     createJsonReporter: function() {
         return createJsonReporter;
     },
@@ -33,92 +29,147 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-function batcher(reportEvents) {
-    const events = [];
-    // Promise queue to ensure events are always sent on flushAll
-    const queue = new Set();
-    return {
-        flushAll: async ()=>{
-            await Promise.all(queue);
-            if (events.length > 0) {
-                await reportEvents(events);
-                events.length = 0;
-            }
-        },
-        report: (event)=>{
-            events.push(event);
-            if (events.length > 100) {
-                const evts = events.slice();
-                events.length = 0;
-                const report = reportEvents(evts);
-                queue.add(report);
-                report.then(()=>queue.delete(report));
-            }
-        }
-    };
-}
-const writeStreamOptions = {
-    flags: 'a',
-    encoding: 'utf8'
-};
-class RotatingWriteStream {
+// The webpack/rspack profiling plugins open a span per module, so writing
+// events individually would put a syscall in the middle of every module build.
+const BUFFER_SIZE = 16 * 1024;
+// Each flush is wrapped as a JSON array; the tail of the buffer is reserved
+// for this and never used by event data.
+const TERMINATOR = Buffer.from(']\n', 'utf8');
+const MAX_UTF8_CHAR_BYTES = 4;
+/**
+ * An append-only newline-delimited JSON file.
+ *
+ * Closing is not part of the normal lifetime: `writeSync` hands the bytes to
+ * the OS before it returns, so once flushed they survive `process.exit()` and
+ * crashes that run no shutdown path. Only the unflushed tail is at risk, which
+ * is why `flush()` is called wherever traces need to be on disk. `close()`
+ * exists for callers that must then act on the file itself.
+ */ class RotatingWriteStream {
     constructor(file, sizeLimit){
-        this.file = file;
+        this.buffer = Buffer.allocUnsafe(BUFFER_SIZE);
+        // Bytes of event data in `buffer`, excluding the terminator written at
+        // flush time. 0 means nothing is pending.
+        this.buffered = 0;
         this.size = 0;
+        this.file = file;
         this.sizeLimit = sizeLimit;
-        this.createWriteStream();
+        // TODO: opening a file in append mode like we do in dev should seed the
+        // size from the current file size.
+        this.size = 0;
     }
-    createWriteStream() {
-        const phase = _shared.traceGlobals.get('phase');
-        this.writeStream = _fs.default.createWriteStream(this.file, {
-            ...writeStreamOptions,
+    /**
+   * Open on first write rather than up front. The dev server records spans
+   * before it cleans its dist dir, and a descriptor opened that early would be
+   * unlinked by the clean -- writes to the orphaned inode still succeed, so
+   * the trace would silently never appear on disk.
+   */ open() {
+        if (this.fd === undefined) {
+            _fs.default.mkdirSync(_path.default.dirname(this.file), {
+                recursive: true
+            });
             // In dev, append so traces accumulate across sessions. In production,
             // truncate so each build starts with a fresh trace file.
-            flags: phase === _constants.PHASE_DEVELOPMENT_SERVER ? 'a' : 'w'
-        });
+            this.fd = _fs.default.openSync(this.file, _shared.traceGlobals.get('phase') === _constants.PHASE_DEVELOPMENT_SERVER ? 'a' : 'w');
+        }
+        return this.fd;
     }
     // Recreate the file
-    async rotate() {
-        await this.end();
+    rotate() {
+        this.closeFd();
+        _fs.default.mkdirSync(_path.default.dirname(this.file), {
+            recursive: true
+        });
+        // Opening in 'w' mode truncates the file, discarding what rotated out.
+        this.fd = _fs.default.openSync(this.file, 'w');
+        this.size = 0;
+    }
+    /**
+   * Append one already-encoded event. Events are written as a single JSON
+   * array per flush, which is the format readers expect (see
+   * `parseTraceEvents` and the trace uploader).
+   */ write(encodedEvent) {
+        const capacity = this.buffer.length - TERMINATOR.length;
+        if (this.tryWriteToBuffer(encodedEvent, capacity)) {
+            return;
+        }
+        // Didn't fit. Start a fresh batch and try again.
+        this.flush();
+        if (this.tryWriteToBuffer(encodedEvent, capacity)) {
+            return;
+        }
+        // Too large to ever fit in the buffer, so give it a batch of its own.
+        this.writeToFile(Buffer.from(`[${encodedEvent}]\n`, 'utf8'));
+    }
+    /**
+   * Append `[event` or `,event` to the buffer, returning false without
+   * modifying it if the whole thing does not fit.
+   */ tryWriteToBuffer(encodedEvent, capacity) {
+        // `[` opens a new batch, `,` separates events within one.
+        const prefix = this.buffered === 0 ? '[' : ',';
+        const written = this.buffer.write(prefix + encodedEvent, this.buffered, capacity - this.buffered, 'utf8');
+        // `Buffer.write` truncates silently, so the byte count is the only signal
+        // that the event did not fit -- and because it stops at the last whole
+        // character, a truncated write can still leave a few bytes unused. Only a
+        // write that ends clear of that margin is known to be complete.
+        if (this.buffered + written > capacity - MAX_UTF8_CHAR_BYTES) {
+            return false;
+        }
+        this.buffered += written;
+        return true;
+    }
+    flush() {
+        if (this.buffered === 0) {
+            return;
+        }
+        this.buffered += TERMINATOR.copy(this.buffer, this.buffered);
+        const data = this.buffer.subarray(0, this.buffered);
+        this.buffered = 0;
+        this.writeToFile(data);
+    }
+    writeToFile(data) {
+        let offset = 0;
         try {
-            _fs.default.unlinkSync(this.file);
-        } catch (err) {
-            // It's fine if the file does not exist yet
-            if (err.code !== 'ENOENT') {
-                throw err;
+            if (this.size + data.length > this.sizeLimit) {
+                this.rotate();
+            }
+            const fd = this.open();
+            // writeSync can write fewer than all the bytes
+            while(offset < data.length){
+                offset += _fs.default.writeSync(fd, data, offset);
             }
+        } catch (err) {
+            // Tracing is diagnostic, so a failed write should not fail the build.
+            // N.B. This is incredibly rare and a torn write means the data may be corrupted on disk.
+            console.log(err);
         }
-        this.size = 0;
-        this.createWriteStream();
-        this.rotatePromise = undefined;
+        this.size += offset;
     }
-    async write(data) {
-        if (this.rotatePromise) await this.rotatePromise;
-        this.size += data.length;
-        if (this.size > this.sizeLimit) {
-            await (this.rotatePromise = this.rotate());
+    /**
+   * Release the descriptor without flushing. Callers that want the buffered
+   * tail on disk flush first; `rotate` deliberately does not.
+   */ closeFd() {
+        if (this.fd === undefined) {
+            return;
         }
-        if (!this.writeStream.write(data, 'utf8')) {
-            if (this.drainPromise === undefined) {
-                this.drainPromise = new Promise((resolve, _reject)=>{
-                    this.writeStream.once('drain', ()=>{
-                        this.drainPromise = undefined;
-                        resolve();
-                    });
-                });
-            }
-            await this.drainPromise;
+        try {
+            _fs.default.closeSync(this.fd);
+        } catch  {
+        // Nothing useful to do if the descriptor is already gone.
         }
+        this.fd = undefined;
     }
-    end() {
-        return new Promise((resolve)=>{
-            this.writeStream.end(resolve);
-        });
+    /**
+   * Flush and release the descriptor. Only needed when something else has to
+   * act on the file (Windows cannot remove a file that is still open), which
+   * in practice means tests -- the normal lifetime of the process is the
+   * lifetime of the trace.
+   */ close() {
+        this.flush();
+        this.closeFd();
     }
 }
 function createJsonReporter(options) {
     let writeStream;
-    let batch;
     function report(event) {
         if (options.filter && !options.filter(event)) {
             return;
@@ -128,37 +179,30 @@ function createJsonReporter(options) {
         if (!distDir || !phase) {
             return;
         }
-        if (!batch) {
-            batch = batcher(async (events)=>{
-                if (!writeStream) {
-                    await _fs.default.promises.mkdir(distDir, {
-                        recursive: true
-                    });
-                    const file = _path.default.join(distDir, options.filename);
-                    const limit = typeof options.sizeLimit === 'function' ? options.sizeLimit(phase) : options.sizeLimit;
-                    writeStream = new RotatingWriteStream(file, limit);
-                }
-                const eventsJson = JSON.stringify(events);
-                try {
-                    await writeStream.write(eventsJson + '\n');
-                } catch (err) {
-                    console.log(err);
-                }
-            });
+        const file = _path.default.join(distDir, options.filename);
+        // `distDir` can change within a process (most visibly between tests), so
+        // a stream opened against a previous one must not keep receiving events.
+        if (writeStream && writeStream.file !== file) {
+            writeStream.close();
+            writeStream = undefined;
+        }
+        if (!writeStream) {
+            // Constructing the stream touches no filesystem state -- the directory
+            // and file are created lazily on the first write.
+            const limit = typeof options.sizeLimit === 'function' ? options.sizeLimit(phase) : options.sizeLimit;
+            writeStream = new RotatingWriteStream(file, limit);
         }
-        batch.report({
+        writeStream.write(JSON.stringify({
             ...event,
             traceId: _shared.traceId
-        });
+        }));
     }
     return {
-        flushAll: (opts)=>batch ? batch.flushAll().then(()=>{
-                const phase = _shared.traceGlobals.get('phase');
-                // Only end writeStream when manually flushing in production
-                if ((opts == null ? void 0 : opts.end) || phase !== _constants.PHASE_DEVELOPMENT_SERVER) {
-                    return writeStream.end();
-                }
-            }) : undefined,
+        flushAll: ()=>writeStream == null ? void 0 : writeStream.flush(),
+        close: ()=>{
+            writeStream == null ? void 0 : writeStream.close();
+            writeStream = undefined;
+        },
         report
     };
 }

package/app/node_modules/next/dist/trace/trace.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
     Span: null,
     SpanStatus: null,
     clearTraceEvents: null,
+    closeAllTraces: null,
     exportTraceState: null,
     flushAllTraces: null,
     getTraceEvents: null,
@@ -30,6 +31,9 @@ _export(exports, {
     clearTraceEvents: function() {
         return clearTraceEvents;
     },
+    closeAllTraces: function() {
+        return closeAllTraces;
+    },
     exportTraceState: function() {
         return exportTraceState;
     },
@@ -70,7 +74,7 @@ var SpanStatus = /*#__PURE__*/ function(SpanStatus) {
     return SpanStatus;
 }({});
 class Span {
-    constructor({ name, parentId, attrs, startTime }){
+    constructor({ name, parentId, attrs, startTime, wallStartTimeMs }){
         this.name = name;
         this.parentId = parentId ?? defaultParentSpanId;
         this.attrs = attrs ? {
@@ -84,7 +88,7 @@ class Span {
         // `These times are relative to an arbitrary time in the past, and not related to the time of day and therefore not subject to clock drift`
         // https://nodejs.org/api/process.html#processhrtimetime
         // Capturing current datetime as additional metadata for external reconstruction.
-        this.now = Date.now();
+        this.now = wallStartTimeMs ?? Date.now();
     }
     // Durations are reported as microseconds. This gives 1000x the precision
     // of something like Date.now(), which reports in milliseconds.
@@ -100,11 +104,7 @@ class Span {
         const duration = (end - this._start) / NUM_OF_MICROSEC_IN_NANOSEC;
         this.status = "stopped";
         if (duration > Number.MAX_SAFE_INTEGER) {
-            throw Object.defineProperty(new Error(`Duration is too long to express as float64: ${duration}`), "__NEXT_ERROR_CODE", {
-                value: "E1030",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Duration is too long to express as float64: ${duration}`);
         }
         const timestamp = this._start / NUM_OF_MICROSEC_IN_NANOSEC;
         const traceEvent = {
@@ -139,7 +139,11 @@ class Span {
             name,
             parentId: this.id,
             attrs,
-            startTime: startTime ? startTime + correction : process.hrtime.bigint()
+            startTime: startTime ? startTime + correction : process.hrtime.bigint(),
+            // The span is constructed when the event is recorded, which may be long
+            // after the work started (e.g. compilation events forwarded from
+            // Turbopack), so derive the wall-clock start from the given epoch time.
+            wallStartTimeMs: startTime ? Number(startTime / NUM_OF_MILLISEC_IN_NANOSEC) : undefined
         });
         span.stop(stopTime ? stopTime + correction : process.hrtime.bigint());
     }
@@ -177,7 +181,8 @@ const trace = (name, parentId, attrs)=>{
         attrs
     });
 };
-const flushAllTraces = (opts)=>_report.reporter.flushAll(opts);
+const flushAllTraces = ()=>_report.reporter.flushAll();
+const closeAllTraces = ()=>_report.reporter.close();
 const exportTraceState = ()=>({
         defaultParentSpanId,
         lastId: count,

package/app/node_modules/next/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next",
-  "version": "16.3.8",
+  "version": "16.4.1",
   "description": "The React Framework",
   "main": "./dist/server/next.js",
   "license": "MIT",
@@ -10,6 +10,7 @@
   "types": "index.d.ts",
   "files": [
     "AGENTS.md",
+    "analyze",
     "dist",
     "app.js",
     "app.d.ts",
@@ -81,7 +82,7 @@
     "next": "./dist/bin/next"
   },
   "dependencies": {
-    "@next/env": "16.3.8",
+    "@next/env": "16.4.1",
     "@swc/helpers": "0.5.23",
     "baseline-browser-mapping": "^2.9.19",
     "caniuse-lite": "^1.0.30001579",
@@ -111,15 +112,15 @@
     }
   },
   "optionalDependencies": {
-    "sharp": "^0.35.4",
-    "@next/swc-darwin-arm64": "16.3.8",
-    "@next/swc-darwin-x64": "16.3.8",
-    "@next/swc-linux-arm64-gnu": "16.3.8",
-    "@next/swc-linux-arm64-musl": "16.3.8",
-    "@next/swc-linux-x64-gnu": "16.3.8",
-    "@next/swc-linux-x64-musl": "16.3.8",
-    "@next/swc-win32-arm64-msvc": "16.3.8",
-    "@next/swc-win32-x64-msvc": "16.3.8"
+    "sharp": "^0.35.5",
+    "@next/swc-darwin-arm64": "16.4.1",
+    "@next/swc-darwin-x64": "16.4.1",
+    "@next/swc-linux-arm64-gnu": "16.4.1",
+    "@next/swc-linux-arm64-musl": "16.4.1",
+    "@next/swc-linux-x64-gnu": "16.4.1",
+    "@next/swc-linux-x64-musl": "16.4.1",
+    "@next/swc-win32-arm64-msvc": "16.4.1",
+    "@next/swc-win32-x64-msvc": "16.4.1"
   },
   "keywords": [
     "react",

package/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "krouter-app",
-  "version": "0.5.166",
+  "version": "0.5.168",
   "description": "kRouter (Kodelyth Router) web dashboard — Kodelyth AI Infrastructure",
   "private": true,
   "scripts": {
@@ -33,7 +33,7 @@
     "marked": "^18.0.1",
     "material-symbols": "^0.44.6",
     "monaco-editor": "^0.53.0",
-    "next": "^16.3.8",
+    "next": "^16.4.1",
     "node-forge": "^1.3.3",
     "node-machine-id": "^1.1.12",
     "open": "^11.0.0",
@@ -45,7 +45,7 @@
     "selfsigned": "^5.5.0",
     "socks-proxy-agent": "^8.0.5",
     "sql.js": "^1.14.1",
-    "undici": "^7.19.2",
+    "undici": "^7.30.1",
     "uuid": "^13.0.0",
     "zustand": "^5.0.10"
   },
@@ -59,6 +59,6 @@
     "eslint-config-next": "16.1.6",
     "postcss": "^8.5.6",
     "tailwindcss": "^4",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.12"
   }
 }