failproofai 1.0.11-beta.0 → 1.0.11-beta.2

package/.next/standalone/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/.next/standalone/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/.next/standalone/node_modules/next/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next",
-  "version": "16.3.8",
+  "version": "16.4.0",
   "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.0",
     "@swc/helpers": "0.5.23",
     "baseline-browser-mapping": "^2.9.19",
     "caniuse-lite": "^1.0.30001579",
@@ -112,14 +113,14 @@
   },
   "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"
+    "@next/swc-darwin-arm64": "16.4.0",
+    "@next/swc-darwin-x64": "16.4.0",
+    "@next/swc-linux-arm64-gnu": "16.4.0",
+    "@next/swc-linux-arm64-musl": "16.4.0",
+    "@next/swc-linux-x64-gnu": "16.4.0",
+    "@next/swc-linux-x64-musl": "16.4.0",
+    "@next/swc-win32-arm64-msvc": "16.4.0",
+    "@next/swc-win32-x64-msvc": "16.4.0"
   },
   "keywords": [
     "react",

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "failproofai",
-  "version": "1.0.11-beta.0",
+  "version": "1.0.11-beta.2",
   "description": "Observability and enforcement for AI agent harnesses. 40 built-in policies hooked into 12 of them — Claude Code, Codex, Cursor, Hermes, OpenClaw and more — blocking the tool call before it runs. Local dashboard included, no account needed.",
   "bin": {
     "failproofai": "./dist/cli.mjs",
@@ -81,14 +81,14 @@
     "access": "public"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.128.0",
+    "@anthropic-ai/sdk": "^0.133.0",
     "@mdx-js/mdx": "^3.1.1",
     "@tailwindcss/postcss": "^4.3.1",
     "@tanstack/react-virtual": "^3.14.10",
     "@testing-library/jest-dom": "^7.0.0",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.5",
-    "@types/node": "26.6.2",
+    "@types/node": "26.6.5",
     "@types/react": "19.3.0",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^6.1.0",
@@ -125,15 +125,15 @@
     "browserslist": "4.28.8"
   },
   "optionalDependencies": {
-    "@failproofai/failproofaid-linux-x64": "1.0.11-beta.0",
-    "@failproofai/failproofaid-linux-arm64": "1.0.11-beta.0",
-    "@failproofai/failproofaid-darwin-x64": "1.0.11-beta.0",
-    "@failproofai/failproofaid-darwin-arm64": "1.0.11-beta.0"
+    "@failproofai/failproofaid-linux-x64": "1.0.11-beta.2",
+    "@failproofai/failproofaid-linux-arm64": "1.0.11-beta.2",
+    "@failproofai/failproofaid-darwin-x64": "1.0.11-beta.2",
+    "@failproofai/failproofaid-darwin-arm64": "1.0.11-beta.2"
   },
   "failproofaidBinaries": {
-    "linux-x64": "40b05c741f4c3c63bbf23b21cc4e200a396c07d568656a10d67a84b12fee42b8",
-    "linux-arm64": "afe688afba9e7f225d6d521c01b7d0038f1374125ede22f669ed45847a12e9b0",
-    "darwin-x64": "d8398fafe3a58abce754437f92111918d0229f966cd987be923d5dafbd5d3f84",
-    "darwin-arm64": "80108cfd087ecae5e1f2c2ba9bab77e160daceb169a0c44b5fe8b6ca519fc8dc"
+    "linux-x64": "4c27c00e42b621d0a7e6de5ff4da25806b3d8f5936b5ba154a49bcb6d252aae0",
+    "linux-arm64": "be383d9ff2a2d34ba5dc82e8d73fb5bd5bd76fca4d7059563307ae6e178cc126",
+    "darwin-x64": "e9f02f91bebe8d5202c58ff841e46ed8d4beb23e240bff3359c5aac2812c887e",
+    "darwin-arm64": "cc28680275bb0561978cf4c9c3882986d8d8b68484c5bf0e6a75c79aa4b90cda"
   }
 }