From a5bbc7b880da7e1a80eddc3119ba9c39f0c530fa Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Wed, 21 Oct 2026 22:35:59 +0200 Subject: [PATCH 001/331] stream: keep async context of parked writes A TransformStream write that parks on backpressure was resumed from the read that lifted the backpressure, so transform(), the writes queued behind it, and flush() ran in the reader's async context instead of the writer's. Capture the async context frame when the write parks and restore it while the continuation runs, matching the context the spec's [[backpressureChangePromise]] reaction had. Fixes: https://github.com/nodejs/node/issues/66906 Signed-off-by: Matteo Collina PR-URL: https://github.com/nodejs/node/pull/66907 Backport-PR-URL: https://github.com/nodejs/node/pull/66915 Fixes: https://github.com/nodejs/node/issues/66906 Refs: https://github.com/nodejs/node/issues/66906 Refs: https://github.com/nodejs/node/pull/66907 Reviewed-By: James M Snell --- lib/internal/webstreams/transformstream.js | 60 ++++++++++++++----- ...tream-parked-write-async-context-legacy.js | 60 +++++++++++++++++++ ...nsformstream-parked-write-async-context.js | 58 ++++++++++++++++++ 3 files changed, 162 insertions(+), 16 deletions(-) create mode 100644 test/parallel/test-whatwg-transformstream-parked-write-async-context-legacy.js create mode 100644 test/parallel/test-whatwg-transformstream-parked-write-async-context.js diff --git a/lib/internal/webstreams/transformstream.js b/lib/internal/webstreams/transformstream.js index 81f60b284f5..dbfbd7b6bf5 100644 --- a/lib/internal/webstreams/transformstream.js +++ b/lib/internal/webstreams/transformstream.js @@ -25,6 +25,9 @@ const { DOMException, } = internalBinding('messaging'); +const AsyncContextFrame = require('internal/async_context_frame'); +const { enabledHooksExist } = require('internal/async_hooks'); + const { customInspectSymbol: kInspect, kEmptyObject, @@ -267,6 +270,8 @@ class TransformStreamState { pullPending = false; pendingWriteParked = false; pendingWriteChunk = undefined; + pendingWriteContextFrame = undefined; + pendingWriteResolve = undefined; writeContinuation = undefined; } ObjectSetPrototypeOf(TransformStreamState.prototype, null); @@ -474,7 +479,13 @@ function transformStreamSetBackpressure(stream, backpressure) { state.readable[kState].controller[kState].pullFulfilled); } } else if (state.pendingWriteParked) { - PromisePrototypeThen(kResolvedPromise, state.writeContinuation); + const resolve = state.pendingWriteResolve; + if (resolve !== undefined) { + state.pendingWriteResolve = undefined; + resolve(); + } else { + PromisePrototypeThen(kResolvedPromise, state.writeContinuation); + } } } @@ -626,31 +637,48 @@ function transformStreamDefaultSinkWriteAlgorithm(stream, chunk) { // them before invoking the write algorithm), replacing the promise // record the old code allocated and resolved per parked chunk. The // writable dispatches a single write at a time, so one pending slot - // suffices. + // suffices. The old reaction was registered here, so the continuation + // runs in the async context captured at park time rather than in the + // context of the read that lifts the backpressure. assert(!state.pendingWriteParked); state.pendingWriteParked = true; state.pendingWriteChunk = chunk; + state.pendingWriteContextFrame = AsyncContextFrame.current(); state.writeContinuation ??= () => { const pendingChunk = state.pendingWriteChunk; + const prior = AsyncContextFrame.exchange(state.pendingWriteContextFrame); state.pendingWriteParked = false; state.pendingWriteChunk = undefined; - const writableState = state.writable[kState]; - const writableControllerState = writableState.controller[kState]; - if (writableState.state === 'erroring') { - const error = writableState.storedError; + state.pendingWriteContextFrame = undefined; + try { + const writableState = state.writable[kState]; + const writableControllerState = writableState.controller[kState]; + if (writableState.state === 'erroring') { + const error = writableState.storedError; + PromisePrototypeThen( + kResolvedPromise, + () => writableControllerState.writeRejected(error)); + return; + } + assert(writableState.state === 'writable'); PromisePrototypeThen( - kResolvedPromise, - () => writableControllerState.writeRejected(error)); - return; + transformStreamDefaultControllerPerformTransform( + controller, + pendingChunk), + writableControllerState.writeFulfilled, + writableControllerState.writeRejected); + } finally { + AsyncContextFrame.set(prior); } - assert(writableState.state === 'writable'); - PromisePrototypeThen( - transformStreamDefaultControllerPerformTransform( - controller, - pendingChunk), - writableControllerState.writeFulfilled, - writableControllerState.writeRejected); }; + if (enabledHooksExist()) { + // Async hooks (and the async_hooks-based AsyncLocalStorage) track + // context through promise reactions, so register the continuation + // now, in the writer's context, and resolve it on unpark. + const { promise, resolve } = PromiseWithResolvers(); + state.pendingWriteResolve = resolve; + PromisePrototypeThen(promise, state.writeContinuation); + } return kParkedAlgorithmResult; } return transformStreamDefaultControllerPerformTransform(controller, chunk); diff --git a/test/parallel/test-whatwg-transformstream-parked-write-async-context-legacy.js b/test/parallel/test-whatwg-transformstream-parked-write-async-context-legacy.js new file mode 100644 index 00000000000..1e30ffe3e82 --- /dev/null +++ b/test/parallel/test-whatwg-transformstream-parked-write-async-context-legacy.js @@ -0,0 +1,60 @@ +// Flags: --no-async-context-frame +'use strict'; + +// A write parked on backpressure must run transform() and the writes queued +// behind it in the async context of the writer, not in the context of the +// read that lifts the backpressure. +// This variant covers the async_hooks-based AsyncLocalStorage. +// Refs: https://github.com/nodejs/node/issues/66906 + +const common = require('../common'); +const assert = require('assert'); +const { AsyncLocalStorage } = require('async_hooks'); +const { setImmediate } = require('timers/promises'); + +const als = new AsyncLocalStorage(); + +function createPipeline(seen) { + return new ReadableStream({ + start(controller) { + for (const chunk of 'abc') controller.enqueue(chunk); + controller.close(); + }, + }).pipeThrough(new TransformStream({ + transform(chunk, controller) { + seen.push(`${chunk}:${als.getStore() ?? 'none'}`); + controller.enqueue(chunk); + }, + flush() { + seen.push(`flush:${als.getStore() ?? 'none'}`); + }, + })); +} + +async function consume(readable) { + // eslint-disable-next-line no-unused-vars + for await (const _ of readable); +} + +(async () => { + { + const seen = []; + const readable = als.run('writer', () => createPipeline(seen)); + // Let the pipe park its first write on backpressure. + await setImmediate(); + await consume(readable); + assert.deepStrictEqual(seen, [ + 'a:writer', 'b:writer', 'c:writer', 'flush:writer', + ]); + } + + { + const seen = []; + const readable = createPipeline(seen); + await setImmediate(); + await als.run('reader', () => consume(readable)); + assert.deepStrictEqual(seen, [ + 'a:none', 'b:none', 'c:none', 'flush:none', + ]); + } +})().then(common.mustCall()); diff --git a/test/parallel/test-whatwg-transformstream-parked-write-async-context.js b/test/parallel/test-whatwg-transformstream-parked-write-async-context.js new file mode 100644 index 00000000000..a5db0afdec4 --- /dev/null +++ b/test/parallel/test-whatwg-transformstream-parked-write-async-context.js @@ -0,0 +1,58 @@ +'use strict'; + +// A write parked on backpressure must run transform() and the writes queued +// behind it in the async context of the writer, not in the context of the +// read that lifts the backpressure. +// Refs: https://github.com/nodejs/node/issues/66906 + +const common = require('../common'); +const assert = require('assert'); +const { AsyncLocalStorage } = require('async_hooks'); +const { setImmediate } = require('timers/promises'); + +const als = new AsyncLocalStorage(); + +function createPipeline(seen) { + return new ReadableStream({ + start(controller) { + for (const chunk of 'abc') controller.enqueue(chunk); + controller.close(); + }, + }).pipeThrough(new TransformStream({ + transform(chunk, controller) { + seen.push(`${chunk}:${als.getStore() ?? 'none'}`); + controller.enqueue(chunk); + }, + flush() { + seen.push(`flush:${als.getStore() ?? 'none'}`); + }, + })); +} + +async function consume(readable) { + // eslint-disable-next-line no-unused-vars + for await (const _ of readable); +} + +(async () => { + { + const seen = []; + const readable = als.run('writer', () => createPipeline(seen)); + // Let the pipe park its first write on backpressure. + await setImmediate(); + await consume(readable); + assert.deepStrictEqual(seen, [ + 'a:writer', 'b:writer', 'c:writer', 'flush:writer', + ]); + } + + { + const seen = []; + const readable = createPipeline(seen); + await setImmediate(); + await als.run('reader', () => consume(readable)); + assert.deepStrictEqual(seen, [ + 'a:none', 'b:none', 'c:none', 'flush:none', + ]); + } +})().then(common.mustCall()); From a5709be4e4aded89fbc753a9fd156b94a9969028 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Thu, 12 Nov 2026 16:32:52 +0100 Subject: [PATCH 002/331] Reapply "module: synchronously load most ES modules" MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit e5cae10148877474eb2ba6a02136e90284eb321f. PR-URL: https://github.com/nodejs/node/pull/66786 Refs: https://github.com/nodejs/node/issues/66767 Refs: https://github.com/nodejs/node/pull/62530 Reviewed-By: Richard Lau Reviewed-By: Joyee Cheung Reviewed-By: Matteo Collina Reviewed-By: Filip Skokan Reviewed-By: Gürgün Dayıoğlu --- benchmark/esm/startup-esm-graph.js | 66 ++++++ lib/internal/modules/esm/loader.js | 52 ++++- lib/internal/modules/esm/module_job.js | 198 +++++++++++------- lib/internal/modules/run_main.js | 27 +++ .../test-esm-cjs-named-error-entrypoint.mjs | 21 ++ test/es-module/test-esm-sync-import.mjs | 40 ++++ .../fixtures/es-modules/require-esm-entry.cjs | 1 + .../source_map_assert_no_source_map.snapshot | 6 +- .../test-inspector-debug-brk-flag-esm-tla.js | 46 ++++ 9 files changed, 373 insertions(+), 84 deletions(-) create mode 100644 benchmark/esm/startup-esm-graph.js create mode 100644 test/es-module/test-esm-cjs-named-error-entrypoint.mjs create mode 100644 test/es-module/test-esm-sync-import.mjs create mode 100644 test/fixtures/es-modules/require-esm-entry.cjs create mode 100644 test/parallel/test-inspector-debug-brk-flag-esm-tla.js diff --git a/benchmark/esm/startup-esm-graph.js b/benchmark/esm/startup-esm-graph.js new file mode 100644 index 00000000000..7684ba67f6a --- /dev/null +++ b/benchmark/esm/startup-esm-graph.js @@ -0,0 +1,66 @@ +'use strict'; + +const common = require('../common.js'); +const fs = require('fs'); +const path = require('path'); +const { pathToFileURL } = require('url'); +const tmpdir = require('../../test/common/tmpdir'); + +const BRANCHING_FACTOR = 10; +const benchmarkDirectory = tmpdir.resolve('esm-graph'); + +// Each measured iteration has to load a graph the ESM cache has never seen, so the +// fixture holds one independent copy of the graph per iteration. +function graphDirectory(modules, copy) { + return path.join(benchmarkDirectory, `g${modules}-${copy}`); +} + +function entryURL(modules, copy) { + return pathToFileURL(path.join(graphDirectory(modules, copy), 'mod0.mjs')).href; +} + +// Build a complete BRANCHING_FACTOR-ary tree of `modules` + 1 modules rooted at mod0: +// module i imports modules BRANCHING_FACTOR*i+1 through BRANCHING_FACTOR*i+BRANCHING_FACTOR, +// capped at the total, so the shape approximates a real dependency tree rather than +// one module with hundreds of direct imports. +function createGraph(modules, copy) { + const dir = graphDirectory(modules, copy); + fs.mkdirSync(dir, { recursive: true }); + const total = modules + 1; + for (let i = 0; i < total; i++) { + let source = ''; + for (let c = 1; c <= BRANCHING_FACTOR; c++) { + const child = BRANCHING_FACTOR * i + c; + if (child < total) { + source += `import './mod${child}.mjs';\n`; + } + } + source += `export const value${i} = ${i};\n`; + fs.writeFileSync(path.join(dir, `mod${i}.mjs`), source); + } +} + +const bench = common.createBenchmark(main, { + modules: [250, 500, 1000, 2000], + n: [10], +}, { + setup(configs) { + // Build every fixture once here rather than per configuration: writing tens of + // thousands of files is far more expensive than the work being measured. + tmpdir.refresh(); + const maxN = configs.reduce((max, c) => Math.max(max, c.n), 0); + for (const modules of new Set(configs.map((c) => c.modules))) { + for (let copy = 0; copy < maxN; copy++) { + createGraph(modules, copy); + } + } + }, +}); + +async function main({ n, modules }) { + bench.start(); + for (let i = 0; i < n; i++) { + await import(entryURL(modules, i)); + } + bench.end(n); +} diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js index f92e87785ce..489d8ff91e3 100644 --- a/lib/internal/modules/esm/loader.js +++ b/lib/internal/modules/esm/loader.js @@ -11,6 +11,7 @@ const { PromisePrototypeThen, RegExpPrototypeSymbolReplace, encodeURIComponent, + globalThis, hardenRegExp, } = primordials; @@ -22,6 +23,11 @@ const { kRequiredModuleSymbol, } = require('internal/modules/cjs/loader'); const { imported_cjs_symbol } = internalBinding('symbols'); +const { + privateSymbols: { + entry_point_module_private_symbol, + }, +} = internalBinding('util'); const assert = require('internal/assert'); const { @@ -350,6 +356,39 @@ class ModuleLoader { return { wrap: job.module, namespace: job.runSync(parent).namespace }; } + /** + * Load and evaluate the entry point module. + * The graph is always loaded and linked synchronously. When it contains no top-level + * await it is evaluated synchronously too, so startup creates no promises at all. + * When it does contain top-level await, evaluation falls back to `job.run()` here, + * reusing the job that was just built rather than making the caller re-enter the + * loader and redo the resolution and linking for the same module. + * @param {string} url The URL of the entry point module. + * @returns {ModuleJobSync|undefined} The job still needing asynchronous evaluation when + * the graph has top-level await, otherwise `undefined` - the module is then already + * fully evaluated and no promise was ever created. + */ + importForEntryPoint(url) { + return onImport.traceSync(() => { + const request = { specifier: url, phase: kEvaluationPhase, attributes: kEmptyObject, __proto__: null }; + const job = this.getOrCreateModuleJob(undefined, request, kImportInImportedESM); + job.instantiateSync(); + if (job.module.hasAsyncGraph) { + // Hand the job back so the caller can evaluate it through the ordinary + // asynchronous entry point machinery, without re-resolving and re-linking + // the module the way re-entering `import()` would. + return job; + } + globalThis[entry_point_module_private_symbol] = job.module; + job.runSync(); + return undefined; + }, { + __proto__: null, + parentURL: undefined, + url, + }); + } + /** * Check invariants on a cached module job when require()'d from ESM. * @param {string} specifier The first parameter of require(). @@ -572,10 +611,14 @@ class ModuleLoader { assert(moduleOrModulePromise instanceof ModuleWrap, `Expected ModuleWrap for loading ${url}`); } - // TODO(joyeecheung): use ModuleJobSync for kRequireInImportedCJS too. - const ModuleJobCtor = (requestType === kImportInRequiredESM ? ModuleJobSync : ModuleJob); const isMain = (parentURL === undefined); const inspectBrk = (isMain && getOptionValue('--inspect-brk')); + // Use ModuleJobSync whenever we're on the main thread (not the async loader hook worker), + // except for kRequireInImportedCJS (TODO: consolidate that case too). + // TODO(joyeecheung): use ModuleJobSync for kRequireInImportedCJS too. + const ModuleJobCtor = (this.isForAsyncLoaderHookWorker || + requestType === kRequireInImportedCJS) ? + ModuleJob : ModuleJobSync; job = new ModuleJobCtor( this, url, @@ -602,8 +645,9 @@ class ModuleLoader { */ getOrCreateModuleJob(parentURL, request, requestType) { let maybePromise; - if (requestType === kRequireInImportedCJS || requestType === kImportInRequiredESM) { - // In these two cases, resolution must be synchronous. + if (!this.isForAsyncLoaderHookWorker) { + // On the main thread, always resolve synchronously; + // `resolveSync` coordinates with the async loader hook worker if needed. maybePromise = this.resolveSync(parentURL, request); assert(!isPromise(maybePromise)); } else { diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js index c54706a9e0a..c8506b42ff3 100644 --- a/lib/internal/modules/esm/module_job.js +++ b/lib/internal/modules/esm/module_job.js @@ -54,7 +54,7 @@ const { getSourceMapsSupport, } = require('internal/source_map/source_map_cache'); const assert = require('internal/assert'); -const resolvedPromise = PromiseResolve(); +let resolvedPromise; const { setHasStartedUserESMExecution, urlToFilename, @@ -65,7 +65,6 @@ const { ERR_REQUIRE_ASYNC_MODULE, ERR_REQUIRE_ESM_RACE_CONDITION, } = require('internal/errors').codes; -let hasPausedEntry = false; const CJSGlobalLike = [ 'require', @@ -241,6 +240,58 @@ function getTopLevelAwaitLocations(root) { return locations; } +/** + * If `error` is a SyntaxError from V8 for a missing named export on a CJS module, rewrite its message to the friendlier + * "Named export '...' not found..." form. Must be called after `decorateErrorStack(error)` so that the arrow (source + * context with the import statement text) has been prepended to `error.stack`. + * @param {Error} error + * @param {ModuleWrap} module The parent module that triggered the instantiation. + * @param {boolean[]} commonJsDeps Per-request array indicating whether each dependency is a CJS module, aligned with + * `module.getModuleRequests()`. + */ +const handleCJSNamedExportError = (error, module, commonJsDeps) => { + // TODO(@bcoe): Add source map support to exception that occurs as result + // of missing named export. This is currently not possible because + // stack trace originates in module_job, not the file itself. A hidden + // symbol with filename could be set in node_errors.cc to facilitate this. + if (!getSourceMapsSupport().enabled && + StringPrototypeIncludes(error.message, + ' does not provide an export named')) { + const splitStack = StringPrototypeSplit(error.stack, '\n', 2); + const { 1: childSpecifier, 2: name } = RegExpPrototypeExec( + /module '(.*)' does not provide an export named '(.+)'/, + error.message); + const moduleRequests = module.getModuleRequests(); + let isCommonJS = false; + for (let i = 0; i < moduleRequests.length; ++i) { + if (moduleRequests[i].specifier === childSpecifier) { + isCommonJS = commonJsDeps[i]; + break; + } + } + if (isCommonJS) { + const importStatement = splitStack[1]; + // TODO(@ctavan): The original error stack only provides the single + // line which causes the error. For multi-line import statements we + // cannot generate an equivalent object destructuring assignment by + // just parsing the error stack. + const oneLineNamedImports = RegExpPrototypeExec(/{.*}/, importStatement); + const destructuringAssignment = oneLineNamedImports && + RegExpPrototypeSymbolReplace(/\s+as\s+/g, oneLineNamedImports, ': '); + error.message = `Named export '${name}' not found. The requested module` + + ` '${childSpecifier}' is a CommonJS module, which may not support` + + ' all module.exports as named exports.\nCommonJS modules can ' + + 'always be imported via the default export, for example using:' + + `\n\nimport pkg from '${childSpecifier}';\n${ + destructuringAssignment ? + `const ${destructuringAssignment} = pkg;\n` : ''}`; + const newStack = StringPrototypeSplit(error.stack, '\n'); + newStack[3] = `SyntaxError: ${error.message}`; + error.stack = ArrayPrototypeJoin(newStack, '\n'); + } + } +}; + class ModuleJobBase { constructor(loader, url, importAttributes, phase, isMain, inspectBrk) { assert(typeof phase === 'number'); @@ -455,63 +506,17 @@ class ModuleJob extends ModuleJobBase { await addJobsToDependencyGraph(this); try { - if (!hasPausedEntry && this.inspectBrk) { - hasPausedEntry = true; - const initWrapper = internalBinding('inspector').callAndPauseOnStart; - initWrapper(this.module.instantiate, this.module); - } else { - this.module.instantiate(); - } - } catch (e) { - decorateErrorStack(e); - // TODO(@bcoe): Add source map support to exception that occurs as result - // of missing named export. This is currently not possible because - // stack trace originates in module_job, not the file itself. A hidden - // symbol with filename could be set in node_errors.cc to facilitate this. - if (!getSourceMapsSupport().enabled && - StringPrototypeIncludes(e.message, - ' does not provide an export named')) { - const splitStack = StringPrototypeSplit(e.stack, '\n', 2); - const { 1: childSpecifier, 2: name } = RegExpPrototypeExec( - /module '(.*)' does not provide an export named '(.+)'/, - e.message); - const moduleRequests = this.module.getModuleRequests(); - let isCommonJS = false; - for (let i = 0; i < moduleRequests.length; ++i) { - if (moduleRequests[i].specifier === childSpecifier) { - isCommonJS = this.commonJsDeps[i]; - break; - } - } - - if (isCommonJS) { - const importStatement = splitStack[1]; - // TODO(@ctavan): The original error stack only provides the single - // line which causes the error. For multi-line import statements we - // cannot generate an equivalent object destructuring assignment by - // just parsing the error stack. - const oneLineNamedImports = RegExpPrototypeExec(/{.*}/, importStatement); - const destructuringAssignment = oneLineNamedImports && - RegExpPrototypeSymbolReplace(/\s+as\s+/g, oneLineNamedImports, ': '); - e.message = `Named export '${name}' not found. The requested module` + - ` '${childSpecifier}' is a CommonJS module, which may not support` + - ' all module.exports as named exports.\nCommonJS modules can ' + - 'always be imported via the default export, for example using:' + - `\n\nimport pkg from '${childSpecifier}';\n${ - destructuringAssignment ? - `const ${destructuringAssignment} = pkg;\n` : ''}`; - const newStack = StringPrototypeSplit(e.stack, '\n'); - newStack[3] = `SyntaxError: ${e.message}`; - e.stack = ArrayPrototypeJoin(newStack, '\n'); - } - } - throw e; + this.module.instantiate(); + } catch (error) { + decorateErrorStack(error); + handleCJSNamedExportError(error, this.module, this.commonJsDeps); + throw error; } for (const dependencyJob of jobsInGraph) { // Calling `this.module.instantiate()` instantiates not only the // ModuleWrap in this module, but all modules in the graph. - dependencyJob.instantiated = resolvedPromise; + dependencyJob.instantiated = resolvedPromise ??= PromiseResolve(); } } @@ -577,12 +582,14 @@ class ModuleJob extends ModuleJobBase { /** * This is a fully synchronous job and does not spawn additional threads in any way. - * All the steps are ensured to be synchronous and it throws on instantiating - * an asynchronous graph. It also disallows CJS <-> ESM cycles. + * Loading and linking are always synchronous. Evaluation via runSync() throws on an + * asynchronous graph; evaluation via run() falls back to async for top-level await. + * It also disallows CJS <-> ESM cycles. * - * This is used for ES modules loaded via require(esm). Modules loaded by require() in - * imported CJS are handled by ModuleJob with the isForRequireInImportedCJS set to true instead. - * The two currently have different caching behaviors. + * Used for all ES module imports on the main thread, regardless of how the import was + * triggered (entry point, import(), require(esm), --import, etc.). + * Modules loaded by require() in imported CJS are handled by ModuleJob with the + * isForRequireInImportedCJS set to true instead. The two currently have different caching behaviors. * TODO(joyeecheung): consolidate this with the isForRequireInImportedCJS variant of ModuleJob. */ class ModuleJobSync extends ModuleJobBase { @@ -623,38 +630,76 @@ class ModuleJobSync extends ModuleJobBase { return PromiseResolve(this.module); } - async run() { + instantiateSync() { + try { + this.module.instantiate(); + } catch (error) { + decorateErrorStack(error); + handleCJSNamedExportError(error, this.module, this.commonJsDeps); + throw error; + } + } + + async run(isEntryPoint = false) { assert(this.shouldRunModule(this.phase)); - // This path is hit by a require'd module that is imported again. const status = this.module.getStatus(); debug('ModuleJobSync.run()', status, this.module); // If the module was previously required and errored, reject from import() again. if (status === kErrored) { throw this.module.getError(); - } else if (status > kInstantiated) { + } + if (status > kInstantiated) { + // Already evaluated (e.g. previously require()'d and now import()'d again). if (this.evaluationPromise) { await this.evaluationPromise; } return { __proto__: null, module: this.module }; - } else if (status === kInstantiated || status === kUninstantiated) { - // If we get here, the module was initially required and is now being imported. - // The require() module failed either because the graph has TLA (kInstantiated), - // or instantiation failed (kUninstantiated, e.g. missing named export). - // Try finishing the instantiation - if it succeeds, proceed to evaluation, - // otherwise the branch below re-throw any instantiation error. - if (status === kUninstantiated) { - this.module.instantiate(); - } + } + if (status < kInstantiated) { + // Either a fresh module - links were already resolved synchronously in the constructor - + // or one that was initially require()'d and is now being imported after its instantiation + // failed (e.g. a missing named export). Try finishing the instantiation: if it succeeds, + // proceed to evaluation, otherwise re-throw the instantiation error. + this.instantiateSync(); + } + // `status === kInstantiated`: either just instantiated above, or previously instantiated + // but evaluation was deferred (e.g. TLA detected by a prior `runSync()` call) + if (isEntryPoint) { + globalThis[entry_point_module_private_symbol] = this.module; + } + setHasStartedUserESMExecution(); + if (this.module.hasAsyncGraph) { + // Has top-level `await`: fall back to async evaluation const timeout = -1; const breakOnSigint = false; - this.evaluationPromise = this.module.evaluate(timeout, breakOnSigint); + if (this.inspectBrk) { + const { callAndPauseOnStart } = internalBinding('inspector'); + this.evaluationPromise = callAndPauseOnStart(this.module.evaluate, this.module, timeout, breakOnSigint); + } else { + this.evaluationPromise = this.module.evaluate(timeout, breakOnSigint); + } await this.evaluationPromise; this.evaluationPromise = undefined; return { __proto__: null, module: this.module }; } + // No top-level `await`: evaluate synchronously + try { + this.#evaluateSync(); + } catch (evaluateError) { + explainCommonJSGlobalLikeNotDefinedError(evaluateError, this.module.url, this.module.hasTopLevelAwait); + throw evaluateError; + } + return { __proto__: null, module: this.module }; + } - assert.fail('Unexpected status of a module that is imported again after being required. ' + - `Status = ${status}`); + // Evaluate this module synchronously, pausing at the first line of user land JS + // that runs if --inspect-brk is active - that may well be inside a dependency. + #evaluateSync() { + if (this.inspectBrk) { + const { callAndPauseOnStart } = internalBinding('inspector'); + return callAndPauseOnStart(this.module.evaluateSync, this.module); + } + return this.module.evaluateSync(); } runSync(parent) { @@ -662,15 +707,14 @@ class ModuleJobSync extends ModuleJobBase { assert(this.shouldRunModule(this.phase)); // TODO(joyeecheung): Reject graphs with top-level await _before_ instantiation, so that the // async graph error supersedes instantiation (mismatch export) errors in the graph. - // TODO(joyeecheung): add the error decoration logic from the async instantiate. - this.module.instantiate(); + this.instantiateSync(); // On the deprecated async loader hook worker thread, dependencies linked by an // earlier import may not be walkable synchronously, so double-check with // V8 now that the graph is instantiated. this.throwIfAsyncGraph(parent); setHasStartedUserESMExecution(); try { - const namespace = this.module.evaluateSync(); + const namespace = this.#evaluateSync(); return { __proto__: null, module: this.module, namespace }; } catch (e) { explainCommonJSGlobalLikeNotDefinedError(e, this.module.url, this.module.hasTopLevelAwait); diff --git a/lib/internal/modules/run_main.js b/lib/internal/modules/run_main.js index 87319e6a94c..b0d7d4845ea 100644 --- a/lib/internal/modules/run_main.js +++ b/lib/internal/modules/run_main.js @@ -140,6 +140,8 @@ function runEntryPointWithESMLoader(callback) { * Because of module detection, this function will attempt to run ambiguous (no explicit extension, no * `package.json` type field) entry points as CommonJS first; under certain conditions, it will retry running as ESM. * @param {string} main - First positional CLI argument, such as `'entry.js'` from `node entry.js` + * @returns {Promise|undefined} A promise when the entry point is still being evaluated + * asynchronously because its graph contains top-level await, otherwise `undefined`. */ function executeUserEntryPoint(main = process.argv[1]) { if (getOptionValue('[vfs_load_set]')) { @@ -173,6 +175,31 @@ function executeUserEntryPoint(main = process.argv[1]) { const mainPath = resolvedMain || main; const mainURL = getOptionValue('--entry-url') ? new URL(mainPath, getCWDURL()) : pathToFileURL(mainPath); + // When no async loader hooks or --import are registered, load the entry point + // directly. The graph is loaded and linked synchronously, and evaluated + // synchronously too unless it contains top-level await. + if (getOptionValue('--experimental-loader').length === 0 && + getOptionValue('--import').length === 0) { + const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader(); + const job = cascadedLoader.importForEntryPoint(mainURL.href); + if (job === undefined) { + // Evaluated synchronously; no promise was created at any point. + return; + } + // Top-level await: evaluate through the usual asynchronous entry point path, + // reusing the job that was already resolved, linked and instantiated above. + return runEntryPointWithESMLoader(async () => { + // Begin evaluation inside a microtask, as `import()` does by awaiting the + // module job before running it, so that a top-level await in the entry point + // resumes in the same microtask drain instead of unwinding to the main stack + // and letting the `process.nextTick` queue run first. + await null; + // Await rather than returning the job's promise: resolving a promise *with* a + // thenable performs a `then` lookup on it, which user code can observe. + await job.run(true); + }); + } + runEntryPointWithESMLoader((cascadedLoader) => { // Note that if the graph contains unsettled TLA, this may never resolve // even after the event loop stops running. diff --git a/test/es-module/test-esm-cjs-named-error-entrypoint.mjs b/test/es-module/test-esm-cjs-named-error-entrypoint.mjs new file mode 100644 index 00000000000..e1939934d2c --- /dev/null +++ b/test/es-module/test-esm-cjs-named-error-entrypoint.mjs @@ -0,0 +1,21 @@ +import '../common/index.mjs'; +import { spawnSyncAndAssert } from '../common/child_process.js'; +import * as fixtures from '../common/fixtures.mjs'; +import assert from 'assert'; + +const entryPoint = fixtures.path('es-modules', 'package-cjs-named-error', 'single-quote.mjs'); +spawnSyncAndAssert(process.execPath, [entryPoint], { + status: 1, + stderr(stderr) { + assert(stderr.includes("Named export 'comeOn' not found."), + 'entry point should show the missing named export'); + assert(stderr.includes('CommonJS modules can always be imported via the default export'), + 'entry point should show the CommonJS named export hint'); + assert(stderr.includes("import pkg from './fail.cjs';"), + 'entry point hint should recommend the default import'); + assert(stderr.includes('const { comeOn } = pkg;'), + 'entry point hint should show the named import as destructuring'); + assert(stderr.includes("import { comeOn } from './fail.cjs';"), + 'entry point error should include the source import statement'); + }, +}); diff --git a/test/es-module/test-esm-sync-import.mjs b/test/es-module/test-esm-sync-import.mjs new file mode 100644 index 00000000000..98896649104 --- /dev/null +++ b/test/es-module/test-esm-sync-import.mjs @@ -0,0 +1,40 @@ +// Flags: --no-warnings +import '../common/index.mjs'; +import { spawnSyncAndAssert } from '../common/child_process.js'; +import * as fixtures from '../common/fixtures.mjs'; +import { describe, it } from 'node:test'; +import assert from 'node:assert'; + +// Promise counts are implementation details tracked for regressions, not API guarantees. + +describe('synchronous ESM loading', () => { + it('should create minimal promises for ESM importing ESM', async () => { + const count = getPromiseCount(fixtures.path('es-modules', 'import-esm.mjs')); + assert.strictEqual(count, 1); + }); + + it('should create minimal promises for ESM importing CJS', async () => { + const count = getPromiseCount(fixtures.path('es-modules', 'builtin-imports-case.mjs')); + assert.strictEqual(count, 4); + }); + + it('should fall back to async evaluation for top-level await', async () => { + const count = getPromiseCount(fixtures.path('es-modules', 'tla', 'resolved.mjs')); + assert(count > 1, `Expected TLA fallback to create multiple promises, got ${count}`); + }); + + it('should create minimal promises when entry point is CJS importing ESM', async () => { + const count = getPromiseCount(fixtures.path('es-modules', 'require-esm-entry.cjs')); + assert.strictEqual(count, 1); + }); +}); + +function getPromiseCount(entry) { + const { stderr } = spawnSyncAndAssert(process.execPath, [ + '--trace-promises', + entry, + ], { + stderr: /created promise #/, + }); + return stderr.match(/created promise #/g)?.length ?? 0; +} diff --git a/test/fixtures/es-modules/require-esm-entry.cjs b/test/fixtures/es-modules/require-esm-entry.cjs new file mode 100644 index 00000000000..ce03a24bece --- /dev/null +++ b/test/fixtures/es-modules/require-esm-entry.cjs @@ -0,0 +1 @@ +require('./imported-esm.mjs'); diff --git a/test/fixtures/source-map/output/source_map_assert_no_source_map.snapshot b/test/fixtures/source-map/output/source_map_assert_no_source_map.snapshot index 0a2ea1a45fe..cc9ba484910 100644 --- a/test/fixtures/source-map/output/source_map_assert_no_source_map.snapshot +++ b/test/fixtures/source-map/output/source_map_assert_no_source_map.snapshot @@ -1,6 +1,6 @@ -node:internal/modules/run_main: - triggerUncaughtException( - ^ +node:internal/modules/esm/module_job: + return this.module.evaluateSync(); + ^ AssertionError [ERR_ASSERTION]: The expression evaluated to a falsy value: diff --git a/test/parallel/test-inspector-debug-brk-flag-esm-tla.js b/test/parallel/test-inspector-debug-brk-flag-esm-tla.js new file mode 100644 index 00000000000..b03c2dd25ca --- /dev/null +++ b/test/parallel/test-inspector-debug-brk-flag-esm-tla.js @@ -0,0 +1,46 @@ +'use strict'; +const common = require('../common'); + +// Test that --inspect-brk pauses at the first executable line of an ESM entry +// point that uses top-level await (which takes the async evaluation path). + +common.skipIfInspectorDisabled(); + +const assert = require('assert'); +const fixtures = require('../common/fixtures'); +const { NodeInstance } = require('../common/inspector-helper.js'); + +async function testBreakpointOnStart(session) { + const commands = [ + { 'method': 'Runtime.enable' }, + { 'method': 'Debugger.enable' }, + { 'method': 'Debugger.setPauseOnExceptions', + 'params': { 'state': 'none' } }, + { 'method': 'Debugger.setAsyncCallStackDepth', + 'params': { 'maxDepth': 0 } }, + { 'method': 'Debugger.setBlackboxPatterns', + 'params': { 'patterns': [] } }, + { 'method': 'Runtime.runIfWaitingForDebugger' }, + ]; + + await session.send({ method: 'NodeRuntime.enable' }); + await session.waitForNotification('NodeRuntime.waitingForDebugger'); + await session.send(commands); + await session.send({ method: 'NodeRuntime.disable' }); + // Static import declarations are not executable statements, so the break + // happens at the first executable line (await setTimeout(9), line index 4). + await session.waitForBreakOnLine(4, session.scriptURL()); +} + +async function runTests() { + const child = new NodeInstance(['--inspect-brk=0'], '', + fixtures.path('es-modules', 'esm-top-level-await.mjs')); + const session = await child.connectInspectorSession(); + + await testBreakpointOnStart(session); + await session.runToCompletion(); + + assert.strictEqual((await child.expectShutdown()).exitCode, 0); +} + +runTests().then(common.mustCall()); From 9fc002efd4cad8935d33372c03441b08269c66ee Mon Sep 17 00:00:00 2001 From: Livia Medeiros Date: Wed, 14 Oct 2026 02:55:52 +0800 Subject: [PATCH 003/331] test: skip test failing when run under root Signed-off-by: LiviaMedeiros PR-URL: https://github.com/nodejs/node/pull/66666 Reviewed-By: Xuguang Mei Reviewed-By: Antoine du Hamel Reviewed-By: Luigi Pinca --- test/parallel/test-fs-rmSync-special-char-additional-error.js | 3 +++ 1 file changed, 3 insertions(+) diff --git a/test/parallel/test-fs-rmSync-special-char-additional-error.js b/test/parallel/test-fs-rmSync-special-char-additional-error.js index 9b4de3c84d6..51e925cdc9b 100644 --- a/test/parallel/test-fs-rmSync-special-char-additional-error.js +++ b/test/parallel/test-fs-rmSync-special-char-additional-error.js @@ -6,6 +6,9 @@ const fs = require('node:fs'); const path = require('node:path'); const { execSync } = require('child_process'); +if (!common.isWindows && process.getuid() === 0) + common.skip('running this test as root would ignore directory permissions'); + tmpdir.refresh(); // Prepare a clean temporary directory function countOccurrences(haystack, needle) { From 9ef0b7ad92d952dfcf821f6eb2875409edec46dd Mon Sep 17 00:00:00 2001 From: Chris Swithinbank Date: Tue, 13 Oct 2026 22:17:24 +0200 Subject: [PATCH 004/331] doc: clarify hex code usage in styleText docs Signed-off-by: Chris Swithinbank PR-URL: https://github.com/nodejs/node/pull/66539 Reviewed-By: James M Snell Reviewed-By: Moshe Atlow --- doc/api/util.md | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/doc/api/util.md b/doc/api/util.md index bfc70c6be8f..20d0a35c4b8 100644 --- a/doc/api/util.md +++ b/doc/api/util.md @@ -2818,9 +2818,8 @@ changes: such as NO_COLOR, NODE_DISABLE_COLORS, and FORCE_COLOR. --> -* `format` {string | Array} A text format or an Array - of text formats defined in `util.inspect.colors`, or a hex color in `#RGB` - or `#RRGGBB` form. +* `format` {string | Array} A text format defined in `util.inspect.colors`, + a hex color in `#RGB` or `#RRGGBB` form, or an Array of text formats and/or hex colors. * `text` {string} The text to be formatted. * `options` {Object} * `validateStream` {boolean} When true, `stream` is checked to see if it can handle colors. **Default:** `true`. @@ -2895,6 +2894,9 @@ console.log(styleText('#ff5733', 'Orange text')); // 3-digit hex color (shorthand) console.log(styleText('#f00', 'Red text')); + +// Hex color combined with other modifiers +console.log(styleText(['#00f', 'bold'], 'Bold blue text')); ``` ```cjs @@ -2905,6 +2907,9 @@ console.log(styleText('#ff5733', 'Orange text')); // 3-digit hex color (shorthand) console.log(styleText('#f00', 'Red text')); + +// Hex color combined with other modifiers +console.log(styleText(['#00f', 'bold'], 'Bold blue text')); ``` The full list of formats can be found in [modifiers][]. From bde88e106a7dfc0830664a0cdc10a2fcd939d5c7 Mon Sep 17 00:00:00 2001 From: Nigro Simone Date: Wed, 14 Oct 2026 03:57:03 +0200 Subject: [PATCH 005/331] src: keep ALS store in AsyncResource::MakeCallback AsyncResource saves the async context frame when it is created, and MakeCallback() enters it with async_context_frame::Scope. Then node::MakeCallback() opens the callback scope with an undefined frame, so the callback never runs in the saved one. Since AsyncContextFrame is the default, AsyncLocalStorage loses its store in these callbacks. Pass the saved frame to InternalMakeCallback(), as the Node-API AsyncContext already does. This also removes the Scope from every call, with its two Environment lookups and its global handle. Refs: https://github.com/nodejs/node/pull/66316 Refs: https://github.com/nodejs/node/issues/43038 Refs: https://github.com/nodejs/performance/issues/24 Signed-off-by: Nigro Simone PR-URL: https://github.com/nodejs/node/pull/66326 Reviewed-By: Yagiz Nizipli Reviewed-By: Chengzhong Wu --- benchmark/napi/make_callback/binding.cc | 27 ++++++++++- benchmark/napi/make_callback/index.js | 12 +++-- src/api/async_resource.cc | 46 ++++++++++++------- .../test-async-local-storage.js | 44 ++++++++++++++++++ 4 files changed, 107 insertions(+), 22 deletions(-) create mode 100644 test/addons/async-resource/test-async-local-storage.js diff --git a/benchmark/napi/make_callback/binding.cc b/benchmark/napi/make_callback/binding.cc index 85d335170fb..3a793b6c190 100644 --- a/benchmark/napi/make_callback/binding.cc +++ b/benchmark/napi/make_callback/binding.cc @@ -12,12 +12,19 @@ using v8::Local; using v8::Object; using v8::Value; +// Same order as the types in index.js. +enum Type { kMakeCallback, kAsyncResource, kCall }; + struct State { uv_timer_t timer; Isolate* isolate; int64_t n; + Type type; Global fn; Global done; + node::AsyncResource* resource = nullptr; + + ~State() { delete resource; } }; static void OnTimer(uv_timer_t* handle) { @@ -30,7 +37,17 @@ static void OnTimer(uv_timer_t* handle) { Local recv = context->Global(); for (int64_t i = 0; i < state->n; i++) { HandleScope inner_scope(isolate); - (void)node::MakeCallback(isolate, recv, fn, 0, nullptr, {0, 0}); + switch (state->type) { + case kMakeCallback: + (void)node::MakeCallback(isolate, recv, fn, 0, nullptr, {0, 0}); + break; + case kAsyncResource: + (void)state->resource->MakeCallback(fn, 0, nullptr); + break; + case kCall: + (void)fn->Call(context, recv, 0, nullptr); + break; + } } Local done = state->done.Get(isolate); (void)node::MakeCallback(isolate, recv, done, 0, nullptr, {0, 0}); @@ -38,7 +55,7 @@ static void OnTimer(uv_timer_t* handle) { [](uv_handle_t* h) { delete static_cast(h->data); }); } -// run(n, fn, done): calls fn n times from a timer, then calls done. +// run(n, fn, done, type): calls fn n times from a timer, then calls done. static void Run(const FunctionCallbackInfo& args) { Isolate* isolate = args.GetIsolate(); State* state = new State; @@ -46,6 +63,12 @@ static void Run(const FunctionCallbackInfo& args) { state->n = args[0]->IntegerValue(isolate->GetCurrentContext()).FromJust(); state->fn.Reset(isolate, args[1].As()); state->done.Reset(isolate, args[2].As()); + state->type = static_cast( + args[3]->Int32Value(isolate->GetCurrentContext()).FromJust()); + if (state->type == kAsyncResource) { + state->resource = + new node::AsyncResource(isolate, Object::New(isolate), "Benchmark"); + } state->timer.data = state; uv_timer_init(node::GetCurrentEventLoop(isolate), &state->timer); uv_timer_start(&state->timer, OnTimer, 0, 0); diff --git a/benchmark/napi/make_callback/index.js b/benchmark/napi/make_callback/index.js index 8c3dba38343..37e76788be7 100644 --- a/benchmark/napi/make_callback/index.js +++ b/benchmark/napi/make_callback/index.js @@ -2,8 +2,9 @@ const common = require('../../common.js'); -// The addon calls into JS with node::MakeCallback from a libuv timer, so -// every call opens a top-level callback scope, like an I/O callback does. +// The addon calls into JS from a libuv timer, so every call opens a top-level +// callback scope, like an I/O callback does. type=Call is a plain +// v8::Function::Call, what the call costs without Node. let binding; try { @@ -13,11 +14,14 @@ try { process.exit(0); } +const types = ['MakeCallback', 'AsyncResource', 'Call']; + const bench = common.createBenchmark(main, { + type: types, n: [1e6, 1e7], }); -function main({ n }) { +function main({ type, n }) { bench.start(); - binding.run(n, () => {}, () => bench.end(n)); + binding.run(n, () => {}, () => bench.end(n), types.indexOf(type)); } diff --git a/src/api/async_resource.cc b/src/api/async_resource.cc index 621fca4ba4d..0cbf2f8e9ff 100644 --- a/src/api/async_resource.cc +++ b/src/api/async_resource.cc @@ -1,6 +1,7 @@ #include "async_context_frame.h" #include "env-inl.h" #include "node.h" +#include "node_internals.h" namespace node { @@ -10,6 +11,7 @@ using v8::Local; using v8::MaybeLocal; using v8::Object; using v8::String; +using v8::Undefined; using v8::Value; AsyncResource::AsyncResource(Isolate* isolate, @@ -39,33 +41,45 @@ MaybeLocal AsyncResource::MakeCallback(Local callback, int argc, Local* argv) { auto isolate = env_->isolate(); - async_context_frame::Scope async_context_frame_scope( - isolate, context_frame_.Get(isolate)); - - return node::MakeCallback( - isolate, get_resource(), callback, argc, argv, async_context_); + // As in Node-API: node::MakeCallback() would run it with no frame. + return InternalMakeCallback(isolate, + get_resource(), + callback, + argc, + argv, + async_context_, + context_frame_.Get(isolate)); } MaybeLocal AsyncResource::MakeCallback(const char* method, int argc, Local* argv) { - auto isolate = env_->isolate(); - async_context_frame::Scope async_context_frame_scope( - isolate, context_frame_.Get(isolate)); - - return node::MakeCallback( - isolate, get_resource(), method, argc, argv, async_context_); + Local method_string; + if (!String::NewFromUtf8(env_->isolate(), method).ToLocal(&method_string)) { + return {}; + } + return MakeCallback(method_string, argc, argv); } MaybeLocal AsyncResource::MakeCallback(Local symbol, int argc, Local* argv) { auto isolate = env_->isolate(); - async_context_frame::Scope async_context_frame_scope( - isolate, context_frame_.Get(isolate)); - - return node::MakeCallback( - isolate, get_resource(), symbol, argc, argv, async_context_); + // Check can_call_into_js() first because calling Get() might do so. + if (!env_->can_call_into_js()) return {}; + Local callback; + { + // A getter runs in the saved frame too, so what it enters stays there. + async_context_frame::Scope async_context_frame_scope( + isolate, context_frame_.Get(isolate)); + if (!get_resource() + ->Get(isolate->GetCurrentContext(), symbol) + .ToLocal(&callback)) { + return {}; + } + } + if (!callback->IsFunction()) return Undefined(isolate); + return MakeCallback(callback.As(), argc, argv); } Local AsyncResource::get_resource() { diff --git a/test/addons/async-resource/test-async-local-storage.js b/test/addons/async-resource/test-async-local-storage.js new file mode 100644 index 00000000000..76b813fab5b --- /dev/null +++ b/test/addons/async-resource/test-async-local-storage.js @@ -0,0 +1,44 @@ +'use strict'; + +const common = require('../../common'); +const assert = require('assert'); +const { AsyncLocalStorage } = require('async_hooks'); +const binding = require(`./build/${common.buildType}/binding`); + +// AsyncResource::MakeCallback() must run the callback in the async context +// frame that was active when the resource was created. + +const als = new AsyncLocalStorage(); +const object = { + 'methöd': common.mustCall(() => { + assert.strictEqual(als.getStore(), 'store'); + }, 3), +}; +const resource = als.run('store', () => binding.createAsyncResource(object)); + +binding.callViaFunction(resource); +binding.callViaString(resource); +binding.callViaUtf8Name(resource); +binding.destroyAsyncResource(resource); + +// A getter of the method runs in that frame too, and what it enters stays +// there. +{ + let getterStore; + const object = Object.defineProperty({}, 'methöd', { + get: common.mustCall(() => { + getterStore = als.getStore(); + als.enterWith('getter'); + return common.mustCall(); + }), + }); + const resource = + als.run('resource', () => binding.createAsyncResource(object)); + let callerStore; + als.run('caller', () => { + binding.callViaString(resource); + callerStore = als.getStore(); + }); + binding.destroyAsyncResource(resource); + assert.deepStrictEqual([getterStore, callerStore], ['resource', 'caller']); +} From be145b610b087ddc733a928f16f70d17e547ee87 Mon Sep 17 00:00:00 2001 From: Roberto Bianchi Date: Wed, 14 Oct 2026 10:51:58 +0200 Subject: [PATCH 006/331] url: reduce search params sort buffering MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit URLSearchParams.sort() copies both merge runs into temporary arrays. Buffer only the left run and read the right run from the output array, removing one scratch-array allocation and the right-run copying. While left-side elements remain, the output cursor stays behind unread right-side elements. Once the left run is exhausted, the right remainder is already in place. Taking the left key on equality preserves stability. The insertion-sort path below 50 pairs is unchanged. Signed-off-by: Roberto Bianchi PR-URL: https://github.com/nodejs/node/pull/66665 Reviewed-By: Xuguang Mei Reviewed-By: Matteo Collina Reviewed-By: Ilyas Shabi Reviewed-By: Gürgün Dayıoğlu --- .../url/url-searchparams-sort-scaling.js | 43 +++++++++++++++ lib/internal/url.js | 40 ++++++-------- ...test-whatwg-url-searchparams-sort-merge.js | 54 +++++++++++++++++++ 3 files changed, 113 insertions(+), 24 deletions(-) create mode 100644 benchmark/url/url-searchparams-sort-scaling.js create mode 100644 test/parallel/test-whatwg-url-searchparams-sort-merge.js diff --git a/benchmark/url/url-searchparams-sort-scaling.js b/benchmark/url/url-searchparams-sort-scaling.js new file mode 100644 index 00000000000..ae1873faf60 --- /dev/null +++ b/benchmark/url/url-searchparams-sort-scaling.js @@ -0,0 +1,43 @@ +'use strict'; + +const common = require('../common.js'); +const assert = require('node:assert'); + +const bench = common.createBenchmark(main, { + n: [1e4], + size: [49, 50, 65, 256, 1024], + order: ['sorted', 'reversed', 'shuffled', 'duplicates'], +}); + +function main({ n, size, order }) { + const entries = Array.from({ length: size }, (_, index) => [ + `key-${String(order === 'duplicates' ? index % 7 : index).padStart(8, '0')}`, + String(index), + ]); + if (order === 'reversed') { + entries.reverse(); + } else if (order === 'shuffled') { + let seed = 12345; + for (let index = entries.length - 1; index > 0; index--) { + seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0; + const other = seed % (index + 1); + [entries[index], entries[other]] = [entries[other], entries[index]]; + } + } + const base = new URLSearchParams(entries); + const expected = entries.slice().sort(([first], [second]) => + (first < second ? -1 : first > second ? 1 : 0)); + + for (let index = 0; index < 1000; index++) { + new URLSearchParams(base).sort(); + } + let result; + bench.start(); + for (let index = 0; index < n; index++) { + result = new URLSearchParams(base); + result.sort(); + } + bench.end(n); + assert.deepStrictEqual([...result], expected); + assert.deepStrictEqual([...base], entries); +} diff --git a/lib/internal/url.js b/lib/internal/url.js index 471df4db439..c97295d4d69 100644 --- a/lib/internal/url.js +++ b/lib/internal/url.js @@ -738,7 +738,6 @@ class URLSearchParams { } else { // Bottom-up iterative stable merge sort const lBuffer = new Array(len); - const rBuffer = new Array(len); for (let step = 2; step < len; step *= 2) { for (let start = 0; start < len - 2; start += 2 * step) { const mid = start + step; @@ -746,7 +745,7 @@ class URLSearchParams { end = end < len ? end : len; if (mid > end) continue; - merge(a, start, mid, end, lBuffer, rBuffer); + merge(a, start, mid, end, lBuffer); } } } @@ -1428,32 +1427,25 @@ function serializeParams(array) { } // for merge sort -function merge(out, start, mid, end, lBuffer, rBuffer) { +function merge(out, start, mid, end, lBuffer) { const sizeLeft = mid - start; - const sizeRight = end - mid; - let l, r, o; - - for (l = 0; l < sizeLeft; l++) - lBuffer[l] = out[start + l]; - for (r = 0; r < sizeRight; r++) - rBuffer[r] = out[mid + r]; - - l = 0; - r = 0; - o = start; - while (l < sizeLeft && r < sizeRight) { - if (lBuffer[l] <= rBuffer[r]) { - out[o++] = lBuffer[l++]; - out[o++] = lBuffer[l++]; + for (let index = 0; index < sizeLeft; index++) + lBuffer[index] = out[start + index]; + + let left = 0; + let right = mid; + let output = start; + while (left < sizeLeft && right < end) { + if (lBuffer[left] <= out[right]) { + out[output++] = lBuffer[left++]; + out[output++] = lBuffer[left++]; } else { - out[o++] = rBuffer[r++]; - out[o++] = rBuffer[r++]; + out[output++] = out[right++]; + out[output++] = out[right++]; } } - while (l < sizeLeft) - out[o++] = lBuffer[l++]; - while (r < sizeRight) - out[o++] = rBuffer[r++]; + while (left < sizeLeft) + out[output++] = lBuffer[left++]; } function domainToASCII(domain) { diff --git a/test/parallel/test-whatwg-url-searchparams-sort-merge.js b/test/parallel/test-whatwg-url-searchparams-sort-merge.js new file mode 100644 index 00000000000..4f0a7690486 --- /dev/null +++ b/test/parallel/test-whatwg-url-searchparams-sort-merge.js @@ -0,0 +1,54 @@ +'use strict'; + +require('../common'); +const assert = require('node:assert'); + +for (const size of [0, 1, 2, 49, 50, 51, 63, 64, 65, 127, 128, 129, + 255, 256, 257, 1023, 1024, 1025]) { + const ascending = Array.from({ length: size }, (_, index) => [ + String(index).padStart(8, '0'), String(index), + ]); + const descending = ascending.slice().reverse(); + const duplicates = ascending.map(([, value], index) => [ + String(index % 7), value, + ]); + const shuffled = ascending.slice(); + let seed = 12345; + for (let index = size - 1; index > 0; index--) { + seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0; + const other = seed % (index + 1); + [shuffled[index], shuffled[other]] = [shuffled[other], shuffled[index]]; + } + + for (const entries of [ascending, descending, duplicates, shuffled]) { + const expected = entries.slice().sort(([first], [second]) => + (first < second ? -1 : first > second ? 1 : 0)); + const params = new URLSearchParams(entries); + const iterator = params.entries(); + params.toString(); + assert.strictEqual(params.sort(), undefined); + assert.deepStrictEqual([...params], expected); + assert.deepStrictEqual([...iterator], expected); + assert.strictEqual(params.size, size); + assert.strictEqual(params.toString(), new URLSearchParams(expected).toString()); + params.sort(); + assert.deepStrictEqual([...params], expected); + } +} + +{ + const entries = Array.from({ length: 65 }, (_, index) => [ + ['\u00e9', 'e\u0301', '\ud83d\ude00', '\uffff', ''][index % 5], + `value ${index}`, + ]); + const expected = entries.slice().sort(([first], [second]) => + (first < second ? -1 : first > second ? 1 : 0)); + const url = new URL('https://example.org/'); + for (const [name, value] of entries) url.searchParams.append(name, value); + assert.strictEqual(url.search, `?${new URLSearchParams(entries)}`); + const params = url.searchParams; + params.sort(); + assert.strictEqual(url.searchParams, params); + assert.deepStrictEqual([...params], expected); + assert.strictEqual(url.search, `?${new URLSearchParams(expected)}`); +} From 8da7c4f4c68038b340208167042b675fc0106cee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guilherme=20Ara=C3=BAjo?= Date: Wed, 14 Oct 2026 15:50:29 -0300 Subject: [PATCH 007/331] sqlite: use shared-shape objects for result rows MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `all()`, `get()` and `iterate()` built each row with the `Object::New()` overload that takes names and values. That overload always returns a dictionary-mode object, so no two rows shared a map and every property read was a hash lookup. Build rows from a `DictionaryTemplate` cached on the statement in place of the column names, invalidated on re-prepare. Rows keep their null prototype. Statements whose column names a template cannot express (array indices, duplicates, non-ASCII names, which the template interns as Latin-1) or with more than 64 columns keep the previous path. Add a benchmark that reads every column of each row, since the existing ones only measure building rows. Fixes: https://github.com/nodejs/node/issues/65799 Assisted-by: Claude Signed-off-by: Guilherme Araújo PR-URL: https://github.com/nodejs/node/pull/66385 Reviewed-By: Trivikram Kamat Reviewed-By: Matteo Collina --- .../sqlite/sqlite-prepare-select-read.js | 44 ++++++ src/node_sqlite.cc | 132 +++++++++++------- src/node_sqlite.h | 6 +- .../test-sqlite-statement-row-shape.js | 79 +++++++++++ 4 files changed, 207 insertions(+), 54 deletions(-) create mode 100644 benchmark/sqlite/sqlite-prepare-select-read.js create mode 100644 test/parallel/test-sqlite-statement-row-shape.js diff --git a/benchmark/sqlite/sqlite-prepare-select-read.js b/benchmark/sqlite/sqlite-prepare-select-read.js new file mode 100644 index 00000000000..63d8a506838 --- /dev/null +++ b/benchmark/sqlite/sqlite-prepare-select-read.js @@ -0,0 +1,44 @@ +'use strict'; +const common = require('../common.js'); +const sqlite = require('node:sqlite'); +const assert = require('assert'); + +const bench = common.createBenchmark(main, { + n: [1e4], + rows: [1, 100], + method: ['all', 'iterate', 'get'], + returnArrays: [0, 1], +}); + +function main(conf) { + const db = new sqlite.Database(':memory:'); + db.exec( + 'CREATE TABLE foo (text_column TEXT, integer_column INTEGER, real_column REAL, blob_column BLOB)', + ); + const insert = db.prepare('INSERT INTO foo VALUES (?, ?, ?, ?)'); + for (let i = 0; i < conf.rows; i++) { + insert.run(`text ${i}`, i, i / 3, Buffer.from('example blob data')); + } + + const stmt = db.prepare(`SELECT * FROM foo LIMIT ${conf.rows}`); + stmt.setReturnArrays(conf.returnArrays === 1); + + // Each row is built and then has every column read once. + const read = conf.returnArrays ? + (row) => row[0].length + row[1] + row[2] + row[3].length : + (row) => row.text_column.length + row.integer_column + + row.real_column + row.blob_column.length; + + let sum = 0; + bench.start(); + for (let i = 0; i < conf.n; i++) { + if (conf.method === 'get') { + sum += read(stmt.get()); + } else { + for (const row of stmt[conf.method]()) sum += read(row); + } + } + bench.end(conf.n); + + assert.ok(sum > 0); +} diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index 6ad797a520c..028794eada9 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -22,6 +22,7 @@ #include #include #include +#include namespace node { namespace sqlite { @@ -3812,6 +3813,7 @@ void Statement::Finalize() { void Statement::InvalidateColumnNameCache() { cached_column_names_.clear(); + cached_row_template_.Reset(); cached_column_names_reprepare_count_ = -1; } @@ -4033,37 +4035,79 @@ MaybeLocal Statement::ColumnNameToName(const int column) { .As(); } -// Populates `keys` with cached column names, rebuilding the cache if the -// statement was re-prepared. -bool Statement::GetCachedColumnNames(LocalVector* keys) { - Isolate* isolate = env()->isolate(); +// Size of the stack array RowToObject passes to the template. +static constexpr int kMaxRowTemplateColumns = 64; + +// Templates read names as Latin-1 and reject indices and duplicates. +static bool CanUseInRowTemplate(Local context, + Local key, + std::string_view name, + const std::vector& seen) { + return simdutf::validate_ascii(name.data(), name.size()) && + std::find(seen.begin(), seen.end(), name) == seen.end() && + key->ToArrayIndex(context).IsEmpty(); +} +// Fills either cached_row_template_ or cached_column_names_. +bool Statement::UpdateRowCache() { const int reprepare_count = sqlite3_stmt_status(statement_.get(), SQLITE_STMTSTATUS_REPREPARE, false); - if (reprepare_count != cached_column_names_reprepare_count_) { - cached_column_names_.clear(); - const int num_cols = sqlite3_column_count(statement_.get()); - if (num_cols == 0) { - cached_column_names_reprepare_count_ = reprepare_count; - return true; - } + if (reprepare_count == cached_column_names_reprepare_count_) return true; + + InvalidateColumnNameCache(); + Isolate* isolate = env()->isolate(); + Local context = env()->context(); + const int num_cols = sqlite3_column_count(statement_.get()); + LocalVector keys(isolate); + std::vector names; + keys.reserve(num_cols); + names.reserve(num_cols); + bool use_template = num_cols <= kMaxRowTemplateColumns; + for (int i = 0; i < num_cols; ++i) { + Local key; + if (!ColumnNameToName(i).ToLocal(&key)) return false; + std::string_view name = sqlite3_column_name(statement_.get(), i); + use_template = + use_template && CanUseInRowTemplate(context, key, name, names); + keys.push_back(key); + names.push_back(name); + } + + if (use_template) { + cached_row_template_.Reset( + isolate, + DictionaryTemplate::New(isolate, {names.data(), names.size()})); + } else { cached_column_names_.reserve(num_cols); - for (int i = 0; i < num_cols; ++i) { - Local key; - if (!ColumnNameToName(i).ToLocal(&key)) { - InvalidateColumnNameCache(); - return false; - } - cached_column_names_.emplace_back(Global(isolate, key)); + for (Local key : keys) { + cached_column_names_.emplace_back(isolate, key); } - cached_column_names_reprepare_count_ = reprepare_count; } + cached_column_names_reprepare_count_ = reprepare_count; + return true; +} - keys->reserve(cached_column_names_.size()); - for (const auto& name : cached_column_names_) { - keys->emplace_back(name.Get(isolate)); +MaybeLocal Statement::RowToObject(LocalVector* values) { + DCHECK_EQ( + sqlite3_stmt_status(statement_.get(), SQLITE_STMTSTATUS_REPREPARE, false), + cached_column_names_reprepare_count_); + Isolate* isolate = env()->isolate(); + if (cached_row_template_.IsEmpty()) { + LocalVector keys(isolate); + keys.reserve(cached_column_names_.size()); + for (const auto& name : cached_column_names_) { + keys.emplace_back(name.Get(isolate)); + } + DCHECK_EQ(keys.size(), values->size()); + return Object::New( + isolate, Null(isolate), keys.data(), values->data(), keys.size()); } - return true; + DCHECK_LE(values->size(), kMaxRowTemplateColumns); + MaybeLocal template_values[kMaxRowTemplateColumns]; + std::copy(values->begin(), values->end(), template_values); + return NewDictionaryInstanceNullProto(env()->context(), + cached_row_template_.Get(isolate), + {template_values, values->size()}); } MaybeLocal StatementExecutionHelper::ColumnToValue(Environment* env, @@ -4108,12 +4152,14 @@ MaybeLocal StatementExecutionHelper::All(Environment* env, int num_cols = 0; LocalVector rows(isolate); LocalVector row_values(isolate); - LocalVector row_keys(isolate); SteppingStatementGuard stepping(db, stmt); while ((r = sqlite3_step(stmt)) == SQLITE_ROW) { if (num_cols == 0) { num_cols = sqlite3_column_count(stmt); + if (!return_arrays && !statement->UpdateRowCache()) { + return MaybeLocal(); + } } if (ExtractRowValues(env, stmt, num_cols, use_big_ints, &row_values) @@ -4126,16 +4172,10 @@ MaybeLocal StatementExecutionHelper::All(Environment* env, Array::New(isolate, row_values.data(), row_values.size()); rows.emplace_back(row_array); } else { - if (row_keys.size() == 0) { - // Reuses the statement's internalized column names instead of - // re-interning them on every call. - if (!statement->GetCachedColumnNames(&row_keys)) { - return MaybeLocal(); - } + Local row_obj; + if (!statement->RowToObject(&row_values).ToLocal(&row_obj)) { + return MaybeLocal(); } - DCHECK_EQ(row_keys.size(), row_values.size()); - Local row_obj = Object::New( - isolate, Null(isolate), row_keys.data(), row_values.data(), num_cols); rows.emplace_back(row_obj); } } @@ -4272,17 +4312,9 @@ MaybeLocal StatementExecutionHelper::Get(Environment* env, Local result; if (return_arrays) { result = Array::New(isolate, row_values.data(), row_values.size()); - } else { - LocalVector keys(isolate); - // Reuses the statement's internalized column names instead of - // re-interning them on every call. - if (!statement->GetCachedColumnNames(&keys)) { - return MaybeLocal(); - } - - DCHECK_EQ(keys.size(), row_values.size()); - result = Object::New( - isolate, Null(isolate), keys.data(), row_values.data(), num_cols); + } else if (!statement->UpdateRowCache() || + !statement->RowToObject(&row_values).ToLocal(&result)) { + return MaybeLocal(); } RESET_AND_CHECK(isolate, db, stmt, needs_reset, MaybeLocal()); @@ -5083,7 +5115,6 @@ void StatementIterator::Next(const FunctionCallbackInfo& args) { int num_cols = sqlite3_column_count(iter->stmt_->statement_.get()); Local row_value; - LocalVector row_keys(isolate); LocalVector row_values(isolate); if (ExtractRowValues(env, @@ -5097,14 +5128,9 @@ void StatementIterator::Next(const FunctionCallbackInfo& args) { if (iter->stmt_->return_arrays_) { row_value = Array::New(isolate, row_values.data(), row_values.size()); - } else { - // Use cached internalized column names to avoid repeated V8 string - // creation and enable hidden class sharing across row objects. - if (!iter->stmt_->GetCachedColumnNames(&row_keys)) return; - - DCHECK_EQ(row_keys.size(), row_values.size()); - row_value = Object::New( - isolate, Null(isolate), row_keys.data(), row_values.data(), num_cols); + } else if (!iter->stmt_->UpdateRowCache() || + !iter->stmt_->RowToObject(&row_values).ToLocal(&row_value)) { + return; } MaybeLocal values[] = {Boolean::New(isolate, false), row_value}; diff --git a/src/node_sqlite.h b/src/node_sqlite.h index 98f9beabe8f..6a51dbffaf3 100644 --- a/src/node_sqlite.h +++ b/src/node_sqlite.h @@ -397,7 +397,9 @@ class Statement : public BaseObject { static void Dispose(const v8::FunctionCallbackInfo& args); v8::MaybeLocal ColumnToValue(const int column); v8::MaybeLocal ColumnNameToName(const int column); - bool GetCachedColumnNames(v8::LocalVector* keys); + // Call after sqlite3_step(), which may re-prepare, and before RowToObject. + bool UpdateRowCache(); + v8::MaybeLocal RowToObject(v8::LocalVector* values); void Finalize(); bool IsFinalized(); @@ -418,6 +420,8 @@ class Statement : public BaseObject { inline int ResetStatement(); std::vector> cached_column_names_; int cached_column_names_reprepare_count_ = -1; + // Set instead of cached_column_names_ when the names fit a template. + v8::Global cached_row_template_; void InvalidateColumnNameCache(); bool BindParams(const v8::FunctionCallbackInfo& args); bool BindValue(const v8::Local& value, const int index); diff --git a/test/parallel/test-sqlite-statement-row-shape.js b/test/parallel/test-sqlite-statement-row-shape.js new file mode 100644 index 00000000000..2799aba799f --- /dev/null +++ b/test/parallel/test-sqlite-statement-row-shape.js @@ -0,0 +1,79 @@ +// Flags: --allow-natives-syntax +'use strict'; +const { skipIfSQLiteMissing } = require('../common'); +skipIfSQLiteMissing(); +const assert = require('node:assert'); +const { Database } = require('node:sqlite'); +const { suite, test } = require('node:test'); + +function assertSharedShape(rows) { + for (const row of rows) { + assert.strictEqual(Object.getPrototypeOf(row), null); + assert(eval('%HasFastProperties(row)')); + assert(eval('%HaveSameMap(row, rows[0])')); + } +} + +suite('result row objects', () => { + const db = new Database(':memory:'); + db.exec('CREATE TABLE t (a INTEGER, b TEXT, c REAL)'); + const insert = db.prepare('INSERT INTO t VALUES (?, ?, ?)'); + insert.run(1, 'x', 1.5); + insert.run(2, 'y', 2.5); + insert.run(3, null, null); + + test('all() rows share a fast map', () => { + const rows = db.prepare('SELECT * FROM t ORDER BY a').all(); + assert.deepStrictEqual(rows, [ + { __proto__: null, a: 1, b: 'x', c: 1.5 }, + { __proto__: null, a: 2, b: 'y', c: 2.5 }, + { __proto__: null, a: 3, b: null, c: null }, + ]); + assertSharedShape(rows); + }); + + test('get() rows share a fast map', () => { + const stmt = db.prepare('SELECT * FROM t WHERE a = ?'); + assertSharedShape([stmt.get(1), stmt.get(2), stmt.get(3)]); + }); + + test('iterate() rows share a fast map', () => { + assertSharedShape(db.prepare('SELECT * FROM t ORDER BY a').iterate().toArray()); + }); + + test('a re-prepared statement picks up the new columns', () => { + using db = new Database(':memory:'); + db.exec('CREATE TABLE s (a INTEGER)'); + db.exec('INSERT INTO s VALUES (1)'); + const stmt = db.prepare('SELECT * FROM s'); + assert.deepStrictEqual(stmt.get(), { __proto__: null, a: 1 }); + db.exec('ALTER TABLE s ADD COLUMN b INTEGER DEFAULT 2'); + assert.deepStrictEqual(stmt.get(), { __proto__: null, a: 1, b: 2 }); + }); + + test('array-index column names', () => { + const stmt = db.prepare('SELECT 1 AS "0", 2 AS b'); + assert.deepStrictEqual(stmt.get(), { __proto__: null, 0: 1, b: 2 }); + assert.deepStrictEqual(stmt.all(), [{ __proto__: null, 0: 1, b: 2 }]); + }); + + test('duplicate column names keep the last value', () => { + const stmt = db.prepare('SELECT 1 AS a, 2 AS a'); + assert.deepStrictEqual(stmt.get(), { __proto__: null, a: 2 }); + assert.deepStrictEqual(stmt.iterate().toArray(), + [{ __proto__: null, a: 2 }]); + }); + + test('non-ASCII column names', () => { + const row = db.prepare('SELECT 1 AS "café", 2 AS "名前"').get(); + assert.deepStrictEqual(row, { __proto__: null, café: 1, 名前: 2 }); + }); + + test('rows wider than the template limit', () => { + const cols = Array.from({ length: 100 }, (_, i) => `${i} AS c${i}`); + const row = db.prepare(`SELECT ${cols.join(', ')}`).get(); + const expected = { __proto__: null }; + for (let i = 0; i < 100; i++) expected[`c${i}`] = i; + assert.deepStrictEqual(row, expected); + }); +}); From 1a6d5e03655415b901e87eb59268a88f837faa6e Mon Sep 17 00:00:00 2001 From: Kisnner Obando Date: Wed, 14 Oct 2026 13:49:23 -0600 Subject: [PATCH 008/331] doc: correct QuicStream direction and id types Signed-off-by: Kisnner Obando PR-URL: https://github.com/nodejs/node/pull/66687 Reviewed-By: James M Snell Reviewed-By: Tim Perry --- doc/api/quic.md | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/doc/api/quic.md b/doc/api/quic.md index 37f75adbdd8..f331649ff6e 100644 --- a/doc/api/quic.md +++ b/doc/api/quic.md @@ -2049,10 +2049,9 @@ side, it is always `false`. added: v23.8.0 --> -* Type: {string|null} One of `'bidi'`, `'uni'`, or `null`. +* Type: {string} One of `'bidi'` or `'uni'`. -The directionality of the stream, or `null` if the stream has been destroyed -or is still pending. Read only. +The directionality of the stream. Read only. ### `stream.budget` @@ -2079,8 +2078,7 @@ added: v23.8.0 * Type: {bigint|null} -The stream ID, or `null` if the stream has been destroyed or is still -pending. Read only. +The stream ID, or `null` while the stream is pending. Read only. ### `stream.onerror` From 57231f2c7c40bdaa70f4022365f42f7d604aa832 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Wed, 14 Oct 2026 17:09:57 -0400 Subject: [PATCH 009/331] test: update WPT for WebCryptoAPI to b638c093cd PR-URL: https://github.com/nodejs/node/pull/66689 Reviewed-By: Filip Skokan Reviewed-By: Daeyeon Jeong Reviewed-By: Colin Ihrig Reviewed-By: Luigi Pinca --- test/fixtures/wpt/WebCryptoAPI/README.md | 19 +- .../failures_AES-OCB.tentative.https.any.js | 6 - .../failures_Ed448.tentative.https.any.js | 6 - .../failures_ML-DSA.tentative.https.any.js | 6 - .../failures_ML-KEM.tentative.https.any.js | 6 - .../failures_X448.tentative.https.any.js | 6 - ...s_chacha20_poly1305.tentative.https.any.js | 6 - .../failures_kmac.tentative.https.any.js | 6 - ...okp_importKey_Ed448.tentative.https.any.js | 10 - .../okp_importKey_X448.tentative.https.any.js | 10 - ...tKey_failures_Ed448.tentative.https.any.js | 9 - ...rtKey_failures_X448.tentative.https.any.js | 9 - .../wpt/WebCryptoAPI/modern-algos/META.yml | 1 + .../derive_bits_keys/argon2.https.any.js} | 2 +- .../derive_bits_keys/argon2.js | 0 .../derive_bits_keys/argon2_vectors.js | 0 .../digest/cshake.https.any.js} | 6 +- .../digest/kangarootwelve.https.any.js} | 2 +- .../digest/sha3.https.any.js} | 6 +- .../digest/turboshake.https.any.js} | 2 +- .../{ => modern-algos}/digest/xof_digest.js | 0 .../encap_decap_bits.https.any.js} | 2 +- .../encap_decap_keys.https.any.js} | 2 +- .../encap_decap/hybrid_kem_vectors.js | 0 .../encap_decap/ml_kem_vectors.js | 0 .../encrypt_decrypt/aes_ocb.https.any.js} | 6 +- .../encrypt_decrypt/aes_ocb_fixtures.js | 0 .../encrypt_decrypt/aes_ocb_vectors.js | 0 .../chacha20_poly1305.https.any.js} | 2 +- .../generateKey/failures_AES-OCB.https.any.js | 6 + .../failures_Hybrid-KEM.https.any.js} | 6 +- .../generateKey/failures_ML-DSA.https.any.js | 6 + .../generateKey/failures_ML-KEM.https.any.js | 6 + .../failures_chacha20_poly1305.https.any.js | 6 + .../generateKey/failures_kmac.https.any.js | 6 + .../successes_AES-OCB.https.any.js} | 6 +- .../successes_Hybrid-KEM.https.any.js} | 6 +- .../successes_ML-DSA.https.any.js} | 6 +- .../successes_ML-KEM.https.any.js} | 6 +- .../successes_chacha20_poly1305.https.any.js} | 6 +- .../generateKey/successes_kmac.https.any.js} | 6 +- .../getPublicKey.https.any.js} | 2 +- .../idlharness.https.any.js} | 5 +- .../AES-OCB_importKey.https.any.js} | 4 +- .../Argon2_importKey.https.any.js} | 4 +- .../ChaCha20-Poly1305_importKey.https.any.js} | 4 +- .../Hybrid-KEM_importKey.https.any.js} | 2 +- .../Hybrid-KEM_importKey_fixtures.js | 0 .../KMAC_importKey.https.any.js} | 4 +- .../ML-DSA_importKey.https.any.js} | 2 +- .../ML-DSA_importKey_fixtures.js | 0 .../ML-KEM_importKey.https.any.js} | 2 +- .../ML-KEM_importKey_fixtures.js | 0 .../import_export/ml_importKey.js | 0 .../raw_format_aliases.https.any.js} | 2 +- .../serialization/aes-ocb.https.any.js} | 4 +- .../chacha20-poly1305.https.any.js} | 4 +- .../serialization/hybridkem.https.window.js} | 4 +- .../serialization/kmac.https.any.js} | 4 +- .../serialization/mldsa.https.any.js} | 4 +- .../serialization/mlkem.https.any.js} | 4 +- .../sign_verify/kmac.https.any.js} | 4 +- .../{ => modern-algos}/sign_verify/kmac.js | 0 .../sign_verify/kmac_vectors.js | 0 .../sign_verify/mldsa.https.any.js} | 4 +- .../{ => modern-algos}/sign_verify/mldsa.js | 0 .../sign_verify/mldsa_vectors.js | 0 .../supports-modern.https.any.js} | 2 +- .../supports.https.any.js} | 2 +- .../util/mldsa_key_fixtures.js | 0 .../{ => modern-algos}/util/supports.js | 0 .../wpt/WebCryptoAPI/secure-curves/META.yml | 1 + .../cfrg_curves_bits_curve448.https.any.js} | 10 +- .../cfrg_curves_keys_curve448.https.any.js} | 10 +- .../generateKey/failures_Ed448.https.any.js | 6 + .../generateKey/failures_X448.https.any.js | 6 + .../generateKey/successes_Ed448.https.any.js} | 6 +- .../generateKey/successes_X448.https.any.js} | 6 +- .../secure-curves/idlharness.https.any.js | 10 + .../okp_importKey_Ed448.https.any.js | 10 + .../okp_importKey_X448.https.any.js | 10 + .../okp_importKey_failures_Ed448.https.any.js | 9 + .../okp_importKey_failures_X448.https.any.js | 9 + .../serialization/ed448.https.any.js} | 4 +- .../serialization/x448.https.any.js} | 4 +- .../sign_verify/eddsa_curve448.https.any.js | 8 + .../eddsa_curve448.tentative.https.any.js | 8 - test/fixtures/wpt/versions.json | 2 +- test/parallel/test-common-wpt-any.js | 30 +-- test/wpt/status/WebCryptoAPI.cjs | 174 +++++++++--------- 90 files changed, 310 insertions(+), 282 deletions(-) delete mode 100644 test/fixtures/wpt/WebCryptoAPI/generateKey/failures_AES-OCB.tentative.https.any.js delete mode 100644 test/fixtures/wpt/WebCryptoAPI/generateKey/failures_Ed448.tentative.https.any.js delete mode 100644 test/fixtures/wpt/WebCryptoAPI/generateKey/failures_ML-DSA.tentative.https.any.js delete mode 100644 test/fixtures/wpt/WebCryptoAPI/generateKey/failures_ML-KEM.tentative.https.any.js delete mode 100644 test/fixtures/wpt/WebCryptoAPI/generateKey/failures_X448.tentative.https.any.js delete mode 100644 test/fixtures/wpt/WebCryptoAPI/generateKey/failures_chacha20_poly1305.tentative.https.any.js delete mode 100644 test/fixtures/wpt/WebCryptoAPI/generateKey/failures_kmac.tentative.https.any.js delete mode 100644 test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_Ed448.tentative.https.any.js delete mode 100644 test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_X448.tentative.https.any.js delete mode 100644 test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_failures_Ed448.tentative.https.any.js delete mode 100644 test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_failures_X448.tentative.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/modern-algos/META.yml rename test/fixtures/wpt/WebCryptoAPI/{derive_bits_keys/argon2.tentative.https.any.js => modern-algos/derive_bits_keys/argon2.https.any.js} (85%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/derive_bits_keys/argon2.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/derive_bits_keys/argon2_vectors.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{digest/cshake.tentative.https.any.js => modern-algos/digest/cshake.https.any.js} (98%) rename test/fixtures/wpt/WebCryptoAPI/{digest/kangarootwelve.tentative.https.any.js => modern-algos/digest/kangarootwelve.https.any.js} (99%) rename test/fixtures/wpt/WebCryptoAPI/{digest/sha3.tentative.https.any.js => modern-algos/digest/sha3.https.any.js} (96%) rename test/fixtures/wpt/WebCryptoAPI/{digest/turboshake.tentative.https.any.js => modern-algos/digest/turboshake.https.any.js} (99%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/digest/xof_digest.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{encap_decap/encap_decap_bits.tentative.https.any.js => modern-algos/encap_decap/encap_decap_bits.https.any.js} (99%) rename test/fixtures/wpt/WebCryptoAPI/{encap_decap/encap_decap_keys.tentative.https.any.js => modern-algos/encap_decap/encap_decap_keys.https.any.js} (99%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/encap_decap/hybrid_kem_vectors.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/encap_decap/ml_kem_vectors.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{encrypt_decrypt/aes_ocb.tentative.https.any.js => modern-algos/encrypt_decrypt/aes_ocb.https.any.js} (54%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/encrypt_decrypt/aes_ocb_fixtures.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/encrypt_decrypt/aes_ocb_vectors.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{encrypt_decrypt/chacha20_poly1305.tentative.https.any.js => modern-algos/encrypt_decrypt/chacha20_poly1305.https.any.js} (99%) create mode 100644 test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_AES-OCB.https.any.js rename test/fixtures/wpt/WebCryptoAPI/{generateKey/failures_Hybrid-KEM.tentative.https.any.js => modern-algos/generateKey/failures_Hybrid-KEM.https.any.js} (50%) create mode 100644 test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_ML-DSA.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_ML-KEM.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_chacha20_poly1305.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_kmac.https.any.js rename test/fixtures/wpt/WebCryptoAPI/{generateKey/successes_AES-OCB.tentative.https.any.js => modern-algos/generateKey/successes_AES-OCB.https.any.js} (50%) rename test/fixtures/wpt/WebCryptoAPI/{generateKey/successes_Hybrid-KEM.tentative.https.any.js => modern-algos/generateKey/successes_Hybrid-KEM.https.any.js} (57%) rename test/fixtures/wpt/WebCryptoAPI/{generateKey/successes_ML-DSA.tentative.https.any.js => modern-algos/generateKey/successes_ML-DSA.https.any.js} (55%) rename test/fixtures/wpt/WebCryptoAPI/{generateKey/successes_ML-KEM.tentative.https.any.js => modern-algos/generateKey/successes_ML-KEM.https.any.js} (55%) rename test/fixtures/wpt/WebCryptoAPI/{generateKey/successes_chacha20_poly1305.tentative.https.any.js => modern-algos/generateKey/successes_chacha20_poly1305.https.any.js} (52%) rename test/fixtures/wpt/WebCryptoAPI/{generateKey/successes_kmac.tentative.https.any.js => modern-algos/generateKey/successes_kmac.https.any.js} (52%) rename test/fixtures/wpt/WebCryptoAPI/{getPublicKey.tentative.https.any.js => modern-algos/getPublicKey.https.any.js} (99%) rename test/fixtures/wpt/WebCryptoAPI/{idlharness.tentative.https.any.js => modern-algos/idlharness.https.any.js} (67%) rename test/fixtures/wpt/WebCryptoAPI/{import_export/AES-OCB_importKey.tentative.https.any.js => modern-algos/import_export/AES-OCB_importKey.https.any.js} (51%) rename test/fixtures/wpt/WebCryptoAPI/{import_export/Argon2_importKey.tentative.https.any.js => modern-algos/import_export/Argon2_importKey.https.any.js} (60%) rename test/fixtures/wpt/WebCryptoAPI/{import_export/ChaCha20-Poly1305_importKey.tentative.https.any.js => modern-algos/import_export/ChaCha20-Poly1305_importKey.https.any.js} (54%) rename test/fixtures/wpt/WebCryptoAPI/{import_export/Hybrid-KEM_importKey.tentative.https.any.js => modern-algos/import_export/Hybrid-KEM_importKey.https.any.js} (88%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/import_export/Hybrid-KEM_importKey_fixtures.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{import_export/KMAC_importKey.tentative.https.any.js => modern-algos/import_export/KMAC_importKey.https.any.js} (56%) rename test/fixtures/wpt/WebCryptoAPI/{import_export/ML-DSA_importKey.tentative.https.any.js => modern-algos/import_export/ML-DSA_importKey.https.any.js} (87%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/import_export/ML-DSA_importKey_fixtures.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{import_export/ML-KEM_importKey.tentative.https.any.js => modern-algos/import_export/ML-KEM_importKey.https.any.js} (85%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/import_export/ML-KEM_importKey_fixtures.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/import_export/ml_importKey.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{import_export/raw_format_aliases.tentative.https.any.js => modern-algos/import_export/raw_format_aliases.https.any.js} (99%) rename test/fixtures/wpt/WebCryptoAPI/{serialization/aes-ocb.tentative.https.any.js => modern-algos/serialization/aes-ocb.https.any.js} (70%) rename test/fixtures/wpt/WebCryptoAPI/{serialization/chacha20-poly1305.tentative.https.any.js => modern-algos/serialization/chacha20-poly1305.https.any.js} (71%) rename test/fixtures/wpt/WebCryptoAPI/{serialization/hybridkem.tentative.https.window.js => modern-algos/serialization/hybridkem.https.window.js} (89%) rename test/fixtures/wpt/WebCryptoAPI/{serialization/kmac.tentative.https.any.js => modern-algos/serialization/kmac.https.any.js} (77%) rename test/fixtures/wpt/WebCryptoAPI/{serialization/mldsa.tentative.https.any.js => modern-algos/serialization/mldsa.https.any.js} (85%) rename test/fixtures/wpt/WebCryptoAPI/{serialization/mlkem.tentative.https.any.js => modern-algos/serialization/mlkem.https.any.js} (89%) rename test/fixtures/wpt/WebCryptoAPI/{sign_verify/kmac.tentative.https.any.js => modern-algos/sign_verify/kmac.https.any.js} (65%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/sign_verify/kmac.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/sign_verify/kmac_vectors.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{sign_verify/mldsa.tentative.https.any.js => modern-algos/sign_verify/mldsa.https.any.js} (70%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/sign_verify/mldsa.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/sign_verify/mldsa_vectors.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{supports-modern.tentative.https.any.js => modern-algos/supports-modern.https.any.js} (99%) rename test/fixtures/wpt/WebCryptoAPI/{supports.tentative.https.any.js => modern-algos/supports.https.any.js} (99%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/util/mldsa_key_fixtures.js (100%) rename test/fixtures/wpt/WebCryptoAPI/{ => modern-algos}/util/supports.js (100%) create mode 100644 test/fixtures/wpt/WebCryptoAPI/secure-curves/META.yml rename test/fixtures/wpt/WebCryptoAPI/{derive_bits_keys/cfrg_curves_bits_curve448.tentative.https.any.js => secure-curves/derive_bits_keys/cfrg_curves_bits_curve448.https.any.js} (63%) rename test/fixtures/wpt/WebCryptoAPI/{derive_bits_keys/cfrg_curves_keys_curve448.tentative.https.any.js => secure-curves/derive_bits_keys/cfrg_curves_keys_curve448.https.any.js} (63%) create mode 100644 test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/failures_Ed448.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/failures_X448.https.any.js rename test/fixtures/wpt/WebCryptoAPI/{generateKey/successes_Ed448.tentative.https.any.js => secure-curves/generateKey/successes_Ed448.https.any.js} (50%) rename test/fixtures/wpt/WebCryptoAPI/{generateKey/successes_X448.tentative.https.any.js => secure-curves/generateKey/successes_X448.https.any.js} (50%) create mode 100644 test/fixtures/wpt/WebCryptoAPI/secure-curves/idlharness.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_Ed448.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_X448.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_failures_Ed448.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_failures_X448.https.any.js rename test/fixtures/wpt/WebCryptoAPI/{serialization/ed448.tentative.https.any.js => secure-curves/serialization/ed448.https.any.js} (70%) rename test/fixtures/wpt/WebCryptoAPI/{serialization/x448.tentative.https.any.js => secure-curves/serialization/x448.https.any.js} (70%) create mode 100644 test/fixtures/wpt/WebCryptoAPI/secure-curves/sign_verify/eddsa_curve448.https.any.js delete mode 100644 test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_curve448.tentative.https.any.js diff --git a/test/fixtures/wpt/WebCryptoAPI/README.md b/test/fixtures/wpt/WebCryptoAPI/README.md index 5546cf2b6f2..51fcb4da2ea 100644 --- a/test/fixtures/wpt/WebCryptoAPI/README.md +++ b/test/fixtures/wpt/WebCryptoAPI/README.md @@ -1 +1,18 @@ -Directory for Crypto API tests +Tests for the Web Cryptography API are grouped by specification: + +- Tests for [Web Cryptography API Level 2](https://w3c.github.io/webcrypto/) + are in this directory's existing operation subdirectories and root files. +- Tests for [Modern Algorithms in the Web Cryptography API](https://wicg.github.io/webcrypto-modern-algos/) + are in `modern-algos/`, including `supports()`, `getPublicKey()`, and key format extensions. +- Tests for [Secure Curves in the Web Cryptography API](https://wicg.github.io/webcrypto-secure-curves/) + are in `secure-curves/`. Ed25519 and X25519 are part of the core specification; + Ed448 and X448 are covered by the secure curves specification. + +Each specification directory has a `META.yml` linking to its specification. +Helpers used across specifications remain in the shared operation directories +or `util/`; helpers specific to an extension are alongside that extension's tests. + +Use `.tentative` only for assertions not yet required by a specification or that +contradict a specification, as described in the [file naming guidelines](../docs/writing-tests/file-names.md). +An algorithm being defined in an extension specification does not by itself make +its tests tentative. diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_AES-OCB.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_AES-OCB.tentative.https.any.js deleted file mode 100644 index ef7c8c38e53..00000000000 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_AES-OCB.tentative.https.any.js +++ /dev/null @@ -1,6 +0,0 @@ -// META: title=WebCryptoAPI: generateKey() for Failures -// META: timeout=long -// META: script=../util/helpers.js -// META: script=algorithm_registry.js -// META: script=failures.js -run_test(["AES-OCB"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_Ed448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_Ed448.tentative.https.any.js deleted file mode 100644 index 6ee388e40f7..00000000000 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_Ed448.tentative.https.any.js +++ /dev/null @@ -1,6 +0,0 @@ -// META: title=WebCryptoAPI: generateKey() for Failures -// META: timeout=long -// META: script=../util/helpers.js -// META: script=algorithm_registry.js -// META: script=failures.js -run_test(["Ed448"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_ML-DSA.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_ML-DSA.tentative.https.any.js deleted file mode 100644 index d41636dea79..00000000000 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_ML-DSA.tentative.https.any.js +++ /dev/null @@ -1,6 +0,0 @@ -// META: title=WebCryptoAPI: generateKey() for Failures -// META: timeout=long -// META: script=../util/helpers.js -// META: script=algorithm_registry.js -// META: script=failures.js -run_test(["ML-DSA-44", "ML-DSA-65", "ML-DSA-87"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_ML-KEM.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_ML-KEM.tentative.https.any.js deleted file mode 100644 index 0ece96944e7..00000000000 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_ML-KEM.tentative.https.any.js +++ /dev/null @@ -1,6 +0,0 @@ -// META: title=WebCryptoAPI: generateKey() for Failures -// META: timeout=long -// META: script=../util/helpers.js -// META: script=algorithm_registry.js -// META: script=failures.js -run_test(["ML-KEM-512", "ML-KEM-768", "ML-KEM-1024"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_X448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_X448.tentative.https.any.js deleted file mode 100644 index 26e12b97259..00000000000 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_X448.tentative.https.any.js +++ /dev/null @@ -1,6 +0,0 @@ -// META: title=WebCryptoAPI: generateKey() for Failures -// META: timeout=long -// META: script=../util/helpers.js -// META: script=algorithm_registry.js -// META: script=failures.js -run_test(["X448"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_chacha20_poly1305.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_chacha20_poly1305.tentative.https.any.js deleted file mode 100644 index 6ec0593a14b..00000000000 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_chacha20_poly1305.tentative.https.any.js +++ /dev/null @@ -1,6 +0,0 @@ -// META: title=WebCryptoAPI: generateKey() for Failures -// META: timeout=long -// META: script=../util/helpers.js -// META: script=algorithm_registry.js -// META: script=failures.js -run_test(["ChaCha20-Poly1305"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_kmac.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_kmac.tentative.https.any.js deleted file mode 100644 index 889c17e9c23..00000000000 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_kmac.tentative.https.any.js +++ /dev/null @@ -1,6 +0,0 @@ -// META: title=WebCryptoAPI: generateKey() for Failures -// META: timeout=long -// META: script=../util/helpers.js -// META: script=algorithm_registry.js -// META: script=failures.js -run_test(["KMAC128", "KMAC256"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_Ed448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_Ed448.tentative.https.any.js deleted file mode 100644 index 8498ce4ef8f..00000000000 --- a/test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_Ed448.tentative.https.any.js +++ /dev/null @@ -1,10 +0,0 @@ -// META: title=WebCryptoAPI: importKey() for OKP keys -// META: timeout=long -// META: script=../util/helpers.js -// META: script=../util/okp_key_fixtures.js -// META: script=okp_importKey_fixtures.js -// META: script=okp_importKey.js - - -// Test importKey and exportKey for OKP algorithms. -runTests("Ed448"); diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_X448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_X448.tentative.https.any.js deleted file mode 100644 index 09361ed9b8d..00000000000 --- a/test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_X448.tentative.https.any.js +++ /dev/null @@ -1,10 +0,0 @@ -// META: title=WebCryptoAPI: importKey() for OKP keys -// META: timeout=long -// META: script=../util/helpers.js -// META: script=../util/okp_key_fixtures.js -// META: script=okp_importKey_fixtures.js -// META: script=okp_importKey.js - - -// Test importKey and exportKey for OKP algorithms. -runTests("X448"); diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_failures_Ed448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_failures_Ed448.tentative.https.any.js deleted file mode 100644 index 726d5c1e377..00000000000 --- a/test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_failures_Ed448.tentative.https.any.js +++ /dev/null @@ -1,9 +0,0 @@ -// META: title=WebCryptoAPI: importKey() for Failures -// META: timeout=long -// META: script=../util/helpers.js -// META: script=../util/okp_key_fixtures.js -// META: script=okp_importKey_failures_fixtures.js -// META: script=importKey_failures.js - - -run_test(["Ed448"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_failures_X448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_failures_X448.tentative.https.any.js deleted file mode 100644 index 2b575d7ab4d..00000000000 --- a/test/fixtures/wpt/WebCryptoAPI/import_export/okp_importKey_failures_X448.tentative.https.any.js +++ /dev/null @@ -1,9 +0,0 @@ -// META: title=WebCryptoAPI: importKey() for Failures -// META: timeout=long -// META: script=../util/helpers.js -// META: script=../util/okp_key_fixtures.js -// META: script=okp_importKey_failures_fixtures.js -// META: script=importKey_failures.js - - -run_test(["X448"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/modern-algos/META.yml b/test/fixtures/wpt/WebCryptoAPI/modern-algos/META.yml new file mode 100644 index 00000000000..78c9d066de3 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/META.yml @@ -0,0 +1 @@ +spec: https://wicg.github.io/webcrypto-modern-algos/ diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/argon2.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/derive_bits_keys/argon2.https.any.js similarity index 85% rename from test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/argon2.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/derive_bits_keys/argon2.https.any.js index 9422c39c958..8ddbac5960e 100644 --- a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/argon2.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/derive_bits_keys/argon2.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: deriveBits() Using Argon2 // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=/common/subset-tests.js // META: script=argon2_vectors.js // META: script=argon2.js diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/argon2.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/derive_bits_keys/argon2.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/argon2.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/derive_bits_keys/argon2.js diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/argon2_vectors.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/derive_bits_keys/argon2_vectors.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/argon2_vectors.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/derive_bits_keys/argon2_vectors.js diff --git a/test/fixtures/wpt/WebCryptoAPI/digest/cshake.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/cshake.https.any.js similarity index 98% rename from test/fixtures/wpt/WebCryptoAPI/digest/cshake.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/cshake.https.any.js index 1bf78f58115..58b5378a852 100644 --- a/test/fixtures/wpt/WebCryptoAPI/digest/cshake.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/cshake.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: digest() cSHAKE algorithms -// META: script=../util/helpers.js -// META: script=digest_test_data.js -// META: script=digest.js +// META: script=../../util/helpers.js +// META: script=../../digest/digest_test_data.js +// META: script=../../digest/digest.js // META: timeout=long var subtle = crypto.subtle; // Change to test prefixed implementations diff --git a/test/fixtures/wpt/WebCryptoAPI/digest/kangarootwelve.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/kangarootwelve.https.any.js similarity index 99% rename from test/fixtures/wpt/WebCryptoAPI/digest/kangarootwelve.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/kangarootwelve.https.any.js index 0e38eb0542a..a3d79a1d9c4 100644 --- a/test/fixtures/wpt/WebCryptoAPI/digest/kangarootwelve.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/kangarootwelve.https.any.js @@ -1,5 +1,5 @@ // META: title=WebCryptoAPI: digest() KangarooTwelve algorithms -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=xof_digest.js // META: timeout=long diff --git a/test/fixtures/wpt/WebCryptoAPI/digest/sha3.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/sha3.https.any.js similarity index 96% rename from test/fixtures/wpt/WebCryptoAPI/digest/sha3.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/sha3.https.any.js index a6cafbb639f..ea44080aac5 100644 --- a/test/fixtures/wpt/WebCryptoAPI/digest/sha3.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/sha3.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: digest() SHA-3 algorithms -// META: script=../util/helpers.js -// META: script=digest_test_data.js -// META: script=digest.js +// META: script=../../util/helpers.js +// META: script=../../digest/digest_test_data.js +// META: script=../../digest/digest.js // META: timeout=long var subtle = crypto.subtle; // Change to test prefixed implementations diff --git a/test/fixtures/wpt/WebCryptoAPI/digest/turboshake.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/turboshake.https.any.js similarity index 99% rename from test/fixtures/wpt/WebCryptoAPI/digest/turboshake.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/turboshake.https.any.js index 356e6987956..9886506d986 100644 --- a/test/fixtures/wpt/WebCryptoAPI/digest/turboshake.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/turboshake.https.any.js @@ -1,5 +1,5 @@ // META: title=WebCryptoAPI: digest() TurboSHAKE algorithms -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=xof_digest.js // META: timeout=long diff --git a/test/fixtures/wpt/WebCryptoAPI/digest/xof_digest.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/xof_digest.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/digest/xof_digest.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/xof_digest.js diff --git a/test/fixtures/wpt/WebCryptoAPI/encap_decap/encap_decap_bits.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/encap_decap/encap_decap_bits.https.any.js similarity index 99% rename from test/fixtures/wpt/WebCryptoAPI/encap_decap/encap_decap_bits.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/encap_decap/encap_decap_bits.https.any.js index c0afb698e0a..df6626aeb7b 100644 --- a/test/fixtures/wpt/WebCryptoAPI/encap_decap/encap_decap_bits.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/encap_decap/encap_decap_bits.https.any.js @@ -1,5 +1,5 @@ // META: title=WebCryptoAPI: KEM encapsulateBits() and decapsulateBits() tests -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=ml_kem_vectors.js // META: script=hybrid_kem_vectors.js // META: timeout=long diff --git a/test/fixtures/wpt/WebCryptoAPI/encap_decap/encap_decap_keys.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/encap_decap/encap_decap_keys.https.any.js similarity index 99% rename from test/fixtures/wpt/WebCryptoAPI/encap_decap/encap_decap_keys.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/encap_decap/encap_decap_keys.https.any.js index e978fe497e6..364183bc2eb 100644 --- a/test/fixtures/wpt/WebCryptoAPI/encap_decap/encap_decap_keys.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/encap_decap/encap_decap_keys.https.any.js @@ -1,5 +1,5 @@ // META: title=WebCryptoAPI: KEM encapsulateKey() and decapsulateKey() tests -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=ml_kem_vectors.js // META: script=hybrid_kem_vectors.js // META: timeout=long diff --git a/test/fixtures/wpt/WebCryptoAPI/encap_decap/hybrid_kem_vectors.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/encap_decap/hybrid_kem_vectors.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/encap_decap/hybrid_kem_vectors.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/encap_decap/hybrid_kem_vectors.js diff --git a/test/fixtures/wpt/WebCryptoAPI/encap_decap/ml_kem_vectors.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/encap_decap/ml_kem_vectors.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/encap_decap/ml_kem_vectors.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/encap_decap/ml_kem_vectors.js diff --git a/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/aes_ocb.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/encrypt_decrypt/aes_ocb.https.any.js similarity index 54% rename from test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/aes_ocb.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/encrypt_decrypt/aes_ocb.https.any.js index e6a6246074c..bc0085719ab 100644 --- a/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/aes_ocb.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/encrypt_decrypt/aes_ocb.https.any.js @@ -1,9 +1,9 @@ // META: title=WebCryptoAPI: encrypt() Using AES-OCB w/ 120-bit iv -// META: script=../util/helpers.js -// META: script=aes_common_fixtures.js +// META: script=../../util/helpers.js +// META: script=../../encrypt_decrypt/aes_common_fixtures.js // META: script=aes_ocb_fixtures.js // META: script=aes_ocb_vectors.js -// META: script=aes.js +// META: script=../../encrypt_decrypt/aes.js // META: timeout=long run_test(); diff --git a/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/aes_ocb_fixtures.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/encrypt_decrypt/aes_ocb_fixtures.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/aes_ocb_fixtures.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/encrypt_decrypt/aes_ocb_fixtures.js diff --git a/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/aes_ocb_vectors.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/encrypt_decrypt/aes_ocb_vectors.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/aes_ocb_vectors.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/encrypt_decrypt/aes_ocb_vectors.js diff --git a/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/chacha20_poly1305.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/encrypt_decrypt/chacha20_poly1305.https.any.js similarity index 99% rename from test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/chacha20_poly1305.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/encrypt_decrypt/chacha20_poly1305.https.any.js index d03f7c03099..85bac420415 100644 --- a/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/chacha20_poly1305.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/encrypt_decrypt/chacha20_poly1305.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: encrypt()/decrypt() ChaCha20-Poly1305 // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js var subtle = crypto.subtle; // Change to test prefixed implementations diff --git a/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_AES-OCB.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_AES-OCB.https.any.js new file mode 100644 index 00000000000..faf99c3b526 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_AES-OCB.https.any.js @@ -0,0 +1,6 @@ +// META: title=WebCryptoAPI: generateKey() for Failures +// META: timeout=long +// META: script=../../util/helpers.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/failures.js +run_test(["AES-OCB"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_Hybrid-KEM.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_Hybrid-KEM.https.any.js similarity index 50% rename from test/fixtures/wpt/WebCryptoAPI/generateKey/failures_Hybrid-KEM.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_Hybrid-KEM.https.any.js index 40c69270c9a..2032ced4876 100644 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/failures_Hybrid-KEM.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_Hybrid-KEM.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: generateKey() for Failures // META: timeout=long -// META: script=../util/helpers.js -// META: script=algorithm_registry.js -// META: script=failures.js +// META: script=../../util/helpers.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/failures.js run_test(["MLKEM768-P256", "MLKEM768-X25519", "MLKEM1024-P384"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_ML-DSA.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_ML-DSA.https.any.js new file mode 100644 index 00000000000..474a2cf8c8b --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_ML-DSA.https.any.js @@ -0,0 +1,6 @@ +// META: title=WebCryptoAPI: generateKey() for Failures +// META: timeout=long +// META: script=../../util/helpers.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/failures.js +run_test(["ML-DSA-44", "ML-DSA-65", "ML-DSA-87"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_ML-KEM.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_ML-KEM.https.any.js new file mode 100644 index 00000000000..d7f62ef19b9 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_ML-KEM.https.any.js @@ -0,0 +1,6 @@ +// META: title=WebCryptoAPI: generateKey() for Failures +// META: timeout=long +// META: script=../../util/helpers.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/failures.js +run_test(["ML-KEM-512", "ML-KEM-768", "ML-KEM-1024"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_chacha20_poly1305.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_chacha20_poly1305.https.any.js new file mode 100644 index 00000000000..8026065f8d7 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_chacha20_poly1305.https.any.js @@ -0,0 +1,6 @@ +// META: title=WebCryptoAPI: generateKey() for Failures +// META: timeout=long +// META: script=../../util/helpers.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/failures.js +run_test(["ChaCha20-Poly1305"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_kmac.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_kmac.https.any.js new file mode 100644 index 00000000000..0ba07082948 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/failures_kmac.https.any.js @@ -0,0 +1,6 @@ +// META: title=WebCryptoAPI: generateKey() for Failures +// META: timeout=long +// META: script=../../util/helpers.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/failures.js +run_test(["KMAC128", "KMAC256"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_AES-OCB.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_AES-OCB.https.any.js similarity index 50% rename from test/fixtures/wpt/WebCryptoAPI/generateKey/successes_AES-OCB.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_AES-OCB.https.any.js index c87f875f4b1..46ebf52bef9 100644 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_AES-OCB.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_AES-OCB.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: generateKey() Successful Calls // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=/common/subset-tests.js -// META: script=algorithm_registry.js -// META: script=successes.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/successes.js run_test(["AES-OCB"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_Hybrid-KEM.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_Hybrid-KEM.https.any.js similarity index 57% rename from test/fixtures/wpt/WebCryptoAPI/generateKey/successes_Hybrid-KEM.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_Hybrid-KEM.https.any.js index bca75d4b6d7..39919c174e6 100644 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_Hybrid-KEM.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_Hybrid-KEM.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: generateKey() Successful Calls // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=/common/subset-tests.js -// META: script=algorithm_registry.js -// META: script=successes.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/successes.js run_test(["MLKEM768-P256", "MLKEM768-X25519", "MLKEM1024-P384"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_ML-DSA.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_ML-DSA.https.any.js similarity index 55% rename from test/fixtures/wpt/WebCryptoAPI/generateKey/successes_ML-DSA.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_ML-DSA.https.any.js index 6c81b193167..c33f9f38b24 100644 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_ML-DSA.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_ML-DSA.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: generateKey() Successful Calls // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=/common/subset-tests.js -// META: script=algorithm_registry.js -// META: script=successes.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/successes.js run_test(["ML-DSA-44", "ML-DSA-65", "ML-DSA-87"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_ML-KEM.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_ML-KEM.https.any.js similarity index 55% rename from test/fixtures/wpt/WebCryptoAPI/generateKey/successes_ML-KEM.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_ML-KEM.https.any.js index f41b5c34cdb..1353d25cb13 100644 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_ML-KEM.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_ML-KEM.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: generateKey() Successful Calls // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=/common/subset-tests.js -// META: script=algorithm_registry.js -// META: script=successes.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/successes.js run_test(["ML-KEM-512", "ML-KEM-768", "ML-KEM-1024"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_chacha20_poly1305.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_chacha20_poly1305.https.any.js similarity index 52% rename from test/fixtures/wpt/WebCryptoAPI/generateKey/successes_chacha20_poly1305.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_chacha20_poly1305.https.any.js index 2f3efebb6bc..c79dddb8d04 100644 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_chacha20_poly1305.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_chacha20_poly1305.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: generateKey() Successful Calls // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=/common/subset-tests.js -// META: script=algorithm_registry.js -// META: script=successes.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/successes.js run_test(["ChaCha20-Poly1305"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_kmac.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_kmac.https.any.js similarity index 52% rename from test/fixtures/wpt/WebCryptoAPI/generateKey/successes_kmac.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_kmac.https.any.js index 8276fa9058c..7f6120b4f89 100644 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_kmac.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/generateKey/successes_kmac.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: generateKey() Successful Calls // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=/common/subset-tests.js -// META: script=algorithm_registry.js -// META: script=successes.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/successes.js run_test(["KMAC128", "KMAC256"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/getPublicKey.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/getPublicKey.https.any.js similarity index 99% rename from test/fixtures/wpt/WebCryptoAPI/getPublicKey.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/getPublicKey.https.any.js index c85d2a9e02b..e5537c900dd 100644 --- a/test/fixtures/wpt/WebCryptoAPI/getPublicKey.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/getPublicKey.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: getPublicKey() method // META: timeout=long -// META: script=util/helpers.js +// META: script=../util/helpers.js "use strict"; diff --git a/test/fixtures/wpt/WebCryptoAPI/idlharness.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/idlharness.https.any.js similarity index 67% rename from test/fixtures/wpt/WebCryptoAPI/idlharness.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/idlharness.https.any.js index 150228aef03..5da45f3d576 100644 --- a/test/fixtures/wpt/WebCryptoAPI/idlharness.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/idlharness.https.any.js @@ -2,12 +2,11 @@ // META: script=/resources/idlharness.js // META: timeout=long -// https://wicg.github.io/webcrypto-secure-curves/ // https://wicg.github.io/webcrypto-modern-algos/ idl_test( - ['webcrypto', 'webcrypto-secure-curves', 'webcrypto-modern-algos'], - ['html', 'dom'], + ['webcrypto-modern-algos'], + ['webcrypto', 'html', 'dom'], idl_array => { idl_array.add_objects({ Crypto: ['crypto'], diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/AES-OCB_importKey.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/AES-OCB_importKey.https.any.js similarity index 51% rename from test/fixtures/wpt/WebCryptoAPI/import_export/AES-OCB_importKey.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/AES-OCB_importKey.https.any.js index 7fa028aa5a0..43ad1d5a530 100644 --- a/test/fixtures/wpt/WebCryptoAPI/import_export/AES-OCB_importKey.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/AES-OCB_importKey.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: importKey() for symmetric keys // META: timeout=long -// META: script=../util/helpers.js -// META: script=symmetric_importKey.js +// META: script=../../util/helpers.js +// META: script=../../import_export/symmetric_importKey.js runTests("AES-OCB"); diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/Argon2_importKey.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/Argon2_importKey.https.any.js similarity index 60% rename from test/fixtures/wpt/WebCryptoAPI/import_export/Argon2_importKey.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/Argon2_importKey.https.any.js index a3edc389630..aad42a55adb 100644 --- a/test/fixtures/wpt/WebCryptoAPI/import_export/Argon2_importKey.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/Argon2_importKey.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: importKey() for symmetric keys // META: timeout=long -// META: script=../util/helpers.js -// META: script=symmetric_importKey.js +// META: script=../../util/helpers.js +// META: script=../../import_export/symmetric_importKey.js runTests("Argon2i"); runTests("Argon2d"); diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/ChaCha20-Poly1305_importKey.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ChaCha20-Poly1305_importKey.https.any.js similarity index 54% rename from test/fixtures/wpt/WebCryptoAPI/import_export/ChaCha20-Poly1305_importKey.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ChaCha20-Poly1305_importKey.https.any.js index 620f22d4aec..d478af3e51d 100644 --- a/test/fixtures/wpt/WebCryptoAPI/import_export/ChaCha20-Poly1305_importKey.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ChaCha20-Poly1305_importKey.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: importKey() for symmetric keys // META: timeout=long -// META: script=../util/helpers.js -// META: script=symmetric_importKey.js +// META: script=../../util/helpers.js +// META: script=../../import_export/symmetric_importKey.js runTests("ChaCha20-Poly1305"); diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/Hybrid-KEM_importKey.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/Hybrid-KEM_importKey.https.any.js similarity index 88% rename from test/fixtures/wpt/WebCryptoAPI/import_export/Hybrid-KEM_importKey.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/Hybrid-KEM_importKey.https.any.js index 3227434ed44..a709f5e7fa6 100644 --- a/test/fixtures/wpt/WebCryptoAPI/import_export/Hybrid-KEM_importKey.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/Hybrid-KEM_importKey.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: importKey() for Hybrid KEM keys // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=Hybrid-KEM_importKey_fixtures.js // META: script=ml_importKey.js diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/Hybrid-KEM_importKey_fixtures.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/Hybrid-KEM_importKey_fixtures.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/import_export/Hybrid-KEM_importKey_fixtures.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/Hybrid-KEM_importKey_fixtures.js diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/KMAC_importKey.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/KMAC_importKey.https.any.js similarity index 56% rename from test/fixtures/wpt/WebCryptoAPI/import_export/KMAC_importKey.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/KMAC_importKey.https.any.js index 83995bca37a..c3aacbeed6e 100644 --- a/test/fixtures/wpt/WebCryptoAPI/import_export/KMAC_importKey.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/KMAC_importKey.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: importKey() for symmetric keys // META: timeout=long -// META: script=../util/helpers.js -// META: script=symmetric_importKey.js +// META: script=../../util/helpers.js +// META: script=../../import_export/symmetric_importKey.js runTests("KMAC128"); runTests("KMAC256"); diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/ML-DSA_importKey.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ML-DSA_importKey.https.any.js similarity index 87% rename from test/fixtures/wpt/WebCryptoAPI/import_export/ML-DSA_importKey.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ML-DSA_importKey.https.any.js index 02f745d71c2..96d17f641b1 100644 --- a/test/fixtures/wpt/WebCryptoAPI/import_export/ML-DSA_importKey.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ML-DSA_importKey.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: importKey() for ML-DSA keys // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=../util/mldsa_key_fixtures.js // META: script=ML-DSA_importKey_fixtures.js // META: script=ml_importKey.js diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/ML-DSA_importKey_fixtures.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ML-DSA_importKey_fixtures.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/import_export/ML-DSA_importKey_fixtures.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ML-DSA_importKey_fixtures.js diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ML-KEM_importKey.https.any.js similarity index 85% rename from test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ML-KEM_importKey.https.any.js index 11d80c76bc5..7766a2badb3 100644 --- a/test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ML-KEM_importKey.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: importKey() for ML-KEM keys // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=ML-KEM_importKey_fixtures.js // META: script=ml_importKey.js diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey_fixtures.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ML-KEM_importKey_fixtures.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey_fixtures.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ML-KEM_importKey_fixtures.js diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/ml_importKey.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ml_importKey.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/import_export/ml_importKey.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/ml_importKey.js diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/raw_format_aliases.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/raw_format_aliases.https.any.js similarity index 99% rename from test/fixtures/wpt/WebCryptoAPI/import_export/raw_format_aliases.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/raw_format_aliases.https.any.js index 646ae1b0de7..e09526e75d3 100644 --- a/test/fixtures/wpt/WebCryptoAPI/import_export/raw_format_aliases.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/import_export/raw_format_aliases.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: raw-secret and raw-public importKey() format aliases // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // For all existing symmetric algorithms in WebCrypto, "raw-secret" acts as an // alias of "raw". For all existing asymmetric algorithms in WebCrypto, diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/aes-ocb.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/aes-ocb.https.any.js similarity index 70% rename from test/fixtures/wpt/WebCryptoAPI/serialization/aes-ocb.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/aes-ocb.https.any.js index 33b814410c3..1d63ea9ef8e 100644 --- a/test/fixtures/wpt/WebCryptoAPI/serialization/aes-ocb.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/aes-ocb.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: CryptoKey serialization -// META: script=../util/helpers.js -// META: script=serialization.js +// META: script=../../util/helpers.js +// META: script=../../serialization/serialization.js run_test([ { name: 'AES-OCB', diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/chacha20-poly1305.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/chacha20-poly1305.https.any.js similarity index 71% rename from test/fixtures/wpt/WebCryptoAPI/serialization/chacha20-poly1305.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/chacha20-poly1305.https.any.js index aaaa24a0b66..6b2357f51ce 100644 --- a/test/fixtures/wpt/WebCryptoAPI/serialization/chacha20-poly1305.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/chacha20-poly1305.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: CryptoKey serialization -// META: script=../util/helpers.js -// META: script=serialization.js +// META: script=../../util/helpers.js +// META: script=../../serialization/serialization.js run_test([ { name: 'ChaCha20-Poly1305', diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/hybridkem.tentative.https.window.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/hybridkem.https.window.js similarity index 89% rename from test/fixtures/wpt/WebCryptoAPI/serialization/hybridkem.tentative.https.window.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/hybridkem.https.window.js index 465f86df55a..ae41250e05f 100644 --- a/test/fixtures/wpt/WebCryptoAPI/serialization/hybridkem.tentative.https.window.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/hybridkem.https.window.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: Hybrid KEM CryptoKey serialization -// META: script=../util/helpers.js -// META: script=serialization.js +// META: script=../../util/helpers.js +// META: script=../../serialization/serialization.js run_test([ { name: 'MLKEM768-P256', diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/kmac.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/kmac.https.any.js similarity index 77% rename from test/fixtures/wpt/WebCryptoAPI/serialization/kmac.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/kmac.https.any.js index 645d16bec77..80913886e38 100644 --- a/test/fixtures/wpt/WebCryptoAPI/serialization/kmac.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/kmac.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: CryptoKey serialization -// META: script=../util/helpers.js -// META: script=serialization.js +// META: script=../../util/helpers.js +// META: script=../../serialization/serialization.js run_test([ { name: 'KMAC128', diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/mldsa.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/mldsa.https.any.js similarity index 85% rename from test/fixtures/wpt/WebCryptoAPI/serialization/mldsa.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/mldsa.https.any.js index 3f61248b3d9..7e0c076496c 100644 --- a/test/fixtures/wpt/WebCryptoAPI/serialization/mldsa.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/mldsa.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: CryptoKey serialization -// META: script=../util/helpers.js -// META: script=serialization.js +// META: script=../../util/helpers.js +// META: script=../../serialization/serialization.js run_test([ { diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/mlkem.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/mlkem.https.any.js similarity index 89% rename from test/fixtures/wpt/WebCryptoAPI/serialization/mlkem.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/mlkem.https.any.js index 62a210f0cda..7437d96f112 100644 --- a/test/fixtures/wpt/WebCryptoAPI/serialization/mlkem.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/serialization/mlkem.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: CryptoKey serialization -// META: script=../util/helpers.js -// META: script=serialization.js +// META: script=../../util/helpers.js +// META: script=../../serialization/serialization.js run_test([ { name: 'ML-KEM-512', diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/kmac.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/kmac.https.any.js similarity index 65% rename from test/fixtures/wpt/WebCryptoAPI/sign_verify/kmac.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/kmac.https.any.js index 0a57ba7a3f8..db28d0cff5e 100644 --- a/test/fixtures/wpt/WebCryptoAPI/sign_verify/kmac.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/kmac.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: sign() and verify() Using KMAC -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=kmac_vectors.js -// META: script=mac.js +// META: script=../../sign_verify/mac.js // META: script=kmac.js // META: timeout=long diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/kmac.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/kmac.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/sign_verify/kmac.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/kmac.js diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/kmac_vectors.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/kmac_vectors.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/sign_verify/kmac_vectors.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/kmac_vectors.js diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/mldsa.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/mldsa.https.any.js similarity index 70% rename from test/fixtures/wpt/WebCryptoAPI/sign_verify/mldsa.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/mldsa.https.any.js index 253cc85e258..db071762f90 100644 --- a/test/fixtures/wpt/WebCryptoAPI/sign_verify/mldsa.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/mldsa.https.any.js @@ -1,8 +1,8 @@ // META: title=WebCryptoAPI: sign() and verify() Using ML-DSA -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=../util/mldsa_key_fixtures.js // META: script=mldsa_vectors.js -// META: script=signature.js +// META: script=../../sign_verify/signature.js // META: script=mldsa.js // META: timeout=long diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/mldsa.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/mldsa.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/sign_verify/mldsa.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/mldsa.js diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/mldsa_vectors.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/mldsa_vectors.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/sign_verify/mldsa_vectors.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/sign_verify/mldsa_vectors.js diff --git a/test/fixtures/wpt/WebCryptoAPI/supports-modern.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/supports-modern.https.any.js similarity index 99% rename from test/fixtures/wpt/WebCryptoAPI/supports-modern.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/supports-modern.https.any.js index 5c4699dcfb7..a929468ed05 100644 --- a/test/fixtures/wpt/WebCryptoAPI/supports-modern.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/supports-modern.https.any.js @@ -1,5 +1,5 @@ // META: title=WebCrypto API: supports method tests for algorithms in https://wicg.github.io/webcrypto-modern-algos/ -// META: script=util/helpers.js +// META: script=../util/helpers.js // META: script=util/supports.js 'use strict'; diff --git a/test/fixtures/wpt/WebCryptoAPI/supports.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/supports.https.any.js similarity index 99% rename from test/fixtures/wpt/WebCryptoAPI/supports.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/supports.https.any.js index a74e49e69d1..a07684cbbe2 100644 --- a/test/fixtures/wpt/WebCryptoAPI/supports.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/supports.https.any.js @@ -1,5 +1,5 @@ // META: title=WebCrypto API: supports method tests -// META: script=util/helpers.js +// META: script=../util/helpers.js // META: script=util/supports.js 'use strict'; diff --git a/test/fixtures/wpt/WebCryptoAPI/util/mldsa_key_fixtures.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/util/mldsa_key_fixtures.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/util/mldsa_key_fixtures.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/util/mldsa_key_fixtures.js diff --git a/test/fixtures/wpt/WebCryptoAPI/util/supports.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/util/supports.js similarity index 100% rename from test/fixtures/wpt/WebCryptoAPI/util/supports.js rename to test/fixtures/wpt/WebCryptoAPI/modern-algos/util/supports.js diff --git a/test/fixtures/wpt/WebCryptoAPI/secure-curves/META.yml b/test/fixtures/wpt/WebCryptoAPI/secure-curves/META.yml new file mode 100644 index 00000000000..e5c16d76a3d --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/META.yml @@ -0,0 +1 @@ +spec: https://wicg.github.io/webcrypto-secure-curves/ diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits_curve448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/derive_bits_keys/cfrg_curves_bits_curve448.https.any.js similarity index 63% rename from test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits_curve448.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/secure-curves/derive_bits_keys/cfrg_curves_bits_curve448.https.any.js index cda5ba87fba..35fc0210362 100644 --- a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits_curve448.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/derive_bits_keys/cfrg_curves_bits_curve448.https.any.js @@ -1,9 +1,9 @@ // META: title=WebCryptoAPI: deriveKey() Using ECDH with CFRG Elliptic Curves -// META: script=../util/helpers.js -// META: script=cfrg_curves_bits_fixtures.js -// META: script=derive.js -// META: script=cfrg_curves.js -// META: script=cfrg_curves_bits.js +// META: script=../../util/helpers.js +// META: script=../../derive_bits_keys/cfrg_curves_bits_fixtures.js +// META: script=../../derive_bits_keys/derive.js +// META: script=../../derive_bits_keys/cfrg_curves.js +// META: script=../../derive_bits_keys/cfrg_curves_bits.js // Define subtests from a `promise_test` to ensure the harness does not // complete before the subtests are available. `explicit_done` cannot be used diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_keys_curve448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/derive_bits_keys/cfrg_curves_keys_curve448.https.any.js similarity index 63% rename from test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_keys_curve448.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/secure-curves/derive_bits_keys/cfrg_curves_keys_curve448.https.any.js index 38a5ce1db5b..595b04e3faf 100644 --- a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_keys_curve448.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/derive_bits_keys/cfrg_curves_keys_curve448.https.any.js @@ -1,9 +1,9 @@ // META: title=WebCryptoAPI: deriveKey() Using ECDH with CFRG Elliptic Curves -// META: script=../util/helpers.js -// META: script=cfrg_curves_bits_fixtures.js -// META: script=derive.js -// META: script=cfrg_curves.js -// META: script=cfrg_curves_keys.js +// META: script=../../util/helpers.js +// META: script=../../derive_bits_keys/cfrg_curves_bits_fixtures.js +// META: script=../../derive_bits_keys/derive.js +// META: script=../../derive_bits_keys/cfrg_curves.js +// META: script=../../derive_bits_keys/cfrg_curves_keys.js // Define subtests from a `promise_test` to ensure the harness does not // complete before the subtests are available. `explicit_done` cannot be used diff --git a/test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/failures_Ed448.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/failures_Ed448.https.any.js new file mode 100644 index 00000000000..b129b88289a --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/failures_Ed448.https.any.js @@ -0,0 +1,6 @@ +// META: title=WebCryptoAPI: generateKey() for Failures +// META: timeout=long +// META: script=../../util/helpers.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/failures.js +run_test(["Ed448"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/failures_X448.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/failures_X448.https.any.js new file mode 100644 index 00000000000..8293786cc30 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/failures_X448.https.any.js @@ -0,0 +1,6 @@ +// META: title=WebCryptoAPI: generateKey() for Failures +// META: timeout=long +// META: script=../../util/helpers.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/failures.js +run_test(["X448"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_Ed448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/successes_Ed448.https.any.js similarity index 50% rename from test/fixtures/wpt/WebCryptoAPI/generateKey/successes_Ed448.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/successes_Ed448.https.any.js index d017170ca1a..c274ffc6b3e 100644 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_Ed448.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/successes_Ed448.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: generateKey() Successful Calls // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=/common/subset-tests.js -// META: script=algorithm_registry.js -// META: script=successes.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/successes.js run_test(["Ed448"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_X448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/successes_X448.https.any.js similarity index 50% rename from test/fixtures/wpt/WebCryptoAPI/generateKey/successes_X448.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/successes_X448.https.any.js index f1475c16bbd..c5ca8f3c968 100644 --- a/test/fixtures/wpt/WebCryptoAPI/generateKey/successes_X448.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/generateKey/successes_X448.https.any.js @@ -1,7 +1,7 @@ // META: title=WebCryptoAPI: generateKey() Successful Calls // META: timeout=long -// META: script=../util/helpers.js +// META: script=../../util/helpers.js // META: script=/common/subset-tests.js -// META: script=algorithm_registry.js -// META: script=successes.js +// META: script=../../generateKey/algorithm_registry.js +// META: script=../../generateKey/successes.js run_test(["X448"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/secure-curves/idlharness.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/idlharness.https.any.js new file mode 100644 index 00000000000..6b90dd4089c --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/idlharness.https.any.js @@ -0,0 +1,10 @@ +// META: script=/resources/WebIDLParser.js +// META: script=/resources/idlharness.js +// META: timeout=long + +// https://wicg.github.io/webcrypto-secure-curves/ + +idl_test( + ['webcrypto-secure-curves'], + ['webcrypto'] +); diff --git a/test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_Ed448.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_Ed448.https.any.js new file mode 100644 index 00000000000..d35b341d132 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_Ed448.https.any.js @@ -0,0 +1,10 @@ +// META: title=WebCryptoAPI: importKey() for OKP keys +// META: timeout=long +// META: script=../../util/helpers.js +// META: script=../../util/okp_key_fixtures.js +// META: script=../../import_export/okp_importKey_fixtures.js +// META: script=../../import_export/okp_importKey.js + + +// Test importKey and exportKey for OKP algorithms. +runTests("Ed448"); diff --git a/test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_X448.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_X448.https.any.js new file mode 100644 index 00000000000..c2319535a40 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_X448.https.any.js @@ -0,0 +1,10 @@ +// META: title=WebCryptoAPI: importKey() for OKP keys +// META: timeout=long +// META: script=../../util/helpers.js +// META: script=../../util/okp_key_fixtures.js +// META: script=../../import_export/okp_importKey_fixtures.js +// META: script=../../import_export/okp_importKey.js + + +// Test importKey and exportKey for OKP algorithms. +runTests("X448"); diff --git a/test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_failures_Ed448.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_failures_Ed448.https.any.js new file mode 100644 index 00000000000..2d33034e9ba --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_failures_Ed448.https.any.js @@ -0,0 +1,9 @@ +// META: title=WebCryptoAPI: importKey() for Failures +// META: timeout=long +// META: script=../../util/helpers.js +// META: script=../../util/okp_key_fixtures.js +// META: script=../../import_export/okp_importKey_failures_fixtures.js +// META: script=../../import_export/importKey_failures.js + + +run_test(["Ed448"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_failures_X448.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_failures_X448.https.any.js new file mode 100644 index 00000000000..1cd1753380f --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/import_export/okp_importKey_failures_X448.https.any.js @@ -0,0 +1,9 @@ +// META: title=WebCryptoAPI: importKey() for Failures +// META: timeout=long +// META: script=../../util/helpers.js +// META: script=../../util/okp_key_fixtures.js +// META: script=../../import_export/okp_importKey_failures_fixtures.js +// META: script=../../import_export/importKey_failures.js + + +run_test(["X448"]); diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/ed448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/serialization/ed448.https.any.js similarity index 70% rename from test/fixtures/wpt/WebCryptoAPI/serialization/ed448.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/secure-curves/serialization/ed448.https.any.js index 4abe5628568..f1fdf785ce4 100644 --- a/test/fixtures/wpt/WebCryptoAPI/serialization/ed448.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/serialization/ed448.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: CryptoKey serialization -// META: script=../util/helpers.js -// META: script=serialization.js +// META: script=../../util/helpers.js +// META: script=../../serialization/serialization.js run_test([ { name: 'Ed448', diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/x448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/serialization/x448.https.any.js similarity index 70% rename from test/fixtures/wpt/WebCryptoAPI/serialization/x448.tentative.https.any.js rename to test/fixtures/wpt/WebCryptoAPI/secure-curves/serialization/x448.https.any.js index cafc00144a3..05c2e17b63f 100644 --- a/test/fixtures/wpt/WebCryptoAPI/serialization/x448.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/serialization/x448.https.any.js @@ -1,6 +1,6 @@ // META: title=WebCryptoAPI: CryptoKey serialization -// META: script=../util/helpers.js -// META: script=serialization.js +// META: script=../../util/helpers.js +// META: script=../../serialization/serialization.js run_test([ { name: 'X448', diff --git a/test/fixtures/wpt/WebCryptoAPI/secure-curves/sign_verify/eddsa_curve448.https.any.js b/test/fixtures/wpt/WebCryptoAPI/secure-curves/sign_verify/eddsa_curve448.https.any.js new file mode 100644 index 00000000000..b7e6b832251 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/secure-curves/sign_verify/eddsa_curve448.https.any.js @@ -0,0 +1,8 @@ +// META: title=WebCryptoAPI: sign() and verify() Using EdDSA +// META: script=../../util/helpers.js +// META: script=../../sign_verify/eddsa_vectors.js +// META: script=../../sign_verify/signature.js +// META: script=../../sign_verify/eddsa.js +// META: timeout=long + +run_test("Ed448"); diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_curve448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_curve448.tentative.https.any.js deleted file mode 100644 index 8dd43dfeb17..00000000000 --- a/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_curve448.tentative.https.any.js +++ /dev/null @@ -1,8 +0,0 @@ -// META: title=WebCryptoAPI: sign() and verify() Using EdDSA -// META: script=../util/helpers.js -// META: script=eddsa_vectors.js -// META: script=signature.js -// META: script=eddsa.js -// META: timeout=long - -run_test("Ed448"); diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json index 33c38735174..2d12ad45360 100644 --- a/test/fixtures/wpt/versions.json +++ b/test/fixtures/wpt/versions.json @@ -100,7 +100,7 @@ "path": "web-locks" }, "WebCryptoAPI": { - "commit": "3127c3a492e63578ed2bf76e3d4bda805183b5a3", + "commit": "b638c093cd3e1849715130bcd99041f79980bb12", "path": "WebCryptoAPI" }, "webidl": { diff --git a/test/parallel/test-common-wpt-any.js b/test/parallel/test-common-wpt-any.js index c198fd70714..6244453f29c 100644 --- a/test/parallel/test-common-wpt-any.js +++ b/test/parallel/test-common-wpt-any.js @@ -38,7 +38,7 @@ assert.deepStrictEqual(getUnexpectedPasses(flakySpecs, {}), []); const specs = WPTTestSpec.from( 'WebCryptoAPI', - 'getPublicKey.tentative.https.any.js', + 'modern-algos/getPublicKey.https.any.js', [], ); @@ -47,11 +47,11 @@ assert.deepStrictEqual(specs.map((spec) => ({ isWebWorkerTest: spec.isWebWorkerTest(), })), [ { - testPath: 'WebCryptoAPI/getPublicKey.tentative.https.any.html', + testPath: 'WebCryptoAPI/modern-algos/getPublicKey.https.any.html', isWebWorkerTest: false, }, { - testPath: 'WebCryptoAPI/getPublicKey.tentative.https.any.worker.html', + testPath: 'WebCryptoAPI/modern-algos/getPublicKey.https.any.worker.html', isWebWorkerTest: true, }, ]); @@ -90,7 +90,7 @@ assert.deepStrictEqual( const skippedSpecs = WPTTestSpec.from( 'WebCryptoAPI', - 'getPublicKey.tentative.https.any.js', + 'modern-algos/getPublicKey.https.any.js', [{ requires: [], skip: 'unsupported' }], ); assert.deepStrictEqual( @@ -100,7 +100,7 @@ assert.deepStrictEqual( const skippedSubtestSpecs = WPTTestSpec.from( 'WebCryptoAPI', - 'getPublicKey.tentative.https.any.js', + 'modern-algos/getPublicKey.https.any.js', [{ requires: [], skipTests: [/getPublicKey method/] }], ); assert.ok(skippedSubtestSpecs.every( @@ -108,7 +108,7 @@ assert.ok(skippedSubtestSpecs.every( const scopedSpecs = WPTTestSpec.from( 'WebCryptoAPI', - 'getPublicKey.tentative.https.any.js', + 'modern-algos/getPublicKey.https.any.js', [], (spec) => (spec.getStatusKey().endsWith('.any.worker.html') ? [{ requires: [], skip: 'worker only' }] : []), @@ -119,26 +119,26 @@ assert.deepStrictEqual( ); const sourceRule = { - key: 'getPublicKey.tentative.https.any.js', + key: 'modern-algos/getPublicKey.https.any.js', requires: [], fail: { expected: ['shared failure'] }, }; const workerRule = { - key: 'getPublicKey.tentative.https.any.worker.html', + key: 'modern-algos/getPublicKey.https.any.worker.html', requires: [], fail: { expected: ['worker failure'] }, }; const expectedFailureSpecs = WPTTestSpec.from( 'WebCryptoAPI', - 'getPublicKey.tentative.https.any.js', + 'modern-algos/getPublicKey.https.any.js', [sourceRule], (spec) => (spec.isWebWorkerTest() ? [workerRule] : []), ); const expectedResults = { - 'getPublicKey.tentative.https.any.html': { + 'modern-algos/getPublicKey.https.any.html': { fail: { expected: ['shared failure'] }, }, - 'getPublicKey.tentative.https.any.worker.html': { + 'modern-algos/getPublicKey.https.any.worker.html': { fail: { expected: ['shared failure', 'worker failure'] }, }, }; @@ -147,15 +147,15 @@ assert.deepStrictEqual( getUnexpectedPasses(expectedFailureSpecs, expectedResults), [], ); -expectedResults['getPublicKey.tentative.https.any.worker.html'].fail.expected = +expectedResults['modern-algos/getPublicKey.https.any.worker.html'].fail.expected = ['worker failure']; assert.deepStrictEqual( getUnexpectedPasses(expectedFailureSpecs, expectedResults), - ['getPublicKey.tentative.https.any.worker.html:shared failure'], + ['modern-algos/getPublicKey.https.any.worker.html:shared failure'], ); -expectedResults['getPublicKey.tentative.https.any.worker.html'].fail.expected = +expectedResults['modern-algos/getPublicKey.https.any.worker.html'].fail.expected = ['shared failure']; assert.deepStrictEqual( getUnexpectedPasses(expectedFailureSpecs, expectedResults), - ['getPublicKey.tentative.https.any.worker.html:worker failure'], + ['modern-algos/getPublicKey.https.any.worker.html:worker failure'], ); diff --git a/test/wpt/status/WebCryptoAPI.cjs b/test/wpt/status/WebCryptoAPI.cjs index e2225c52d73..606cbbac34d 100644 --- a/test/wpt/status/WebCryptoAPI.cjs +++ b/test/wpt/status/WebCryptoAPI.cjs @@ -32,99 +32,99 @@ function skipSubtests(...entries) { if (!hasOpenSSL(3, 0)) { skip( - 'encrypt_decrypt/aes_ocb.tentative.https.any.js', - 'generateKey/failures_AES-OCB.tentative.https.any.js', - 'generateKey/failures_kmac.tentative.https.any.js', - 'generateKey/successes_AES-OCB.tentative.https.any.js', - 'generateKey/successes_kmac.tentative.https.any.js', - 'import_export/AES-OCB_importKey.tentative.https.any.js', - 'import_export/KMAC_importKey.tentative.https.any.js', - 'serialization/aes-ocb.tentative.https.any.js', - 'serialization/kmac.tentative.https.any.js', - 'sign_verify/kmac.tentative.https.any.js'); + 'modern-algos/encrypt_decrypt/aes_ocb.https.any.js', + 'modern-algos/generateKey/failures_AES-OCB.https.any.js', + 'modern-algos/generateKey/failures_kmac.https.any.js', + 'modern-algos/generateKey/successes_AES-OCB.https.any.js', + 'modern-algos/generateKey/successes_kmac.https.any.js', + 'modern-algos/import_export/AES-OCB_importKey.https.any.js', + 'modern-algos/import_export/KMAC_importKey.https.any.js', + 'modern-algos/serialization/aes-ocb.https.any.js', + 'modern-algos/serialization/kmac.https.any.js', + 'modern-algos/sign_verify/kmac.https.any.js'); } if (!hasOpenSSL(3, 2) || hasFIPS(3)) { skip( - 'derive_bits_keys/argon2.tentative.https.any.js', - 'import_export/Argon2_importKey.tentative.https.any.js'); + 'modern-algos/derive_bits_keys/argon2.https.any.js', + 'modern-algos/import_export/Argon2_importKey.https.any.js'); } if (!hasOpenSSL(3, 5) && !isBoringSSL) { skip( - 'encap_decap/encap_decap_bits.tentative.https.any.js', - 'encap_decap/encap_decap_keys.tentative.https.any.js', - 'generateKey/failures_Hybrid-KEM.tentative.https.any.js', - 'generateKey/failures_ML-DSA.tentative.https.any.js', - 'generateKey/failures_ML-KEM.tentative.https.any.js', - 'generateKey/successes_Hybrid-KEM.tentative.https.any.js', - 'generateKey/successes_ML-DSA.tentative.https.any.js', - 'generateKey/successes_ML-KEM.tentative.https.any.js', - 'import_export/Hybrid-KEM_importKey.tentative.https.any.js', - 'import_export/ML-DSA_importKey.tentative.https.any.js', - 'import_export/ML-KEM_importKey.tentative.https.any.js', - 'serialization/hybridkem.tentative.https.window.js', - 'serialization/mldsa.tentative.https.any.js', - 'serialization/mlkem.tentative.https.any.js', - 'sign_verify/mldsa.tentative.https.any.js'); + 'modern-algos/encap_decap/encap_decap_bits.https.any.js', + 'modern-algos/encap_decap/encap_decap_keys.https.any.js', + 'modern-algos/generateKey/failures_Hybrid-KEM.https.any.js', + 'modern-algos/generateKey/failures_ML-DSA.https.any.js', + 'modern-algos/generateKey/failures_ML-KEM.https.any.js', + 'modern-algos/generateKey/successes_Hybrid-KEM.https.any.js', + 'modern-algos/generateKey/successes_ML-DSA.https.any.js', + 'modern-algos/generateKey/successes_ML-KEM.https.any.js', + 'modern-algos/import_export/Hybrid-KEM_importKey.https.any.js', + 'modern-algos/import_export/ML-DSA_importKey.https.any.js', + 'modern-algos/import_export/ML-KEM_importKey.https.any.js', + 'modern-algos/serialization/hybridkem.https.window.js', + 'modern-algos/serialization/mldsa.https.any.js', + 'modern-algos/serialization/mlkem.https.any.js', + 'modern-algos/sign_verify/mldsa.https.any.js'); skipSubtests( - ['getPublicKey.tentative.https.any.js', /ml-?(?:kem|dsa)/i], + ['modern-algos/getPublicKey.https.any.js', /ml-?(?:kem|dsa)/i], [ - 'supports-modern.tentative.https.any.js', + 'modern-algos/supports-modern.https.any.js', /(?:ml-?(?:kem|dsa)|(?:en|de)capsulateKey)/i, ]); } if (isBoringSSL) { skip( - 'derive_bits_keys/cfrg_curves_bits_curve448.tentative.https.any.js', - 'derive_bits_keys/cfrg_curves_keys_curve448.tentative.https.any.js', - 'digest/cshake.tentative.https.any.js', - 'digest/sha3.tentative.https.any.js', - 'generateKey/failures_Ed448.tentative.https.any.js', - 'generateKey/failures_Hybrid-KEM.tentative.https.any.js', - 'generateKey/failures_X448.tentative.https.any.js', - 'generateKey/successes_Ed448.tentative.https.any.js', - 'generateKey/successes_Hybrid-KEM.tentative.https.any.js', - 'generateKey/successes_X448.tentative.https.any.js', - 'import_export/Hybrid-KEM_importKey.tentative.https.any.js', - 'import_export/okp_importKey_Ed448.tentative.https.any.js', - 'import_export/okp_importKey_failures_Ed448.tentative.https.any.js', - 'import_export/okp_importKey_failures_X448.tentative.https.any.js', - 'import_export/okp_importKey_X448.tentative.https.any.js', - 'serialization/ed448.tentative.https.any.js', - 'serialization/hybridkem.tentative.https.window.js', - 'serialization/x448.tentative.https.any.js', - 'sign_verify/eddsa_curve448.tentative.https.any.js'); + 'secure-curves/derive_bits_keys/cfrg_curves_bits_curve448.https.any.js', + 'secure-curves/derive_bits_keys/cfrg_curves_keys_curve448.https.any.js', + 'modern-algos/digest/cshake.https.any.js', + 'modern-algos/digest/sha3.https.any.js', + 'secure-curves/generateKey/failures_Ed448.https.any.js', + 'modern-algos/generateKey/failures_Hybrid-KEM.https.any.js', + 'secure-curves/generateKey/failures_X448.https.any.js', + 'secure-curves/generateKey/successes_Ed448.https.any.js', + 'modern-algos/generateKey/successes_Hybrid-KEM.https.any.js', + 'secure-curves/generateKey/successes_X448.https.any.js', + 'modern-algos/import_export/Hybrid-KEM_importKey.https.any.js', + 'secure-curves/import_export/okp_importKey_Ed448.https.any.js', + 'secure-curves/import_export/okp_importKey_failures_Ed448.https.any.js', + 'secure-curves/import_export/okp_importKey_failures_X448.https.any.js', + 'secure-curves/import_export/okp_importKey_X448.https.any.js', + 'secure-curves/serialization/ed448.https.any.js', + 'modern-algos/serialization/hybridkem.https.window.js', + 'secure-curves/serialization/x448.https.any.js', + 'secure-curves/sign_verify/eddsa_curve448.https.any.js'); skipSubtests( - ['encap_decap/encap_decap_bits.tentative.https.any.js', /(?:ml-kem-512|mlkem)/i], - ['encap_decap/encap_decap_keys.tentative.https.any.js', /(?:ml-kem-512|mlkem)/i], - ['generateKey/failures_ML-KEM.tentative.https.any.js', /ml-kem-512/i], - ['generateKey/successes_ML-KEM.tentative.https.any.js', /ml-kem-512/i], - ['getPublicKey.tentative.https.any.js', /(?:ed448|x448|ml-kem-512|mlkem)/i], - ['import_export/ML-KEM_importKey.tentative.https.any.js', /ml-kem-512/i], - ['serialization/mlkem.tentative.https.any.js', /ml-kem-512/i], - ['supports-modern.tentative.https.any.js', /(?:ml-kem-512|mlkem)/i]); + ['modern-algos/encap_decap/encap_decap_bits.https.any.js', /(?:ml-kem-512|mlkem)/i], + ['modern-algos/encap_decap/encap_decap_keys.https.any.js', /(?:ml-kem-512|mlkem)/i], + ['modern-algos/generateKey/failures_ML-KEM.https.any.js', /ml-kem-512/i], + ['modern-algos/generateKey/successes_ML-KEM.https.any.js', /ml-kem-512/i], + ['modern-algos/getPublicKey.https.any.js', /(?:ed448|x448|ml-kem-512|mlkem)/i], + ['modern-algos/import_export/ML-KEM_importKey.https.any.js', /ml-kem-512/i], + ['modern-algos/serialization/mlkem.https.any.js', /ml-kem-512/i], + ['modern-algos/supports-modern.https.any.js', /(?:ml-kem-512|mlkem)/i]); } if (hasFIPS(3)) { skip( - 'encrypt_decrypt/aes_ocb.tentative.https.any.js', - 'encrypt_decrypt/chacha20_poly1305.tentative.https.any.js', - 'generateKey/failures_AES-OCB.tentative.https.any.js', - 'generateKey/failures_chacha20_poly1305.tentative.https.any.js', - 'generateKey/successes_AES-OCB.tentative.https.any.js', - 'generateKey/successes_chacha20_poly1305.tentative.https.any.js', - 'import_export/AES-OCB_importKey.tentative.https.any.js', - 'import_export/ChaCha20-Poly1305_importKey.tentative.https.any.js', - 'serialization/aes-ocb.tentative.https.any.js', - 'serialization/chacha20-poly1305.tentative.https.any.js'); + 'modern-algos/encrypt_decrypt/aes_ocb.https.any.js', + 'modern-algos/encrypt_decrypt/chacha20_poly1305.https.any.js', + 'modern-algos/generateKey/failures_AES-OCB.https.any.js', + 'modern-algos/generateKey/failures_chacha20_poly1305.https.any.js', + 'modern-algos/generateKey/successes_AES-OCB.https.any.js', + 'modern-algos/generateKey/successes_chacha20_poly1305.https.any.js', + 'modern-algos/import_export/AES-OCB_importKey.https.any.js', + 'modern-algos/import_export/ChaCha20-Poly1305_importKey.https.any.js', + 'modern-algos/serialization/aes-ocb.https.any.js', + 'modern-algos/serialization/chacha20-poly1305.https.any.js'); skipSubtests( [ - 'supports-modern.tentative.https.any.js', + 'modern-algos/supports-modern.https.any.js', /(?:ChaCha20-Poly1305|^supports returns (?:true|false) for algorithm objects with (?:valid|invalid) parameters$)/, ], [ @@ -135,8 +135,8 @@ if (hasFIPS(3)) { if (hasFIPS()) { skip( - 'digest/kangarootwelve.tentative.https.any.js', - 'digest/turboshake.tentative.https.any.js'); + 'modern-algos/digest/kangarootwelve.https.any.js', + 'modern-algos/digest/turboshake.https.any.js'); } // OpenSSL 3.0 through 3.3 reject SHA-1 signature generation in FIPS mode. @@ -153,39 +153,39 @@ if (hasFIPS(3) && !hasOpenSSL(3, 4)) { if (hasFIPS(3, 5)) { skip( 'derive_bits_keys/cfrg_curves_bits_curve25519.https.any.js', - 'derive_bits_keys/cfrg_curves_bits_curve448.tentative.https.any.js', + 'secure-curves/derive_bits_keys/cfrg_curves_bits_curve448.https.any.js', 'derive_bits_keys/cfrg_curves_keys_curve25519.https.any.js', - 'derive_bits_keys/cfrg_curves_keys_curve448.tentative.https.any.js', - 'generateKey/failures_Hybrid-KEM.tentative.https.any.js', + 'secure-curves/derive_bits_keys/cfrg_curves_keys_curve448.https.any.js', + 'modern-algos/generateKey/failures_Hybrid-KEM.https.any.js', 'generateKey/failures_X25519.https.any.js', - 'generateKey/failures_X448.tentative.https.any.js', - 'generateKey/successes_Hybrid-KEM.tentative.https.any.js', + 'secure-curves/generateKey/failures_X448.https.any.js', + 'modern-algos/generateKey/successes_Hybrid-KEM.https.any.js', 'generateKey/successes_X25519.https.any.js', - 'generateKey/successes_X448.tentative.https.any.js', - 'import_export/Hybrid-KEM_importKey.tentative.https.any.js', + 'secure-curves/generateKey/successes_X448.https.any.js', + 'modern-algos/import_export/Hybrid-KEM_importKey.https.any.js', 'import_export/okp_importKey_X25519.https.any.js', - 'import_export/okp_importKey_X448.tentative.https.any.js', + 'secure-curves/import_export/okp_importKey_X448.https.any.js', 'import_export/okp_importKey_failures_X25519.https.any.js', - 'import_export/okp_importKey_failures_X448.tentative.https.any.js', - 'serialization/hybridkem.tentative.https.window.js', + 'secure-curves/import_export/okp_importKey_failures_X448.https.any.js', + 'modern-algos/serialization/hybridkem.https.window.js', 'serialization/x25519.https.any.js', - 'serialization/x448.tentative.https.any.js'); + 'secure-curves/serialization/x448.https.any.js'); skipSubtests( [ 'derive_bits_keys/derived_bits_length.https.any.js', /^X25519 derivation/, ], - ['encap_decap/encap_decap_bits.tentative.https.any.js', /mlkem/i], - ['encap_decap/encap_decap_keys.tentative.https.any.js', /mlkem/i], - ['getPublicKey.tentative.https.any.js', /(?:X25519|X448|MLKEM)/], + ['modern-algos/encap_decap/encap_decap_bits.https.any.js', /mlkem/i], + ['modern-algos/encap_decap/encap_decap_keys.https.any.js', /mlkem/i], + ['modern-algos/getPublicKey.https.any.js', /(?:X25519|X448|MLKEM)/], [ - 'import_export/raw_format_aliases.tentative.https.any.js', + 'modern-algos/import_export/raw_format_aliases.https.any.js', /(?:X25519|X448)/, ], - ['supports-modern.tentative.https.any.js', /mlkem/i], + ['modern-algos/supports-modern.https.any.js', /mlkem/i], [ - 'supports.tentative.https.any.js', + 'modern-algos/supports.https.any.js', /(?:X25519|^deriveKey promise tests|^supports validates the ECDH public key$)/, ], [ @@ -245,7 +245,7 @@ if (hasFIPS(4)) { if (!hasFIPS()) { skipSubtests( - ['digest/kangarootwelve.tentative.https.any.js', /C=(?:\d{4,}|5(?:1[3-9]|[2-9]\d)|[6-9]\d{2}) bytes/]); + ['modern-algos/digest/kangarootwelve.https.any.js', /C=(?:\d{4,}|5(?:1[3-9]|[2-9]\d)|[6-9]\d{2}) bytes/]); } function assertNoOverlap(fileSkips, subtestSkips) { From e4f931249dbd39b88b6b9e07fda3abbc35170d41 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Wed, 14 Oct 2026 23:36:15 +0200 Subject: [PATCH 010/331] tools: add read-only access in `nix-changes.yml` MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Without it, the workflow fails on private forks. Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/66691 Reviewed-By: Matteo Collina Reviewed-By: Ulises Gascón Reviewed-By: James M Snell --- .github/workflows/nix-changes.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/nix-changes.yml b/.github/workflows/nix-changes.yml index 7eee0e2e7f5..e077276e5dd 100644 --- a/.github/workflows/nix-changes.yml +++ b/.github/workflows/nix-changes.yml @@ -50,7 +50,7 @@ jobs: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: fetch-depth: 2 - persist-credentials: false + persist-credentials: true # We need read access in case we need to fetch in `Compute requisites before change` step sparse-checkout: | shell.nix tools/nix/ From ca5de657871ff1440cfc01c8804e1152eddbf2a8 Mon Sep 17 00:00:00 2001 From: Jiawen Geng Date: Thu, 15 Oct 2026 17:46:38 +0800 Subject: [PATCH 011/331] crypto: avoid reusing randomInt() cache bytes When an asynchronous randomInt() call finds the cache empty, it queues itself and starts randomFill() on the shared cache buffer. A synchronous call made before that job completes refills the same buffer with randomFillSync() and returns values from offset 0. The completion callback then reset the offset to 0, so the queued call and later calls returned the bytes that synchronous calls had already used. The threadpool job and randomFillSync() could also write the buffer at the same time. Fill a separate buffer asynchronously and copy it into the cache once the job is done. Fixes: https://github.com/nodejs/node/issues/66595 Refs: https://github.com/nodejs/node/pull/35110 Signed-off-by: Jiawen Geng Assisted-by: claude:opus-5.5 PR-URL: https://github.com/nodejs/node/pull/66597 Reviewed-By: Filip Skokan --- lib/internal/crypto/random.js | 13 +++++- test/parallel/test-crypto-randomint-cache.js | 43 ++++++++++++++++++++ 2 files changed, 54 insertions(+), 2 deletions(-) create mode 100644 test/parallel/test-crypto-randomint-cache.js diff --git a/lib/internal/crypto/random.js b/lib/internal/crypto/random.js index edf5b95f509..d13faf2d75d 100644 --- a/lib/internal/crypto/random.js +++ b/lib/internal/crypto/random.js @@ -26,6 +26,7 @@ const { TypedArrayPrototypeGetByteLength, TypedArrayPrototypeGetLength, TypedArrayPrototypeGetSymbolToStringTag, + TypedArrayPrototypeSet, Uint8Array, } = primordials; @@ -242,6 +243,8 @@ const RAND_MAX = 0xFFFF_FFFF_FFFF; // divisible by 6 because each attempt to obtain a random int uses 6 bytes. const randomCache = new FastBuffer(6 * 1024); let randomCacheOffset = randomCache.length; +// Asynchronous refills write into this buffer, never into randomCache. +let asyncRandomCache; let asyncCacheFillInProgress = false; const asyncCachePendingTasks = []; @@ -322,13 +325,19 @@ function asyncRefillRandomIntCache() { return; asyncCacheFillInProgress = true; - randomFill(randomCache, (err) => { + // Synchronous calls may refill and read randomCache while this job runs. + // Filling a separate buffer and copying it in afterwards ensures that + // resetting the offset never hands out bytes they have already used. + asyncRandomCache ??= new FastBuffer(randomCache.length); + randomFill(asyncRandomCache, (err) => { asyncCacheFillInProgress = false; const tasks = asyncCachePendingTasks; const errorReceiver = err && ArrayPrototypeShift(tasks); - if (!err) + if (!err) { + TypedArrayPrototypeSet(randomCache, asyncRandomCache); randomCacheOffset = 0; + } // Restart all pending tasks. If an error occurred, we only notify a single // callback (errorReceiver) about it. This way, every async call to diff --git a/test/parallel/test-crypto-randomint-cache.js b/test/parallel/test-crypto-randomint-cache.js new file mode 100644 index 00000000000..027793aa1fb --- /dev/null +++ b/test/parallel/test-crypto-randomint-cache.js @@ -0,0 +1,43 @@ +// Flags: --expose-internals +'use strict'; +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +// Synchronous randomInt() calls made while an asynchronous cache refill is +// pending must not cause the same random bytes to be returned twice. + +const assert = require('assert'); +const { randomInt } = require('crypto'); +const { internalBinding } = require('internal/test/binding'); +const { RandomBytesJob } = internalBinding('crypto'); + +// With this range, every 6-byte draw except 0xffffffffffff is returned +// unchanged, so a repeated value means repeated cache bytes. +const max = 2 ** 48 - 1; +const values = []; + +// The refill job calls ondone on the main thread after the threadpool has +// written its buffer. Make the synchronous calls at that point, before the +// refill callback in randomInt() runs. +const { run } = RandomBytesJob.prototype; +RandomBytesJob.prototype.run = common.mustCall(function() { + RandomBytesJob.prototype.run = run; + const { ondone } = this; + this.ondone = common.mustCall((...args) => { + for (let i = 0; i < 3; i++) + values.push(randomInt(max)); + ondone(...args); + }); + run.call(this); +}); + +// This is the first randomInt() call in the process, so the cache is empty. +// The call is queued and an asynchronous refill starts. +randomInt(max, common.mustSucceed((n) => { + values.push(n); + for (let i = 0; i < 3; i++) + values.push(randomInt(max)); + assert.strictEqual(new Set(values).size, values.length, + `duplicate values: ${values}`); +})); From 763587a280d3bb5a1d5d16c3cdda9521df7d730a Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Thu, 15 Oct 2026 14:45:32 +0200 Subject: [PATCH 012/331] tools: update OpenSSL on the selected branch Use the selected workflow branch as the PR base and prefix PR titles for branches other than the repository's default branch. Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66704 Reviewed-By: Antoine du Hamel Reviewed-By: Richard Lau --- .github/workflows/update-openssl.yml | 70 ++++++++++--------- .../maintaining/maintaining-openssl.md | 57 ++++++++------- 2 files changed, 64 insertions(+), 63 deletions(-) diff --git a/.github/workflows/update-openssl.yml b/.github/workflows/update-openssl.yml index b81a260312b..47c74e178ba 100644 --- a/.github/workflows/update-openssl.yml +++ b/.github/workflows/update-openssl.yml @@ -12,37 +12,40 @@ permissions: jobs: openssl-update: if: github.repository == 'nodejs/node' + name: OpenSSL update (${{ github.ref_name }}) # Cannot use ubuntu-slim here because the update script requires Docker runs-on: ubuntu-latest + concurrency: + group: openssl-update-${{ github.ref_name }} + cancel-in-progress: false + env: + TARGET_BRANCH: ${{ github.ref_name }} + DEFAULT_BRANCH: ${{ github.event.repository.default_branch }} steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: persist-credentials: false + - name: Setup Git config + run: | + git config user.name "Node.js GitHub Bot" + git config user.email "github-bot@iojs.org" + if [ "$TARGET_BRANCH" != "$DEFAULT_BRANCH" ]; then + echo "PR_TITLE_PREFIX=[${TARGET_BRANCH%-staging}] " >> "$GITHUB_ENV" + fi - name: Check and download new OpenSSL version run: | - ./tools/dep_updaters/update-openssl.sh download > temp-output - cat temp-output - tail -n1 temp-output | grep "NEW_VERSION=" >> "$GITHUB_ENV" || true - rm temp-output + ./tools/dep_updaters/update-openssl.sh download \ + | tee /dev/stderr \ + | tail -n1 \ + | sed -n '/^NEW_VERSION=/p' >> "$GITHUB_ENV" + shell: bash env: GITHUB_TOKEN: ${{ secrets.GH_USER_TOKEN }} - - name: Create PR with first commit - id: create-pull-request + - name: Commit OpenSSL sources if: env.NEW_VERSION - uses: gr2m/create-or-update-pull-request-action@b65137ca591da0b9f43bad7b24df13050ea45d1b # v1.10.1 - # Creates a PR with the new OpenSSL source code committed - env: - GITHUB_TOKEN: ${{ secrets.GH_USER_TOKEN }} - with: - author: Node.js GitHub Bot - body: This is an automated update of OpenSSL to ${{ env.NEW_VERSION }}. - branch: actions/tools-update-openssl # Custom branch *just* for this Action. - commit-message: 'deps: upgrade openssl sources to openssl-${{ env.NEW_VERSION }}' - labels: dependencies, openssl - title: 'deps: update OpenSSL to ${{ env.NEW_VERSION }}' - path: deps/openssl - update-pull-request-title-and-body: true - draft: true + run: | + git add -A deps/openssl/openssl + git commit -m "deps: upgrade openssl sources to openssl-$NEW_VERSION" - name: Regenerate platform specific files if: env.NEW_VERSION run: | @@ -50,20 +53,19 @@ jobs: ./tools/dep_updaters/update-openssl.sh regenerate env: GITHUB_TOKEN: ${{ secrets.GH_USER_TOKEN }} - - name: Add second commit - # Adds a second commit to the PR with the generated platform-dependent files + - name: Commit generated files if: env.NEW_VERSION - uses: gr2m/create-or-update-pull-request-action@b65137ca591da0b9f43bad7b24df13050ea45d1b # v1.10.1 - env: - GITHUB_TOKEN: ${{ secrets.GH_USER_TOKEN }} + run: | + git add -A deps/openssl + git commit -m "deps: update archs files for openssl-$NEW_VERSION" + - name: Create or update PR + if: env.NEW_VERSION + uses: peter-evans/create-pull-request@5f6978faf089d4d20b00c7766989d076bb2fc7f1 # v8.1.1 with: + token: ${{ secrets.GH_USER_TOKEN }} author: Node.js GitHub Bot - branch: actions/tools-update-openssl # Custom branch *just* for this Action. - commit-message: 'deps: update archs files for openssl-${{ env.NEW_VERSION }}' - path: deps/openssl - - name: Mark PR as ready for review - if: env.NEW_VERSION - env: - GITHUB_TOKEN: ${{ secrets.GH_USER_TOKEN }} - PR_ID: ${{ steps.create-pull-request.outputs.pull-request-number }} - run: gh --repo "$GITHUB_REPOSITORY" pr ready "$PR_ID" + committer: Node.js GitHub Bot + body: This is an automated update of OpenSSL to ${{ env.NEW_VERSION }} for ${{ github.ref_name }}. + branch: actions/${{ github.ref_name != github.event.repository.default_branch && format('{0}/', github.ref_name) || '' }}tools-update-openssl + labels: dependencies, openssl + title: '${{ env.PR_TITLE_PREFIX }}deps: update OpenSSL to ${{ env.NEW_VERSION }}' diff --git a/doc/contributing/maintaining/maintaining-openssl.md b/doc/contributing/maintaining/maintaining-openssl.md index aba013bb3c5..92525c4c65b 100644 --- a/doc/contributing/maintaining/maintaining-openssl.md +++ b/doc/contributing/maintaining/maintaining-openssl.md @@ -30,39 +30,49 @@ NASM version 2.11.08 ## 1. Obtain and extract new OpenSSL sources -Get a new source from -and copy all files into `deps/openssl/openssl`. Then add all files and commit -them. (The link above, and the branch, will change with each new OpenSSL -release). +Get the sources for the desired `openssl-` tag from + and copy all files into +`deps/openssl/openssl`. Then add all files and commit them. ```bash git clone https://github.com/openssl/openssl cd openssl +git checkout openssl- cd ../node/deps/openssl rm -rf openssl cp -R ../../../openssl openssl -rm -rf openssl/.git* +rm -rf openssl/.git git add --all openssl git commit openssl ``` ```text -deps: upgrade openssl sources to openssl-3.0.16 +deps: upgrade openssl sources to openssl- This updates all sources in deps/openssl/openssl by: $ git clone git@github.com:openssl/openssl.git $ cd openssl - $ git checkout openssl-3.0.16 + $ git checkout openssl- $ cd ../node/deps/openssl $ rm -rf openssl $ cp -R ../../../openssl openssl - $ rm -rf openssl/.git* + $ rm -rf openssl/.git $ git add --all openssl $ git commit openssl ``` ## 2. Execute `make` in `deps/openssl/config` directory +Fix up 32-bit Windows assembler directives. This will allow the commits to be +cherry-picked to older release lines that still provide binaries on 32-bit Windows. + +```bash +# Edit deps/openssl/openssl/crypto/perlasm/x86asm.pl changing +# #ifdef/#endif to %ifdef/%endif for nasm on 32-bit Windows. +# See: https://github.com/nodejs/node/pull/43603#issuecomment-1170670844 +# Reference: https://github.com/openssl/openssl/issues/18459 +``` + Use `make` to regenerate all platform dependent files in `deps/openssl/config/archs/`: @@ -75,17 +85,6 @@ make -C deps/openssl/config clean make -C deps/openssl/config ``` -Fix up 32-bit Windows assembler directives. This will allow the commits to be -cherry-picked to older release lines that still provide binaries on 32-bit Windows. - -```bash -make -C deps/openssl/config clean -# Edit deps/openssl/openssl/crypto/perlasm/x86asm.pl changing -# #ifdef to %ifdef to make it compatible to nasm on 32-bit Windows. -# See: https://github.com/nodejs/node/pull/43603#issuecomment-1170670844 -# Reference: https://github.com/openssl/openssl/issues/18459 -``` - ## 3. Check diffs Check diffs to ensure updates are right. Even if there are no updates in openssl @@ -98,19 +97,19 @@ git diff -- deps/openssl _Note_: On Windows, OpenSSL Configure generates a `makefile` that can be used for the `nmake` command. The `make` command in step 2 (above) uses -`Makefile_VC-WIN64A` and `Makefile_VC-WIN32` that are manually -created. When source files or build options are updated in Windows, -it needs to change these two Makefiles by hand. If you are not sure, +`Makefile_VC-WIN64A`, `Makefile_VC-WIN32`, and `Makefile_VC-WIN64-ARM`, +which are manually created. When source files or build options are updated in +Windows, these Makefiles need to be changed by hand. If you are not sure, please ask @shigeki for details. -## 4. Commit and make test +## 4. Commit and test Update all architecture dependent files. Do not forget to git add or remove files if they are changed before committing: ```bash -git add deps/openssl/config/archs -git add deps/openssl/openssl +git add -A deps/openssl/config/archs +git add -A deps/openssl/openssl git commit ``` @@ -118,16 +117,16 @@ The commit message can be written as (with the openssl version set to the relevant value): ```text -deps: update archs files for openssl-3.0.16 +deps: update archs files for openssl- After an OpenSSL source update, all the config files need to be regenerated and committed by: $ make -C deps/openssl/config - $ git add deps/openssl/config/archs - $ git add deps/openssl/openssl + $ git add -A deps/openssl/config/archs + $ git add -A deps/openssl/openssl $ git commit ``` -Finally, build Node.js and run the tests. +Finally, build Node.js with the bundled OpenSSL and run the tests. [update-openssl-action]: ../../../.github/workflows/update-openssl.yml From f0a74d23b60b8ac92e9ac6b75fabff1169f40f34 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Thu, 15 Oct 2026 15:26:29 +0200 Subject: [PATCH 013/331] build: fix gtest integration MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/66735 Reviewed-By: Filip Skokan Reviewed-By: Gürgün Dayıoğlu --- configure.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/configure.py b/configure.py index a3769ff2d87..fb742692f53 100755 --- a/configure.py +++ b/configure.py @@ -2198,7 +2198,7 @@ def configure_napi(output): def configure_library(lib, output, pkgname=None, libraries_key='libraries'): shared_lib = 'shared_' + lib output['variables']['node_' + shared_lib] = b(getattr(options, shared_lib)) - libraries = output[libraries_key] + libraries = output[libraries_key] if libraries_key in output else output['variables'][libraries_key] if getattr(options, shared_lib): (pkg_libs, pkg_cflags, pkg_libpath, _) = pkg_config(pkgname or lib) @@ -2968,7 +2968,7 @@ def make_bin_override(): configure_library('cares', output, pkgname='libcares') # Only cctest uses gtest; keep it out of the node binary's link line. output['variables']['node_shared_gtest_libraries'] = [] -configure_library('gtest', output, 'node_shared_gtest_libraries') +configure_library('gtest', output, libraries_key='node_shared_gtest_libraries') configure_library('hdr_histogram', output) configure_library('highway', output, pkgname='libhwy') configure_library('merve', output) From a20322182bf340139fe665dab5f81d5d72c214c8 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sun, 4 Oct 2026 01:33:51 +0000 Subject: [PATCH 014/331] stream: keep long-lived stream/iter objects in fast mode MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Object literals with `__proto__: null` are created in V8 dictionary mode. Create the objects that live as long as a stream and are used for every chunk with ObjectSetPrototypeOf() instead, as was done for the share and broadcast consumer state, so that they keep fast properties: - the iterators returned by push(), pull(), share(), shareSync() and broadcast() consumers, and the pull() consumer-cleanup wrapper, - the iterators and the cancellation context used by from() normalization, - the async wrapper share() uses for sync sources. Objects created per call or per chunk (iterator results, options bags, promise resolver records, single-use iterables) keep the literal form: for those, setting the prototype after creation costs more than it saves, about 2x slower in a create-and-read microbenchmark. The fromWritable() writer is also unchanged, since V8 keeps object literals with accessors in dictionary mode regardless. With 200,000 16-byte chunks, pipeTo() is about 3.5% faster and pull() with a transform or a signal about 1-1.5% faster. In benchmark/streams/iter-throughput-share*.js, share() and shareSync() improve by 1-4.5%; no benchmark regressed significantly. Assisted-by: OpenCode Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/66648 Reviewed-By: Trivikram Kamat Reviewed-By: Gürgün Dayıoğlu --- lib/internal/streams/iter/broadcast.js | 5 ++--- lib/internal/streams/iter/from.js | 16 +++++++--------- lib/internal/streams/iter/pull.js | 16 +++++++--------- lib/internal/streams/iter/push.js | 6 +++--- lib/internal/streams/iter/share.js | 15 ++++++--------- 5 files changed, 25 insertions(+), 33 deletions(-) diff --git a/lib/internal/streams/iter/broadcast.js b/lib/internal/streams/iter/broadcast.js index cdf25021bbc..e862f8d2a7a 100644 --- a/lib/internal/streams/iter/broadcast.js +++ b/lib/internal/streams/iter/broadcast.js @@ -225,8 +225,7 @@ class BroadcastImpl { return { __proto__: null, [SymbolAsyncIterator]() { - return { - __proto__: null, + return ObjectSetPrototypeOf({ next() { if (state.detached) { if (state.error !== kNoBroadcastError) { @@ -284,7 +283,7 @@ class BroadcastImpl { detach(); return kDone; }, - }; + }, null); }, }; } diff --git a/lib/internal/streams/iter/from.js b/lib/internal/streams/iter/from.js index e434ff9c253..9f39e0f614a 100644 --- a/lib/internal/streams/iter/from.js +++ b/lib/internal/streams/iter/from.js @@ -15,6 +15,7 @@ const { DataViewPrototypeGetByteLength, DataViewPrototypeGetByteOffset, FunctionPrototypeCall, + ObjectSetPrototypeOf, PromisePrototypeThen, PromiseResolve, PromiseWithResolvers, @@ -68,13 +69,12 @@ const kNormalizationCancelled = Symbol('kNormalizationCancelled'); const kFlushBatch = Symbol('kFlushBatch'); function createNormalizationContext() { - return { - __proto__: null, + return ObjectSetPrototypeOf({ cancelled: false, reason: undefined, resolve: null, suppressCleanup: false, - }; + }, null); } function cancelNormalization(context, reason, suppressCleanup = false) { @@ -112,8 +112,7 @@ async function waitForNormalization(value, context) { function createNormalizationIterator(createIterator) { const context = createNormalizationContext(); const iterator = createIterator(context); - return { - __proto__: null, + return ObjectSetPrototypeOf({ next(value) { return FunctionPrototypeCall(iterator.next, iterator, value); }, @@ -129,7 +128,7 @@ function createNormalizationIterator(createIterator) { [SymbolAsyncIterator]() { return this; }, - }; + }, null); } function createNormalizationSource(createIterator) { @@ -386,8 +385,7 @@ function yieldNormalizationAbortable(source, context) { } } - return { - __proto__: null, + return ObjectSetPrototypeOf({ async next() { if (completed) { return { __proto__: null, done: true, value: undefined }; @@ -433,7 +431,7 @@ function yieldNormalizationAbortable(source, context) { [SymbolAsyncIterator]() { return this; }, - }; + }, null); }, }; } diff --git a/lib/internal/streams/iter/pull.js b/lib/internal/streams/iter/pull.js index 176d8dbfc83..6dff97e42be 100644 --- a/lib/internal/streams/iter/pull.js +++ b/lib/internal/streams/iter/pull.js @@ -11,6 +11,7 @@ const { ArrayPrototypePush, ArrayPrototypeSlice, FunctionPrototypeCall, + ObjectSetPrototypeOf, PromisePrototypeThen, PromiseReject, PromiseResolve, @@ -861,8 +862,7 @@ function pull(source, ...args) { yield* createAsyncPipeline(normalized, transforms, controller.signal); } const iterator = pipeline(); - return { - __proto__: null, + return ObjectSetPrototypeOf({ next(value) { return iterator.next(value); }, @@ -877,7 +877,7 @@ function pull(source, ...args) { [SymbolAsyncIterator]() { return this; }, - }; + }, null); } return createAbortablePullIterator(normalized, transforms, signal); }, @@ -907,8 +907,7 @@ function createAbortablePullIterator(source, transforms, signal) { throw error; } - return { - __proto__: null, + return ObjectSetPrototypeOf({ next(value) { if (aborted) return PromiseReject(signal.reason); return PromisePrototypeThen(iterator.next(value), undefined, onRejected); @@ -929,7 +928,7 @@ function createAbortablePullIterator(source, transforms, signal) { [SymbolAsyncIterator]() { return this; }, - }; + }, null); } // Keep ownership of a bonded consumer outside the transform pipeline so it can @@ -986,8 +985,7 @@ function pullWithConsumerCleanup(source, transforms, signal) { __proto__: null, [SymbolAsyncIterator]() { const iterator = pipeline[SymbolAsyncIterator](); - return { - __proto__: null, + return ObjectSetPrototypeOf({ next(value) { return PromisePrototypeThen( iterator.next(value), @@ -1011,7 +1009,7 @@ function pullWithConsumerCleanup(source, transforms, signal) { [SymbolAsyncIterator]() { return this; }, - }; + }, null); }, }; } diff --git a/lib/internal/streams/iter/push.js b/lib/internal/streams/iter/push.js index 764a3afac92..039e6b9f39d 100644 --- a/lib/internal/streams/iter/push.js +++ b/lib/internal/streams/iter/push.js @@ -7,6 +7,7 @@ const { ArrayPrototypePush, + ObjectSetPrototypeOf, PromisePrototypeThen, PromiseReject, PromiseResolve, @@ -733,8 +734,7 @@ function createReadable(queue) { return { __proto__: null, [SymbolAsyncIterator]() { - return { - __proto__: null, + return ObjectSetPrototypeOf({ async next() { return queue.read(); }, @@ -746,7 +746,7 @@ function createReadable(queue) { queue.consumerThrow(error); throw error; }, - }; + }, null); }, }; } diff --git a/lib/internal/streams/iter/share.js b/lib/internal/streams/iter/share.js index 6e9881b682a..a61d4627ad5 100644 --- a/lib/internal/streams/iter/share.js +++ b/lib/internal/streams/iter/share.js @@ -235,8 +235,7 @@ class ShareImpl { } }; - return { - __proto__: null, + return ObjectSetPrototypeOf({ next() { const next = PromisePrototypeThen( state.pendingNext, @@ -266,7 +265,7 @@ class ShareImpl { } return { __proto__: null, done: true, value: undefined }; }, - }; + }, null); }, }; } @@ -401,8 +400,7 @@ class ShareImpl { } else if (isSyncIterable(this.#source)) { const syncIterator = this.#source[SymbolIterator](); - this.#sourceIterator = { - __proto__: null, + this.#sourceIterator = ObjectSetPrototypeOf({ async next() { return syncIterator.next(); }, @@ -410,7 +408,7 @@ class ShareImpl { return syncIterator.return?.() ?? { __proto__: null, done: true, value: undefined }; }, - }; + }, null); } else { throw new ERR_INVALID_ARG_TYPE( 'source', ['AsyncIterable', 'Iterable'], this.#source); @@ -592,8 +590,7 @@ class SyncShareImpl { return { __proto__: null, [SymbolIterator]() { - return { - __proto__: null, + return ObjectSetPrototypeOf({ next() { if (state.detached) { if (state.error !== kNoShareError) throw state.error; @@ -710,7 +707,7 @@ class SyncShareImpl { } return { __proto__: null, done: true, value: undefined }; }, - }; + }, null); }, }; } From 05d9793857c08a252d57a15868fd76758f9f5513 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sun, 4 Oct 2026 01:34:53 +0000 Subject: [PATCH 015/331] stream: make endSync() optional in pipeToSync() MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit pipeToSync() threw ERR_INVALID_ARG_TYPE before writing anything when the writer had no endSync() method and preventClose was not set. endSync() is optional: the spec (pipeToSync() step 7) only calls it if the writer has it, and pipeTo() already treats it that way. A writer without endSync() now receives the data and is not closed. pipeToSync() still never falls back to the async end(). This also fixes the from-sync-writev case of benchmark/streams/iter-from-batching.js, whose writer has no endSync(). testPipeToSyncNoEndSync asserted the previous rejection and now checks that the data is written and end() is not called. The documentation of the writer requirements is corrected as well: only writeSync() is required. Assisted-by: OpenCode Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/66648 Reviewed-By: Trivikram Kamat Reviewed-By: Gürgün Dayıoğlu --- doc/api/stream_iter.md | 9 ++++++--- lib/internal/streams/iter/pull.js | 9 +++------ test/parallel/test-stream-iter-pipeto-edge.js | 20 +++++++++---------- 3 files changed, 18 insertions(+), 20 deletions(-) diff --git a/doc/api/stream_iter.md b/doc/api/stream_iter.md index fa3b3ea4157..5dccdcae2ce 100644 --- a/doc/api/stream_iter.md +++ b/doc/api/stream_iter.md @@ -706,7 +706,7 @@ added: v25.9.0 * `source` {Iterable} The sync data source. * `...transforms` {Function|Object} Zero or more sync transforms. -* `writer` {Object} Destination with `write(chunk)` method. +* `writer` {Object} Destination with a `writeSync(chunk)` method. * `options` {Object} * `failOnIncompleteClose` {boolean} If `true`, call `writer.fail()` when `writer.endSync()` cannot close the writer synchronously. Ignored when @@ -719,8 +719,11 @@ added: v25.9.0 Synchronous version of [`pipeTo()`][]. The `source`, all transforms, and the `writer` must be synchronous. Cannot accept async iterables or promises. -The `writer` must have the `*Sync` methods (`writeSync`, `writevSync`, -`endSync`) and `fail()` for this to work. +The `writer` must have a `writeSync()` method. The other methods are +optional: `writevSync()` is used for batches of more than one chunk if it is +present, `endSync()` is called to close the writer (unless `preventClose` is +`true`), and `fail()` is called if the pipe fails (unless `preventFail` is +`true`). A writer without `endSync()` is not closed. `pipeToSync()` never falls back to the asynchronous writer methods. If `writer.endSync()` returns `-1` because the writer cannot close synchronously diff --git a/lib/internal/streams/iter/pull.js b/lib/internal/streams/iter/pull.js index 6dff97e42be..70e89a99423 100644 --- a/lib/internal/streams/iter/pull.js +++ b/lib/internal/streams/iter/pull.js @@ -1032,12 +1032,9 @@ function pipeToSync(source, ...args) { context: 'options', }); const hasWritevSync = typeof writer.writevSync === 'function'; + // endSync() is optional: a writer without it is not closed. const endSync = writer.endSync; - - if (!options.preventClose && typeof endSync !== 'function') { - throw new ERR_INVALID_ARG_TYPE( - 'writer.endSync', 'Function', endSync); - } + const hasEndSync = typeof endSync === 'function'; // Normalize source and create pipeline const normalized = fromSync(source); @@ -1074,7 +1071,7 @@ function pipeToSync(source, ...args) { } } - if (!options.preventClose) { + if (!options.preventClose && hasEndSync) { closedSync = FunctionPrototypeCall(endSync, writer) >= 0; } } catch (error) { diff --git a/test/parallel/test-stream-iter-pipeto-edge.js b/test/parallel/test-stream-iter-pipeto-edge.js index 0c5448db5a8..082871a9e4c 100644 --- a/test/parallel/test-stream-iter-pipeto-edge.js +++ b/test/parallel/test-stream-iter-pipeto-edge.js @@ -47,20 +47,18 @@ async function testPipeToSyncEndSyncFailureDoesNotFailWriter() { assert.strictEqual(await result, 'abcdef'); } -// pipeToSync requires endSync() when closing is enabled. +// pipeToSync does not require endSync(). async function testPipeToSyncNoEndSync() { - let writeCalled = false; - let endCalled = false; + // endSync() is optional. Without it the data is still written and the + // writer is not closed; pipeToSync() never falls back to end(). + const written = []; const writer = { - writeSync() { writeCalled = true; return true; }, - end() { endCalled = true; }, + writeSync(chunk) { written.push(chunk); return true; }, + end: common.mustNotCall(), + fail: common.mustNotCall(), }; - assert.throws( - () => pipeToSync(fromSync('data'), writer), - { code: 'ERR_INVALID_ARG_TYPE' }, - ); - assert.strictEqual(writeCalled, false); - assert.strictEqual(endCalled, false); + assert.strictEqual(pipeToSync(fromSync('data'), writer), 4); + assert.deepStrictEqual(written, [new TextEncoder().encode('data')]); } // pipeToSync with preventFail: true — source error does NOT call fail() From ee8d377e5036ed9161c05bed1812c4a311edd79d Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sun, 4 Oct 2026 01:47:21 +0000 Subject: [PATCH 016/331] stream: create stream/iter iterator results with a constructor MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The iterators of push(), share(), shareSync(), broadcast() consumers and from() normalization created a `{ __proto__: null, done, value }` literal for every result. V8 creates such literals in dictionary mode, which makes them several times more expensive to create and read than ordinary objects. Create them with an IterResult constructor whose prototype is a single frozen, null-prototype object instead. Results have fast properties and a single shape, and still have no %Object.prototype% in their prototype chain, so a polluted Object.prototype.then still cannot turn a result into a thenable. Creating and reading a result is about 5x faster in a microbenchmark. benchmark/streams/iter-throughput-share-sync.js improves by 7% to 42% (more with more consumers) and iter-throughput-share.js by 4-6%; pipeTo() with small chunks is about 2.5% faster. This is observable: results are no longer null-prototype objects, so deepStrictEqual() comparisons against `{ __proto__: null, ... }` no longer match, and util.inspect() prints them as `IterResult { done, value }` (the prototype has a non-enumerable `constructor` for that purpose). The five tests that compared results that way now compare their own properties, and a new test covers the result contract and the prototype pollution case. Assisted-by: OpenCode Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/66648 Reviewed-By: Trivikram Kamat Reviewed-By: Gürgün Dayıoğlu --- lib/internal/streams/iter/broadcast.js | 17 ++-- lib/internal/streams/iter/from.js | 9 ++- lib/internal/streams/iter/pull.js | 3 +- lib/internal/streams/iter/push.js | 19 ++--- lib/internal/streams/iter/share.js | 37 ++++----- lib/internal/streams/iter/utils.js | 27 +++++++ .../test-stream-iter-broadcast-basic.js | 3 +- .../test-stream-iter-broadcast-from.js | 3 +- .../test-stream-iter-iterator-result.js | 79 +++++++++++++++++++ test/parallel/test-stream-iter-pull-async.js | 4 +- .../test-stream-iter-reason-propagation.js | 3 +- .../test-stream-iter-share-coverage.js | 3 +- 12 files changed, 157 insertions(+), 50 deletions(-) create mode 100644 test/parallel/test-stream-iter-iterator-result.js diff --git a/lib/internal/streams/iter/broadcast.js b/lib/internal/streams/iter/broadcast.js index e862f8d2a7a..df2a701f20c 100644 --- a/lib/internal/streams/iter/broadcast.js +++ b/lib/internal/streams/iter/broadcast.js @@ -57,6 +57,7 @@ const { } = require('internal/streams/iter/pull'); const { + IterResult, kMultiConsumerDefaultBudget, kResolvedPromise, convertChunks, @@ -207,13 +208,13 @@ class BroadcastImpl { const self = this; const kDone = PromiseResolve( - { __proto__: null, done: true, value: undefined }); + new IterResult(true, undefined)); function detach() { state.detached = true; self.#waiters.delete(state); if (state.resolve) { - state.resolve({ __proto__: null, done: true, value: undefined }); + state.resolve(new IterResult(true, undefined)); } self.#resolvePendingDone(state); if (self.#deleteConsumer(state)) { @@ -245,7 +246,7 @@ class BroadcastImpl { self.#tryTrimBuffer(); } return PromiseResolve( - { __proto__: null, done: false, value: chunk }); + new IterResult(false, chunk)); } if (self.#errored) { @@ -307,7 +308,7 @@ class BroadcastImpl { if (hasReason) { consumer.reject?.(reason); } else { - consumer.resolve({ __proto__: null, done: true, value: undefined }); + consumer.resolve(new IterResult(true, undefined)); } consumer.resolve = null; consumer.reject = null; @@ -397,9 +398,9 @@ class BroadcastImpl { --this.#cachedMinCursorConsumers === 0) { this.#tryTrimBuffer(); } - consumer.resolve({ __proto__: null, done: false, value: chunk }); + consumer.resolve(new IterResult(false, chunk)); } else { - consumer.resolve({ __proto__: null, done: true, value: undefined }); + consumer.resolve(new IterResult(true, undefined)); this.#resolvePendingDone(consumer); consumer.detached = true; } @@ -529,7 +530,7 @@ class BroadcastImpl { const resolve = consumer.resolve; consumer.resolve = null; consumer.reject = null; - resolve({ __proto__: null, done: false, value: chunk }); + resolve(new IterResult(false, chunk)); if (consumer.detached && this.#deleteConsumer(consumer)) { this.#tryTrimBuffer(); } else if (this.#promotePending(consumer)) { @@ -573,7 +574,7 @@ class BroadcastImpl { } while (consumer.pending.length > 0) { ArrayPrototypeShift(consumer.pending).resolve( - { __proto__: null, done: true, value: undefined }); + new IterResult(true, undefined)); } } diff --git a/lib/internal/streams/iter/from.js b/lib/internal/streams/iter/from.js index 9f39e0f614a..78b61b267de 100644 --- a/lib/internal/streams/iter/from.js +++ b/lib/internal/streams/iter/from.js @@ -53,6 +53,7 @@ const { } = require('internal/streams/iter/types'); const { + IterResult, getProtocolMethod, toUint8Array, } = require('internal/streams/iter/utils'); @@ -388,7 +389,7 @@ function yieldNormalizationAbortable(source, context) { return ObjectSetPrototypeOf({ async next() { if (completed) { - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); } throwIfNormalizationCancelled(context); reading = true; @@ -406,12 +407,12 @@ function yieldNormalizationAbortable(source, context) { throwIfNormalizationCancelled(context); completed = true; closed = true; - return { __proto__: null, done: true, value: result.value }; + return new IterResult(true, result.value); } const value = result.value; reading = false; throwIfNormalizationCancelled(context); - return { __proto__: null, done: false, value }; + return new IterResult(false, value); } catch (error) { if (context.cancelled) await closeSource(true); reading = false; @@ -421,7 +422,7 @@ function yieldNormalizationAbortable(source, context) { async return(value) { await closeSource( context.suppressCleanup || (context.cancelled && reading)); - return { __proto__: null, done: true, value }; + return new IterResult(true, value); }, async throw(error) { await closeSource( diff --git a/lib/internal/streams/iter/pull.js b/lib/internal/streams/iter/pull.js index 70e89a99423..9a52a5fdfed 100644 --- a/lib/internal/streams/iter/pull.js +++ b/lib/internal/streams/iter/pull.js @@ -50,6 +50,7 @@ const { } = require('internal/streams/iter/from'); const { + IterResult, createBatchEntry, isTransformObject, parsePullArgs, @@ -914,7 +915,7 @@ function createAbortablePullIterator(source, transforms, signal) { }, return(value) { if (aborted) { - return PromiseResolve({ __proto__: null, done: true, value }); + return PromiseResolve(new IterResult(true, value)); } controller.abort(lazyDOMException('Aborted', 'AbortError')); return iterator.return(value); diff --git a/lib/internal/streams/iter/push.js b/lib/internal/streams/iter/push.js index 039e6b9f39d..d15f5752fa6 100644 --- a/lib/internal/streams/iter/push.js +++ b/lib/internal/streams/iter/push.js @@ -29,6 +29,7 @@ const { } = require('internal/streams/iter/types'); const { + IterResult, kPushDefaultBudget, kResolvedPromise, createBatchEntry, @@ -438,7 +439,7 @@ class PushQueue { async read() { if (this.#consumerState === 'returned') { - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); } if (this.#consumerState === 'thrown') { throw this.#consumerError; @@ -448,17 +449,17 @@ class PushQueue { if (this.#slots.length > 0) { const result = this.#drain(); this.#resolvePendingWrites(); - return { __proto__: null, done: false, value: result }; + return new IterResult(false, result); } // Buffer empty and writer closing = drain complete if (this.#writerState === 'closing') { this.endDrained(); - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); } if (this.#writerState === 'closed') { - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); } if (this.#writerState === 'errored') { @@ -540,7 +541,7 @@ class PushQueue { while (this.#pendingReads.length > 0) { if (this.#consumerState === 'returned') { const pending = this.#pendingReads.shift(); - pending.resolve({ __proto__: null, done: true, value: undefined }); + pending.resolve(new IterResult(true, undefined)); } else if (this.#consumerState === 'thrown') { const pending = this.#pendingReads.shift(); pending.reject(this.#consumerError); @@ -549,7 +550,7 @@ class PushQueue { try { const result = this.#drain(); this.#resolvePendingWrites(); - pending.resolve({ __proto__: null, done: false, value: result }); + pending.resolve(new IterResult(false, result)); } catch (error) { pending.reject(error); } @@ -558,10 +559,10 @@ class PushQueue { this.#pendingWrites.length === 0) { this.endDrained(); const pending = this.#pendingReads.shift(); - pending.resolve({ __proto__: null, done: true, value: undefined }); + pending.resolve(new IterResult(true, undefined)); } else if (this.#writerState === 'closed') { const pending = this.#pendingReads.shift(); - pending.resolve({ __proto__: null, done: true, value: undefined }); + pending.resolve(new IterResult(true, undefined)); } else if (this.#writerState === 'errored') { const pending = this.#pendingReads.shift(); pending.reject(this.#writerError); @@ -740,7 +741,7 @@ function createReadable(queue) { }, async return() { queue.consumerReturn(); - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); }, async throw(error) { queue.consumerThrow(error); diff --git a/lib/internal/streams/iter/share.js b/lib/internal/streams/iter/share.js index a61d4627ad5..937528b3929 100644 --- a/lib/internal/streams/iter/share.js +++ b/lib/internal/streams/iter/share.js @@ -38,6 +38,7 @@ const { } = require('internal/streams/iter/pull'); const { + IterResult, kMultiConsumerDefaultBudget, createBatchEntry, getProtocolMethod, @@ -175,7 +176,7 @@ class ShareImpl { for (;;) { if (state.detached) { if (state.error !== kNoShareError) throw state.error; - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); } if (self.#cancelled) { @@ -183,7 +184,7 @@ class ShareImpl { state.error = self.#cancelError; self.#deleteConsumer(state); if (state.error !== kNoShareError) throw state.error; - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); } // Check if data is available in buffer @@ -196,7 +197,7 @@ class ShareImpl { --self.#cachedMinCursorConsumers === 0) { self.#tryTrimBuffer(); } - return { __proto__: null, done: false, value: chunk }; + return new IterResult(false, chunk); } if (self.#sourceExhausted) { @@ -206,7 +207,7 @@ class ShareImpl { state.error = self.#sourceError; throw state.error; } - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); } // Need to pull from source - check buffer limit @@ -225,7 +226,7 @@ class ShareImpl { state.error = self.#cancelError; self.#deleteConsumer(state); if (state.error !== kNoShareError) throw state.error; - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); } await self.#pullFromSource(!shouldBuffer); @@ -253,7 +254,7 @@ class ShareImpl { if (self.#deleteConsumer(state)) { self.#tryTrimBuffer(); } - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); }, async throw() { @@ -263,7 +264,7 @@ class ShareImpl { if (self.#deleteConsumer(state)) { self.#tryTrimBuffer(); } - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); }, }, null); }, @@ -302,7 +303,7 @@ class ShareImpl { if (hasReason) { consumer.reject?.(reason); } else { - consumer.resolve({ __proto__: null, done: true, value: undefined }); + consumer.resolve(new IterResult(true, undefined)); } consumer.resolve = null; consumer.reject = null; @@ -406,7 +407,7 @@ class ShareImpl { }, async return() { return syncIterator.return?.() ?? - { __proto__: null, done: true, value: undefined }; + new IterResult(true, undefined); }, }, null); } else { @@ -594,7 +595,7 @@ class SyncShareImpl { next() { if (state.detached) { if (state.error !== kNoShareError) throw state.error; - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); } if (self.#sourceError !== kNoShareError) { state.detached = true; @@ -605,7 +606,7 @@ class SyncShareImpl { if (self.#cancelled) { state.detached = true; self.#deleteConsumer(state); - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); } const bufferIndex = state.cursor - self.#bufferStart; @@ -617,13 +618,13 @@ class SyncShareImpl { --self.#cachedMinCursorConsumers === 0) { self.#tryTrimBuffer(); } - return { __proto__: null, done: false, value: chunk }; + return new IterResult(false, chunk); } if (self.#sourceExhausted) { state.detached = true; self.#deleteConsumer(state); - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); } // Check buffer limit. 'unbounded' and 'drop-newest' are rejected @@ -680,16 +681,16 @@ class SyncShareImpl { --self.#cachedMinCursorConsumers === 0) { self.#tryTrimBuffer(); } - return { __proto__: null, done: false, value: chunk }; + return new IterResult(false, chunk); } if (self.#sourceExhausted) { state.detached = true; self.#deleteConsumer(state); - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); } - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); }, return() { @@ -697,7 +698,7 @@ class SyncShareImpl { if (self.#deleteConsumer(state)) { self.#tryTrimBuffer(); } - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); }, throw() { @@ -705,7 +706,7 @@ class SyncShareImpl { if (self.#deleteConsumer(state)) { self.#tryTrimBuffer(); } - return { __proto__: null, done: true, value: undefined }; + return new IterResult(true, undefined); }, }, null); }, diff --git a/lib/internal/streams/iter/utils.js b/lib/internal/streams/iter/utils.js index 2f72a78c0d2..0c6e1daaa32 100644 --- a/lib/internal/streams/iter/utils.js +++ b/lib/internal/streams/iter/utils.js @@ -7,6 +7,8 @@ const { ArrayBufferPrototypeGetResizable, ArrayPrototypePush, ArrayPrototypeSlice, + ObjectDefineProperty, + ObjectFreeze, PromiseResolve, PromiseWithResolvers, SafePromisePrototypeFinally, @@ -61,6 +63,30 @@ const kPushDefaultBudget = 16384; /** Default byte budget for broadcast and share streams (multi-consumer). */ const kMultiConsumerDefaultBudget = 65536; +/** + * Iterator result object (`{ done, value }`) for the iterators returned by + * this module. A result is created for every chunk, so it must be cheap. + * + * `new IterResult(done, value)` literals are created in V8 dictionary + * mode, which costs several times more than an ordinary object. Instances + * of this constructor have fast properties, always with the same shape + * (`done` before `value`), and still have no %Object.prototype% in their + * prototype chain, so a polluted `Object.prototype.then` cannot turn a + * result into a thenable when an async `next()` resolves with it. The + * prototype is a single empty, frozen, null-prototype object (V8 gives + * objects fast properties once they are used as a prototype). + * @param {boolean} done + * @param {any} value + */ +function IterResult(done, value) { + this.done = done; + this.value = value; +} +// The non-enumerable `constructor` lets util.inspect() print results as +// `IterResult { done, value }`. +IterResult.prototype = ObjectFreeze(ObjectDefineProperty( + { __proto__: null }, 'constructor', { __proto__: null, value: IterResult })); + /** * Register a handler for an AbortSignal, handling the already-aborted case. * If the signal is already aborted, calls handler immediately. @@ -539,6 +565,7 @@ function validateBackpressure(value) { } module.exports = { + IterResult, kMultiConsumerDefaultBudget, kPushDefaultBudget, kResolvedPromise, diff --git a/test/parallel/test-stream-iter-broadcast-basic.js b/test/parallel/test-stream-iter-broadcast-basic.js index 232439cdf7d..c59689c2d12 100644 --- a/test/parallel/test-stream-iter-broadcast-basic.js +++ b/test/parallel/test-stream-iter-broadcast-basic.js @@ -385,8 +385,7 @@ async function testOverlappingNextKeepsEarlierRead() { assert.strictEqual(Buffer.concat(result.value).toString(), 'x'); writer.endSync(); - assert.deepStrictEqual(await second, { - __proto__: null, + assert.deepStrictEqual({ ...await second }, { done: true, value: undefined, }); diff --git a/test/parallel/test-stream-iter-broadcast-from.js b/test/parallel/test-stream-iter-broadcast-from.js index b76a2b31b7f..8bc2abde2e1 100644 --- a/test/parallel/test-stream-iter-broadcast-from.js +++ b/test/parallel/test-stream-iter-broadcast-from.js @@ -144,8 +144,7 @@ async function testBroadcastFromCancelWhileBlocked() { let writesAfterCancel = 0; writer.writevSync = () => { writesAfterCancel++; return true; }; bc.cancel(); - assert.deepStrictEqual(await pendingRead, { - __proto__: null, + assert.deepStrictEqual({ ...await pendingRead }, { done: true, value: undefined, }); diff --git a/test/parallel/test-stream-iter-iterator-result.js b/test/parallel/test-stream-iter-iterator-result.js new file mode 100644 index 00000000000..4f29bf05534 --- /dev/null +++ b/test/parallel/test-stream-iter-iterator-result.js @@ -0,0 +1,79 @@ +// Flags: --experimental-stream-iter +'use strict'; + +// Iterator results created by the stream/iter iterators themselves do not +// inherit from Object.prototype, so prototype pollution cannot affect them. +// (Iterators implemented as async generators, such as the one returned by +// pull(), return ordinary iterator results created by the engine.) + +const common = require('../common'); +const assert = require('assert'); +const { inspect } = require('util'); +const { + broadcast, + from, + push, + share, + shareSync, +} = require('stream/iter'); + +function assertResult(result, done) { + assert.strictEqual(result instanceof Object, false); + assert.deepStrictEqual(Object.keys(result), ['done', 'value']); + assert.strictEqual(result.done, done); + assert.match(inspect(result), /^IterResult \{ done: (true|false), value: /); +} + +async function testAsyncIterators() { + const sources = { + 'push()': () => { + const { writer, readable } = push(); + writer.writeSync('a'); + writer.endSync(); + return readable; + }, + 'share()': () => share(from('a')).pull(), + 'broadcast()': () => { + const { writer, broadcast: bc } = broadcast(); + const consumer = bc.push(); + writer.writeSync('a'); + writer.endSync(); + return consumer; + }, + }; + for (const create of Object.values(sources)) { + const iterator = create()[Symbol.asyncIterator](); + assertResult(await iterator.next(), false); + assertResult(await iterator.next(), true); + } +} + +function testShareSync() { + const iterator = shareSync(['a']).pull()[Symbol.iterator](); + assertResult(iterator.next(), false); + assertResult(iterator.next(), true); +} + +async function testPollutedThen() { + // Resolving an async next() with an object looks up `then`. Results must + // not pick it up from a polluted Object.prototype. + const { writer, readable } = push(); + writer.writeSync('ab'); + writer.endSync(); + const iterator = readable[Symbol.asyncIterator](); + Object.prototype.then = common.mustNotCall('Object.prototype.then'); + try { + const first = await iterator.next(); + assert.strictEqual(first.done, false); + assert.strictEqual(new TextDecoder().decode(first.value[0]), 'ab'); + assert.strictEqual((await iterator.next()).done, true); + } finally { + delete Object.prototype.then; + } +} + +(async () => { + await testAsyncIterators(); + testShareSync(); + await testPollutedThen(); +})().then(common.mustCall()); diff --git a/test/parallel/test-stream-iter-pull-async.js b/test/parallel/test-stream-iter-pull-async.js index 632306fa589..71fc27426ea 100644 --- a/test/parallel/test-stream-iter-pull-async.js +++ b/test/parallel/test-stream-iter-pull-async.js @@ -79,8 +79,8 @@ async function testPullWithAbortSignal() { await assert.rejects(iterator.next(), (error) => error === signal.reason); await assert.rejects(iterator.next(), (error) => error === signal.reason); assert.strictEqual(started, false); - assert.deepStrictEqual(await iterator.return(), - { __proto__: null, done: true, value: undefined }); + assert.deepStrictEqual({ ...await iterator.return() }, + { done: true, value: undefined }); await assert.rejects(text(pull(gen(), (chunks) => chunks, { signal })), (error) => error === signal.reason); diff --git a/test/parallel/test-stream-iter-reason-propagation.js b/test/parallel/test-stream-iter-reason-propagation.js index 7511dbb2c41..58ae7d4e5f4 100644 --- a/test/parallel/test-stream-iter-reason-propagation.js +++ b/test/parallel/test-stream-iter-reason-propagation.js @@ -249,8 +249,7 @@ async function testCompletedBroadcastConsumerStaysCompleted() { await iterator.return(); writer.fail(undefined); - assert.deepStrictEqual(await iterator.next(), { - __proto__: null, + assert.deepStrictEqual({ ...await iterator.next() }, { done: true, value: undefined, }); diff --git a/test/parallel/test-stream-iter-share-coverage.js b/test/parallel/test-stream-iter-share-coverage.js index fee28ae1568..73827f2d40f 100644 --- a/test/parallel/test-stream-iter-share-coverage.js +++ b/test/parallel/test-stream-iter-share-coverage.js @@ -113,8 +113,7 @@ async function testCompletedSyncConsumerStaysCompleted() { assert.strictEqual(error, reason); } assert.strictEqual(caught, true); - assert.deepStrictEqual(completed.next(), { - __proto__: null, + assert.deepStrictEqual({ ...completed.next() }, { done: true, value: undefined, }); From b58e5b64b53a33a283e183d5f134e336c5656058 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sun, 4 Oct 2026 02:13:10 +0000 Subject: [PATCH 017/331] stream: avoid per-write allocations in stream/iter writers MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Every write() and writeSync() allocated a `{ __proto__: null, context }` options object for the WebIDL chunk conversion, and for a Uint8Array chunk a second, six-property one with [AllowShared] and [AllowResizable]. Both are created in V8 dictionary mode. Return Uint8Array chunks directly from the WriterChunk converter: with [AllowShared] and [AllowResizable], the Uint8Array conversion cannot reject a value isUint8Array() accepts and returns the same object. Use shared, frozen conversion contexts for chunks, chunk sequences and write options; the converters only read them to build error messages. Writing 1e6 16-byte Uint8Array chunks into a push() stream and reading them back is about 27% faster with writeSync() and with writevSync() (4 chunks per call). String chunks are unaffected. Behavior and error messages are unchanged. Assisted-by: OpenCode Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/66648 Reviewed-By: Trivikram Kamat Reviewed-By: Gürgün Dayıoğlu --- lib/internal/streams/iter/utils.js | 23 +++++++++++------------ lib/internal/streams/iter/webidl.js | 20 +++++--------------- 2 files changed, 16 insertions(+), 27 deletions(-) diff --git a/lib/internal/streams/iter/utils.js b/lib/internal/streams/iter/utils.js index 0c6e1daaa32..d50ec639ab7 100644 --- a/lib/internal/streams/iter/utils.js +++ b/lib/internal/streams/iter/utils.js @@ -412,6 +412,14 @@ function concatBytes(chunks) { return concatenated; } +// Conversion contexts for the per-write paths. The converters only read +// them (to build error messages), so they are shared rather than allocated +// on every write. +const kChunkContext = ObjectFreeze({ __proto__: null, context: 'chunk' }); +const kChunksContext = ObjectFreeze({ __proto__: null, context: 'chunks' }); +const kWriteOptionsContext = + ObjectFreeze({ __proto__: null, context: 'options' }); + /** * Convert an array of chunks (strings or Uint8Arrays) to a Uint8Array[]. * Always returns a fresh copy of the array. @@ -419,10 +427,7 @@ function concatBytes(chunks) { * @returns {Uint8Array[]} */ function convertChunks(chunks) { - chunks = converters.WriterChunkSequence(chunks, { - __proto__: null, - context: 'chunks', - }); + chunks = converters.WriterChunkSequence(chunks, kChunksContext); const len = chunks.length; const result = new Array(len); for (let i = 0; i < len; i++) { @@ -437,17 +442,11 @@ function convertChunks(chunks) { * @returns {AbortSignal|undefined} */ function getWriterSignal(options) { - return converters.WriteOptions(options, { - __proto__: null, - context: 'options', - }).signal; + return converters.WriteOptions(options, kWriteOptionsContext).signal; } function toWriterUint8Array(chunk) { - return toUint8Array(converters.WriterChunk(chunk, { - __proto__: null, - context: 'chunk', - })); + return toUint8Array(converters.WriterChunk(chunk, kChunkContext)); } /** diff --git a/lib/internal/streams/iter/webidl.js b/lib/internal/streams/iter/webidl.js index ef61abb7794..6ee1afd622a 100644 --- a/lib/internal/streams/iter/webidl.js +++ b/lib/internal/streams/iter/webidl.js @@ -27,17 +27,6 @@ function enforceRangeUnsignedLongLong(value, options = { __proto__: null }) { }); } -function allowStreamBufferOptions(options) { - return { - __proto__: null, - prefix: options.prefix, - context: options.context, - code: options.code, - allowShared: true, - allowResizable: true, - }; -} - converters.AbortSignal = baseConverters.AbortSignal; converters.BackpressurePolicy = createEnumConverter('BackpressurePolicy', [ 'strict', @@ -48,10 +37,11 @@ converters.BackpressurePolicy = createEnumConverter('BackpressurePolicy', [ converters.unsignedLongLong = unsignedLongLong; converters.enforceRangeUnsignedLongLong = enforceRangeUnsignedLongLong; converters.WriterChunk = (value, options = { __proto__: null }) => { - if (isUint8Array(value)) { - return baseConverters.Uint8Array( - value, allowStreamBufferOptions(options)); - } + // The chunk is a Uint8Array with [AllowShared] and [AllowResizable]. The + // Uint8Array conversion cannot reject a value isUint8Array() accepts when + // both are allowed, and returns the same object, so skip it: writes are + // hot, and the conversion would need its own options object. + if (isUint8Array(value)) return value; return baseConverters.USVString(value, options); }; converters.WriterChunkSequence = createSequenceConverter( From d164ecd7ff61034637d2ed3a15486283f3f1d8c8 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sun, 4 Oct 2026 02:21:50 +0000 Subject: [PATCH 018/331] stream: construct stream/iter byte view snapshots and batch entries MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit createBatchEntry() and recordChunk() snapshot every chunk in a seven-property `{ __proto__: null, ... }` literal, and every batch gets a `{ __proto__: null, views, byteLength }` record. V8 creates such literals in dictionary mode, which is expensive for objects created for every chunk. Create them with constructors whose prototype is an empty, frozen, null-prototype object instead, as for IterResult. They have fast properties and a single shape, and are only used internally. Writing 1e6 16-byte chunks into a push() stream and reading them back is about 6x faster with writeSync(), 3.7x faster with writevSync() (4 chunks per call) and 1.7x faster with string chunks. benchmark/streams/iter-throughput-share-sync.js improves by 67-93%, iter-throughput-share.js by 4-8%, and iter-throughput-broadcast.js with 4 consumers by 8%. pipeTo() with small chunks is about 1.5x faster. Assisted-by: OpenCode Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/66648 Reviewed-By: Trivikram Kamat Reviewed-By: Gürgün Dayıoğlu --- lib/internal/streams/iter/utils.js | 45 +++++++++++++++++++----------- 1 file changed, 28 insertions(+), 17 deletions(-) diff --git a/lib/internal/streams/iter/utils.js b/lib/internal/streams/iter/utils.js index d50ec639ab7..915e5340ceb 100644 --- a/lib/internal/streams/iter/utils.js +++ b/lib/internal/streams/iter/utils.js @@ -217,23 +217,35 @@ function toUint8Array(chunk) { return chunk; } +// Byte view snapshots and batch entries are created for every chunk and +// every batch, so like IterResult they are constructed rather than created +// as `{ __proto__: null, ... }` literals (which are dictionary-mode objects), +// and their prototype is an empty null-prototype object. +function ByteViewSnapshot(value, buffer, sharedBufferView) { + this.value = value; + this.buffer = buffer; + this.bufferByteLength = sharedBufferView === undefined ? + ArrayBufferPrototypeGetByteLength(buffer) : + TypedArrayPrototypeGetByteLength(sharedBufferView); + this.byteLength = TypedArrayPrototypeGetByteLength(value); + this.byteOffset = TypedArrayPrototypeGetByteOffset(value); + this.detached = sharedBufferView === undefined && + ArrayBufferPrototypeGetDetached(buffer); + this.sharedBufferView = sharedBufferView; +} +ByteViewSnapshot.prototype = ObjectFreeze({ __proto__: null }); + +function BatchEntry(views, byteLength) { + this.views = views; + this.byteLength = byteLength; +} +BatchEntry.prototype = ObjectFreeze({ __proto__: null }); + function snapshotByteView(value) { const buffer = TypedArrayPrototypeGetBuffer(value); const sharedBufferView = isSharedArrayBuffer(buffer) ? new Uint8Array(buffer) : undefined; - return { - __proto__: null, - value, - buffer, - bufferByteLength: sharedBufferView === undefined ? - ArrayBufferPrototypeGetByteLength(buffer) : - TypedArrayPrototypeGetByteLength(sharedBufferView), - byteLength: TypedArrayPrototypeGetByteLength(value), - byteOffset: TypedArrayPrototypeGetByteOffset(value), - detached: sharedBufferView === undefined && - ArrayBufferPrototypeGetDetached(buffer), - sharedBufferView, - }; + return new ByteViewSnapshot(value, buffer, sharedBufferView); } function validateByteView(snapshot) { @@ -325,7 +337,7 @@ function createBatchEntry(chunks) { views[i] = view; byteLength += view.byteLength; } - return { __proto__: null, views, byteLength }; + return new BatchEntry(views, byteLength); } /** @@ -345,15 +357,14 @@ function splitBatchEntry(entry, limit) { for (let i = 0; i < views.length; i++) { const view = views[i]; if (current.length > 0 && byteLength + view.byteLength >= limit) { - ArrayPrototypePush(entries, - { __proto__: null, views: current, byteLength }); + ArrayPrototypePush(entries, new BatchEntry(current, byteLength)); current = []; byteLength = 0; } ArrayPrototypePush(current, view); byteLength += view.byteLength; } - ArrayPrototypePush(entries, { __proto__: null, views: current, byteLength }); + ArrayPrototypePush(entries, new BatchEntry(current, byteLength)); return entries; } From 80c84f9ac7eda3d6a3e674e980f547d3ba6b42b6 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sun, 4 Oct 2026 02:28:24 +0000 Subject: [PATCH 019/331] stream: construct stream/iter wait and merge records MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The records queued when a stream/iter read, write or drain has to wait, and merge()'s ready-queue entries, were `{ __proto__: null, ... }` literals, which V8 creates in dictionary mode. They can be created once per chunk: whenever the consumer is ahead of the producer, every read waits, and with a full budget every write does. Create them with constructors whose prototype is an empty, frozen, null-prototype object: PendingRequest and PendingWrite (push(), broadcast() and fromWritable()), QueuedWrite (fromWritable()) and MergeEntry (merge()). fromWritable() drain waiters now settle through resolve(false) instead of a per-waiter close() closure. merge() tells error entries apart by their missing iterator rather than by a kind string. When every push() read waits for data, or every write waits behind a full budget, reading or writing 16-byte chunks is about 30% faster. fromWritable() with queued writes is about 18% faster, and merge() of two sources about 9% faster. Assisted-by: OpenCode Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/66648 Reviewed-By: Trivikram Kamat Reviewed-By: Gürgün Dayıoğlu --- lib/internal/streams/iter/broadcast.js | 8 ++++--- lib/internal/streams/iter/classic.js | 32 ++++++++++++++------------ lib/internal/streams/iter/consumers.js | 27 ++++++++++++---------- lib/internal/streams/iter/push.js | 8 ++++--- lib/internal/streams/iter/utils.js | 17 ++++++++++++++ 5 files changed, 59 insertions(+), 33 deletions(-) diff --git a/lib/internal/streams/iter/broadcast.js b/lib/internal/streams/iter/broadcast.js index df2a701f20c..e395b5e84f2 100644 --- a/lib/internal/streams/iter/broadcast.js +++ b/lib/internal/streams/iter/broadcast.js @@ -58,6 +58,8 @@ const { const { IterResult, + PendingRequest, + PendingWrite, kMultiConsumerDefaultBudget, kResolvedPromise, convertChunks, @@ -264,7 +266,7 @@ class BroadcastImpl { if (state.resolve) { const { promise, resolve, reject } = PromiseWithResolvers(); ArrayPrototypePush(state.pending, - { __proto__: null, resolve, reject }); + new PendingRequest(resolve, reject)); return promise; } @@ -625,7 +627,7 @@ class BroadcastWriter { if (canWrite === null) return null; if (canWrite) return PromiseResolve(true); const { promise, resolve, reject } = PromiseWithResolvers(); - ArrayPrototypePush(this.#pendingDrains, { __proto__: null, resolve, reject }); + ArrayPrototypePush(this.#pendingDrains, new PendingRequest(resolve, reject)); return promise; } @@ -802,7 +804,7 @@ class BroadcastWriter { */ #createPendingWrite(batch, signal) { const { promise, resolve, reject } = PromiseWithResolvers(); - const entry = { __proto__: null, batch, resolve, reject }; + const entry = new PendingWrite(batch, resolve, reject); this.#pendingWrites.push(entry); if (signal) { wireBroadcastWriteSignal(entry, signal, resolve, reject, this); diff --git a/lib/internal/streams/iter/classic.js b/lib/internal/streams/iter/classic.js index 2c1fa640714..2a7b818efd9 100644 --- a/lib/internal/streams/iter/classic.js +++ b/lib/internal/streams/iter/classic.js @@ -14,6 +14,7 @@ const { ArrayPrototypePush, FunctionPrototypeCall, + ObjectFreeze, Promise, PromisePrototypeThen, PromiseReject, @@ -61,6 +62,7 @@ const { } = require('internal/streams/iter/types'); const { + PendingRequest, convertChunks, getWriterSignal, onSignalAbort, @@ -522,6 +524,18 @@ function toReadableSync(source, options = kNullPrototype) { // Cache: one Writer adapter per Writable instance. const fromWritableCache = new SafeWeakMap(); +// A write queued by fromWritable() until the writable can accept it. Like +// the other per-write records, constructed rather than created as a +// `{ __proto__: null, ... }` literal (a dictionary-mode object). +function QueuedWrite(chunks, resolve, reject) { + this.chunks = chunks; + this.resolve = resolve; + this.reject = reject; + this.signal = undefined; + this.onAbort = undefined; +} +QueuedWrite.prototype = ObjectFreeze({ __proto__: null }); + /** * Create a stream/iter Writer adapter from a classic Writable (or duck-type). * @@ -643,7 +657,7 @@ function fromWritable(writable, options = kNullPrototype) { if (preserveReason) { pending[i].reject(reason); } else { - pending[i].close(); + pending[i].resolve(false); } } @@ -755,14 +769,7 @@ function fromWritable(writable, options = kNullPrototype) { function queueWrite(chunks, signal) { const { promise, resolve, reject } = PromiseWithResolvers(); - const entry = { - __proto__: null, - chunks, - resolve, - reject, - signal: undefined, - onAbort: undefined, - }; + const entry = new QueuedWrite(chunks, resolve, reject); pendingWrites.push(entry); installDrainListener(); @@ -1038,12 +1045,7 @@ function fromWritable(writable, options = kNullPrototype) { return PromiseResolve(true); } const { promise, resolve, reject } = PromiseWithResolvers(); - ArrayPrototypePush(drainWaiters, { - __proto__: null, - resolve, - reject, - close() { resolve(false); }, - }); + ArrayPrototypePush(drainWaiters, new PendingRequest(resolve, reject)); installDrainListener(); return promise; }; diff --git a/lib/internal/streams/iter/consumers.js b/lib/internal/streams/iter/consumers.js index a18794aa732..8678e8235ac 100644 --- a/lib/internal/streams/iter/consumers.js +++ b/lib/internal/streams/iter/consumers.js @@ -17,6 +17,7 @@ const { ArrayPrototypeShift, ArrayPrototypeSlice, FunctionPrototypeCall, + ObjectFreeze, Promise, PromisePrototypeThen, SafePromiseAllReturnVoid, @@ -456,6 +457,16 @@ function ondrain(drainable) { const kNoMergeError = Symbol('kNoMergeError'); +// An entry in merge()'s ready queue: a value from `iterator`, or, for a +// source that failed, `reason` with no iterator. Created for every merged +// chunk, so constructed rather than created as a dictionary-mode literal. +function MergeEntry(iterator, value, reason) { + this.iterator = iterator; + this.value = value; + this.reason = reason; +} +MergeEntry.prototype = ObjectFreeze({ __proto__: null }); + /** * Merge multiple async iterables by yielding values in temporal order. * @param {...(AsyncIterable|object)} args @@ -531,12 +542,8 @@ function merge(...args) { if (result.done) { activeCount--; } else { - ArrayPrototypePush(ready, { - __proto__: null, - kind: 'value', - iterator, - value: result.value, - }); + ArrayPrototypePush(ready, + new MergeEntry(iterator, result.value, undefined)); } if (waitResolve) { waitResolve(); @@ -547,11 +554,7 @@ function merge(...args) { const onRejected = (iterator, reason) => { pendingPulls.delete(iterator); if (stopped) return; - ArrayPrototypePush(ready, { - __proto__: null, - kind: 'error', - reason, - }); + ArrayPrototypePush(ready, new MergeEntry(undefined, undefined, reason)); if (waitResolve) { waitResolve(); waitResolve = null; @@ -579,7 +582,7 @@ function merge(...args) { // Drain ready queue synchronously while (ready.length > 0) { const item = ArrayPrototypeShift(ready); - if (item.kind === 'error') { + if (item.iterator === undefined) { throw item.reason; } yield item.value; diff --git a/lib/internal/streams/iter/push.js b/lib/internal/streams/iter/push.js index d15f5752fa6..b5db45a1a32 100644 --- a/lib/internal/streams/iter/push.js +++ b/lib/internal/streams/iter/push.js @@ -30,6 +30,8 @@ const { const { IterResult, + PendingRequest, + PendingWrite, kPushDefaultBudget, kResolvedPromise, createBatchEntry, @@ -294,7 +296,7 @@ class PushQueue { */ #createPendingWrite(batch, signal) { const { promise, resolve, reject } = PromiseWithResolvers(); - const entry = { __proto__: null, batch, resolve, reject }; + const entry = new PendingWrite(batch, resolve, reject); this.#pendingWrites.push(entry); if (signal) { @@ -429,7 +431,7 @@ class PushQueue { */ waitForDrain() { const { promise, resolve, reject } = PromiseWithResolvers(); - ArrayPrototypePush(this.#pendingDrains, { __proto__: null, resolve, reject }); + ArrayPrototypePush(this.#pendingDrains, new PendingRequest(resolve, reject)); return promise; } @@ -467,7 +469,7 @@ class PushQueue { } const { promise, resolve, reject } = PromiseWithResolvers(); - this.#pendingReads.push({ __proto__: null, resolve, reject }); + this.#pendingReads.push(new PendingRequest(resolve, reject)); return promise; } diff --git a/lib/internal/streams/iter/utils.js b/lib/internal/streams/iter/utils.js index 915e5340ceb..8b0c074b4e1 100644 --- a/lib/internal/streams/iter/utils.js +++ b/lib/internal/streams/iter/utils.js @@ -241,6 +241,21 @@ function BatchEntry(views, byteLength) { } BatchEntry.prototype = ObjectFreeze({ __proto__: null }); +// Waiters for reads, writes and drains are queued whenever a stream has +// to wait, which can be once per chunk. +function PendingRequest(resolve, reject) { + this.resolve = resolve; + this.reject = reject; +} +PendingRequest.prototype = ObjectFreeze({ __proto__: null }); + +function PendingWrite(batch, resolve, reject) { + this.batch = batch; + this.resolve = resolve; + this.reject = reject; +} +PendingWrite.prototype = ObjectFreeze({ __proto__: null }); + function snapshotByteView(value) { const buffer = TypedArrayPrototypeGetBuffer(value); const sharedBufferView = isSharedArrayBuffer(buffer) ? @@ -576,6 +591,8 @@ function validateBackpressure(value) { module.exports = { IterResult, + PendingRequest, + PendingWrite, kMultiConsumerDefaultBudget, kPushDefaultBudget, kResolvedPromise, From bd793f131377ebacc3f362808da33a61b404e9a2 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sun, 4 Oct 2026 02:35:56 +0000 Subject: [PATCH 020/331] stream: construct the options passed to stream/iter transforms MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit pull() passes every stateless transform call a new `{ __proto__: null, signal }` options object, which V8 creates in dictionary mode, once per batch and transform. Create the options with a TransformOptions constructor instead, for stateful transforms as well so that both forms receive the same kind of object. Each call still gets its own object, as the pipeline requires. Its prototype is a single frozen object with no %Object.prototype% in its chain, so a transform cannot pass state to other transforms through it, and with a non-enumerable `constructor` so that util.inspect() prints `TransformOptions { signal }`. With 300,000 single-chunk batches, pull() is about 2% faster with one stateless transform and about 8% faster with four. This is observable: the options object's prototype is no longer null. A new test covers the options contract, and the documentation now describes it, including that pullSync() passes transforms no options. Assisted-by: OpenCode Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/66648 Reviewed-By: Trivikram Kamat Reviewed-By: Gürgün Dayıoğlu --- doc/api/stream_iter.md | 6 ++++ lib/internal/streams/iter/pull.js | 27 ++++++++++---- test/parallel/test-stream-iter-pull-async.js | 37 ++++++++++++++++++++ 3 files changed, 64 insertions(+), 6 deletions(-) diff --git a/doc/api/stream_iter.md b/doc/api/stream_iter.md index 5dccdcae2ce..539ebdf5a60 100644 --- a/doc/api/stream_iter.md +++ b/doc/api/stream_iter.md @@ -140,6 +140,12 @@ Both forms receive an `options` parameter with the following property: can check `signal.aborted` or listen for the `'abort'` event to perform early cleanup. +In `pull()`, stateless transforms receive a new `options` object for every +call, and stateful transforms one for the pipeline, so a transform can modify +its `options` without affecting other transforms. The object does not inherit +from `Object.prototype`. Transforms passed to [`pullSync()`][] receive no +`options`. + The flush signal (`null`) is sent after the source ends, giving transforms a chance to emit trailing data (e.g., compression footers). diff --git a/lib/internal/streams/iter/pull.js b/lib/internal/streams/iter/pull.js index 9a52a5fdfed..35836dd27d6 100644 --- a/lib/internal/streams/iter/pull.js +++ b/lib/internal/streams/iter/pull.js @@ -11,6 +11,8 @@ const { ArrayPrototypePush, ArrayPrototypeSlice, FunctionPrototypeCall, + ObjectDefineProperty, + ObjectFreeze, ObjectSetPrototypeOf, PromisePrototypeThen, PromiseReject, @@ -564,6 +566,19 @@ function* createSyncPipeline(source, transforms) { // Async Pipeline Implementation // ============================================================================= +// The options object passed to async transforms. Stateless transforms get a +// new one for every call, so it is constructed rather than created as a +// `{ __proto__: null, signal }` literal (a dictionary-mode object). The +// prototype is frozen and has no %Object.prototype% in its chain, and the +// non-enumerable `constructor` lets util.inspect() print the options as +// `TransformOptions { signal }`. +function TransformOptions(signal) { + this.signal = signal; +} +TransformOptions.prototype = ObjectFreeze(ObjectDefineProperty( + { __proto__: null }, 'constructor', + { __proto__: null, value: TransformOptions })); + /** * Apply a single stateless async transform to a source. * @yields {Uint8Array[]} @@ -574,7 +589,7 @@ function* createSyncPipeline(source, transforms) { * avoiding the overhead of N async generator ticks for N transforms. * * INVARIANT: This function accepts a signal, NOT a pre-built options object. - * A fresh { __proto__: null, signal } options object is created for each + * A fresh TransformOptions object is created for each * transform invocation to prevent cross-transform mutation. * @param {AsyncIterable} source * @param {Array} run - Array of stateless transform functions @@ -585,7 +600,7 @@ async function* applyFusedStatelessAsyncTransforms(source, run, signal) { for await (const chunks of source) { let current = chunks; for (let i = 0; i < run.length; i++) { - let result = run[i](current, { __proto__: null, signal }); + let result = run[i](current, new TransformOptions(signal)); if (isPromise(result)) result = await result; if (result === null) { current = null; @@ -628,14 +643,14 @@ async function* applyFusedStatelessAsyncTransforms(source, run, signal) { for (let j = 0; j < pending.length; j++) { const pendingResult = appendTransformResultAsync( next, - run[i](pending[j], { __proto__: null, signal })); + run[i](pending[j], new TransformOptions(signal))); if (pendingResult !== undefined) { await pendingResult; } } const flushResult = appendTransformResultAsync( next, - run[i](null, { __proto__: null, signal })); + run[i](null, new TransformOptions(signal))); if (flushResult !== undefined) { await flushResult; } @@ -742,7 +757,7 @@ async function* createAsyncPipeline(source, transforms, signal) { // generator layer to avoid unnecessary async generator ticks. // // INVARIANT: Each transform invocation MUST receive its own fresh options - // object ({ __proto__: null, signal }). Transforms may mutate the options + // object (new TransformOptions(signal)). Transforms may mutate the options // object, so sharing a single object across invocations would allow one // transform to corrupt the options seen by another. The signal is shared // across calls (mutations to it are acceptable), but the containing options @@ -763,7 +778,7 @@ async function* createAsyncPipeline(source, transforms, signal) { transformSignal); statelessRun = []; } - const opts = { __proto__: null, signal: transformSignal }; + const opts = new TransformOptions(transformSignal); if (transform[kValidatedTransform]) { current = applyValidatedStatefulAsyncTransform( current, transform.transform, transform.receiver, opts); diff --git a/test/parallel/test-stream-iter-pull-async.js b/test/parallel/test-stream-iter-pull-async.js index 71fc27426ea..5bffd49d511 100644 --- a/test/parallel/test-stream-iter-pull-async.js +++ b/test/parallel/test-stream-iter-pull-async.js @@ -16,6 +16,7 @@ const { } = require('stream/iter'); const { setImmediate } = require('timers/promises'); +const { inspect } = require('util'); async function testPullIdentity() { const data = await text(pull(from('hello-async'))); @@ -573,6 +574,41 @@ async function testTransformOptionsNotShared() { assert.strictEqual(seen[1].mutated, undefined); } +// Stateless transforms get a new options object for every call, and stateful +// transforms one for the pipeline. The options object has only `signal`, does +// not inherit from Object.prototype, and its prototype is frozen, so that a +// transform cannot pass state to others through it. +async function testTransformOptionsShape() { + const seen = []; + const stateless = (chunks, options) => { + seen.push(options); + return chunks; + }; + const stateful = { + async* transform(source, options) { + seen.push(options); + for await (const chunks of source) yield chunks; + }, + }; + const ac = new AbortController(); + await text(pull(from(['a', 'b']), stateless, stateful, + { signal: ac.signal })); + // Stateless: one call per batch plus the flush call. + assert.strictEqual(seen.length, 4); + assert.strictEqual(new Set(seen).size, seen.length); + for (const options of seen) { + assert.strictEqual(options instanceof Object, false); + assert.deepStrictEqual(Object.keys(options), ['signal']); + assert.ok(options.signal instanceof AbortSignal); + assert.strictEqual(Object.isFrozen(Object.getPrototypeOf(options)), true); + assert.match(inspect(options), /^TransformOptions \{ signal: /); + } + assert.strictEqual(Object.getPrototypeOf(seen[0]), + Object.getPrototypeOf(seen[3])); + assert.throws(() => { Object.getPrototypeOf(seen[0]).leak = true; }, + TypeError); +} + // Run the uncaughtException test sequentially (it installs a global handler // that would interfere with concurrent tests). (async () => { @@ -609,6 +645,7 @@ async function testTransformOptionsNotShared() { testTransformReturnsArrayBuffer(), testPipeToStringSource(), testTransformOptionsNotShared(), + testTransformOptionsShape(), ]); // Run after all concurrent tests complete to avoid global handler races await testTransformSignalListenerErrorOnSourceError(); From d99c0416df2df4d5f3fb839866983993a93aaf14 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sun, 4 Oct 2026 02:39:06 +0000 Subject: [PATCH 021/331] stream: do not miss 'drain' in fromWritable() MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit When a write filled the classic Writable, fromWritable() recorded that it needed to drain, but only listened for 'drain' once a later write was queued or something waited for drain. If the Writable emitted 'drain' before that, for example because its write callback ran on a microtask or with process.nextTick(), the event was missed and the flag was never cleared: the next write() or writev() never settled, canWrite stayed false and ondrain() never resolved. Listen for 'drain' as soon as a write returns false, and keep listening until it is emitted. Assisted-by: OpenCode Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/66648 Reviewed-By: Trivikram Kamat Reviewed-By: Gürgün Dayıoğlu --- lib/internal/streams/iter/classic.js | 7 ++++ ...est-stream-iter-from-writable-lifecycle.js | 33 +++++++++++++++++++ 2 files changed, 40 insertions(+) diff --git a/lib/internal/streams/iter/classic.js b/lib/internal/streams/iter/classic.js index 2a7b818efd9..0eafba0182b 100644 --- a/lib/internal/streams/iter/classic.js +++ b/lib/internal/streams/iter/classic.js @@ -621,7 +621,9 @@ function fromWritable(writable, options = kNullPrototype) { } function removeDrainListenerIfIdle() { + // Keep listening while needsDrain is set: it is only cleared by 'drain'. if (!drainListenerInstalled || + needsDrain || pendingWrites.length !== 0 || drainWaiters.length !== 0) { return; @@ -701,7 +703,12 @@ function fromWritable(writable, options = kNullPrototype) { for (let i = 0; i < chunks.length; i++) { const bytes = chunks[i]; if (!writable.write(bytes)) { + // Listen for 'drain' now, even if nothing is waiting yet: the + // Writable can emit it before the next write or wait (for example + // when its write callback runs on a microtask), and needsDrain + // would never be cleared. needsDrain = true; + installDrainListener(); ok = false; } totalBytes += TypedArrayPrototypeGetByteLength(bytes); diff --git a/test/parallel/test-stream-iter-from-writable-lifecycle.js b/test/parallel/test-stream-iter-from-writable-lifecycle.js index d5be23fdd03..450fe8d7359 100644 --- a/test/parallel/test-stream-iter-from-writable-lifecycle.js +++ b/test/parallel/test-stream-iter-from-writable-lifecycle.js @@ -277,7 +277,40 @@ async function testSignalAbortedByUnderlyingEnd() { assert.strictEqual(await ending, 0); } +// A write that fills the Writable resolves before 'drain'. If the Writable's +// write callback runs on a microtask or a tick, 'drain' can be emitted before +// the next write or wait; the adapter must not miss it. +async function testDrainBeforeNextWrite() { + for (const defer of [queueMicrotask, process.nextTick]) { + const writable = new Writable({ + highWaterMark: 4, + write(chunk, encoding, callback) { defer(callback); }, + }); + const writer = fromWritable(writable); + + for (let i = 0; i < 3; i++) { + await writer.write('abcd'); + } + await writer.writev(['ab', 'cd']); + await writer.writev(['ab', 'cd']); + + await setImmediate(); + assert.strictEqual(writer.canWrite, true); + // Nothing is waiting any more, so the 'drain' listener is removed. + assert.strictEqual(writable.listenerCount('drain'), 0); + + writer.write('abcd'); + assert.strictEqual(writer.canWrite, false); + assert.strictEqual(await ondrain(writer), true); + assert.strictEqual(writer.canWrite, true); + + await writer.end(); + assert.strictEqual(writable.listenerCount('drain'), 0); + } +} + Promise.all([ + testDrainBeforeNextWrite(), testQueuedWriteThrowsDuringFlush(), testQueuedWriteErrorsDuringFlush(), testWriteErrorsSynchronously(), From efa7bb55b10974bcf3e15ac475eaa2dfdb81a2ce Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sun, 4 Oct 2026 02:47:38 +0000 Subject: [PATCH 022/331] stream: share the once option for stream/iter abort listeners MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit stream/iter registered its one-time 'abort' listeners with a new `{ __proto__: null, once: true }` options object every time, which can be once per chunk (abortableNext()) or per waiting write. Use a single shared kNullOnceOption instead. It is frozen, because signals can come from user code and a patched addEventListener() must not be able to change the options for every later registration. The difference is small, since the listener registration itself costs much more: with 300,000 16-byte chunks, pull() with a signal is about 1.7% faster, push() writes that wait with a signal about 3% faster, and pipeTo() and bytes() with a signal are unchanged. Assisted-by: OpenCode Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/66648 Reviewed-By: Trivikram Kamat Reviewed-By: Gürgün Dayıoğlu --- lib/internal/streams/iter/broadcast.js | 5 +++-- lib/internal/streams/iter/classic.js | 6 ++---- lib/internal/streams/iter/consumers.js | 6 ++---- lib/internal/streams/iter/duplex.js | 4 ++-- lib/internal/streams/iter/pull.js | 6 +++--- lib/internal/streams/iter/push.js | 8 +++----- lib/internal/streams/iter/transform.js | 3 ++- lib/internal/streams/iter/utils.js | 10 ++++++++-- 8 files changed, 25 insertions(+), 23 deletions(-) diff --git a/lib/internal/streams/iter/broadcast.js b/lib/internal/streams/iter/broadcast.js index e395b5e84f2..00ed899d653 100644 --- a/lib/internal/streams/iter/broadcast.js +++ b/lib/internal/streams/iter/broadcast.js @@ -61,6 +61,7 @@ const { PendingRequest, PendingWrite, kMultiConsumerDefaultBudget, + kNullOnceOption, kResolvedPromise, convertChunks, createBatchEntry, @@ -99,7 +100,7 @@ function raceEndWithSignal(promise, signal) { const { promise: aborted, reject } = PromiseWithResolvers(); const onAbort = () => reject(signal.reason); - signal.addEventListener('abort', onAbort, { __proto__: null, once: true }); + signal.addEventListener('abort', onAbort, kNullOnceOption); if (signal.aborted) onAbort(); return SafePromisePrototypeFinally( @@ -873,7 +874,7 @@ function wireBroadcastWriteSignal(entry, signal, resolve, reject, self) { entry.batch = null; reject(reason); }; - signal.addEventListener('abort', onAbort, { __proto__: null, once: true }); + signal.addEventListener('abort', onAbort, kNullOnceOption); } // ============================================================================= diff --git a/lib/internal/streams/iter/classic.js b/lib/internal/streams/iter/classic.js index 0eafba0182b..c1ed8ad51f5 100644 --- a/lib/internal/streams/iter/classic.js +++ b/lib/internal/streams/iter/classic.js @@ -63,6 +63,7 @@ const { const { PendingRequest, + kNullOnceOption, convertChunks, getWriterSignal, onSignalAbort, @@ -103,10 +104,7 @@ function raceWithSignal(promise, signal) { reject, } = PromiseWithResolvers(); const onAbort = () => reject(signal.reason); - signal.addEventListener('abort', onAbort, { - __proto__: null, - once: true, - }); + signal.addEventListener('abort', onAbort, kNullOnceOption); PromisePrototypeThen( promise, (value) => { diff --git a/lib/internal/streams/iter/consumers.js b/lib/internal/streams/iter/consumers.js index 8678e8235ac..0751d2cc95f 100644 --- a/lib/internal/streams/iter/consumers.js +++ b/lib/internal/streams/iter/consumers.js @@ -54,6 +54,7 @@ const { } = require('internal/streams/iter/from'); const { + kNullOnceOption, concatBytes, getProtocolMethod, recordChunk, @@ -528,10 +529,7 @@ function merge(...args) { waitResolve = null; } }; - signal.addEventListener('abort', onAbort, { - __proto__: null, - once: true, - }); + signal.addEventListener('abort', onAbort, kNullOnceOption); } // Called when a source's .next() settles. Pushes the result into diff --git a/lib/internal/streams/iter/duplex.js b/lib/internal/streams/iter/duplex.js index 95a117d8141..ce5ccadd060 100644 --- a/lib/internal/streams/iter/duplex.js +++ b/lib/internal/streams/iter/duplex.js @@ -18,6 +18,7 @@ const { const { converters, } = require('internal/streams/iter/webidl'); +const { kNullOnceOption } = require('internal/streams/iter/utils'); /** * Create a pair of connected duplex channels for bidirectional communication. @@ -66,8 +67,7 @@ function duplex(options = { __proto__: null }) { if (signal.aborted) { abortBoth(); } else { - signal.addEventListener('abort', abortBoth, - { __proto__: null, once: true }); + signal.addEventListener('abort', abortBoth, kNullOnceOption); } } diff --git a/lib/internal/streams/iter/pull.js b/lib/internal/streams/iter/pull.js index 35836dd27d6..fc8fa9902c1 100644 --- a/lib/internal/streams/iter/pull.js +++ b/lib/internal/streams/iter/pull.js @@ -53,6 +53,7 @@ const { const { IterResult, + kNullOnceOption, createBatchEntry, isTransformObject, parsePullArgs, @@ -748,7 +749,7 @@ async function* createAsyncPipeline(source, transforms, signal) { abortHandler = () => { abortSignal(controller.signal, signal.reason); }; - signal.addEventListener('abort', abortHandler, { __proto__: null, once: true }); + signal.addEventListener('abort', abortHandler, kNullOnceOption); } let completed = false; @@ -992,8 +993,7 @@ function pullWithConsumerCleanup(source, transforms, signal) { if (signal !== undefined) { abortHandler = () => closeSource('throw', signal.reason); - signal.addEventListener('abort', abortHandler, - { __proto__: null, once: true }); + signal.addEventListener('abort', abortHandler, kNullOnceOption); if (signal.aborted) abortHandler(); } diff --git a/lib/internal/streams/iter/push.js b/lib/internal/streams/iter/push.js index b5db45a1a32..c99253af43e 100644 --- a/lib/internal/streams/iter/push.js +++ b/lib/internal/streams/iter/push.js @@ -32,6 +32,7 @@ const { IterResult, PendingRequest, PendingWrite, + kNullOnceOption, kPushDefaultBudget, kResolvedPromise, createBatchEntry, @@ -72,10 +73,7 @@ function raceEndWithSignal(promise, signal) { } = PromiseWithResolvers(); const onAbort = () => reject(signal.reason); - signal.addEventListener('abort', onAbort, { - __proto__: null, - once: true, - }); + signal.addEventListener('abort', onAbort, kNullOnceOption); PromisePrototypeThen( promise, (value) => { @@ -320,7 +318,7 @@ class PushQueue { reject(reason); }; - signal.addEventListener('abort', onAbort, { __proto__: null, once: true }); + signal.addEventListener('abort', onAbort, kNullOnceOption); } return promise; diff --git a/lib/internal/streams/iter/transform.js b/lib/internal/streams/iter/transform.js index 2cd06957b80..c6c315cf6bd 100644 --- a/lib/internal/streams/iter/transform.js +++ b/lib/internal/streams/iter/transform.js @@ -40,6 +40,7 @@ const { } = require('internal/errors'); const { isArrayBufferView, isAnyArrayBuffer } = require('internal/util/types'); const { kValidatedTransform } = require('internal/streams/iter/types'); +const { kNullOnceOption } = require('internal/streams/iter/utils'); const { checkRangesOrGetDefault, kValidateObjectAllowArray, @@ -413,7 +414,7 @@ function makeZlibTransform(createHandleFn, processFlag, finishFlag) { reject(signal.reason); } }; - signal.addEventListener('abort', onAbort, { __proto__: null, once: true }); + signal.addEventListener('abort', onAbort, kNullOnceOption); function continueInputAsync() { const { promise, resolve, reject } = PromiseWithResolvers(); diff --git a/lib/internal/streams/iter/utils.js b/lib/internal/streams/iter/utils.js index 8b0c074b4e1..8c2835acd8b 100644 --- a/lib/internal/streams/iter/utils.js +++ b/lib/internal/streams/iter/utils.js @@ -47,6 +47,11 @@ const { kValidatedTransform, } = require('internal/streams/iter/types'); +// Shared `addEventListener()` options for one-time 'abort' listeners. Frozen +// because signals can come from user code, and a patched addEventListener() +// must not be able to change the options for every later registration. +const kNullOnceOption = ObjectFreeze({ __proto__: null, once: true }); + // Cached resolved promise to avoid allocating a new one on every sync fast-path. const kResolvedPromise = PromiseResolve(); @@ -98,7 +103,7 @@ function onSignalAbort(signal, handler) { if (signal.aborted) { handler(); } else { - signal.addEventListener('abort', handler, { __proto__: null, once: true }); + signal.addEventListener('abort', handler, kNullOnceOption); } } @@ -122,7 +127,7 @@ function abortableNext(iterator, signal) { const next = iterator.next(); const { promise, reject } = PromiseWithResolvers(); const onAbort = getOnAbort(reject, signal); - signal.addEventListener('abort', onAbort, { __proto__: null, once: true }); + signal.addEventListener('abort', onAbort, kNullOnceOption); if (signal.aborted) { onAbort(); } @@ -594,6 +599,7 @@ module.exports = { PendingRequest, PendingWrite, kMultiConsumerDefaultBudget, + kNullOnceOption, kPushDefaultBudget, kResolvedPromise, concatBytes, From 3b6a489cf3fea89d4ad43a5f5823dbbdf1593358 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sun, 4 Oct 2026 03:09:04 +0000 Subject: [PATCH 023/331] stream: make stream/iter from() cancellation waits cheaper MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit To stay cancellable while a source is pending, from() waits for every value of an async source through waitForNormalization(). For each value it created a PromiseWithResolvers(), raced it against the value with SafePromiseRace(), which wraps both in new promises, and ran an async function with try/finally. This was the largest per-batch cost of normalizing an async source. Wait with a single promise and a single reaction on the value instead, and reject that promise directly on cancellation. The outcome is unchanged: the value's result, its rejection, or the cancellation reason, whichever comes first, and the cancellation reason if the normalization was cancelled by the time the value fulfills. With an async generator yielding 16-byte chunks, pipeTo() is about 1.7x faster and iterating from() about 1.75x faster. Assisted-by: OpenCode Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/66648 Reviewed-By: Trivikram Kamat Reviewed-By: Gürgün Dayıoğlu --- lib/internal/streams/iter/from.js | 58 ++++++++++++++++++++++--------- 1 file changed, 41 insertions(+), 17 deletions(-) diff --git a/lib/internal/streams/iter/from.js b/lib/internal/streams/iter/from.js index 78b61b267de..c89b7ea6d08 100644 --- a/lib/internal/streams/iter/from.js +++ b/lib/internal/streams/iter/from.js @@ -19,7 +19,6 @@ const { PromisePrototypeThen, PromiseResolve, PromiseWithResolvers, - SafePromiseRace, Symbol, SymbolAsyncIterator, SymbolIterator, @@ -54,6 +53,7 @@ const { const { IterResult, + kResolvedPromise, getProtocolMethod, toUint8Array, } = require('internal/streams/iter/utils'); @@ -62,7 +62,6 @@ const { // Bounds peak memory when arrays flow through transforms, which must // allocate output for the entire batch at once. const FROM_BATCH_SIZE = 128; -const kNormalizationCancelled = Symbol('kNormalizationCancelled'); // Yielded by normalizeAsyncValue() (only when `emitFlush` is true) right // before it waits on a promise or on a nested async iterable. Callers that // batch chunks yield whatever they have collected so far, so that chunks that @@ -83,31 +82,56 @@ function cancelNormalization(context, reason, suppressCleanup = false) { context.cancelled = true; context.reason = reason; context.suppressCleanup = suppressCleanup; - context.resolve?.(kNormalizationCancelled); + context.resolve?.(); } function throwIfNormalizationCancelled(context) { if (context?.cancelled) throw context.reason; } -async function waitForNormalization(value, context) { +/** + * Wait for `value`, but stop waiting if the normalization is cancelled. + * Settles with the first of: + * - `value` fulfilling: its value, or the cancellation reason if the + * normalization has been cancelled by then; + * - `value` rejecting: its rejection reason; + * - cancellation: the cancellation reason. + * This runs for every value of a normalized async source, so it uses a + * single promise and a single reaction on `value` rather than racing + * promises. + * @param {any} value + * @param {object} [context] + * @returns {Promise|any} + */ +function waitForNormalization(value, context) { if (context === undefined) return value; - const { promise, resolve } = PromiseWithResolvers(); + const { promise, resolve, reject } = PromiseWithResolvers(); + const onCancel = () => { + if (context.resolve === onCancel) context.resolve = null; + reject(context.reason); + }; + PromisePrototypeThen( + PromiseResolve(value), + (result) => { + if (context.resolve === onCancel) context.resolve = null; + if (context.cancelled) { + reject(context.reason); + } else { + resolve(result); + } + }, + (error) => { + if (context.resolve === onCancel) context.resolve = null; + reject(error); + }); if (context.cancelled) { - resolve(kNormalizationCancelled); + // Already cancelled: a `value` that has already settled still takes + // precedence, as its reaction above runs first. + PromisePrototypeThen(kResolvedPromise, onCancel); } else { - context.resolve = resolve; - } - try { - const result = await SafePromiseRace([ - PromiseResolve(value), - promise, - ]); - throwIfNormalizationCancelled(context); - return result; - } finally { - if (context.resolve === resolve) context.resolve = null; + context.resolve = onCancel; } + return promise; } function createNormalizationIterator(createIterator) { From f5eb0d89f5192e0ac28d87bb8ae861e9fdd470d9 Mon Sep 17 00:00:00 2001 From: Rich Trott Date: Thu, 15 Oct 2026 23:40:37 -0700 Subject: [PATCH 024/331] test: cover source-specific membership on closed sockets Signed-off-by: Rich Trott Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66624 Reviewed-By: Luigi Pinca --- test/parallel/test-dgram-membership.js | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/test/parallel/test-dgram-membership.js b/test/parallel/test-dgram-membership.js index 052deb92d61..5ef9087afbd 100644 --- a/test/parallel/test-dgram-membership.js +++ b/test/parallel/test-dgram-membership.js @@ -35,6 +35,20 @@ const setup = dgram.createSocket.bind(dgram, { type: 'udp4', reuseAddr: true }); })); } +// Source-specific membership methods on closed sockets should throw. +for (const method of ['addSourceSpecificMembership', 'dropSourceSpecificMembership']) { + const socket = setup(); + socket.close(common.mustCall(() => { + assert.throws(() => { + socket[method]('127.0.0.1', multicastAddress); + }, { + code: 'ERR_SOCKET_DGRAM_NOT_RUNNING', + name: 'Error', + message: 'Not running' + }); + })); +} + // addMembership() with no argument should throw { const socket = setup(); From 2f39614d27196917bd5633aec339237a264c313b Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 14 Oct 2026 11:37:36 +0200 Subject: [PATCH 025/331] test: retry unready process timeout reports MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Retry attempts that did not reach the blocked Worker before parsing their report. A timeout during startup can force exit before the report is complete. Keep the report and exit assertions once startup is ready. Refs: https://github.com/nodejs/reliability/issues/1687 Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66722 Refs: https://github.com/nodejs/reliability/issues/1686 Refs: https://github.com/nodejs/reliability/issues/1690 Reviewed-By: Antoine du Hamel Reviewed-By: James M Snell Reviewed-By: Matteo Collina Reviewed-By: Guilherme Araújo --- test/report/test-report-process-timeout-worker.js | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/test/report/test-report-process-timeout-worker.js b/test/report/test-report-process-timeout-worker.js index a42e2513ccb..d7fe24a7a0d 100644 --- a/test/report/test-report-process-timeout-worker.js +++ b/test/report/test-report-process-timeout-worker.js @@ -31,6 +31,12 @@ for (let timeout = common.platformTimeout(1000); ; timeout *= 2) { marker, ], { cwd: tmpdir.path, encoding: 'utf8' }); + // If startup did not reach the blocked Worker, the watchdog may have + // interrupted report generation too. Retry before reading that report. + if (!fs.existsSync(marker) && timeout < common.platformTimeout(16000)) { + continue; + } + const reports = helper.findReports(child.pid, tmpdir.path); assert.strictEqual(reports.length, 1, child.stderr); helper.validate(reports[0], [ From c01f8dfe1701d02357ea3eb6fcdf89e201515ff3 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 14 Oct 2026 11:37:36 +0200 Subject: [PATCH 026/331] test: wait for inspector restart before exit MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The self-directed debug signal restarts the inspector asynchronously. Wait for the replacement server to listen before asking the child to exit, instead of racing startup against a zero-delay timer. Refs: https://github.com/nodejs/reliability/issues/1687 Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66722 Refs: https://github.com/nodejs/reliability/issues/1686 Refs: https://github.com/nodejs/reliability/issues/1690 Reviewed-By: Antoine du Hamel Reviewed-By: James M Snell Reviewed-By: Matteo Collina Reviewed-By: Guilherme Araújo --- test/parallel/test-inspector-debug-end.js | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/test/parallel/test-inspector-debug-end.js b/test/parallel/test-inspector-debug-end.js index 328f15628e3..fe5a62430fd 100644 --- a/test/parallel/test-inspector-debug-end.js +++ b/test/parallel/test-inspector-debug-end.js @@ -22,18 +22,23 @@ async function testNoSessionNoCrash() { async function testSessionNoCrash() { console.log('Test there\'s no crash stopping server after connecting'); const script = `process._debugEnd(); - process._debugProcess(process.pid); - setTimeout(() => { - console.log("Done"); - process.exit(42); - });`; + process.stdin.once('data', () => { + console.log("Done"); + process.exit(42); + }); + process._debugProcess(process.pid);`; const instance = new NodeInstance('--inspect-brk=0', script); const session = await instance.connectInspectorSession(); await session.send({ method: 'NodeRuntime.enable' }); await session.waitForNotification('NodeRuntime.waitingForDebugger'); + instance.resetPort(); await session.send({ 'method': 'Runtime.runIfWaitingForDebugger' }); await session.waitForServerDisconnect(); + // _debugProcess() starts the inspector asynchronously. Wait for the new + // server to listen before asking the child to exit. + await instance.portPromise; + instance.write('exit'); assert.strictEqual((await instance.expectShutdown()).exitCode, 42); } From 8189a563ba2f54848d33e748087ce812877d3797 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 14 Oct 2026 11:37:37 +0200 Subject: [PATCH 027/331] test: allow periodic flush to finish under load MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Keep the event loop alive until the periodic write drains and let the test runner enforce the timeout. A one-second deadline can expire while asynchronous file I/O is still pending on a busy CI machine. Refs: https://github.com/nodejs/reliability/issues/1690 Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66722 Refs: https://github.com/nodejs/reliability/issues/1686 Refs: https://github.com/nodejs/reliability/issues/1687 Reviewed-By: Antoine du Hamel Reviewed-By: James M Snell Reviewed-By: Matteo Collina Reviewed-By: Guilherme Araújo --- test/parallel/test-fastutf8stream-periodicflush.js | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/test/parallel/test-fastutf8stream-periodicflush.js b/test/parallel/test-fastutf8stream-periodicflush.js index 4889fa8b19e..ed9f8aef883 100644 --- a/test/parallel/test-fastutf8stream-periodicflush.js +++ b/test/parallel/test-fastutf8stream-periodicflush.js @@ -85,13 +85,12 @@ function runTests(sync) { minLength: 5000, periodicFlush: common.platformTimeout(10), }); - const timeout = setTimeout( - common.mustNotCall('periodic flush did not complete'), - common.platformTimeout(1000), - ); + // Periodic flush timers are unrefed. Keep the event loop alive until the + // write completes, and let the test runner enforce the timeout. + const keepAlive = setInterval(() => {}, 1000); stream.once('drain', common.mustCall(() => { - clearTimeout(timeout); + clearInterval(keepAlive); stream.destroy(); readFile(dest, 'utf8', common.mustSucceed((data) => { assert.strictEqual(data, 'periodic flush\n'); From 44c7188a26a80cc6f762c83a4726f12091550b6f Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 14 Oct 2026 11:37:37 +0200 Subject: [PATCH 028/331] test: move large SQLite string cases to pummel MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The oversized-string cases allocate hundreds of megabytes and can make the ordinary statement test time out under parallel suite load. Move all five cases unchanged to the sequential pummel suite, which also allows more time for intensive tests. Refs: https://github.com/nodejs/reliability/issues/1690 Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66722 Refs: https://github.com/nodejs/reliability/issues/1686 Refs: https://github.com/nodejs/reliability/issues/1687 Reviewed-By: Antoine du Hamel Reviewed-By: James M Snell Reviewed-By: Matteo Collina Reviewed-By: Guilherme Araújo --- test/parallel/test-sqlite-statement.js | 55 +---------------- test/pummel/test-sqlite-statement-too-long.js | 60 +++++++++++++++++++ 2 files changed, 61 insertions(+), 54 deletions(-) create mode 100644 test/pummel/test-sqlite-statement-too-long.js diff --git a/test/parallel/test-sqlite-statement.js b/test/parallel/test-sqlite-statement.js index 79e72a89d18..a66ef9585be 100644 --- a/test/parallel/test-sqlite-statement.js +++ b/test/parallel/test-sqlite-statement.js @@ -1,13 +1,11 @@ // Flags: --expose-gc 'use strict'; -const { enoughTestMem, skipIfSQLiteMissing } = require('../common'); +const { skipIfSQLiteMissing } = require('../common'); skipIfSQLiteMissing(); const { Database, Statement, - constants: { SQLITE_OK }, } = require('node:sqlite'); -const { constants } = require('node:buffer'); const { suite, test } = require('node:test'); suite('Statement() constructor', () => { @@ -1447,54 +1445,3 @@ suite('options.persistent', () => { t.assert.deepStrictEqual(stmt.get(), { __proto__: null, val: 42n }); }); }); - -suite('values larger than the maximum string length', { skip: !enoughTestMem }, () => { - // hex() doubles its input, so this is the smallest blob whose text form - // exceeds what V8 can hold in a string. - const blobSize = (constants.MAX_STRING_LENGTH >>> 1) + 1; - // '\u20ac' is 1 UTF-16 code unit but 3 UTF-8 bytes, so this identifier is a - // valid JS string whose UTF-8 form exceeds the limit. - const longIdentifier = '\u20ac'.repeat(Math.ceil(constants.MAX_STRING_LENGTH / 3) + 10); - const tooLong = { code: 'ERR_STRING_TOO_LONG', name: 'Error' }; - - test('get() throws instead of returning undefined', (t) => { - using db = new Database(':memory:'); - using stmt = db.prepare('SELECT hex(zeroblob(?))'); - t.assert.throws(() => { - stmt.get(blobSize); - }, tooLong); - }); - - test('prepare() throws when the SQLite error message is too long', (t) => { - using db = new Database(':memory:'); - // SQLite repeats the identifier in the error. - t.assert.throws(() => { - db.prepare(`SELECT 1 FROM "${longIdentifier}"`); - }, tooLong); - }); - - test('prepare() throws for an oversized authorizer argument', (t) => { - using db = new Database(':memory:'); - db.setAuthorizer(() => SQLITE_OK); - t.assert.throws(() => db.prepare(`CREATE TABLE "${longIdentifier}" (x)`), tooLong); - }); - - test('columns() throws for an oversized declared type', (t) => { - using db = new Database(':memory:'); - db.exec(`CREATE TABLE t (x "${longIdentifier}")`); - using stmt = db.prepare('SELECT x FROM t'); - t.assert.throws(() => stmt.columns(), tooLong); - }); - - test('exec() surfaces the error from a user-defined function', (t) => { - using db = new Database(':memory:'); - db.exec('CREATE TABLE data(val TEXT)'); - db.function('identity', (val) => val); - - t.assert.throws(() => { - db.exec(`INSERT INTO data (val) VALUES (identity(hex(zeroblob(${blobSize}))))`); - }, tooLong); - using stmt = db.prepare('SELECT count(*) AS count FROM data'); - t.assert.deepStrictEqual(stmt.get(), { __proto__: null, count: 0 }); - }); -}); diff --git a/test/pummel/test-sqlite-statement-too-long.js b/test/pummel/test-sqlite-statement-too-long.js new file mode 100644 index 00000000000..02c3faf0ac3 --- /dev/null +++ b/test/pummel/test-sqlite-statement-too-long.js @@ -0,0 +1,60 @@ +'use strict'; + +const { enoughTestMem, skipIfSQLiteMissing } = require('../common'); +skipIfSQLiteMissing(); +const { Database, constants: { SQLITE_OK } } = require('node:sqlite'); +const { constants } = require('node:buffer'); +const { suite, test } = require('node:test'); + +// These queries allocate strings and blobs of several hundred megabytes. +// Run them separately from the ordinary statement tests. +suite('values larger than the maximum string length', { skip: !enoughTestMem }, () => { + // hex() doubles its input, so this is the smallest blob whose text form + // exceeds what V8 can hold in a string. + const blobSize = (constants.MAX_STRING_LENGTH >>> 1) + 1; + // '\u20ac' is 1 UTF-16 code unit but 3 UTF-8 bytes, so this identifier is a + // valid JS string whose UTF-8 form exceeds the limit. + const longIdentifier = '\u20ac'.repeat(Math.ceil(constants.MAX_STRING_LENGTH / 3) + 10); + const tooLong = { code: 'ERR_STRING_TOO_LONG', name: 'Error' }; + + test('get() throws instead of returning undefined', (t) => { + using db = new Database(':memory:'); + using stmt = db.prepare('SELECT hex(zeroblob(?))'); + t.assert.throws(() => { + stmt.get(blobSize); + }, tooLong); + }); + + test('prepare() throws when the SQLite error message is too long', (t) => { + using db = new Database(':memory:'); + // SQLite repeats the identifier in the error. + t.assert.throws(() => { + db.prepare(`SELECT 1 FROM "${longIdentifier}"`); + }, tooLong); + }); + + test('prepare() throws for an oversized authorizer argument', (t) => { + using db = new Database(':memory:'); + db.setAuthorizer(() => SQLITE_OK); + t.assert.throws(() => db.prepare(`CREATE TABLE "${longIdentifier}" (x)`), tooLong); + }); + + test('columns() throws for an oversized declared type', (t) => { + using db = new Database(':memory:'); + db.exec(`CREATE TABLE t (x "${longIdentifier}")`); + using stmt = db.prepare('SELECT x FROM t'); + t.assert.throws(() => stmt.columns(), tooLong); + }); + + test('exec() surfaces the error from a user-defined function', (t) => { + using db = new Database(':memory:'); + db.exec('CREATE TABLE data(val TEXT)'); + db.function('identity', (val) => val); + + t.assert.throws(() => { + db.exec(`INSERT INTO data (val) VALUES (identity(hex(zeroblob(${blobSize}))))`); + }, tooLong); + using stmt = db.prepare('SELECT count(*) AS count FROM data'); + t.assert.deepStrictEqual(stmt.get(), { __proto__: null, count: 0 }); + }); +}); From 9c2b2ade76d742cbecc8f97a0dc2504c9e81e1d9 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 14 Oct 2026 11:37:37 +0200 Subject: [PATCH 029/331] test: wait for shared-isolate Worker exit MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ten thousand non-blocking loop turns can finish before the Worker has started. Use a thirty-second deadline and yield between turns while waiting for its exit, preserving the expected exit-code assertion. Refs: https://github.com/nodejs/reliability/issues/1687 Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66722 Refs: https://github.com/nodejs/reliability/issues/1686 Refs: https://github.com/nodejs/reliability/issues/1690 Reviewed-By: Antoine du Hamel Reviewed-By: James M Snell Reviewed-By: Matteo Collina Reviewed-By: Guilherme Araújo --- test/cctest/test_environment_shared_isolate.cc | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/test/cctest/test_environment_shared_isolate.cc b/test/cctest/test_environment_shared_isolate.cc index 3e86063b064..b3807b7bb70 100644 --- a/test/cctest/test_environment_shared_isolate.cc +++ b/test/cctest/test_environment_shared_isolate.cc @@ -354,9 +354,13 @@ TEST_P(SharedIsolateTest, EnvironmentsComeAndGoWhileSiblingsRun) { " return 0;\n" "})()"), 0); - for (int turn = 0; turn < 10000; turn++) { + // Loop turns do not bound Worker startup time. Yield to the Worker and + // allow it to finish even when the main thread pumps the loop quickly. + const uint64_t deadline = uv_hrtime() + 30ULL * 1000 * 1000 * 1000; + while (uv_hrtime() < deadline) { PumpLoop(1); if (EvaluateInt(third.get(), "state.workerExit") == 7) break; + uv_sleep(1); } EXPECT_EQ(EvaluateInt(third.get(), "state.workerExit"), 7); } From bfeb3900a4e14f889af9ccb14bdcee4caf991fa7 Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Fri, 16 Oct 2026 09:44:22 -0300 Subject: [PATCH 030/331] benchmark: fix hideStackFrames error benchmarks MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: RafaelGSS PR-URL: https://github.com/nodejs/node/pull/66723 Reviewed-By: Vinícius Lourenço Claro Cardoso Reviewed-By: Luigi Pinca --- benchmark/error/hidestackframes-noerr.js | 4 ++-- benchmark/error/hidestackframes-throw.js | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/benchmark/error/hidestackframes-noerr.js b/benchmark/error/hidestackframes-noerr.js index 9e662f6a620..7a2eb85e16c 100644 --- a/benchmark/error/hidestackframes-noerr.js +++ b/benchmark/error/hidestackframes-noerr.js @@ -29,11 +29,11 @@ function main({ n, type }) { const hideStackFramesTestfn = hideStackFrames((value) => { if (typeof value !== 'number') { - throw new ERR_INVALID_ARG_TYPE.HideStackFrameError('Benchmark', 'number', value); + throw new ERR_INVALID_ARG_TYPE.HideStackFramesError('Benchmark', 'number', value); } }); - const fn = type === 'hide-stackframe' ? hideStackFramesTestfn : testfn; + const fn = type === 'hide-stackframes' ? hideStackFramesTestfn : testfn; const value = 42; diff --git a/benchmark/error/hidestackframes-throw.js b/benchmark/error/hidestackframes-throw.js index c7147e39ba5..8610bb9c44a 100644 --- a/benchmark/error/hidestackframes-throw.js +++ b/benchmark/error/hidestackframes-throw.js @@ -32,7 +32,7 @@ function main({ n, type, double }) { const hideStackFramesTestfn = hideStackFrames((value) => { if (typeof value !== 'number') { - throw new ERR_INVALID_ARG_TYPE.HideStackFrameError('Benchmark', 'number', value); + throw new ERR_INVALID_ARG_TYPE.HideStackFramesError('Benchmark', 'number', value); } }); @@ -44,7 +44,7 @@ function main({ n, type, double }) { hideStackFramesTestfn.withoutStackTrace(value); }); - const fn = type === 'hide-stackframe' ? + const fn = type === 'hide-stackframes' ? double === 'true' ? doubleHideStackFramesTestfn : hideStackFramesTestfn : From f534a4c31ff9f5cf7ab3d3212b36cd155cbc8bb6 Mon Sep 17 00:00:00 2001 From: Paul Bouchon Date: Fri, 16 Oct 2026 08:44:49 -0400 Subject: [PATCH 031/331] doc: warn against awaiting replies in module hooks Awaiting a reply from the registering thread inside a resolve or load hook deadlocks: resolution is synchronous from that thread's perspective, so it is blocked in the request and cannot answer. Fixes: https://github.com/nodejs/node/issues/63085 Signed-off-by: Paul Bouchon PR-URL: https://github.com/nodejs/node/pull/65590 Reviewed-By: Jacob Smith --- doc/api/module.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/doc/api/module.md b/doc/api/module.md index 272ce94c15b..95a076164a6 100644 --- a/doc/api/module.md +++ b/doc/api/module.md @@ -1272,6 +1272,13 @@ register('./my-hooks.mjs', { }); ``` +A hook can send messages to the thread that registered it at any time, as +above. It must not block on a reply from that thread: resolution and loading +are synchronous from the perspective of the thread that triggered them, so that +thread is blocked until the hook settles and cannot answer in the meantime. +Hooks can otherwise be fully asynchronous; it is only a reply over this +message channel that cannot be awaited. + #### Asynchronous hooks accepted by `module.register()` + +* `reason` {any} The value the returned promise rejects with. + +Changes the mock's implementation to a function that returns a promise rejected +with `reason`. This is shorthand for +`ctx.mockImplementation(() => Promise.reject(reason))`. + +```js +test('mocks a rejected value', async (t) => { + const fn = t.mock.fn(); + + fn.mock.mockRejectedValue(new Error('boom')); + await assert.rejects(fn(), { message: 'boom' }); +}); +``` + +### `ctx.mockResolvedValue(value)` + + + +* `value` {any} The value the returned promise resolves with. + +Changes the mock's implementation to a function that returns a promise resolved +with `value`. This is shorthand for +`ctx.mockImplementation(() => Promise.resolve(value))`. + +```js +test('mocks a resolved value', async (t) => { + const fn = t.mock.fn(); + + fn.mock.mockResolvedValue(42); + assert.strictEqual(await fn(), 42); +}); +``` + +### `ctx.mockReturnValue(value)` + + + +* `value` {any} The value returned by the mock. + +Changes the mock's implementation to a function that returns `value`. This is +shorthand for `ctx.mockImplementation(() => value)`. + +```js +test('mocks a return value', (t) => { + const fn = t.mock.fn(); + + fn.mock.mockReturnValue(42); + assert.strictEqual(fn(), 42); + assert.strictEqual(fn(), 42); +}); +``` + +### `ctx.mockThrownValue(value)` + + + +* `value` {any} The value thrown by the mock. + +Changes the mock's implementation to a function that throws `value`. This is +shorthand for `ctx.mockImplementation(() => { throw value; })`. + +```js +test('mocks a thrown value', (t) => { + const fn = t.mock.fn(); + + fn.mock.mockThrownValue(new Error('boom')); + assert.throws(fn, { message: 'boom' }); +}); +``` + ### `ctx.resetCalls()` -* `code` {number|bigint} The application error code to send to the peer. - **Default:** `0n`. +* `code` {number|bigint} The application error code to send to the peer. Must + be a non-negative 62-bit unsigned varint + (`0n <= code <= 2n ** 62n - 1n`). **Default:** `0n`. Tells the peer that this end will not send any more data on this stream, sending a `RESET_STREAM` frame carrying `code`. The readable side is left @@ -2016,8 +2018,9 @@ remote-initiated unidirectional stream, which has no writable side to abort. added: v23.8.0 --> -* `code` {number|bigint} The application error code to send to the peer. - **Default:** `0n`. +* `code` {number|bigint} The application error code to send to the peer. Must + be a non-negative 62-bit unsigned varint + (`0n <= code <= 2n ** 62n - 1n`). **Default:** `0n`. Asks the peer to stop sending data on this stream, sending a `STOP_SENDING` frame carrying `code`. The writable side is left open, so this end can diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js index d163311dc18..177965510e0 100644 --- a/lib/internal/quic/quic.js +++ b/lib/internal/quic/quic.js @@ -1033,6 +1033,23 @@ function assertPrivateSymbol(privateSymbol) { // maximum representable code is 2**62 - 1. const kMaxQuicErrorCode = (1n << 62n) - 1n; +function validateQuicErrorCode(code, name) { + if (typeof code !== 'bigint' && typeof code !== 'number') { + throw new ERR_INVALID_ARG_TYPE(name, ['bigint', 'number'], code); + } + if (typeof code === 'number' && !NumberIsInteger(code)) { + throw new ERR_OUT_OF_RANGE(name, 'an integer', code); + } + const numericCode = BigInt(code); + if (numericCode < 0n || numericCode > kMaxQuicErrorCode) { + throw new ERR_OUT_OF_RANGE( + name, + `>= 0 and <= ${kMaxQuicErrorCode}`, + code); + } + return numericCode; +} + /** * An Error subclass that carries an explicit numeric QUIC error code. * Use this when destroying a stream or aborting an outbound writer to @@ -1087,18 +1104,11 @@ class QuicError extends Error { if (errorCode === undefined) { throw new ERR_MISSING_ARGS('options.errorCode'); } - if (typeof errorCode !== 'bigint' && typeof errorCode !== 'number') { - throw new ERR_INVALID_ARG_TYPE('options.errorCode', - ['bigint', 'number'], errorCode); - } + const numericCode = validateQuicErrorCode( + errorCode, + 'options.errorCode'); validateString(code, 'options.code'); validateOneOf(type, 'options.type', ['transport', 'application']); - const numericCode = BigInt(errorCode); - if (numericCode < 0n || numericCode > kMaxQuicErrorCode) { - throw new ERR_OUT_OF_RANGE('options.errorCode', - `>= 0 and <= ${kMaxQuicErrorCode}`, - errorCode); - } super(message); this.code = code; this.#errorCode = numericCode; @@ -2081,11 +2091,9 @@ class QuicStream { // promise). The caller may retry with valid options. validateObject(options, 'options'); const { code: optionCode, reason } = options; - if (optionCode !== undefined && - typeof optionCode !== 'bigint' && - typeof optionCode !== 'number') { - throw new ERR_INVALID_ARG_TYPE('options.code', - ['bigint', 'number'], optionCode); + let abortCode; + if (optionCode !== undefined) { + abortCode = validateQuicErrorCode(optionCode, 'options.code'); } if (reason !== undefined) { validateString(reason, 'options.reason'); @@ -2093,10 +2101,7 @@ class QuicStream { inner.destroying = true; // Resolve the wire error code for any RESET_STREAM / STOP_SENDING // frames emitted below. - let abortCode; - if (optionCode !== undefined) { - abortCode = BigInt(optionCode); - } else if (error !== undefined) { + if (abortCode === undefined && error !== undefined) { abortCode = QuicError.isQuicError(error) ? error.errorCode : getQuicSessionState(inner.session).internalErrorCode; @@ -2606,7 +2611,7 @@ class QuicStream { stopSending(code = 0n) { assertIsQuicStream(this); if (this.destroyed) return; - const abortCode = BigInt(code); + const abortCode = validateQuicErrorCode(code, 'code'); this.#inner.stopSendingCode = abortCode; this.#handle.stopSending(abortCode); } @@ -2621,7 +2626,7 @@ class QuicStream { resetStream(code = 0n) { assertIsQuicStream(this); if (this.destroyed) return; - this.#handle.resetStream(BigInt(code)); + this.#handle.resetStream(validateQuicErrorCode(code, 'code')); } /** @@ -5482,17 +5487,7 @@ function validateCloseOptions(options) { } = options; if (code !== undefined) { - if (typeof code !== 'bigint' && typeof code !== 'number') { - throw new ERR_INVALID_ARG_TYPE('options.code', - ['bigint', 'number'], code); - } - if (typeof code === 'number' && !NumberIsInteger(code)) { - throw new ERR_OUT_OF_RANGE('options.code', 'an integer', code); - } - if (code < 0 || code > kMaxQuicErrorCode) { - throw new ERR_OUT_OF_RANGE('options.code', - `>= 0 and <= ${kMaxQuicErrorCode}`, code); - } + validateQuicErrorCode(code, 'options.code'); } validateOneOf(type, 'options.type', ['transport', 'application']); if (reason !== undefined) { diff --git a/src/quic/streams.cc b/src/quic/streams.cc index 1354ad54c47..8e9d3570938 100644 --- a/src/quic/streams.cc +++ b/src/quic/streams.cc @@ -432,12 +432,8 @@ struct Stream::Impl { JS_METHOD(StopSending) { Stream* stream; ASSIGN_OR_RETURN_UNWRAP(&stream, args.This()); - error_code code = 0; - CHECK_IMPLIES(!args[0]->IsUndefined(), args[0]->IsBigInt()); - if (!args[0]->IsUndefined()) { - bool unused = false; // not used but still necessary. - code = args[0].As()->Uint64Value(&unused); - } + CHECK(args[0]->IsBigInt()); + error_code code = args[0].As()->Uint64Value(); stream->SendStopSending(code); } @@ -449,12 +445,8 @@ struct Stream::Impl { JS_METHOD(ResetStream) { Stream* stream; ASSIGN_OR_RETURN_UNWRAP(&stream, args.This()); - error_code code = 0; - CHECK_IMPLIES(!args[0]->IsUndefined(), args[0]->IsBigInt()); - if (!args[0]->IsUndefined()) { - bool lossless = false; // not used but still necessary. - code = args[0].As()->Uint64Value(&lossless); - } + CHECK(args[0]->IsBigInt()); + error_code code = args[0].As()->Uint64Value(); stream->DoStreamReset(code); } diff --git a/test/parallel/test-quic-stream-error-code-validation.mjs b/test/parallel/test-quic-stream-error-code-validation.mjs new file mode 100644 index 00000000000..4af0bff0c24 --- /dev/null +++ b/test/parallel/test-quic-stream-error-code-validation.mjs @@ -0,0 +1,53 @@ +// Flags: --experimental-quic --no-warnings + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverEndpoint = await listen(mustCall(() => true)); +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); + +const invalidTypes = ['1', true, null]; +const invalidCodes = [ + -1, + 1.5, + NaN, + Infinity, + 2 ** 62, + -1n, + 2n ** 62n, +]; + +for (const method of ['stopSending', 'resetStream']) { + for (const code of invalidTypes) { + assert.throws(() => stream[method](code), { + code: 'ERR_INVALID_ARG_TYPE', + }); + } + + for (const code of invalidCodes) { + assert.throws(() => stream[method](code), { + code: 'ERR_OUT_OF_RANGE', + }); + } +} + +for (const code of invalidCodes) { + assert.throws(() => stream.destroy(new Error('test'), { code }), { + code: 'ERR_OUT_OF_RANGE', + }); +} +assert.strictEqual(stream.destroyed, false); + +stream.destroy(); +await stream.closed; +await clientSession.close(); +await serverEndpoint.close(); From a251f737b9da931ac79d45608eb528cbd4f66230 Mon Sep 17 00:00:00 2001 From: David Babenko-Sanders Date: Sat, 17 Oct 2026 23:08:16 -0700 Subject: [PATCH 046/331] test: skip openssl config test under BoringSSL Signed-off-by: David Babenko-Sanders PR-URL: https://github.com/nodejs/node/pull/66780 Reviewed-By: Filip Skokan Reviewed-By: Richard Lau Reviewed-By: Luigi Pinca --- test/parallel/test-openssl-unreadable-config.js | 3 +++ 1 file changed, 3 insertions(+) diff --git a/test/parallel/test-openssl-unreadable-config.js b/test/parallel/test-openssl-unreadable-config.js index 99681e0ecba..83d77d80e27 100644 --- a/test/parallel/test-openssl-unreadable-config.js +++ b/test/parallel/test-openssl-unreadable-config.js @@ -10,6 +10,9 @@ const { spawnSync } = require('node:child_process'); if (!common.hasCrypto) common.skip('missing crypto'); +const { isBoringSSL } = require('../common/crypto'); +if (isBoringSSL) + common.skip('BoringSSL does not load a default configuration file'); if (!common.isLinux) common.skip('linux only'); if (process.config.variables.node_shared_openssl) From 1f5d6a6fcc8fbf21851edac29eb46f078197188c Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Sun, 18 Oct 2026 08:36:43 +0200 Subject: [PATCH 047/331] process: return unregister fn from finalization MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit process.finalization.register() and registerBeforeExit() now return a function that removes only that registration, leaving other registrations for the same object in place. The function does not hold a strong reference to the object. Each registration now uses its WeakRef as the unregister token, which also makes process.finalization.unregister() remove the entries from the FinalizationRegistry; previously it passed the object as the token, which was never registered, so the call had no effect. Refs: https://github.com/nodejs/node/pull/66482 Signed-off-by: Matteo Collina Assisted-by: pi PR-URL: https://github.com/nodejs/node/pull/66482 Reviewed-By: James M Snell Reviewed-By: Paolo Insogna Reviewed-By: Ulises Gascón --- doc/api/process.md | 19 ++++++++++++ lib/internal/process/finalization.js | 23 +++++++++++---- test/fixtures/process/unregister-function.mjs | 29 +++++++++++++++++++ test/parallel/test-process-finalization.mjs | 1 + 4 files changed, 67 insertions(+), 5 deletions(-) create mode 100644 test/fixtures/process/unregister-function.mjs diff --git a/doc/api/process.md b/doc/api/process.md index 33dfd847716..45b310c6872 100644 --- a/doc/api/process.md +++ b/doc/api/process.md @@ -2062,6 +2062,9 @@ Since it's not possible to build Node.js without libuv, this value is always `tr + +> Stability: 1 - Experimental + +* `prefix` {string|Buffer|URL} +* `options` {string|Object} + * `encoding` {string} **Default:** `'utf8'` (or `'buffer'` if `prefix` is a `Buffer`) +* Returns: {Promise} Fulfills with an {Object}: + * `path` {string|Buffer} The path of the created file. + * `handle` {FileHandle} The created file, opened for reading and writing. + +Creates and opens a unique temporary file. A unique file name is generated by +appending six random characters to the end of the provided `prefix`. Due to +platform inconsistencies, avoid trailing `X` characters in `prefix`. Some +platforms, notably the BSDs, can return more than six random characters, and +replace trailing `X` characters in `prefix` with random characters. + +The file is created and opened in a single operation, so another process cannot +create a file with the same name in between. On POSIX systems, the file is only +readable and writable by its owner. + +The optional `options` argument can be a string specifying an encoding, or an +object with an `encoding` property specifying the character encoding to use for +the returned `path`. + +```mjs +import { mkstemp } from 'node:fs/promises'; +import { join } from 'node:path'; +import { tmpdir } from 'node:os'; + +const { path, handle } = await mkstemp(join(tmpdir(), 'foo-')); +try { + await handle.writeFile('some data'); + console.log(path); + // Prints: /tmp/foo-itXde2 or C:\Users\...\AppData\Local\Temp\foo-itXde2 +} finally { + await handle.close(); +} +``` + +The file is not removed automatically. It is the caller's responsibility to +close the {FileHandle} and to remove the file when it is no longer needed. + +As with [`fsPromises.mkdtemp()`][], the random characters are appended directly +to `prefix`. To create a file _within_ a directory, `prefix` must end with a +trailing platform-specific path separator (`require('node:path').sep`) or +include the beginning of the file name. + ### `fsPromises.open(path, flags[, mode])` + +> Stability: 1 - Experimental + +* `prefix` {string|Buffer|URL} +* `options` {string|Object} + * `encoding` {string} **Default:** `'utf8'` (or `'buffer'` if `prefix` is a `Buffer`) +* `callback` {Function} + * `err` {Error} + * `file` {Object} + * `path` {string|Buffer} The path of the created file. + * `fd` {integer} A file descriptor for the created file, opened for + reading and writing. + +Creates and opens a unique temporary file. + +Generates six random characters to be appended behind a required `prefix` to +create a unique temporary file. Due to platform inconsistencies, avoid trailing +`X` characters in `prefix`. Some platforms, notably the BSDs, can return more +than six random characters, and replace trailing `X` characters in `prefix` +with random characters. + +The file is created and opened in a single operation, so another process cannot +create a file with the same name in between. On POSIX systems, the file is only +readable and writable by its owner. + +The optional `options` argument can be a string specifying an encoding, or an +object with an `encoding` property specifying the character encoding to use for +the `path` passed to the callback. + +```mjs +import { mkstemp, write, close } from 'node:fs'; +import { join } from 'node:path'; +import { tmpdir } from 'node:os'; + +mkstemp(join(tmpdir(), 'foo-'), (err, file) => { + if (err) throw err; + console.log(file.path); + // Prints: /tmp/foo-itXde2 or C:\Users\...\AppData\Local\Temp\foo-itXde2 + write(file.fd, 'some data', (err) => { + if (err) throw err; + close(file.fd, (err) => { + if (err) throw err; + }); + }); +}); +``` + +The file is not removed automatically. It is the caller's responsibility to +close the file descriptor and to remove the file when it is no longer needed. + +As with [`fs.mkdtemp()`][], the random characters are appended directly to +`prefix`. To create a file _within_ a directory, `prefix` must end with a +trailing platform-specific path separator (`require('node:path').sep`) or +include the beginning of the file name. + ### `fs.open(path[, flags[, mode]], callback)` + +> Stability: 1 - Experimental + +* `prefix` {string|Buffer|URL} +* `options` {string|Object} + * `encoding` {string} **Default:** `'utf8'` (or `'buffer'` if `prefix` is a `Buffer`) +* Returns: {Object} + * `path` {string|Buffer} The path of the created file. + * `fd` {integer} A file descriptor for the created file, opened for reading + and writing. + +Synchronously creates and opens a unique temporary file. + +For detailed information, see the documentation of the asynchronous version of +this API: [`fs.mkstemp()`][]. + +The optional `options` argument can be a string specifying an encoding, or an +object with an `encoding` property specifying the character encoding to use for +the returned `path`. + ### `fs.openAsBlobSync(path[, options])` + +* Type: {net.Socket|stream.Duplex|null} + +The underlying socket or stream that this socket reads and writes TLS data +through. This is the `socket` passed to [`new tls.TLSSocket()`][] or +[`tls.connect()`][], or the connection given to a [`tls.Server`][] by its +`'connection'` event. + +This is only `null` for client sockets that manage their own connection, +created by [`tls.connect()`][] with a `port` or `path` rather than a `socket`. +Connection details such as `remoteAddress` are then available directly on this +socket. Server sockets always have an underlying socket. + +This remains available after the socket has been destroyed, for example to +identify the underlying connection from a [`'tlsClientError'`][] listener. + ## `tls.checkServerIdentity(hostname, cert)` + +> Stability: 1 - Experimental + +By default, Node.js refuses to strip types from TypeScript files inside +folders under a `node_modules` path. This flag enables type stripping for +such files when they belong to a package whose `package.json` contains +`"private": true`. Files belonging to non-private packages still throw +[`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`][]. +The limitation to private packages should never be lifted, +as publishing packages with TypeScript sources +is highly discouraged. +Stripping types inside `node_modules` is intended only +for local development. + ### `--experimental-test-coverage` + +* Type: {boolean} + +```json +{ + "private": true +} +``` + +The `"private"` field marks a package as private, signaling to package managers +such as _npm_ that it must not be published to a public registry. +By default, Node.js refuses to strip types from TypeScript files inside +`node_modules`. When [`--experimental-strip-private-modules`][] is enabled, +Node.js allows type stripping for: + +* files that are not inside a `node_modules` directory. +* files inside `node_modules`, but only when the package that contains the + file sets `"private": true`. Only the `package.json` at each package boundary + is considered: the package's root directory, which is the directory directly + under `node_modules` (or under `node_modules/<@scope>` for scoped packages). + Nested `package.json` files are ignored. + [CommonJS]: modules.md [Conditional exports]: #conditional-exports [ES module]: esm.md @@ -1360,10 +1390,12 @@ This field defines [subpath imports][] for the current package. [`"imports"`]: #imports [`"main"`]: #main [`"name"`]: #name +[`"private"`]: #private [`"type"`]: #type [`--conditions` / `-C` flag]: #resolving-user-conditions [`--experimental-addon-modules`]: cli.md#--experimental-addon-modules [`--experimental-package-map`]: cli.md#--experimental-package-mappath +[`--experimental-strip-private-modules`]: cli.md#--experimental-strip-private-modules [`--no-addons` flag]: cli.md#--no-addons [`ERR_PACKAGE_MAP_EXTERNAL_FILE`]: errors.md#err_package_map_external_file [`ERR_PACKAGE_PATH_NOT_EXPORTED`]: errors.md#err_package_path_not_exported diff --git a/doc/api/typescript.md b/doc/api/typescript.md index 701280375ba..5ea7dea0202 100644 --- a/doc/api/typescript.md +++ b/doc/api/typescript.md @@ -222,6 +222,15 @@ To discourage package authors from publishing packages written in TypeScript, Node.js refuses to handle TypeScript files inside folders under a `node_modules` path. +The [`--experimental-strip-private-modules`][] flag relaxes this restriction +for packages whose `package.json` contains `"private": true`, such as +workspace packages in a monorepo, which are not published to a registry. +The limitation to private packages should never be lifted, +as publishing packages with TypeScript sources +is highly discouraged. +Stripping types inside `node_modules` is intended only +for local development. + ### Paths aliases [`tsconfig` "paths"][] won't be transformed and therefore produce an error. The closest @@ -231,6 +240,7 @@ with `#`. [CommonJS]: modules.md [ES Modules]: esm.md [Full TypeScript support]: #full-typescript-support +[`--experimental-strip-private-modules`]: cli.md#--experimental-strip-private-modules [`--no-strip-types`]: cli.md#--no-strip-types [`ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX`]: errors.md#err_unsupported_typescript_syntax [`tsconfig` "paths"]: https://www.typescriptlang.org/tsconfig/#paths diff --git a/doc/node-config-schema.json b/doc/node-config-schema.json index ef46b6e5943..fdc866406b2 100644 --- a/doc/node-config-schema.json +++ b/doc/node-config-schema.json @@ -375,6 +375,10 @@ "type": "boolean", "description": "experimental iterable streams API (node:stream/iter)" }, + "experimental-strip-private-modules": { + "type": "boolean", + "description": "Type-stripping for TypeScript files under node_modules belonging to packages marked \"private\": true" + }, "experimental-vm-modules": { "type": "boolean", "description": "experimental ES Module support in vm module" diff --git a/doc/node.1 b/doc/node.1 index 613f00cfcee..676ebff6fad 100644 --- a/doc/node.1 +++ b/doc/node.1 @@ -869,6 +869,18 @@ Enable experimental support for storage inspection .It Fl -experimental-stream-iter Enable the experimental \fBnode:stream/iter\fR module. . +.It Fl -experimental-strip-private-modules +By default, Node.js refuses to strip types from TypeScript files inside +folders under a \fBnode_modules\fR path. This flag enables type stripping for +such files when they belong to a package whose \fBpackage.json\fR contains +\fB"private": true\fR. Files belonging to non-private packages still throw +\fBERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING\fR. +The limitation to private packages should never be lifted, +as publishing packages with TypeScript sources +is highly discouraged. +Stripping types inside \fBnode_modules\fR is intended only +for local development. +. .It Fl -experimental-test-coverage When used in conjunction with the \fBnode:test\fR module, a code coverage report is generated as part of the test runner output. If no tests are run, a coverage @@ -2235,6 +2247,8 @@ one is included in the list below. .It \fB--experimental-stream-iter\fR .It +\fB--experimental-strip-private-modules\fR +.It \fB--experimental-test-isolation\fR .It \fB--experimental-top-level-await\fR diff --git a/lib/internal/modules/helpers.js b/lib/internal/modules/helpers.js index 98d9e04d0c9..851547d2216 100644 --- a/lib/internal/modules/helpers.js +++ b/lib/internal/modules/helpers.js @@ -85,6 +85,8 @@ const nativeLoaderMethods = { modulesBinding.readPackageJSON(jsonPath, isESM, base, specifier), getNearestParentPackageJSON: (checkPath) => modulesBinding.getNearestParentPackageJSON(checkPath), + getRootPackageJSON: (checkPath) => + modulesBinding.getRootPackageJSON(checkPath), getNearestParentPackageJSONType: (checkPath) => modulesBinding.getNearestParentPackageJSONType(checkPath), getPackageScopeConfig: (resolved) => diff --git a/lib/internal/modules/package_json_reader.js b/lib/internal/modules/package_json_reader.js index ea6b7d26395..2ef5d1ebed3 100644 --- a/lib/internal/modules/package_json_reader.js +++ b/lib/internal/modules/package_json_reader.js @@ -64,6 +64,7 @@ function deserializePackageJSON(path, contents) { 3: plainImports, 4: plainExports, 5: optionalFilePath, + 6: isPrivate, } = contents; const pjsonPath = optionalFilePath ?? path; @@ -73,6 +74,7 @@ function deserializePackageJSON(path, contents) { ...(name != null && { name }), ...(main != null && { main }), ...(type != null && { type }), + ...(isPrivate != null && { private: isPrivate }), }; if (plainExports !== null) { @@ -217,6 +219,40 @@ function getNearestParentPackageJSON(checkPath) { return deserializedPackageJSONCache.get(parentPackageJSONPath); } +const moduleToRootPackageJSONCache = new SafeMap(); + +/** + * This is stricter than {@link getNearestParentPackageJSON}: nested + * `package.json` files inside a package are ignored, and a non-private package + * anywhere in the `node_modules` chain (for example a publishable package that + * bundles a private dependency) disqualifies the path. A directory under + * `node_modules` with no `package.json` (such as pnpm's `.pnpm` store) is not + * a package and is skipped. + * + * Returns the package.json data and the path to the package.json file, or undefined. + * @param {string} checkPath The path to start searching from. + * @returns {undefined | DeserializedPackageConfig} + */ +function getRootPackageJSON(checkPath) { + const packageJSONPath = moduleToRootPackageJSONCache.get(checkPath); + if (packageJSONPath !== undefined) { + return deserializedPackageJSONCache.get(packageJSONPath); + } + + const result = loaderMethods.getRootPackageJSON(checkPath); + const packageConfig = deserializePackageJSON(checkPath, result); + + moduleToRootPackageJSONCache.set(checkPath, packageConfig.path); + + const maybeCachedPackageConfig = deserializedPackageJSONCache.get(packageConfig.path); + if (maybeCachedPackageConfig !== undefined) { + return maybeCachedPackageConfig; + } + + deserializedPackageJSONCache.set(packageConfig.path, packageConfig); + return packageConfig; +} + /** * Returns the package configuration for the given resolved URL. * @param {URL | string} resolved - The resolved URL. @@ -412,6 +448,7 @@ function purgePackageJSONCacheForPrefix(mountPoint) { module.exports = { read, getNearestParentPackageJSON, + getRootPackageJSON, getPackageScopeConfig, getPackageType, getPackageJSONURL, diff --git a/lib/internal/modules/typescript.js b/lib/internal/modules/typescript.js index 43bc57d977e..ebe41e308bc 100644 --- a/lib/internal/modules/typescript.js +++ b/lib/internal/modules/typescript.js @@ -18,6 +18,7 @@ const { ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING, ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX, } = require('internal/errors').codes; +const { getOptionValue } = require('internal/options'); const assert = require('internal/assert'); const { getCompileCacheEntry, @@ -141,6 +142,35 @@ function stripTypeScriptTypesForCoverage(code) { } +/** + * Whether type-stripping is allowed for files under node_modules belonging + * to packages whose package.json contains `"private": true`. + * @returns {boolean} + */ +const isStripPrivateModulesEnabled = getLazy( + () => getOptionValue('--experimental-strip-private-modules'), +); + +/** + * Checks whether a file under node_modules is owned by a private package, in + * which case type stripping is allowed under `--experimental-strip-private-modules`. + * + * Every package enclosing the file inside `node_modules` must be marked + * `"private": true`. npm refuses to publish a private package, so requiring + * the package root (not a nested package.json, which is published verbatim) + * and rejecting any non-private enclosing package (e.g. a publishable package + * bundling a private dependency) prevents published packages from shipping + * strippable TypeScript. See {@link getRootPackageJSON}. + * @param {string} filename The filename (path or file URL) of the source code. + * @returns {boolean} Whether the file belongs to a package with `"private": true`. + */ +function isInsidePrivatePackage(filename) { + const { getRootPackageJSON } = require('internal/modules/package_json_reader'); + const { urlToFilename } = require('internal/modules/helpers'); + const packageJSON = getRootPackageJSON(urlToFilename(filename)); + return packageJSON?.data.private === true; +} + /** * Performs type-stripping to TypeScript source code internally. * It is used by internal loaders. @@ -152,7 +182,10 @@ function stripTypeScriptTypesForCoverage(code) { function stripTypeScriptModuleTypes(source, filename, sourceURL) { assert(typeof source === 'string'); if (isUnderNodeModules(filename)) { - throw new ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING(filename); + if (!isStripPrivateModulesEnabled() || !isInsidePrivatePackage(filename)) { + throw new ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING(filename); + } + emitExperimentalWarning('Type stripping in node_modules'); } // Get a compile cache entry into the native compile cache store, // keyed by the filename. If the cache can already be loaded on disk, diff --git a/src/node_modules.cc b/src/node_modules.cc index ec4f6bdd79a..f88fc461f4d 100644 --- a/src/node_modules.cc +++ b/src/node_modules.cc @@ -21,6 +21,7 @@ namespace node { namespace modules { using v8::Array; +using v8::Boolean; using v8::Context; using v8::External; using v8::FunctionCallbackInfo; @@ -80,15 +81,18 @@ Local BindingData::PackageConfig::Serialize(Realm* realm) const { isolate, input.data(), NewStringType::kNormal, input.size()) .ToLocalChecked(); }; - Local values[6] = { + Local values[7] = { name.has_value() ? ToString(*name) : Undefined(isolate), main.has_value() ? ToString(*main) : Undefined(isolate), ToString(type), imports.has_value() ? ToString(*imports) : Undefined(isolate), exports.has_value() ? ToString(*exports) : Undefined(isolate), ToString(file_path), + is_private.has_value() + ? Boolean::New(isolate, *is_private).As() + : Undefined(isolate), }; - return Array::New(isolate, values, 6); + return Array::New(isolate, values, 7); } bool BindingData::ParsePackageJSON(Realm* realm, @@ -207,6 +211,11 @@ bool BindingData::ParsePackageJSON(Realm* realm, if (field_value == "commonjs" || field_value == "module") { package_config->type = field_value; } + } else if (key == "private") { + bool is_private; + if (!value.get_bool().get(is_private)) { + package_config->is_private = is_private; + } } else if (key == "scripts") { if (value.type().get(field_type)) { return throw_invalid_package_config(); @@ -405,6 +414,72 @@ const BindingData::PackageConfig* BindingData::TraverseParent( return nullptr; } +const BindingData::PackageConfig* BindingData::FindNodeModulesPackage( + Realm* realm, const std::filesystem::path& check_path) { + std::filesystem::path current_path = check_path; + std::filesystem::path child; + std::filesystem::path grandchild; + const PackageConfig* innermost = nullptr; + auto env = realm->env(); + const bool is_permissions_enabled = env->permission()->enabled(); + + while (true) { + auto parent_path = current_path.parent_path(); + if (parent_path == current_path) { + // Reached the filesystem root. + break; + } + + if (current_path.filename() == "node_modules") { + // `child` is the directory directly under node_modules. For scoped + // packages the package root is one level further down. + const std::string child_name = child.filename().generic_string(); + const std::filesystem::path& package_root = + (!child_name.empty() && child_name[0] == '@') ? grandchild : child; + if (package_root.empty()) { + // The path points at a node_modules or bare scope directory rather + // than into a package. + return nullptr; + } + + auto package_json_path = package_root / "package.json"; + + // GetPackageJSON()'s ReadFileSync() reads the file directly without + // consulting the permission model, so check read access here as + // TraverseParent() does. Without permission to confirm the package is + // private, fail closed and deny stripping. + if (is_permissions_enabled) [[unlikely]] { + if (!env->permission()->is_granted( + env, + permission::PermissionScope::kFileSystemRead, + ConvertGenericPathToUTF8(package_json_path))) { + return nullptr; + } + } + + auto package_json = + GetPackageJSON(realm, ConvertPathToUTF8(package_json_path), nullptr); + if (package_json != nullptr) { + if (!package_json->is_private.value_or(false)) { + // A publishable (non-private) package encloses the file. + return nullptr; + } + if (innermost == nullptr) { + innermost = package_json; + } + } + // A directory under node_modules with no package.json is not a package + // (e.g. pnpm's `.pnpm` store); skip it and keep walking upwards. + } + + grandchild = child; + child = current_path; + current_path = parent_path; + } + + return innermost; +} + const std::filesystem::path BindingData::NormalizePath( Realm* realm, BufferValue* path_value) { // Check if the path has a trailing slash. If so, add it after @@ -439,6 +514,22 @@ void BindingData::GetNearestParentPackageJSON( } } +void BindingData::GetRootPackageJSON(const FunctionCallbackInfo& args) { + CHECK_GE(args.Length(), 1); + CHECK(args[0]->IsString()); + + Realm* realm = Realm::GetCurrent(args); + BufferValue path_value(realm->isolate(), args[0]); + + auto path = NormalizePath(realm, &path_value); + + auto package_json = FindNodeModulesPackage(realm, path); + + if (package_json != nullptr) { + args.GetReturnValue().Set(package_json->Serialize(realm)); + } +} + void BindingData::GetNearestParentPackageJSONType( const FunctionCallbackInfo& args) { CHECK_GE(args.Length(), 1); @@ -696,6 +787,7 @@ void BindingData::CreatePerIsolateProperties(IsolateData* isolate_data, target, "getNearestParentPackageJSON", GetNearestParentPackageJSON); + SetMethod(isolate, target, "getRootPackageJSON", GetRootPackageJSON); SetMethod( isolate, target, "getPackageScopeConfig", GetPackageScopeConfig); SetMethod(isolate, target, "getPackageType", GetPackageScopeConfig); @@ -769,6 +861,7 @@ void BindingData::RegisterExternalReferences( registry->Register(ParsePackageJSONBinding); registry->Register(GetNearestParentPackageJSONType); registry->Register(GetNearestParentPackageJSON); + registry->Register(GetRootPackageJSON); registry->Register(GetPackageScopeConfig); registry->Register(GetPackageScopeConfig); registry->Register(EnableCompileCache); diff --git a/src/node_modules.h b/src/node_modules.h index 54417731265..997f428b3a1 100644 --- a/src/node_modules.h +++ b/src/node_modules.h @@ -33,6 +33,7 @@ class BindingData : public SnapshotableObject { std::optional exports; std::optional imports; std::optional scripts; + std::optional is_private; std::string raw_json; v8::Local Serialize(Realm* realm) const; @@ -62,6 +63,8 @@ class BindingData : public SnapshotableObject { const v8::FunctionCallbackInfo& args); static void GetNearestParentPackageJSON( const v8::FunctionCallbackInfo& args); + static void GetRootPackageJSON( + const v8::FunctionCallbackInfo& args); static void GetNearestParentPackageJSONType( const v8::FunctionCallbackInfo& args); template @@ -103,6 +106,11 @@ class BindingData : public SnapshotableObject { ErrorContext* error_context); static const PackageConfig* TraverseParent( Realm* realm, const std::filesystem::path& check_path); + // Returns the package.json of the package that owns check_path inside the + // innermost node_modules directory, or null when check_path is not inside + // node_modules or the package root has no package.json. + static const PackageConfig* FindNodeModulesPackage( + Realm* realm, const std::filesystem::path& check_path); }; } // namespace modules diff --git a/src/node_options.cc b/src/node_options.cc index c80ef56390f..d93d8059570 100644 --- a/src/node_options.cc +++ b/src/node_options.cc @@ -1464,6 +1464,11 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() { kAllowedInEnvvar, HAVE_AMARO); AddAlias("--experimental-strip-types", "--strip-types"); + AddOption("--experimental-strip-private-modules", + "Type-stripping for TypeScript files under node_modules " + "belonging to packages marked \"private\": true", + BOOL_FIELD(experimental_strip_private_modules), + kAllowedInEnvvar); AddOption("--interactive", "always enter the REPL even if stdin does not appear " "to be a terminal", diff --git a/src/node_options.h b/src/node_options.h index 22c7e007077..c8f9a0a5d76 100644 --- a/src/node_options.h +++ b/src/node_options.h @@ -298,6 +298,8 @@ class EnvironmentOptions : public Options { DEFINE_BOOL_FIELD(tls_max_v1_2) = false; DEFINE_BOOL_FIELD(tls_max_v1_3) = false; DEFINE_BOOL_FIELD(strip_types) = HAVE_AMARO; + DEFINE_BOOL_FIELD(experimental_strip_private_modules) = + EXPERIMENTALS_DEFAULT_VALUE; DEFINE_BOOL_FIELD(report_exclude_env) = false; DEFINE_BOOL_FIELD(report_exclude_network) = false; #if HAVE_INSPECTOR diff --git a/test/es-module/test-typescript.mjs b/test/es-module/test-typescript.mjs index fd58d1d990a..07b556c2db1 100644 --- a/test/es-module/test-typescript.mjs +++ b/test/es-module/test-typescript.mjs @@ -61,6 +61,136 @@ test('execute a TypeScript file with node_modules', async () => { assert.strictEqual(result.code, 0); }); +test('execute a TypeScript file from a private package in node_modules', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-private-modules', + '--no-warnings', + fixtures.path('typescript/ts/test-typescript-private-node-modules.ts'), + ]); + + assert.strictEqual(result.stderr, ''); + assert.match(result.stdout, /Hello, TypeScript!/); + assert.strictEqual(result.code, 0); +}); + +test('execute a TypeScript file from a private package with a non-private nested package.json', + async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-private-modules', + '--no-warnings', + fixtures.path('typescript/ts/test-typescript-nested-nonprivate-node-modules.ts'), + ]); + + assert.strictEqual(result.stderr, ''); + assert.match(result.stdout, /Hello, TypeScript!/); + assert.strictEqual(result.code, 0); + }); + +test('emit an experimental warning when stripping types in a private node_modules package', + async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-private-modules', + fixtures.path('typescript/ts/test-typescript-private-node-modules.ts'), + ]); + + assert.match(result.stderr, /Type stripping in node_modules is an experimental feature/); + assert.match(result.stdout, /Hello, TypeScript!/); + assert.strictEqual(result.code, 0); + }); + +test('require a TypeScript file from a private package in node_modules', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-private-modules', + '--no-warnings', + fixtures.path('typescript/ts/test-typescript-private-node-modules-require.ts'), + ]); + + assert.strictEqual(result.stderr, ''); + assert.match(result.stdout, /Hello, TypeScript!/); + assert.strictEqual(result.code, 0); +}); + +test('expect failure for a private package in node_modules without --experimental-strip-private-modules', + async () => { + const result = await spawnPromisified(process.execPath, [ + '--no-warnings', + fixtures.path('typescript/ts/test-typescript-private-node-modules.ts'), + ]); + + assert.match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + assert.strictEqual(result.stdout, ''); + assert.strictEqual(result.code, 1); + }); + +// A nested package.json must not be able to enable type stripping: npm only +// refuses to publish packages whose root package.json has "private": true, so +// a published package can freely ship a nested package.json with +// "private": true. Only the package.json at the package root is consulted. +test('expect failure for a nested package.json faking "private": true in node_modules', + async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-private-modules', + '--no-warnings', + fixtures.path('typescript/ts/test-typescript-fake-private-node-modules.ts'), + ]); + + assert.match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + assert.strictEqual(result.stdout, ''); + assert.strictEqual(result.code, 1); + }); + +test('expect failure for a private package bundled inside a non-private package', + async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-private-modules', + '--no-warnings', + fixtures.path('typescript/ts/test-typescript-bundled-private-node-modules.ts'), + ]); + + assert.match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + assert.strictEqual(result.stdout, ''); + assert.strictEqual(result.code, 1); + }); + +test('expect failure for a relative import into a non-private node_modules package', + async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-private-modules', + '--no-warnings', + fixtures.path('typescript/ts/test-typescript-relative-node-modules.ts'), + ]); + + assert.match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + assert.strictEqual(result.stdout, ''); + assert.strictEqual(result.code, 1); + }); + +test('expect failure for a ".." path resolving to a non-private node_modules package', + async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-private-modules', + '--no-warnings', + fixtures.path('typescript/ts/test-typescript-dotdot-node-modules.ts'), + ]); + + assert.match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + assert.strictEqual(result.stdout, ''); + assert.strictEqual(result.code, 1); + }); + +test('expect failure for a non-private package in node_modules with --experimental-strip-private-modules', + async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-private-modules', + '--no-warnings', + fixtures.path('typescript/ts/test-import-ts-node-modules.ts'), + ]); + + assert.match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + assert.strictEqual(result.stdout, ''); + assert.strictEqual(result.code, 1); + }); + test('expect error when executing a TypeScript file with imports with no extensions', async () => { const result = await spawnPromisified(process.execPath, [ fixtures.path('typescript/ts/test-import-no-extension.ts'), diff --git a/test/fixtures/typescript/ts/node_modules/bundler-pkg/index.js b/test/fixtures/typescript/ts/node_modules/bundler-pkg/index.js new file mode 100644 index 00000000000..d342ad0fa36 --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/bundler-pkg/index.js @@ -0,0 +1 @@ +export { baz } from 'bundled-private'; diff --git a/test/fixtures/typescript/ts/node_modules/bundler-pkg/node_modules/bundled-private/bundled-private.ts b/test/fixtures/typescript/ts/node_modules/bundler-pkg/node_modules/bundled-private/bundled-private.ts new file mode 100644 index 00000000000..746109acf8c --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/bundler-pkg/node_modules/bundled-private/bundled-private.ts @@ -0,0 +1 @@ +export const baz: string = 'Hello, TypeScript!'; diff --git a/test/fixtures/typescript/ts/node_modules/bundler-pkg/node_modules/bundled-private/package.json b/test/fixtures/typescript/ts/node_modules/bundler-pkg/node_modules/bundled-private/package.json new file mode 100644 index 00000000000..b0f08d814dc --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/bundler-pkg/node_modules/bundled-private/package.json @@ -0,0 +1,7 @@ +{ + "name": "bundled-private", + "version": "1.0.0", + "private": true, + "type": "module", + "main": "bundled-private.ts" +} diff --git a/test/fixtures/typescript/ts/node_modules/bundler-pkg/package.json b/test/fixtures/typescript/ts/node_modules/bundler-pkg/package.json new file mode 100644 index 00000000000..cd729ba337a --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/bundler-pkg/package.json @@ -0,0 +1,6 @@ +{ + "name": "bundler-pkg", + "version": "1.0.0", + "type": "module", + "exports": "./index.js" +} diff --git a/test/fixtures/typescript/ts/node_modules/fake-private-pkg/lib/fake-private-pkg.ts b/test/fixtures/typescript/ts/node_modules/fake-private-pkg/lib/fake-private-pkg.ts new file mode 100644 index 00000000000..746109acf8c --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/fake-private-pkg/lib/fake-private-pkg.ts @@ -0,0 +1 @@ +export const baz: string = 'Hello, TypeScript!'; diff --git a/test/fixtures/typescript/ts/node_modules/fake-private-pkg/lib/package.json b/test/fixtures/typescript/ts/node_modules/fake-private-pkg/lib/package.json new file mode 100644 index 00000000000..e986b24bbae --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/fake-private-pkg/lib/package.json @@ -0,0 +1,4 @@ +{ + "private": true, + "type": "module" +} diff --git a/test/fixtures/typescript/ts/node_modules/fake-private-pkg/package.json b/test/fixtures/typescript/ts/node_modules/fake-private-pkg/package.json new file mode 100644 index 00000000000..1ef96e66059 --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/fake-private-pkg/package.json @@ -0,0 +1,5 @@ +{ + "name": "fake-private-pkg", + "version": "1.0.0", + "main": "lib/fake-private-pkg.ts" +} diff --git a/test/fixtures/typescript/ts/node_modules/nested-nonprivate-pkg/lib/index.ts b/test/fixtures/typescript/ts/node_modules/nested-nonprivate-pkg/lib/index.ts new file mode 100644 index 00000000000..746109acf8c --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/nested-nonprivate-pkg/lib/index.ts @@ -0,0 +1 @@ +export const baz: string = 'Hello, TypeScript!'; diff --git a/test/fixtures/typescript/ts/node_modules/nested-nonprivate-pkg/lib/package.json b/test/fixtures/typescript/ts/node_modules/nested-nonprivate-pkg/lib/package.json new file mode 100644 index 00000000000..3dbc1ca591c --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/nested-nonprivate-pkg/lib/package.json @@ -0,0 +1,3 @@ +{ + "type": "module" +} diff --git a/test/fixtures/typescript/ts/node_modules/nested-nonprivate-pkg/package.json b/test/fixtures/typescript/ts/node_modules/nested-nonprivate-pkg/package.json new file mode 100644 index 00000000000..a0ba58582ef --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/nested-nonprivate-pkg/package.json @@ -0,0 +1,7 @@ +{ + "name": "nested-nonprivate-pkg", + "version": "1.0.0", + "private": true, + "type": "module", + "exports": "./lib/index.ts" +} diff --git a/test/fixtures/typescript/ts/node_modules/private-pkg-cjs/package.json b/test/fixtures/typescript/ts/node_modules/private-pkg-cjs/package.json new file mode 100644 index 00000000000..d6cdf88f497 --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/private-pkg-cjs/package.json @@ -0,0 +1,6 @@ +{ + "name": "private-pkg-cjs", + "version": "1.0.0", + "private": true, + "main": "private-pkg-cjs.ts" +} diff --git a/test/fixtures/typescript/ts/node_modules/private-pkg-cjs/private-pkg-cjs.ts b/test/fixtures/typescript/ts/node_modules/private-pkg-cjs/private-pkg-cjs.ts new file mode 100644 index 00000000000..2d42fcdf192 --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/private-pkg-cjs/private-pkg-cjs.ts @@ -0,0 +1,3 @@ +const baz: string = 'Hello, TypeScript!'; + +module.exports = { baz }; diff --git a/test/fixtures/typescript/ts/node_modules/private-pkg/greeting.ts b/test/fixtures/typescript/ts/node_modules/private-pkg/greeting.ts new file mode 100644 index 00000000000..00b0820776c --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/private-pkg/greeting.ts @@ -0,0 +1 @@ +export const greeting: string = 'Hello, TypeScript!'; diff --git a/test/fixtures/typescript/ts/node_modules/private-pkg/package.json b/test/fixtures/typescript/ts/node_modules/private-pkg/package.json new file mode 100644 index 00000000000..2fd30de076e --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/private-pkg/package.json @@ -0,0 +1,7 @@ +{ + "name": "private-pkg", + "version": "1.0.0", + "private": true, + "type": "module", + "main": "private-pkg.ts" +} diff --git a/test/fixtures/typescript/ts/node_modules/private-pkg/private-pkg.ts b/test/fixtures/typescript/ts/node_modules/private-pkg/private-pkg.ts new file mode 100644 index 00000000000..25228dcb9ea --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/private-pkg/private-pkg.ts @@ -0,0 +1,3 @@ +import { greeting } from './greeting.ts'; + +export const baz: string = greeting; diff --git a/test/fixtures/typescript/ts/test-typescript-bundled-private-node-modules.ts b/test/fixtures/typescript/ts/test-typescript-bundled-private-node-modules.ts new file mode 100644 index 00000000000..6d57c6d8e04 --- /dev/null +++ b/test/fixtures/typescript/ts/test-typescript-bundled-private-node-modules.ts @@ -0,0 +1,3 @@ +import { baz } from 'bundler-pkg'; + +console.log(baz); diff --git a/test/fixtures/typescript/ts/test-typescript-dotdot-node-modules.ts b/test/fixtures/typescript/ts/test-typescript-dotdot-node-modules.ts new file mode 100644 index 00000000000..5f9ed34c790 --- /dev/null +++ b/test/fixtures/typescript/ts/test-typescript-dotdot-node-modules.ts @@ -0,0 +1 @@ +require('./node_modules/private-pkg-cjs/../bar/bar.ts'); diff --git a/test/fixtures/typescript/ts/test-typescript-fake-private-node-modules.ts b/test/fixtures/typescript/ts/test-typescript-fake-private-node-modules.ts new file mode 100644 index 00000000000..f340f6b5963 --- /dev/null +++ b/test/fixtures/typescript/ts/test-typescript-fake-private-node-modules.ts @@ -0,0 +1,3 @@ +import { baz } from 'fake-private-pkg'; + +console.log(baz); diff --git a/test/fixtures/typescript/ts/test-typescript-nested-nonprivate-node-modules.ts b/test/fixtures/typescript/ts/test-typescript-nested-nonprivate-node-modules.ts new file mode 100644 index 00000000000..30c2c46864e --- /dev/null +++ b/test/fixtures/typescript/ts/test-typescript-nested-nonprivate-node-modules.ts @@ -0,0 +1,3 @@ +import { baz } from 'nested-nonprivate-pkg'; + +console.log(baz); diff --git a/test/fixtures/typescript/ts/test-typescript-private-node-modules-require.ts b/test/fixtures/typescript/ts/test-typescript-private-node-modules-require.ts new file mode 100644 index 00000000000..f2aa981bfaa --- /dev/null +++ b/test/fixtures/typescript/ts/test-typescript-private-node-modules-require.ts @@ -0,0 +1,3 @@ +const { baz } = require('private-pkg-cjs'); + +console.log(baz); diff --git a/test/fixtures/typescript/ts/test-typescript-private-node-modules.ts b/test/fixtures/typescript/ts/test-typescript-private-node-modules.ts new file mode 100644 index 00000000000..92a5cec8ecd --- /dev/null +++ b/test/fixtures/typescript/ts/test-typescript-private-node-modules.ts @@ -0,0 +1,3 @@ +import { baz } from 'private-pkg'; + +console.log(baz); diff --git a/test/fixtures/typescript/ts/test-typescript-relative-node-modules.ts b/test/fixtures/typescript/ts/test-typescript-relative-node-modules.ts new file mode 100644 index 00000000000..7691013129f --- /dev/null +++ b/test/fixtures/typescript/ts/test-typescript-relative-node-modules.ts @@ -0,0 +1 @@ +require('./node_modules/bar/bar.ts'); diff --git a/typings/internalBinding/modules.d.ts b/typings/internalBinding/modules.d.ts index 0b1d0e29383..73bfd2a5aca 100644 --- a/typings/internalBinding/modules.d.ts +++ b/typings/internalBinding/modules.d.ts @@ -5,6 +5,7 @@ export type PackageConfig = { type: PackageType exports?: string | string[] | Record imports?: string | string[] | Record + private?: boolean } export type DeserializedPackageConfig = { data: PackageConfig, @@ -18,12 +19,14 @@ export type SerializedPackageConfig = [ string | undefined, // exports string | undefined, // imports DeserializedPackageConfig['path'], // pjson file path + PackageConfig['private'], // private ] export interface ModulesBinding { readPackageJSON(path: string): SerializedPackageConfig | undefined; getNearestParentPackageJSONType(path: string): PackageConfig['type'] getNearestParentPackageJSON(path: string): SerializedPackageConfig | undefined + getRootPackageJSON(path: string): SerializedPackageConfig | undefined getPackageScopeConfig(path: string): SerializedPackageConfig | undefined getPackageType(path: string): PackageConfig['type'] | undefined enableCompileCache(path?: string): { status: number, message?: string, directory?: string } From ab6f045ebd6da439fb78ff3b408b48c4d6a2dc5a Mon Sep 17 00:00:00 2001 From: Murat Kirazkaya <77299279+GroophyLifefor@users.noreply.github.com> Date: Mon, 19 Oct 2026 18:51:08 +0300 Subject: [PATCH 058/331] tools: add lint rule for unread benchmark `n` MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit If a benchmark declares `n` in its configs, main() must read it. nodejs/node#59872 renamed a config key from `num` to `n` but left `{ num: n }` in main(), so `n` resolved to undefined and the benchmark silently reported near-zero results until #62084 fixed it. The rule also found `async_hooks/async-resource-vs-destroy.js`, which has declared `n: [1e6]` since it was added but never read it. Remove the unused key. Refs: https://github.com/nodejs/node/pull/59872 Refs: https://github.com/nodejs/node/pull/62084 Signed-off-by: Murat Kirazkaya Assisted-by: Claude Code PR-URL: https://github.com/nodejs/node/pull/66807 Refs: https://github.com/nodejs/performance/issues/187 Reviewed-By: Antoine du Hamel Reviewed-By: Gürgün Dayıoğlu Reviewed-By: Yagiz Nizipli Reviewed-By: Ulises Gascón Reviewed-By: Rafael Gonzaga --- .../async_hooks/async-resource-vs-destroy.js | 1 - benchmark/eslint.config_partial.mjs | 1 + .../test-eslint-benchmark-n-config.js | 82 +++++++++ tools/eslint-rules/benchmark-n-config.js | 158 ++++++++++++++++++ 4 files changed, 241 insertions(+), 1 deletion(-) create mode 100644 test/parallel/test-eslint-benchmark-n-config.js create mode 100644 tools/eslint-rules/benchmark-n-config.js diff --git a/benchmark/async_hooks/async-resource-vs-destroy.js b/benchmark/async_hooks/async-resource-vs-destroy.js index 3bd9dd56934..50085ddcf8a 100644 --- a/benchmark/async_hooks/async-resource-vs-destroy.js +++ b/benchmark/async_hooks/async-resource-vs-destroy.js @@ -19,7 +19,6 @@ const bench = common.createBenchmark(main, { path: '/', connections: 500, duration: 5, - n: [1e6], }); function buildCurrentResource(getServe) { diff --git a/benchmark/eslint.config_partial.mjs b/benchmark/eslint.config_partial.mjs index 7f10460f719..47ef1467390 100644 --- a/benchmark/eslint.config_partial.mjs +++ b/benchmark/eslint.config_partial.mjs @@ -9,6 +9,7 @@ export default [ }, }, rules: { + 'node-core/benchmark-n-config': 'error', 'prefer-arrow-callback': 'error', }, }, diff --git a/test/parallel/test-eslint-benchmark-n-config.js b/test/parallel/test-eslint-benchmark-n-config.js new file mode 100644 index 00000000000..98049592fc8 --- /dev/null +++ b/test/parallel/test-eslint-benchmark-n-config.js @@ -0,0 +1,82 @@ +'use strict'; + +const common = require('../common'); +if ((!common.hasCrypto) || (!common.hasIntl)) { + common.skip('ESLint tests require crypto and Intl'); +} + +common.skipIfEslintMissing(); + +const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester; +const rule = require('../../tools/eslint-rules/benchmark-n-config'); + +const message = '`n` is configured but not read by the benchmark main ' + + 'function (destructure `{ n }` or read `conf.n`)'; + +new RuleTester().run('benchmark-n-config', rule, { + valid: [ + ` + const bench = common.createBenchmark(main, { len: [1], n: [100] }); + function main({ len, n }) { bench.end(n); } + `, + ` + const bench = common.createBenchmark(main, { n: [100] }); + function main(conf) { bench.end(conf.n); } + `, + ` + const bench = common.createBenchmark(main, { n: [100] }); + function main(conf) { const { n } = conf; bench.end(n); } + `, + ` + const bench = common.createBenchmark(({ n }) => bench.end(n), { n: [1] }); + `, + ` + const configs = { n: [100] }; + const bench = common.createBenchmark(main, configs); + function main({ n }) { bench.end(n); } + `, + // Configs without `n` (e.g. duration-driven benchmarks) are not checked. + ` + const bench = common.createBenchmark(main, { duration: [5] }); + function main({ duration }) {} + `, + // Non-static configs are skipped. + ` + const bench = common.createBenchmark(main, { ...base, n: [100] }); + function main({ len }) {} + `, + ], + invalid: [ + // nodejs/node#59872: the config key was renamed to `n`, but main() kept + // reading `num`. + { + code: ` + const bench = common.createBenchmark(main, { len: [1], n: [100] }); + function main({ len, num: n }) { bench.end(n); } + `, + errors: [{ message }], + }, + { + code: ` + const bench = common.createBenchmark(main, { n: [1e6], duration: [5] }); + function main({ duration }) {} + `, + errors: [{ message }], + }, + { + code: ` + const bench = common.createBenchmark(main, { n: [100] }); + function main(conf) { bench.end(conf.num); } + `, + errors: [{ message }], + }, + { + code: ` + const configs = { n: [100] }; + const bench = common.createBenchmark(main, configs); + function main({ count }) { bench.end(count); } + `, + errors: [{ message }], + }, + ], +}); diff --git a/tools/eslint-rules/benchmark-n-config.js b/tools/eslint-rules/benchmark-n-config.js new file mode 100644 index 00000000000..81a4fb30d96 --- /dev/null +++ b/tools/eslint-rules/benchmark-n-config.js @@ -0,0 +1,158 @@ +'use strict'; + +// Requires benchmarks that declare an `n` iteration count in their configs +// to actually read that value in the benchmark main function. +// +// This prevents regressions like nodejs/node#59872, where a config key was +// renamed to `n` while main() kept reading the old key, silently producing +// a near-zero result. + +function walk(node, visit) { + if (node === null || typeof node !== 'object') return; + if (Array.isArray(node)) { + for (const item of node) walk(item, visit); + return; + } + if (typeof node.type !== 'string') return; + visit(node); + for (const key of Object.keys(node)) { + if (key === 'parent' || key === 'loc' || key === 'range') continue; + walk(node[key], visit); + } +} + +// Collects the property names read by an ObjectPattern: `{ num: n }` reads +// `num`, `{ n }` reads `n`. +function objectPatternNames(pattern, out) { + for (const prop of pattern.properties) { + if (prop.type !== 'Property' || prop.computed) continue; + if (prop.key.type === 'Identifier') out.add(prop.key.name); + else if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') { + out.add(prop.key.value); + } + if (prop.value && prop.value.type === 'ObjectPattern') { + objectPatternNames(prop.value, out); + } + } +} + +// Returns false when the object literal is not fully static. +function objectExpressionKeys(node, out) { + for (const prop of node.properties) { + if (prop.type === 'SpreadElement') return false; + if (prop.type !== 'Property' || prop.computed) continue; + if (prop.key.type === 'Identifier') out.add(prop.key.name); + else if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') { + out.add(prop.key.value); + } + } + return true; +} + +module.exports = { + meta: { + type: 'problem', + docs: { + description: 'require benchmark main to read `n` when configs declare it', + }, + schema: [], + }, + + create(context) { + const { sourceCode } = context; + + let state = null; + + return { + CallExpression(node) { + if (state !== null) return; + const callee = node.callee; + if (callee.type !== 'MemberExpression' || callee.computed) return; + if (callee.property.name !== 'createBenchmark') return; + if (node.arguments.length < 2) return; + state = { + mainArg: node.arguments[0], + configArg: node.arguments[1], + }; + }, + + 'Program:exit'() { + if (state === null) return; + const { mainArg, configArg } = state; + + // Resolve config keys. + const configKeys = new Set(); + if (configArg.type === 'ObjectExpression') { + if (!objectExpressionKeys(configArg, configKeys)) return; + } else if (configArg.type === 'Identifier') { + let resolved = false; + walk(sourceCode.ast, (n) => { + if (resolved) return; + if (n.type === 'VariableDeclarator' && n.id.type === 'Identifier' && + n.id.name === configArg.name && n.init && + n.init.type === 'ObjectExpression') { + resolved = objectExpressionKeys(n.init, configKeys); + } + }); + if (!resolved) return; + } else { + return; + } + if (!configKeys.has('n')) return; + + // Resolve the main function node. + let fn = null; + if (mainArg.type === 'Identifier') { + walk(sourceCode.ast, (n) => { + if (fn !== null) return; + if (n.type === 'FunctionDeclaration' && n.id && n.id.name === mainArg.name) { + fn = n; + } + if (fn === null && n.type === 'VariableDeclarator' && n.id.type === 'Identifier' && + n.id.name === mainArg.name && n.init && + (n.init.type === 'FunctionExpression' || + n.init.type === 'ArrowFunctionExpression')) { + fn = n.init; + } + }); + } else if (mainArg.type === 'FunctionExpression' || + mainArg.type === 'ArrowFunctionExpression') { + fn = mainArg; + } + if (fn === null) return; + + // Collect every name through which `n` could be read in main(). + const paramNames = new Set(); + const readNames = new Set(); + for (const param of fn.params) { + if (param.type === 'ObjectPattern') { + objectPatternNames(param, readNames); + } else if (param.type === 'Identifier') { + paramNames.add(param.name); + } + } + walk(fn.body, (n) => { + // `const { a, b } = conf;` inside the body. + if (n.type === 'VariableDeclarator' && n.id.type === 'ObjectPattern' && + n.init && n.init.type === 'Identifier' && paramNames.has(n.init.name)) { + objectPatternNames(n.id, readNames); + } + // `conf.n` member access. + if (n.type === 'MemberExpression' && !n.computed && + n.object.type === 'Identifier' && paramNames.has(n.object.name) && + n.property.type === 'Identifier') { + readNames.add(n.property.name); + } + }); + + if (!readNames.has('n')) { + context.report({ + node: fn.id ?? fn, + message: '`n` is configured but not read by the benchmark main ' + + 'function (destructure `{ n }` or read `conf.n`)', + }); + } + }, + }; + }, +}; From 214d5e77dd80cf0e47938a93b6c67f51110207b2 Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Mon, 19 Oct 2026 13:27:15 -0300 Subject: [PATCH 059/331] doc: update V8 ABI release policy MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Document the V8-related native addon ABI policy discussed in nodejs/TSC#1852. Starting with Node.js 27, V8 updates may land during Alpha and Current even when they require a `NODE_MODULE_VERSION` bump, as long as the ABI change is documented in release notes. Refs: https://github.com/nodejs/TSC/issues/1852#issuecomment-4566968175 Signed-off-by: RafaelGSS PR-URL: https://github.com/nodejs/node/pull/64196 Refs: https://github.com/nodejs/TSC/issues/1852 Reviewed-By: Matteo Collina Reviewed-By: Robert Nagy Reviewed-By: Ulises Gascón Reviewed-By: Chengzhong Wu Reviewed-By: Antoine du Hamel Reviewed-By: Richard Lau --- .../maintaining/maintaining-V8.md | 4 ++++ doc/contributing/releases.md | 24 +++++++++++++++---- 2 files changed, 24 insertions(+), 4 deletions(-) diff --git a/doc/contributing/maintaining/maintaining-V8.md b/doc/contributing/maintaining/maintaining-V8.md index 9208b7cdbcd..e3571b63cac 100644 --- a/doc/contributing/maintaining/maintaining-V8.md +++ b/doc/contributing/maintaining/maintaining-V8.md @@ -330,6 +330,10 @@ Revision_ from the 5.4 branch that can be useful in the update process above. We upgrade the version of V8 in Node.js `main` whenever a V8 release goes stable upstream, that is, whenever a new release of Chrome comes out. +V8 updates can require a `NODE_MODULE_VERSION` bump if they change the native +addon ABI. See the release process documentation for when +`NODE_MODULE_VERSION` may be updated during a release line. + Upgrading major versions would be much harder to do with the patch mechanism above. A better strategy is to diff --git a/doc/contributing/releases.md b/doc/contributing/releases.md index 57bf2dc31bf..0b50c014c3b 100644 --- a/doc/contributing/releases.md +++ b/doc/contributing/releases.md @@ -1460,10 +1460,26 @@ in the registry. Also include a change to the registry in your commit to reflect the newly used value. Ensure that the release commit removes the `-pre` suffix for the major version being prepared. -It is current TSC policy to bump major version when ABI changes. If you -see a need to bump `NODE_MODULE_VERSION` outside of a major release then -you should consult the TSC. Commits may need to be reverted or a major -version bump may need to happen. +Starting with Node.js 27, changes that break the native addon ABI and require +a `NODE_MODULE_VERSION` bump, such as V8 updates, may land during the Alpha and +Current phases of a release line. Such changes should still be labeled as +semver-major on the default branch. When they are promoted to the release line, +they may land in semver-minor releases as long as the ABI change is clearly +documented in the release notes. + +Once a release line enters LTS, ABI-breaking changes are strongly discouraged. +They should only land when they are necessary, such as for security fixes, and +when there is no way to make the change without breaking the ABI. Breaking +changes that are not necessary for an LTS line, such as adding fields to a +struct to expose more information in a diagnostic API, do not meet this bar, +and should be reworked as non-breaking changes before they could land. In +practice, this means V8 is generally stable on a release line after it enters +LTS, and no ABI or API breaking changes +are expected unless in exceptional circumstances. + +This policy applies to addons that depend on V8, Node.js, or other non-Node-API +native interfaces. Node-API remains the recommended interface for native addons +that require ABI stability across Node.js versions. ##### Changelogs From 817eee082a33cb30ebe56fa7b7b1aaec56f499c8 Mon Sep 17 00:00:00 2001 From: Guy Bedford Date: Mon, 19 Oct 2026 09:56:07 -0700 Subject: [PATCH 060/331] wasi: accept wasm i32 pointers with high bit set Wasm i32 arguments with the high bit set are passed to JS as negative Int32 numbers, so WASI functions taking uint32_t pointers rejected them with EINVAL. Accept Int32 in CheckType and reinterpret as uint32_t on conversion, fixing all WASI functions at once. Fixes: https://github.com/nodejs/node/issues/62671 Refs: https://github.com/nodejs/node/pull/62822 Assisted-by: OpenCode Signed-off-by: Guy Bedford PR-URL: https://github.com/nodejs/node/pull/66636 Reviewed-By: James M Snell --- src/node_wasi.cc | 7 ++++++- test/fixtures/wasi-high-bit-ptr.wasm | Bin 0 -> 311 bytes test/fixtures/wasi-high-bit-ptr.wat | 22 ++++++++++++++++++++++ test/wasi/test-wasi-high-bit-ptr.js | 24 ++++++++++++++++++++++++ 4 files changed, 52 insertions(+), 1 deletion(-) create mode 100644 test/fixtures/wasi-high-bit-ptr.wasm create mode 100644 test/fixtures/wasi-high-bit-ptr.wat create mode 100644 test/wasi/test-wasi-high-bit-ptr.js diff --git a/src/node_wasi.cc b/src/node_wasi.cc index 7d8d056620c..326e449b391 100644 --- a/src/node_wasi.cc +++ b/src/node_wasi.cc @@ -36,6 +36,7 @@ using v8::FastApiCallbackOptions; using v8::FunctionCallbackInfo; using v8::FunctionTemplate; using v8::HandleScope; +using v8::Int32; using v8::Integer; using v8::Isolate; using v8::Local; @@ -296,13 +297,17 @@ static bool CheckType(Local v); template static VT ConvertType(Local V); +// Wasm i32 values with the high bit set arrive as negative Int32 numbers. template <> bool CheckType(Local value) { - return value->IsUint32(); + return value->IsUint32() || value->IsInt32(); } template <> uint32_t ConvertType(Local value) { + if (value->IsInt32()) { + return static_cast(value.As()->Value()); + } return value.As()->Value(); } diff --git a/test/fixtures/wasi-high-bit-ptr.wasm b/test/fixtures/wasi-high-bit-ptr.wasm new file mode 100644 index 0000000000000000000000000000000000000000..78f123ffbde2691e35054364ed00057192e93813 GIT binary patch literal 311 zcmZ`!OA5j;5Pg%RDprac>)M^*$|KYpc!D%YXoJR-LzM&Qql04;($m2|jGmPASDw9F^6yVEB2DvVOt?C$(KN literal 0 HcmV?d00001 diff --git a/test/fixtures/wasi-high-bit-ptr.wat b/test/fixtures/wasi-high-bit-ptr.wat new file mode 100644 index 00000000000..5336be28936 --- /dev/null +++ b/test/fixtures/wasi-high-bit-ptr.wat @@ -0,0 +1,22 @@ +;; Build: wasm-tools parse wasi-high-bit-ptr.wat -o wasi-high-bit-ptr.wasm +(module + (import "wasi_snapshot_preview1" "clock_time_get" + (func $clock_time_get (param i32 i64 i32) (result i32))) + (import "wasi_snapshot_preview1" "args_sizes_get" + (func $args_sizes_get (param i32 i32) (result i32))) + (memory (export "memory") 1) + (func (export "_start")) + (func (export "clock_time_get_high_ptr") (result i32) + i32.const 0 + i64.const 1 + i32.const 0x80000000 + call $clock_time_get) + (func (export "clock_time_get_low_ptr") (result i32) + i32.const 0 + i64.const 1 + i32.const 8 + call $clock_time_get) + (func (export "args_sizes_get_high_ptr") (result i32) + i32.const 0x80000000 + i32.const 0xfffffff0 + call $args_sizes_get)) diff --git a/test/wasi/test-wasi-high-bit-ptr.js b/test/wasi/test-wasi-high-bit-ptr.js new file mode 100644 index 00000000000..e2ea0bdbc6c --- /dev/null +++ b/test/wasi/test-wasi-high-bit-ptr.js @@ -0,0 +1,24 @@ +'use strict'; +// Wasm i32 arguments with the high bit set arrive in JS as negative Int32 +// numbers. WASI functions must reinterpret them as uint32 pointers rather +// than rejecting them with EINVAL. +const common = require('../common'); +const assert = require('assert'); +const fixtures = require('../common/fixtures'); +const { WASI } = require('wasi'); + +const UVWASI_EOVERFLOW = 61; + +(async () => { + const wasi = new WASI({ version: 'preview1', returnOnExit: true }); + const importObject = { wasi_snapshot_preview1: wasi.wasiImport }; + const { instance } = await WebAssembly.instantiate( + fixtures.readSync('wasi-high-bit-ptr.wasm'), importObject); + wasi.start(instance); + + assert.strictEqual(instance.exports.clock_time_get_low_ptr(), 0); + assert.strictEqual(instance.exports.clock_time_get_high_ptr(), + UVWASI_EOVERFLOW); + assert.strictEqual(instance.exports.args_sizes_get_high_ptr(), + UVWASI_EOVERFLOW); +})().then(common.mustCall()); From bb6de74919ec901724f9988252afeeb10195dd84 Mon Sep 17 00:00:00 2001 From: Guy Bedford Date: Mon, 19 Oct 2026 10:09:42 -0700 Subject: [PATCH 061/331] module: add "worker" condition for Web Worker threads Adds a "worker" package condition that is applied within Web Worker threads created via the `Worker` global, for the worker entry point, its dependencies, `import()`, `require()` and `import.meta.resolve()`. Threads created via `worker_threads`, including from within a Web Worker, do not apply the condition. Other conditions are unaffected. Assisted-by: OpenCode Signed-off-by: Guy Bedford PR-URL: https://github.com/nodejs/node/pull/66635 Reviewed-By: James M Snell --- doc/api/globals.md | 7 ++ doc/api/packages.md | 7 ++ lib/internal/main/worker_thread.js | 1 + lib/internal/modules/esm/hooks.js | 2 + lib/internal/modules/esm/utils.js | 2 + lib/internal/modules/esm/worker.js | 7 +- lib/internal/modules/helpers.js | 14 ++++ .../worker-condition/classic-worker.js | 5 ++ .../worker-condition/hooks-worker.mjs | 6 ++ .../es-modules/worker-condition/hooks.mjs | 6 ++ .../es-modules/worker-condition/main.mjs | 13 ++++ .../worker-condition/module-worker.mjs | 31 ++++++++ .../worker-condition/nested-worker.mjs | 2 + .../node_modules/pkg/custom-worker.mjs | 1 + .../node_modules/pkg/custom.mjs | 1 + .../node_modules/pkg/default.cjs | 1 + .../node_modules/pkg/default.mjs | 1 + .../node_modules/pkg/package.json | 23 ++++++ .../node_modules/pkg/worker.cjs | 1 + .../node_modules/pkg/worker.mjs | 1 + .../thread-spawns-webworker.mjs | 8 ++ .../es-modules/worker-condition/thread.mjs | 13 ++++ test/parallel/test-webworker-conditions.js | 77 +++++++++++++++++++ 23 files changed, 229 insertions(+), 1 deletion(-) create mode 100644 test/fixtures/es-modules/worker-condition/classic-worker.js create mode 100644 test/fixtures/es-modules/worker-condition/hooks-worker.mjs create mode 100644 test/fixtures/es-modules/worker-condition/hooks.mjs create mode 100644 test/fixtures/es-modules/worker-condition/main.mjs create mode 100644 test/fixtures/es-modules/worker-condition/module-worker.mjs create mode 100644 test/fixtures/es-modules/worker-condition/nested-worker.mjs create mode 100644 test/fixtures/es-modules/worker-condition/node_modules/pkg/custom-worker.mjs create mode 100644 test/fixtures/es-modules/worker-condition/node_modules/pkg/custom.mjs create mode 100644 test/fixtures/es-modules/worker-condition/node_modules/pkg/default.cjs create mode 100644 test/fixtures/es-modules/worker-condition/node_modules/pkg/default.mjs create mode 100644 test/fixtures/es-modules/worker-condition/node_modules/pkg/package.json create mode 100644 test/fixtures/es-modules/worker-condition/node_modules/pkg/worker.cjs create mode 100644 test/fixtures/es-modules/worker-condition/node_modules/pkg/worker.mjs create mode 100644 test/fixtures/es-modules/worker-condition/thread-spawns-webworker.mjs create mode 100644 test/fixtures/es-modules/worker-condition/thread.mjs create mode 100644 test/parallel/test-webworker-conditions.js diff --git a/doc/api/globals.md b/doc/api/globals.md index f2366fbfd11..f14779dda23 100644 --- a/doc/api/globals.md +++ b/doc/api/globals.md @@ -1373,6 +1373,12 @@ accepted and how failures are reported: `file:` URLs. The `type` option, not the file extension, decides how an entry is run, so a `.cts` entry is still evaluated as an ES module. +Package resolution within a Web Worker, including the entry point, its +dependencies, `import()`, `require()`, and `import.meta.resolve()`, applies +the `"worker"` [package condition][] in addition to the usual conditions. +Threads created through [`node:worker_threads`][] from within a Web Worker do +not apply it. + ### Differences from the HTML Standard Besides script loading, mentioned above: @@ -1541,6 +1547,7 @@ A browser-compatible implementation of [`WritableStreamDefaultWriter`][]. [browser `LockManager`]: https://developer.mozilla.org/en-US/docs/Web/API/LockManager [buffer section]: buffer.md [built-in objects]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects +[package condition]: packages.md#conditional-exports [timers]: timers.md [type stripping]: typescript.md#type-stripping [webassembly-mdn]: https://developer.mozilla.org/en-US/docs/WebAssembly diff --git a/doc/api/packages.md b/doc/api/packages.md index 653a2947d7c..55ac9ad3a38 100644 --- a/doc/api/packages.md +++ b/doc/api/packages.md @@ -710,6 +710,11 @@ specific to least specific as conditions should be defined: `import()` or `require()`. The format is expected to be ES modules that does not contain top-level await in its module graph - if it does, `ERR_REQUIRE_ASYNC_MODULE` will be thrown when the module is `require()`-ed. +* `"worker"` - matches when the package is loaded within a [Web Worker][] + thread, including the worker entry point and all of its dependencies, + `import()`, `require()`, and `import.meta.resolve()`. Does not apply to + threads created with [`node:worker_threads`][], including those created + from within a Web Worker. * `"default"` - the generic fallback that always matches. Can be a CommonJS or ES module file. _This condition should always come last._ @@ -1384,6 +1389,7 @@ Node.js allows type stripping for: [Runtime Keys]: https://runtime-keys.proposal.wintercg.org/ [Syntax detection]: #syntax-detection [TypeScript]: typescript.md +[Web Worker]: globals.md#class-worker [WebAssembly modules]: esm.md#wasm-modules [WinterCG]: https://wintercg.org/ [`"exports"`]: #exports @@ -1401,6 +1407,7 @@ Node.js allows type stripping for: [`ERR_PACKAGE_PATH_NOT_EXPORTED`]: errors.md#err_package_path_not_exported [`ERR_UNKNOWN_FILE_EXTENSION`]: errors.md#err_unknown_file_extension [`URL`]: url.md#the-whatwg-url-api +[`node:worker_threads`]: worker_threads.md [`package.json`]: #nodejs-packagejson-field-definitions [customization hooks]: module.md#customization-hooks [entry points]: #package-entry-points diff --git a/lib/internal/main/worker_thread.js b/lib/internal/main/worker_thread.js index e2b30de754a..864b776925f 100644 --- a/lib/internal/main/worker_thread.js +++ b/lib/internal/main/worker_thread.js @@ -119,6 +119,7 @@ port.on('message', (message) => { setupMainThreadPort(mainThreadPort); if (webWorkerData !== undefined) { + require('internal/modules/helpers').enableWorkerCondition(); require('internal/webworker') .installDedicatedWorkerGlobalScope(webWorkerData.url, webWorkerData); } diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js index 4ced5521aca..220dcd33754 100644 --- a/lib/internal/modules/esm/hooks.js +++ b/lib/internal/modules/esm/hooks.js @@ -50,6 +50,7 @@ const { const { getDefaultConditions, } = require('internal/modules/esm/utils'); +const { hasWorkerCondition } = require('internal/modules/helpers'); const { deserializeError } = require('internal/error_serdes'); const { SHARED_MEMORY_BYTE_LENGTH, @@ -531,6 +532,7 @@ class AsyncLoaderHookWorker { trackUnmanagedFds: false, workerData: { lock, + workerCondition: hasWorkerCondition(), }, }); this.#worker.unref(); // ! Allows the process to eventually exit. diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js index 9e27a2db1eb..c6b101fb907 100644 --- a/lib/internal/modules/esm/utils.js +++ b/lib/internal/modules/esm/utils.js @@ -44,6 +44,7 @@ const { } = require('internal/util'); const assert = require('internal/assert'); const { + hasWorkerCondition, normalizeReferrerURL, loadBuiltinModuleForEmbedder, } = require('internal/modules/helpers'); @@ -84,6 +85,7 @@ function initializeDefaultConditions() { 'import', ...moduleConditions, ...addonConditions, + ...(hasWorkerCondition() ? ['worker'] : []), ...userConditions, ]); defaultConditionsSet = new SafeSet(defaultConditions); diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js index e2553b253db..7d023059a4b 100644 --- a/lib/internal/modules/esm/worker.js +++ b/lib/internal/modules/esm/worker.js @@ -35,6 +35,7 @@ const { isMarkedAsUntransferable } = require('internal/buffer'); const { getCWDURL } = require('internal/util'); const { isCascadedLoaderInitialized, getOrInitializeCascadedLoader } = require('internal/modules/esm/loader'); const { AsyncLoaderHooksOnLoaderHookWorker } = require('internal/modules/esm/hooks'); +const { enableWorkerCondition } = require('internal/modules/helpers'); /** * Register asynchronous module loader customization hooks. This should only be run in the loader @@ -285,12 +286,16 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) { /** * Initializes a worker thread for a module with customized hooks. * ! Run everything possible within this function so errors get reported. - * @param {{lock: SharedArrayBuffer}} workerData - The lock used to synchronize with the main thread. + * @param {{lock: SharedArrayBuffer, workerCondition: boolean}} workerData - The lock used to + * synchronize with the main thread, and whether the spawning thread is a Web Worker. * @param {MessagePort} syncCommPort - The communication port used to communicate with the main thread. * @returns {object} */ module.exports = function setupModuleWorker(workerData, syncCommPort) { const lock = new Int32Array(workerData.lock); + if (workerData.workerCondition) { + enableWorkerCondition(); + } /** * Handles errors that occur in the worker thread. diff --git a/lib/internal/modules/helpers.js b/lib/internal/modules/helpers.js index 851547d2216..e30b892ad5e 100644 --- a/lib/internal/modules/helpers.js +++ b/lib/internal/modules/helpers.js @@ -196,6 +196,17 @@ function purgeRealpathCacheForPrefix(mountPoint) { cleanForVfsPrefix(realpathCache, mountPoint); } +/** Whether the `worker` condition applies, i.e. this is a Web Worker thread. */ +let workerCondition = false; + +function enableWorkerCondition() { + workerCondition = true; +} + +function hasWorkerCondition() { + return workerCondition; +} + /** @type {Set} */ let cjsConditions; /** @type {string[]} */ @@ -214,6 +225,7 @@ function initializeCjsConditions() { 'require', 'node', ...addonConditions, + ...(workerCondition ? ['worker'] : []), ...userConditions, ]; if (getOptionValue('--require-module')) { @@ -693,11 +705,13 @@ module.exports = { purgeRealpathCacheForPrefix, constants, enableCompileCache, + enableWorkerCondition, flushCompileCache, getBuiltinModule, getCjsConditions, getCjsConditionsArray, getCompileCacheDir, + hasWorkerCondition, initializeCjsConditions, legacyMainResolveExtensions, legacyMainResolveExtensionsIndexes, diff --git a/test/fixtures/es-modules/worker-condition/classic-worker.js b/test/fixtures/es-modules/worker-condition/classic-worker.js new file mode 100644 index 00000000000..d1f5f4e8d41 --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/classic-worker.js @@ -0,0 +1,5 @@ +'use strict'; +const required = require('pkg'); +import('pkg').then(({ default: imported }) => { + postMessage({ require: required, import: imported, resolve: require.resolve('pkg') }); +}); diff --git a/test/fixtures/es-modules/worker-condition/hooks-worker.mjs b/test/fixtures/es-modules/worker-condition/hooks-worker.mjs new file mode 100644 index 00000000000..ee9cd45bd6c --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/hooks-worker.mjs @@ -0,0 +1,6 @@ +import { register } from 'node:module'; + +register('./hooks.mjs', import.meta.url); + +const { default: value } = await import('pkg'); +postMessage(value); diff --git a/test/fixtures/es-modules/worker-condition/hooks.mjs b/test/fixtures/es-modules/worker-condition/hooks.mjs new file mode 100644 index 00000000000..8505bafc98d --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/hooks.mjs @@ -0,0 +1,6 @@ +export async function resolve(specifier, context, nextResolve) { + if (specifier === 'pkg' && !context.conditions.includes('worker')) { + throw new Error(`missing worker condition: ${context.conditions}`); + } + return nextResolve(specifier, context); +} diff --git a/test/fixtures/es-modules/worker-condition/main.mjs b/test/fixtures/es-modules/worker-condition/main.mjs new file mode 100644 index 00000000000..2565f04c420 --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/main.mjs @@ -0,0 +1,13 @@ +import { createRequire } from 'node:module'; +import value from 'pkg'; +import custom from 'pkg/custom'; + +const require = createRequire(import.meta.url); + +export default { + import: value, + custom, + require: require('pkg'), + resolve: import.meta.resolve('pkg'), + workerOnly: await import('pkg/worker-only').then(() => 'resolved', (err) => err.code), +}; diff --git a/test/fixtures/es-modules/worker-condition/module-worker.mjs b/test/fixtures/es-modules/worker-condition/module-worker.mjs new file mode 100644 index 00000000000..fb069c69213 --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/module-worker.mjs @@ -0,0 +1,31 @@ +import { once } from 'node:events'; +import { createRequire } from 'node:module'; +import { Worker as ThreadWorker } from 'node:worker_threads'; +import staticImport from 'pkg'; +import custom from 'pkg/custom'; +import workerOnly from 'pkg/worker-only'; + +const require = createRequire(import.meta.url); + +const { default: dynamicImport } = await import('pkg'); + +const thread = new ThreadWorker(new URL('./thread.mjs', import.meta.url)); +const [threadResult] = await once(thread, 'message'); + +const nested = new Worker(new URL('./nested-worker.mjs', import.meta.url), { type: 'module' }); +const nestedResult = await new Promise((resolve, reject) => { + nested.onmessage = ({ data }) => resolve(data); + nested.onerror = reject; +}); +nested.terminate(); + +postMessage({ + staticImport, + dynamicImport, + custom, + workerOnly, + resolve: import.meta.resolve('pkg'), + require: require('pkg'), + thread: threadResult, + nested: nestedResult, +}); diff --git a/test/fixtures/es-modules/worker-condition/nested-worker.mjs b/test/fixtures/es-modules/worker-condition/nested-worker.mjs new file mode 100644 index 00000000000..48a03e4fe41 --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/nested-worker.mjs @@ -0,0 +1,2 @@ +import value from 'pkg'; +postMessage(value); diff --git a/test/fixtures/es-modules/worker-condition/node_modules/pkg/custom-worker.mjs b/test/fixtures/es-modules/worker-condition/node_modules/pkg/custom-worker.mjs new file mode 100644 index 00000000000..e80a870ddab --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/node_modules/pkg/custom-worker.mjs @@ -0,0 +1 @@ +export default 'custom-worker'; diff --git a/test/fixtures/es-modules/worker-condition/node_modules/pkg/custom.mjs b/test/fixtures/es-modules/worker-condition/node_modules/pkg/custom.mjs new file mode 100644 index 00000000000..bcd83d82be0 --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/node_modules/pkg/custom.mjs @@ -0,0 +1 @@ +export default 'custom'; diff --git a/test/fixtures/es-modules/worker-condition/node_modules/pkg/default.cjs b/test/fixtures/es-modules/worker-condition/node_modules/pkg/default.cjs new file mode 100644 index 00000000000..024b12f7391 --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/node_modules/pkg/default.cjs @@ -0,0 +1 @@ +module.exports = 'default'; diff --git a/test/fixtures/es-modules/worker-condition/node_modules/pkg/default.mjs b/test/fixtures/es-modules/worker-condition/node_modules/pkg/default.mjs new file mode 100644 index 00000000000..413f601a377 --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/node_modules/pkg/default.mjs @@ -0,0 +1 @@ +export default 'default'; diff --git a/test/fixtures/es-modules/worker-condition/node_modules/pkg/package.json b/test/fixtures/es-modules/worker-condition/node_modules/pkg/package.json new file mode 100644 index 00000000000..b50fb3299d0 --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/node_modules/pkg/package.json @@ -0,0 +1,23 @@ +{ + "name": "pkg", + "exports": { + ".": { + "worker": { + "import": "./worker.mjs", + "require": "./worker.cjs" + }, + "import": "./default.mjs", + "require": "./default.cjs" + }, + "./custom": { + "custom-condition": { + "worker": "./custom-worker.mjs", + "default": "./custom.mjs" + }, + "default": "./default.mjs" + }, + "./worker-only": { + "worker": "./worker.mjs" + } + } +} diff --git a/test/fixtures/es-modules/worker-condition/node_modules/pkg/worker.cjs b/test/fixtures/es-modules/worker-condition/node_modules/pkg/worker.cjs new file mode 100644 index 00000000000..a8baa369c92 --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/node_modules/pkg/worker.cjs @@ -0,0 +1 @@ +module.exports = 'worker'; diff --git a/test/fixtures/es-modules/worker-condition/node_modules/pkg/worker.mjs b/test/fixtures/es-modules/worker-condition/node_modules/pkg/worker.mjs new file mode 100644 index 00000000000..314cb87d069 --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/node_modules/pkg/worker.mjs @@ -0,0 +1 @@ +export default 'worker'; diff --git a/test/fixtures/es-modules/worker-condition/thread-spawns-webworker.mjs b/test/fixtures/es-modules/worker-condition/thread-spawns-webworker.mjs new file mode 100644 index 00000000000..c76a741d6cc --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/thread-spawns-webworker.mjs @@ -0,0 +1,8 @@ +import { parentPort } from 'node:worker_threads'; +import value from 'pkg'; + +const worker = new Worker(new URL('./nested-worker.mjs', import.meta.url), { type: 'module' }); +worker.onmessage = ({ data }) => { + worker.terminate(); + parentPort.postMessage({ thread: value, webWorker: data }); +}; diff --git a/test/fixtures/es-modules/worker-condition/thread.mjs b/test/fixtures/es-modules/worker-condition/thread.mjs new file mode 100644 index 00000000000..d5e0b615cc0 --- /dev/null +++ b/test/fixtures/es-modules/worker-condition/thread.mjs @@ -0,0 +1,13 @@ +import { parentPort } from 'node:worker_threads'; +import { createRequire } from 'node:module'; +import value from 'pkg'; +import custom from 'pkg/custom'; + +const require = createRequire(import.meta.url); + +parentPort.postMessage({ + import: value, + custom, + require: require('pkg'), + resolve: import.meta.resolve('pkg'), +}); diff --git a/test/parallel/test-webworker-conditions.js b/test/parallel/test-webworker-conditions.js new file mode 100644 index 00000000000..313e3f3d643 --- /dev/null +++ b/test/parallel/test-webworker-conditions.js @@ -0,0 +1,77 @@ +// Flags: --experimental-web-worker --conditions=custom-condition +'use strict'; + +// The `worker` package condition applies only within Web Worker threads, +// not on the main thread or in `worker_threads` threads. + +const common = require('../common'); +const fixtures = require('../common/fixtures'); +const assert = require('node:assert'); +const { once } = require('node:events'); +const { Worker: ThreadWorker } = require('node:worker_threads'); + +const base = fixtures.fileURL('es-modules/worker-condition/'); +const pkg = new URL('node_modules/pkg/', base); + +function runWebWorker(url, options) { + const worker = new Worker(url, options); + worker.onerror = common.mustNotCall('worker failed'); + return new Promise((resolve) => { + worker.onmessage = common.mustCall(({ data }) => { + worker.terminate(); + resolve(data); + }); + }); +} + +(async () => { + // Main thread: no worker condition. + assert.deepStrictEqual((await import(new URL('main.mjs', base))).default, { + import: 'default', + custom: 'custom', + require: 'default', + resolve: new URL('default.mjs', pkg).href, + workerOnly: 'ERR_PACKAGE_PATH_NOT_EXPORTED', + }); + + // Module Web Worker: entry point dependencies, dynamic import, + // import.meta.resolve, require, nested threads. + assert.deepStrictEqual( + await runWebWorker(new URL('module-worker.mjs', base), { type: 'module' }), + { + staticImport: 'worker', + dynamicImport: 'worker', + custom: 'custom-worker', + workerOnly: 'worker', + resolve: new URL('worker.mjs', pkg).href, + require: 'worker', + // worker_threads created from a Web Worker revert to no worker condition. + thread: { + import: 'default', + custom: 'custom', + require: 'default', + resolve: new URL('default.mjs', pkg).href, + }, + // Nested Web Workers retain it. + nested: 'worker', + }); + + // Classic Web Worker. + assert.deepStrictEqual( + await runWebWorker(new URL('classic-worker.js', base)), + { + require: 'worker', + import: 'worker', + resolve: fixtures.path('es-modules/worker-condition/node_modules/pkg/worker.cjs'), + }); + + // Web Worker created from a worker_threads thread. + const thread = new ThreadWorker(new URL('thread-spawns-webworker.mjs', base)); + const [threadResult] = await once(thread, 'message'); + assert.deepStrictEqual(threadResult, { thread: 'default', webWorker: 'worker' }); + + // Async module customization hooks registered from a Web Worker. + assert.strictEqual( + await runWebWorker(new URL('hooks-worker.mjs', base), { type: 'module' }), + 'worker'); +})().then(common.mustCall()); From 4a37d08ceba677b79bcca13b467c5604b826811b Mon Sep 17 00:00:00 2001 From: Efe Karasakal Date: Mon, 19 Oct 2026 23:16:23 +0200 Subject: [PATCH 062/331] quic: allow null body when opening streams Signed-off-by: Efe Karasakal PR-URL: https://github.com/nodejs/node/pull/66690 Reviewed-By: Tim Perry --- lib/internal/quic/quic.js | 3 +- src/quic/streams.cc | 5 +- .../parallel/test-quic-stream-zero-length.mjs | 78 +++++++++++++------ 3 files changed, 60 insertions(+), 26 deletions(-) diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js index d80b5846682..2d75c5cbe00 100644 --- a/lib/internal/quic/quic.js +++ b/lib/internal/quic/quic.js @@ -1253,7 +1253,7 @@ function invokeOnerror(fn, error) { } function validateBody(body) { - if (body === undefined) return body; + if (body === undefined || body === null) return body; // ArrayBuffers, SharedArrayBuffers, and ArrayBufferViews are passed // through to the C++ layer which copies the bytes into its own // BackingStore. Callers can therefore safely reuse or mutate their @@ -1290,6 +1290,7 @@ function validateBody(body) { 'ArrayBufferView', 'Blob', 'FileHandle', + 'null', ], body); } diff --git a/src/quic/streams.cc b/src/quic/streams.cc index 8e9d3570938..0a2af12d366 100644 --- a/src/quic/streams.cc +++ b/src/quic/streams.cc @@ -290,11 +290,14 @@ std::unique_ptr CreateEntryFromBuffer( Maybe> Stream::GetDataQueueFromSource( Environment* env, Local value) { - DCHECK_IMPLIES(!value->IsUndefined(), value->IsObject()); + DCHECK(value->IsUndefined() || value->IsNull() || value->IsObject()); std::vector> entries; if (value->IsUndefined()) { // Return an empty DataQueue. return Just(std::shared_ptr()); + } else if (value->IsNull()) { + // Return an empty, completed data source. + return Just(DataQueue::CreateIdempotent(std::move(entries))); } else if (value->IsArrayBuffer()) { auto buffer = value.As(); auto length = buffer->ByteLength(); diff --git a/test/parallel/test-quic-stream-zero-length.mjs b/test/parallel/test-quic-stream-zero-length.mjs index 1c745ffc264..32f7bc52440 100644 --- a/test/parallel/test-quic-stream-zero-length.mjs +++ b/test/parallel/test-quic-stream-zero-length.mjs @@ -15,27 +15,57 @@ if (!hasQuic) { const { listen, connect } = await import('../common/quic.mjs'); const { bytes } = await import('stream/iter'); -const serverDone = Promise.withResolvers(); - -const serverEndpoint = await listen(mustCall((serverSession) => { - serverSession.onstream = mustCall(async (stream) => { - const received = await bytes(stream); - assert.strictEqual(received.byteLength, 0); - stream.writer.endSync(); - await stream.closed; - serverSession.close(); - serverDone.resolve(); - }); -})); - -const clientSession = await connect(serverEndpoint.address); -await clientSession.opened; - -const stream = await clientSession.createBidirectionalStream(); -stream.setBody(null); - -await dump(stream); - -await Promise.all([stream.closed, serverDone.promise]); -await clientSession.close(); -await serverEndpoint.close(); +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + assert.strictEqual(received.byteLength, 0); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream(); + stream.setBody(null); + + await dump(stream); + + await Promise.all([stream.closed, serverDone.promise]); + await clientSession.close(); + await serverEndpoint.close(); +} + +// Stream via createBidirectionalStream({ body: null }). +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + assert.strictEqual(received.byteLength, 0); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + const stream = + await clientSession.createBidirectionalStream({ body: null }); + + await dump(stream); + + await Promise.all([stream.closed, serverDone.promise]); + await clientSession.close(); + await serverEndpoint.close(); +} From 2d72918af37a84373d37e73cc8c140be8d091d99 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Mon, 19 Oct 2026 20:46:45 -0400 Subject: [PATCH 063/331] test: update WPT for WebCryptoAPI to e15690d276 PR-URL: https://github.com/nodejs/node/pull/66813 Reviewed-By: Filip Skokan Reviewed-By: Matthew Aitken Reviewed-By: Luigi Pinca --- .../wpt/WebCryptoAPI/digest/digest.js | 4 +- .../wpt/WebCryptoAPI/encrypt_decrypt/aes.js | 8 +- .../wpt/WebCryptoAPI/encrypt_decrypt/rsa.js | 8 +- .../okp_fixed_length.https.any.js | 127 ++++++++++++++++++ .../okp_malformed_asn1.https.any.js | 99 ++++++++++++++ .../modern-algos/digest/xof_digest.js | 4 +- .../wpt/WebCryptoAPI/sign_verify/mac.js | 8 +- .../wpt/WebCryptoAPI/sign_verify/signature.js | 8 +- .../aes_kw_unwrapKey_failures.https.any.js | 38 ++++++ test/fixtures/wpt/versions.json | 2 +- test/wpt/status/WebCryptoAPI.cjs | 2 + 11 files changed, 297 insertions(+), 11 deletions(-) create mode 100644 test/fixtures/wpt/WebCryptoAPI/import_export/okp_fixed_length.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/import_export/okp_malformed_asn1.https.any.js create mode 100644 test/fixtures/wpt/WebCryptoAPI/wrapKey_unwrapKey/aes_kw_unwrapKey_failures.https.any.js diff --git a/test/fixtures/wpt/WebCryptoAPI/digest/digest.js b/test/fixtures/wpt/WebCryptoAPI/digest/digest.js index 63dfd86ebf1..ab1453c58ae 100644 --- a/test/fixtures/wpt/WebCryptoAPI/digest/digest.js +++ b/test/fixtures/wpt/WebCryptoAPI/digest/digest.js @@ -59,7 +59,9 @@ function runDigestTests(subtle, sourceData, getVectors) { promise_test(function () { var buffer = new Uint8Array(sourceData[size]); var algorithm = withNameGetter(vector.algorithm, function () { - buffer.buffer.transfer(); + if (!buffer.buffer.detached) { + buffer.buffer.transfer(); + } return algorithmName(vector.algorithm); }); return subtle.digest(algorithm, buffer).then(function (result) { diff --git a/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/aes.js b/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/aes.js index 9caecf695cf..57567fd4975 100644 --- a/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/aes.js +++ b/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/aes.js @@ -102,7 +102,9 @@ function run_test() { var operation = subtle.encrypt({ ...vector.algorithm, get name() { - plaintext.buffer.transfer(); + if (!plaintext.buffer.detached) { + plaintext.buffer.transfer(); + } return vector.algorithm.name; } }, vector.key, plaintext) @@ -244,7 +246,9 @@ function run_test() { var operation = subtle.decrypt({ ...vector.algorithm, get name() { - ciphertext.buffer.transfer(); + if (!ciphertext.buffer.detached) { + ciphertext.buffer.transfer(); + } return vector.algorithm.name; } }, vector.key, ciphertext) diff --git a/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/rsa.js b/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/rsa.js index 951ffd56e58..d866b7b4779 100644 --- a/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/rsa.js +++ b/test/fixtures/wpt/WebCryptoAPI/encrypt_decrypt/rsa.js @@ -124,7 +124,9 @@ function run_test() { var operation = subtle.decrypt({ ...vector.algorithm, get name() { - ciphertext.buffer.transfer(); + if (!ciphertext.buffer.detached) { + ciphertext.buffer.transfer(); + } return vector.algorithm.name; } }, vector.privateKey, ciphertext) @@ -337,7 +339,9 @@ function run_test() { var operation = subtle.encrypt({ ...vector.algorithm, get name() { - plaintext.buffer.transfer(); + if (!plaintext.buffer.detached) { + plaintext.buffer.transfer(); + } return vector.algorithm.name; } }, vector.publicKey, plaintext) diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/okp_fixed_length.https.any.js b/test/fixtures/wpt/WebCryptoAPI/import_export/okp_fixed_length.https.any.js new file mode 100644 index 00000000000..66123b24c79 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/import_export/okp_fixed_length.https.any.js @@ -0,0 +1,127 @@ +// META: title=WebCryptoAPI: OKP imports preserve fixed-length key material + +const message = bytes("010203"); +const peer = { + pkcs8: bytes("302e020100300506032b656e0422042038adaddfe94506a579a2cabcc9a50794b464689e065ed3e86b76e1ef1011f01a"), + spki: bytes("302a300506032b656e032100a1d178cd56e2528f7b8d82ba2e3772b219c944f0e8fbfb0d1ca3951d0ce00b13"), +}; + +const vectors = [ + { + algorithm: "Ed25519", + name: "a leading-zero private key", + pkcs8: "302e020100300506032b6570042204200007070707070707070707070707070707070707070707070707070707070707", + raw: "ff812f84e53570c36ae9479aad71e649c3cc4a04a6768632150febdd66a238a8", + signature: "94ff57055f3b90728d704bfbf19a3e4b49806f98a10384ae01ed5c700e6d482a12dd5f6372ce160f5cf94e8cd53555a7b525658d8f4126d463fa4200578d710e", + spki: "302a300506032b6570032100ff812f84e53570c36ae9479aad71e649c3cc4a04a6768632150febdd66a238a8", + }, + { + algorithm: "Ed25519", + name: "an all-zero private key", + pkcs8: "302e020100300506032b6570042204200000000000000000000000000000000000000000000000000000000000000000", + raw: "3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29", + signature: "2a26779ba6cbb5e54292257f725af112b273c38728329682d99ed81ba6d7670350ae4cc53c5456fa437128d19298a5d949ab46e3d41ab3dbcfb0b35c895e9304", + spki: "302a300506032b65700321003b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29", + }, + { + algorithm: "Ed25519", + name: "a leading-zero public key", + pkcs8: "302e020100300506032b6570042204204dca5ad94292a81e64a2c780e98d5469f53523107d9b00a63e37b5097786481f", + raw: "00009314998a59a276e35cac5d39d9cf642b5add8fc428baca5d18a7b30cda40", + signature: "b6a45af39f7545b0fb894a583c5156e027a97cb09e46a999ffb269aec6fc0d0af76169c7771d09431c08ee22cb99c8966fa261097c843855cd2005678c88710a", + spki: "302a300506032b657003210000009314998a59a276e35cac5d39d9cf642b5add8fc428baca5d18a7b30cda40", + }, + { + algorithm: "X25519", + name: "a leading-zero private key", + pkcs8: "302e020100300506032b656e042204200007070707070707070707070707070707070707070707070707070707070707", + raw: "13be4feaeaf204c7fd3358fc9c00721881d174278128227ec674f37f7fe97b6d", + secret: "51eafdc7ed3371472837de1aca43bee0b198aa02d1f619eb26ed1d1045bcd936", + spki: "302a300506032b656e03210013be4feaeaf204c7fd3358fc9c00721881d174278128227ec674f37f7fe97b6d", + }, + { + algorithm: "X25519", + name: "an all-zero private key", + pkcs8: "302e020100300506032b656e042204200000000000000000000000000000000000000000000000000000000000000000", + raw: "2fe57da347cd62431528daac5fbb290730fff684afc4cfc2ed90995f58cb3b74", + secret: "caa5f83ef211ee3ce3ae25b011f85ba0c55384769049a04bfc19770373c6df30", + spki: "302a300506032b656e0321002fe57da347cd62431528daac5fbb290730fff684afc4cfc2ed90995f58cb3b74", + }, + { + algorithm: "X25519", + name: "a leading-zero public key", + pkcs8: "302e020100300506032b656e0422042031821845335f559760a05a2e1d3b0fd6e603b6a2640d969cd29e28ea9c5dddd7", + raw: "00a3785afdc7bb07fa13a4b075f00576cba6946a70cd6ad20b25c949eae6f636", + secret: "83b1b1eafc349edfc4401760c9949bc2fa95fceebd51cd7d87c2fd4a6ac85d21", + spki: "302a300506032b656e03210000a3785afdc7bb07fa13a4b075f00576cba6946a70cd6ad20b25c949eae6f636", + }, +]; + +function bytes(hex) { + return new Uint8Array(hex.match(/../g).map(value => Number.parseInt(value, 16))); +} + +function base64url(value) { + return btoa(String.fromCharCode(...value)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, ""); +} + +function privateBytes(pkcs8) { + return pkcs8.slice(-32); +} + +for (const vector of vectors) { + promise_test(async () => { + const pkcs8 = bytes(vector.pkcs8); + const privateUsages = vector.algorithm === "Ed25519" ? ["sign"] : ["deriveBits"]; + const privateKey = await crypto.subtle.importKey("pkcs8", pkcs8, vector.algorithm, true, privateUsages); + + assert_array_equals( + new Uint8Array(await crypto.subtle.exportKey("pkcs8", privateKey)), + pkcs8, + "PKCS#8 round trip", + ); + const jwk = await crypto.subtle.exportKey("jwk", privateKey); + assert_equals(jwk.d, base64url(privateBytes(pkcs8)), "JWK private key bytes"); + assert_equals(jwk.x, base64url(bytes(vector.raw)), "JWK public key bytes"); + + const spki = bytes(vector.spki); + const publicUsages = vector.algorithm === "Ed25519" ? ["verify"] : []; + const publicKey = await crypto.subtle.importKey("spki", spki, vector.algorithm, true, publicUsages); + assert_array_equals( + new Uint8Array(await crypto.subtle.exportKey("spki", publicKey)), + spki, + "SPKI round trip", + ); + assert_array_equals( + new Uint8Array(await crypto.subtle.exportKey("raw", publicKey)), + bytes(vector.raw), + "raw public key", + ); + + if (vector.algorithm === "Ed25519") { + const signature = new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, message)); + assert_true( + await crypto.subtle.verify("Ed25519", publicKey, signature, message), + "generated signature verifies", + ); + assert_true( + await crypto.subtle.verify("Ed25519", publicKey, bytes(vector.signature), message), + "independent reference signature verifies", + ); + return; + } + + const peerPublic = await crypto.subtle.importKey("spki", peer.spki, "X25519", false, []); + assert_array_equals( + new Uint8Array(await crypto.subtle.deriveBits({name: "X25519", public: peerPublic}, privateKey, 256)), + bytes(vector.secret), + "independent reference shared secret", + ); + const peerPrivate = await crypto.subtle.importKey("pkcs8", peer.pkcs8, "X25519", false, ["deriveBits"]); + assert_array_equals( + new Uint8Array(await crypto.subtle.deriveBits({name: "X25519", public: publicKey}, peerPrivate, 256)), + bytes(vector.secret), + "imported public key shared secret", + ); + }, `${vector.algorithm} preserves ${vector.name}`); +} diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/okp_malformed_asn1.https.any.js b/test/fixtures/wpt/WebCryptoAPI/import_export/okp_malformed_asn1.https.any.js new file mode 100644 index 00000000000..adfd9f68c1b --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/import_export/okp_malformed_asn1.https.any.js @@ -0,0 +1,99 @@ +// META: title=WebCryptoAPI: OKP imports reject malformed ASN.1 + +const vectors = [ + { + algorithm: "Ed25519", + pkcs8: "302e020100300506032b6570042204200007070707070707070707070707070707070707070707070707070707070707", + raw: "ff812f84e53570c36ae9479aad71e649c3cc4a04a6768632150febdd66a238a8", + leadingZeroRaw: "00009314998a59a276e35cac5d39d9cf642b5add8fc428baca5d18a7b30cda40", + spki: "302a300506032b6570032100ff812f84e53570c36ae9479aad71e649c3cc4a04a6768632150febdd66a238a8", + }, + { + algorithm: "X25519", + pkcs8: "302e020100300506032b656e042204200007070707070707070707070707070707070707070707070707070707070707", + raw: "13be4feaeaf204c7fd3358fc9c00721881d174278128227ec674f37f7fe97b6d", + leadingZeroRaw: "00a3785afdc7bb07fa13a4b075f00576cba6946a70cd6ad20b25c949eae6f636", + spki: "302a300506032b656e03210013be4feaeaf204c7fd3358fc9c00721881d174278128227ec674f37f7fe97b6d", + }, +]; + +function bytes(hex) { + return new Uint8Array(hex.match(/../g).map(value => Number.parseInt(value, 16))); +} + +function spki(algorithm, raw) { + const oid = algorithm === "Ed25519" ? 0x70 : 0x6e; + return new Uint8Array([ + 0x30, raw.length + 10, + 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, oid, + 0x03, raw.length + 1, 0x00, + ...raw, + ]); +} + +for (const vector of vectors) { + for (const format of ["pkcs8", "spki"]) { + promise_test(async test => { + const encoded = bytes(vector[format]); + const usages = format === "pkcs8" + ? (vector.algorithm === "Ed25519" ? ["sign"] : ["deriveBits"]) + : (vector.algorithm === "Ed25519" ? ["verify"] : []); + await promise_rejects_dom( + test, + "DataError", + crypto.subtle.importKey(format, encoded.slice(0, -1), vector.algorithm, true, usages), + "truncated input", + ); + const invalidTag = encoded.slice(); + invalidTag[0] = 0x31; + await promise_rejects_dom( + test, + "DataError", + crypto.subtle.importKey(format, invalidTag, vector.algorithm, true, usages), + "invalid outer ASN.1 tag", + ); + }, `${vector.algorithm} rejects malformed ${format}`); + } +} + +for (const vector of vectors) { + const usages = vector.algorithm === "Ed25519" ? ["verify"] : []; + const raw = bytes(vector.raw); + const leadingZeroRaw = bytes(vector.leadingZeroRaw); + + promise_test(async () => { + const key = await crypto.subtle.importKey( + "spki", + spki(vector.algorithm, leadingZeroRaw), + vector.algorithm, + true, + usages, + ); + assert_array_equals( + new Uint8Array(await crypto.subtle.exportKey("raw", key)), + leadingZeroRaw, + "valid fixed-width public value", + ); + }, `${vector.algorithm} accepts a valid 32-byte leading-zero SPKI public value`); + + const invalidPublicValues = [ + { name: "31-byte", raw: raw.slice(1) }, + { name: "33-byte", raw: new Uint8Array([...raw, 0x01]) }, + { name: "leading-zero 33-byte", raw: new Uint8Array([0x00, ...raw]) }, + ]; + for (const invalid of invalidPublicValues) { + promise_test(async test => { + await promise_rejects_dom( + test, + "DataError", + crypto.subtle.importKey( + "spki", + spki(vector.algorithm, invalid.raw), + vector.algorithm, + true, + usages, + ), + ); + }, `${vector.algorithm} rejects a ${invalid.name} SPKI public value`); + } +} diff --git a/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/xof_digest.js b/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/xof_digest.js index f5ef5846b79..124d74f6392 100644 --- a/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/xof_digest.js +++ b/test/fixtures/wpt/WebCryptoAPI/modern-algos/digest/xof_digest.js @@ -98,7 +98,9 @@ function runXofDigestTests(subtle, options) { var duringCallParams = { get name() { // Transfer the buffer while calling digest - buffer.buffer.transfer(); + if (!buffer.buffer.detached) { + buffer.buffer.transfer(); + } return alg; }, outputLength: outputLength, diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/mac.js b/test/fixtures/wpt/WebCryptoAPI/sign_verify/mac.js index 27787c91d8a..fd92e0c4949 100644 --- a/test/fixtures/wpt/WebCryptoAPI/sign_verify/mac.js +++ b/test/fixtures/wpt/WebCryptoAPI/sign_verify/mac.js @@ -107,7 +107,9 @@ function runMacTests(options) { promise_test(function(test) { var signature = copyBuffer(vector.signature); var operation = subtle.verify(operationAlgorithm(vector, function() { - signature.buffer.transfer(); + if (!signature.buffer.detached) { + signature.buffer.transfer(); + } return options.operationAlgorithm(vector).name; }), vector.key, signature, vector.plaintext) .then(function(is_verified) { @@ -212,7 +214,9 @@ function runMacTests(options) { promise_test(function(test) { var plaintext = copyBuffer(vector.plaintext); var operation = subtle.verify(operationAlgorithm(vector, function() { - plaintext.buffer.transfer(); + if (!plaintext.buffer.detached) { + plaintext.buffer.transfer(); + } return options.operationAlgorithm(vector).name; }), vector.key, vector.signature, plaintext) .then(function(is_verified) { diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/signature.js b/test/fixtures/wpt/WebCryptoAPI/sign_verify/signature.js index 2d734e1d973..1c6efa0bd22 100644 --- a/test/fixtures/wpt/WebCryptoAPI/sign_verify/signature.js +++ b/test/fixtures/wpt/WebCryptoAPI/sign_verify/signature.js @@ -125,7 +125,9 @@ function runSignatureTests(options) { const key = await publicKey(vector); const signature = copyBuffer(vector.signature); const duringCallAlgorithm = algorithmWithNameGetter(vector, function () { - signature.buffer.transfer(); + if (!signature.buffer.detached) { + signature.buffer.transfer(); + } return algorithmName(vector); }); const isVerified = await subtle.verify( @@ -174,7 +176,9 @@ function runSignatureTests(options) { const key = await publicKey(vector); const data = copyBuffer(vector.data); const duringCallAlgorithm = algorithmWithNameGetter(vector, function () { - data.buffer.transfer(); + if (!data.buffer.detached) { + data.buffer.transfer(); + } return algorithmName(vector); }); const isVerified = await subtle.verify( diff --git a/test/fixtures/wpt/WebCryptoAPI/wrapKey_unwrapKey/aes_kw_unwrapKey_failures.https.any.js b/test/fixtures/wpt/WebCryptoAPI/wrapKey_unwrapKey/aes_kw_unwrapKey_failures.https.any.js new file mode 100644 index 00000000000..aa198151a1f --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/wrapKey_unwrapKey/aes_kw_unwrapKey_failures.https.any.js @@ -0,0 +1,38 @@ +// META: title=WebCryptoAPI: unwrapKey() with invalid AES-KW wrapped keys + +// Test vector from RFC 3394, section 4.1: wrap 128 bits of key data with a +// 128-bit KEK. +var kekBytes = new Uint8Array([0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f]); +var keyBytes = new Uint8Array([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]); +var wrappedKeyBytes = new Uint8Array([0x1f, 0xa6, 0x8b, 0x0a, 0x81, 0x12, 0xb4, 0x47, + 0xae, 0xf3, 0x4b, 0xd8, 0xfb, 0x5a, 0x7b, 0x82, 0x9d, 0x3e, 0x86, 0x23, + 0x71, 0xd2, 0xcf, 0xe5]); + +function importKek() { + return crypto.subtle.importKey("raw", kekBytes, "AES-KW", false, ["unwrapKey"]); +} + +function unwrapKey(kek, wrappedKey) { + return crypto.subtle.unwrapKey("raw", wrappedKey, kek, "AES-KW", "AES-CBC", true, ["encrypt", "decrypt"]); +} + +promise_test(async () => { + const kek = await importKek(); + const key = await unwrapKey(kek, wrappedKeyBytes); + const exported = new Uint8Array(await crypto.subtle.exportKey("raw", key)); + assert_array_equals(exported, keyBytes); +}, "AES-KW unwrapKey with a valid wrapped key"); + +promise_test(async (t) => { + const kek = await importKek(); + const tamperedKeyBytes = wrappedKeyBytes.slice(); + tamperedKeyBytes[tamperedKeyBytes.length - 1] ^= 1; + return promise_rejects_dom(t, "OperationError", unwrapKey(kek, tamperedKeyBytes)); +}, "AES-KW unwrapKey with a tampered wrapped key"); + +promise_test(async (t) => { + const kek = await importKek(); + return promise_rejects_dom(t, "OperationError", unwrapKey(kek, wrappedKeyBytes.slice(0, 16))); +}, "AES-KW unwrapKey with a wrapped key shorter than 24 bytes"); diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json index 2d12ad45360..711d469cc36 100644 --- a/test/fixtures/wpt/versions.json +++ b/test/fixtures/wpt/versions.json @@ -100,7 +100,7 @@ "path": "web-locks" }, "WebCryptoAPI": { - "commit": "b638c093cd3e1849715130bcd99041f79980bb12", + "commit": "e15690d276ae50728b9d557f4e04f894588d34a0", "path": "WebCryptoAPI" }, "webidl": { diff --git a/test/wpt/status/WebCryptoAPI.cjs b/test/wpt/status/WebCryptoAPI.cjs index 606cbbac34d..a73db3793a9 100644 --- a/test/wpt/status/WebCryptoAPI.cjs +++ b/test/wpt/status/WebCryptoAPI.cjs @@ -176,6 +176,8 @@ if (hasFIPS(3, 5)) { 'derive_bits_keys/derived_bits_length.https.any.js', /^X25519 derivation/, ], + ['import_export/okp_fixed_length.https.any.js', /^X25519 /], + ['import_export/okp_malformed_asn1.https.any.js', /^X25519 /], ['modern-algos/encap_decap/encap_decap_bits.https.any.js', /mlkem/i], ['modern-algos/encap_decap/encap_decap_keys.https.any.js', /mlkem/i], ['modern-algos/getPublicKey.https.any.js', /(?:X25519|X448|MLKEM)/], From dbe7d0e3461ed131569e8be4768b7c3a68c0ea7f Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Mon, 19 Oct 2026 21:15:47 -0400 Subject: [PATCH 064/331] deps: update simdjson to 5.0.5 PR-URL: https://github.com/nodejs/node/pull/66817 Reviewed-By: Antoine du Hamel Reviewed-By: Joyee Cheung Reviewed-By: Colin Ihrig --- deps/simdjson/simdjson.cpp | 47 +- deps/simdjson/simdjson.h | 2133 ++++++++++++++++++++++++++++-------- 2 files changed, 1702 insertions(+), 478 deletions(-) diff --git a/deps/simdjson/simdjson.cpp b/deps/simdjson/simdjson.cpp index 980bb83cefa..e8a2a24a04b 100644 --- a/deps/simdjson/simdjson.cpp +++ b/deps/simdjson/simdjson.cpp @@ -1,4 +1,4 @@ -/* auto-generated on 2026-10-07 22:43:29 -0400. version 5.0.3 Do not edit! */ +/* auto-generated on 2026-10-14 15:49:28 -0400. version 5.0.5 Do not edit! */ /* including simdjson.cpp: */ /* begin file simdjson.cpp */ #define SIMDJSON_SRC_SIMDJSON_CPP @@ -3355,6 +3355,10 @@ consteval std::string consteval_to_quoted_escaped(std::string_view input) { out.push_back('"'); return out; } + +consteval std::size_t padded_key_length(std::size_t length) { + return (length + 15) / 16 * 16; +} #endif // SIMDJSON_CONSTEVAL @@ -3391,10 +3395,45 @@ struct fixed_string { template fixed_string(const char (&)[N]) -> fixed_string; +template +inline constexpr bool is_fixed_string = false; +template +inline constexpr bool is_fixed_string> = true; + template struct string_constant { static constexpr std::string_view value = str.view(); }; + +#if SIMDJSON_CONSTEVAL +template +consteval std::size_t static_string_size() { + return Text::text().size(); +} +template +consteval std::size_t padded_static_string_size() { + return padded_key_length(static_string_size()); +} + +template +consteval auto make_static_string() { + std::array()> out{}; + std::string text = Text::text(); + // The tail past text.size() stays zero: it is the padding. + for (std::size_t i = 0; i < text.size(); ++i) { + out[i] = text[i]; + } + return out; +} + +template +inline constexpr auto static_string = make_static_string(); + +template +struct quoted_escaped_text { + static consteval std::string text() { return consteval_to_quoted_escaped(str.view()); } +}; +#endif // SIMDJSON_CONSTEVAL #endif // SIMDJSON_SUPPORTS_CONCEPTS } // namespace constevalutil @@ -9436,10 +9475,10 @@ simdjson_fastfloat_really_inline bool rounds_to_nearest() noexcept { // https://stackoverflow.com/questions/46079446/is-there-a-warning-for-floating-point-equality-checking-in-visual-studio-2013 #elif defined(__clang__) #pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wfloat-equal" +SIMDJSON_DISABLE_GCC_WARNING(-Wfloat-equal) #elif defined(__GNUC__) #pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wfloat-equal" +SIMDJSON_DISABLE_GCC_WARNING(-Wfloat-equal) #endif return (fmini + 1.0f == 1.0f - fmini); #ifdef SIMDJSON_FASTFLOAT_VISUAL_STUDIO @@ -9680,7 +9719,7 @@ from_chars_float_advanced(UC const *first, UC const *last, T &value, #ifdef __clang__ #pragma clang diagnostic push #if (!defined(__APPLE_CC__) && __clang_major__ >= 10) || (__clang_major__ >= 13) -#pragma clang diagnostic ignored "-Wc++20-extensions" +SIMDJSON_DISABLE_GCC_WARNING(-Wc++20-extensions) #endif #endif if simdjson_fastfloat_unlikely (pns.too_many_digits) { diff --git a/deps/simdjson/simdjson.h b/deps/simdjson/simdjson.h index 58041ff68a7..faf21bdc232 100644 --- a/deps/simdjson/simdjson.h +++ b/deps/simdjson/simdjson.h @@ -1,4 +1,4 @@ -/* auto-generated on 2026-10-07 22:43:29 -0400. version 5.0.3 Do not edit! */ +/* auto-generated on 2026-10-14 15:49:28 -0400. version 5.0.5 Do not edit! */ /* including simdjson.h: */ /* begin file simdjson.h */ #ifndef SIMDJSON_H @@ -2715,7 +2715,7 @@ namespace std { #define SIMDJSON_SIMDJSON_VERSION_H /** The version of simdjson being used (major.minor.revision) */ -#define SIMDJSON_VERSION "5.0.3" +#define SIMDJSON_VERSION "5.0.5" namespace simdjson { enum { @@ -2730,7 +2730,7 @@ enum { /** * The revision (major.minor.REVISION) of simdjson being used. */ - SIMDJSON_VERSION_REVISION = 3 + SIMDJSON_VERSION_REVISION = 5 }; } // namespace simdjson @@ -3418,6 +3418,10 @@ consteval std::string consteval_to_quoted_escaped(std::string_view input) { out.push_back('"'); return out; } + +consteval std::size_t padded_key_length(std::size_t length) { + return (length + 15) / 16 * 16; +} #endif // SIMDJSON_CONSTEVAL @@ -3454,10 +3458,45 @@ struct fixed_string { template fixed_string(const char (&)[N]) -> fixed_string; +template +inline constexpr bool is_fixed_string = false; +template +inline constexpr bool is_fixed_string> = true; + template struct string_constant { static constexpr std::string_view value = str.view(); }; + +#if SIMDJSON_CONSTEVAL +template +consteval std::size_t static_string_size() { + return Text::text().size(); +} +template +consteval std::size_t padded_static_string_size() { + return padded_key_length(static_string_size()); +} + +template +consteval auto make_static_string() { + std::array()> out{}; + std::string text = Text::text(); + // The tail past text.size() stays zero: it is the padding. + for (std::size_t i = 0; i < text.size(); ++i) { + out[i] = text[i]; + } + return out; +} + +template +inline constexpr auto static_string = make_static_string(); + +template +struct quoted_escaped_text { + static consteval std::string text() { return consteval_to_quoted_escaped(str.view()); } +}; +#endif // SIMDJSON_CONSTEVAL #endif // SIMDJSON_SUPPORTS_CONCEPTS } // namespace constevalutil @@ -8621,7 +8660,7 @@ template std::string prettify(simdjson_result x) { if (x.error()) { throw simdjson_error(x.error()); } - return to_string(x.value()); + return prettify(x.value()); } #endif @@ -8852,6 +8891,7 @@ inline std::string fractured_json_string(std::string_view json_str, #include #include +#include namespace simdjson { namespace internal { @@ -8893,6 +8933,28 @@ simdjson_inline error_code parse_json_pointer_array_index(std::string_view json_ return SUCCESS; } + +/** + * Returns true if the error means that a JSONPath segment matched nothing + * (missing field, index out of bounds, value of the wrong type, or a scalar + * reached while path segments remain), as opposed to a document error. + * A wildcard walk skips such branches, as RFC 9535 and DOM's + * at_path_with_wildcard do. + */ +simdjson_inline bool is_matching_failure_error(error_code error) noexcept { + return error == NO_SUCH_FIELD || error == INDEX_OUT_OF_BOUNDS || + error == INCORRECT_TYPE || error == INVALID_JSON_POINTER; +} + +/** + * Returns true if a wildcard follows in the remaining JSONPath. A segment that + * matches nothing before a wildcard yields an empty result instead of an + * error, as in DOM's at_path_with_wildcard. Like DOM, this treats a '*' inside + * a quoted key as a wildcard. + */ +simdjson_inline bool json_path_has_wildcard(std::string_view json_path) noexcept { + return json_path.find('*') != std::string_view::npos; +} } // namespace internal /** @@ -8999,12 +9061,100 @@ inline std::pair get_next_key_and_json_path( } else if ((i+2 < json_path.size()) && json_path[i] == '[' && json_path[i+1] == '*' && json_path[i+2] == ']') { // i.e [*].additional_keys or [*]["additional_keys"] key = "*"; i += 3; + } else if (i < json_path.size() && json_path[i] == '[') { // i.e. [0] or [123] + size_t j = i + 1; + while (j < json_path.size() && json_path[j] >= '0' && json_path[j] <= '9') { + ++j; + } + if (j > i + 1 && j < json_path.size() && json_path[j] == ']') { + key = json_path.substr(i + 1, j - i - 1); + i = j + 1; + } } return std::make_pair(key, json_path.substr(i)); } +namespace internal { +/** + * A JSONPath as the DOM at_path_with_wildcard() consumes it, parsed once. + * + * Every node visited at a given depth sees the same remaining path, so we + * parse it up front rather than at each node: re-scanning (and converting) + * the remaining path at every node costs O(nodes * path length), which + * made a long path after a couple of wildcards take minutes on a large + * document. + */ +struct wildcard_json_path { + enum class tail_type { invalid, all_values, pointer }; + // One JSON pointer ("/key") per leading segment, "/*" being a wildcard. + std::vector steps{}; + // What to do once the steps are exhausted. + tail_type tail{tail_type::invalid}; + // The rest of the path, as a JSON pointer, when tail == pointer. + std::string tail_pointer{}; +}; + +/** + * Splits json_path the same way the recursive DOM at_path_with_wildcard() + * historically did, one level at a time, but in a single pass. + */ +inline wildcard_json_path parse_wildcard_json_path(std::string_view json_path) { + wildcard_json_path result; + // The remaining path (always a suffix of json_path) contains a '*' if and + // only if it starts at or before the last one. + const size_t last_star = json_path.rfind('*'); + std::string_view path = json_path; + while (true) { + size_t i = 0; + if (!path.empty() && path.front() == '$') { + i = 1; + } + if (i >= path.size() || (path[i] != '.' && path[i] != '[')) { + result.tail = wildcard_json_path::tail_type::invalid; + return result; + } + const size_t offset = json_path.size() - path.size(); + if (last_star == std::string_view::npos || last_star < offset) { + result.tail_pointer = json_path_to_pointer_conversion(path); + result.tail = (result.tail_pointer == "-1") + ? wildcard_json_path::tail_type::invalid + : wildcard_json_path::tail_type::pointer; + return result; + } + if ((path.compare(i, 3, "[*]") == 0 && path.size() == i + 3) || + (path.compare(i, 2, ".*") == 0 && path.size() == i + 2)) { + result.tail = wildcard_json_path::tail_type::all_values; + return result; + } + std::pair key_and_json_path = get_next_key_and_json_path(path); + if (key_and_json_path.first.empty()) { + result.tail = wildcard_json_path::tail_type::invalid; + return result; + } + std::string step; + step.reserve(key_and_json_path.first.size() + 1); + step += '/'; + // The step is consumed by at_pointer, which unescapes ~0/~1, so '~' and + // '/' in the key must be escaped as json_path_to_pointer_conversion does: + // a raw '/' splits the step into two pointer tokens and a raw '~' + // invalidates it, either way addressing the wrong element. + for (const char c : key_and_json_path.first) { + if (c == '~') { + step += "~0"; + } else if (c == '/') { + step += "~1"; + } else { + step += c; + } + } + result.steps.push_back(std::move(step)); + path = key_and_json_path.second; + } +} +} // namespace internal + } // namespace simdjson #endif // SIMDJSON_JSONPATHUTIL_H /* end file simdjson/jsonpathutil.h */ @@ -9383,68 +9533,7 @@ inline void array::process_json_path_of_child_elements(std::vector::ite inline simdjson_result> array::at_path_with_wildcard(std::string_view json_path) const noexcept { SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 - - size_t i = 0; - // json_path.starts_with('$') requires C++20. - if (!json_path.empty() && json_path.front() == '$') { - i = 1; - } - - if (i >= json_path.size() || (json_path[i] != '.' && json_path[i] != '[')) { - return INVALID_JSON_POINTER; - } - - if (json_path.find("*") != std::string::npos) { - std::vector child_values; - - if ( - (json_path.compare(i, 3, "[*]") == 0 && json_path.size() == i + 3) || - (json_path.compare(i, 2,".*") == 0 && json_path.size() == i + 2) - ) { - get_values(child_values); - return child_values; - } - - std::pair key_and_json_path = get_next_key_and_json_path(json_path); - - std::string_view key = key_and_json_path.first; - json_path = key_and_json_path.second; - - if (key.size() > 0) { - if (key == "*") { - get_values(child_values); - } else { - element pointer_result; - std::string json_pointer = std::string("/") + std::string(key); - auto error = at_pointer(json_pointer).get(pointer_result); - - if (!error) { - child_values.emplace_back(pointer_result); - } - } - - std::vector result = {}; - - if (child_values.size() > 0) { - std::vector::iterator child_values_begin = child_values.begin(); - std::vector::iterator child_values_end = child_values.end(); - - process_json_path_of_child_elements(child_values_begin, child_values_end, json_path, result); - } - - return result; - } else { - return INVALID_JSON_POINTER; - } - } else { - element result; - auto error = at_path(json_path).get(result); - if (error) { - return error; - } - - return std::vector{std::move(result)}; - } + return element(*this).at_path_with_wildcard(json_path); } inline simdjson_result array::at(size_t index) const noexcept { @@ -9723,73 +9812,7 @@ inline void object::process_json_path_of_child_elements(std::vector::it inline simdjson_result> object::at_path_with_wildcard(std::string_view json_path) const noexcept { SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 - - size_t i = 0; - if (json_path.empty()) { - return INVALID_JSON_POINTER; - } - // if JSONPath starts with $, skip it - // json_path.starts_with('$') requires C++20. - if (json_path.front() == '$') { - i = 1; - } - - if (i >= json_path.size() || (json_path[i] != '.' && json_path[i] != '[')) { - // expect JSONPath expressions to always start with $ but this isn't currently - // expected in jsonpathutil.h. - return INVALID_JSON_POINTER; - } - - if (json_path.find("*") != std::string::npos) { - - std::vector child_values; - - if ( - (json_path.compare(i, 3, "[*]") == 0 && json_path.size() == i + 3) || - (json_path.compare(i, 2,".*") == 0 && json_path.size() == i + 2) - ) { - get_values(child_values); - return child_values; - } - - std::pair key_and_json_path = get_next_key_and_json_path(json_path); - - std::string_view key = key_and_json_path.first; - json_path = key_and_json_path.second; - - if (key.size() > 0) { - if (key == "*") { - get_values(child_values); - } else { - element pointer_result; - auto error = at_pointer(std::string("/") + std::string(key)).get(pointer_result); - - if (!error) { - child_values.emplace_back(pointer_result); - } - } - - std::vector result = {}; - if (child_values.size() > 0) { - - std::vector::iterator child_values_begin = child_values.begin(); - std::vector::iterator child_values_end = child_values.end(); - - process_json_path_of_child_elements(child_values_begin, child_values_end, json_path, result); - } - - return result; - } else { - return INVALID_JSON_POINTER; - } - } else { - element result; - auto error = this->at_path(json_path).get(result); - if (error) { - return error; - } - return std::vector{std::move(result)}; - } + return element(*this).at_path_with_wildcard(json_path); } inline simdjson_result object::at_key(std::string_view key) const noexcept { @@ -10136,6 +10159,68 @@ simdjson_inline dom::array::iterator simdjson_result::end() const #endif // SIMDJSON_EXCEPTIONS +namespace internal { +// Appends the children of e, which must be an array or an object. +inline void get_container_values(const dom::element &e, std::vector &out) noexcept { + dom::array a; + if (!e.get_array().get(a)) { + a.get_values(out); + return; + } + dom::object o; + if (!e.get_object().get(o)) { + o.get_values(out); + } +} + +// Walks a pre-parsed wildcard path from e, which is at depth `step` of the +// path. Errors below the starting node are skipped, not reported. +inline simdjson_result> at_wildcard_json_path(const dom::element &e, const wildcard_json_path &path, size_t step) noexcept { + const dom::element_type t = e.type(); + if (t != dom::element_type::ARRAY && t != dom::element_type::OBJECT) { + return std::vector{}; + } + std::vector children; + if (step == path.steps.size()) { + switch (path.tail) { + case wildcard_json_path::tail_type::all_values: + get_container_values(e, children); + return children; + case wildcard_json_path::tail_type::pointer: { + dom::element result; + auto error = e.at_pointer(path.tail_pointer).get(result); + if (error) { + return error; + } + return std::vector{std::move(result)}; + } + default: + return INVALID_JSON_POINTER; + } + } + const std::string &key_pointer = path.steps[step]; + if (key_pointer == "/*") { + get_container_values(e, children); + } else { + dom::element child; + if (!e.at_pointer(key_pointer).get(child)) { + children.emplace_back(child); + } + } + std::vector result; + for (const dom::element &child : children) { + std::vector child_result; + if (at_wildcard_json_path(child, path, step + 1).get(child_result)) { + continue; + } + result.insert(result.end(), + std::make_move_iterator(child_result.begin()), + std::make_move_iterator(child_result.end())); + } + return result; +} +} // namespace internal + namespace dom { // @@ -10394,9 +10479,8 @@ inline simdjson_result> element::at_path_with_wildcard(std: switch (tape.tape_ref_type()) { case internal::tape_type::START_OBJECT: - return object(tape).at_path_with_wildcard(json_path); case internal::tape_type::START_ARRAY: - return array(tape).at_path_with_wildcard(json_path); + return internal::at_wildcard_json_path(*this, internal::parse_wildcard_json_path(json_path), 0); default: return std::vector{}; } @@ -12711,8 +12795,18 @@ inline element_metrics structure_analyzer::analyze_object(const dom::object& obj inline size_t structure_analyzer::estimate_string_length(std::string_view s) const { size_t len = 2; // quotes for (char c : s) { - if (c == '"' || c == '\\' || static_cast(c) < 32) { - len += 2; // escape sequence (at least) + unsigned char uc = static_cast(c); + if (c == '"' || c == '\\') { + len += 2; // \" and \\ are two-character escapes + } else if (uc < 0x20) { + switch (c) { + case '\b': case '\f': case '\n': case '\r': case '\t': + len += 2; // two-character escapes: \b \f \n \r \t + break; + default: + len += 6; // \u00XX -- six-character escape for other control chars + break; + } } else { len += 1; } @@ -12803,7 +12897,9 @@ inline void structure_analyzer::build_table_columns( table_column_type common = table_column_type::unknown; for (const auto& v : values) { table_column_type t = classify_table_value(v.first.type()); - if (t == table_column_type::unknown) continue; + // Null cannot be projected into object or array columns. Keep these + // values intact by falling back to ordinary value formatting. + if (t == table_column_type::unknown) return; if (common == table_column_type::unknown) common = t; else if (t != common) { common = table_column_type::mixed; break; } } @@ -46559,6 +46655,13 @@ class string_builder { template simdjson_inline void append_key_value(value_type value) noexcept; + template + simdjson_inline void append_key_value() noexcept; + + template + requires (!constevalutil::is_fixed_string>) + simdjson_inline void append_key_value() noexcept; + // Support for optional types (std::optional, etc.) template requires(!require_custom_serialization) @@ -46600,6 +46703,7 @@ requires (!std::is_convertible::value && !concepts::optiona */ template simdjson_inline void append_raw_n(const char *str) noexcept; + #if SIMDJSON_EXCEPTIONS /** * Creates an std::string from the written JSON buffer. @@ -46679,6 +46783,15 @@ requires (!std::is_convertible::value && !concepts::optiona */ simdjson_inline bool capacity_check(size_t upcoming_bytes); +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL + /** + * Append constevalutil::static_string. The whole zero-padded array is + * copied in 16-byte blocks, but position only advances by the text length. + */ + template + simdjson_inline void append_static_string() noexcept; +#endif + /** * Grow the buffer to at least desired_capacity bytes. * If the allocation fails, is_valid is set to false. We expect @@ -46872,10 +46985,6 @@ using unchecked_writer = basic_writer; // 16-byte blocks). inline constexpr size_t unchecked_slack = 64; -consteval size_t padded_key_length(size_t length) { - return (length + 15) / 16 * 16; -} - // === Helper: invoke a string_builder member that writes variable-length // content (escape_and_append_with_quotes etc), syncing the writer's local // state before the call and reloading after. Used for string fields where @@ -46965,16 +47074,16 @@ simdjson_really_inline void atom_fields(W &w, const T &t, bool &first) { constexpr size_t rest_key_len = first_key_len + 1; constexpr auto first_key = std::define_static_string( constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(first_key_len) - first_key_len, '\0')); + std::string(constevalutil::padded_key_length(first_key_len) - first_key_len, '\0')); constexpr auto rest_key = std::define_static_string( std::string(",") + constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(rest_key_len) - rest_key_len, '\0')); - if (!w.ensure(padded_key_length(rest_key_len))) { return; } + std::string(constevalutil::padded_key_length(rest_key_len) - rest_key_len, '\0')); + if (!w.ensure(constevalutil::padded_key_length(rest_key_len))) { return; } if (first) { - std::memcpy(w.ptr + w.pos, first_key, padded_key_length(first_key_len)); + std::memcpy(w.ptr + w.pos, first_key, constevalutil::padded_key_length(first_key_len)); w.pos += first_key_len; } else { - std::memcpy(w.ptr + w.pos, rest_key, padded_key_length(rest_key_len)); + std::memcpy(w.ptr + w.pos, rest_key, constevalutil::padded_key_length(rest_key_len)); w.pos += rest_key_len; } first = false; @@ -47706,6 +47815,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for arm64 */ #include #include +#include #include #include #include @@ -48746,7 +48856,11 @@ string_builder::escape_and_append_with_quotes(const char *input) noexcept { #if SIMDJSON_SUPPORTS_CONCEPTS template simdjson_inline void string_builder::escape_and_append_with_quotes() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(constevalutil::string_constant::value); +#endif } #endif @@ -48780,6 +48894,18 @@ simdjson_inline void string_builder::append_raw_n(const char *str) noexcept { position += N; } } + +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL +template +simdjson_inline void string_builder::append_static_string() noexcept { + constexpr auto& padded = constevalutil::static_string; + if (capacity_check(padded.size())) { + std::memcpy(buffer.get() + position, padded.data(), padded.size()); + position += constevalutil::static_string_size(); + } +} +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS // Support for optional types (std::optional, etc.) template @@ -48946,11 +49072,24 @@ string_builder::append_key_value(key_type key, value_type value) noexcept { } #if SIMDJSON_SUPPORTS_CONCEPTS +#if SIMDJSON_CONSTEVAL +template +struct quoted_key_text { + static consteval std::string text() { + return constevalutil::consteval_to_quoted_escaped(key.view()) + ":"; + } +}; +#endif + template simdjson_inline void string_builder::append_key_value(value_type value) noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(); append_colon(); +#endif SIMDJSON_IF_CONSTEXPR(std::is_same::value) { append_null(); } @@ -48968,6 +49107,56 @@ string_builder::append_key_value(value_type value) noexcept { append(value); } } + +#if SIMDJSON_CONSTEVAL +template +concept compile_time_formattable = + constevalutil::is_fixed_string> || + std::same_as, bool> || + std::same_as, std::nullptr_t>; + +template +requires compile_time_formattable +struct key_value_text { + static consteval std::string text() { + using value_type = std::remove_cvref_t; + std::string out = constevalutil::consteval_to_quoted_escaped(key.view()) + ':'; + SIMDJSON_IF_CONSTEXPR(constevalutil::is_fixed_string) + out += constevalutil::consteval_to_quoted_escaped(value.view()); + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += value ? "true" : "false"; + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += "null"; + return out; + } +}; +#endif + +template +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else + escape_and_append_with_quotes(); + append_colon(); + escape_and_append_with_quotes(); +#endif +} + +template +requires (!constevalutil::is_fixed_string>) +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + SIMDJSON_IF_CONSTEXPR(compile_time_formattable) { + append_static_string>(); + } else +#endif + { + append_key_value(value); + } +} #endif } // namespace builder @@ -49397,6 +49586,13 @@ class string_builder { template simdjson_inline void append_key_value(value_type value) noexcept; + template + simdjson_inline void append_key_value() noexcept; + + template + requires (!constevalutil::is_fixed_string>) + simdjson_inline void append_key_value() noexcept; + // Support for optional types (std::optional, etc.) template requires(!require_custom_serialization) @@ -49438,6 +49634,7 @@ requires (!std::is_convertible::value && !concepts::optiona */ template simdjson_inline void append_raw_n(const char *str) noexcept; + #if SIMDJSON_EXCEPTIONS /** * Creates an std::string from the written JSON buffer. @@ -49517,6 +49714,15 @@ requires (!std::is_convertible::value && !concepts::optiona */ simdjson_inline bool capacity_check(size_t upcoming_bytes); +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL + /** + * Append constevalutil::static_string. The whole zero-padded array is + * copied in 16-byte blocks, but position only advances by the text length. + */ + template + simdjson_inline void append_static_string() noexcept; +#endif + /** * Grow the buffer to at least desired_capacity bytes. * If the allocation fails, is_valid is set to false. We expect @@ -49710,10 +49916,6 @@ using unchecked_writer = basic_writer; // 16-byte blocks). inline constexpr size_t unchecked_slack = 64; -consteval size_t padded_key_length(size_t length) { - return (length + 15) / 16 * 16; -} - // === Helper: invoke a string_builder member that writes variable-length // content (escape_and_append_with_quotes etc), syncing the writer's local // state before the call and reloading after. Used for string fields where @@ -49803,16 +50005,16 @@ simdjson_really_inline void atom_fields(W &w, const T &t, bool &first) { constexpr size_t rest_key_len = first_key_len + 1; constexpr auto first_key = std::define_static_string( constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(first_key_len) - first_key_len, '\0')); + std::string(constevalutil::padded_key_length(first_key_len) - first_key_len, '\0')); constexpr auto rest_key = std::define_static_string( std::string(",") + constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(rest_key_len) - rest_key_len, '\0')); - if (!w.ensure(padded_key_length(rest_key_len))) { return; } + std::string(constevalutil::padded_key_length(rest_key_len) - rest_key_len, '\0')); + if (!w.ensure(constevalutil::padded_key_length(rest_key_len))) { return; } if (first) { - std::memcpy(w.ptr + w.pos, first_key, padded_key_length(first_key_len)); + std::memcpy(w.ptr + w.pos, first_key, constevalutil::padded_key_length(first_key_len)); w.pos += first_key_len; } else { - std::memcpy(w.ptr + w.pos, rest_key, padded_key_length(rest_key_len)); + std::memcpy(w.ptr + w.pos, rest_key, constevalutil::padded_key_length(rest_key_len)); w.pos += rest_key_len; } first = false; @@ -50544,6 +50746,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for fallback */ #include #include +#include #include #include #include @@ -51584,7 +51787,11 @@ string_builder::escape_and_append_with_quotes(const char *input) noexcept { #if SIMDJSON_SUPPORTS_CONCEPTS template simdjson_inline void string_builder::escape_and_append_with_quotes() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(constevalutil::string_constant::value); +#endif } #endif @@ -51618,6 +51825,18 @@ simdjson_inline void string_builder::append_raw_n(const char *str) noexcept { position += N; } } + +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL +template +simdjson_inline void string_builder::append_static_string() noexcept { + constexpr auto& padded = constevalutil::static_string; + if (capacity_check(padded.size())) { + std::memcpy(buffer.get() + position, padded.data(), padded.size()); + position += constevalutil::static_string_size(); + } +} +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS // Support for optional types (std::optional, etc.) template @@ -51784,11 +52003,24 @@ string_builder::append_key_value(key_type key, value_type value) noexcept { } #if SIMDJSON_SUPPORTS_CONCEPTS +#if SIMDJSON_CONSTEVAL +template +struct quoted_key_text { + static consteval std::string text() { + return constevalutil::consteval_to_quoted_escaped(key.view()) + ":"; + } +}; +#endif + template simdjson_inline void string_builder::append_key_value(value_type value) noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(); append_colon(); +#endif SIMDJSON_IF_CONSTEXPR(std::is_same::value) { append_null(); } @@ -51806,6 +52038,56 @@ string_builder::append_key_value(value_type value) noexcept { append(value); } } + +#if SIMDJSON_CONSTEVAL +template +concept compile_time_formattable = + constevalutil::is_fixed_string> || + std::same_as, bool> || + std::same_as, std::nullptr_t>; + +template +requires compile_time_formattable +struct key_value_text { + static consteval std::string text() { + using value_type = std::remove_cvref_t; + std::string out = constevalutil::consteval_to_quoted_escaped(key.view()) + ':'; + SIMDJSON_IF_CONSTEXPR(constevalutil::is_fixed_string) + out += constevalutil::consteval_to_quoted_escaped(value.view()); + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += value ? "true" : "false"; + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += "null"; + return out; + } +}; +#endif + +template +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else + escape_and_append_with_quotes(); + append_colon(); + escape_and_append_with_quotes(); +#endif +} + +template +requires (!constevalutil::is_fixed_string>) +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + SIMDJSON_IF_CONSTEXPR(compile_time_formattable) { + append_static_string>(); + } else +#endif + { + append_key_value(value); + } +} #endif } // namespace builder @@ -52712,6 +52994,13 @@ class string_builder { template simdjson_inline void append_key_value(value_type value) noexcept; + template + simdjson_inline void append_key_value() noexcept; + + template + requires (!constevalutil::is_fixed_string>) + simdjson_inline void append_key_value() noexcept; + // Support for optional types (std::optional, etc.) template requires(!require_custom_serialization) @@ -52753,6 +53042,7 @@ requires (!std::is_convertible::value && !concepts::optiona */ template simdjson_inline void append_raw_n(const char *str) noexcept; + #if SIMDJSON_EXCEPTIONS /** * Creates an std::string from the written JSON buffer. @@ -52832,6 +53122,15 @@ requires (!std::is_convertible::value && !concepts::optiona */ simdjson_inline bool capacity_check(size_t upcoming_bytes); +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL + /** + * Append constevalutil::static_string. The whole zero-padded array is + * copied in 16-byte blocks, but position only advances by the text length. + */ + template + simdjson_inline void append_static_string() noexcept; +#endif + /** * Grow the buffer to at least desired_capacity bytes. * If the allocation fails, is_valid is set to false. We expect @@ -53025,10 +53324,6 @@ using unchecked_writer = basic_writer; // 16-byte blocks). inline constexpr size_t unchecked_slack = 64; -consteval size_t padded_key_length(size_t length) { - return (length + 15) / 16 * 16; -} - // === Helper: invoke a string_builder member that writes variable-length // content (escape_and_append_with_quotes etc), syncing the writer's local // state before the call and reloading after. Used for string fields where @@ -53118,16 +53413,16 @@ simdjson_really_inline void atom_fields(W &w, const T &t, bool &first) { constexpr size_t rest_key_len = first_key_len + 1; constexpr auto first_key = std::define_static_string( constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(first_key_len) - first_key_len, '\0')); + std::string(constevalutil::padded_key_length(first_key_len) - first_key_len, '\0')); constexpr auto rest_key = std::define_static_string( std::string(",") + constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(rest_key_len) - rest_key_len, '\0')); - if (!w.ensure(padded_key_length(rest_key_len))) { return; } + std::string(constevalutil::padded_key_length(rest_key_len) - rest_key_len, '\0')); + if (!w.ensure(constevalutil::padded_key_length(rest_key_len))) { return; } if (first) { - std::memcpy(w.ptr + w.pos, first_key, padded_key_length(first_key_len)); + std::memcpy(w.ptr + w.pos, first_key, constevalutil::padded_key_length(first_key_len)); w.pos += first_key_len; } else { - std::memcpy(w.ptr + w.pos, rest_key, padded_key_length(rest_key_len)); + std::memcpy(w.ptr + w.pos, rest_key, constevalutil::padded_key_length(rest_key_len)); w.pos += rest_key_len; } first = false; @@ -53859,6 +54154,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for haswell */ #include #include +#include #include #include #include @@ -54899,7 +55195,11 @@ string_builder::escape_and_append_with_quotes(const char *input) noexcept { #if SIMDJSON_SUPPORTS_CONCEPTS template simdjson_inline void string_builder::escape_and_append_with_quotes() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(constevalutil::string_constant::value); +#endif } #endif @@ -54933,6 +55233,18 @@ simdjson_inline void string_builder::append_raw_n(const char *str) noexcept { position += N; } } + +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL +template +simdjson_inline void string_builder::append_static_string() noexcept { + constexpr auto& padded = constevalutil::static_string; + if (capacity_check(padded.size())) { + std::memcpy(buffer.get() + position, padded.data(), padded.size()); + position += constevalutil::static_string_size(); + } +} +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS // Support for optional types (std::optional, etc.) template @@ -55099,11 +55411,24 @@ string_builder::append_key_value(key_type key, value_type value) noexcept { } #if SIMDJSON_SUPPORTS_CONCEPTS +#if SIMDJSON_CONSTEVAL +template +struct quoted_key_text { + static consteval std::string text() { + return constevalutil::consteval_to_quoted_escaped(key.view()) + ":"; + } +}; +#endif + template simdjson_inline void string_builder::append_key_value(value_type value) noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(); append_colon(); +#endif SIMDJSON_IF_CONSTEXPR(std::is_same::value) { append_null(); } @@ -55121,6 +55446,56 @@ string_builder::append_key_value(value_type value) noexcept { append(value); } } + +#if SIMDJSON_CONSTEVAL +template +concept compile_time_formattable = + constevalutil::is_fixed_string> || + std::same_as, bool> || + std::same_as, std::nullptr_t>; + +template +requires compile_time_formattable +struct key_value_text { + static consteval std::string text() { + using value_type = std::remove_cvref_t; + std::string out = constevalutil::consteval_to_quoted_escaped(key.view()) + ':'; + SIMDJSON_IF_CONSTEXPR(constevalutil::is_fixed_string) + out += constevalutil::consteval_to_quoted_escaped(value.view()); + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += value ? "true" : "false"; + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += "null"; + return out; + } +}; +#endif + +template +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else + escape_and_append_with_quotes(); + append_colon(); + escape_and_append_with_quotes(); +#endif +} + +template +requires (!constevalutil::is_fixed_string>) +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + SIMDJSON_IF_CONSTEXPR(compile_time_formattable) { + append_static_string>(); + } else +#endif + { + append_key_value(value); + } +} #endif } // namespace builder @@ -56027,6 +56402,13 @@ class string_builder { template simdjson_inline void append_key_value(value_type value) noexcept; + template + simdjson_inline void append_key_value() noexcept; + + template + requires (!constevalutil::is_fixed_string>) + simdjson_inline void append_key_value() noexcept; + // Support for optional types (std::optional, etc.) template requires(!require_custom_serialization) @@ -56068,6 +56450,7 @@ requires (!std::is_convertible::value && !concepts::optiona */ template simdjson_inline void append_raw_n(const char *str) noexcept; + #if SIMDJSON_EXCEPTIONS /** * Creates an std::string from the written JSON buffer. @@ -56147,6 +56530,15 @@ requires (!std::is_convertible::value && !concepts::optiona */ simdjson_inline bool capacity_check(size_t upcoming_bytes); +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL + /** + * Append constevalutil::static_string. The whole zero-padded array is + * copied in 16-byte blocks, but position only advances by the text length. + */ + template + simdjson_inline void append_static_string() noexcept; +#endif + /** * Grow the buffer to at least desired_capacity bytes. * If the allocation fails, is_valid is set to false. We expect @@ -56340,10 +56732,6 @@ using unchecked_writer = basic_writer; // 16-byte blocks). inline constexpr size_t unchecked_slack = 64; -consteval size_t padded_key_length(size_t length) { - return (length + 15) / 16 * 16; -} - // === Helper: invoke a string_builder member that writes variable-length // content (escape_and_append_with_quotes etc), syncing the writer's local // state before the call and reloading after. Used for string fields where @@ -56433,16 +56821,16 @@ simdjson_really_inline void atom_fields(W &w, const T &t, bool &first) { constexpr size_t rest_key_len = first_key_len + 1; constexpr auto first_key = std::define_static_string( constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(first_key_len) - first_key_len, '\0')); + std::string(constevalutil::padded_key_length(first_key_len) - first_key_len, '\0')); constexpr auto rest_key = std::define_static_string( std::string(",") + constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(rest_key_len) - rest_key_len, '\0')); - if (!w.ensure(padded_key_length(rest_key_len))) { return; } + std::string(constevalutil::padded_key_length(rest_key_len) - rest_key_len, '\0')); + if (!w.ensure(constevalutil::padded_key_length(rest_key_len))) { return; } if (first) { - std::memcpy(w.ptr + w.pos, first_key, padded_key_length(first_key_len)); + std::memcpy(w.ptr + w.pos, first_key, constevalutil::padded_key_length(first_key_len)); w.pos += first_key_len; } else { - std::memcpy(w.ptr + w.pos, rest_key, padded_key_length(rest_key_len)); + std::memcpy(w.ptr + w.pos, rest_key, constevalutil::padded_key_length(rest_key_len)); w.pos += rest_key_len; } first = false; @@ -57174,6 +57562,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for icelake */ #include #include +#include #include #include #include @@ -58214,7 +58603,11 @@ string_builder::escape_and_append_with_quotes(const char *input) noexcept { #if SIMDJSON_SUPPORTS_CONCEPTS template simdjson_inline void string_builder::escape_and_append_with_quotes() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(constevalutil::string_constant::value); +#endif } #endif @@ -58248,6 +58641,18 @@ simdjson_inline void string_builder::append_raw_n(const char *str) noexcept { position += N; } } + +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL +template +simdjson_inline void string_builder::append_static_string() noexcept { + constexpr auto& padded = constevalutil::static_string; + if (capacity_check(padded.size())) { + std::memcpy(buffer.get() + position, padded.data(), padded.size()); + position += constevalutil::static_string_size(); + } +} +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS // Support for optional types (std::optional, etc.) template @@ -58414,11 +58819,24 @@ string_builder::append_key_value(key_type key, value_type value) noexcept { } #if SIMDJSON_SUPPORTS_CONCEPTS +#if SIMDJSON_CONSTEVAL +template +struct quoted_key_text { + static consteval std::string text() { + return constevalutil::consteval_to_quoted_escaped(key.view()) + ":"; + } +}; +#endif + template simdjson_inline void string_builder::append_key_value(value_type value) noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(); append_colon(); +#endif SIMDJSON_IF_CONSTEXPR(std::is_same::value) { append_null(); } @@ -58436,6 +58854,56 @@ string_builder::append_key_value(value_type value) noexcept { append(value); } } + +#if SIMDJSON_CONSTEVAL +template +concept compile_time_formattable = + constevalutil::is_fixed_string> || + std::same_as, bool> || + std::same_as, std::nullptr_t>; + +template +requires compile_time_formattable +struct key_value_text { + static consteval std::string text() { + using value_type = std::remove_cvref_t; + std::string out = constevalutil::consteval_to_quoted_escaped(key.view()) + ':'; + SIMDJSON_IF_CONSTEXPR(constevalutil::is_fixed_string) + out += constevalutil::consteval_to_quoted_escaped(value.view()); + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += value ? "true" : "false"; + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += "null"; + return out; + } +}; +#endif + +template +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else + escape_and_append_with_quotes(); + append_colon(); + escape_and_append_with_quotes(); +#endif +} + +template +requires (!constevalutil::is_fixed_string>) +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + SIMDJSON_IF_CONSTEXPR(compile_time_formattable) { + append_static_string>(); + } else +#endif + { + append_key_value(value); + } +} #endif } // namespace builder @@ -59457,6 +59925,13 @@ class string_builder { template simdjson_inline void append_key_value(value_type value) noexcept; + template + simdjson_inline void append_key_value() noexcept; + + template + requires (!constevalutil::is_fixed_string>) + simdjson_inline void append_key_value() noexcept; + // Support for optional types (std::optional, etc.) template requires(!require_custom_serialization) @@ -59498,6 +59973,7 @@ requires (!std::is_convertible::value && !concepts::optiona */ template simdjson_inline void append_raw_n(const char *str) noexcept; + #if SIMDJSON_EXCEPTIONS /** * Creates an std::string from the written JSON buffer. @@ -59577,6 +60053,15 @@ requires (!std::is_convertible::value && !concepts::optiona */ simdjson_inline bool capacity_check(size_t upcoming_bytes); +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL + /** + * Append constevalutil::static_string. The whole zero-padded array is + * copied in 16-byte blocks, but position only advances by the text length. + */ + template + simdjson_inline void append_static_string() noexcept; +#endif + /** * Grow the buffer to at least desired_capacity bytes. * If the allocation fails, is_valid is set to false. We expect @@ -59770,10 +60255,6 @@ using unchecked_writer = basic_writer; // 16-byte blocks). inline constexpr size_t unchecked_slack = 64; -consteval size_t padded_key_length(size_t length) { - return (length + 15) / 16 * 16; -} - // === Helper: invoke a string_builder member that writes variable-length // content (escape_and_append_with_quotes etc), syncing the writer's local // state before the call and reloading after. Used for string fields where @@ -59863,16 +60344,16 @@ simdjson_really_inline void atom_fields(W &w, const T &t, bool &first) { constexpr size_t rest_key_len = first_key_len + 1; constexpr auto first_key = std::define_static_string( constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(first_key_len) - first_key_len, '\0')); + std::string(constevalutil::padded_key_length(first_key_len) - first_key_len, '\0')); constexpr auto rest_key = std::define_static_string( std::string(",") + constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(rest_key_len) - rest_key_len, '\0')); - if (!w.ensure(padded_key_length(rest_key_len))) { return; } + std::string(constevalutil::padded_key_length(rest_key_len) - rest_key_len, '\0')); + if (!w.ensure(constevalutil::padded_key_length(rest_key_len))) { return; } if (first) { - std::memcpy(w.ptr + w.pos, first_key, padded_key_length(first_key_len)); + std::memcpy(w.ptr + w.pos, first_key, constevalutil::padded_key_length(first_key_len)); w.pos += first_key_len; } else { - std::memcpy(w.ptr + w.pos, rest_key, padded_key_length(rest_key_len)); + std::memcpy(w.ptr + w.pos, rest_key, constevalutil::padded_key_length(rest_key_len)); w.pos += rest_key_len; } first = false; @@ -60604,6 +61085,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for ppc64 */ #include #include +#include #include #include #include @@ -61644,7 +62126,11 @@ string_builder::escape_and_append_with_quotes(const char *input) noexcept { #if SIMDJSON_SUPPORTS_CONCEPTS template simdjson_inline void string_builder::escape_and_append_with_quotes() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(constevalutil::string_constant::value); +#endif } #endif @@ -61678,6 +62164,18 @@ simdjson_inline void string_builder::append_raw_n(const char *str) noexcept { position += N; } } + +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL +template +simdjson_inline void string_builder::append_static_string() noexcept { + constexpr auto& padded = constevalutil::static_string; + if (capacity_check(padded.size())) { + std::memcpy(buffer.get() + position, padded.data(), padded.size()); + position += constevalutil::static_string_size(); + } +} +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS // Support for optional types (std::optional, etc.) template @@ -61844,11 +62342,24 @@ string_builder::append_key_value(key_type key, value_type value) noexcept { } #if SIMDJSON_SUPPORTS_CONCEPTS +#if SIMDJSON_CONSTEVAL +template +struct quoted_key_text { + static consteval std::string text() { + return constevalutil::consteval_to_quoted_escaped(key.view()) + ":"; + } +}; +#endif + template simdjson_inline void string_builder::append_key_value(value_type value) noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(); append_colon(); +#endif SIMDJSON_IF_CONSTEXPR(std::is_same::value) { append_null(); } @@ -61866,6 +62377,56 @@ string_builder::append_key_value(value_type value) noexcept { append(value); } } + +#if SIMDJSON_CONSTEVAL +template +concept compile_time_formattable = + constevalutil::is_fixed_string> || + std::same_as, bool> || + std::same_as, std::nullptr_t>; + +template +requires compile_time_formattable +struct key_value_text { + static consteval std::string text() { + using value_type = std::remove_cvref_t; + std::string out = constevalutil::consteval_to_quoted_escaped(key.view()) + ':'; + SIMDJSON_IF_CONSTEXPR(constevalutil::is_fixed_string) + out += constevalutil::consteval_to_quoted_escaped(value.view()); + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += value ? "true" : "false"; + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += "null"; + return out; + } +}; +#endif + +template +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else + escape_and_append_with_quotes(); + append_colon(); + escape_and_append_with_quotes(); +#endif +} + +template +requires (!constevalutil::is_fixed_string>) +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + SIMDJSON_IF_CONSTEXPR(compile_time_formattable) { + append_static_string>(); + } else +#endif + { + append_key_value(value); + } +} #endif } // namespace builder @@ -63194,6 +63755,13 @@ class string_builder { template simdjson_inline void append_key_value(value_type value) noexcept; + template + simdjson_inline void append_key_value() noexcept; + + template + requires (!constevalutil::is_fixed_string>) + simdjson_inline void append_key_value() noexcept; + // Support for optional types (std::optional, etc.) template requires(!require_custom_serialization) @@ -63235,6 +63803,7 @@ requires (!std::is_convertible::value && !concepts::optiona */ template simdjson_inline void append_raw_n(const char *str) noexcept; + #if SIMDJSON_EXCEPTIONS /** * Creates an std::string from the written JSON buffer. @@ -63314,6 +63883,15 @@ requires (!std::is_convertible::value && !concepts::optiona */ simdjson_inline bool capacity_check(size_t upcoming_bytes); +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL + /** + * Append constevalutil::static_string. The whole zero-padded array is + * copied in 16-byte blocks, but position only advances by the text length. + */ + template + simdjson_inline void append_static_string() noexcept; +#endif + /** * Grow the buffer to at least desired_capacity bytes. * If the allocation fails, is_valid is set to false. We expect @@ -63507,10 +64085,6 @@ using unchecked_writer = basic_writer; // 16-byte blocks). inline constexpr size_t unchecked_slack = 64; -consteval size_t padded_key_length(size_t length) { - return (length + 15) / 16 * 16; -} - // === Helper: invoke a string_builder member that writes variable-length // content (escape_and_append_with_quotes etc), syncing the writer's local // state before the call and reloading after. Used for string fields where @@ -63600,16 +64174,16 @@ simdjson_really_inline void atom_fields(W &w, const T &t, bool &first) { constexpr size_t rest_key_len = first_key_len + 1; constexpr auto first_key = std::define_static_string( constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(first_key_len) - first_key_len, '\0')); + std::string(constevalutil::padded_key_length(first_key_len) - first_key_len, '\0')); constexpr auto rest_key = std::define_static_string( std::string(",") + constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(rest_key_len) - rest_key_len, '\0')); - if (!w.ensure(padded_key_length(rest_key_len))) { return; } + std::string(constevalutil::padded_key_length(rest_key_len) - rest_key_len, '\0')); + if (!w.ensure(constevalutil::padded_key_length(rest_key_len))) { return; } if (first) { - std::memcpy(w.ptr + w.pos, first_key, padded_key_length(first_key_len)); + std::memcpy(w.ptr + w.pos, first_key, constevalutil::padded_key_length(first_key_len)); w.pos += first_key_len; } else { - std::memcpy(w.ptr + w.pos, rest_key, padded_key_length(rest_key_len)); + std::memcpy(w.ptr + w.pos, rest_key, constevalutil::padded_key_length(rest_key_len)); w.pos += rest_key_len; } first = false; @@ -64341,6 +64915,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for westmere */ #include #include +#include #include #include #include @@ -65381,7 +65956,11 @@ string_builder::escape_and_append_with_quotes(const char *input) noexcept { #if SIMDJSON_SUPPORTS_CONCEPTS template simdjson_inline void string_builder::escape_and_append_with_quotes() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(constevalutil::string_constant::value); +#endif } #endif @@ -65415,6 +65994,18 @@ simdjson_inline void string_builder::append_raw_n(const char *str) noexcept { position += N; } } + +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL +template +simdjson_inline void string_builder::append_static_string() noexcept { + constexpr auto& padded = constevalutil::static_string; + if (capacity_check(padded.size())) { + std::memcpy(buffer.get() + position, padded.data(), padded.size()); + position += constevalutil::static_string_size(); + } +} +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS // Support for optional types (std::optional, etc.) template @@ -65581,11 +66172,24 @@ string_builder::append_key_value(key_type key, value_type value) noexcept { } #if SIMDJSON_SUPPORTS_CONCEPTS +#if SIMDJSON_CONSTEVAL +template +struct quoted_key_text { + static consteval std::string text() { + return constevalutil::consteval_to_quoted_escaped(key.view()) + ":"; + } +}; +#endif + template simdjson_inline void string_builder::append_key_value(value_type value) noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(); append_colon(); +#endif SIMDJSON_IF_CONSTEXPR(std::is_same::value) { append_null(); } @@ -65603,6 +66207,56 @@ string_builder::append_key_value(value_type value) noexcept { append(value); } } + +#if SIMDJSON_CONSTEVAL +template +concept compile_time_formattable = + constevalutil::is_fixed_string> || + std::same_as, bool> || + std::same_as, std::nullptr_t>; + +template +requires compile_time_formattable +struct key_value_text { + static consteval std::string text() { + using value_type = std::remove_cvref_t; + std::string out = constevalutil::consteval_to_quoted_escaped(key.view()) + ':'; + SIMDJSON_IF_CONSTEXPR(constevalutil::is_fixed_string) + out += constevalutil::consteval_to_quoted_escaped(value.view()); + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += value ? "true" : "false"; + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += "null"; + return out; + } +}; +#endif + +template +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else + escape_and_append_with_quotes(); + append_colon(); + escape_and_append_with_quotes(); +#endif +} + +template +requires (!constevalutil::is_fixed_string>) +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + SIMDJSON_IF_CONSTEXPR(compile_time_formattable) { + append_static_string>(); + } else +#endif + { + append_key_value(value); + } +} #endif } // namespace builder @@ -66421,6 +67075,13 @@ class string_builder { template simdjson_inline void append_key_value(value_type value) noexcept; + template + simdjson_inline void append_key_value() noexcept; + + template + requires (!constevalutil::is_fixed_string>) + simdjson_inline void append_key_value() noexcept; + // Support for optional types (std::optional, etc.) template requires(!require_custom_serialization) @@ -66462,6 +67123,7 @@ requires (!std::is_convertible::value && !concepts::optiona */ template simdjson_inline void append_raw_n(const char *str) noexcept; + #if SIMDJSON_EXCEPTIONS /** * Creates an std::string from the written JSON buffer. @@ -66541,6 +67203,15 @@ requires (!std::is_convertible::value && !concepts::optiona */ simdjson_inline bool capacity_check(size_t upcoming_bytes); +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL + /** + * Append constevalutil::static_string. The whole zero-padded array is + * copied in 16-byte blocks, but position only advances by the text length. + */ + template + simdjson_inline void append_static_string() noexcept; +#endif + /** * Grow the buffer to at least desired_capacity bytes. * If the allocation fails, is_valid is set to false. We expect @@ -66734,10 +67405,6 @@ using unchecked_writer = basic_writer; // 16-byte blocks). inline constexpr size_t unchecked_slack = 64; -consteval size_t padded_key_length(size_t length) { - return (length + 15) / 16 * 16; -} - // === Helper: invoke a string_builder member that writes variable-length // content (escape_and_append_with_quotes etc), syncing the writer's local // state before the call and reloading after. Used for string fields where @@ -66827,16 +67494,16 @@ simdjson_really_inline void atom_fields(W &w, const T &t, bool &first) { constexpr size_t rest_key_len = first_key_len + 1; constexpr auto first_key = std::define_static_string( constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(first_key_len) - first_key_len, '\0')); + std::string(constevalutil::padded_key_length(first_key_len) - first_key_len, '\0')); constexpr auto rest_key = std::define_static_string( std::string(",") + constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(rest_key_len) - rest_key_len, '\0')); - if (!w.ensure(padded_key_length(rest_key_len))) { return; } + std::string(constevalutil::padded_key_length(rest_key_len) - rest_key_len, '\0')); + if (!w.ensure(constevalutil::padded_key_length(rest_key_len))) { return; } if (first) { - std::memcpy(w.ptr + w.pos, first_key, padded_key_length(first_key_len)); + std::memcpy(w.ptr + w.pos, first_key, constevalutil::padded_key_length(first_key_len)); w.pos += first_key_len; } else { - std::memcpy(w.ptr + w.pos, rest_key, padded_key_length(rest_key_len)); + std::memcpy(w.ptr + w.pos, rest_key, constevalutil::padded_key_length(rest_key_len)); w.pos += rest_key_len; } first = false; @@ -67568,6 +68235,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for lsx */ #include #include +#include #include #include #include @@ -68608,7 +69276,11 @@ string_builder::escape_and_append_with_quotes(const char *input) noexcept { #if SIMDJSON_SUPPORTS_CONCEPTS template simdjson_inline void string_builder::escape_and_append_with_quotes() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(constevalutil::string_constant::value); +#endif } #endif @@ -68642,6 +69314,18 @@ simdjson_inline void string_builder::append_raw_n(const char *str) noexcept { position += N; } } + +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL +template +simdjson_inline void string_builder::append_static_string() noexcept { + constexpr auto& padded = constevalutil::static_string; + if (capacity_check(padded.size())) { + std::memcpy(buffer.get() + position, padded.data(), padded.size()); + position += constevalutil::static_string_size(); + } +} +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS // Support for optional types (std::optional, etc.) template @@ -68808,11 +69492,24 @@ string_builder::append_key_value(key_type key, value_type value) noexcept { } #if SIMDJSON_SUPPORTS_CONCEPTS +#if SIMDJSON_CONSTEVAL +template +struct quoted_key_text { + static consteval std::string text() { + return constevalutil::consteval_to_quoted_escaped(key.view()) + ":"; + } +}; +#endif + template simdjson_inline void string_builder::append_key_value(value_type value) noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(); append_colon(); +#endif SIMDJSON_IF_CONSTEXPR(std::is_same::value) { append_null(); } @@ -68830,6 +69527,56 @@ string_builder::append_key_value(value_type value) noexcept { append(value); } } + +#if SIMDJSON_CONSTEVAL +template +concept compile_time_formattable = + constevalutil::is_fixed_string> || + std::same_as, bool> || + std::same_as, std::nullptr_t>; + +template +requires compile_time_formattable +struct key_value_text { + static consteval std::string text() { + using value_type = std::remove_cvref_t; + std::string out = constevalutil::consteval_to_quoted_escaped(key.view()) + ':'; + SIMDJSON_IF_CONSTEXPR(constevalutil::is_fixed_string) + out += constevalutil::consteval_to_quoted_escaped(value.view()); + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += value ? "true" : "false"; + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += "null"; + return out; + } +}; +#endif + +template +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else + escape_and_append_with_quotes(); + append_colon(); + escape_and_append_with_quotes(); +#endif +} + +template +requires (!constevalutil::is_fixed_string>) +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + SIMDJSON_IF_CONSTEXPR(compile_time_formattable) { + append_static_string>(); + } else +#endif + { + append_key_value(value); + } +} #endif } // namespace builder @@ -69671,6 +70418,13 @@ class string_builder { template simdjson_inline void append_key_value(value_type value) noexcept; + template + simdjson_inline void append_key_value() noexcept; + + template + requires (!constevalutil::is_fixed_string>) + simdjson_inline void append_key_value() noexcept; + // Support for optional types (std::optional, etc.) template requires(!require_custom_serialization) @@ -69712,6 +70466,7 @@ requires (!std::is_convertible::value && !concepts::optiona */ template simdjson_inline void append_raw_n(const char *str) noexcept; + #if SIMDJSON_EXCEPTIONS /** * Creates an std::string from the written JSON buffer. @@ -69791,6 +70546,15 @@ requires (!std::is_convertible::value && !concepts::optiona */ simdjson_inline bool capacity_check(size_t upcoming_bytes); +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL + /** + * Append constevalutil::static_string. The whole zero-padded array is + * copied in 16-byte blocks, but position only advances by the text length. + */ + template + simdjson_inline void append_static_string() noexcept; +#endif + /** * Grow the buffer to at least desired_capacity bytes. * If the allocation fails, is_valid is set to false. We expect @@ -69984,10 +70748,6 @@ using unchecked_writer = basic_writer; // 16-byte blocks). inline constexpr size_t unchecked_slack = 64; -consteval size_t padded_key_length(size_t length) { - return (length + 15) / 16 * 16; -} - // === Helper: invoke a string_builder member that writes variable-length // content (escape_and_append_with_quotes etc), syncing the writer's local // state before the call and reloading after. Used for string fields where @@ -70077,16 +70837,16 @@ simdjson_really_inline void atom_fields(W &w, const T &t, bool &first) { constexpr size_t rest_key_len = first_key_len + 1; constexpr auto first_key = std::define_static_string( constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(first_key_len) - first_key_len, '\0')); + std::string(constevalutil::padded_key_length(first_key_len) - first_key_len, '\0')); constexpr auto rest_key = std::define_static_string( std::string(",") + constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(rest_key_len) - rest_key_len, '\0')); - if (!w.ensure(padded_key_length(rest_key_len))) { return; } + std::string(constevalutil::padded_key_length(rest_key_len) - rest_key_len, '\0')); + if (!w.ensure(constevalutil::padded_key_length(rest_key_len))) { return; } if (first) { - std::memcpy(w.ptr + w.pos, first_key, padded_key_length(first_key_len)); + std::memcpy(w.ptr + w.pos, first_key, constevalutil::padded_key_length(first_key_len)); w.pos += first_key_len; } else { - std::memcpy(w.ptr + w.pos, rest_key, padded_key_length(rest_key_len)); + std::memcpy(w.ptr + w.pos, rest_key, constevalutil::padded_key_length(rest_key_len)); w.pos += rest_key_len; } first = false; @@ -70818,6 +71578,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for lasx */ #include #include +#include #include #include #include @@ -71858,7 +72619,11 @@ string_builder::escape_and_append_with_quotes(const char *input) noexcept { #if SIMDJSON_SUPPORTS_CONCEPTS template simdjson_inline void string_builder::escape_and_append_with_quotes() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(constevalutil::string_constant::value); +#endif } #endif @@ -71892,6 +72657,18 @@ simdjson_inline void string_builder::append_raw_n(const char *str) noexcept { position += N; } } + +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL +template +simdjson_inline void string_builder::append_static_string() noexcept { + constexpr auto& padded = constevalutil::static_string; + if (capacity_check(padded.size())) { + std::memcpy(buffer.get() + position, padded.data(), padded.size()); + position += constevalutil::static_string_size(); + } +} +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS // Support for optional types (std::optional, etc.) template @@ -72058,11 +72835,24 @@ string_builder::append_key_value(key_type key, value_type value) noexcept { } #if SIMDJSON_SUPPORTS_CONCEPTS +#if SIMDJSON_CONSTEVAL +template +struct quoted_key_text { + static consteval std::string text() { + return constevalutil::consteval_to_quoted_escaped(key.view()) + ":"; + } +}; +#endif + template simdjson_inline void string_builder::append_key_value(value_type value) noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(); append_colon(); +#endif SIMDJSON_IF_CONSTEXPR(std::is_same::value) { append_null(); } @@ -72080,6 +72870,56 @@ string_builder::append_key_value(value_type value) noexcept { append(value); } } + +#if SIMDJSON_CONSTEVAL +template +concept compile_time_formattable = + constevalutil::is_fixed_string> || + std::same_as, bool> || + std::same_as, std::nullptr_t>; + +template +requires compile_time_formattable +struct key_value_text { + static consteval std::string text() { + using value_type = std::remove_cvref_t; + std::string out = constevalutil::consteval_to_quoted_escaped(key.view()) + ':'; + SIMDJSON_IF_CONSTEXPR(constevalutil::is_fixed_string) + out += constevalutil::consteval_to_quoted_escaped(value.view()); + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += value ? "true" : "false"; + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += "null"; + return out; + } +}; +#endif + +template +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else + escape_and_append_with_quotes(); + append_colon(); + escape_and_append_with_quotes(); +#endif +} + +template +requires (!constevalutil::is_fixed_string>) +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + SIMDJSON_IF_CONSTEXPR(compile_time_formattable) { + append_static_string>(); + } else +#endif + { + append_key_value(value); + } +} #endif } // namespace builder @@ -72924,6 +73764,13 @@ class string_builder { template simdjson_inline void append_key_value(value_type value) noexcept; + template + simdjson_inline void append_key_value() noexcept; + + template + requires (!constevalutil::is_fixed_string>) + simdjson_inline void append_key_value() noexcept; + // Support for optional types (std::optional, etc.) template requires(!require_custom_serialization) @@ -72965,6 +73812,7 @@ requires (!std::is_convertible::value && !concepts::optiona */ template simdjson_inline void append_raw_n(const char *str) noexcept; + #if SIMDJSON_EXCEPTIONS /** * Creates an std::string from the written JSON buffer. @@ -73044,6 +73892,15 @@ requires (!std::is_convertible::value && !concepts::optiona */ simdjson_inline bool capacity_check(size_t upcoming_bytes); +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL + /** + * Append constevalutil::static_string. The whole zero-padded array is + * copied in 16-byte blocks, but position only advances by the text length. + */ + template + simdjson_inline void append_static_string() noexcept; +#endif + /** * Grow the buffer to at least desired_capacity bytes. * If the allocation fails, is_valid is set to false. We expect @@ -73237,10 +74094,6 @@ using unchecked_writer = basic_writer; // 16-byte blocks). inline constexpr size_t unchecked_slack = 64; -consteval size_t padded_key_length(size_t length) { - return (length + 15) / 16 * 16; -} - // === Helper: invoke a string_builder member that writes variable-length // content (escape_and_append_with_quotes etc), syncing the writer's local // state before the call and reloading after. Used for string fields where @@ -73330,16 +74183,16 @@ simdjson_really_inline void atom_fields(W &w, const T &t, bool &first) { constexpr size_t rest_key_len = first_key_len + 1; constexpr auto first_key = std::define_static_string( constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(first_key_len) - first_key_len, '\0')); + std::string(constevalutil::padded_key_length(first_key_len) - first_key_len, '\0')); constexpr auto rest_key = std::define_static_string( std::string(",") + constevalutil::consteval_to_quoted_escaped(key_name) + ":" + - std::string(padded_key_length(rest_key_len) - rest_key_len, '\0')); - if (!w.ensure(padded_key_length(rest_key_len))) { return; } + std::string(constevalutil::padded_key_length(rest_key_len) - rest_key_len, '\0')); + if (!w.ensure(constevalutil::padded_key_length(rest_key_len))) { return; } if (first) { - std::memcpy(w.ptr + w.pos, first_key, padded_key_length(first_key_len)); + std::memcpy(w.ptr + w.pos, first_key, constevalutil::padded_key_length(first_key_len)); w.pos += first_key_len; } else { - std::memcpy(w.ptr + w.pos, rest_key, padded_key_length(rest_key_len)); + std::memcpy(w.ptr + w.pos, rest_key, constevalutil::padded_key_length(rest_key_len)); w.pos += rest_key_len; } first = false; @@ -74071,6 +74924,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for rvv_vls */ #include #include +#include #include #include #include @@ -75111,7 +75965,11 @@ string_builder::escape_and_append_with_quotes(const char *input) noexcept { #if SIMDJSON_SUPPORTS_CONCEPTS template simdjson_inline void string_builder::escape_and_append_with_quotes() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(constevalutil::string_constant::value); +#endif } #endif @@ -75145,6 +76003,18 @@ simdjson_inline void string_builder::append_raw_n(const char *str) noexcept { position += N; } } + +#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_CONSTEVAL +template +simdjson_inline void string_builder::append_static_string() noexcept { + constexpr auto& padded = constevalutil::static_string; + if (capacity_check(padded.size())) { + std::memcpy(buffer.get() + position, padded.data(), padded.size()); + position += constevalutil::static_string_size(); + } +} +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS // Support for optional types (std::optional, etc.) template @@ -75311,11 +76181,24 @@ string_builder::append_key_value(key_type key, value_type value) noexcept { } #if SIMDJSON_SUPPORTS_CONCEPTS +#if SIMDJSON_CONSTEVAL +template +struct quoted_key_text { + static consteval std::string text() { + return constevalutil::consteval_to_quoted_escaped(key.view()) + ":"; + } +}; +#endif + template simdjson_inline void string_builder::append_key_value(value_type value) noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else escape_and_append_with_quotes(); append_colon(); +#endif SIMDJSON_IF_CONSTEXPR(std::is_same::value) { append_null(); } @@ -75333,6 +76216,56 @@ string_builder::append_key_value(value_type value) noexcept { append(value); } } + +#if SIMDJSON_CONSTEVAL +template +concept compile_time_formattable = + constevalutil::is_fixed_string> || + std::same_as, bool> || + std::same_as, std::nullptr_t>; + +template +requires compile_time_formattable +struct key_value_text { + static consteval std::string text() { + using value_type = std::remove_cvref_t; + std::string out = constevalutil::consteval_to_quoted_escaped(key.view()) + ':'; + SIMDJSON_IF_CONSTEXPR(constevalutil::is_fixed_string) + out += constevalutil::consteval_to_quoted_escaped(value.view()); + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += value ? "true" : "false"; + else SIMDJSON_IF_CONSTEXPR(std::same_as) + out += "null"; + return out; + } +}; +#endif + +template +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + append_static_string>(); +#else + escape_and_append_with_quotes(); + append_colon(); + escape_and_append_with_quotes(); +#endif +} + +template +requires (!constevalutil::is_fixed_string>) +simdjson_inline void +string_builder::append_key_value() noexcept { +#if SIMDJSON_CONSTEVAL + SIMDJSON_IF_CONSTEXPR(compile_time_formattable) { + append_static_string>(); + } else +#endif + { + append_key_value(value); + } +} #endif } // namespace builder @@ -81909,6 +82842,20 @@ struct simdjson_result : public arm64::implementation_si #define SIMDJSON_KEY_SELECTOR_HAS_LSX 0 #endif +// Clang 15 and earlier reject a call to a consteval function from within a +// consteval function template when an argument refers to one of the caller's +// reference parameters ("function parameter 'keys' with unknown value cannot +// be used in a constant expression"). With those compilers, the helpers below +// are merely constexpr: the perfect-hash tables are still computed at compile +// time because they initialize static constexpr data members. +#ifndef SIMDJSON_KEY_SELECTOR_CONSTEVAL +#if defined(__clang__) && ((defined(__apple_build_version__) && __apple_build_version__ < 15000000) || (!defined(__apple_build_version__) && __clang_major__ < 16)) + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL constexpr +#else + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL consteval +#endif +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS namespace simdjson { @@ -81963,7 +82910,7 @@ constexpr std::size_t char_at(std::string_view key, std::size_t pos) noexcept { // lengths differ modulo the table size are separated by the length term in the // hash, so they need no position coverage. template -consteval std::size_t count_undistinguished_pairs( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t count_undistinguished_pairs( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -81986,7 +82933,7 @@ consteval std::size_t count_undistinguished_pairs( } template -consteval bool positions_distinguish( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool positions_distinguish( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -81996,7 +82943,7 @@ consteval bool positions_distinguish( // Number of distinct (length % modulus, char_at(key, pos)) pairs at a position. template -consteval std::size_t discriminating_power( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t discriminating_power( const std::array& keys, std::size_t pos, std::size_t modulus) { @@ -82020,7 +82967,7 @@ consteval std::size_t discriminating_power( } template -consteval std::size_t max_key_length(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t max_key_length(const std::array& keys) { std::size_t m = 0; for (std::size_t i = 0; i < N; ++i) { if (keys[i].size() > m) { m = keys[i].size(); } @@ -82030,7 +82977,7 @@ consteval std::size_t max_key_length(const std::array& keys // Bounded backtracking DFS for a minimal set of distinguishing positions. template -consteval bool backtracking_search( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool backtracking_search( const std::array& keys, const std::size_t* candidates, std::size_t num_candidates, @@ -82081,7 +83028,7 @@ consteval bool backtracking_search( // Phase 1: select character positions that distinguish all colliding pairs. template -consteval std::size_t select_positions( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t select_positions( const std::array& keys, std::array& positions, std::size_t modulus) { @@ -82160,7 +83107,7 @@ struct phf_result { // (position, character) symbol at a time; never revisits a value. Equivalence // classes (keys sharing the same undetermined symbols) keep the search cheap. template -consteval bool try_generate_gperf( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_generate_gperf( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -82308,7 +83255,7 @@ consteval bool try_generate_gperf( } template -consteval bool try_compute_phf(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -82327,7 +83274,7 @@ consteval bool try_compute_phf(const std::array& keys, phf_ } template -consteval bool try_gperf_po2(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_gperf_po2(const std::array& keys, phf_result& result) { if (try_compute_phf(keys, result)) { return true; } constexpr std::size_t NextM = M * 2; if constexpr (NextM <= MaxM) { return try_gperf_po2(keys, result); } @@ -82362,7 +83309,7 @@ constexpr std::size_t hd_key_hash_4(std::string_view key) noexcept { } template -consteval bool try_hash_and_displace( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_hash_and_displace( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -82462,7 +83409,7 @@ consteval bool try_hash_and_displace( } template -consteval bool try_compute_phf_hd(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf_hd(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -82481,7 +83428,7 @@ consteval bool try_compute_phf_hd(const std::array& keys, p } template -consteval phf_result compute_phf_hd_po2(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf_hd_po2(const std::array& keys) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); phf_result result{}; if (try_compute_phf_hd(keys, result)) { return result; } @@ -82497,7 +83444,7 @@ consteval phf_result compute_phf_hd_po2(const std::array // Compute a perfect hash for `keys`: try gperf at power-of-two sizes (capped so // the runtime tables stay within uint8 indices), then fall back to H&D. template -consteval phf_result compute_phf(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf(const std::array& keys) { constexpr std::size_t StartM = next_power_of_2(N); constexpr std::size_t GPERF_MAX_TABLE = phf_result::MAX_TABLE_SIZE < 256 ? phf_result::MAX_TABLE_SIZE : 256; @@ -82534,7 +83481,7 @@ constexpr std::size_t compute_max_key_len(const std::array& // Validate keys and build the runtime tables from the computed perfect hash. template -consteval phf_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_data build_phf_data(const std::array& keys, const phf_result& result) { for (std::size_t i = 0; i < N; ++i) { if (keys[i].empty()) { compile_time_error("empty keys are not allowed in key_selector"); } @@ -82843,7 +83790,7 @@ constexpr unsigned window_value(const std::array& keys, } template -consteval window_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL window_data compute_window(const std::array& keys) { window_data out{}; @@ -82928,7 +83875,7 @@ match_window_candidate(const char* p, std::uint8_t ki, // --- describe() string helpers (constexpr; no std::to_string, which is not) --- // Append the decimal form of v to s. -SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { +inline SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { if (v == 0) { s.push_back('0'); return; } char buf[20]; std::size_t n = 0; @@ -82938,7 +83885,7 @@ SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { // Append a byte as its decimal value, plus the printable character in quotes // when it is in the printable ASCII range (e.g. "110 ('n')"). -SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { +inline SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { append_uint(s, b); if (b >= 0x20 && b < 0x7f) { s += " ('"; @@ -85779,30 +86726,36 @@ inline error_code array::for_each_at_path_with_wildcard(std::string_view json_pa if (remaining_path.empty()) { callback(val); } else { - error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); - if(err) { return err; } + // An element that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { // Specific index case in which we access the element at the given index - size_t idx = 0; - for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } - idx = idx*10 + (c - '0'); } - - auto element = at(idx); + // Rejects leading zeros and indexes that overflow size_t, as DOM does. + size_t idx; + size_t idx_length; + error_code error = internal::parse_json_pointer_array_index(key, idx, idx_length); value val; - SIMDJSON_TRY(element.get(val)); + if (!error) { error = at(idx).get(val); } + if (error) { + if (error == INDEX_OUT_OF_BOUNDS && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()){ callback(val); return SUCCESS; } else { - return element.for_each_at_path_with_wildcard(remaining_path, callback); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -90113,13 +91066,21 @@ inline error_code object::for_each_at_path_with_wildcard(std::string_view json_p if (remaining_path.empty()) { callback(val); } else { - SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); + // A field that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { value val; - SIMDJSON_TRY(find_field(key).get(val)); + error_code error = find_field(key).get(val); + if (error) { + if (error == NO_SUCH_FIELD && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()) { callback(val); @@ -99628,6 +100589,20 @@ struct simdjson_result : public fallback::implementat #define SIMDJSON_KEY_SELECTOR_HAS_LSX 0 #endif +// Clang 15 and earlier reject a call to a consteval function from within a +// consteval function template when an argument refers to one of the caller's +// reference parameters ("function parameter 'keys' with unknown value cannot +// be used in a constant expression"). With those compilers, the helpers below +// are merely constexpr: the perfect-hash tables are still computed at compile +// time because they initialize static constexpr data members. +#ifndef SIMDJSON_KEY_SELECTOR_CONSTEVAL +#if defined(__clang__) && ((defined(__apple_build_version__) && __apple_build_version__ < 15000000) || (!defined(__apple_build_version__) && __clang_major__ < 16)) + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL constexpr +#else + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL consteval +#endif +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS namespace simdjson { @@ -99682,7 +100657,7 @@ constexpr std::size_t char_at(std::string_view key, std::size_t pos) noexcept { // lengths differ modulo the table size are separated by the length term in the // hash, so they need no position coverage. template -consteval std::size_t count_undistinguished_pairs( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t count_undistinguished_pairs( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -99705,7 +100680,7 @@ consteval std::size_t count_undistinguished_pairs( } template -consteval bool positions_distinguish( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool positions_distinguish( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -99715,7 +100690,7 @@ consteval bool positions_distinguish( // Number of distinct (length % modulus, char_at(key, pos)) pairs at a position. template -consteval std::size_t discriminating_power( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t discriminating_power( const std::array& keys, std::size_t pos, std::size_t modulus) { @@ -99739,7 +100714,7 @@ consteval std::size_t discriminating_power( } template -consteval std::size_t max_key_length(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t max_key_length(const std::array& keys) { std::size_t m = 0; for (std::size_t i = 0; i < N; ++i) { if (keys[i].size() > m) { m = keys[i].size(); } @@ -99749,7 +100724,7 @@ consteval std::size_t max_key_length(const std::array& keys // Bounded backtracking DFS for a minimal set of distinguishing positions. template -consteval bool backtracking_search( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool backtracking_search( const std::array& keys, const std::size_t* candidates, std::size_t num_candidates, @@ -99800,7 +100775,7 @@ consteval bool backtracking_search( // Phase 1: select character positions that distinguish all colliding pairs. template -consteval std::size_t select_positions( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t select_positions( const std::array& keys, std::array& positions, std::size_t modulus) { @@ -99879,7 +100854,7 @@ struct phf_result { // (position, character) symbol at a time; never revisits a value. Equivalence // classes (keys sharing the same undetermined symbols) keep the search cheap. template -consteval bool try_generate_gperf( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_generate_gperf( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -100027,7 +101002,7 @@ consteval bool try_generate_gperf( } template -consteval bool try_compute_phf(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -100046,7 +101021,7 @@ consteval bool try_compute_phf(const std::array& keys, phf_ } template -consteval bool try_gperf_po2(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_gperf_po2(const std::array& keys, phf_result& result) { if (try_compute_phf(keys, result)) { return true; } constexpr std::size_t NextM = M * 2; if constexpr (NextM <= MaxM) { return try_gperf_po2(keys, result); } @@ -100081,7 +101056,7 @@ constexpr std::size_t hd_key_hash_4(std::string_view key) noexcept { } template -consteval bool try_hash_and_displace( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_hash_and_displace( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -100181,7 +101156,7 @@ consteval bool try_hash_and_displace( } template -consteval bool try_compute_phf_hd(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf_hd(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -100200,7 +101175,7 @@ consteval bool try_compute_phf_hd(const std::array& keys, p } template -consteval phf_result compute_phf_hd_po2(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf_hd_po2(const std::array& keys) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); phf_result result{}; if (try_compute_phf_hd(keys, result)) { return result; } @@ -100216,7 +101191,7 @@ consteval phf_result compute_phf_hd_po2(const std::array // Compute a perfect hash for `keys`: try gperf at power-of-two sizes (capped so // the runtime tables stay within uint8 indices), then fall back to H&D. template -consteval phf_result compute_phf(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf(const std::array& keys) { constexpr std::size_t StartM = next_power_of_2(N); constexpr std::size_t GPERF_MAX_TABLE = phf_result::MAX_TABLE_SIZE < 256 ? phf_result::MAX_TABLE_SIZE : 256; @@ -100253,7 +101228,7 @@ constexpr std::size_t compute_max_key_len(const std::array& // Validate keys and build the runtime tables from the computed perfect hash. template -consteval phf_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_data build_phf_data(const std::array& keys, const phf_result& result) { for (std::size_t i = 0; i < N; ++i) { if (keys[i].empty()) { compile_time_error("empty keys are not allowed in key_selector"); } @@ -100562,7 +101537,7 @@ constexpr unsigned window_value(const std::array& keys, } template -consteval window_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL window_data compute_window(const std::array& keys) { window_data out{}; @@ -100647,7 +101622,7 @@ match_window_candidate(const char* p, std::uint8_t ki, // --- describe() string helpers (constexpr; no std::to_string, which is not) --- // Append the decimal form of v to s. -SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { +inline SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { if (v == 0) { s.push_back('0'); return; } char buf[20]; std::size_t n = 0; @@ -100657,7 +101632,7 @@ SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { // Append a byte as its decimal value, plus the printable character in quotes // when it is in the printable ASCII range (e.g. "110 ('n')"). -SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { +inline SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { append_uint(s, b); if (b >= 0x20 && b < 0x7f) { s += " ('"; @@ -103498,30 +104473,36 @@ inline error_code array::for_each_at_path_with_wildcard(std::string_view json_pa if (remaining_path.empty()) { callback(val); } else { - error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); - if(err) { return err; } + // An element that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { // Specific index case in which we access the element at the given index - size_t idx = 0; - for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } - idx = idx*10 + (c - '0'); } - - auto element = at(idx); + // Rejects leading zeros and indexes that overflow size_t, as DOM does. + size_t idx; + size_t idx_length; + error_code error = internal::parse_json_pointer_array_index(key, idx, idx_length); value val; - SIMDJSON_TRY(element.get(val)); + if (!error) { error = at(idx).get(val); } + if (error) { + if (error == INDEX_OUT_OF_BOUNDS && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()){ callback(val); return SUCCESS; } else { - return element.for_each_at_path_with_wildcard(remaining_path, callback); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -107832,13 +108813,21 @@ inline error_code object::for_each_at_path_with_wildcard(std::string_view json_p if (remaining_path.empty()) { callback(val); } else { - SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); + // A field that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { value val; - SIMDJSON_TRY(find_field(key).get(val)); + error_code error = find_field(key).get(val); + if (error) { + if (error == NO_SUCH_FIELD && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()) { callback(val); @@ -117824,6 +118813,20 @@ struct simdjson_result : public haswell::implementatio #define SIMDJSON_KEY_SELECTOR_HAS_LSX 0 #endif +// Clang 15 and earlier reject a call to a consteval function from within a +// consteval function template when an argument refers to one of the caller's +// reference parameters ("function parameter 'keys' with unknown value cannot +// be used in a constant expression"). With those compilers, the helpers below +// are merely constexpr: the perfect-hash tables are still computed at compile +// time because they initialize static constexpr data members. +#ifndef SIMDJSON_KEY_SELECTOR_CONSTEVAL +#if defined(__clang__) && ((defined(__apple_build_version__) && __apple_build_version__ < 15000000) || (!defined(__apple_build_version__) && __clang_major__ < 16)) + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL constexpr +#else + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL consteval +#endif +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS namespace simdjson { @@ -117878,7 +118881,7 @@ constexpr std::size_t char_at(std::string_view key, std::size_t pos) noexcept { // lengths differ modulo the table size are separated by the length term in the // hash, so they need no position coverage. template -consteval std::size_t count_undistinguished_pairs( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t count_undistinguished_pairs( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -117901,7 +118904,7 @@ consteval std::size_t count_undistinguished_pairs( } template -consteval bool positions_distinguish( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool positions_distinguish( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -117911,7 +118914,7 @@ consteval bool positions_distinguish( // Number of distinct (length % modulus, char_at(key, pos)) pairs at a position. template -consteval std::size_t discriminating_power( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t discriminating_power( const std::array& keys, std::size_t pos, std::size_t modulus) { @@ -117935,7 +118938,7 @@ consteval std::size_t discriminating_power( } template -consteval std::size_t max_key_length(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t max_key_length(const std::array& keys) { std::size_t m = 0; for (std::size_t i = 0; i < N; ++i) { if (keys[i].size() > m) { m = keys[i].size(); } @@ -117945,7 +118948,7 @@ consteval std::size_t max_key_length(const std::array& keys // Bounded backtracking DFS for a minimal set of distinguishing positions. template -consteval bool backtracking_search( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool backtracking_search( const std::array& keys, const std::size_t* candidates, std::size_t num_candidates, @@ -117996,7 +118999,7 @@ consteval bool backtracking_search( // Phase 1: select character positions that distinguish all colliding pairs. template -consteval std::size_t select_positions( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t select_positions( const std::array& keys, std::array& positions, std::size_t modulus) { @@ -118075,7 +119078,7 @@ struct phf_result { // (position, character) symbol at a time; never revisits a value. Equivalence // classes (keys sharing the same undetermined symbols) keep the search cheap. template -consteval bool try_generate_gperf( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_generate_gperf( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -118223,7 +119226,7 @@ consteval bool try_generate_gperf( } template -consteval bool try_compute_phf(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -118242,7 +119245,7 @@ consteval bool try_compute_phf(const std::array& keys, phf_ } template -consteval bool try_gperf_po2(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_gperf_po2(const std::array& keys, phf_result& result) { if (try_compute_phf(keys, result)) { return true; } constexpr std::size_t NextM = M * 2; if constexpr (NextM <= MaxM) { return try_gperf_po2(keys, result); } @@ -118277,7 +119280,7 @@ constexpr std::size_t hd_key_hash_4(std::string_view key) noexcept { } template -consteval bool try_hash_and_displace( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_hash_and_displace( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -118377,7 +119380,7 @@ consteval bool try_hash_and_displace( } template -consteval bool try_compute_phf_hd(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf_hd(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -118396,7 +119399,7 @@ consteval bool try_compute_phf_hd(const std::array& keys, p } template -consteval phf_result compute_phf_hd_po2(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf_hd_po2(const std::array& keys) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); phf_result result{}; if (try_compute_phf_hd(keys, result)) { return result; } @@ -118412,7 +119415,7 @@ consteval phf_result compute_phf_hd_po2(const std::array // Compute a perfect hash for `keys`: try gperf at power-of-two sizes (capped so // the runtime tables stay within uint8 indices), then fall back to H&D. template -consteval phf_result compute_phf(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf(const std::array& keys) { constexpr std::size_t StartM = next_power_of_2(N); constexpr std::size_t GPERF_MAX_TABLE = phf_result::MAX_TABLE_SIZE < 256 ? phf_result::MAX_TABLE_SIZE : 256; @@ -118449,7 +119452,7 @@ constexpr std::size_t compute_max_key_len(const std::array& // Validate keys and build the runtime tables from the computed perfect hash. template -consteval phf_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_data build_phf_data(const std::array& keys, const phf_result& result) { for (std::size_t i = 0; i < N; ++i) { if (keys[i].empty()) { compile_time_error("empty keys are not allowed in key_selector"); } @@ -118758,7 +119761,7 @@ constexpr unsigned window_value(const std::array& keys, } template -consteval window_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL window_data compute_window(const std::array& keys) { window_data out{}; @@ -118843,7 +119846,7 @@ match_window_candidate(const char* p, std::uint8_t ki, // --- describe() string helpers (constexpr; no std::to_string, which is not) --- // Append the decimal form of v to s. -SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { +inline SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { if (v == 0) { s.push_back('0'); return; } char buf[20]; std::size_t n = 0; @@ -118853,7 +119856,7 @@ SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { // Append a byte as its decimal value, plus the printable character in quotes // when it is in the printable ASCII range (e.g. "110 ('n')"). -SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { +inline SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { append_uint(s, b); if (b >= 0x20 && b < 0x7f) { s += " ('"; @@ -121694,30 +122697,36 @@ inline error_code array::for_each_at_path_with_wildcard(std::string_view json_pa if (remaining_path.empty()) { callback(val); } else { - error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); - if(err) { return err; } + // An element that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { // Specific index case in which we access the element at the given index - size_t idx = 0; - for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } - idx = idx*10 + (c - '0'); } - - auto element = at(idx); + // Rejects leading zeros and indexes that overflow size_t, as DOM does. + size_t idx; + size_t idx_length; + error_code error = internal::parse_json_pointer_array_index(key, idx, idx_length); value val; - SIMDJSON_TRY(element.get(val)); + if (!error) { error = at(idx).get(val); } + if (error) { + if (error == INDEX_OUT_OF_BOUNDS && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()){ callback(val); return SUCCESS; } else { - return element.for_each_at_path_with_wildcard(remaining_path, callback); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -126028,13 +127037,21 @@ inline error_code object::for_each_at_path_with_wildcard(std::string_view json_p if (remaining_path.empty()) { callback(val); } else { - SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); + // A field that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { value val; - SIMDJSON_TRY(find_field(key).get(val)); + error_code error = find_field(key).get(val); + if (error) { + if (error == NO_SUCH_FIELD && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()) { callback(val); @@ -136020,6 +137037,20 @@ struct simdjson_result : public icelake::implementatio #define SIMDJSON_KEY_SELECTOR_HAS_LSX 0 #endif +// Clang 15 and earlier reject a call to a consteval function from within a +// consteval function template when an argument refers to one of the caller's +// reference parameters ("function parameter 'keys' with unknown value cannot +// be used in a constant expression"). With those compilers, the helpers below +// are merely constexpr: the perfect-hash tables are still computed at compile +// time because they initialize static constexpr data members. +#ifndef SIMDJSON_KEY_SELECTOR_CONSTEVAL +#if defined(__clang__) && ((defined(__apple_build_version__) && __apple_build_version__ < 15000000) || (!defined(__apple_build_version__) && __clang_major__ < 16)) + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL constexpr +#else + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL consteval +#endif +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS namespace simdjson { @@ -136074,7 +137105,7 @@ constexpr std::size_t char_at(std::string_view key, std::size_t pos) noexcept { // lengths differ modulo the table size are separated by the length term in the // hash, so they need no position coverage. template -consteval std::size_t count_undistinguished_pairs( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t count_undistinguished_pairs( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -136097,7 +137128,7 @@ consteval std::size_t count_undistinguished_pairs( } template -consteval bool positions_distinguish( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool positions_distinguish( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -136107,7 +137138,7 @@ consteval bool positions_distinguish( // Number of distinct (length % modulus, char_at(key, pos)) pairs at a position. template -consteval std::size_t discriminating_power( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t discriminating_power( const std::array& keys, std::size_t pos, std::size_t modulus) { @@ -136131,7 +137162,7 @@ consteval std::size_t discriminating_power( } template -consteval std::size_t max_key_length(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t max_key_length(const std::array& keys) { std::size_t m = 0; for (std::size_t i = 0; i < N; ++i) { if (keys[i].size() > m) { m = keys[i].size(); } @@ -136141,7 +137172,7 @@ consteval std::size_t max_key_length(const std::array& keys // Bounded backtracking DFS for a minimal set of distinguishing positions. template -consteval bool backtracking_search( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool backtracking_search( const std::array& keys, const std::size_t* candidates, std::size_t num_candidates, @@ -136192,7 +137223,7 @@ consteval bool backtracking_search( // Phase 1: select character positions that distinguish all colliding pairs. template -consteval std::size_t select_positions( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t select_positions( const std::array& keys, std::array& positions, std::size_t modulus) { @@ -136271,7 +137302,7 @@ struct phf_result { // (position, character) symbol at a time; never revisits a value. Equivalence // classes (keys sharing the same undetermined symbols) keep the search cheap. template -consteval bool try_generate_gperf( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_generate_gperf( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -136419,7 +137450,7 @@ consteval bool try_generate_gperf( } template -consteval bool try_compute_phf(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -136438,7 +137469,7 @@ consteval bool try_compute_phf(const std::array& keys, phf_ } template -consteval bool try_gperf_po2(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_gperf_po2(const std::array& keys, phf_result& result) { if (try_compute_phf(keys, result)) { return true; } constexpr std::size_t NextM = M * 2; if constexpr (NextM <= MaxM) { return try_gperf_po2(keys, result); } @@ -136473,7 +137504,7 @@ constexpr std::size_t hd_key_hash_4(std::string_view key) noexcept { } template -consteval bool try_hash_and_displace( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_hash_and_displace( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -136573,7 +137604,7 @@ consteval bool try_hash_and_displace( } template -consteval bool try_compute_phf_hd(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf_hd(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -136592,7 +137623,7 @@ consteval bool try_compute_phf_hd(const std::array& keys, p } template -consteval phf_result compute_phf_hd_po2(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf_hd_po2(const std::array& keys) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); phf_result result{}; if (try_compute_phf_hd(keys, result)) { return result; } @@ -136608,7 +137639,7 @@ consteval phf_result compute_phf_hd_po2(const std::array // Compute a perfect hash for `keys`: try gperf at power-of-two sizes (capped so // the runtime tables stay within uint8 indices), then fall back to H&D. template -consteval phf_result compute_phf(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf(const std::array& keys) { constexpr std::size_t StartM = next_power_of_2(N); constexpr std::size_t GPERF_MAX_TABLE = phf_result::MAX_TABLE_SIZE < 256 ? phf_result::MAX_TABLE_SIZE : 256; @@ -136645,7 +137676,7 @@ constexpr std::size_t compute_max_key_len(const std::array& // Validate keys and build the runtime tables from the computed perfect hash. template -consteval phf_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_data build_phf_data(const std::array& keys, const phf_result& result) { for (std::size_t i = 0; i < N; ++i) { if (keys[i].empty()) { compile_time_error("empty keys are not allowed in key_selector"); } @@ -136954,7 +137985,7 @@ constexpr unsigned window_value(const std::array& keys, } template -consteval window_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL window_data compute_window(const std::array& keys) { window_data out{}; @@ -137039,7 +138070,7 @@ match_window_candidate(const char* p, std::uint8_t ki, // --- describe() string helpers (constexpr; no std::to_string, which is not) --- // Append the decimal form of v to s. -SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { +inline SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { if (v == 0) { s.push_back('0'); return; } char buf[20]; std::size_t n = 0; @@ -137049,7 +138080,7 @@ SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { // Append a byte as its decimal value, plus the printable character in quotes // when it is in the printable ASCII range (e.g. "110 ('n')"). -SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { +inline SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { append_uint(s, b); if (b >= 0x20 && b < 0x7f) { s += " ('"; @@ -139890,30 +140921,36 @@ inline error_code array::for_each_at_path_with_wildcard(std::string_view json_pa if (remaining_path.empty()) { callback(val); } else { - error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); - if(err) { return err; } + // An element that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { // Specific index case in which we access the element at the given index - size_t idx = 0; - for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } - idx = idx*10 + (c - '0'); } - - auto element = at(idx); + // Rejects leading zeros and indexes that overflow size_t, as DOM does. + size_t idx; + size_t idx_length; + error_code error = internal::parse_json_pointer_array_index(key, idx, idx_length); value val; - SIMDJSON_TRY(element.get(val)); + if (!error) { error = at(idx).get(val); } + if (error) { + if (error == INDEX_OUT_OF_BOUNDS && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()){ callback(val); return SUCCESS; } else { - return element.for_each_at_path_with_wildcard(remaining_path, callback); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -144224,13 +145261,21 @@ inline error_code object::for_each_at_path_with_wildcard(std::string_view json_p if (remaining_path.empty()) { callback(val); } else { - SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); + // A field that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { value val; - SIMDJSON_TRY(find_field(key).get(val)); + error_code error = find_field(key).get(val); + if (error) { + if (error == NO_SUCH_FIELD && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()) { callback(val); @@ -154331,6 +155376,20 @@ struct simdjson_result : public ppc64::implementation_si #define SIMDJSON_KEY_SELECTOR_HAS_LSX 0 #endif +// Clang 15 and earlier reject a call to a consteval function from within a +// consteval function template when an argument refers to one of the caller's +// reference parameters ("function parameter 'keys' with unknown value cannot +// be used in a constant expression"). With those compilers, the helpers below +// are merely constexpr: the perfect-hash tables are still computed at compile +// time because they initialize static constexpr data members. +#ifndef SIMDJSON_KEY_SELECTOR_CONSTEVAL +#if defined(__clang__) && ((defined(__apple_build_version__) && __apple_build_version__ < 15000000) || (!defined(__apple_build_version__) && __clang_major__ < 16)) + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL constexpr +#else + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL consteval +#endif +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS namespace simdjson { @@ -154385,7 +155444,7 @@ constexpr std::size_t char_at(std::string_view key, std::size_t pos) noexcept { // lengths differ modulo the table size are separated by the length term in the // hash, so they need no position coverage. template -consteval std::size_t count_undistinguished_pairs( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t count_undistinguished_pairs( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -154408,7 +155467,7 @@ consteval std::size_t count_undistinguished_pairs( } template -consteval bool positions_distinguish( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool positions_distinguish( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -154418,7 +155477,7 @@ consteval bool positions_distinguish( // Number of distinct (length % modulus, char_at(key, pos)) pairs at a position. template -consteval std::size_t discriminating_power( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t discriminating_power( const std::array& keys, std::size_t pos, std::size_t modulus) { @@ -154442,7 +155501,7 @@ consteval std::size_t discriminating_power( } template -consteval std::size_t max_key_length(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t max_key_length(const std::array& keys) { std::size_t m = 0; for (std::size_t i = 0; i < N; ++i) { if (keys[i].size() > m) { m = keys[i].size(); } @@ -154452,7 +155511,7 @@ consteval std::size_t max_key_length(const std::array& keys // Bounded backtracking DFS for a minimal set of distinguishing positions. template -consteval bool backtracking_search( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool backtracking_search( const std::array& keys, const std::size_t* candidates, std::size_t num_candidates, @@ -154503,7 +155562,7 @@ consteval bool backtracking_search( // Phase 1: select character positions that distinguish all colliding pairs. template -consteval std::size_t select_positions( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t select_positions( const std::array& keys, std::array& positions, std::size_t modulus) { @@ -154582,7 +155641,7 @@ struct phf_result { // (position, character) symbol at a time; never revisits a value. Equivalence // classes (keys sharing the same undetermined symbols) keep the search cheap. template -consteval bool try_generate_gperf( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_generate_gperf( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -154730,7 +155789,7 @@ consteval bool try_generate_gperf( } template -consteval bool try_compute_phf(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -154749,7 +155808,7 @@ consteval bool try_compute_phf(const std::array& keys, phf_ } template -consteval bool try_gperf_po2(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_gperf_po2(const std::array& keys, phf_result& result) { if (try_compute_phf(keys, result)) { return true; } constexpr std::size_t NextM = M * 2; if constexpr (NextM <= MaxM) { return try_gperf_po2(keys, result); } @@ -154784,7 +155843,7 @@ constexpr std::size_t hd_key_hash_4(std::string_view key) noexcept { } template -consteval bool try_hash_and_displace( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_hash_and_displace( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -154884,7 +155943,7 @@ consteval bool try_hash_and_displace( } template -consteval bool try_compute_phf_hd(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf_hd(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -154903,7 +155962,7 @@ consteval bool try_compute_phf_hd(const std::array& keys, p } template -consteval phf_result compute_phf_hd_po2(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf_hd_po2(const std::array& keys) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); phf_result result{}; if (try_compute_phf_hd(keys, result)) { return result; } @@ -154919,7 +155978,7 @@ consteval phf_result compute_phf_hd_po2(const std::array // Compute a perfect hash for `keys`: try gperf at power-of-two sizes (capped so // the runtime tables stay within uint8 indices), then fall back to H&D. template -consteval phf_result compute_phf(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf(const std::array& keys) { constexpr std::size_t StartM = next_power_of_2(N); constexpr std::size_t GPERF_MAX_TABLE = phf_result::MAX_TABLE_SIZE < 256 ? phf_result::MAX_TABLE_SIZE : 256; @@ -154956,7 +156015,7 @@ constexpr std::size_t compute_max_key_len(const std::array& // Validate keys and build the runtime tables from the computed perfect hash. template -consteval phf_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_data build_phf_data(const std::array& keys, const phf_result& result) { for (std::size_t i = 0; i < N; ++i) { if (keys[i].empty()) { compile_time_error("empty keys are not allowed in key_selector"); } @@ -155265,7 +156324,7 @@ constexpr unsigned window_value(const std::array& keys, } template -consteval window_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL window_data compute_window(const std::array& keys) { window_data out{}; @@ -155350,7 +156409,7 @@ match_window_candidate(const char* p, std::uint8_t ki, // --- describe() string helpers (constexpr; no std::to_string, which is not) --- // Append the decimal form of v to s. -SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { +inline SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { if (v == 0) { s.push_back('0'); return; } char buf[20]; std::size_t n = 0; @@ -155360,7 +156419,7 @@ SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { // Append a byte as its decimal value, plus the printable character in quotes // when it is in the printable ASCII range (e.g. "110 ('n')"). -SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { +inline SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { append_uint(s, b); if (b >= 0x20 && b < 0x7f) { s += " ('"; @@ -158201,30 +159260,36 @@ inline error_code array::for_each_at_path_with_wildcard(std::string_view json_pa if (remaining_path.empty()) { callback(val); } else { - error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); - if(err) { return err; } + // An element that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { // Specific index case in which we access the element at the given index - size_t idx = 0; - for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } - idx = idx*10 + (c - '0'); } - - auto element = at(idx); + // Rejects leading zeros and indexes that overflow size_t, as DOM does. + size_t idx; + size_t idx_length; + error_code error = internal::parse_json_pointer_array_index(key, idx, idx_length); value val; - SIMDJSON_TRY(element.get(val)); + if (!error) { error = at(idx).get(val); } + if (error) { + if (error == INDEX_OUT_OF_BOUNDS && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()){ callback(val); return SUCCESS; } else { - return element.for_each_at_path_with_wildcard(remaining_path, callback); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -162535,13 +163600,21 @@ inline error_code object::for_each_at_path_with_wildcard(std::string_view json_p if (remaining_path.empty()) { callback(val); } else { - SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); + // A field that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { value val; - SIMDJSON_TRY(find_field(key).get(val)); + error_code error = find_field(key).get(val); + if (error) { + if (error == NO_SUCH_FIELD && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()) { callback(val); @@ -172949,6 +174022,20 @@ struct simdjson_result : public westmere::implementat #define SIMDJSON_KEY_SELECTOR_HAS_LSX 0 #endif +// Clang 15 and earlier reject a call to a consteval function from within a +// consteval function template when an argument refers to one of the caller's +// reference parameters ("function parameter 'keys' with unknown value cannot +// be used in a constant expression"). With those compilers, the helpers below +// are merely constexpr: the perfect-hash tables are still computed at compile +// time because they initialize static constexpr data members. +#ifndef SIMDJSON_KEY_SELECTOR_CONSTEVAL +#if defined(__clang__) && ((defined(__apple_build_version__) && __apple_build_version__ < 15000000) || (!defined(__apple_build_version__) && __clang_major__ < 16)) + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL constexpr +#else + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL consteval +#endif +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS namespace simdjson { @@ -173003,7 +174090,7 @@ constexpr std::size_t char_at(std::string_view key, std::size_t pos) noexcept { // lengths differ modulo the table size are separated by the length term in the // hash, so they need no position coverage. template -consteval std::size_t count_undistinguished_pairs( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t count_undistinguished_pairs( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -173026,7 +174113,7 @@ consteval std::size_t count_undistinguished_pairs( } template -consteval bool positions_distinguish( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool positions_distinguish( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -173036,7 +174123,7 @@ consteval bool positions_distinguish( // Number of distinct (length % modulus, char_at(key, pos)) pairs at a position. template -consteval std::size_t discriminating_power( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t discriminating_power( const std::array& keys, std::size_t pos, std::size_t modulus) { @@ -173060,7 +174147,7 @@ consteval std::size_t discriminating_power( } template -consteval std::size_t max_key_length(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t max_key_length(const std::array& keys) { std::size_t m = 0; for (std::size_t i = 0; i < N; ++i) { if (keys[i].size() > m) { m = keys[i].size(); } @@ -173070,7 +174157,7 @@ consteval std::size_t max_key_length(const std::array& keys // Bounded backtracking DFS for a minimal set of distinguishing positions. template -consteval bool backtracking_search( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool backtracking_search( const std::array& keys, const std::size_t* candidates, std::size_t num_candidates, @@ -173121,7 +174208,7 @@ consteval bool backtracking_search( // Phase 1: select character positions that distinguish all colliding pairs. template -consteval std::size_t select_positions( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t select_positions( const std::array& keys, std::array& positions, std::size_t modulus) { @@ -173200,7 +174287,7 @@ struct phf_result { // (position, character) symbol at a time; never revisits a value. Equivalence // classes (keys sharing the same undetermined symbols) keep the search cheap. template -consteval bool try_generate_gperf( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_generate_gperf( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -173348,7 +174435,7 @@ consteval bool try_generate_gperf( } template -consteval bool try_compute_phf(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -173367,7 +174454,7 @@ consteval bool try_compute_phf(const std::array& keys, phf_ } template -consteval bool try_gperf_po2(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_gperf_po2(const std::array& keys, phf_result& result) { if (try_compute_phf(keys, result)) { return true; } constexpr std::size_t NextM = M * 2; if constexpr (NextM <= MaxM) { return try_gperf_po2(keys, result); } @@ -173402,7 +174489,7 @@ constexpr std::size_t hd_key_hash_4(std::string_view key) noexcept { } template -consteval bool try_hash_and_displace( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_hash_and_displace( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -173502,7 +174589,7 @@ consteval bool try_hash_and_displace( } template -consteval bool try_compute_phf_hd(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf_hd(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -173521,7 +174608,7 @@ consteval bool try_compute_phf_hd(const std::array& keys, p } template -consteval phf_result compute_phf_hd_po2(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf_hd_po2(const std::array& keys) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); phf_result result{}; if (try_compute_phf_hd(keys, result)) { return result; } @@ -173537,7 +174624,7 @@ consteval phf_result compute_phf_hd_po2(const std::array // Compute a perfect hash for `keys`: try gperf at power-of-two sizes (capped so // the runtime tables stay within uint8 indices), then fall back to H&D. template -consteval phf_result compute_phf(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf(const std::array& keys) { constexpr std::size_t StartM = next_power_of_2(N); constexpr std::size_t GPERF_MAX_TABLE = phf_result::MAX_TABLE_SIZE < 256 ? phf_result::MAX_TABLE_SIZE : 256; @@ -173574,7 +174661,7 @@ constexpr std::size_t compute_max_key_len(const std::array& // Validate keys and build the runtime tables from the computed perfect hash. template -consteval phf_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_data build_phf_data(const std::array& keys, const phf_result& result) { for (std::size_t i = 0; i < N; ++i) { if (keys[i].empty()) { compile_time_error("empty keys are not allowed in key_selector"); } @@ -173883,7 +174970,7 @@ constexpr unsigned window_value(const std::array& keys, } template -consteval window_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL window_data compute_window(const std::array& keys) { window_data out{}; @@ -173968,7 +175055,7 @@ match_window_candidate(const char* p, std::uint8_t ki, // --- describe() string helpers (constexpr; no std::to_string, which is not) --- // Append the decimal form of v to s. -SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { +inline SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { if (v == 0) { s.push_back('0'); return; } char buf[20]; std::size_t n = 0; @@ -173978,7 +175065,7 @@ SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { // Append a byte as its decimal value, plus the printable character in quotes // when it is in the printable ASCII range (e.g. "110 ('n')"). -SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { +inline SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { append_uint(s, b); if (b >= 0x20 && b < 0x7f) { s += " ('"; @@ -176819,30 +177906,36 @@ inline error_code array::for_each_at_path_with_wildcard(std::string_view json_pa if (remaining_path.empty()) { callback(val); } else { - error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); - if(err) { return err; } + // An element that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { // Specific index case in which we access the element at the given index - size_t idx = 0; - for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } - idx = idx*10 + (c - '0'); } - - auto element = at(idx); + // Rejects leading zeros and indexes that overflow size_t, as DOM does. + size_t idx; + size_t idx_length; + error_code error = internal::parse_json_pointer_array_index(key, idx, idx_length); value val; - SIMDJSON_TRY(element.get(val)); + if (!error) { error = at(idx).get(val); } + if (error) { + if (error == INDEX_OUT_OF_BOUNDS && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()){ callback(val); return SUCCESS; } else { - return element.for_each_at_path_with_wildcard(remaining_path, callback); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -181153,13 +182246,21 @@ inline error_code object::for_each_at_path_with_wildcard(std::string_view json_p if (remaining_path.empty()) { callback(val); } else { - SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); + // A field that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { value val; - SIMDJSON_TRY(find_field(key).get(val)); + error_code error = find_field(key).get(val); + if (error) { + if (error == NO_SUCH_FIELD && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()) { callback(val); @@ -191057,6 +192158,20 @@ struct simdjson_result : public lsx::implementation_simdjs #define SIMDJSON_KEY_SELECTOR_HAS_LSX 0 #endif +// Clang 15 and earlier reject a call to a consteval function from within a +// consteval function template when an argument refers to one of the caller's +// reference parameters ("function parameter 'keys' with unknown value cannot +// be used in a constant expression"). With those compilers, the helpers below +// are merely constexpr: the perfect-hash tables are still computed at compile +// time because they initialize static constexpr data members. +#ifndef SIMDJSON_KEY_SELECTOR_CONSTEVAL +#if defined(__clang__) && ((defined(__apple_build_version__) && __apple_build_version__ < 15000000) || (!defined(__apple_build_version__) && __clang_major__ < 16)) + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL constexpr +#else + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL consteval +#endif +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS namespace simdjson { @@ -191111,7 +192226,7 @@ constexpr std::size_t char_at(std::string_view key, std::size_t pos) noexcept { // lengths differ modulo the table size are separated by the length term in the // hash, so they need no position coverage. template -consteval std::size_t count_undistinguished_pairs( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t count_undistinguished_pairs( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -191134,7 +192249,7 @@ consteval std::size_t count_undistinguished_pairs( } template -consteval bool positions_distinguish( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool positions_distinguish( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -191144,7 +192259,7 @@ consteval bool positions_distinguish( // Number of distinct (length % modulus, char_at(key, pos)) pairs at a position. template -consteval std::size_t discriminating_power( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t discriminating_power( const std::array& keys, std::size_t pos, std::size_t modulus) { @@ -191168,7 +192283,7 @@ consteval std::size_t discriminating_power( } template -consteval std::size_t max_key_length(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t max_key_length(const std::array& keys) { std::size_t m = 0; for (std::size_t i = 0; i < N; ++i) { if (keys[i].size() > m) { m = keys[i].size(); } @@ -191178,7 +192293,7 @@ consteval std::size_t max_key_length(const std::array& keys // Bounded backtracking DFS for a minimal set of distinguishing positions. template -consteval bool backtracking_search( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool backtracking_search( const std::array& keys, const std::size_t* candidates, std::size_t num_candidates, @@ -191229,7 +192344,7 @@ consteval bool backtracking_search( // Phase 1: select character positions that distinguish all colliding pairs. template -consteval std::size_t select_positions( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t select_positions( const std::array& keys, std::array& positions, std::size_t modulus) { @@ -191308,7 +192423,7 @@ struct phf_result { // (position, character) symbol at a time; never revisits a value. Equivalence // classes (keys sharing the same undetermined symbols) keep the search cheap. template -consteval bool try_generate_gperf( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_generate_gperf( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -191456,7 +192571,7 @@ consteval bool try_generate_gperf( } template -consteval bool try_compute_phf(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -191475,7 +192590,7 @@ consteval bool try_compute_phf(const std::array& keys, phf_ } template -consteval bool try_gperf_po2(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_gperf_po2(const std::array& keys, phf_result& result) { if (try_compute_phf(keys, result)) { return true; } constexpr std::size_t NextM = M * 2; if constexpr (NextM <= MaxM) { return try_gperf_po2(keys, result); } @@ -191510,7 +192625,7 @@ constexpr std::size_t hd_key_hash_4(std::string_view key) noexcept { } template -consteval bool try_hash_and_displace( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_hash_and_displace( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -191610,7 +192725,7 @@ consteval bool try_hash_and_displace( } template -consteval bool try_compute_phf_hd(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf_hd(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -191629,7 +192744,7 @@ consteval bool try_compute_phf_hd(const std::array& keys, p } template -consteval phf_result compute_phf_hd_po2(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf_hd_po2(const std::array& keys) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); phf_result result{}; if (try_compute_phf_hd(keys, result)) { return result; } @@ -191645,7 +192760,7 @@ consteval phf_result compute_phf_hd_po2(const std::array // Compute a perfect hash for `keys`: try gperf at power-of-two sizes (capped so // the runtime tables stay within uint8 indices), then fall back to H&D. template -consteval phf_result compute_phf(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf(const std::array& keys) { constexpr std::size_t StartM = next_power_of_2(N); constexpr std::size_t GPERF_MAX_TABLE = phf_result::MAX_TABLE_SIZE < 256 ? phf_result::MAX_TABLE_SIZE : 256; @@ -191682,7 +192797,7 @@ constexpr std::size_t compute_max_key_len(const std::array& // Validate keys and build the runtime tables from the computed perfect hash. template -consteval phf_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_data build_phf_data(const std::array& keys, const phf_result& result) { for (std::size_t i = 0; i < N; ++i) { if (keys[i].empty()) { compile_time_error("empty keys are not allowed in key_selector"); } @@ -191991,7 +193106,7 @@ constexpr unsigned window_value(const std::array& keys, } template -consteval window_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL window_data compute_window(const std::array& keys) { window_data out{}; @@ -192076,7 +193191,7 @@ match_window_candidate(const char* p, std::uint8_t ki, // --- describe() string helpers (constexpr; no std::to_string, which is not) --- // Append the decimal form of v to s. -SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { +inline SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { if (v == 0) { s.push_back('0'); return; } char buf[20]; std::size_t n = 0; @@ -192086,7 +193201,7 @@ SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { // Append a byte as its decimal value, plus the printable character in quotes // when it is in the printable ASCII range (e.g. "110 ('n')"). -SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { +inline SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { append_uint(s, b); if (b >= 0x20 && b < 0x7f) { s += " ('"; @@ -194927,30 +196042,36 @@ inline error_code array::for_each_at_path_with_wildcard(std::string_view json_pa if (remaining_path.empty()) { callback(val); } else { - error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); - if(err) { return err; } + // An element that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { // Specific index case in which we access the element at the given index - size_t idx = 0; - for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } - idx = idx*10 + (c - '0'); } - - auto element = at(idx); + // Rejects leading zeros and indexes that overflow size_t, as DOM does. + size_t idx; + size_t idx_length; + error_code error = internal::parse_json_pointer_array_index(key, idx, idx_length); value val; - SIMDJSON_TRY(element.get(val)); + if (!error) { error = at(idx).get(val); } + if (error) { + if (error == INDEX_OUT_OF_BOUNDS && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()){ callback(val); return SUCCESS; } else { - return element.for_each_at_path_with_wildcard(remaining_path, callback); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -199261,13 +200382,21 @@ inline error_code object::for_each_at_path_with_wildcard(std::string_view json_p if (remaining_path.empty()) { callback(val); } else { - SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); + // A field that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { value val; - SIMDJSON_TRY(find_field(key).get(val)); + error_code error = find_field(key).get(val); + if (error) { + if (error == NO_SUCH_FIELD && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()) { callback(val); @@ -209188,6 +210317,20 @@ struct simdjson_result : public lasx::implementation_simd #define SIMDJSON_KEY_SELECTOR_HAS_LSX 0 #endif +// Clang 15 and earlier reject a call to a consteval function from within a +// consteval function template when an argument refers to one of the caller's +// reference parameters ("function parameter 'keys' with unknown value cannot +// be used in a constant expression"). With those compilers, the helpers below +// are merely constexpr: the perfect-hash tables are still computed at compile +// time because they initialize static constexpr data members. +#ifndef SIMDJSON_KEY_SELECTOR_CONSTEVAL +#if defined(__clang__) && ((defined(__apple_build_version__) && __apple_build_version__ < 15000000) || (!defined(__apple_build_version__) && __clang_major__ < 16)) + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL constexpr +#else + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL consteval +#endif +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS namespace simdjson { @@ -209242,7 +210385,7 @@ constexpr std::size_t char_at(std::string_view key, std::size_t pos) noexcept { // lengths differ modulo the table size are separated by the length term in the // hash, so they need no position coverage. template -consteval std::size_t count_undistinguished_pairs( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t count_undistinguished_pairs( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -209265,7 +210408,7 @@ consteval std::size_t count_undistinguished_pairs( } template -consteval bool positions_distinguish( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool positions_distinguish( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -209275,7 +210418,7 @@ consteval bool positions_distinguish( // Number of distinct (length % modulus, char_at(key, pos)) pairs at a position. template -consteval std::size_t discriminating_power( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t discriminating_power( const std::array& keys, std::size_t pos, std::size_t modulus) { @@ -209299,7 +210442,7 @@ consteval std::size_t discriminating_power( } template -consteval std::size_t max_key_length(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t max_key_length(const std::array& keys) { std::size_t m = 0; for (std::size_t i = 0; i < N; ++i) { if (keys[i].size() > m) { m = keys[i].size(); } @@ -209309,7 +210452,7 @@ consteval std::size_t max_key_length(const std::array& keys // Bounded backtracking DFS for a minimal set of distinguishing positions. template -consteval bool backtracking_search( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool backtracking_search( const std::array& keys, const std::size_t* candidates, std::size_t num_candidates, @@ -209360,7 +210503,7 @@ consteval bool backtracking_search( // Phase 1: select character positions that distinguish all colliding pairs. template -consteval std::size_t select_positions( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t select_positions( const std::array& keys, std::array& positions, std::size_t modulus) { @@ -209439,7 +210582,7 @@ struct phf_result { // (position, character) symbol at a time; never revisits a value. Equivalence // classes (keys sharing the same undetermined symbols) keep the search cheap. template -consteval bool try_generate_gperf( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_generate_gperf( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -209587,7 +210730,7 @@ consteval bool try_generate_gperf( } template -consteval bool try_compute_phf(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -209606,7 +210749,7 @@ consteval bool try_compute_phf(const std::array& keys, phf_ } template -consteval bool try_gperf_po2(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_gperf_po2(const std::array& keys, phf_result& result) { if (try_compute_phf(keys, result)) { return true; } constexpr std::size_t NextM = M * 2; if constexpr (NextM <= MaxM) { return try_gperf_po2(keys, result); } @@ -209641,7 +210784,7 @@ constexpr std::size_t hd_key_hash_4(std::string_view key) noexcept { } template -consteval bool try_hash_and_displace( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_hash_and_displace( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -209741,7 +210884,7 @@ consteval bool try_hash_and_displace( } template -consteval bool try_compute_phf_hd(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf_hd(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -209760,7 +210903,7 @@ consteval bool try_compute_phf_hd(const std::array& keys, p } template -consteval phf_result compute_phf_hd_po2(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf_hd_po2(const std::array& keys) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); phf_result result{}; if (try_compute_phf_hd(keys, result)) { return result; } @@ -209776,7 +210919,7 @@ consteval phf_result compute_phf_hd_po2(const std::array // Compute a perfect hash for `keys`: try gperf at power-of-two sizes (capped so // the runtime tables stay within uint8 indices), then fall back to H&D. template -consteval phf_result compute_phf(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf(const std::array& keys) { constexpr std::size_t StartM = next_power_of_2(N); constexpr std::size_t GPERF_MAX_TABLE = phf_result::MAX_TABLE_SIZE < 256 ? phf_result::MAX_TABLE_SIZE : 256; @@ -209813,7 +210956,7 @@ constexpr std::size_t compute_max_key_len(const std::array& // Validate keys and build the runtime tables from the computed perfect hash. template -consteval phf_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_data build_phf_data(const std::array& keys, const phf_result& result) { for (std::size_t i = 0; i < N; ++i) { if (keys[i].empty()) { compile_time_error("empty keys are not allowed in key_selector"); } @@ -210122,7 +211265,7 @@ constexpr unsigned window_value(const std::array& keys, } template -consteval window_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL window_data compute_window(const std::array& keys) { window_data out{}; @@ -210207,7 +211350,7 @@ match_window_candidate(const char* p, std::uint8_t ki, // --- describe() string helpers (constexpr; no std::to_string, which is not) --- // Append the decimal form of v to s. -SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { +inline SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { if (v == 0) { s.push_back('0'); return; } char buf[20]; std::size_t n = 0; @@ -210217,7 +211360,7 @@ SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { // Append a byte as its decimal value, plus the printable character in quotes // when it is in the printable ASCII range (e.g. "110 ('n')"). -SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { +inline SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { append_uint(s, b); if (b >= 0x20 && b < 0x7f) { s += " ('"; @@ -213058,30 +214201,36 @@ inline error_code array::for_each_at_path_with_wildcard(std::string_view json_pa if (remaining_path.empty()) { callback(val); } else { - error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); - if(err) { return err; } + // An element that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { // Specific index case in which we access the element at the given index - size_t idx = 0; - for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } - idx = idx*10 + (c - '0'); } - - auto element = at(idx); + // Rejects leading zeros and indexes that overflow size_t, as DOM does. + size_t idx; + size_t idx_length; + error_code error = internal::parse_json_pointer_array_index(key, idx, idx_length); value val; - SIMDJSON_TRY(element.get(val)); + if (!error) { error = at(idx).get(val); } + if (error) { + if (error == INDEX_OUT_OF_BOUNDS && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()){ callback(val); return SUCCESS; } else { - return element.for_each_at_path_with_wildcard(remaining_path, callback); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -217392,13 +218541,21 @@ inline error_code object::for_each_at_path_with_wildcard(std::string_view json_p if (remaining_path.empty()) { callback(val); } else { - SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); + // A field that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { value val; - SIMDJSON_TRY(find_field(key).get(val)); + error_code error = find_field(key).get(val); + if (error) { + if (error == NO_SUCH_FIELD && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()) { callback(val); @@ -227322,6 +228479,20 @@ struct simdjson_result : public rvv_vls::implementatio #define SIMDJSON_KEY_SELECTOR_HAS_LSX 0 #endif +// Clang 15 and earlier reject a call to a consteval function from within a +// consteval function template when an argument refers to one of the caller's +// reference parameters ("function parameter 'keys' with unknown value cannot +// be used in a constant expression"). With those compilers, the helpers below +// are merely constexpr: the perfect-hash tables are still computed at compile +// time because they initialize static constexpr data members. +#ifndef SIMDJSON_KEY_SELECTOR_CONSTEVAL +#if defined(__clang__) && ((defined(__apple_build_version__) && __apple_build_version__ < 15000000) || (!defined(__apple_build_version__) && __clang_major__ < 16)) + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL constexpr +#else + #define SIMDJSON_KEY_SELECTOR_CONSTEVAL consteval +#endif +#endif + #if SIMDJSON_SUPPORTS_CONCEPTS namespace simdjson { @@ -227376,7 +228547,7 @@ constexpr std::size_t char_at(std::string_view key, std::size_t pos) noexcept { // lengths differ modulo the table size are separated by the length term in the // hash, so they need no position coverage. template -consteval std::size_t count_undistinguished_pairs( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t count_undistinguished_pairs( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -227399,7 +228570,7 @@ consteval std::size_t count_undistinguished_pairs( } template -consteval bool positions_distinguish( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool positions_distinguish( const std::array& keys, const std::size_t* positions, std::size_t num_positions, @@ -227409,7 +228580,7 @@ consteval bool positions_distinguish( // Number of distinct (length % modulus, char_at(key, pos)) pairs at a position. template -consteval std::size_t discriminating_power( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t discriminating_power( const std::array& keys, std::size_t pos, std::size_t modulus) { @@ -227433,7 +228604,7 @@ consteval std::size_t discriminating_power( } template -consteval std::size_t max_key_length(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t max_key_length(const std::array& keys) { std::size_t m = 0; for (std::size_t i = 0; i < N; ++i) { if (keys[i].size() > m) { m = keys[i].size(); } @@ -227443,7 +228614,7 @@ consteval std::size_t max_key_length(const std::array& keys // Bounded backtracking DFS for a minimal set of distinguishing positions. template -consteval bool backtracking_search( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool backtracking_search( const std::array& keys, const std::size_t* candidates, std::size_t num_candidates, @@ -227494,7 +228665,7 @@ consteval bool backtracking_search( // Phase 1: select character positions that distinguish all colliding pairs. template -consteval std::size_t select_positions( +SIMDJSON_KEY_SELECTOR_CONSTEVAL std::size_t select_positions( const std::array& keys, std::array& positions, std::size_t modulus) { @@ -227573,7 +228744,7 @@ struct phf_result { // (position, character) symbol at a time; never revisits a value. Equivalence // classes (keys sharing the same undetermined symbols) keep the search cheap. template -consteval bool try_generate_gperf( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_generate_gperf( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -227721,7 +228892,7 @@ consteval bool try_generate_gperf( } template -consteval bool try_compute_phf(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -227740,7 +228911,7 @@ consteval bool try_compute_phf(const std::array& keys, phf_ } template -consteval bool try_gperf_po2(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_gperf_po2(const std::array& keys, phf_result& result) { if (try_compute_phf(keys, result)) { return true; } constexpr std::size_t NextM = M * 2; if constexpr (NextM <= MaxM) { return try_gperf_po2(keys, result); } @@ -227775,7 +228946,7 @@ constexpr std::size_t hd_key_hash_4(std::string_view key) noexcept { } template -consteval bool try_hash_and_displace( +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_hash_and_displace( const std::array& keys, std::array, MAX_POSITIONS>& asso_values, std::size_t& num_positions, @@ -227875,7 +229046,7 @@ consteval bool try_hash_and_displace( } template -consteval bool try_compute_phf_hd(const std::array& keys, phf_result& result) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL bool try_compute_phf_hd(const std::array& keys, phf_result& result) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); std::array, MAX_POSITIONS> asso{}; std::size_t npos{}; @@ -227894,7 +229065,7 @@ consteval bool try_compute_phf_hd(const std::array& keys, p } template -consteval phf_result compute_phf_hd_po2(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf_hd_po2(const std::array& keys) { static_assert(M <= phf_result::MAX_TABLE_SIZE, "Table size M exceeds maximum"); phf_result result{}; if (try_compute_phf_hd(keys, result)) { return result; } @@ -227910,7 +229081,7 @@ consteval phf_result compute_phf_hd_po2(const std::array // Compute a perfect hash for `keys`: try gperf at power-of-two sizes (capped so // the runtime tables stay within uint8 indices), then fall back to H&D. template -consteval phf_result compute_phf(const std::array& keys) { +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_result compute_phf(const std::array& keys) { constexpr std::size_t StartM = next_power_of_2(N); constexpr std::size_t GPERF_MAX_TABLE = phf_result::MAX_TABLE_SIZE < 256 ? phf_result::MAX_TABLE_SIZE : 256; @@ -227947,7 +229118,7 @@ constexpr std::size_t compute_max_key_len(const std::array& // Validate keys and build the runtime tables from the computed perfect hash. template -consteval phf_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL phf_data build_phf_data(const std::array& keys, const phf_result& result) { for (std::size_t i = 0; i < N; ++i) { if (keys[i].empty()) { compile_time_error("empty keys are not allowed in key_selector"); } @@ -228256,7 +229427,7 @@ constexpr unsigned window_value(const std::array& keys, } template -consteval window_data +SIMDJSON_KEY_SELECTOR_CONSTEVAL window_data compute_window(const std::array& keys) { window_data out{}; @@ -228341,7 +229512,7 @@ match_window_candidate(const char* p, std::uint8_t ki, // --- describe() string helpers (constexpr; no std::to_string, which is not) --- // Append the decimal form of v to s. -SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { +inline SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { if (v == 0) { s.push_back('0'); return; } char buf[20]; std::size_t n = 0; @@ -228351,7 +229522,7 @@ SIMDJSON_CONSTEXPR_STRING void append_uint(std::string& s, std::size_t v) { // Append a byte as its decimal value, plus the printable character in quotes // when it is in the printable ASCII range (e.g. "110 ('n')"). -SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { +inline SIMDJSON_CONSTEXPR_STRING void append_byte(std::string& s, unsigned b) { append_uint(s, b); if (b >= 0x20 && b < 0x7f) { s += " ('"; @@ -231192,30 +232363,36 @@ inline error_code array::for_each_at_path_with_wildcard(std::string_view json_pa if (remaining_path.empty()) { callback(val); } else { - error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); - if(err) { return err; } + // An element that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { // Specific index case in which we access the element at the given index - size_t idx = 0; - for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } - idx = idx*10 + (c - '0'); } - - auto element = at(idx); + // Rejects leading zeros and indexes that overflow size_t, as DOM does. + size_t idx; + size_t idx_length; + error_code error = internal::parse_json_pointer_array_index(key, idx, idx_length); value val; - SIMDJSON_TRY(element.get(val)); + if (!error) { error = at(idx).get(val); } + if (error) { + if (error == INDEX_OUT_OF_BOUNDS && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()){ callback(val); return SUCCESS; } else { - return element.for_each_at_path_with_wildcard(remaining_path, callback); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -235526,13 +236703,21 @@ inline error_code object::for_each_at_path_with_wildcard(std::string_view json_p if (remaining_path.empty()) { callback(val); } else { - SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); + // A field that does not match the rest of the path is skipped. + error_code err = val.for_each_at_path_with_wildcard(remaining_path, callback); + if (err && !internal::is_matching_failure_error(err)) { return err; } } } return SUCCESS; } else { value val; - SIMDJSON_TRY(find_field(key).get(val)); + error_code error = find_field(key).get(val); + if (error) { + if (error == NO_SUCH_FIELD && internal::json_path_has_wildcard(remaining_path)) { + return SUCCESS; + } + return error; + } if (remaining_path.empty()) { callback(val); @@ -244286,10 +245471,10 @@ simdjson_fastfloat_really_inline bool rounds_to_nearest() noexcept { // https://stackoverflow.com/questions/46079446/is-there-a-warning-for-floating-point-equality-checking-in-visual-studio-2013 #elif defined(__clang__) #pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wfloat-equal" +SIMDJSON_DISABLE_GCC_WARNING(-Wfloat-equal) #elif defined(__GNUC__) #pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wfloat-equal" +SIMDJSON_DISABLE_GCC_WARNING(-Wfloat-equal) #endif return (fmini + 1.0f == 1.0f - fmini); #ifdef SIMDJSON_FASTFLOAT_VISUAL_STUDIO @@ -244530,7 +245715,7 @@ from_chars_float_advanced(UC const *first, UC const *last, T &value, #ifdef __clang__ #pragma clang diagnostic push #if (!defined(__APPLE_CC__) && __clang_major__ >= 10) || (__clang_major__ >= 13) -#pragma clang diagnostic ignored "-Wc++20-extensions" +SIMDJSON_DISABLE_GCC_WARNING(-Wc++20-extensions) #endif #endif if simdjson_fastfloat_unlikely (pns.too_many_digits) { From 30dbe1487a3c180d7aa5040866c9bbf46d807f16 Mon Sep 17 00:00:00 2001 From: Donghoon Kang Date: Tue, 20 Oct 2026 11:50:02 +0900 Subject: [PATCH 065/331] ffi: add binary parameter to internal binding type Add the optional binary parameter to the DynamicLibrary constructor declaration to match the native binding introduced in #65909. Signed-off-by: HoonDongKang PR-URL: https://github.com/nodejs/node/pull/66502 Refs: https://github.com/nodejs/node/pull/65909 Refs: https://github.com/nodejs/node/pull/65734 Reviewed-By: Matteo Collina Reviewed-By: Paolo Insogna --- typings/internalBinding/ffi.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/typings/internalBinding/ffi.d.ts b/typings/internalBinding/ffi.d.ts index 0294d1987b0..bebf2afa24d 100644 --- a/typings/internalBinding/ffi.d.ts +++ b/typings/internalBinding/ffi.d.ts @@ -32,7 +32,7 @@ declare namespace InternalFFIBinding { } class DynamicLibrary { - constructor(path: string | null); + constructor(path: string | null, binary?: ArrayBufferView); readonly path: string; readonly symbols: Record; From eb177050995b11b571ce4b1486fd1e99583527ac Mon Sep 17 00:00:00 2001 From: Donghoon Kang Date: Tue, 20 Oct 2026 11:50:14 +0900 Subject: [PATCH 066/331] ffi: add getFunction cache-miss benchmark MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The existing get-function benchmark reuses the callable cached during warmup, so it no longer measures trampoline creation. Add a cache-miss benchmark that resolves a function once per library instance. Construct the instances before timing to exclude library loading while including symbol resolution, signature preparation, and callable creation. Update the existing benchmark comments to describe cache-hit lookups. Signed-off-by: HoonDongKang Assisted-by: Codex:Astra-medium PR-URL: https://github.com/nodejs/node/pull/66456 Refs: https://github.com/nodejs/node/pull/64969 Refs: https://github.com/nodejs/node/pull/64971 Reviewed-By: Anna Henningsen Reviewed-By: Gürgün Dayıoğlu --- benchmark/ffi/get-function-cache-miss.js | 48 ++++++++++++++++++++++++ benchmark/ffi/get-function.js | 15 +++----- 2 files changed, 53 insertions(+), 10 deletions(-) create mode 100644 benchmark/ffi/get-function-cache-miss.js diff --git a/benchmark/ffi/get-function-cache-miss.js b/benchmark/ffi/get-function-cache-miss.js new file mode 100644 index 00000000000..9cb559c6ecb --- /dev/null +++ b/benchmark/ffi/get-function-cache-miss.js @@ -0,0 +1,48 @@ +'use strict'; + +// Measures the first getFunction() call on each library instance. This includes +// symbol resolution, signature preparation, and callable creation. +// The `fast` variant is eligible for a generated trampoline on supported +// platforms; `slow` exceeds the x86_64 register budget and falls back. +// Library construction and closing are outside the measured region. + +const common = require('../common.js'); +const { DynamicLibrary } = require('node:ffi'); +const { libraryPath, ensureFixtureLibrary } = require('./common.js'); + +const bench = common.createBenchmark(main, { + signature: ['fast', 'slow'], + n: [1e3], +}); + +ensureFixtureLibrary(); + +const signatures = { + fast: { name: 'add_i32', return: 'i32', arguments: ['i32', 'i32'] }, + slow: { + name: 'sum_8_i32', + return: 'i32', + arguments: ['i32', 'i32', 'i32', 'i32', 'i32', 'i32', 'i32', 'i32'], + }, +}; + +function main({ n, signature }) { + const { name, ...definition } = signatures[signature]; + + // Warm up one-time initialization without populating the measured caches. + const warmup = new DynamicLibrary(libraryPath); + warmup.getFunction(name, definition); + warmup.close(); + + // Each instance has its own cache, so its first lookup creates a callable. + const libraries = Array.from({ length: n }, () => new DynamicLibrary(libraryPath)); + const functions = new Array(n); + + bench.start(); + for (let i = 0; i < n; ++i) + functions[i] = libraries[i].getFunction(name, definition); + bench.end(n); + + for (const lib of libraries) + lib.close(); +} diff --git a/benchmark/ffi/get-function.js b/benchmark/ffi/get-function.js index 939c1630ab6..7b885f1c6bd 100644 --- a/benchmark/ffi/get-function.js +++ b/benchmark/ffi/get-function.js @@ -1,13 +1,9 @@ 'use strict'; -// Measures symbol resolution rather than call throughput. Creating a callable -// for a fast-eligible signature emits a native trampoline, so this benchmark -// covers the trampoline allocation path that the call benchmarks never reach. -// -// The `fast` variant is eligible for a generated trampoline; `slow` exceeds the -// x86_64 register budget and falls back, so it resolves without allocating one. -// Comparing the two isolates trampoline creation cost from the rest of symbol -// resolution. +// Measures repeated getFunction() calls with a cached callable rather than +// call throughput. The warmup populates the cache for the measured symbol. +// See get-function-cache-miss.js for first-time resolution, including trampoline +// creation for fast-eligible signatures on supported platforms. const common = require('../common.js'); const { DynamicLibrary } = require('node:ffi'); @@ -33,8 +29,7 @@ function main({ n, signature }) { const { name, ...definition } = signatures[signature]; const lib = new DynamicLibrary(libraryPath); - // Warm up one-time initialization (libffi setup, executable memory probe) so - // it is not attributed to the measured resolutions. + // Populate the callable cache before measuring repeated lookups. lib.getFunction(name, definition); bench.start(); From 3f5f257a6012e0dac89c5c489c5e2d8ebacd86fc Mon Sep 17 00:00:00 2001 From: Donghoon Kang Date: Tue, 20 Oct 2026 13:54:54 +0900 Subject: [PATCH 067/331] util: fix inspecting URL subclass prototypes Check the URL private field brand before accessing href to avoid throwing when inspecting URL subclass prototypes. Assisted-by: Codex:6.1SolHigh Signed-off-by: HoonDongKang PR-URL: https://github.com/nodejs/node/pull/66822 Fixes: https://github.com/nodejs/node/issues/66821 Reviewed-By: Antoine du Hamel Reviewed-By: Matthew Aitken --- lib/internal/util/inspect.js | 2 +- test/parallel/test-util-inspect-url.js | 35 ++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 1 deletion(-) create mode 100644 test/parallel/test-util-inspect-url.js diff --git a/lib/internal/util/inspect.js b/lib/internal/util/inspect.js index 622dab4eae8..3d36c5793be 100644 --- a/lib/internal/util/inspect.js +++ b/lib/internal/util/inspect.js @@ -205,7 +205,7 @@ function pathToFileUrlHref(filepath) { function isURL(value) { internalUrl ??= require('internal/url'); - return typeof value.href === 'string' && value instanceof internalUrl.URL; + return internalUrl.isURLInstance(value) && typeof value.href === 'string'; } const builtInObjects = new SafeSet( diff --git a/test/parallel/test-util-inspect-url.js b/test/parallel/test-util-inspect-url.js new file mode 100644 index 00000000000..3635e9ab9f7 --- /dev/null +++ b/test/parallel/test-util-inspect-url.js @@ -0,0 +1,35 @@ +'use strict'; + +require('../common'); +const assert = require('assert'); +const { format, inspect } = require('util'); + +class TestURL extends URL {} + +assert.strictEqual(inspect(TestURL.prototype), 'URL {}'); +assert.strictEqual( + inspect(TestURL.prototype, { customInspect: false }), + 'URL {}', +); + +// Inspecting hidden properties must not throw when reaching the prototype. +inspect(TestURL, { showHidden: true }); +inspect({ TestURL }, { showHidden: true }); +format('%o', { TestURL }); + +const url = new TestURL('https://example.org/'); +assert.strictEqual( + inspect(url, { customInspect: false }), + 'https://example.org/', +); + +class NonStringURL extends URL { + get href() { + return undefined; + } +} + +assert.strictEqual( + inspect(new NonStringURL('https://example.org/'), { customInspect: false }), + 'NonStringURL [URL] {}', +); From 37b4435191aabf5cf0d034a881d1264d910c47ee Mon Sep 17 00:00:00 2001 From: Efe Karasakal Date: Tue, 20 Oct 2026 13:01:08 +0200 Subject: [PATCH 068/331] quic: truncate CONNECTION_CLOSE frame reason field Signed-off-by: Efe Karasakal PR-URL: https://github.com/nodejs/node/pull/66644 Reviewed-By: Tim Perry --- doc/api/quic.md | 7 +- src/quic/data.cc | 17 +++ src/quic/data.h | 2 + src/quic/packet.cc | 3 +- src/quic/session.cc | 10 +- ...t-quic-session-close-reason-truncation.mjs | 110 ++++++++++++++++++ 6 files changed, 139 insertions(+), 10 deletions(-) create mode 100644 test/parallel/test-quic-session-close-reason-truncation.mjs diff --git a/doc/api/quic.md b/doc/api/quic.md index cc05f2907cf..8e047bb58a9 100644 --- a/doc/api/quic.md +++ b/doc/api/quic.md @@ -973,7 +973,8 @@ added: v23.8.0 is application-specific. **Default:** `'transport'`. * `reason` {string} An optional human-readable reason string included in the `CONNECTION_CLOSE` frame. Per RFC 9000, this is for diagnostic purposes - only and should not be used for machine-readable error descriptions. + only and should not be used for machine-readable error descriptions. If its + UTF-8 encoding exceeds 256 bytes, it is truncated to at most 256 bytes. * Returns: {Promise} Initiate a graceful close of the session. Existing streams will be allowed @@ -1048,7 +1049,9 @@ added: v23.8.0 * `type` {string} Either `'transport'` or `'application'`. **Default:** `'transport'`. * `reason` {string} An optional human-readable reason string included in - the `CONNECTION_CLOSE` frame. + the `CONNECTION_CLOSE` frame. Per RFC 9000, this is for diagnostic purposes + only and should not be used for machine-readable error descriptions. If its + UTF-8 encoding exceeds 256 bytes, it is truncated to at most 256 bytes. Immediately destroy the session. All streams will be destroyed and the session will be closed. If `error` is provided and [`session.onerror`][] is diff --git a/src/quic/data.cc b/src/quic/data.cc index f15051da498..36867390b0f 100644 --- a/src/quic/data.cc +++ b/src/quic/data.cc @@ -7,9 +7,11 @@ #include #include #include +#include #include "bindingdata.h" #include "data.h" #include "defs.h" +#include "simdutf.h" #include "util.h" namespace node { @@ -218,6 +220,9 @@ void Store::MemoryInfo(MemoryTracker* tracker) const { // ============================================================================ namespace { + +constexpr size_t kMaxConnectionCloseReasonLength = 256; + constexpr std::string_view TypeName(QuicError::Type type) { switch (type) { case QuicError::Type::APPLICATION: @@ -332,6 +337,18 @@ QuicError::operator const ngtcp2_ccerr*() const { return ptr_; } +ngtcp2_ccerr QuicError::ToNgtcp2ConnectionCloseError() const { + ngtcp2_ccerr error = *ptr_; + error.reason = reason_c_str(); + + const size_t reasonlen = + std::min(reason_.size(), kMaxConnectionCloseReasonLength); + + error.reasonlen = simdutf::trim_partial_utf8(reason_.data(), reasonlen); + + return error; +} + std::string QuicError::reason_for_liberr(int liberr) { return ngtcp2_strerror(liberr); } diff --git a/src/quic/data.h b/src/quic/data.h index 9c92a30c1dd..79d7f178a86 100644 --- a/src/quic/data.h +++ b/src/quic/data.h @@ -260,6 +260,8 @@ class QuicError final : public MemoryRetainer { operator const ngtcp2_ccerr&() const; operator const ngtcp2_ccerr*() const; + ngtcp2_ccerr ToNgtcp2ConnectionCloseError() const; + // Crypto errors are a subset of transport errors. The error code includes // the TLS alert code embedded within it. bool is_crypto_error() const; diff --git a/src/quic/packet.cc b/src/quic/packet.cc index a1ab4c7090e..00cebc5c98c 100644 --- a/src/quic/packet.cc +++ b/src/quic/packet.cc @@ -110,8 +110,9 @@ Packet::Ptr Packet::CreateConnectionClosePacket( if (!packet) return packet; ngtcp2_vec vec = *packet; + ngtcp2_ccerr wire_error = error.ToNgtcp2ConnectionCloseError(); ssize_t nwrite = ngtcp2_conn_write_connection_close( - conn, nullptr, nullptr, vec.base, vec.len, error, uv_hrtime()); + conn, nullptr, nullptr, vec.base, vec.len, &wire_error, uv_hrtime()); if (nwrite < 0) return Ptr(); packet->Truncate(static_cast(nwrite)); return packet; diff --git a/src/quic/session.cc b/src/quic/session.cc index d83c1cbb89d..ba672a3bee4 100644 --- a/src/quic/session.cc +++ b/src/quic/session.cc @@ -3680,13 +3680,9 @@ void Session::SendConnectionClose() { ngtcp2_vec vec = *packet; Path path(impl_->local_address_, impl_->remote_address_); - ssize_t nwrite = ngtcp2_conn_write_connection_close(*this, - &path, - nullptr, - vec.base, - vec.len, - impl_->last_error_, - uv_hrtime()); + ngtcp2_ccerr wire_error = impl_->last_error_.ToNgtcp2ConnectionCloseError(); + ssize_t nwrite = ngtcp2_conn_write_connection_close( + *this, &path, nullptr, vec.base, vec.len, &wire_error, uv_hrtime()); if (nwrite < 0) [[unlikely]] { return ErrorAndSilentClose(); diff --git a/test/parallel/test-quic-session-close-reason-truncation.mjs b/test/parallel/test-quic-session-close-reason-truncation.mjs new file mode 100644 index 00000000000..a2a958ae895 --- /dev/null +++ b/test/parallel/test-quic-session-close-reason-truncation.mjs @@ -0,0 +1,110 @@ +// Flags: --experimental-quic --no-warnings + +// CONNECTION_CLOSE reason strings are truncated to 256 UTF-8 bytes. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const kMaxReasonLength = 256; + +// Client close with an ASCII reason longer than the wire limit. +{ + const reason = 'a'.repeat(kMaxReasonLength + 1); + const expectedReason = reason.slice(0, kMaxReasonLength); + const serverSessionReady = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onerror = mustCall((error) => { + assert.strictEqual(error.reason, expectedReason); + }); + await serverSession.opened; + serverSessionReady.resolve(serverSession); + })); + + const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + }); + await clientSession.opened; + const serverSession = await serverSessionReady.promise; + await clientSession.close({ + code: 1n, + type: 'application', + reason, + }); + + await assert.rejects(serverSession.closed, { + code: 'ERR_QUIC_APPLICATION_ERROR', + reason: expectedReason, + }); + await serverEndpoint.close(); +} + +// Client close where truncating at the byte limit would split a UTF-8 sequence. +{ + const prefix = 'a'.repeat(kMaxReasonLength - 1); + const reason = `${prefix}€`; + const serverSessionReady = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onerror = mustCall((error) => { + assert.strictEqual(error.reason, prefix); + }); + await serverSession.opened; + serverSessionReady.resolve(serverSession); + })); + + const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + }); + await clientSession.opened; + const serverSession = await serverSessionReady.promise; + await clientSession.close({ + code: 2n, + type: 'application', + reason, + }); + + await assert.rejects(serverSession.closed, { + code: 'ERR_QUIC_APPLICATION_ERROR', + reason: prefix, + }); + await serverEndpoint.close(); +} + +// Server close exercises the server-specific CONNECTION_CLOSE packet path. +{ + const reason = 's'.repeat(kMaxReasonLength + 1); + const expectedReason = reason.slice(0, kMaxReasonLength); + const serverSessionReady = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + serverSessionReady.resolve(serverSession); + })); + + const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + onerror: mustCall((error) => { + assert.strictEqual(error.reason, expectedReason); + }), + }); + await clientSession.opened; + const serverSession = await serverSessionReady.promise; + await serverSession.close({ + code: 3n, + type: 'application', + reason, + }); + + await assert.rejects(clientSession.closed, { + code: 'ERR_QUIC_APPLICATION_ERROR', + reason: expectedReason, + }); + await serverEndpoint.close(); +} From fac766f7b24e8e6ed7e6c4ccebcf1a424da3aece Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Tue, 20 Oct 2026 14:13:35 +0200 Subject: [PATCH 069/331] build: warn on incompatible quic configure flags MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/66754 Reviewed-By: Chengzhong Wu Reviewed-By: Gürgün Dayıoğlu --- configure.py | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/configure.py b/configure.py index fb742692f53..efb77a36038 100755 --- a/configure.py +++ b/configure.py @@ -2450,9 +2450,21 @@ def configure_ffi(o): configure_library('ffi', o, pkgname='libffi') def configure_quic(o): + if options.experimental_quic and options.without_ssl: + warn('--experimental-quic is incompatible with --without-ssl') o['variables']['node_use_quic'] = b(options.experimental_quic and not options.without_ssl) + if not options.experimental_quic: + for lib in ['nghttp3', 'ngtcp2']: + shared_lib = 'shared_' + lib + if getattr(options, shared_lib): + warn(f'--shared-{lib} requires --experimental-quic') + return + + configure_library('nghttp3', output, pkgname='libnghttp3') + configure_library('ngtcp2', output, pkgname='libngtcp2') + def configure_dtls(o): o['variables']['node_use_dtls'] = b(options.experimental_dtls and not options.without_ssl) @@ -2974,8 +2986,6 @@ def make_bin_override(): configure_library('merve', output) configure_library('nbytes', output) configure_library('nghttp2', output, pkgname='libnghttp2') -configure_library('nghttp3', output, pkgname='libnghttp3') -configure_library('ngtcp2', output, pkgname='libngtcp2') configure_lief(output); configure_perfetto(output); configure_sqlite(output); From 36b1de5ebd82556eb11f18d48019e7b8980be3d6 Mon Sep 17 00:00:00 2001 From: Philipp Dunkel Date: Tue, 20 Oct 2026 14:33:08 +0200 Subject: [PATCH 070/331] zlib: add crc32c Add zlib.crc32c(data[, value]), which computes the CRC-32C checksum (Castagnoli polynomial, RFC 3720 section 12.1). CRC-32C has better error detection properties than the CRC-32 of zlib.crc32() and is the checksum required by many current protocols, formats and services, among them: - iSCSI header and data digests (RFC 7143) - SCTP packet checksums (RFC 9260) - iWARP MPA framing (RFC 5044) - NVMe/TCP header and data digests - ext4, Btrfs and XFS metadata checksums - the Snappy framing format - Apache Kafka record batches - LevelDB and RocksDB block checksums - TensorFlow TFRecord files - Google Cloud Storage and Amazon S3 object checksums Implementing any of these in JavaScript currently needs a userland CRC-32C, which is far slower than native code. The function mirrors zlib.crc32(): it accepts a string (encoded as UTF-8) or an ArrayBufferView, takes an optional 32-bit unsigned starting value so a checksum can be continued across chunks, and has a V8 fast API path. The checksum is computed by absl::ExtendCrc32c() from the bundled Abseil, which is already built and linked into node, so this adds no new dependency and no new checksum implementation. absl_crc32c is added to the libraries linked with --shared-abseil. Abseil selects its hardware-accelerated CRC-32C path (SSE4.2 and PCLMULQDQ on x64, the CRC32 and PMULL extensions on arm64) at compile time, so with node's default compiler flags the portable table-driven implementation is used. It runs at about the same speed as zlib.crc32() (about 6.5 GB/s on a recent x64 machine), while the hardware path reaches about 38 GB/s. Builds whose target CPU baseline already includes those instructions get the hardware path without changes. Enabling it for generic builds is left out on purpose: on x64, Abseil uses the accelerated code for unrecognized CPUs without a runtime feature check, so compiling it in unconditionally would fault on CPUs without SSE4.2. Signed-off-by: Philipp Dunkel PR-URL: https://github.com/nodejs/node/pull/66828 Reviewed-By: Matteo Collina Reviewed-By: Paolo Insogna Reviewed-By: Trivikram Kamat --- benchmark/zlib/crc32c.js | 47 ++++++++++ configure.py | 1 + doc/api/zlib.md | 45 ++++++++++ lib/zlib.js | 13 ++- src/node_zlib.cc | 34 ++++++++ test/parallel/test-zlib-crc32c.js | 92 ++++++++++++++++++++ test/sequential/test-zlib-crc32c-fast-api.js | 26 ++++++ typings/internalBinding/zlib.d.ts | 1 + 8 files changed, 258 insertions(+), 1 deletion(-) create mode 100644 benchmark/zlib/crc32c.js create mode 100644 test/parallel/test-zlib-crc32c.js create mode 100644 test/sequential/test-zlib-crc32c-fast-api.js diff --git a/benchmark/zlib/crc32c.js b/benchmark/zlib/crc32c.js new file mode 100644 index 00000000000..3a8abd0a286 --- /dev/null +++ b/benchmark/zlib/crc32c.js @@ -0,0 +1,47 @@ +'use strict'; + +const common = require('../common.js'); +const { crc32c } = require('zlib'); + +// Benchmark crc32c on Buffer and String inputs across sizes. +// Iteration count is scaled inversely with input length to keep runtime sane. +// Example: +// node benchmark/zlib/crc32c.js type=buffer len=4096 n=4000000 +// ./out/Release/node benchmark/zlib/crc32c.js --test + +const bench = common.createBenchmark(main, { + type: ['buffer', 'string'], + len: [32, 256, 4096, 65536], + n: [4e6], +}); + +function makeBuffer(size) { + const buf = Buffer.allocUnsafe(size); + for (let i = 0; i < size; i++) buf[i] = (i * 1103515245 + 12345) & 0xff; + return buf; +} + +function makeAsciiString(size) { + const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'; + let out = ''; + for (let i = 0, j = 0; i < size; i++, j = (j + 7) % chars.length) out += chars[j]; + return out; +} + +function main({ type, len, n }) { + // Scale iterations so that total processed bytes roughly constant around n*4096 bytes. + const scale = 4096 / len; + const iters = Math.max(1, Math.floor(n * scale)); + + const data = type === 'buffer' ? makeBuffer(len) : makeAsciiString(len); + + let acc = 0; + for (let i = 0; i < Math.min(iters, 10000); i++) acc ^= crc32c(data, 0); + + bench.start(); + let sum = 0; + for (let i = 0; i < iters; i++) sum ^= crc32c(data, 0); + bench.end(iters); + + if (sum === acc - 1) process.stderr.write(''); +} diff --git a/configure.py b/configure.py index efb77a36038..f9914b6ddb4 100755 --- a/configure.py +++ b/configure.py @@ -2923,6 +2923,7 @@ def make_bin_override(): 'absl_cleanup', 'absl_config', 'absl_cord', + 'absl_crc32c', 'absl_core_headers', 'absl_die_if_null', 'absl_dynamic_annotations', diff --git a/doc/api/zlib.md b/doc/api/zlib.md index 3753f8ec94f..b4cf51c5b3f 100644 --- a/doc/api/zlib.md +++ b/doc/api/zlib.md @@ -2367,6 +2367,49 @@ crc = zlib.crc32(Buffer.from('hello', 'utf16le')); // 1427272415 crc = zlib.crc32(Buffer.from('world', 'utf16le'), crc); // 4150509955 ``` +## `zlib.crc32c(data[, value])` + + + +* `data` {string|Buffer|TypedArray|DataView} When `data` is a string, + it will be encoded as UTF-8 before being used for computation. +* `value` {integer} An optional starting value. It must be a 32-bit unsigned + integer. **Default:** `0` +* Returns: {integer} A 32-bit unsigned integer containing the checksum. + +Computes a 32-bit [Cyclic Redundancy Check][] checksum of `data` using the +Castagnoli polynomial (CRC-32C, [RFC 3720][] section 12.1). If `value` is +specified, it is used as the starting value of the checksum, otherwise, 0 is +used as the starting value. Passing the result of a previous call as `value` +continues the checksum, as with [`zlib.crc32()`][]. + +CRC-32C is a different checksum from the CRC-32 computed by +[`zlib.crc32()`][]; the two produce different results for the same input. +CRC-32C is used by protocols and formats such as iSCSI, SCTP, ext4, Btrfs, +and the Snappy framing format, and has better error detection properties than +CRC-32. + +The CRC algorithm is designed to compute checksums and to detect error +in data transmission. It's not suitable for cryptographic authentication. + +Strings are encoded as UTF-8, in the same way as [`zlib.crc32()`][]. + +```mjs +import zlib from 'node:zlib'; + +let crc = zlib.crc32c('hello'); // 2591144780 +crc = zlib.crc32c('world', crc); // 1456190592 +``` + +```cjs +const zlib = require('node:zlib'); + +let crc = zlib.crc32c('hello'); // 2591144780 +crc = zlib.crc32c('world', crc); // 1456190592 +``` + ## `zlib.createBrotliCompress([options])` -> Stability: 1 - Experimental +> Stability: 2 - Stable The Node.js test runner supports running in watch mode by passing the `--watch` flag: From 5fd81baf19d04f4cb55fbe95aa011fe5b54d0010 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 21 Oct 2026 09:32:56 +0200 Subject: [PATCH 091/331] test: deflake test-http-agent-keepalive MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The cleanup assertions can run before the socket closes when I/O is delayed. Wait for the socket's close event in both the remote-close and remote-error paths. Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66887 Reviewed-By: Richard Lau Reviewed-By: Luigi Pinca Reviewed-By: Gürgün Dayıoğlu --- test/parallel/test-http-agent-keepalive.js | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/test/parallel/test-http-agent-keepalive.js b/test/parallel/test-http-agent-keepalive.js index 1cf5a597d0a..dcfcc8c9066 100644 --- a/test/parallel/test-http-agent-keepalive.js +++ b/test/parallel/test-http-agent-keepalive.js @@ -94,13 +94,13 @@ function remoteClose() { assert.strictEqual(agent.sockets[name], undefined); assert.strictEqual(agent.freeSockets[name].length, 1); assert.strictEqual(agent.totalSocketCount, 1); - // Waiting remote server close the socket - setTimeout(common.mustCall(() => { + // Wait for the remote server to close the socket. + req.socket.once('close', common.mustCall(() => { assert.strictEqual(agent.sockets[name], undefined); assert.strictEqual(agent.freeSockets[name], undefined); assert.strictEqual(agent.totalSocketCount, 0); remoteError(); - }), common.platformTimeout(200)); + })); })); })); })); @@ -115,13 +115,13 @@ function remoteError() { assert.strictEqual(agent.sockets[name].length, 1); assert.strictEqual(agent.freeSockets[name], undefined); assert.strictEqual(agent.totalSocketCount, 1); - // Wait socket 'close' event emit - setTimeout(common.mustCall(() => { + // Wait for the socket's 'close' event. + req.socket.once('close', common.mustCall(() => { assert.strictEqual(agent.sockets[name], undefined); assert.strictEqual(agent.freeSockets[name], undefined); assert.strictEqual(agent.totalSocketCount, 0); server.close(); - }), common.platformTimeout(1)); + })); })); } From 08428bebf48c19228d6fc2f1a0174b8575535ba9 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 21 Oct 2026 09:33:12 +0200 Subject: [PATCH 092/331] test: handle stringbytes allocation failures MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Buffer.allocUnsafe() can throw ERR_MEMORY_ALLOCATION_FAILED under memory pressure. Accept it alongside the V8 allocation-failure message so the tests take their intended low-memory skip. Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66887 Reviewed-By: Richard Lau Reviewed-By: Luigi Pinca Reviewed-By: Gürgün Dayıoğlu --- .../test-stringbytes-external-at-max.js | 3 ++- .../test-stringbytes-external-exceed-max-by-1-ascii.js | 3 ++- .../test-stringbytes-external-exceed-max-by-1-base64.js | 3 ++- .../test-stringbytes-external-exceed-max-by-1-binary.js | 3 ++- .../test-stringbytes-external-exceed-max-by-1-hex.js | 3 ++- .../test-stringbytes-external-exceed-max-by-1-utf8.js | 3 ++- .../test-stringbytes-external-exceed-max-by-2.js | 3 ++- .../test-stringbytes-external-exceed-max.js | 3 ++- 8 files changed, 16 insertions(+), 8 deletions(-) diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-at-max.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-at-max.js index fcf5279dd3c..87a754cb216 100644 --- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-at-max.js +++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-at-max.js @@ -17,7 +17,8 @@ try { buf = Buffer.allocUnsafe(kStringMaxLength); } catch (e) { // If the exception is not due to memory confinement then rethrow it. - if (e.message !== 'Array buffer allocation failed') throw (e); + if (e.code !== 'ERR_MEMORY_ALLOCATION_FAILED' && + e.message !== 'Array buffer allocation failed') throw (e); common.skip(skipMessage); } diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-ascii.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-ascii.js index 6aff0445195..e03b5ae0352 100644 --- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-ascii.js +++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-ascii.js @@ -17,7 +17,8 @@ try { buf = Buffer.allocUnsafe(kStringMaxLength + 1); } catch (e) { // If the exception is not due to memory confinement then rethrow it. - if (e.message !== 'Array buffer allocation failed') throw (e); + if (e.code !== 'ERR_MEMORY_ALLOCATION_FAILED' && + e.message !== 'Array buffer allocation failed') throw (e); common.skip(skipMessage); } diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-base64.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-base64.js index 7c8e2d92c6a..9ffff4fdbbe 100644 --- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-base64.js +++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-base64.js @@ -17,7 +17,8 @@ try { buf = Buffer.allocUnsafe(kStringMaxLength + 1); } catch (e) { // If the exception is not due to memory confinement then rethrow it. - if (e.message !== 'Array buffer allocation failed') throw (e); + if (e.code !== 'ERR_MEMORY_ALLOCATION_FAILED' && + e.message !== 'Array buffer allocation failed') throw (e); common.skip(skipMessage); } diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-binary.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-binary.js index 176c095e22e..c962c491d0c 100644 --- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-binary.js +++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-binary.js @@ -18,7 +18,8 @@ try { buf = Buffer.allocUnsafe(kStringMaxLength + 1); } catch (e) { // If the exception is not due to memory confinement then rethrow it. - if (e.message !== 'Array buffer allocation failed') throw (e); + if (e.code !== 'ERR_MEMORY_ALLOCATION_FAILED' && + e.message !== 'Array buffer allocation failed') throw (e); common.skip(skipMessage); } diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-hex.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-hex.js index a473e0e90fb..1cef739c5c3 100644 --- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-hex.js +++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-hex.js @@ -17,7 +17,8 @@ try { buf = Buffer.allocUnsafe(kStringMaxLength + 1); } catch (e) { // If the exception is not due to memory confinement then rethrow it. - if (e.message !== 'Array buffer allocation failed') throw (e); + if (e.code !== 'ERR_MEMORY_ALLOCATION_FAILED' && + e.message !== 'Array buffer allocation failed') throw (e); common.skip(skipMessage); } diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-utf8.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-utf8.js index 25271fad94b..2e00ff49722 100644 --- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-utf8.js +++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-utf8.js @@ -17,7 +17,8 @@ try { buf = Buffer.allocUnsafe(kStringMaxLength + 1); } catch (e) { // If the exception is not due to memory confinement then rethrow it. - if (e.message !== 'Array buffer allocation failed') throw (e); + if (e.code !== 'ERR_MEMORY_ALLOCATION_FAILED' && + e.message !== 'Array buffer allocation failed') throw (e); common.skip(skipMessage); } diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-2.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-2.js index 121ca2d62ba..6fbc52849c4 100644 --- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-2.js +++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-2.js @@ -17,7 +17,8 @@ try { buf = Buffer.allocUnsafe(kStringMaxLength + 2); } catch (e) { // If the exception is not due to memory confinement then rethrow it. - if (e.message !== 'Array buffer allocation failed') throw (e); + if (e.code !== 'ERR_MEMORY_ALLOCATION_FAILED' && + e.message !== 'Array buffer allocation failed') throw (e); common.skip(skipMessage); } diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max.js index b843be5a9ab..e13f865405c 100644 --- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max.js +++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max.js @@ -17,7 +17,8 @@ try { buf = Buffer.allocUnsafe(kStringMaxLength * 2 + 2); } catch (e) { // If the exception is not due to memory confinement then rethrow it. - if (e.message !== 'Array buffer allocation failed') throw (e); + if (e.code !== 'ERR_MEMORY_ALLOCATION_FAILED' && + e.message !== 'Array buffer allocation failed') throw (e); common.skip(skipMessage); } From 1a8c999b0288c0eb62288543a20e7e7ac7e8e65f Mon Sep 17 00:00:00 2001 From: Mert Can Altin Date: Fri, 23 Oct 2026 10:51:50 +0300 Subject: [PATCH 093/331] lib: optimize TextEncoder.encode for short strings Assisted-by: Claude opus 5.5 Signed-off-by: Mert Can Altin PR-URL: https://github.com/nodejs/node/pull/66831 Reviewed-By: Antoine du Hamel Reviewed-By: Yagiz Nizipli Reviewed-By: Robert Nagy --- lib/internal/encoding.js | 19 ++++++++++- ...hatwg-encoding-custom-textencoder-short.js | 33 +++++++++++++++++++ 2 files changed, 51 insertions(+), 1 deletion(-) create mode 100644 test/parallel/test-whatwg-encoding-custom-textencoder-short.js diff --git a/lib/internal/encoding.js b/lib/internal/encoding.js index 11003db8bc5..c6eafa2ba34 100644 --- a/lib/internal/encoding.js +++ b/lib/internal/encoding.js @@ -13,6 +13,7 @@ const { StringPrototypeSlice, Symbol, SymbolToStringTag, + Uint8Array, } = primordials; const { FastBuffer } = require('internal/buffer'); @@ -338,11 +339,27 @@ function getEncodingFromLabel(label) { let lazyInspect; +// Maximum string length handled by the reusable scratch buffer. +const kSmallEncodeLength = 32; +let smallEncodeScratch; + class TextEncoder { #encoding = 'utf-8'; #encode(input) { - return encodeUtf8String(`${input}`); + input = `${input}`; + if (input.length > kSmallEncodeLength) { + return encodeUtf8String(input); + } + + smallEncodeScratch ??= new Uint8Array(kSmallEncodeLength * 3); + encodeInto(input, smallEncodeScratch); + const written = encodeIntoResults[1]; + const result = new Uint8Array(written); + for (let i = 0; i < written; i++) { + result[i] = smallEncodeScratch[i]; + } + return result; } #encodeInto(input, dest) { diff --git a/test/parallel/test-whatwg-encoding-custom-textencoder-short.js b/test/parallel/test-whatwg-encoding-custom-textencoder-short.js new file mode 100644 index 00000000000..3f8ad64b567 --- /dev/null +++ b/test/parallel/test-whatwg-encoding-custom-textencoder-short.js @@ -0,0 +1,33 @@ +'use strict'; + +// Tests TextEncoder.prototype.encode() around the short string path. + +require('../common'); + +const assert = require('assert'); + +const encoder = new TextEncoder(); + +const inputs = [ + '', + 'a', + 'a'.repeat(32), + 'a'.repeat(33), + '\xff'.repeat(32), + 'ğ'.repeat(32), + 'ࠀ'.repeat(32), + '\u{1F44B}'.repeat(16), + '\u{1F44B}'.repeat(17), + '\ud800', + 'a\udc00b', + 'abc\ud83d', +]; + +for (const input of inputs) { + const result = encoder.encode(input); + const expected = Buffer.from(input, 'utf8'); + assert.strictEqual(Object.getPrototypeOf(result), Uint8Array.prototype); + assert.strictEqual(result.byteOffset, 0); + assert.strictEqual(result.buffer.byteLength, expected.length); + assert.deepStrictEqual(Buffer.from(result), expected); +} From 114bc1c73fdab924fd34484d19f545f3d76c99dd Mon Sep 17 00:00:00 2001 From: StefanStojanovic Date: Wed, 9 Sep 2026 08:24:06 +0200 Subject: [PATCH 094/331] build,win: fix Perfetto MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: StefanStojanovic Co-Authored-By: Chengzhong Wu PR-URL: https://github.com/nodejs/node/pull/66876 Reviewed-By: Chengzhong Wu Reviewed-By: Luigi Pinca Reviewed-By: Juan José Arboleda Reviewed-By: Gürgün Dayıoğlu --- deps/perfetto/perfetto.gyp | 8 ++++++++ node.gypi | 5 +++++ tools/v8_gypfiles/features.gypi | 2 +- 3 files changed, 14 insertions(+), 1 deletion(-) diff --git a/deps/perfetto/perfetto.gyp b/deps/perfetto/perfetto.gyp index 083d0b386dd..697256401a3 100644 --- a/deps/perfetto/perfetto.gyp +++ b/deps/perfetto/perfetto.gyp @@ -18,6 +18,14 @@ 'sources': [ '<@(perfetto_sdk_sources)', ], + 'conditions': [ + ['OS=="win"', { + 'defines': [ + 'WIN32_LEAN_AND_MEAN', + 'NOMINMAX', + ], + }], + ], }, ] } diff --git a/node.gypi b/node.gypi index 9eb972adc47..3ca9d4633d0 100644 --- a/node.gypi +++ b/node.gypi @@ -93,6 +93,11 @@ [ 'OS=="linux" and target_arch=="s390x"', { 'cflags': [ '-march=z14' ], }], + [ 'v8_use_perfetto==1 and node_shared_perfetto=="false"', { + 'dependencies': [ + 'deps/perfetto/perfetto.gyp:perfetto_sdk', + ], + }], [ 'node_enable_d8=="true"', { 'dependencies': [ 'tools/v8_gypfiles/d8.gyp:d8' ], }], diff --git a/tools/v8_gypfiles/features.gypi b/tools/v8_gypfiles/features.gypi index 95717992bca..550709b5635 100644 --- a/tools/v8_gypfiles/features.gypi +++ b/tools/v8_gypfiles/features.gypi @@ -62,7 +62,7 @@ }, { 'is_component_build': 0, }], - ['OS == "win" or OS == "mac"', { + ['(OS == "win" or OS == "mac") and v8_use_perfetto == 0', { # Sets -DENABLE_SYSTEM_INSTRUMENTATION. Enables OS-dependent event tracing 'v8_enable_system_instrumentation': 1, }, { From 6390e0ee67c7f116f626d0ca8cecc0a9ea6f66ea Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Fri, 23 Oct 2026 09:51:48 +0200 Subject: [PATCH 095/331] doc: update config schema for test-forbid-only Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/66945 Reviewed-By: Antoine du Hamel Reviewed-By: Mike McCready <66998419+MikeMcC399@users.noreply.github.com> --- doc/node-config-schema.json | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/doc/node-config-schema.json b/doc/node-config-schema.json index d63f88c8023..97aaddd7b3f 100644 --- a/doc/node-config-schema.json +++ b/doc/node-config-schema.json @@ -706,6 +706,10 @@ "type": "number", "description": "the line coverage minimum threshold" }, + "test-forbid-only": { + "type": "boolean", + "description": "fail tests that use the 'only' option" + }, "test-global-setup": { "type": "string", "description": "specifies the path to the global setup file" @@ -1145,6 +1149,10 @@ "type": "number", "description": "the line coverage minimum threshold" }, + "test-forbid-only": { + "type": "boolean", + "description": "fail tests that use the 'only' option" + }, "test-force-exit": { "type": "boolean", "description": "force test runner to exit upon completion" From 5b6ac3854945a8977df77be10f17f8bae78d65df Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Fri, 23 Oct 2026 11:28:33 +0200 Subject: [PATCH 096/331] build: warn on incompatible dtls configure flags Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/66892 Reviewed-By: Luigi Pinca Reviewed-By: Richard Lau --- configure.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/configure.py b/configure.py index f9914b6ddb4..d0e6663bc2c 100755 --- a/configure.py +++ b/configure.py @@ -2466,6 +2466,9 @@ def configure_quic(o): configure_library('ngtcp2', output, pkgname='libngtcp2') def configure_dtls(o): + if options.experimental_dtls and options.without_ssl: + warn('--experimental-dtls is incompatible with --without-ssl') + o['variables']['node_use_dtls'] = b(options.experimental_dtls and not options.without_ssl) From aab3384b4cfbd98d27346d4346c8311fb8327de1 Mon Sep 17 00:00:00 2001 From: Yuya Inoue <65857152+inoway46@users.noreply.github.com> Date: Fri, 23 Oct 2026 21:44:53 +0900 Subject: [PATCH 097/331] tools: limit checkout for lint-addon-docs Exclude unused vendored dependencies from the lint-addon-docs checkout to reduce checkout time. Assisted-by: Codex Signed-off-by: inoway46 PR-URL: https://github.com/nodejs/node/pull/66505 Refs: https://github.com/nodejs/node/issues/64972 Reviewed-By: Antoine du Hamel --- .github/workflows/linters.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/linters.yml b/.github/workflows/linters.yml index a4997b3d4cc..f6945f9df51 100644 --- a/.github/workflows/linters.yml +++ b/.github/workflows/linters.yml @@ -28,6 +28,10 @@ jobs: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: persist-credentials: false + sparse-checkout: | + /* + !/deps/ + sparse-checkout-cone-mode: false - name: Use Node.js ${{ env.NODE_VERSION }} uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 with: From d47af538e367a101354b9639695309359736fe64 Mon Sep 17 00:00:00 2001 From: Lazizbek Ergashev Date: Fri, 23 Oct 2026 18:23:50 +0500 Subject: [PATCH 098/331] src: fix build with `--shared-brotli` Assisted-by: Claude Code Signed-off-by: lazerg PR-URL: https://github.com/nodejs/node/pull/66895 Fixes: https://github.com/nodejs/node/issues/66894 Reviewed-By: Antoine du Hamel Reviewed-By: Filip Skokan Reviewed-By: Richard Lau --- src/node_zlib.cc | 36 +++--------------------- test/parallel/test-zlib-invalid-input.js | 2 +- tools/nix/sharedLibDeps.nix | 9 +----- 3 files changed, 6 insertions(+), 41 deletions(-) diff --git a/src/node_zlib.cc b/src/node_zlib.cc index d25662bdb98..a34905c3e3a 100644 --- a/src/node_zlib.cc +++ b/src/node_zlib.cc @@ -2280,38 +2280,10 @@ void DefineZlibConstants(Local target) { NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION); NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_PARAM_LARGE_WINDOW); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_NO_ERROR); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_SUCCESS); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_NEEDS_MORE_INPUT); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_NEEDS_MORE_OUTPUT); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_RESERVED); - NODE_DEFINE_CONSTANT(target, - BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE); - NODE_DEFINE_CONSTANT(target, - BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_CL_SPACE); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_TRANSFORM); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_DICTIONARY); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_PADDING_1); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_PADDING_2); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_DISTANCE); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_INVALID_ARGUMENTS); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES); - NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_UNREACHABLE); +#define V(PREFIX, NAME, CODE) \ + NODE_DEFINE_CONSTANT(target, BROTLI_DECODER##PREFIX##NAME); + BROTLI_DECODER_ERROR_CODES_LIST(V, ) +#undef V // Zstd constants NODE_DEFINE_CONSTANT(target, ZSTD_e_continue); diff --git a/test/parallel/test-zlib-invalid-input.js b/test/parallel/test-zlib-invalid-input.js index 976d4640eba..95177bb150e 100644 --- a/test/parallel/test-zlib-invalid-input.js +++ b/test/parallel/test-zlib-invalid-input.js @@ -89,7 +89,7 @@ Object.defineProperty(spoofedLength, 'byteLength', { get: () => 5000 }); deflate.close(); } -{ +if (zlib.constants.BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH) { // A block switch is invalid when the stream declares only one block type. const invalidBlockSwitch = Buffer.from( '200010414141fcffff07002228f00b60f7f41f000000', diff --git a/tools/nix/sharedLibDeps.nix b/tools/nix/sharedLibDeps.nix index 9224bac45ec..ce044486cd9 100644 --- a/tools/nix/sharedLibDeps.nix +++ b/tools/nix/sharedLibDeps.nix @@ -11,6 +11,7 @@ { inherit (pkgs) ada + brotli gtest libuv merve @@ -21,14 +22,6 @@ zstd ; abseil = pkgs.abseil-cpp; - brotli = pkgs.brotli.overrideAttrs (old: { - patches = (old.patches or [ ]) ++ [ - (pkgs.fetchpatch2 { - url = "https://github.com/google/brotli/commit/0ed4268a4401abcb4472096340477cf4af7d1a2b.patch?full_index=1"; - hash = "sha256-dVpnYI2JLDEt2VQkbI6RnbpdcQSMB5bTQ6TJp5CLnyw="; - }) - ]; - }); cares = pkgs.c-ares; hdr-histogram = pkgs.hdrhistogram_c; highway = pkgs.libhwy; From 7d9d18ea1c73e8124e0a551904a63884bde8e75a Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 21 Oct 2026 18:24:04 +0200 Subject: [PATCH 099/331] Revert "test: mark worker init failure flaky on SmartOS" MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 6ecfd6587d3dadc6a4f21bbfa5b7a014bb9b5d1d. PR-URL: https://github.com/nodejs/node/pull/66903 Reviewed-By: Richard Lau Reviewed-By: Luigi Pinca Reviewed-By: Gürgün Dayıoğlu --- test/parallel/parallel.status | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/parallel/parallel.status b/test/parallel/parallel.status index 0fe217d4e44..be53eda583b 100644 --- a/test/parallel/parallel.status +++ b/test/parallel/parallel.status @@ -45,8 +45,6 @@ test-crypto-keygen: SKIP test-debugger-heap-profiler: PASS, FLAKY [$system==solaris] # Also applies to SmartOS -# https://github.com/nodejs/node/pull/66282#issuecomment-5833089308 -test-worker-init-failure: PASS, FLAKY # https://github.com/nodejs/node/issues/43457 test-domain-no-error-handler-abort-on-uncaught-0: PASS, FLAKY test-domain-no-error-handler-abort-on-uncaught-1: PASS,FLAKY From c558d85160932c5493ff452eba13a3831f4d6d7b Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 21 Oct 2026 18:24:04 +0200 Subject: [PATCH 100/331] Revert "src: seed V8 from the OS CSPRNG instead of OpenSSL's DRBG" MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 43d3fe95581cb599611dc8e1aae9a79a900998b8. PR-URL: https://github.com/nodejs/node/pull/66903 Reviewed-By: Richard Lau Reviewed-By: Luigi Pinca Reviewed-By: Gürgün Dayıoğlu --- src/node.cc | 36 ++++--------------- .../test-legacy-provider-option.js | 3 -- .../openssl3-conf/random_unavailable.cnf | 7 ---- test/parallel/test-crypto-no-algorithm.js | 18 ---------- test/parallel/test-crypto-secure-heap.js | 35 ------------------ 5 files changed, 6 insertions(+), 93 deletions(-) delete mode 100644 test/fixtures/openssl3-conf/random_unavailable.cnf diff --git a/src/node.cc b/src/node.cc index 163070b501c..e6a1c7d577c 100644 --- a/src/node.cc +++ b/src/node.cc @@ -49,9 +49,6 @@ #if HAVE_OPENSSL #include "ncrypto.h" -#if OPENSSL_VERSION_MAJOR >= 3 -#include -#endif #include "node_crypto.h" #if OPENSSL_VERSION_MAJOR >= 3 && !defined(CONF_MFLAGS_IGNORE_MISSING_FILE) // OpenSSL hides this deprecated macro under OPENSSL_NO_DEPRECATED, but the @@ -1324,36 +1321,15 @@ InitializeOncePerProcessInternal(const std::vector& args, } crypto::InstallFipsIndicatorCallback(); - // Activating the default provider here keeps --openssl-legacy-provider - // working. Its explicit load disables OpenSSL's fallback, and the eager - // CSPRNG check used to activate the provider as a side effect. Only - // check the seeding when that provider is missing or FIPS is on, so a - // configuration without a DRBG still aborts at startup instead of - // hanging at the first crypto call. Otherwise the DRBG is instantiated - // on first use. -#if OPENSSL_VERSION_MAJOR >= 3 - const bool check_csprng = ncrypto::isFipsEnabled() || - !OSSL_PROVIDER_available(nullptr, "default"); -#else - const bool check_csprng = true; -#endif - if (check_csprng) { - CHECK(ncrypto::CSPRNG(nullptr, 0)); - } + // Ensure CSPRNG is properly seeded. + CHECK(ncrypto::CSPRNG(nullptr, 0)); - // V8 uses the entropy for hash seeds, ASLR and Math.random(), none of - // it cryptographic. Going through OpenSSL would instantiate the DRBG - // and build the default provider's algorithm tables on every startup. - // V8 falls back to very weak entropy when the source fails, so abort - // instead. V8::SetEntropySource([](unsigned char* buffer, size_t length) { -#ifdef _AIX - // uv_random() reads /dev/random on AIX, which blocks. OpenSSL seeds - // from /dev/urandom there. + // V8 falls back to very weak entropy when this function fails + // and /dev/urandom isn't available. That wouldn't be so bad if + // the entropy was only used for Math.random() but it's also used for + // hash table and address space layout randomization. Better to abort. CHECK(ncrypto::CSPRNG(buffer, length)); -#else - CHECK_EQ(uv_random(nullptr, nullptr, buffer, length, 0, nullptr), 0); -#endif return true; }); #endif // !defined(OPENSSL_IS_BORINGSSL) diff --git a/test/addons/openssl-providers/test-legacy-provider-option.js b/test/addons/openssl-providers/test-legacy-provider-option.js index 1f01ce55a8f..5ad60dac9b8 100644 --- a/test/addons/openssl-providers/test-legacy-provider-option.js +++ b/test/addons/openssl-providers/test-legacy-provider-option.js @@ -22,6 +22,3 @@ if (getFips()) { common.skip('this test cannot be run in FIPS mode'); } providers.testProviderPresent('legacy'); -// The explicit legacy load disables OpenSSL's provider fallback, so the -// default provider has to be active before it runs. -providers.testProviderPresent('default'); diff --git a/test/fixtures/openssl3-conf/random_unavailable.cnf b/test/fixtures/openssl3-conf/random_unavailable.cnf deleted file mode 100644 index a2dc8d2c9ff..00000000000 --- a/test/fixtures/openssl3-conf/random_unavailable.cnf +++ /dev/null @@ -1,7 +0,0 @@ -nodejs_conf = nodejs_init - -[nodejs_init] -random = random_sect - -[random_sect] -random = NO-SUCH-DRBG diff --git a/test/parallel/test-crypto-no-algorithm.js b/test/parallel/test-crypto-no-algorithm.js index 0354aad8b0b..06aab7614ff 100644 --- a/test/parallel/test-crypto-no-algorithm.js +++ b/test/parallel/test-crypto-no-algorithm.js @@ -57,21 +57,3 @@ if (isMainThread) { assert(common.nodeProcessAborted(cp.status, cp.signal), `process did not abort, code:${cp.status} signal:${cp.signal}`); } - -// AIX keeps OpenSSL as V8's entropy source, so a DRBG that cannot be -// fetched still aborts at startup there. -if (!common.isAIX) { - // A configuration whose random section names a DRBG that cannot be - // fetched starts normally; the first crypto call fails, without a hang. - const fixtures = require('../common/fixtures'); - const { spawnSync } = require('node:child_process'); - const randomConf = fixtures.path('openssl3-conf', 'random_unavailable.cnf'); - const cp = spawnSync(process.execPath, - [ `--openssl-config=${randomConf}`, '-e', - 'require("node:crypto").randomBytes(8)' ], - { encoding: 'utf8' }); - assert(!common.nodeProcessAborted(cp.status, cp.signal), - `process aborted, code:${cp.status} signal:${cp.signal}`); - assert.strictEqual(cp.status, 1); - assert.match(cp.stderr, /unable to fetch drbg/); -} diff --git a/test/parallel/test-crypto-secure-heap.js b/test/parallel/test-crypto-secure-heap.js index 3c79d1bb8a6..22f90b6be99 100644 --- a/test/parallel/test-crypto-secure-heap.js +++ b/test/parallel/test-crypto-secure-heap.js @@ -70,28 +70,6 @@ if (process.argv[2] === 'child') { return; } -if (process.argv[2] === 'workers') { - // Eight Workers held alive at once. A 1 KiB secure heap has room for a - // few DRBGs only, so an isolate setup that drew its entropy through - // OpenSSL would fail for the later Workers and abort the process. - const { Worker } = require('worker_threads'); - const i32 = new Int32Array(new SharedArrayBuffer(4)); - let online = 0; - for (let i = 0; i < 8; i++) { - const worker = new Worker( - 'const { workerData } = require("worker_threads");' + - 'Atomics.wait(workerData.i32, 0, 0);', - { eval: true, workerData: { i32 } }); - worker.on('online', () => { - if (++online === 8) { - Atomics.store(i32, 0, 1); - Atomics.notify(i32, 0); - } - }); - } - return; -} - const child = fork( process.argv[1], ['child'], @@ -101,19 +79,6 @@ child.on('exit', common.mustCall((code) => { assert.strictEqual(code, 0); })); -// AIX keeps OpenSSL as V8's entropy source, so a Worker's isolate setup -// still draws on the secure heap there. -if (!common.isAIX) { - const child = fork( - process.argv[1], - ['workers'], - { execArgv: ['--secure-heap=1024', '--secure-heap-min=4'] }); - child.on('exit', common.mustCall((code, signal) => { - assert.strictEqual(signal, null); - assert.strictEqual(code, 0); - })); -} - { const child = fork(fixtures.path('a.js'), { execArgv: ['--secure-heap=3', '--secure-heap-min=3'], From 8664e708ca4ee13c7e8b013480a7f84a6f129ebc Mon Sep 17 00:00:00 2001 From: Chengzhong Wu Date: Fri, 23 Oct 2026 18:01:33 -0400 Subject: [PATCH 101/331] build,test: setup perfetto tests on windows build Signed-off-by: Chengzhong Wu PR-URL: https://github.com/nodejs/node/pull/66731 Reviewed-By: Antoine du Hamel Reviewed-By: Filip Skokan --- .gitignore | 1 + Makefile | 2 +- test/common/trace_events.js | 8 ++-- test/trace_events/README.md | 8 ++-- tools/perfetto/get_trace_processor | 36 ---------------- tools/perfetto/get_trace_processor.py | 61 +++++++++++++++++++++++++++ vcbuild.bat | 10 +++++ 7 files changed, 83 insertions(+), 43 deletions(-) delete mode 100755 tools/perfetto/get_trace_processor create mode 100755 tools/perfetto/get_trace_processor.py diff --git a/.gitignore b/.gitignore index 9ba14770743..84c35fbdd94 100644 --- a/.gitignore +++ b/.gitignore @@ -123,6 +123,7 @@ tools/*/*.i.tmp # === Rules for tools/perfetto === /tools/perfetto/trace_processor_shell +/tools/perfetto/trace_processor_shell.exe # === Rules for test artifacts === /*.tap diff --git a/Makefile b/Makefile index b817f8fbdb2..d1de619ff2d 100644 --- a/Makefile +++ b/Makefile @@ -349,7 +349,7 @@ TRACE_PROCESSOR_SHELL_DEPS = deps/perfetto/VERSION endif $(TRACE_PROCESSOR_SHELL_PATH): $(TRACE_PROCESSOR_SHELL_DEPS) - @tools/perfetto/get_trace_processor $@ + @$(PYTHON) tools/perfetto/get_trace_processor.py $@ .PHONY: test # This does not run tests of third-party libraries inside deps. diff --git a/test/common/trace_events.js b/test/common/trace_events.js index 67fc0919350..cbb5dbdcc60 100644 --- a/test/common/trace_events.js +++ b/test/common/trace_events.js @@ -4,7 +4,8 @@ // binary format. // This depends on perfetto's `trace_processor_shell` converts to pftrace format // to JSON format. Run `make tools/perfetto/trace_processor_shell` to download -// it, or point `TRACE_PROCESSOR_SHELL_PATH` at an existing build of it. +// it (`vcbuild test` does so on Windows), or point `TRACE_PROCESSOR_SHELL_PATH` +// at an existing build of it. const assert = require('assert'); const { spawnSync } = require('child_process'); @@ -14,7 +15,8 @@ const common = require('./'); const traceProcessor = path.resolve( __dirname, '..', '..', - process.env.TRACE_PROCESSOR_SHELL_PATH || 'tools/perfetto/trace_processor_shell'); + process.env.TRACE_PROCESSOR_SHELL_PATH || + `tools/perfetto/trace_processor_shell${common.isWindows ? '.exe' : ''}`); // The JSON form of a trace runs about three times the size of the trace it was // converted from, and the traces these tests produce are a few hundred KiB at @@ -29,7 +31,7 @@ const defaultTraceFileName = `node_trace.1.${traceFileExt}`; function checkTraceProcessor() { if (common.hasPerfetto && !fs.existsSync(traceProcessor)) { assert.fail('trace_processor_shell is missing, ' + - 'run `make tools/perfetto/trace_processor_shell` to download it'); + 'run `python3 tools/perfetto/get_trace_processor.py` to download it'); } } diff --git a/test/trace_events/README.md b/test/trace_events/README.md index 756dd9aeba6..6b78efd220b 100644 --- a/test/trace_events/README.md +++ b/test/trace_events/README.md @@ -2,10 +2,12 @@ When the `node` binary is built with configure flag `--with-perfetto`, the tests in this folder depends on `tools/perfetto/trace_processor_shell`, -which is downloaded with `tools/perfetto/get_trace_processor` via +which is downloaded with `tools/perfetto/get_trace_processor.py` via `make tools/perfetto/trace_processor_shell`, to convert Perfetto binary trace -files to JSON format. Set `TRACE_PROCESSOR_SHELL_PATH` to use an existing build -of the tool instead of downloading a release. +files to JSON format. On Windows, `vcbuild.bat` downloads +`tools/perfetto/trace_processor_shell.exe` with the same script before running +the tests. Set `TRACE_PROCESSOR_SHELL_PATH` to use an existing build of the +tool instead of downloading a release. Refer to for help of the `trace_processor_shell` CLI. diff --git a/tools/perfetto/get_trace_processor b/tools/perfetto/get_trace_processor deleted file mode 100755 index f00fee8b21e..00000000000 --- a/tools/perfetto/get_trace_processor +++ /dev/null @@ -1,36 +0,0 @@ -#!/bin/sh -# Downloads perfetto's trace_processor_shell, matching the SDK version vendored -# in deps/perfetto. The trace events tests read back the binary traces that -# perfetto builds write through this tool. -set -e - -script_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd) -version=$(cat "$script_dir/../../deps/perfetto/VERSION") -trace_processor="${1:-$script_dir/trace_processor_shell}" - -# Perfetto names its release archives -, which does not match uname. -case "$(uname -s)" in - Darwin) os=mac ;; - Linux) os=linux ;; - *) echo "No perfetto release for $(uname -s)" >&2; exit 1 ;; -esac - -case "$(uname -m)" in - x86_64 | amd64) arch=amd64 ;; - arm64 | aarch64) arch=arm64 ;; - *) echo "No perfetto release for $(uname -m)" >&2; exit 1 ;; -esac - -url="https://github.com/google/perfetto/releases/download/v$version/$os-$arch.zip" -archive=$(mktemp) - -rm -f "$trace_processor" -echo "Downloading $url" -curl -sSfL -o "$archive" "$url" -unzip -q -j -o "$archive" '*/trace_processor_shell' -d "$script_dir" -rm -f "$archive" -chmod +x "$trace_processor" -# The archive carries the release's own mtime. Make decides whether the tool is -# current by comparing it against deps/perfetto/VERSION, so it has to come out -# newer than the version file it was downloaded for. -touch "$trace_processor" diff --git a/tools/perfetto/get_trace_processor.py b/tools/perfetto/get_trace_processor.py new file mode 100755 index 00000000000..ed519922b19 --- /dev/null +++ b/tools/perfetto/get_trace_processor.py @@ -0,0 +1,61 @@ +#!/usr/bin/env python3 +# Downloads perfetto's trace_processor_shell, matching the SDK version vendored +# in deps/perfetto. The trace events tests read back the binary traces that +# perfetto builds write through this tool. + +import io +import os +import platform +import sys +import urllib.request +import zipfile + +script_dir = os.path.dirname(os.path.abspath(__file__)) +version_file = os.path.join(script_dir, '..', '..', 'deps', 'perfetto', 'VERSION') +is_windows = platform.system() == 'Windows' + +# Perfetto names its release archives -, which does not match what +# platform reports. +OS_NAMES = {'Darwin': 'mac', 'Linux': 'linux'} +ARCH_NAMES = {'x86_64': 'amd64', 'arm64': 'arm64', 'aarch64': 'arm64'} + + +def release_name(): + # Perfetto releases only an x64 build for Windows. Windows on arm64 runs it + # under emulation. + if is_windows: + return 'windows-amd64' + + os_name = OS_NAMES.get(platform.system()) + arch = ARCH_NAMES.get(platform.machine()) + if os_name is None or arch is None: + sys.exit(f'No perfetto release for {platform.system()} {platform.machine()}') + return f'{os_name}-{arch}' + + +def main(): + exe = 'trace_processor_shell.exe' if is_windows else 'trace_processor_shell' + trace_processor = sys.argv[1] if len(sys.argv) > 1 else os.path.join(script_dir, exe) + + # The tool is current when it is newer than the version file it was + # downloaded for, so a version bump re-downloads it. + if (os.path.exists(trace_processor) and + os.path.getmtime(trace_processor) > os.path.getmtime(version_file)): + return + + with open(version_file) as f: + version = f.read().strip() + name = release_name() + url = f'https://github.com/google/perfetto/releases/download/v{version}/{name}.zip' + + print(f'Downloading {url}') + with urllib.request.urlopen(url) as response: + archive = zipfile.ZipFile(io.BytesIO(response.read())) + print(f'Extracting {name}/{exe} to {trace_processor}') + with open(trace_processor, 'wb') as dst: + dst.write(archive.read(f'{name}/{exe}')) + os.chmod(trace_processor, 0o755) + + +if __name__ == '__main__': + main() diff --git a/vcbuild.bat b/vcbuild.bat index a1c18ace6a3..4ef76449aa6 100644 --- a/vcbuild.bat +++ b/vcbuild.bat @@ -85,6 +85,7 @@ set compile_commands= set cfg= set v8temporal= set v8windbg= +set with_perfetto= set exit_code=0 :next-arg @@ -116,6 +117,7 @@ if /i "%1"=="pgo-generate" set pgo_generate=1&goto arg-ok if /i "%1"=="pgo-use" set pgo_use=1&goto arg-ok if /i "%1"=="v8temporal" set v8temporal=1&goto arg-ok if /i "%1"=="v8windbg" set v8windbg=1&goto arg-ok +if /i "%1"=="with-perfetto" set with_perfetto=1&goto arg-ok if /i "%1"=="licensertf" set licensertf=1&goto arg-ok if /i "%1"=="test" set test_args=%test_args% %common_test_suites%&set lint_cpp=1&set lint_js=1&set lint_md=1&goto arg-ok if /i "%1"=="test-ci-native" set test_args=%test_args% %test_ci_args% -p tap --logfile test.tap %CI_NATIVE_SUITES% %CI_DOC%&set build_addons=1&set build_js_native_api_tests=1&set build_node_api_tests=1&set build_ffi_tests=1&set cctest_args=%cctest_args% --gtest_output=xml:cctest.junit.xml&goto arg-ok @@ -272,6 +274,7 @@ if defined compile_commands set configure_flags=%configure_flags% -C if defined cfg set configure_flags=%configure_flags% --control-flow-guard if defined v8temporal set configure_flags=%configure_flags% --v8-enable-temporal-support if defined v8windbg set configure_flags=%configure_flags% --enable-v8windbg +if defined with_perfetto set configure_flags=%configure_flags% --with-perfetto if "%target_arch%"=="x86" ( echo "32-bit Windows builds are not supported anymore." @@ -824,6 +827,13 @@ echo running 'cctest %cctest_args%' "%config%\cctest" %cctest_args% if %errorlevel% neq 0 set exit_code=%errorlevel% :run-test-py +@rem Download trace_processor_shell for perfetto builds. +if defined TRACE_PROCESSOR_SHELL_PATH goto run-test-py-start +findstr /r /c:"v8_use_perfetto.: 1," config.gypi >nul 2>&1 +if errorlevel 1 goto run-test-py-start +python tools\perfetto\get_trace_processor.py +if errorlevel 1 exit /b 1 +:run-test-py-start echo running 'python tools\test.py %test_args%' python tools\test.py %test_args% if %errorlevel% neq 0 set exit_code=%errorlevel% From a066b2cf04d03bfc9fefc66af7fe88031ac47050 Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Fri, 23 Oct 2026 19:37:13 -0300 Subject: [PATCH 102/331] doc: add rafael and antoine as last security release stewards Signed-off-by: RafaelGSS PR-URL: https://github.com/nodejs/node/pull/66909 Reviewed-By: Richard Lau Reviewed-By: Antoine du Hamel Reviewed-By: Luigi Pinca Reviewed-By: Yagiz Nizipli --- doc/contributing/security-release-process.md | 55 ++++++++++---------- 1 file changed, 28 insertions(+), 27 deletions(-) diff --git a/doc/contributing/security-release-process.md b/doc/contributing/security-release-process.md index e5ecbe39e40..7444707774f 100644 --- a/doc/contributing/security-release-process.md +++ b/doc/contributing/security-release-process.md @@ -19,33 +19,34 @@ steps listed in the process as outlined in The current security stewards are documented in the main Node.js [README.md](https://github.com/nodejs/node#security-release-stewards). -| Company | Person | Release Date | -| ----------------------- | --------------- | ------------ | -| NearForm | Matteo | 2021-Oct-12 | -| Datadog | Bryan | 2022-Jan-10 | -| RH and IBM | Joe | 2022-Mar-18 | -| NearForm | Matteo / Rafael | 2022-Jul-07 | -| Datadog | Vladimir | 2022-Sep-23 | -| NodeSource | Juan | 2022-Nov-04 | -| RH and IBM | Michael | 2023-Feb-16 | -| NearForm | Rafael | 2023-Jun-20 | -| NearForm | Rafael | 2023-Aug-09 | -| NearForm | Rafael | 2023-Oct-13 | -| NodeSource | Rafael | 2024-Feb-14 | -| NodeSource | Rafael | 2024-Apr-03 | -| NodeSource | Rafael | 2024-Apr-10 | -| NodeSource | Rafael | 2024-Jul-08 | -| NodeSource | Rafael | 2025-Jan-21 | -| NodeSource | Rafael | 2025-May-14 | -| NodeSource | Rafael | 2025-Jul-15 | -| HeroDevs and NodeSource | Marco / Rafael | 2026-Jan-13 | -| NodeSource | Rafael | 2026-Mar-24 | -| Platformatic | Antoine | 2026-Jun-18 | -| NodeSource | Rafael | 2026-Jul-29 | -| Datadog | Bryan | | -| IBM | Joe | | -| Platformatic | Matteo | | -| NodeSource | Juan | | +| Company | Person | Release Date | +| --------------------------- | ---------------- | ------------ | +| NearForm | Matteo | 2021-Oct-12 | +| Datadog | Bryan | 2022-Jan-10 | +| RH and IBM | Joe | 2022-Mar-18 | +| NearForm | Matteo / Rafael | 2022-Jul-07 | +| Datadog | Vladimir | 2022-Sep-23 | +| NodeSource | Juan | 2022-Nov-04 | +| RH and IBM | Michael | 2023-Feb-16 | +| NearForm | Rafael | 2023-Jun-20 | +| NearForm | Rafael | 2023-Aug-09 | +| NearForm | Rafael | 2023-Oct-13 | +| NodeSource | Rafael | 2024-Feb-14 | +| NodeSource | Rafael | 2024-Apr-03 | +| NodeSource | Rafael | 2024-Apr-10 | +| NodeSource | Rafael | 2024-Jul-08 | +| NodeSource | Rafael | 2025-Jan-21 | +| NodeSource | Rafael | 2025-May-14 | +| NodeSource | Rafael | 2025-Jul-15 | +| HeroDevs and NodeSource | Marco / Rafael | 2026-Jan-13 | +| NodeSource | Rafael | 2026-Mar-24 | +| Platformatic | Antoine | 2026-Jun-18 | +| NodeSource | Rafael | 2026-Jul-29 | +| NodeSource and Platformatic | Rafael / Antoine | 2026-Oct-21 | +| Datadog | Bryan | | +| IBM | Joe | | +| Platformatic | Matteo | | +| NodeSource | Juan | | ## Planning From fdadf15323dd1c456684f677c30ecfcb468a1b96 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Sat, 24 Oct 2026 00:47:44 +0200 Subject: [PATCH 103/331] test: fix TLS coalescing test for OpenSSL 4.1 Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/66962 Refs: https://ci.nodejs.org/job/node-test-pull-request/78600/ Reviewed-By: Antoine du Hamel Reviewed-By: Richard Lau Reviewed-By: Luigi Pinca --- test/parallel/test-tls-coalesce-records.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/parallel/test-tls-coalesce-records.js b/test/parallel/test-tls-coalesce-records.js index 9eb6289c73a..d247ec29073 100644 --- a/test/parallel/test-tls-coalesce-records.js +++ b/test/parallel/test-tls-coalesce-records.js @@ -7,7 +7,7 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); -const { isBoringSSL } = require('../common/crypto'); +const { hasOpenSSL, isBoringSSL } = require('../common/crypto'); const assert = require('assert'); const net = require('net'); const tls = require('tls'); @@ -117,7 +117,7 @@ function sendPayload(socket) { })); client.on('data', (chunk) => chunks.push(chunk)); client.on('error', common.mustCall((err) => { - assert.strictEqual(err.code, isBoringSSL ? + assert.strictEqual(err.code, isBoringSSL || hasOpenSSL(4, 1) ? 'ERR_SSL_BAD_DECRYPT' : 'ERR_SSL_DECRYPTION_FAILED_OR_BAD_RECORD_MAC'); assert.deepStrictEqual(Buffer.concat(chunks), From 53570d28daceecc55fcf8a0db9d002426a414453 Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Fri, 23 Oct 2026 20:55:50 -0700 Subject: [PATCH 104/331] ffi: drain task queues after event loop callbacks When native code invokes a registered callback from the event loop, no callback scope is active. A nextTick or microtask queued by the callback only ran when an unrelated Node.js callback fired, or at beforeExit. Open an InternalCallbackScope in InvokeCallback when no scope is active, so the queues are drained when the callback returns. Callbacks invoked synchronously during a call into native code already run inside the caller's scope and are left unchanged. Signed-off-by: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Assisted-by: claude:opus-5.5 PR-URL: https://github.com/nodejs/node/pull/66918 Fixes: https://github.com/nodejs/node/issues/66917 Reviewed-By: Paolo Insogna Reviewed-By: Daeyeon Jeong Reviewed-By: Matteo Collina --- src/node_ffi.cc | 13 ++++++++ test/ffi/test-ffi-callbacks.js | 60 ++++++++++++++++++++++++++++++++++ 2 files changed, 73 insertions(+) diff --git a/src/node_ffi.cc b/src/node_ffi.cc index 0cce543e469..afdc8f1fd36 100644 --- a/src/node_ffi.cc +++ b/src/node_ffi.cc @@ -5,6 +5,7 @@ #include #include #include +#include #include "base_object-inl.h" #include "env-inl.h" #include "ffi/data.h" @@ -13,6 +14,7 @@ #include "ffi/types.h" #include "node_binding.h" #include "node_errors.h" +#include "node_internals.h" namespace node { @@ -772,6 +774,17 @@ void DynamicLibrary::InvokeCallback(ffi_cif* cif, callback_args[i] = ToJSArgument(isolate, cb->args[i], args[i]); } + // When native code invokes the callback from the event loop (for example + // through a libuv handle), no callback scope is active. Open one so that + // nextTick and microtasks queued by the callback are drained when it + // returns, as for Node.js's own callbacks. Callbacks invoked synchronously + // during a call into native code already run inside the caller's scope. + Context::Scope context_scope(context); + std::optional callback_scope; + if (env->async_callback_scope_depth() == 0) { + callback_scope.emplace(env, Object::New(isolate), async_context{0, 0}); + } + TryCatch try_catch(isolate); Local callback = Local::New(isolate, cb->fn); MaybeLocal result = callback->Call( diff --git a/test/ffi/test-ffi-callbacks.js b/test/ffi/test-ffi-callbacks.js index e402343bbc2..2dca67d6605 100644 --- a/test/ffi/test-ffi-callbacks.js +++ b/test/ffi/test-ffi-callbacks.js @@ -82,3 +82,63 @@ test('ffi callback ref and unref APIs work', () => { lib.close(); } }); + +test('ffi callbacks drain nextTick and microtasks only from the event loop', { + skip: common.isWindows, +}, async () => { + const { lib, functions: symbols } = getLibrary(); + let ran = false; + const syncCallback = lib.registerCallback( + { arguments: ['i32'], return: 'i32' }, + (value) => { + queueMicrotask(() => { ran = true; }); + return value; + }, + ); + + // The process exports libuv, so a uv timer can invoke the callback from + // the event loop with no JS on the stack. + const { lib: uvLib, functions: uv } = ffi.dlopen(null, { + uv_handle_size: { arguments: ['i32'], return: 'u64' }, + uv_timer_init: { arguments: ['pointer', 'pointer'], return: 'i32' }, + uv_timer_start: { arguments: ['pointer', 'pointer', 'u64', 'u64'], return: 'i32' }, + uv_close: { arguments: ['pointer', 'pointer'], return: 'void' }, + }); + const UV_TIMER = 13; + const timerSize = Number(uv.uv_handle_size(UV_TIMER)) + 64; + const timers = [new Uint8Array(timerSize), new Uint8Array(timerSize)]; + const { promise, resolve } = Promise.withResolvers(); + const order = []; + const timerCallbacks = [ + uvLib.registerCallback({ arguments: ['pointer'], return: 'void' }, () => { + order.push('callback'); + process.nextTick(() => order.push('nextTick')); + queueMicrotask(() => order.push('microtask')); + }), + // The second timer runs right after the first one, with no Node.js + // callback in between that could drain the queues instead. + uvLib.registerCallback({ arguments: ['pointer'], return: 'void' }, () => { + resolve([...order]); + for (const timer of timers) uv.uv_close(timer, 0n); + }), + ]; + + try { + // A callback invoked synchronously runs inside the caller's scope, so its + // microtasks must not run before the native call returns. + assert.strictEqual(symbols.call_int_callback(syncCallback, 1), 1); + assert.strictEqual(ran, false); + + const loop = ffi.getCurrentEventLoop(); + for (let i = 0; i < timers.length; i++) { + assert.strictEqual(uv.uv_timer_init(loop, timers[i]), 0); + assert.strictEqual(uv.uv_timer_start(timers[i], timerCallbacks[i], 0n, 0n), 0); + } + assert.deepStrictEqual(await promise, ['callback', 'nextTick', 'microtask']); + // Let the uv_close() of the timer handles complete. + await new Promise(setImmediate); + } finally { + lib.close(); + uvLib.close(); + } +}); From f07e33fc17cacf1229de5be50f98073e56f7199d Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Sat, 24 Oct 2026 08:59:20 +0200 Subject: [PATCH 105/331] tools: grant CI workflows Actions read permission The workflow run metadata query in node-core-utils requires Actions read permission for GITHUB_TOKEN. Grant it to the commit queue and automatic CI jobs. Refs: https://github.com/nodejs/node-core-utils/pull/1192 Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/66919 Reviewed-By: Antoine du Hamel Reviewed-By: Mike McCready <66998419+MikeMcC399@users.noreply.github.com> Reviewed-By: Colin Ihrig Reviewed-By: Tierney Cyren Reviewed-By: Luigi Pinca --- .github/workflows/auto-start-ci.yml | 1 + .github/workflows/commit-queue.yml | 1 + 2 files changed, 2 insertions(+) diff --git a/.github/workflows/auto-start-ci.yml b/.github/workflows/auto-start-ci.yml index 85f3e92f2ff..3c7872baab7 100644 --- a/.github/workflows/auto-start-ci.yml +++ b/.github/workflows/auto-start-ci.yml @@ -54,6 +54,7 @@ jobs: BATCH_SIZE: ${{ vars.AUTO_START_CI_BATCH_SIZE || '5' }} start-ci: permissions: + actions: read checks: read contents: read pull-requests: write diff --git a/.github/workflows/commit-queue.yml b/.github/workflows/commit-queue.yml index 83f921838b3..520b0239ff4 100644 --- a/.github/workflows/commit-queue.yml +++ b/.github/workflows/commit-queue.yml @@ -59,6 +59,7 @@ jobs: needs: get_candidate_prs if: needs.get_candidate_prs.outputs.candidates != '' permissions: + actions: read checks: read contents: read pull-requests: read From 6fef75c41fbd47e316aff7e7e3f891a4daa670de Mon Sep 17 00:00:00 2001 From: Robert Nagy Date: Sat, 24 Oct 2026 21:17:24 +0200 Subject: [PATCH 106/331] lib: speed up AbortSignal Speed up creating and aborting signals, adding and removing abort listeners, AbortSignal.any() and AbortSignal.timeout(), and stop the default abort reason from retaining the aborting caller. - Only allocate and dispatch the abort event when the signal has abort listeners, and only allocate the dependent signal list when there are dependent signals. - Track whether an event is trusted with a private field instead of a WeakSet. - Flatten addEventListener() options into locals instead of allocating a normalized options object, only validate the signal option when one is passed, and use the listener flags directly. - Call the EventTarget kNewListener and kRemoveListener implementations directly. V8 does not optimize keyed super property access such as super[kNewListener](). - Initialize the internal slots that AbortSignal.any() adds to its sources up front, and the composite-only slots for composites, so live signals don't change shape. - Give every signal a single WeakRef that is shared by all the composites that follow it, and register each composite and each source once with their cleanup registries instead of registering every (source, composite) pair with an unregister token. Registering with an unregister token is several times more expensive. - Register AbortSignal.timeout() timers through a holder that is emptied when the timer fires, instead of using the signal as an unregister token. - Take positional arguments in AbortSignal's internal constructor instead of destructuring an options object that defaults to kEmptyObject. kEmptyObject is a null-prototype object, which V8 keeps in dictionary mode, so each of those reads was an uncached dictionary miss that cost more than the rest of the constructor. - Create the default abort reason with Error.stackTraceLimit set to 0. Until a captured stack is formatted, V8 keeps the call sites, which retain the receivers and functions of the aborting caller's frames, so a retained signal kept the aborted work alive. Formatting the stack eagerly would fix that but costs several microseconds per abort(). The default AbortError no longer shows where abort() was called; callers that want that can pass their own reason. - Add benchmarks for aborting, adding and removing abort listeners, and AbortSignal.any(). Refs: https://github.com/nodejs/node/issues/66192 Refs: https://github.com/nodejs/node/pull/66265 Assisted-by: claude:opus-5.5 Signed-off-by: Robert Nagy PR-URL: https://github.com/nodejs/node/pull/66789 Reviewed-By: Yagiz Nizipli --- .../abort-controller-abort.js | 21 ++ .../abort-signal-add-remove.js | 43 ++++ .../abort_controller/abort-signal-any.js | 46 ++++ lib/internal/abort_controller.js | 243 +++++++++++------- lib/internal/event_target.js | 98 +++---- .../test-runner/output/abort.snapshot | 20 -- .../test-runner/output/abort_hooks.snapshot | 24 -- .../test-runner/output/abort_suite.snapshot | 10 - ...test-abortcontroller-default-reason-gc.mjs | 66 +++++ test/parallel/test-abortsignal-any.mjs | 19 ++ .../test-abortsignal-drop-settled-signals.mjs | 17 ++ test/parallel/test-eventtarget.js | 31 +++ 12 files changed, 439 insertions(+), 199 deletions(-) create mode 100644 benchmark/abort_controller/abort-controller-abort.js create mode 100644 benchmark/abort_controller/abort-signal-add-remove.js create mode 100644 benchmark/abort_controller/abort-signal-any.js create mode 100644 test/parallel/test-abortcontroller-default-reason-gc.mjs diff --git a/benchmark/abort_controller/abort-controller-abort.js b/benchmark/abort_controller/abort-controller-abort.js new file mode 100644 index 00000000000..c1c97718f82 --- /dev/null +++ b/benchmark/abort_controller/abort-controller-abort.js @@ -0,0 +1,21 @@ +'use strict'; +const common = require('../common.js'); + +const bench = common.createBenchmark(main, { + n: [1e6], + listeners: [0, 1], +}); + +function main({ n, listeners }) { + const reason = new Error('reason'); + const noop = () => {}; + + bench.start(); + for (let i = 0; i < n; i++) { + const ac = new AbortController(); + if (listeners > 0) + ac.signal.addEventListener('abort', noop); + ac.abort(reason); + } + bench.end(n); +} diff --git a/benchmark/abort_controller/abort-signal-add-remove.js b/benchmark/abort_controller/abort-signal-add-remove.js new file mode 100644 index 00000000000..77a5216f238 --- /dev/null +++ b/benchmark/abort_controller/abort-signal-add-remove.js @@ -0,0 +1,43 @@ +'use strict'; +const common = require('../common.js'); +const { addAbortListener } = require('events'); + +const bench = common.createBenchmark(main, { + n: [1e6], + kind: ['addEventListener', 'addEventListener-once', 'addAbortListener'], +}); + +function main({ n, kind }) { + const { signal } = new AbortController(); + const noop = () => {}; + + switch (kind) { + case 'addEventListener': + bench.start(); + for (let i = 0; i < n; i++) { + signal.addEventListener('abort', noop); + signal.removeEventListener('abort', noop); + } + bench.end(n); + break; + case 'addEventListener-once': { + const options = { once: true }; + bench.start(); + for (let i = 0; i < n; i++) { + signal.addEventListener('abort', noop, options); + signal.removeEventListener('abort', noop); + } + bench.end(n); + break; + } + case 'addAbortListener': + bench.start(); + for (let i = 0; i < n; i++) { + addAbortListener(signal, noop)[Symbol.dispose](); + } + bench.end(n); + break; + default: + throw new Error('Invalid kind'); + } +} diff --git a/benchmark/abort_controller/abort-signal-any.js b/benchmark/abort_controller/abort-signal-any.js new file mode 100644 index 00000000000..96981067e50 --- /dev/null +++ b/benchmark/abort_controller/abort-signal-any.js @@ -0,0 +1,46 @@ +'use strict'; +const common = require('../common.js'); + +const bench = common.createBenchmark(main, { + n: [2e5], + kind: ['create', 'listen', 'abort'], +}); + +// Combines a per-iteration signal with a long-lived one, like a request +// signal combined with a server wide one. The work is split into batches +// that run in separate macrotasks because WeakRef targets are kept alive +// until the end of the current job, as they would be between requests. +function main({ n, kind }) { + const reason = new Error('reason'); + const noop = () => {}; + const longLived = new AbortController().signal; + const batch = 1000; + + function run(count) { + for (let i = 0; i < count; i++) { + const ac = new AbortController(); + const signal = AbortSignal.any([ac.signal, longLived]); + if (kind === 'create') + continue; + signal.addEventListener('abort', noop, { once: true }); + if (kind === 'listen') + signal.removeEventListener('abort', noop); + else + ac.abort(reason); + } + } + + let left = n; + function step() { + const count = Math.min(batch, left); + run(count); + left -= count; + if (left > 0) + setImmediate(step); + else + bench.end(n); + } + + bench.start(); + step(); +} diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js index 9722484a422..7daa63e1f91 100644 --- a/lib/internal/abort_controller.js +++ b/lib/internal/abort_controller.js @@ -5,9 +5,11 @@ const { ArrayPrototypePush, + FunctionPrototypeCall, ObjectAssign, ObjectDefineProperties, ObjectDefineProperty, + ObjectFreeze, ObjectSetPrototypeOf, PromiseResolve, PromiseWithResolvers, @@ -22,6 +24,7 @@ const { defineEventHandler, EventTarget, Event, + kEvents, kTrustEvent, kNewListener, kRemoveListener, @@ -31,7 +34,6 @@ const { const { kMaxEventTargetListeners } = require('events'); const { customInspectSymbol, - kEmptyObject, kEnumerableProperty, } = require('internal/util'); const { inspect } = require('internal/util/inspect'); @@ -41,6 +43,7 @@ const { ERR_INVALID_ARG_TYPE, ERR_INVALID_THIS, }, + isErrorStackTraceLimitWritable, } = require('internal/errors'); const { converters, @@ -75,6 +78,15 @@ let _MessageChannel; const kDontThrowSymbol = Symbol('kDontThrowSymbol'); +const kTrustedEventInit = ObjectFreeze({ [kTrustEvent]: true }); + +// V8 doesn't optimize keyed super property access such as +// super[kNewListener](), so call the EventTarget implementations directly. +const { + [kNewListener]: eventTargetNewListener, + [kRemoveListener]: eventTargetRemoveListener, +} = EventTarget.prototype; + // Loading the MessageChannel and markTransferable have to be done lazily // because otherwise we'll end up with a require cycle that ends up with // an incomplete initialization of abort_controller. @@ -84,28 +96,37 @@ function lazyMessageChannel() { return new _MessageChannel(); } -const clearTimeoutRegistry = new SafeFinalizationRegistry(clearTimeout); -const dependantSignalsCleanupRegistry = new SafeFinalizationRegistry( - ({ sourceSignalRef, dependantSignalRef }) => { - sourceSignalsCleanupRegistry.unregister(dependantSignalRef); +const clearTimeoutRegistry = new SafeFinalizationRegistry((holder) => { + if (holder.timeout !== undefined) { + clearTimeout(holder.timeout); + } +}); - const sourceSignal = sourceSignalRef.deref(); - if (sourceSignal === undefined) { - return; +// Each followed composite signal is registered once. When it is collected, +// remove it from the dependant signals of its remaining sources. +const dependantSignalsCleanupRegistry = new SafeFinalizationRegistry( + ({ sourceSignals, dependantSignalRef }) => { + for (const sourceSignalRef of sourceSignals) { + sourceSignalRef.deref()?.[kDependantSignals]?.delete(dependantSignalRef); } - sourceSignal[kDependantSignals].delete(dependantSignalRef); }); const gcPersistentSignals = new SafeSet(); -const sourceSignalsCleanupRegistry = new SafeFinalizationRegistry(({ sourceSignalRef, composedSignalRef }) => { - const composedSignal = composedSignalRef.deref(); - if (composedSignal !== undefined) { - composedSignal[kSourceSignals].delete(sourceSignalRef); - - if (composedSignal[kSourceSignals].size === 0) { - // This signal will no longer abort. There's no need to keep it in the gcPersistentSignals set. - gcPersistentSignals.delete(composedSignal); +// Each source signal is registered once, when it gets its first dependant. +// When it is collected, remove it from the source signals of its remaining +// dependants. Registering per source rather than per (source, dependant) pair +// avoids unregister tokens, which are expensive to register. +const sourceSignalsCleanupRegistry = new SafeFinalizationRegistry(({ sourceSignalRef, dependantSignals }) => { + for (const composedSignalRef of dependantSignals) { + const composedSignal = composedSignalRef.deref(); + if (composedSignal !== undefined) { + composedSignal[kSourceSignals].delete(sourceSignalRef); + + if (composedSignal[kSourceSignals].size === 0) { + // This signal will no longer abort. There's no need to keep it in the gcPersistentSignals set. + gcPersistentSignals.delete(composedSignal); + } } } }); @@ -117,10 +138,16 @@ const kTimeout = Symbol('kTimeout'); const kMakeTransferable = Symbol('kMakeTransferable'); const kComposite = Symbol('kComposite'); const kFollowing = Symbol('kFollowing'); -const kResultSignalWeakRef = Symbol('kResultSignalWeakRef'); +const kWeakRef = Symbol('kWeakRef'); const kSourceSignals = Symbol('kSourceSignals'); const kDependantSignals = Symbol('kDependantSignals'); +// A signal's own WeakRef, shared by every composite that follows it so that +// a long-lived source doesn't allocate a new WeakRef per AbortSignal.any(). +function getWeakRef(signal) { + return signal[kWeakRef] ??= new SafeWeakRef(signal); +} + function customInspect(self, obj, depth, options) { if (depth < 0) return self; @@ -161,12 +188,18 @@ function followCompositeSignal(signal) { return; } - const resultSignalWeakRef = signal[kResultSignalWeakRef] ??= new SafeWeakRef(signal); + const resultSignalWeakRef = getWeakRef(signal); + const sourceSignals = signal[kSourceSignals]; - for (const sourceSignalWeakRef of signal[kSourceSignals]) { + dependantSignalsCleanupRegistry.register(signal, { + sourceSignals, + dependantSignalRef: resultSignalWeakRef, + }); + + for (const sourceSignalWeakRef of sourceSignals) { const sourceSignal = sourceSignalWeakRef.deref(); if (sourceSignal === undefined) { - signal[kSourceSignals].delete(sourceSignalWeakRef); + sourceSignals.delete(sourceSignalWeakRef); continue; } @@ -175,19 +208,15 @@ function followCompositeSignal(signal) { return; } - sourceSignal[kDependantSignals] ??= new SafeSet(); - sourceSignal[kDependantSignals].add(resultSignalWeakRef); - dependantSignalsCleanupRegistry.register(signal, { - sourceSignalRef: sourceSignalWeakRef, - dependantSignalRef: resultSignalWeakRef, - }); - // Nested composites share their sources' WeakRefs, so use this signal's - // own WeakRef as the unregister token. Otherwise collecting an inner - // composite would also unregister the outer composite from its sources. - sourceSignalsCleanupRegistry.register(sourceSignal, { - sourceSignalRef: sourceSignalWeakRef, - composedSignalRef: resultSignalWeakRef, - }, resultSignalWeakRef); + let dependantSignals = sourceSignal[kDependantSignals]; + if (dependantSignals === undefined) { + dependantSignals = sourceSignal[kDependantSignals] = new SafeSet(); + sourceSignalsCleanupRegistry.register(sourceSignal, { + sourceSignalRef: sourceSignalWeakRef, + dependantSignals, + }); + } + dependantSignals.add(resultSignalWeakRef); } signal[kFollowing] = true; @@ -201,11 +230,16 @@ function followCompositeSignal(signal) { // over the WeakRef rather than directly over the AbortSignal, and we unref // the created timer object. Separately, we add the signal to a // FinalizerRegistry that will clear the timeout when the signal is gc'd. +// The registry holds the timeout through a holder that is emptied once the +// timer fires, which releases the fired timer without having to unregister +// the signal. Registering with an unregister token is several times more +// expensive than registering without one. function setWeakAbortSignalTimeout(weakRef, delay) { - const timeout = setTimeout(() => { + const holder = { timeout: undefined }; + holder.timeout = setTimeout(() => { + holder.timeout = undefined; const signal = weakRef.deref(); if (signal !== undefined) { - clearTimeoutRegistry.unregister(signal); gcPersistentSignals.delete(signal); abortSignal( signal, @@ -214,8 +248,25 @@ function setWeakAbortSignalTimeout(weakRef, delay) { 'TimeoutError')); } }, delay); - timeout.unref(); - return timeout; + holder.timeout.unref(); + return holder; +} + +// The default reason captures no stack. A captured stack keeps the receivers +// and functions of the aborting caller's frames alive until it is formatted, +// so a retained signal would keep the aborted work alive, and formatting it +// eagerly costs several microseconds per abort. Callers that want the stack +// can pass their own reason. +// Refs: https://github.com/nodejs/node/issues/66192 +function createDefaultAbortReason() { + if (!isErrorStackTraceLimitWritable()) { + return new DOMException('This operation was aborted', 'AbortError'); + } + const limit = Error.stackTraceLimit; + Error.stackTraceLimit = 0; + const reason = new DOMException('This operation was aborted', 'AbortError'); + Error.stackTraceLimit = limit; + return reason; } class AbortSignal extends EventTarget { @@ -229,31 +280,37 @@ class AbortSignal extends EventTarget { } /** + * Takes positional arguments rather than an options object: destructuring + * the default kEmptyObject, which V8 keeps in dictionary mode, cost more + * than the rest of the constructor. * @param {symbol | undefined} dontThrowSymbol - * @param {{ - * aborted? : boolean, - * reason? : any, - * transferable? : boolean, - * composite? : boolean, - * }} [init] + * @param {boolean} [aborted] + * @param {any} [reason] + * @param {boolean} [transferable] + * @param {boolean} [composite] * @private */ - constructor(dontThrowSymbol = undefined, init = kEmptyObject) { + constructor(dontThrowSymbol = undefined, aborted = false, reason = undefined, + transferable = false, composite = false) { if (dontThrowSymbol !== kDontThrowSymbol) { throw new ERR_ILLEGAL_CONSTRUCTOR(); } super(); this[kMaxEventTargetListeners] = 0; - const { - aborted = false, - reason = undefined, - transferable = false, - composite = false, - } = init; this[kAborted] = aborted; this[kReason] = reason; this[kComposite] = composite; + // Signals that become sources of AbortSignal.any() get these slots later. + // Initialize them up front so that adding them doesn't change the shape + // of live signals and make the call sites that use them polymorphic. + this[kWeakRef] = undefined; + this[kDependantSignals] = undefined; + if (composite) { + this[kTimeout] = false; + this[kFollowing] = false; + this[kSourceSignals] = undefined; + } if (transferable) { markTransferMode(this, false, true); } @@ -295,9 +352,8 @@ class AbortSignal extends EventTarget { * @param {any} [reason] * @returns {AbortSignal} */ - static abort( - reason = new DOMException('This operation was aborted', 'AbortError')) { - return new AbortSignal(kDontThrowSymbol, { aborted: true, reason }); + static abort(reason = createDefaultAbortReason()) { + return new AbortSignal(kDontThrowSymbol, true, reason); } /** @@ -310,8 +366,7 @@ class AbortSignal extends EventTarget { signal[kTimeout] = true; clearTimeoutRegistry.register( signal, - setWeakAbortSignalTimeout(new SafeWeakRef(signal), delay), - signal); + setWeakAbortSignalTimeout(getWeakRef(signal), delay)); return signal; } @@ -325,7 +380,7 @@ class AbortSignal extends EventTarget { { __proto__: null, context: 'signals' }, ); - const resultSignal = new AbortSignal(kDontThrowSymbol, { composite: true }); + const resultSignal = new AbortSignal(kDontThrowSymbol, false, undefined, false, true); if (!signalsArray.length) { return resultSignal; } @@ -354,8 +409,7 @@ class AbortSignal extends EventTarget { } if (!signal[kComposite]) { - const signalWeakRef = new SafeWeakRef(signal); - resultSignal[kSourceSignals].add(signalWeakRef); + resultSignal[kSourceSignals].add(getWeakRef(signal)); } else if (!signal[kSourceSignals]) { continue; } else { @@ -391,7 +445,7 @@ class AbortSignal extends EventTarget { } [kNewListener](size, type, listener, once, capture, passive, weak) { - super[kNewListener](size, type, listener, once, capture, passive, weak); + FunctionPrototypeCall(eventTargetNewListener, this, size, type, listener, once, capture, passive, weak); if (this[kComposite] && type === 'abort' && !this.aborted && size === 1) { followCompositeSignal(this); @@ -412,7 +466,7 @@ class AbortSignal extends EventTarget { } [kRemoveListener](size, type, listener, capture) { - super[kRemoveListener](size, type, listener, capture); + FunctionPrototypeCall(eventTargetRemoveListener, this, size, type, listener, capture); const isTimeoutOrNonEmptyCompositeSignal = this[kTimeout] || (this[kComposite] && this[kSourceSignals]?.size); if (isTimeoutOrNonEmptyCompositeSignal && type === 'abort' && size === 0) { gcPersistentSignals.delete(this); @@ -479,7 +533,7 @@ class AbortSignal extends EventTarget { converters['sequence'] = createSequenceConverter(converters.AbortSignal); function ClonedAbortSignal() { - return new AbortSignal(kDontThrowSymbol, { transferable: true }); + return new AbortSignal(kDontThrowSymbol, false, undefined, true); } ClonedAbortSignal.prototype[kDeserialize] = () => {}; @@ -508,36 +562,43 @@ function abortSignal(signal, reason) { signal[kReason] = reason; // 3. Let dependentSignalsToAbort be a new list. - const dependentSignalsToAbort = ObjectSetPrototypeOf([], null); + // The list is only allocated when there are dependent signals. + let dependentSignalsToAbort; // 4. For each dependentSignal of signal's dependent signals: - signal[kDependantSignals]?.forEach((s) => { - const dependentSignal = s.deref(); - // 1. If dependentSignal is not aborted, then: - if (dependentSignal && !dependentSignal[kAborted]) { - // 1. Set dependentSignal's abort reason to signal's abort reason. - dependentSignal[kReason] = reason; - dependentSignal[kAborted] = true; - // 2. Append dependentSignal to dependentSignalsToAbort. - ArrayPrototypePush(dependentSignalsToAbort, dependentSignal); - } - }); + const dependantSignals = signal[kDependantSignals]; + if (dependantSignals !== undefined && dependantSignals.size > 0) { + dependentSignalsToAbort = ObjectSetPrototypeOf([], null); + dependantSignals.forEach((s) => { + const dependentSignal = s.deref(); + // 1. If dependentSignal is not aborted, then: + if (dependentSignal && !dependentSignal[kAborted]) { + // 1. Set dependentSignal's abort reason to signal's abort reason. + dependentSignal[kReason] = reason; + dependentSignal[kAborted] = true; + // 2. Append dependentSignal to dependentSignalsToAbort. + ArrayPrototypePush(dependentSignalsToAbort, dependentSignal); + } + }); + } // 5. Run the abort steps for signal runAbort(signal); // 6. For each dependentSignal of dependentSignalsToAbort, // run the abort steps for dependentSignal. - for (let i = 0; i < dependentSignalsToAbort.length; i++) { - const dependentSignal = dependentSignalsToAbort[i]; - runAbort(dependentSignal); - // A transitively-aborted dependent signal can never abort again, so there - // is no longer any reason to keep it alive. Dropping it from - // gcPersistentSignals lets it be collected, which in turn prunes its - // WeakRef from its sources' kDependantSignals sets. Otherwise, an observed - // composite that follows a long-lived source stays retained forever and - // its entry accumulates in that source's kDependantSignals. - gcPersistentSignals.delete(dependentSignal); + if (dependentSignalsToAbort !== undefined) { + for (let i = 0; i < dependentSignalsToAbort.length; i++) { + const dependentSignal = dependentSignalsToAbort[i]; + runAbort(dependentSignal); + // A transitively-aborted dependent signal can never abort again, so there + // is no longer any reason to keep it alive. Dropping it from + // gcPersistentSignals lets it be collected, which in turn prunes its + // WeakRef from its sources' kDependantSignals sets. Otherwise, an observed + // composite that follows a long-lived source stays retained forever and + // its entry accumulates in that source's kDependantSignals. + gcPersistentSignals.delete(dependentSignal); + } } // Clean up the signal from gcPersistentSignals @@ -557,9 +618,13 @@ function abortSignal(signal, reason) { // To run the abort steps for an AbortSignal signal function runAbort(signal) { - const event = new Event('abort', { - [kTrustEvent]: true, - }); + // Firing an event at a signal without abort listeners has no observable + // effect, so skip allocating and dispatching it. + const root = signal[kEvents]?.get('abort'); + if (root === undefined || root.next === undefined) { + return; + } + const event = new Event('abort', kTrustedEventInit); signal.dispatchEvent(event); } @@ -578,7 +643,7 @@ class AbortController { /** * @param {any} [reason] */ - abort(reason = new DOMException('This operation was aborted', 'AbortError')) { + abort(reason = createDefaultAbortReason()) { abortSignal(this.#signal ??= new AbortSignal(kDontThrowSymbol), reason); } @@ -590,7 +655,7 @@ class AbortController { static [kMakeTransferable]() { const controller = new AbortController(); - controller.#signal = new AbortSignal(kDontThrowSymbol, { transferable: true }); + controller.#signal = new AbortSignal(kDontThrowSymbol, false, undefined, true); return controller; } } diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js index 69cdc4aac5b..c5f10408513 100644 --- a/lib/internal/event_target.js +++ b/lib/internal/event_target.js @@ -17,7 +17,6 @@ const { SafeSet, SafeWeakMap, SafeWeakRef, - SafeWeakSet, String, Symbol, SymbolFor, @@ -79,19 +78,7 @@ const kType = Symbol('type'); const kDetail = Symbol('detail'); const kInPassiveListener = Symbol('kInPassiveListener'); -const isTrustedSet = new SafeWeakSet(); -const isTrusted = ObjectGetOwnPropertyDescriptor({ - get isTrusted() { - return isTrustedSet.has(this); - }, -}, 'isTrusted').get; - -const isTrustedDescriptor = { - __proto__: null, - configurable: false, - enumerable: true, - get: isTrusted, -}; +let isTrusted; function isEvent(value) { return typeof value?.[kType] === 'string'; @@ -104,6 +91,16 @@ class Event { #defaultPrevented = false; #timestamp = now(); #propagationStopped = false; + #isTrusted = false; + + static { + isTrusted = ObjectGetOwnPropertyDescriptor({ + get isTrusted() { + return typeof this === 'object' && this !== null && + #isTrusted in this && this.#isTrusted; + }, + }, 'isTrusted').get; + } /** * @param {string} type @@ -124,7 +121,7 @@ class Event { this[kType] = `${type}`; if (options?.[kTrustEvent]) { - isTrustedSet.add(this); + this.#isTrusted = true; } this[kTarget] = null; @@ -367,7 +364,12 @@ ObjectDefineProperties( // LegacyUnforgeable but defining it in the constructor has a big // performance impact and the property doesn't seem to be useful outside of // browsers. - isTrusted: isTrustedDescriptor, + isTrusted: { + __proto__: null, + configurable: false, + enumerable: true, + get: isTrusted, + }, }); const staticProps = ['NONE', 'CAPTURING_PHASE', 'AT_TARGET', 'BUBBLING_PHASE']; @@ -481,9 +483,7 @@ class Listener { flags |= kFlagResistStopPropagation; this.flags = flags; - this.removed = false; - - if (this.weak) { + if (weak) { this.callback = new SafeWeakRef(listener); weakListeners().registry.register(listener, { __proto__: null, @@ -545,8 +545,9 @@ class Listener { } same(listener, capture) { - const myListener = this.weak ? this.listener.deref() : this.listener; - return myListener === listener && this.capture === capture; + const flags = this.flags; + const myListener = (flags & kFlagWeak) !== 0 ? this.listener.deref() : this.listener; + return myListener === listener && ((flags & kFlagCapture) !== 0) === capture; } remove() { @@ -554,8 +555,8 @@ class Listener { this.previous.next = this.next; if (this.next !== undefined) this.next.previous = this.previous; - this.removed = true; - if (this.weak) { + this.flags |= kFlagRemoved; + if ((this.flags & kFlagWeak) !== 0) { weakListeners().registry.unregister(this); const weakKey = this.weakKeyRef?.deref(); const listener = this.callback?.deref(); @@ -646,28 +647,31 @@ class EventTarget { let weak = false; let resistStopPropagation = false; - if (options !== kEmptyObject) { - // We validateOptions before the validateListener check because the spec - // requires us to hit getters. - options = validateEventListenerOptions(options); - - once = options.once; - capture = options.capture; - passive = options.passive; - isNodeStyleListener = options.isNodeStyleListener; - weak = options.weak; - resistStopPropagation = options.resistStopPropagation; - + // We flatten the options before the validateListener check because the + // spec requires us to hit getters. + if (typeof options === 'boolean') { + capture = options; + } else if (options !== kEmptyObject && options !== null) { + validateObject(options, 'options', kValidateObjectAllowObjects); + once = Boolean(options.once); + capture = Boolean(options.capture); + passive = Boolean(options.passive); const signal = options.signal; + weak = options[kWeakHandler]; + resistStopPropagation = options[kResistStopPropagation] ?? false; + isNodeStyleListener = Boolean(options[kIsNodeStyleListener]); - validateAbortSignal(signal, 'options.signal'); + if (signal !== undefined) { + validateAbortSignal(signal, 'options.signal'); - if (signal) { if (signal.aborted) { return; } + // Capture a copy so that the closure doesn't move `capture` into the + // function context, which slows down the listener lookup below. + const removeCapture = capture; signal.addEventListener('abort', () => { - this.removeEventListener(type, listener, options); + this.removeEventListener(type, listener, removeCapture); }, { __proto__: null, once: true, [kWeakHandler]: this, [kResistStopPropagation]: true }); } } @@ -1106,24 +1110,6 @@ function validateEventListener(listener) { throw new ERR_INVALID_ARG_TYPE('listener', 'EventListener', listener); } -function validateEventListenerOptions(options) { - if (typeof options === 'boolean') - return { capture: options }; - - if (options === null) - return kEmptyObject; - validateObject(options, 'options', kValidateObjectAllowObjects); - return { - once: Boolean(options.once), - capture: Boolean(options.capture), - passive: Boolean(options.passive), - signal: options.signal, - weak: options[kWeakHandler], - resistStopPropagation: options[kResistStopPropagation] ?? false, - isNodeStyleListener: Boolean(options[kIsNodeStyleListener]), - }; -} - // Test whether the argument is an event object. This is far from a fool-proof // test, for example this input will result in a false positive: // > isEventTarget({ constructor: EventTarget }) diff --git a/test/fixtures/test-runner/output/abort.snapshot b/test/fixtures/test-runner/output/abort.snapshot index 72504832704..2798e6e3a5a 100644 --- a/test/fixtures/test-runner/output/abort.snapshot +++ b/test/fixtures/test-runner/output/abort.snapshot @@ -54,8 +54,6 @@ TAP version 13 error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - ... # Subtest: not ok 4 not ok 8 - not ok 4 @@ -67,8 +65,6 @@ TAP version 13 error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - ... # Subtest: not ok 5 not ok 9 - not ok 5 @@ -80,8 +76,6 @@ TAP version 13 error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - ... 1..9 not ok 1 - promise timeout signal @@ -106,10 +100,6 @@ not ok 2 - promise abort signal error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - - Object. (/test/fixtures/test-runner/output/abort.js:21:52) - ... # Subtest: callback timeout signal # Subtest: ok 1 @@ -166,8 +156,6 @@ not ok 2 - promise abort signal error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - ... # Subtest: not ok 4 not ok 8 - not ok 4 @@ -179,8 +167,6 @@ not ok 2 - promise abort signal error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - ... # Subtest: not ok 5 not ok 9 - not ok 5 @@ -192,8 +178,6 @@ not ok 2 - promise abort signal error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - ... 1..9 not ok 3 - callback timeout signal @@ -218,10 +202,6 @@ not ok 4 - callback abort signal error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - - Object. (/test/fixtures/test-runner/output/abort.js:39:53) - ... 1..4 # tests 22 diff --git a/test/fixtures/test-runner/output/abort_hooks.snapshot b/test/fixtures/test-runner/output/abort_hooks.snapshot index 10a9c189e78..15e4fa6bddc 100644 --- a/test/fixtures/test-runner/output/abort_hooks.snapshot +++ b/test/fixtures/test-runner/output/abort_hooks.snapshot @@ -38,10 +38,6 @@ not ok 1 - 1 before describe error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - - before.signal (/test/fixtures/test-runner/output/abort_hooks.js:8:8) - ... # Subtest: 2 after describe # Subtest: test 1 @@ -66,10 +62,6 @@ not ok 2 - 2 after describe error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - - after.signal (/test/fixtures/test-runner/output/abort_hooks.js:23:8) - ... # Subtest: 3 beforeEach describe # Subtest: test 1 @@ -82,10 +74,6 @@ not ok 2 - 2 after describe error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - - beforeEach.signal (/test/fixtures/test-runner/output/abort_hooks.js:38:8) - ... # Subtest: test 2 not ok 2 - test 2 @@ -97,10 +85,6 @@ not ok 2 - 2 after describe error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - - beforeEach.signal (/test/fixtures/test-runner/output/abort_hooks.js:38:8) - ... 1..2 not ok 3 - 3 beforeEach describe @@ -123,10 +107,6 @@ not ok 3 - 3 beforeEach describe error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - - afterEach.signal (/test/fixtures/test-runner/output/abort_hooks.js:53:8) - ... # Subtest: test 2 not ok 2 - test 2 @@ -138,10 +118,6 @@ not ok 3 - 3 beforeEach describe error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - - afterEach.signal (/test/fixtures/test-runner/output/abort_hooks.js:53:8) - ... 1..2 not ok 4 - 4 afterEach describe diff --git a/test/fixtures/test-runner/output/abort_suite.snapshot b/test/fixtures/test-runner/output/abort_suite.snapshot index 0f1a1710c77..acbc7fab73e 100644 --- a/test/fixtures/test-runner/output/abort_suite.snapshot +++ b/test/fixtures/test-runner/output/abort_suite.snapshot @@ -54,8 +54,6 @@ TAP version 13 error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - ... # Subtest: not ok 4 not ok 8 - not ok 4 @@ -67,8 +65,6 @@ TAP version 13 error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - ... # Subtest: not ok 5 not ok 9 - not ok 5 @@ -80,8 +76,6 @@ TAP version 13 error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - ... 1..9 not ok 1 - describe timeout signal @@ -106,10 +100,6 @@ not ok 2 - describe abort signal error: 'This operation was aborted' code: 20 name: 'AbortError' - stack: |- - - Object. (/test/fixtures/test-runner/output/abort_suite.js:19:57) - ... 1..2 # tests 9 diff --git a/test/parallel/test-abortcontroller-default-reason-gc.mjs b/test/parallel/test-abortcontroller-default-reason-gc.mjs new file mode 100644 index 00000000000..7e004dd8065 --- /dev/null +++ b/test/parallel/test-abortcontroller-default-reason-gc.mjs @@ -0,0 +1,66 @@ +// Flags: --expose-gc + +import '../common/index.mjs'; +import { gcUntil } from '../common/gc.js'; +import assert from 'node:assert/strict'; +import { it } from 'node:test'; + +// The default abort reason must not keep the objects on the caller's stack +// alive. It captures no stack at all. Refs: https://github.com/nodejs/node/issues/66192 + +class Job { + controller = new AbortController(); + + cancel() { + this.controller.abort(); + return this.controller.signal; + } + + cancelStatic() { + return AbortSignal.abort(); + } +} + +for (const method of ['cancel', 'cancelStatic']) { + it(`does not retain the caller through the default reason (${method})`, async () => { + let job = new Job(); + const jobRef = new WeakRef(job); + const signal = job[method](); + job = null; + + await gcUntil('job is collected', () => jobRef.deref() === undefined); + assert.strictEqual(signal.aborted, true); + assert.ok(signal.reason instanceof DOMException); + assert.strictEqual(signal.reason.name, 'AbortError'); + assert.strictEqual(signal.reason.message, 'This operation was aborted'); + assert.doesNotMatch(signal.reason.stack, /\n\s+at /); + }); +} + +it('creates a new default reason for every abort', () => { + assert.notStrictEqual(new Job().cancel().reason, new Job().cancel().reason); + assert.notStrictEqual(AbortSignal.abort().reason, AbortSignal.abort().reason); +}); + +it('restores Error.stackTraceLimit', () => { + const { stackTraceLimit } = Error; + Error.stackTraceLimit = 7; + try { + new Job().cancel(); + new Job().cancelStatic(); + assert.strictEqual(Error.stackTraceLimit, 7); + } finally { + Error.stackTraceLimit = stackTraceLimit; + } +}); + +it('does not throw when Error.prepareStackTrace throws', () => { + const { prepareStackTrace } = Error; + Error.prepareStackTrace = () => { throw new Error('boom'); }; + try { + assert.strictEqual(new Job().cancel().reason.name, 'AbortError'); + assert.strictEqual(new Job().cancelStatic().reason.name, 'AbortError'); + } finally { + Error.prepareStackTrace = prepareStackTrace; + } +}); diff --git a/test/parallel/test-abortsignal-any.mjs b/test/parallel/test-abortsignal-any.mjs index ff5226055b8..ddc8fb5691c 100644 --- a/test/parallel/test-abortsignal-any.mjs +++ b/test/parallel/test-abortsignal-any.mjs @@ -75,6 +75,25 @@ describe('AbortSignal.any()', { concurrency: !process.env.TEST_PARALLEL }, () => assert.strictEqual(signal.reason, 'reason'); }); + it('aborts every signal that shares a source', () => { + const controller = new AbortController(); + const other = new AbortController(); + const signals = [ + AbortSignal.any([controller.signal]), + AbortSignal.any([other.signal, controller.signal]), + AbortSignal.any([AbortSignal.any([controller.signal]), other.signal]), + ]; + for (const signal of signals) { + signal.addEventListener('abort', common.mustCall()); + } + controller.abort('reason'); + for (const signal of signals) { + assert.ok(signal.aborted); + assert.strictEqual(signal.reason, 'reason'); + } + other.abort('other reason'); + }); + it('handles deeply aborted signals', async () => { const controllers = Array.from({ length: 2 }, () => new AbortController()); const composedSignal1 = AbortSignal.any([controllers[0].signal]); diff --git a/test/parallel/test-abortsignal-drop-settled-signals.mjs b/test/parallel/test-abortsignal-drop-settled-signals.mjs index 03e0146722e..4f9015c2bb4 100644 --- a/test/parallel/test-abortsignal-drop-settled-signals.mjs +++ b/test/parallel/test-abortsignal-drop-settled-signals.mjs @@ -271,6 +271,23 @@ it('drops an observed composite of a composite once its sources are collected', await gcUntil('outer composite is collected', () => outerRef.deref() === undefined); }); +it('drops observed composites that share a source once it is collected', async () => { + const handler = () => {}; + // Using a helper keeps the source and the composites off this stack. + const createObservedComposites = () => { + const controller = new AbortController(); + return Array.from({ length: 10 }, () => { + const composite = AbortSignal.any([controller.signal]); + composite.addEventListener('abort', handler); + return new WeakRef(composite); + }); + }; + const refs = createObservedComposites(); + + await gcUntil('observed composites are collected', + () => refs.every((ref) => ref.deref() === undefined)); +}); + it('drops settled signals even when there are listeners', (t, done) => { runWithOrphanListeners(limit, async (signalRefs) => { await gcUntil('all signals are GCed', () => { diff --git a/test/parallel/test-eventtarget.js b/test/parallel/test-eventtarget.js index 558ee58f8be..60d55badeb9 100644 --- a/test/parallel/test-eventtarget.js +++ b/test/parallel/test-eventtarget.js @@ -779,3 +779,34 @@ let asyncTest = Promise.resolve(); new Event('', null); new Event('', undefined); } + +{ + // Aborting the signal option only removes the listener that was registered + // with the same capture flag. + const et = new EventTarget(); + const controller = new AbortController(); + let calls = 0; + const listener = () => calls++; + et.addEventListener('foo', listener, { capture: true, signal: controller.signal }); + et.addEventListener('foo', listener, false); + et.dispatchEvent(new Event('foo')); + assert.strictEqual(calls, 2); + controller.abort(); + et.dispatchEvent(new Event('foo')); + assert.strictEqual(calls, 3); + et.removeEventListener('foo', listener); + et.dispatchEvent(new Event('foo')); + assert.strictEqual(calls, 3); +} + +{ + // The isTrusted getter returns false for any receiver that is not a trusted + // event, without throwing. + const { get } = Object.getOwnPropertyDescriptor(Event.prototype, 'isTrusted'); + for (const value of [ + undefined, null, 1, 'foo', Symbol('foo'), {}, () => {}, + { __proto__: Event.prototype }, new Event('foo'), new CustomEvent('foo'), + ]) { + assert.strictEqual(get.call(value), false); + } +} From 12f0e03b224477c2113b3e84388bc1db4ab12bb2 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Thu, 22 Oct 2026 11:15:44 +0200 Subject: [PATCH 107/331] crypto: wire up SHA-3 with BoringSSL Add SHA3-256, SHA3-384, and SHA3-512 to name lookup and getHashes(). BoringSSL exposes EVP_sha3_* descriptors but omits them from its digest registry. Map the names directly to those descriptors so node:crypto can use them too. When using BoringSSL, limit WebCrypto SHA-3 support to digest operations. Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66922 Reviewed-By: Antoine du Hamel Reviewed-By: James M Snell --- deps/ncrypto/ncrypto.cc | 7 + lib/internal/crypto/util.js | 15 +- lib/internal/crypto/webidl.js | 4 +- src/crypto/crypto_hash.cc | 6 + test/fixtures/crypto/ecdsa.js | 11 +- test/fixtures/crypto/hmac.js | 46 ++--- test/fixtures/crypto/rsa_pkcs.js | 7 +- test/fixtures/crypto/rsa_pss.js | 174 +++++++++--------- .../webcrypto/supports-modern-algorithms.mjs | 3 +- test/fixtures/webcrypto/supports-sha3.mjs | 68 +++---- .../test-crypto-boringssl-evp-list.js | 3 + .../test-crypto-boringssl-sha3-signatures.js | 104 +++++++++++ test/parallel/test-crypto-hash-stream-pipe.js | 11 +- .../test-crypto-key-objects-to-crypto-key.js | 21 ++- test/parallel/test-crypto-sha3.js | 117 ++++++++++++ .../parallel/test-webcrypto-boringssl-sha3.js | 80 ++++++++ .../test-webcrypto-derivebits-hkdf.js | 2 +- test/parallel/test-webcrypto-derivekey.js | 8 +- test/parallel/test-webcrypto-digest.js | 74 ++++---- .../test-webcrypto-encrypt-decrypt.js | 15 +- .../test-webcrypto-export-import-rsa.js | 31 ++-- test/parallel/test-webcrypto-export-import.js | 23 ++- test/parallel/test-webcrypto-keygen.js | 4 +- .../test-webcrypto-normalization-boundary.js | 2 +- .../test-webcrypto-rsa-jwk-sha3-alg.js | 13 +- .../test-webcrypto-sign-verify-hmac.js | 5 + .../test-webcrypto-sign-verify-rsa.js | 7 + test/wpt/status/WebCryptoAPI.cjs | 1 - 28 files changed, 616 insertions(+), 246 deletions(-) create mode 100644 test/parallel/test-crypto-boringssl-sha3-signatures.js create mode 100644 test/parallel/test-crypto-sha3.js create mode 100644 test/parallel/test-webcrypto-boringssl-sha3.js diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index a48b953dc1b..af6ac711832 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -2804,6 +2804,13 @@ const EVP_MD* getDigestByName(const char* name) { if (strcmp(name, "dss1") == 0 || strcmp(name, "DSS1") == 0) [[unlikely]] { return EVP_sha1(); } +#if NCRYPTO_USE_BORINGSSL + // BoringSSL exposes SHA-3 through EVP_MD descriptors without registering + // their names or assigning them NIDs. + if (CaseInsensitiveNameEqual()(name, "sha3-256")) return EVP_sha3_256(); + if (CaseInsensitiveNameEqual()(name, "sha3-384")) return EVP_sha3_384(); + if (CaseInsensitiveNameEqual()(name, "sha3-512")) return EVP_sha3_512(); +#endif return EVP_get_digestbyname(name); } diff --git a/lib/internal/crypto/util.js b/lib/internal/crypto/util.js index 3633bce9cb1..f915b103db4 100644 --- a/lib/internal/crypto/util.js +++ b/lib/internal/crypto/util.js @@ -53,6 +53,8 @@ const { isKeyAlgorithmAvailable, } = internalBinding('crypto'); +const { openssl_is_boringssl: isBoringSSL } = process.features; + let fips; let fipsGeneration; function isFips() { @@ -525,7 +527,7 @@ function getConditionalAlgorithms() { 'Argon2d': !!Argon2Job && !fips, 'Argon2i': !!Argon2Job && !fips, 'Argon2id': !!Argon2Job && !fips, - 'ChaCha20-Poly1305': process.features.openssl_is_boringssl || + 'ChaCha20-Poly1305': isBoringSSL || has(ciphers, 'chacha20-poly1305'), 'cSHAKE128': has(hashes, 'shake128'), 'cSHAKE256': has(hashes, 'shake256'), @@ -542,15 +544,15 @@ function getConditionalAlgorithms() { 'ML-KEM-768': mlKem768, 'ML-KEM-1024': mlKem1024, 'MLKEM768-P256': !fips && mlKem768 && - (!process.features.openssl_is_boringssl || + (!isBoringSSL || (has(hashes, 'sha3-256') && has(hashes, 'shake256'))), 'MLKEM768-X25519': !fips && mlKem768 && - (!process.features.openssl_is_boringssl || + (!isBoringSSL || (has(hashes, 'sha3-256') && has(hashes, 'shake256'))), 'MLKEM1024-P384': !fips && mlKem1024 && - (!process.features.openssl_is_boringssl || + (!isBoringSSL || (has(hashes, 'sha3-256') && has(hashes, 'shake256'))), 'SHA-1': has(hashes, 'sha1'), @@ -839,6 +841,11 @@ function normalizeAlgorithm(algorithm, op) { throw lazyDOMException( `Only SHA hashes are supported in ${desiredType}`, 'NotSupportedError'); } + if (isBoringSSL && StringPrototypeStartsWith(hash.name, 'SHA3-')) { + throw lazyDOMException( + 'SHA-3 is only supported for digest operations', + 'NotSupportedError'); + } normalizedAlgorithm[member] = hash; } else if (idlType === 'AlgorithmIdentifier') { // This extension point is not used by any supported algorithm (yet?) diff --git a/lib/internal/crypto/webidl.js b/lib/internal/crypto/webidl.js index 64fb0a8a226..ba3913f9d4a 100644 --- a/lib/internal/crypto/webidl.js +++ b/lib/internal/crypto/webidl.js @@ -14,6 +14,8 @@ const { TypedArrayPrototypeIncludes, } = primordials; +const { openssl_is_boringssl: isBoringSSL } = process.features; + const { lazyDOMException, kEmptyObject, @@ -694,7 +696,7 @@ converters.ContextParams = createAlgorithmDictionaryConverter( const validateLength = (V) => validateMaxBufferLength(V, 'ContextParams.context', 255); - if (process.features.openssl_is_boringssl) { + if (isBoringSSL) { this.validator = validateLength; } else { let { 0: major, 1: minor } = diff --git a/src/crypto/crypto_hash.cc b/src/crypto/crypto_hash.cc index c7b21e60de2..b221b68a4a4 100644 --- a/src/crypto/crypto_hash.cc +++ b/src/crypto/crypto_hash.cc @@ -255,6 +255,12 @@ const std::vector& GetSupportedHashAlgorithms(Environment* env) { EVP_MD_do_all_provided(nullptr, SaveSupportedProviderHashAlgorithms, env); #else EVP_MD_do_all_sorted(SaveSupportedHashAlgorithms, env); +#endif +#if NCRYPTO_USE_BORINGSSL + // SHA-3 descriptors are not included in BoringSSL's name registry. + for (const char* name : {"sha3-256", "sha3-384", "sha3-512"}) { + env->supported_hash_algorithms.emplace_back(name); + } #endif } const uint64_t current_generation = ncrypto::getFipsStateGeneration(); diff --git a/test/fixtures/crypto/ecdsa.js b/test/fixtures/crypto/ecdsa.js index 6da56a0601f..677e553d6e0 100644 --- a/test/fixtures/crypto/ecdsa.js +++ b/test/fixtures/crypto/ecdsa.js @@ -2,7 +2,8 @@ const { isBoringSSL } = require('../../common/crypto'); -module.exports = function() { +module.exports = function({ includeUnsupported = false } = {}) { + const includeSha3 = !isBoringSSL || includeUnsupported; const pkcs8 = { 'P-256': Buffer.from( '308187020100301306072a8648ce3d020106082a8648ce3d030107046d306b020101' + @@ -74,7 +75,7 @@ module.exports = function() { 'b6a0a14d7e4bc6dd2eda82c9234f174b670b60c8f7d101f68fdf5889e02373b025' + 'dcbc4c82f2929b8e06c68535da98e38fe399c53a814b097935581ef21535eb', 'hex'), - ...(!isBoringSSL ? { + ...(includeSha3 ? { 'SHA3-256': Buffer.from( 'f6a48eb5557f484ed0c3e4b5c78a3cf497cbd346db06a4165d429248aa2cc51a69' + '747d09f57af145469a8b607a9b8b9709629d74e8f5ca337c6ddc581b6f6103', @@ -106,7 +107,7 @@ module.exports = function() { '72fbdb369fd34c1c54264d07f4facd69b02e4206f8a8bb259b882a305c56fde2d3' + '5107e493c53cd6b4af0b31306f4d03fd43cfc762a1030e17a3d775453a1212b142' + '9f7b3d93066a5f42a10b138cd177dc09616e827d598822d78d4627b754e6', 'hex'), - ...(!isBoringSSL ? { + ...(includeSha3 ? { 'SHA3-256': Buffer.from( '0b07c078be30fa5925a307d6fc559c5f398e63fb5d007d6b24a834847f2d3d18d5' + 'b5e840711c52a7bc6626c3ced93301e873c013a706f6b297c12cc6d47a71e0529e' + @@ -146,7 +147,7 @@ module.exports = function() { '01f0071e6a32867fa70f695cd39c4e87e142b9e4134d38740bd6fee354a575167e' + '13524e94832637910fe11e53a85fb21b91adb81bb1779c4e2b8bc87c717dc35084', 'hex'), - ...(!isBoringSSL ? { + ...(includeSha3 ? { 'SHA3-256': Buffer.from( '00463679f47a4c705e03447360dcf34d1743e0d4b2591cc66832a6bc80d92e538c' + '169a1fd330f98e7235ca7fec7e16ac44fb13095b8edf2c76b75c4845177d59e425' + @@ -172,7 +173,7 @@ module.exports = function() { const curves = ['P-256', 'P-384', 'P-521']; const hashes = ['SHA-1', 'SHA-256', 'SHA-384', 'SHA-512']; - if (!isBoringSSL) { + if (includeSha3) { hashes.push('SHA3-256', 'SHA3-384', 'SHA3-512'); } diff --git a/test/fixtures/crypto/hmac.js b/test/fixtures/crypto/hmac.js index 55376a1299d..6505c6e2ae5 100644 --- a/test/fixtures/crypto/hmac.js +++ b/test/fixtures/crypto/hmac.js @@ -1,7 +1,5 @@ 'use strict'; -const { isBoringSSL } = require('../../common/crypto'); - module.exports = function () { const plaintext = Buffer.from( '5f4dba4f320c0ce876725afce5fbd25bf83e5a7125a08cafe73c3ebac421779df9d55d' + @@ -24,18 +22,16 @@ module.exports = function () { '5dcc359443aaf652fa1375d6b3e61fdcf29bb4a28bd5d3dcfa40f82f906bb280' + '0455db03b5d31fb972a15a6d0103a24e56d156a119c0e5a1e92a44c3c5657cf9', 'hex'), - ...(!isBoringSSL ? { - 'SHA3-256': Buffer.from( - 'e588ec0811463d767241df1074b47ae4071b51f2ce36537ba69ccdc3fdc2b7a8', - 'hex'), - 'SHA3-384': Buffer.from( - '6b1da28eab1f582ad9718effe05e23d5fd2c9877a2d9443f90bec093bece2ea7' + - 'd2354cd0bdc5e147d2e9009373494488', 'hex'), - 'SHA3-512': Buffer.from( - '5dcc359443aaf652fa1375d6b3e61fdcf29bb4a28bd5d3dcfa40f82f906bb280' + - '0455db03b5d31fb972a15a6d0103a24e56d156a119c0e5a1e92a44c3c5657cf9', - 'hex') - } : {}) + 'SHA3-256': Buffer.from( + 'e588ec0811463d767241df1074b47ae4071b51f2ce36537ba69ccdc3fdc2b7a8', + 'hex'), + 'SHA3-384': Buffer.from( + '6b1da28eab1f582ad9718effe05e23d5fd2c9877a2d9443f90bec093bece2ea7' + + 'd2354cd0bdc5e147d2e9009373494488', 'hex'), + 'SHA3-512': Buffer.from( + '5dcc359443aaf652fa1375d6b3e61fdcf29bb4a28bd5d3dcfa40f82f906bb280' + + '0455db03b5d31fb972a15a6d0103a24e56d156a119c0e5a1e92a44c3c5657cf9', + 'hex') } const signatures = { @@ -50,18 +46,16 @@ module.exports = function () { '61fb278c3ffb0cce2bf1cf723ddfd8ef1f931c0c618c25907324605939e3f9a2' + 'c6f4af690bda3407dc2f5770f6a0a44b954d64a332e3ee0821abf82b7f3e99c1', 'hex'), - ...(!isBoringSSL ? { - 'SHA3-256': Buffer.from( - 'c1ac5e11fcd50c48bf567f6e296632f5801c4eb07a8a47579b41dee971a3099b', - 'hex'), - 'SHA3-384': Buffer.from( - 'ac8c97f6dd8d9e16101063077c16b23fe291a5e6d149653e9ac7002365159317' + - 'adcfad511996578b0053a5c14b75f16c', 'hex'), - 'SHA3-512': Buffer.from( - '2162c2a8907e6b2f68599a69e81a464d8f076b5eeb555d98b4d20330034df3c7' + - 'cf35b1fa958a074ca12f0d242df39f0da3d4f1dbfb3629057798fe1f883974ee', - 'hex') - } : {}) + 'SHA3-256': Buffer.from( + 'c1ac5e11fcd50c48bf567f6e296632f5801c4eb07a8a47579b41dee971a3099b', + 'hex'), + 'SHA3-384': Buffer.from( + 'ac8c97f6dd8d9e16101063077c16b23fe291a5e6d149653e9ac7002365159317' + + 'adcfad511996578b0053a5c14b75f16c', 'hex'), + 'SHA3-512': Buffer.from( + '2162c2a8907e6b2f68599a69e81a464d8f076b5eeb555d98b4d20330034df3c7' + + 'cf35b1fa958a074ca12f0d242df39f0da3d4f1dbfb3629057798fe1f883974ee', + 'hex') } const vectors = []; diff --git a/test/fixtures/crypto/rsa_pkcs.js b/test/fixtures/crypto/rsa_pkcs.js index 74a8c0512ef..598097362e7 100644 --- a/test/fixtures/crypto/rsa_pkcs.js +++ b/test/fixtures/crypto/rsa_pkcs.js @@ -2,7 +2,8 @@ const { isBoringSSL } = require('../../common/crypto'); -module.exports = function () { +module.exports = function ({ includeUnsupported = false } = {}) { + const includeSha3 = !isBoringSSL || includeUnsupported; const pkcs8 = Buffer.from( '308204bf020100300d06092a864886f70d0101010500048204a9308204a50201000282' + '010100d3576092e62957364544e7e4233b7bdb293db2085122c479328546f9f0f712f6' + @@ -99,7 +100,7 @@ module.exports = function () { '7a6335c70e193235dcda48add6858626bd96311e60f7e5ea4491b6c1e6248afe12b' + 'bbd54f8869b043a5b0444562813f0a98b300356f306e6b783a29f3bec97ca40ea20' + '062cab8926ec5d96aa387cc84821a6d72b8ea126e7d', 'hex'), - ...(!isBoringSSL ? { + ...(includeSha3 ? { 'sha3-256': Buffer.from( 'be1b476c1911a01d71710fd8a2f3158d6f7839e91443b01bed30dfdd04336d80c6b' + 'f692c06fad254877901c10a73853e8fb202a29cddefdf16c3adcda1fc123625897d' + @@ -163,7 +164,7 @@ module.exports = function () { plaintext, signature: signatures['sha-512'] }, - ...(!isBoringSSL ? [ + ...(includeSha3 ? [ { publicKeyBuffer: spki, privateKeyBuffer: pkcs8, diff --git a/test/fixtures/crypto/rsa_pss.js b/test/fixtures/crypto/rsa_pss.js index 4aeaf3330e7..101122b2ffe 100644 --- a/test/fixtures/crypto/rsa_pss.js +++ b/test/fixtures/crypto/rsa_pss.js @@ -1,7 +1,5 @@ 'use strict'; -const { isBoringSSL } = require('../../common/crypto'); - module.exports = function() { const pkcs8 = Buffer.from( '308204bf020100300d06092a864886f70d0101010500048204a9308204a5020100028' + @@ -152,44 +150,42 @@ module.exports = function() { 'b68c04bfe452c3adc6c10066a915231b7b404727eb6201b4921eb96d9407de2b963' + '3879ceb71d759d9828d7b4d062f6ef100757d8328187caf57dfb859d1555345207c' + '1cce7905c3564c08fec78867a53d5a2cf84810e1ffa', 'hex'), - ...(!isBoringSSL ? { - 'sha3-512, no salt': Buffer.from( - 'd2430dc87abeaa7d13f7cec8510f1a296e1c608f44b1696829c59a99e8eefe9b2ee' + - '6ee8ad6fdc93c24fcba2f04d1da195924b6209717e1992c10ed9f4783478765fe34' + - '3e761203bff9d326bb6dc2061b0a7554c8ce0814b29249136c20c8e30054df0c6bc' + - '656509a82845149368896690e32ff5dd32ef01543686f01d6a69bb438b049e66a8b' + - 'df485a13edcd7dc482da4cc57d0b740aca3e56f0da247794e600afd27b22b6da13b' + - 'cc15dd2059b525f8cb6bcd07540aa843f0ae51d4b0eea27045485914b908bdd01d0' + - 'a9d42379f9f7180f4ad162ff73df5fed0200eb02ad01473975d54a77c15a9c61a3c' + - 'b5e27de5d1eecc363d45506f7123a5ddd115c5e4c9e', 'hex'), - 'sha3-256, salted': Buffer.from( - '59cb9cce6ae838eb20d38d6af4acb9b866b0753bb7df9e441037d788512c03279e8' + - '3d9a9cf5c0921fe1c0b6e8e895a8c0ad24a18b123f809b34ef2a3a1f05974030320' + - '435692ef5d378cef4368c3658c098a25371dfaf1c0b6910f653a4ec15f2c08956c1' + - '405136c2aba7f25a808fa7dbf57a4cb2978bd91af710b27ee239d955c8cac7a76ae' + - '9085cefeda2a585a99cc948f064b5da66a9c4aa4f3f767ac905a9f314b47038e05c' + - '3608fbb7e67a278e4f009a62c3cd3fdf43692e759d9361be1217999a76a69d4d119' + - 'f8791a90e207e46b3f6125721f56fd819292d06a3cdae2c62c9a1dc0d964a06036c' + - '8c18661cc6c873532a3536ab51e1ce210926db299e2', 'hex'), - 'sha3-384, salted': Buffer.from( - '8d1f9297c8169f27f0c58827dba991d862de58c1155f612ad2995d2bf862d051c4a' + - '91b48571849b0412384382e5b77990de6a3c84010046b35c4a504f175a3479483d9' + - '5c58f86bb96d53a27e59d6f67fddaae295ce90610f5086acc711557c2c85aac32d3' + - '24199cff2367ae44e1d91307a98c8cbfb085a8bce6b1c20714711bc15b0eddb7881' + - '823227d4be477ffdad8093663a6a1fc62eb39c49c2c3a821c2b202cf7904b49ca92' + - '3c83819602bb13931577354a80f99309030044935b1cd41f0513160e661db1959fb' + - '1ec15f087f3d288e875d54cbf070ec860b0aeecc951ea65e97cd5460750d4b7de52' + - '22cb9e7466b1f506ecf6a81fc399dfd8334160f9084', 'hex'), - 'sha3-512, salted': Buffer.from( - '7b6d7be418c5d37cc8070698b8b03d818ecd8b673d047d34921913f6d59c69cb496' + - '172d6118207d9ff92b8e1246acf0e03a845d935a70f8a82c3d5d6db6a1a0e337269' + - '4b904372413dcbaa7ac5486bc8ccaf70d7e9470be82b928a90017e272cf9761ed26' + - 'c160fe874a2675a4fb2acad72c50fbfffdd70b5a6f2919553d7ea1829934670f8de' + - 'f2a5c2816404b1aa153323c92c58400622f184b9b0463fa48d6b27091f68c287e3f' + - '6d9ab9eb451711a5d984c547f3d56f14a686a89ddf36c47ce25092b8c6530904de9' + - '5df7fc602fe9394315f1b1847aae304cb5ad71e2cb78acfbc997a87a9d62a6898bb' + - '6d84a81bb89b50186265f4be171a93d837a4bf777c8', 'hex') - } : {}) + 'sha3-512, no salt': Buffer.from( + 'd2430dc87abeaa7d13f7cec8510f1a296e1c608f44b1696829c59a99e8eefe9b2ee' + + '6ee8ad6fdc93c24fcba2f04d1da195924b6209717e1992c10ed9f4783478765fe34' + + '3e761203bff9d326bb6dc2061b0a7554c8ce0814b29249136c20c8e30054df0c6bc' + + '656509a82845149368896690e32ff5dd32ef01543686f01d6a69bb438b049e66a8b' + + 'df485a13edcd7dc482da4cc57d0b740aca3e56f0da247794e600afd27b22b6da13b' + + 'cc15dd2059b525f8cb6bcd07540aa843f0ae51d4b0eea27045485914b908bdd01d0' + + 'a9d42379f9f7180f4ad162ff73df5fed0200eb02ad01473975d54a77c15a9c61a3c' + + 'b5e27de5d1eecc363d45506f7123a5ddd115c5e4c9e', 'hex'), + 'sha3-256, salted': Buffer.from( + '59cb9cce6ae838eb20d38d6af4acb9b866b0753bb7df9e441037d788512c03279e8' + + '3d9a9cf5c0921fe1c0b6e8e895a8c0ad24a18b123f809b34ef2a3a1f05974030320' + + '435692ef5d378cef4368c3658c098a25371dfaf1c0b6910f653a4ec15f2c08956c1' + + '405136c2aba7f25a808fa7dbf57a4cb2978bd91af710b27ee239d955c8cac7a76ae' + + '9085cefeda2a585a99cc948f064b5da66a9c4aa4f3f767ac905a9f314b47038e05c' + + '3608fbb7e67a278e4f009a62c3cd3fdf43692e759d9361be1217999a76a69d4d119' + + 'f8791a90e207e46b3f6125721f56fd819292d06a3cdae2c62c9a1dc0d964a06036c' + + '8c18661cc6c873532a3536ab51e1ce210926db299e2', 'hex'), + 'sha3-384, salted': Buffer.from( + '8d1f9297c8169f27f0c58827dba991d862de58c1155f612ad2995d2bf862d051c4a' + + '91b48571849b0412384382e5b77990de6a3c84010046b35c4a504f175a3479483d9' + + '5c58f86bb96d53a27e59d6f67fddaae295ce90610f5086acc711557c2c85aac32d3' + + '24199cff2367ae44e1d91307a98c8cbfb085a8bce6b1c20714711bc15b0eddb7881' + + '823227d4be477ffdad8093663a6a1fc62eb39c49c2c3a821c2b202cf7904b49ca92' + + '3c83819602bb13931577354a80f99309030044935b1cd41f0513160e661db1959fb' + + '1ec15f087f3d288e875d54cbf070ec860b0aeecc951ea65e97cd5460750d4b7de52' + + '22cb9e7466b1f506ecf6a81fc399dfd8334160f9084', 'hex'), + 'sha3-512, salted': Buffer.from( + '7b6d7be418c5d37cc8070698b8b03d818ecd8b673d047d34921913f6d59c69cb496' + + '172d6118207d9ff92b8e1246acf0e03a845d935a70f8a82c3d5d6db6a1a0e337269' + + '4b904372413dcbaa7ac5486bc8ccaf70d7e9470be82b928a90017e272cf9761ed26' + + 'c160fe874a2675a4fb2acad72c50fbfffdd70b5a6f2919553d7ea1829934670f8de' + + 'f2a5c2816404b1aa153323c92c58400622f184b9b0463fa48d6b27091f68c287e3f' + + '6d9ab9eb451711a5d984c547f3d56f14a686a89ddf36c47ce25092b8c6530904de9' + + '5df7fc602fe9394315f1b1847aae304cb5ad71e2cb78acfbc997a87a9d62a6898bb' + + '6d84a81bb89b50186265f4be171a93d837a4bf777c8', 'hex') } const vectors = [ @@ -257,56 +253,54 @@ module.exports = function() { plaintext, signature: signatures['sha-512, salted'] }, - ...(!isBoringSSL ? [ - { - publicKeyBuffer: spki, - privateKeyBuffer: pkcs8, - algorithm: { name: 'RSA-PSS', saltLength: 0 }, - hash: 'SHA3-256', - plaintext, - signature: signatures['sha3-256, no salt'] - }, - { - publicKeyBuffer: spki, - privateKeyBuffer: pkcs8, - algorithm: { name: 'RSA-PSS', saltLength: 0 }, - hash: 'SHA3-384', - plaintext, - signature: signatures['sha3-384, no salt'] - }, - { - publicKeyBuffer: spki, - privateKeyBuffer: pkcs8, - algorithm: { name: 'RSA-PSS', saltLength: 0 }, - hash: 'SHA3-512', - plaintext, - signature: signatures['sha3-512, no salt'] - }, - { - publicKeyBuffer: spki, - privateKeyBuffer: pkcs8, - algorithm: { name: 'RSA-PSS', saltLength: 32 }, - hash: 'SHA3-256', - plaintext, - signature: signatures['sha3-256, salted'] - }, - { - publicKeyBuffer: spki, - privateKeyBuffer: pkcs8, - algorithm: { name: 'RSA-PSS', saltLength: 48 }, - hash: 'SHA3-384', - plaintext, - signature: signatures['sha3-384, salted'] - }, - { - publicKeyBuffer: spki, - privateKeyBuffer: pkcs8, - algorithm: { name: 'RSA-PSS', saltLength: 64 }, - hash: 'SHA3-512', - plaintext, - signature: signatures['sha3-512, salted'] - } - ] : []), + { + publicKeyBuffer: spki, + privateKeyBuffer: pkcs8, + algorithm: { name: 'RSA-PSS', saltLength: 0 }, + hash: 'SHA3-256', + plaintext, + signature: signatures['sha3-256, no salt'] + }, + { + publicKeyBuffer: spki, + privateKeyBuffer: pkcs8, + algorithm: { name: 'RSA-PSS', saltLength: 0 }, + hash: 'SHA3-384', + plaintext, + signature: signatures['sha3-384, no salt'] + }, + { + publicKeyBuffer: spki, + privateKeyBuffer: pkcs8, + algorithm: { name: 'RSA-PSS', saltLength: 0 }, + hash: 'SHA3-512', + plaintext, + signature: signatures['sha3-512, no salt'] + }, + { + publicKeyBuffer: spki, + privateKeyBuffer: pkcs8, + algorithm: { name: 'RSA-PSS', saltLength: 32 }, + hash: 'SHA3-256', + plaintext, + signature: signatures['sha3-256, salted'] + }, + { + publicKeyBuffer: spki, + privateKeyBuffer: pkcs8, + algorithm: { name: 'RSA-PSS', saltLength: 48 }, + hash: 'SHA3-384', + plaintext, + signature: signatures['sha3-384, salted'] + }, + { + publicKeyBuffer: spki, + privateKeyBuffer: pkcs8, + algorithm: { name: 'RSA-PSS', saltLength: 64 }, + hash: 'SHA3-512', + plaintext, + signature: signatures['sha3-512, salted'] + } ]; return vectors; diff --git a/test/fixtures/webcrypto/supports-modern-algorithms.mjs b/test/fixtures/webcrypto/supports-modern-algorithms.mjs index 8d58397783e..250646125fa 100644 --- a/test/fixtures/webcrypto/supports-modern-algorithms.mjs +++ b/test/fixtures/webcrypto/supports-modern-algorithms.mjs @@ -13,10 +13,9 @@ const shake128 = crypto.getHashes().includes('shake128'); const shake256 = crypto.getHashes().includes('shake256'); const cshake128 = crypto.getHashes().includes('cshake128'); const cshake256 = crypto.getHashes().includes('cshake256'); -const sha3 = crypto.getHashes().includes('sha3-256'); const ocb = hasOpenSSL(3) && crypto.getCiphers().includes('aes-128-ocb'); const kmac = hasOpenSSL(3) && crypto.getMacs().includes('kmac128'); -const hybridKems = !fips && pqc && (!boringSSL || (sha3 && shake256)); +const hybridKems = !fips && pqc && (!boringSSL || shake256); export const vectors = { diff --git a/test/fixtures/webcrypto/supports-sha3.mjs b/test/fixtures/webcrypto/supports-sha3.mjs index 699b72bb11b..a3221b1a2ec 100644 --- a/test/fixtures/webcrypto/supports-sha3.mjs +++ b/test/fixtures/webcrypto/supports-sha3.mjs @@ -1,28 +1,30 @@ -import { getHashes } from 'node:crypto'; +import { isBoringSSL } from '../../common/crypto.js'; import { ECDH, X25519 } from './supports-level-2.mjs'; -const hashes = getHashes(); -const hasSha3 = hashes.includes('sha3-256'); - const RSA_KEY_GEN = { modulusLength: 2048, publicExponent: new Uint8Array([1, 0, 1]) }; export const vectors = { + 'sign': [ + [!isBoringSSL, { name: 'ECDSA', hash: 'SHA3-256' }], + [!isBoringSSL, { name: 'ECDSA', hash: 'SHA3-384' }], + [!isBoringSSL, { name: 'ECDSA', hash: 'SHA3-512' }], + ], 'digest': [ - [hasSha3, 'SHA3-256'], - [hashes.includes('sha3-384'), 'SHA3-384'], - [hashes.includes('sha3-512'), 'SHA3-512'], + [true, 'SHA3-256'], + [true, 'SHA3-384'], + [true, 'SHA3-512'], ], 'generateKey': [ - [hasSha3, { name: 'HMAC', hash: 'SHA3-256', length: 256 }], - [hasSha3, { name: 'HMAC', hash: 'SHA3-256', length: 25 }], - [hasSha3, { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA3-256', ...RSA_KEY_GEN }], - [hasSha3, { name: 'RSA-PSS', hash: 'SHA3-256', ...RSA_KEY_GEN }], - [hasSha3, { name: 'RSA-OAEP', hash: 'SHA3-256', ...RSA_KEY_GEN }], - [hasSha3, { name: 'HMAC', hash: 'SHA3-256', length: 256 }], - [hasSha3, { name: 'HMAC', hash: 'SHA3-256', length: 25 }], + [!isBoringSSL, { name: 'HMAC', hash: 'SHA3-256', length: 256 }], + [!isBoringSSL, { name: 'HMAC', hash: 'SHA3-256', length: 25 }], + [!isBoringSSL, { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA3-256', ...RSA_KEY_GEN }], + [!isBoringSSL, { name: 'RSA-PSS', hash: 'SHA3-256', ...RSA_KEY_GEN }], + [!isBoringSSL, { name: 'RSA-OAEP', hash: 'SHA3-256', ...RSA_KEY_GEN }], + [!isBoringSSL, { name: 'HMAC', hash: 'SHA3-256', length: 256 }], + [!isBoringSSL, { name: 'HMAC', hash: 'SHA3-256', length: 25 }], [false, { name: 'HMAC', hash: 'SHA3-256', length: 0 }], // This interaction is not defined for now. @@ -30,28 +32,28 @@ export const vectors = { [false, { name: 'HMAC', hash: 'SHA3-256' }], ], 'deriveKey': [ - [hasSha3, + [!isBoringSSL, { name: 'HKDF', hash: 'SHA3-256', salt: Buffer.alloc(0), info: Buffer.alloc(0) }, { name: 'AES-CBC', length: 128 }], - [hasSha3, + [!isBoringSSL, { name: 'HKDF', hash: 'SHA3-256', salt: Buffer.alloc(0), info: Buffer.alloc(0) }, { name: 'HMAC', hash: 'SHA3-256', length: 256 }], [false, { name: 'HKDF', hash: 'SHA3-256', salt: Buffer.alloc(0), info: Buffer.alloc(0) }, 'HKDF'], - [hasSha3, + [!isBoringSSL, { name: 'PBKDF2', hash: 'SHA3-256', salt: Buffer.alloc(0), iterations: 1 }, { name: 'AES-CBC', length: 128 }], - [hasSha3, + [!isBoringSSL, { name: 'PBKDF2', hash: 'SHA3-256', salt: Buffer.alloc(0), iterations: 1 }, { name: 'HMAC', hash: 'SHA3-256', length: 256 }], [false, { name: 'PBKDF2', hash: 'SHA3-256', salt: Buffer.alloc(0), iterations: 1 }, 'HKDF'], - [hasSha3 && X25519 !== undefined, + [!isBoringSSL && X25519 !== undefined, { name: 'X25519', public: X25519?.publicKey }, { name: 'HMAC', hash: 'SHA3-256', length: 256 }], - [hasSha3, + [!isBoringSSL, { name: 'ECDH', public: ECDH.publicKey }, { name: 'HMAC', hash: 'SHA3-256', length: 256 }], @@ -71,27 +73,27 @@ export const vectors = { { name: 'HMAC', hash: 'SHA3-256' }], ], 'deriveBits': [ - [hasSha3, { name: 'HKDF', hash: 'SHA3-256', salt: Buffer.alloc(0), info: Buffer.alloc(0) }, 8], - [hasSha3, { name: 'HKDF', hash: 'SHA3-256', salt: Buffer.alloc(0), info: Buffer.alloc(0) }, 0], + [!isBoringSSL, { name: 'HKDF', hash: 'SHA3-256', salt: Buffer.alloc(0), info: Buffer.alloc(0) }, 8], + [!isBoringSSL, { name: 'HKDF', hash: 'SHA3-256', salt: Buffer.alloc(0), info: Buffer.alloc(0) }, 0], [false, { name: 'HKDF', hash: 'SHA3-256', salt: Buffer.alloc(0), info: Buffer.alloc(0) }, null], [false, { name: 'HKDF', hash: 'SHA3-256', salt: Buffer.alloc(0), info: Buffer.alloc(0) }, 7], - [hasSha3, { name: 'PBKDF2', hash: 'SHA3-256', salt: Buffer.alloc(0), iterations: 1 }, 8], - [hasSha3, { name: 'PBKDF2', hash: 'SHA3-256', salt: Buffer.alloc(0), iterations: 1 }, 0], + [!isBoringSSL, { name: 'PBKDF2', hash: 'SHA3-256', salt: Buffer.alloc(0), iterations: 1 }, 8], + [!isBoringSSL, { name: 'PBKDF2', hash: 'SHA3-256', salt: Buffer.alloc(0), iterations: 1 }, 0], [false, { name: 'PBKDF2', hash: 'SHA3-256', salt: Buffer.alloc(0), iterations: 0 }, 8], [false, { name: 'PBKDF2', hash: 'SHA3-256', salt: Buffer.alloc(0), iterations: 1 }, null], [false, { name: 'PBKDF2', hash: 'SHA3-256', salt: Buffer.alloc(0), iterations: 1 }, 7], ], 'importKey': [ - [hasSha3, { name: 'HMAC', hash: 'SHA3-256' }], - [hasSha3, { name: 'HMAC', hash: 'SHA3-256', length: 256 }], - [hasSha3, { name: 'HMAC', hash: 'SHA3-256', length: 25 }], - [hasSha3, { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA3-256', ...RSA_KEY_GEN }], - [hasSha3, { name: 'RSA-PSS', hash: 'SHA3-256', ...RSA_KEY_GEN }], - [hasSha3, { name: 'RSA-OAEP', hash: 'SHA3-256', ...RSA_KEY_GEN }], - [hasSha3, { name: 'HMAC', hash: 'SHA3-256' }], - [hasSha3, { name: 'HMAC', hash: 'SHA3-256', length: 256 }], - [hasSha3, { name: 'HMAC', hash: 'SHA3-256', length: 25 }], + [!isBoringSSL, { name: 'HMAC', hash: 'SHA3-256' }], + [!isBoringSSL, { name: 'HMAC', hash: 'SHA3-256', length: 256 }], + [!isBoringSSL, { name: 'HMAC', hash: 'SHA3-256', length: 25 }], + [!isBoringSSL, { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA3-256', ...RSA_KEY_GEN }], + [!isBoringSSL, { name: 'RSA-PSS', hash: 'SHA3-256', ...RSA_KEY_GEN }], + [!isBoringSSL, { name: 'RSA-OAEP', hash: 'SHA3-256', ...RSA_KEY_GEN }], + [!isBoringSSL, { name: 'HMAC', hash: 'SHA3-256' }], + [!isBoringSSL, { name: 'HMAC', hash: 'SHA3-256', length: 256 }], + [!isBoringSSL, { name: 'HMAC', hash: 'SHA3-256', length: 25 }], [false, { name: 'HMAC', hash: 'SHA3-256', length: 0 }], ], 'get key length': [ diff --git a/test/parallel/test-crypto-boringssl-evp-list.js b/test/parallel/test-crypto-boringssl-evp-list.js index f2d8fd4796c..1589837eee8 100644 --- a/test/parallel/test-crypto-boringssl-evp-list.js +++ b/test/parallel/test-crypto-boringssl-evp-list.js @@ -30,4 +30,7 @@ const hashes = getHashes(); 'sha1', 'sha256', 'sha512-256', + 'sha3-256', + 'sha3-384', + 'sha3-512', ].forEach((hash) => assert(hashes.includes(hash), hash)); diff --git a/test/parallel/test-crypto-boringssl-sha3-signatures.js b/test/parallel/test-crypto-boringssl-sha3-signatures.js new file mode 100644 index 00000000000..f5549d73931 --- /dev/null +++ b/test/parallel/test-crypto-boringssl-sha3-signatures.js @@ -0,0 +1,104 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const { isBoringSSL } = require('../common/crypto'); +if (!isBoringSSL) + common.skip('BoringSSL-only test'); + +const assert = require('assert'); +const { + constants, + createPrivateKey, + createPublicKey, + createSign, + createVerify, + sign, + subtle, + verify, +} = require('crypto'); +const { promisify } = require('util'); +const signAsync = promisify(sign); +const verifyAsync = promisify(verify); +// BoringSSL exposes SHA-3 digests, but its PKCS1v1.5 DigestInfo table and ECDSA +// digest restrictions still reject them. Use valid independent signatures so +// these assertions fail when support lands and the fixture skips can be removed. +const vectors = [ + ...require('../fixtures/crypto/rsa_pkcs')({ includeUnsupported: true }), + ...require('../fixtures/crypto/ecdsa')({ includeUnsupported: true }), +].filter(({ hash }) => hash.startsWith('SHA3-')); +assert.strictEqual(vectors.length, 12); + +async function test(vector) { + const { + hash, + namedCurve, + plaintext, + privateKeyBuffer, + publicKeyBuffer, + signature, + } = vector; + const isECDSA = vector.name === 'ECDSA'; + const name = isECDSA ? vector.name : vector.algorithm.name; + const context = `${name} ${namedCurve ?? ''} ${hash}`; + const error = { + code: isECDSA ? 'ERR_OSSL_EVP_INVALID_DIGEST_TYPE' : + 'ERR_OSSL_RSA_UNKNOWN_ALGORITHM_TYPE', + }; + const privateKey = createPrivateKey({ + key: privateKeyBuffer, format: 'der', type: 'pkcs8', + }); + const publicKey = createPublicKey({ + key: publicKeyBuffer, format: 'der', type: 'spki', + }); + const options = isECDSA ? { dsaEncoding: 'ieee-p1363' } : + { padding: constants.RSA_PKCS1_PADDING }; + const signingKey = { key: privateKey, ...options }; + const verificationKey = { key: publicKey, ...options }; + + assert.throws(() => sign(hash, plaintext, signingKey), error, context); + await assert.rejects(signAsync(hash, plaintext, signingKey), error, context); + assert.throws(() => createSign(hash).update(plaintext).sign(signingKey), + error, context); + + if (isECDSA) { + assert.throws(() => verify(hash, plaintext, verificationKey, signature), + error, context); + await assert.rejects(verifyAsync(hash, plaintext, verificationKey, signature), + error, context); + } else { + assert.strictEqual(verify(hash, plaintext, verificationKey, signature), false, + context); + assert.strictEqual( + await verifyAsync(hash, plaintext, verificationKey, signature), false, + context); + } + assert.strictEqual(createVerify(hash).update(plaintext) + .verify(verificationKey, signature), false, context); + + const unsupportedHash = { name: 'NotSupportedError' }; + if (!isECDSA) { + const algorithm = { name, hash }; + await assert.rejects(subtle.importKey( + 'pkcs8', privateKeyBuffer, algorithm, false, ['sign']), + unsupportedHash, context); + await assert.rejects(subtle.importKey( + 'spki', publicKeyBuffer, algorithm, false, ['verify']), + unsupportedHash, context); + return; + } + + const [webPrivateKey, webPublicKey] = await Promise.all([ + subtle.importKey('pkcs8', privateKeyBuffer, { name, namedCurve }, false, ['sign']), + subtle.importKey('spki', publicKeyBuffer, { name, namedCurve }, false, ['verify']), + ]); + await assert.rejects(subtle.sign({ name, hash }, webPrivateKey, plaintext), + unsupportedHash, context); + await assert.rejects(subtle.verify({ name, hash }, webPublicKey, signature, + plaintext), unsupportedHash, context); +} + +for (const vector of vectors) + test(vector).then(common.mustCall()); diff --git a/test/parallel/test-crypto-hash-stream-pipe.js b/test/parallel/test-crypto-hash-stream-pipe.js index c6b9433456e..d94af277f63 100644 --- a/test/parallel/test-crypto-hash-stream-pipe.js +++ b/test/parallel/test-crypto-hash-stream-pipe.js @@ -22,7 +22,6 @@ 'use strict'; const common = require('../common'); -const { isBoringSSL } = require('../common/crypto'); if (!common.hasCrypto) common.skip('missing crypto'); @@ -32,14 +31,8 @@ const crypto = require('crypto'); const stream = require('stream'); const s = new stream.PassThrough(); -const h = isBoringSSL ? - crypto.createHash('sha512') : - crypto.createHash('sha3-512'); -const expect = isBoringSSL ? - 'fba055c6fd0c5b6645407749ed7a8b41' + - 'b8f629f2163c3ca3701d864adabda1f8' + - '93c37bf82b22fdd151ba8e357f611da4' + - '88a74b6a5525dd9b69554c6ce5138ad7' : +const h = crypto.createHash('sha3-512'); +const expect = '36a38a2a35e698974d4e5791a3f05b05' + '198235381e864f91a0e8cd6a26b677ec' + 'dcde8e2b069bd7355fabd68abd6fc801' + diff --git a/test/parallel/test-crypto-key-objects-to-crypto-key.js b/test/parallel/test-crypto-key-objects-to-crypto-key.js index 6024029da1b..544a44700f1 100644 --- a/test/parallel/test-crypto-key-objects-to-crypto-key.js +++ b/test/parallel/test-crypto-key-objects-to-crypto-key.js @@ -12,13 +12,15 @@ const { randomBytes, generateKeyPairSync, } = require('crypto'); -const { hasFIPS } = require('../common/crypto'); +const { hasFIPS, isBoringSSL } = require('../common/crypto'); const { kSupportedAlgorithms } = require('internal/crypto/util'); const rejectsXCurves = hasFIPS(3, 5); const hashes = Object.keys(kSupportedAlgorithms.digest).filter((name) => { return name.startsWith('SHA-') || name.startsWith('SHA3-'); }); +const unsupportedKeyHashes = isBoringSSL ? ['SHA3-256', 'SHA3-384', 'SHA3-512'] : []; +const keyHashes = hashes.filter((hash) => !unsupportedKeyHashes.includes(hash)); const namedCurves = ['P-256', 'P-384', 'P-521']; const signingUsages = { @@ -98,6 +100,17 @@ function runVector(vector) { assertVector(vector, false); } +function assertUnsupportedKeyHashes(keyObject, name, usages) { + for (const hash of unsupportedKeyHashes) { + for (const extractable of [true, false]) { + assert.throws(() => keyObject.toCryptoKey({ name, hash }, extractable, usages), { + name: 'NotSupportedError', + message: 'SHA-3 is only supported for digest operations', + }); + } + } +} + function symmetricVectors(name, usages) { const vectors = []; for (const length of [128, 192, 256]) { @@ -174,7 +187,8 @@ function hmacVectors() { const vectors = []; for (const length of [128, 192, 256]) { const key = secretKey(length); - for (const hash of hashes) { + assertUnsupportedKeyHashes(key, 'HMAC', ['sign', 'verify']); + for (const hash of keyHashes) { vectors.push(vector( key, { name: 'HMAC', hash }, @@ -212,7 +226,8 @@ function rsaVectors(name, usagesByType) { const keyPair = generateKeyPairSync('rsa', { modulusLength: 2048 }); const vectors = []; for (const keyObject of [keyPair.publicKey, keyPair.privateKey]) { - for (const hash of hashes) { + assertUnsupportedKeyHashes(keyObject, name, getUsages(keyObject, usagesByType)); + for (const hash of keyHashes) { vectors.push(vector( keyObject, { name, hash }, diff --git a/test/parallel/test-crypto-sha3.js b/test/parallel/test-crypto-sha3.js new file mode 100644 index 00000000000..6a7ed2e13b3 --- /dev/null +++ b/test/parallel/test-crypto-sha3.js @@ -0,0 +1,117 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('assert'); +const { + constants, + createHash, + createHmac, + createPrivateKey, + createPublicKey, + createSign, + createVerify, + getHashes, + hash, + hkdf, + hkdfSync, + pbkdf2, + pbkdf2Sync, + sign, + verify, +} = require('crypto'); +const rsaPss = require('../fixtures/crypto/rsa_pss'); + +const vectors = [ + { + name: 'sha3-256', + digest: '3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532', + hmac: '961fcf59ed455732e405e74f5dc78beb7aa41ad315af5e2b2a0dcf8cef9887e0', + hkdf: '38c2d1e7b3933f7df51e35f3eeaa0a0138b1b812e2bf57810ad4e2300e2c4a81', + pbkdf2: 'db7d83f5e7ebc6b0ea83e9b6c57a27e254e96cfef315278e9ed96b10483a7ad0', + }, + { + name: 'sha3-384', + digest: 'ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b29' + + '8d88cea927ac7f539f1edf228376d25', + hmac: 'f1d3898bb4cd7b7904fe4e7cecb84d3225b3add0265842ec7386867d662ee3364' + + '8a90e98a5c673b2266eb1077fb91ed6', + hkdf: '3ca21ccc4e742ec6a365ee5857db1ab5a0a8843196467d7a0b26c724e542f6f5', + pbkdf2: '7f049e44bfddb1b591d1ae2beaa1f3be54d683063bd25759b412a86012186c16', + }, + { + name: 'sha3-512', + digest: 'b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e1' + + '0e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0', + hmac: '5576c01b021fc928ae1bc83a6ddb8db5f9a201681e940ecf1f7d5c8a6ec80ac34' + + '614d4a68c9581957f69dc8a8c0fbf413984b0f938db3e8212c0744a1a9c5915', + hkdf: 'cd54f848a5f6ffb9e730d4bfbdff30d69a4b86316afdf5ba61b4fe95bd022037', + pbkdf2: '2b5150c50e0bf48dcb5b32205ad81e8c42d97f8f8dff57dcc365a38e857a05c7', + }, +]; + +const hashes = getHashes(); +for (const vector of vectors) { + assert(hashes.includes(vector.name)); + for (const name of [vector.name, vector.name.toUpperCase(), + vector.name.replace('sha', 'sHa')]) { + assert.strictEqual(hash(name, 'abc'), vector.digest); + + const original = createHash(name).update('a'); + const copy = original.copy(); + assert.strictEqual(original.update('bc').digest('hex'), vector.digest); + assert.strictEqual(copy.update('b').copy().update('c').digest('hex'), vector.digest); + + // Exceed every SHA-3 block size so HMAC also hashes the key. + assert.strictEqual(createHmac(name, Buffer.alloc(200, 0xaa)) + .update('abc').digest('hex'), vector.hmac); + + assert.strictEqual(Buffer.from(hkdfSync(name, 'passwordpassword', 'saltsaltsaltsalt', 'info', 32)) + .toString('hex'), vector.hkdf); + hkdf(name, 'passwordpassword', 'saltsaltsaltsalt', 'info', 32, common.mustSucceed((result) => { + assert.strictEqual(Buffer.from(result).toString('hex'), vector.hkdf); + })); + + assert.strictEqual(pbkdf2Sync('passwordpassword', 'saltsaltsaltsalt', 1000, 32, name) + .toString('hex'), vector.pbkdf2); + pbkdf2('passwordpassword', 'saltsaltsaltsalt', 1000, 32, name, common.mustSucceed((result) => { + assert.strictEqual(result.toString('hex'), vector.pbkdf2); + })); + } +} + +// Reuse independent RSA-PSS signature vectors to check SHA-3 in both the +// one-shot and streaming APIs, including zero-length and digest-length salts. +for (const vector of rsaPss()) { + if (!vector.hash.startsWith('SHA3-')) continue; + const privateKey = createPrivateKey({ + key: vector.privateKeyBuffer, format: 'der', type: 'pkcs8', + }); + const publicKey = createPublicKey({ + key: vector.publicKeyBuffer, format: 'der', type: 'spki', + }); + const options = { + padding: constants.RSA_PKCS1_PSS_PADDING, + saltLength: vector.algorithm.saltLength, + }; + const signingKey = { key: privateKey, ...options }; + const verificationKey = { key: publicKey, ...options }; + + assert(verify(vector.hash, vector.plaintext, verificationKey, + vector.signature)); + assert(createVerify(vector.hash).update(vector.plaintext) + .verify(verificationKey, vector.signature)); + + for (const signature of [ + sign(vector.hash, vector.plaintext, signingKey), + createSign(vector.hash).update(vector.plaintext).sign(signingKey), + ]) { + assert(verify(vector.hash, vector.plaintext, verificationKey, signature)); + assert(createVerify(vector.hash).update(vector.plaintext) + .verify(verificationKey, signature)); + if (options.saltLength === 0) + assert.deepStrictEqual(signature, vector.signature); + } +} diff --git a/test/parallel/test-webcrypto-boringssl-sha3.js b/test/parallel/test-webcrypto-boringssl-sha3.js new file mode 100644 index 00000000000..f4e2267fe0e --- /dev/null +++ b/test/parallel/test-webcrypto-boringssl-sha3.js @@ -0,0 +1,80 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const { isBoringSSL } = require('../common/crypto'); +if (!isBoringSSL) + common.skip('BoringSSL-only test'); + +const assert = require('assert'); +const { subtle } = require('crypto'); +const { SubtleCrypto } = globalThis; + +const unsupportedHash = { + name: 'NotSupportedError', + message: 'SHA-3 is only supported for digest operations', +}; + +async function test() { + const data = Buffer.from('abc'); + const secret = Buffer.alloc(32); + const wrappingKey = await subtle.importKey( + 'raw', Buffer.alloc(16), 'AES-KW', false, ['wrapKey', 'unwrapKey']); + const keyToWrap = await subtle.importKey( + 'raw', secret, { name: 'HMAC', hash: 'SHA-256' }, true, ['sign']); + const wrapped = await subtle.wrapKey('raw', keyToWrap, wrappingKey, 'AES-KW'); + const bases = await Promise.all(['HKDF', 'PBKDF2'].map((name) => + subtle.importKey('raw', secret, name, false, ['deriveBits', 'deriveKey']))); + + for (const [hash, length] of [ + ['SHA3-256', 32], + ['SHA3-384', 48], + ['SHA3-512', 64], + ]) { + assert.strictEqual(SubtleCrypto.supports('digest', hash), true); + assert.strictEqual((await subtle.digest(hash, data)).byteLength, length); + + for (const name of ['RSASSA-PKCS1-v1_5', 'RSA-PSS', 'RSA-OAEP']) { + const algorithm = { + name, hash, modulusLength: 2048, + publicExponent: new Uint8Array([1, 0, 1]), + }; + const usages = name === 'RSA-OAEP' ? ['encrypt', 'decrypt'] : ['sign', 'verify']; + assert.strictEqual(SubtleCrypto.supports('generateKey', algorithm), false); + assert.strictEqual(SubtleCrypto.supports('importKey', algorithm), false); + await assert.rejects(subtle.generateKey(algorithm, true, usages), unsupportedHash); + } + + const hmac = { name: 'HMAC', hash, length: 256 }; + assert.strictEqual(SubtleCrypto.supports('generateKey', hmac), false); + assert.strictEqual(SubtleCrypto.supports('importKey', hmac), false); + await assert.rejects(subtle.generateKey(hmac, true, ['sign']), unsupportedHash); + await assert.rejects(subtle.importKey('raw', secret, hmac, false, ['sign']), + unsupportedHash); + assert.strictEqual(SubtleCrypto.supports('unwrapKey', 'AES-KW', hmac), false); + await assert.rejects(subtle.unwrapKey( + 'raw', wrapped, wrappingKey, 'AES-KW', hmac, false, ['sign']), unsupportedHash); + + for (const [index, algorithm] of [ + { name: 'HKDF', hash, salt: secret, info: data }, + { name: 'PBKDF2', hash, salt: secret, iterations: 1 }, + ].entries()) { + const base = bases[index]; + const derivedKey = { name: 'AES-GCM', length: 128 }; + assert.strictEqual(SubtleCrypto.supports('deriveBits', algorithm, 128), false); + assert.strictEqual(SubtleCrypto.supports('deriveKey', algorithm, derivedKey), false); + await assert.rejects(subtle.deriveBits(algorithm, base, 128), unsupportedHash); + await assert.rejects(subtle.deriveKey( + algorithm, base, derivedKey, false, ['encrypt']), unsupportedHash); + + const sha256 = { ...algorithm, hash: 'SHA-256' }; + assert.strictEqual(SubtleCrypto.supports('deriveKey', sha256, hmac), false); + await assert.rejects(subtle.deriveKey( + sha256, base, hmac, false, ['sign']), unsupportedHash); + } + } +} + +test().then(common.mustCall()); diff --git a/test/parallel/test-webcrypto-derivebits-hkdf.js b/test/parallel/test-webcrypto-derivebits-hkdf.js index 4fb372fd3a8..4fbaa1d7c64 100644 --- a/test/parallel/test-webcrypto-derivebits-hkdf.js +++ b/test/parallel/test-webcrypto-derivebits-hkdf.js @@ -35,7 +35,7 @@ if (!isBoringSSL) { ['HMAC', 256, 'SHA3-512', 'sign', 'verify'], ); } else { - common.printSkipMessage('Skipping unsupported test cases'); + common.printSkipMessage('SHA-3 is only supported for digest operations'); } if (hasOpenSSL(3)) { diff --git a/test/parallel/test-webcrypto-derivekey.js b/test/parallel/test-webcrypto-derivekey.js index 675b740d939..1df24227470 100644 --- a/test/parallel/test-webcrypto-derivekey.js +++ b/test/parallel/test-webcrypto-derivekey.js @@ -96,7 +96,7 @@ const fips4 = hasFIPS(4); 'ac5d90a6bc848961e78a491887539b29c532a9c0d0b39cec464df071a63e0061'], ); } else { - common.printSkipMessage('Skipping unsupported SHA-3 test cases'); + common.printSkipMessage('SHA-3 is only supported for digest operations'); } const tests = Promise.all(kTests.map((args) => test(...args))); @@ -149,7 +149,7 @@ const fips4 = hasFIPS(4); '03431052c37d626ae3fc1df582ff2a4d610642fc27e1b8130ca5980c0b0756ac'] ); } else { - common.printSkipMessage('Skipping unsupported SHA-3 test cases'); + common.printSkipMessage('SHA-3 is only supported for digest operations'); } const promises = kTests.map((args) => test(...args)); @@ -187,7 +187,7 @@ const fips4 = hasFIPS(4); // [{ name: 'HMAC', hash: 'SHA3-512' }, 'sign', 512], ); } else { - common.printSkipMessage('Skipping unsupported SHA-3 test cases'); + common.printSkipMessage('SHA-3 is only supported for digest operations'); } if (hasOpenSSL(3)) { @@ -247,7 +247,7 @@ const fips4 = hasFIPS(4); // [{ name: 'HMAC', hash: 'SHA3-512' }, 'sign', 512], ); } else { - common.printSkipMessage('Skipping unsupported SHA-3 test cases'); + common.printSkipMessage('SHA-3 is only supported for digest operations'); } if (hasOpenSSL(3)) { diff --git a/test/parallel/test-webcrypto-digest.js b/test/parallel/test-webcrypto-digest.js index 89bd86bd928..f9e31192602 100644 --- a/test/parallel/test-webcrypto-digest.js +++ b/test/parallel/test-webcrypto-digest.js @@ -16,15 +16,15 @@ const kTests = [ ['SHA-256', ['sha256'], 256], ['SHA-384', ['sha384'], 384], ['SHA-512', ['sha512'], 512], + ['SHA3-256', ['sha3-256'], 256], + ['SHA3-384', ['sha3-384'], 384], + ['SHA3-512', ['sha3-512'], 512], ]; if (!isBoringSSL) { kTests.push( [{ name: 'cSHAKE128', outputLength: 256 }, ['shake128', { outputLength: 256 >> 3 }], 256], [{ name: 'cSHAKE256', outputLength: 512 }, ['shake256', { outputLength: 512 >> 3 }], 512], - ['SHA3-256', ['sha3-256'], 256], - ['SHA3-384', ['sha3-384'], 384], - ['SHA3-512', ['sha3-512'], 512], ); } else { common.printSkipMessage('Skipping unsupported test cases'); @@ -175,41 +175,41 @@ const kDigestedData = { 'd5290933492f9d17411926a613dd0611668c2ac999e8' + 'c011aabaa9004323425fbad75b0f58ee6e777a94' }, - 'sha3-256': { - empty: 'a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a', - short: '3059af7aa33b517084e8ad7bbc4fb208a44c28ef32b4698d103dd540e4f91aa1', - medium: '1fa7cd1da74cd8046417508c8314e74a9a4a9d38f9f18e6cb215b8c891a0a80e', - long: 'b2cfc61e0386cdaef5e10a2be189891f5ef52a7624bfcd8edc893acc64fec600' - }, - 'sha3-384': { - empty: '0c63a75b845e4f7d01107d852e4c2485c51a50aaaa9' + - '4fc61995e71bbee983a2ac3713831264adb47fb6bd1' + - 'e058d5f004', - short: '54b8f0e4cf4974de740098f66b3024479b01631315a' + - '6773606c33eadc32556a6e778e08f0225ae79265aec' + - '666cb2390b', - medium: '437b7d8b68b250b5c1739ea4cc86db2033879dfb18' + - 'de292c9c50d9c193a4c79a08a6cae3f4e483c2795e' + - 'a5d1ef7e69d2', - long: '3b39c4c97ad87613305d0ccc987181713e2d5e84b1f9' + - '760011bcce0c297499005bdce8a3d2409b5ad0164f32' + - 'bb8778d0' - }, - 'sha3-512': { - empty: 'a69f73cca23a9ac5c8b567dc185a756e97c982164fe' + - '25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9' + - '402c3ac558f500199d95b6d3e301758586281dcd26', - short: '2dd2e07a62e6ad0498ba84f313c4d4024cb46001f78' + - 'f75db336b0d4d8bd2a9ec152c4ad20878735d82ba08' + - '72ecf59608ef3ced2b2a8669427e7da31e362333d8', - medium: 'e640a21909536640369e9b0a48931c5cb2efcbc91f' + - 'ecf247306bc96a0e4ca33307cb8e1b9af367946dd01' + - 'c243f3907508d04f1692a3161df1f898de8ee25febe', - long: 'bd262cecf565c338032de5ba0138f0aacfe7dde83d27' + - '2d0d37d952829ed25de1a1342d98659ef7d2fa4aca7c' + - 'e2b1aa0784d8fc1dcbf81bcec7a7431a3da36bf7' - } } : {}), + 'sha3-256': { + empty: 'a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a', + short: '3059af7aa33b517084e8ad7bbc4fb208a44c28ef32b4698d103dd540e4f91aa1', + medium: '1fa7cd1da74cd8046417508c8314e74a9a4a9d38f9f18e6cb215b8c891a0a80e', + long: 'b2cfc61e0386cdaef5e10a2be189891f5ef52a7624bfcd8edc893acc64fec600' + }, + 'sha3-384': { + empty: '0c63a75b845e4f7d01107d852e4c2485c51a50aaaa9' + + '4fc61995e71bbee983a2ac3713831264adb47fb6bd1' + + 'e058d5f004', + short: '54b8f0e4cf4974de740098f66b3024479b01631315a' + + '6773606c33eadc32556a6e778e08f0225ae79265aec' + + '666cb2390b', + medium: '437b7d8b68b250b5c1739ea4cc86db2033879dfb18' + + 'de292c9c50d9c193a4c79a08a6cae3f4e483c2795e' + + 'a5d1ef7e69d2', + long: '3b39c4c97ad87613305d0ccc987181713e2d5e84b1f9' + + '760011bcce0c297499005bdce8a3d2409b5ad0164f32' + + 'bb8778d0' + }, + 'sha3-512': { + empty: 'a69f73cca23a9ac5c8b567dc185a756e97c982164fe' + + '25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9' + + '402c3ac558f500199d95b6d3e301758586281dcd26', + short: '2dd2e07a62e6ad0498ba84f313c4d4024cb46001f78' + + 'f75db336b0d4d8bd2a9ec152c4ad20878735d82ba08' + + '72ecf59608ef3ced2b2a8669427e7da31e362333d8', + medium: 'e640a21909536640369e9b0a48931c5cb2efcbc91f' + + 'ecf247306bc96a0e4ca33307cb8e1b9af367946dd01' + + 'c243f3907508d04f1692a3161df1f898de8ee25febe', + long: 'bd262cecf565c338032de5ba0138f0aacfe7dde83d27' + + '2d0d37d952829ed25de1a1342d98659ef7d2fa4aca7c' + + 'e2b1aa0784d8fc1dcbf81bcec7a7431a3da36bf7' + } }; async function testDigest(size, alg) { diff --git a/test/parallel/test-webcrypto-encrypt-decrypt.js b/test/parallel/test-webcrypto-encrypt-decrypt.js index 8c851682432..45d0aa64f72 100644 --- a/test/parallel/test-webcrypto-encrypt-decrypt.js +++ b/test/parallel/test-webcrypto-encrypt-decrypt.js @@ -48,18 +48,21 @@ async function testRSAOaep(publicKey, privateKey) { await testRSAOaep(publicKey, privateKey); + // SHA-3 is only supported for digest operations in BoringSSL. if (!isBoringSSL) { // Import the same key material with SHA-3 to avoid another RSA keygen. const [spki, pkcs8] = await Promise.all([ subtle.exportKey('spki', publicKey), subtle.exportKey('pkcs8', privateKey), ]); - const algorithm = { name: 'RSA-OAEP', hash: 'SHA3-384' }; - const [sha3PublicKey, sha3PrivateKey] = await Promise.all([ - subtle.importKey('spki', spki, algorithm, false, ['encrypt']), - subtle.importKey('pkcs8', pkcs8, algorithm, false, ['decrypt']), - ]); - await testRSAOaep(sha3PublicKey, sha3PrivateKey); + for (const hash of ['SHA3-256', 'SHA3-384', 'SHA3-512']) { + const algorithm = { name: 'RSA-OAEP', hash }; + const [sha3PublicKey, sha3PrivateKey] = await Promise.all([ + subtle.importKey('spki', spki, algorithm, false, ['encrypt']), + subtle.importKey('pkcs8', pkcs8, algorithm, false, ['decrypt']), + ]); + await testRSAOaep(sha3PublicKey, sha3PrivateKey); + } } })().then(common.mustCall()); diff --git a/test/parallel/test-webcrypto-export-import-rsa.js b/test/parallel/test-webcrypto-export-import-rsa.js index 385b8e0bc52..9f184084e7c 100644 --- a/test/parallel/test-webcrypto-export-import-rsa.js +++ b/test/parallel/test-webcrypto-export-import-rsa.js @@ -2,7 +2,6 @@ const common = require('../common'); -const { isBoringSSL } = require('../common/crypto'); const fixtures = require('../common/fixtures'); if (!common.hasCrypto) @@ -10,6 +9,7 @@ if (!common.hasCrypto) const assert = require('assert'); const crypto = require('crypto'); +const { isBoringSSL } = require('../common/crypto'); const { subtle } = globalThis.crypto; const sizes = [1024, 2048, 4096]; @@ -19,18 +19,11 @@ const hashes = [ 'SHA-256', 'SHA-384', 'SHA-512', + 'SHA3-256', + 'SHA3-384', + 'SHA3-512', ]; -if (!isBoringSSL) { - hashes.push( - 'SHA3-256', - 'SHA3-384', - 'SHA3-512', - ); -} else { - common.printSkipMessage('Skipping unsupported SHA-3 test cases'); -} - const keyData = { 1024: { spki: Buffer.from( @@ -643,6 +636,22 @@ const testVectors = [ hashes.forEach((hash) => { [true, false].forEach((extractable) => { testVectors.forEach((vector) => { + if (isBoringSSL && hash.startsWith('SHA3-')) { + const { spki, pkcs8, jwk } = keyData[size]; + for (const [format, data, usages] of [ + ['spki', spki, vector.publicUsages], + ['pkcs8', pkcs8, vector.privateUsages], + ['jwk', { kty: jwk.kty, n: jwk.n, e: jwk.e }, vector.publicUsages], + ['jwk', jwk, vector.privateUsages], + ]) { + variations.push(assert.rejects(subtle.importKey( + format, data, { name: vector.name, hash }, extractable, usages), { + name: 'NotSupportedError', + message: 'SHA-3 is only supported for digest operations', + })); + } + return; + } variations.push(testImportSpki(vector, size, hash, extractable)); variations.push(testImportPkcs8(vector, size, hash, extractable)); variations.push(testImportJwk(vector, size, hash, extractable)); diff --git a/test/parallel/test-webcrypto-export-import.js b/test/parallel/test-webcrypto-export-import.js index 63fdde05f1e..4578f7d587d 100644 --- a/test/parallel/test-webcrypto-export-import.js +++ b/test/parallel/test-webcrypto-export-import.js @@ -484,12 +484,19 @@ if (hasOpenSSL(3)) { } // SHA-3 hashes and JWK "alg" -if (!isBoringSSL) { +{ const rsa = fixtures.readKey('rsa_private_2048.pem'); const privateKey = createPrivateKey(rsa); const publicKey = createPublicKey(privateKey); async function test(keyObject, algorithm, usages) { + if (isBoringSSL) { + assert.throws(() => keyObject.toCryptoKey(algorithm, true, usages), { + name: 'NotSupportedError', + message: 'SHA-3 is only supported for digest operations', + }); + return; + } const key = keyObject.toCryptoKey(algorithm, true, usages); const jwk = await subtle.exportKey('jwk', key); assert.strictEqual(jwk.alg, undefined); @@ -501,7 +508,8 @@ if (!isBoringSSL) { test(privateKey, { name, hash }, [name === 'RSA-OAEP' ? 'unwrapKey' : 'sign']).then(common.mustCall()); } - test(createSecretKey(Buffer.alloc(32)), { name: 'HMAC', hash }, ['sign']); + test(createSecretKey(Buffer.alloc(32)), { name: 'HMAC', hash }, ['sign']) + .then(common.mustCall()); } { @@ -517,7 +525,16 @@ if (!isBoringSSL) { message: 'JWK "alg" does not match the requested algorithm', }).then(common.mustCall()); - subtle.importKey('jwk', jwk, { name: 'HMAC', hash: 'SHA3-256' }, false, ['sign', 'verify']).then(common.mustCall()); + const imported = subtle.importKey( + 'jwk', jwk, { name: 'HMAC', hash: 'SHA3-256' }, false, ['sign', 'verify']); + if (isBoringSSL) { + assert.rejects(imported, { + name: 'NotSupportedError', + message: 'SHA-3 is only supported for digest operations', + }).then(common.mustCall()); + } else { + imported.then(common.mustCall()); + } } } diff --git a/test/parallel/test-webcrypto-keygen.js b/test/parallel/test-webcrypto-keygen.js index b1fc8f41b2a..6618a43db74 100644 --- a/test/parallel/test-webcrypto-keygen.js +++ b/test/parallel/test-webcrypto-keygen.js @@ -527,7 +527,7 @@ if (hasOpenSSL(3, 5) || isBoringSSL) { ); } } else { - common.printSkipMessage('Skipping unsupported SHA-3 test case'); + common.printSkipMessage('SHA-3 is only supported for digest operations'); } const tests = kTests.map((args) => test(...args)); @@ -733,7 +733,7 @@ if (hasOpenSSL(3, 5) || isBoringSSL) { // [undefined, 'SHA3-512', ['sign', 'verify']], ); } else { - common.printSkipMessage('Skipping unsupported SHA-3 test cases'); + common.printSkipMessage('SHA-3 is only supported for digest operations'); } const tests = Promise.all(kTests.map((args) => test(...args))); diff --git a/test/parallel/test-webcrypto-normalization-boundary.js b/test/parallel/test-webcrypto-normalization-boundary.js index 20102c32e6a..8365a7d4059 100644 --- a/test/parallel/test-webcrypto-normalization-boundary.js +++ b/test/parallel/test-webcrypto-normalization-boundary.js @@ -39,7 +39,7 @@ const { subtle } = globalThis.crypto; { name: 'OperationError' }); await assert.rejects(subtle.generateKey({ name: 'HMAC', hash: 'SHA-256', length: 0 }, false, []), { name: 'OperationError' }); - if (SubtleCrypto.supports('digest', 'SHA3-256')) { + if (SubtleCrypto.supports('generateKey', { name: 'HMAC', hash: 'SHA3-256', length: 256 })) { const hmac = { name: 'HMAC', hash: 'SHA3-256' }; await assert.rejects(subtle.generateKey(hmac, false, ['encrypt']), { name: 'SyntaxError' }); await assert.rejects(subtle.generateKey(hmac, false, []), { name: 'NotSupportedError' }); diff --git a/test/parallel/test-webcrypto-rsa-jwk-sha3-alg.js b/test/parallel/test-webcrypto-rsa-jwk-sha3-alg.js index 88bc64194e6..55e45119103 100644 --- a/test/parallel/test-webcrypto-rsa-jwk-sha3-alg.js +++ b/test/parallel/test-webcrypto-rsa-jwk-sha3-alg.js @@ -4,13 +4,10 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); -const { isBoringSSL } = require('../common/crypto'); -if (isBoringSSL) - common.skip('missing SHA-3'); - const assert = require('assert'); const { createPrivateKey, createPublicKey } = require('crypto'); const fixtures = require('../common/fixtures'); +const { isBoringSSL } = require('../common/crypto'); const { subtle } = globalThis.crypto; (async () => { @@ -24,6 +21,14 @@ const { subtle } = globalThis.crypto; const usages = name === 'RSA-OAEP' ? [jwk.d ? 'decrypt' : 'encrypt'] : [jwk.d ? 'sign' : 'verify']; const algorithm = { name, hash }; + if (isBoringSSL) { + await assert.rejects( + subtle.importKey('jwk', jwk, algorithm, true, usages), { + name: 'NotSupportedError', + message: 'SHA-3 is only supported for digest operations', + }); + continue; + } // There is no JWK alg identifier for RSA with SHA-3. Omitting alg is // valid, but an identifier for SHA-2 or an unknown identifier is not. const key = await subtle.importKey('jwk', jwk, algorithm, true, usages); diff --git a/test/parallel/test-webcrypto-sign-verify-hmac.js b/test/parallel/test-webcrypto-sign-verify-hmac.js index bbe5dd49810..93d8a43c7ae 100644 --- a/test/parallel/test-webcrypto-sign-verify-hmac.js +++ b/test/parallel/test-webcrypto-sign-verify-hmac.js @@ -7,6 +7,7 @@ if (!common.hasCrypto) const assert = require('assert'); const { getFips } = require('crypto'); +const { isBoringSSL } = require('../common/crypto'); const { subtle } = globalThis.crypto; const vectors = require('../fixtures/crypto/hmac')(); @@ -174,6 +175,10 @@ async function testSign({ hash, const variations = []; for (const vector of vectors) { + // The shared fixtures also cover node:crypto; WebCrypto only supports + // SHA-3 for digest operations in BoringSSL. + if (isBoringSSL && vector.hash.startsWith('SHA3-')) + continue; variations.push(testVerify(vector)); variations.push(testSign(vector)); } diff --git a/test/parallel/test-webcrypto-sign-verify-rsa.js b/test/parallel/test-webcrypto-sign-verify-rsa.js index 201d28fbf1f..8551ad3afa3 100644 --- a/test/parallel/test-webcrypto-sign-verify-rsa.js +++ b/test/parallel/test-webcrypto-sign-verify-rsa.js @@ -267,6 +267,7 @@ async function testSaltLengths(keyLength) { ['SHA-256', 32], ['SHA-384', 48], ['SHA-512', 64], + // SHA-3 is only supported for digest operations in BoringSSL. ...(!isBoringSSL ? [ ['SHA3-256', 32], ['SHA3-384', 48], @@ -283,12 +284,18 @@ async function testSaltLengths(keyLength) { (async function() { const variations = []; + // The shared fixtures also cover node:crypto; WebCrypto only supports + // SHA-3 for digest operations in BoringSSL. rsa_pkcs().forEach((vector) => { + if (isBoringSSL && vector.hash.startsWith('SHA3-')) + return; variations.push(testVerify(vector)); variations.push(rejectsSha1Signing && vector.hash === 'SHA-1' ? testFipsSignRejected(vector) : testSign(vector)); }); rsa_pss().forEach((vector) => { + if (isBoringSSL && vector.hash.startsWith('SHA3-')) + return; variations.push(testVerify(vector)); variations.push(rejectsSha1Signing && vector.hash === 'SHA-1' ? testFipsSignRejected(vector) : testSign(vector)); diff --git a/test/wpt/status/WebCryptoAPI.cjs b/test/wpt/status/WebCryptoAPI.cjs index a73db3793a9..4e8e4efd882 100644 --- a/test/wpt/status/WebCryptoAPI.cjs +++ b/test/wpt/status/WebCryptoAPI.cjs @@ -81,7 +81,6 @@ if (isBoringSSL) { 'secure-curves/derive_bits_keys/cfrg_curves_bits_curve448.https.any.js', 'secure-curves/derive_bits_keys/cfrg_curves_keys_curve448.https.any.js', 'modern-algos/digest/cshake.https.any.js', - 'modern-algos/digest/sha3.https.any.js', 'secure-curves/generateKey/failures_Ed448.https.any.js', 'modern-algos/generateKey/failures_Hybrid-KEM.https.any.js', 'secure-curves/generateKey/failures_X448.https.any.js', From 0504aab04e0282040772a9a4b6100c8f7704ffea Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Thu, 22 Oct 2026 11:20:43 +0200 Subject: [PATCH 108/331] tls: configure TLS 1.3 ciphers with BoringSSL Translate cipher-suite names into protocol IDs for BoringSSL's TLS 1.3 configuration API. Handle duplicates and unknown names, reject nonempty lists without a supported suite, and implement honorCipherOrder through preference flags. Cover suite restrictions, explicit preference ordering, legacy-only lists, runtime defaults, and command-line overrides. Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66922 Reviewed-By: Antoine du Hamel Reviewed-By: James M Snell --- deps/ncrypto/ncrypto.cc | 52 ++++++- lib/internal/tls/wrap.js | 4 +- test/parallel/test-tls-getcipher.js | 5 +- test/parallel/test-tls-set-ciphers-error.js | 10 +- test/parallel/test-tls-set-ciphers.js | 13 +- test/parallel/test-tls13-ciphers.js | 151 ++++++++++++++++++++ 6 files changed, 215 insertions(+), 20 deletions(-) create mode 100644 test/parallel/test-tls13-ciphers.js diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index af6ac711832..28a1431467c 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -5114,13 +5114,57 @@ bool SSLCtxPointer::setGroups(const char* groups) { } bool SSLCtxPointer::setCipherSuites(const char* ciphers) { -#ifndef OPENSSL_IS_BORINGSSL if (!ctx_) return false; +#ifndef OPENSSL_IS_BORINGSSL return SSL_CTX_set_ciphersuites(ctx_.get(), ciphers); #else - // BoringSSL does not allow API config of TLS 1.3 cipher suites. - // We treat this as a non-op. - return true; + constexpr std::array supported = { + SSL_CIPHER_AES_128_GCM_SHA256, + SSL_CIPHER_AES_256_GCM_SHA384, + SSL_CIPHER_CHACHA20_POLY1305_SHA256, + }; + std::vector cipher_ids; + std::string_view remaining(ciphers); + while (!remaining.empty()) { + const size_t end = remaining.find(':'); + std::string_view name = remaining.substr(0, end); + const size_t first = name.find_first_not_of(" \t\n\r\f\v"); + if (first != std::string_view::npos) { + name = name.substr(first); + name = name.substr(0, name.find_last_not_of(" \t\n\r\f\v") + 1); + for (const auto id : supported) { + const SSL_CIPHER* cipher = SSL_get_cipher_by_value(id); + if (name == SSL_CIPHER_standard_name(cipher)) { + // OpenSSL ignores unknown names and accepts duplicates, while + // BoringSSL requires unique protocol IDs. + if (std::find(cipher_ids.begin(), cipher_ids.end(), id) == + cipher_ids.end()) { + cipher_ids.push_back(id); + } + break; + } + } + } + if (end == std::string_view::npos) break; + remaining.remove_prefix(end + 1); + } + if (*ciphers != '\0' && cipher_ids.empty()) { + OPENSSL_PUT_ERROR(SSL, SSL_R_NO_CIPHER_MATCH); + return false; + } + std::vector flags(cipher_ids.size()); + if (!flags.empty() && + (SSL_CTX_get_options(get()) & SSL_OP_CIPHER_SERVER_PREFERENCE) == 0) { + // TLS 1.3 otherwise always uses server preference in BoringSSL. An + // equal-preference group lets the client choose from the configured list. + std::fill(flags.begin(), + flags.end() - 1, + SSL_CIPHER_FLAG_EQUAL_PREFERENCE_WITH_NEXT); + } + // An empty input resets BoringSSL's built-in preference order. The public + // TLS API expands empty cipher strings to Node's defaults before this call. + return SSL_CTX_set1_tls13_ciphers( + get(), cipher_ids.data(), flags.data(), cipher_ids.size()) == 1; #endif } diff --git a/lib/internal/tls/wrap.js b/lib/internal/tls/wrap.js index 9badbafa202..ef1c63d3a5b 100644 --- a/lib/internal/tls/wrap.js +++ b/lib/internal/tls/wrap.js @@ -39,6 +39,8 @@ const { assertCrypto(); +const { openssl_is_boringssl: isBoringSSL } = process.features; + const { setImmediate } = require('timers'); const assert = require('internal/assert'); const crypto = require('crypto'); @@ -1134,7 +1136,7 @@ TLSSocket.prototype.renegotiate = function(options, callback) { this._handle.renegotiate(); } catch (err) { const isBoringSSLRenegotiationUnsupported = - process.features.openssl_is_boringssl && + isBoringSSL && err?.code === 'ERR_SSL_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED'; const error = isBoringSSLRenegotiationUnsupported ? new ERR_TLS_RENEGOTIATION_UNSUPPORTED() : err; diff --git a/test/parallel/test-tls-getcipher.js b/test/parallel/test-tls-getcipher.js index cb8f1ba826b..560a1b2a6e2 100644 --- a/test/parallel/test-tls-getcipher.js +++ b/test/parallel/test-tls-getcipher.js @@ -109,10 +109,7 @@ tls.createServer({ rejectUnauthorized: false }, common.mustCall(() => { const cipher = client.getCipher(); - const expectedCipher = isBoringSSL ? - 'TLS_AES_128_GCM_SHA256' : - 'TLS_AES_256_GCM_SHA384'; - assert.strictEqual(cipher.name, expectedCipher); + assert.strictEqual(cipher.name, 'TLS_AES_256_GCM_SHA384'); assert.strictEqual(cipher.standardName, cipher.name); assert.strictEqual(cipher.version, isBoringSSL ? 'TLSv1/SSLv3' : diff --git a/test/parallel/test-tls-set-ciphers-error.js b/test/parallel/test-tls-set-ciphers-error.js index 102186f9e39..3cfc8c391bf 100644 --- a/test/parallel/test-tls-set-ciphers-error.js +++ b/test/parallel/test-tls-set-ciphers-error.js @@ -7,7 +7,7 @@ if (!common.hasCrypto) const assert = require('assert'); const tls = require('tls'); const fixtures = require('../common/fixtures'); -const { hasOpenSSL, isBoringSSL } = require('../common/crypto'); +const { hasOpenSSL } = require('../common/crypto'); { const options = { @@ -21,12 +21,8 @@ const { hasOpenSSL, isBoringSSL } = require('../common/crypto'); assert.throws(() => tls.createServer(options, common.mustNotCall()), /no[_ ]cipher[_ ]match/i); options.ciphers = 'TLS_not_a_cipher'; - if (isBoringSSL) { - tls.createServer(options).close(); - } else { - assert.throws(() => tls.createServer(options, common.mustNotCall()), - /no[_ ]cipher[_ ]match/i); - } + assert.throws(() => tls.createServer(options, common.mustNotCall()), + /no[_ ]cipher[_ ]match/i); } // Cipher name matching is case-sensitive prior to OpenSSL 4.0, and diff --git a/test/parallel/test-tls-set-ciphers.js b/test/parallel/test-tls-set-ciphers.js index 57fb3599112..0562c808b8d 100644 --- a/test/parallel/test-tls-set-ciphers.js +++ b/test/parallel/test-tls-set-ciphers.js @@ -7,9 +7,10 @@ if (!common.hasCrypto) { const { hasOpenSSL, hasFIPS, + isBoringSSL, } = require('../common/crypto'); -if (!hasOpenSSL(3)) { +if (!hasOpenSSL(3) && !isBoringSSL) { common.skip('missing crypto, or OpenSSL version lower than 3'); } @@ -133,10 +134,11 @@ if (hasFIPS(3)) { test('TLS_AES_256_GCM_SHA384', 'TLS_CHACHA20_POLY1305_SHA256', U, expectedTLSAlertError, 'ERR_SSL_NO_SHARED_CIPHER'); - test('AES256-SHA', 'AES256-SHA256', U, expectedTLSAlertError, + // Use TLS 1.2 suites available on both crypto backends. + test('AES256-SHA', 'ECDHE-RSA-AES256-GCM-SHA384', U, expectedTLSAlertError, 'ERR_SSL_NO_SHARED_CIPHER'); test('AES256-SHA:TLS_AES_256_GCM_SHA384', - 'TLS_CHACHA20_POLY1305_SHA256:AES256-SHA256', + 'TLS_CHACHA20_POLY1305_SHA256:ECDHE-RSA-AES256-GCM-SHA384', U, expectedTLSAlertError, 'ERR_SSL_NO_SHARED_CIPHER'); // Cipher order ignored, TLS1.3 chosen before TLS1.2. @@ -154,7 +156,10 @@ if (hasFIPS(3)) { // default, but work. // However, for OpenSSL32 AES_128 is not enabled due to the // default security level - if (!hasOpenSSL(3, 2)) { + if (isBoringSSL) { + // BoringSSL does not implement the TLS 1.3 CCM cipher suites. + test('TLS_AES_128_CCM_8_SHA256', U, U, 'ERR_SSL_NO_CIPHER_MATCH', U); + } else if (!hasOpenSSL(3, 2)) { test('TLS_AES_128_CCM_8_SHA256', U, U, 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE', 'ERR_SSL_NO_SHARED_CIPHER'); diff --git a/test/parallel/test-tls13-ciphers.js b/test/parallel/test-tls13-ciphers.js new file mode 100644 index 00000000000..7cf87557e8d --- /dev/null +++ b/test/parallel/test-tls13-ciphers.js @@ -0,0 +1,151 @@ +'use strict'; +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('assert'); +const { constants } = require('crypto'); +const tls = require('tls'); +const fixtures = require('../common/fixtures'); +const { hasOpenSSL, isBoringSSL } = require('../common/crypto'); +const { spawnSyncAndAssert } = require('../common/child_process'); +const { connect, keys } = require(fixtures.path('tls-connect')); + +const aes128 = 'TLS_AES_128_GCM_SHA256'; +const aes256 = 'TLS_AES_256_GCM_SHA384'; +const tls13Ciphers = [aes128, aes256, 'TLS_CHACHA20_POLY1305_SHA256']; +const legacy = 'ECDHE-RSA-AES256-GCM-SHA384'; + +function test(clientCiphers, serverCiphers, expectedCipher, options = {}) { + connect({ + client: { + rejectUnauthorized: false, + minVersion: 'TLSv1.2', + maxVersion: 'TLSv1.3', + ciphers: clientCiphers, + ...options.client, + }, + server: { + key: keys.agent2.key, + cert: keys.agent2.cert, + minVersion: 'TLSv1.2', + maxVersion: 'TLSv1.3', + ciphers: serverCiphers, + ...options.server, + }, + }, common.mustCall((err, pair, cleanup) => { + if (expectedCipher === undefined) { + assert(err); + assert.strictEqual(pair.server.err.code, 'ERR_SSL_NO_SHARED_CIPHER'); + assert(pair.client.err); + } else { + assert.ifError(err); + const expected = Array.isArray(expectedCipher) ? expectedCipher : [expectedCipher]; + const cipher = pair.client.conn.getCipher().name; + assert(expected.includes(cipher)); + for (const { conn } of [pair.client, pair.server]) { + assert.strictEqual(conn.getCipher().name, cipher); + assert.strictEqual(conn.getProtocol(), + expectedCipher === legacy ? 'TLSv1.2' : 'TLSv1.3'); + } + } + cleanup(); + })); +} + +function testLegacyOnlyCipherLists() { + for (const honorCipherOrder of [true, false]) { + const options = { server: { honorCipherOrder } }; + // A legacy-only list retains the backend's TLS 1.3 defaults. Check that + // each peer can negotiate either AES suite without assuming their order. + test(aes128, legacy, aes128, options); + test(aes256, legacy, aes256, options); + test(legacy, aes128, aes128, options); + test(legacy, aes256, aes256, options); + test(legacy, legacy, tls13Ciphers, options); + } +} + +if (process.argv[2] !== undefined) { + const mode = process.argv[2]; + if (mode === 'runtime-defaults') { + tls.DEFAULT_CIPHERS = aes128; + } else { + assert.strictEqual(tls.DEFAULT_CIPHERS, + mode === 'cli-defaults' ? aes128 : legacy); + } + // Explicit TLS 1.3 defaults are still applied when ciphers is omitted, but + // must not replace the native defaults for an explicit legacy-only list. + test(undefined, undefined, mode === 'cli-legacy-defaults' ? tls13Ciphers : aes128); + testLegacyOnlyCipherLists(); + return; +} + +// Both peers must apply the configured TLS 1.3 cipher list. +test(aes256, undefined, aes256); +test(undefined, aes256, aes256); +test(aes128, aes256, undefined); + +// Duplicate names and trailing whitespace must not cause rejection. +const duplicates = `${aes256} \t:${aes256}`; +test(duplicates, duplicates, aes256); + +// OpenSSL 1.1.1 rejects unknown TLS 1.3 cipher names. OpenSSL 3 and BoringSSL +// ignore them and do not interpret exclusion rules in the TLS 1.3 list. +const list = `TLS_UNKNOWN:!${aes128}:${duplicates}`; +if (hasOpenSSL(3) || isBoringSSL) { + test(list, list, aes256); +} else { + assert.throws(() => tls.createSecureContext({ ciphers: list }), { + code: 'ERR_SSL_NO_CIPHER_MATCH', + }); +} +for (const ciphers of ['TLS_UNKNOWN', `!${aes128}`]) { + assert.throws(() => tls.createSecureContext({ ciphers }), { + code: 'ERR_SSL_NO_CIPHER_MATCH', + }); +} +if (isBoringSSL) { + assert.throws(() => tls.createSecureContext({ + ciphers: 'TLS_AES_128_CCM_SHA256', + }), { + code: 'ERR_SSL_NO_CIPHER_MATCH', + }); +} + +// Honor the server's cipher-order option in TLS 1.3 as well as TLS 1.2. +test(`${aes256}:${aes128}`, `${aes128}:${aes256}`, aes128, { + server: { honorCipherOrder: true }, +}); +test(`${aes256}:${aes128}`, `${aes128}:${aes256}`, aes256, { + server: { honorCipherOrder: false }, +}); +testLegacyOnlyCipherLists(); + +// TLS 1.2 configuration and explicit protocol restrictions remain effective. +const mixed = `${legacy}:${aes256}`; +test(mixed, mixed, aes256); +test(mixed, mixed, legacy, { + client: { maxVersion: 'TLSv1.2' }, + server: { maxVersion: 'TLSv1.2' }, +}); +test(mixed, mixed, legacy, { + server: { secureOptions: constants.SSL_OP_NO_TLSv1_3 }, +}); + +// Empty public cipher strings continue to select Node's defaults. +test('', aes256, aes256); +test(aes256, '', aes256); + +for (const [mode, ciphers] of [ + ['runtime-defaults', undefined], + ['cli-defaults', aes128], + ['cli-legacy-defaults', legacy], +]) { + spawnSyncAndAssert(process.execPath, [ + ...process.execArgv, + ...(ciphers === undefined ? [] : [`--tls-cipher-list=${ciphers}`]), + __filename, + mode, + ], {}); +} From 4cd1a7fd7627f774c497e1c70794baabbc5be03f Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Thu, 22 Oct 2026 11:20:45 +0200 Subject: [PATCH 109/331] test: remove obsolete BoringSSL skips Run supported DH, ECDH, legacy TLS, TLS 1.2 PSK, cipher metadata, raw key, and X.509 date cases with BoringSSL. Assert its DH flags, curve format errors, and name-constraint behavior. Narrow key/cert array exclusions to the failing multi-identity cases. Use modp5 for the DH group setter checks and remove the unused legacy protocol fallback helper. Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66922 Reviewed-By: Antoine du Hamel Reviewed-By: James M Snell --- test/common/boringssl.js | 28 -- test/parallel/test-crypto-dh-curves.js | 256 +++++++++--------- test/parallel/test-crypto-dh-group-setters.js | 7 +- test/parallel/test-crypto-dh-modp2-views.js | 9 +- test/parallel/test-crypto-dh-modp2.js | 9 +- test/parallel/test-crypto-getcipherinfo.js | 16 +- test/parallel/test-crypto-key-objects-raw.js | 6 +- test/parallel/test-crypto-x509.js | 18 +- .../test-https-options-boolean-check.js | 45 ++- test/parallel/test-tls-getprotocol.js | 20 +- test/parallel/test-tls-min-max-version.js | 58 ++-- test/parallel/test-tls-name-constraints-cn.js | 18 +- .../test-tls-options-boolean-check.js | 45 ++- ...ls-psk-alpn-callback-exception-handling.js | 16 +- test/parallel/test-tls-psk-circuit.js | 15 +- test/parallel/test-tls-psk-server.js | 11 +- test/sequential/test-tls-psk-client.js | 11 +- 17 files changed, 276 insertions(+), 312 deletions(-) diff --git a/test/common/boringssl.js b/test/common/boringssl.js index ab7f0505b0c..53d5044e545 100644 --- a/test/common/boringssl.js +++ b/test/common/boringssl.js @@ -167,33 +167,6 @@ function testEphemeralKeyInfo() { })); } -/** - * The protocol matrix tests cover OpenSSL behavior for legacy TLS protocols. - * For BoringSSL we only need to exhibit that a TLSv1-only client cannot connect - * to a server whose minimum protocol is TLS 1.2; the client receives the - * protocol-version alert instead of the OpenSSL version-specific matrix. - */ -function testLegacyProtocolUnsupported() { - const server = tls.createServer({ - key: fixtures.readKey('agent2-key.pem'), - cert: fixtures.readKey('agent2-cert.pem'), - minVersion: 'TLSv1.2', - }, common.mustNotCall()); - - server.on('tlsClientError', common.mustCall()); - server.listen(0, common.mustCall(() => { - const client = tls.connect({ - port: server.address().port, - rejectUnauthorized: false, - secureProtocol: 'TLSv1_method', - }, common.mustNotCall()); - client.on('error', common.mustCall((err) => { - assert.strictEqual(err.code, 'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION'); - server.close(); - })); - })); -} - /** * BoringSSL can load a multi-PFX option well enough to serve the ECDSA * identity, but it does not provide the same OpenSSL multi-identity selection @@ -335,7 +308,6 @@ module.exports = { assertNoCipherMatch, assertOpenSSLSecurityLevelsUnsupported, testEphemeralKeyInfo, - testLegacyProtocolUnsupported, testMultiPfxSelectionDifference, testPskTls13Unsupported, testRenegotiationUnsupported, diff --git a/test/parallel/test-crypto-dh-curves.js b/test/parallel/test-crypto-dh-curves.js index 22b05fb8960..ef5d0323d33 100644 --- a/test/parallel/test-crypto-dh-curves.js +++ b/test/parallel/test-crypto-dh-curves.js @@ -21,12 +21,14 @@ const p = 'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74' + 'EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFF'; crypto.createDiffieHellman(p, 'hex'); -if (!isBoringSSL) { +{ + // BoringSSL also flags these primes as unsuitable for generator 2. + const generatorError = isBoringSSL ? DH_NOT_SUITABLE_GENERATOR : 0; const notPrime = Buffer.from(p, 'hex'); notPrime[notPrime.length - 1] = 0xfd; assert.strictEqual( crypto.createDiffieHellman(notPrime, Buffer.from([2])).verifyError, - DH_CHECK_P_NOT_PRIME); + DH_CHECK_P_NOT_PRIME | generatorError); const notSafePrime = Buffer.from( 'd2d6d13e1c1e0bbb63c742199dee010411f089ac74f0f7213348388280700fd6' + @@ -34,7 +36,7 @@ if (!isBoringSSL) { 'hex'); assert.strictEqual( crypto.createDiffieHellman(notSafePrime, Buffer.from([2])).verifyError, - DH_CHECK_P_NOT_SAFE_PRIME); + DH_CHECK_P_NOT_SAFE_PRIME | generatorError); } const group = crypto.getDiffieHellman('modp14'); @@ -95,7 +97,7 @@ if (availableCurves.has('Oakley-EC2N-3')) { } // Test ECDH -if (availableCurves.has('prime256v1') && availableCurves.has('secp256k1')) { +if (availableCurves.has('prime256v1')) { const ecdh1 = crypto.createECDH('prime256v1'); const ecdh2 = crypto.createECDH('prime256v1'); const key1 = ecdh1.generateKeys(); @@ -109,8 +111,15 @@ if (availableCurves.has('prime256v1') && availableCurves.has('secp256k1')) { assert.strictEqual(ecdh1.getPublicKey('buffer', 'uncompressed')[0], 4); let firstByte = ecdh1.getPublicKey('buffer', 'compressed')[0]; assert(firstByte === 2 || firstByte === 3); - firstByte = ecdh1.getPublicKey('buffer', 'hybrid')[0]; - assert(firstByte === 6 || firstByte === 7); + if (isBoringSSL) { + assert.throws(() => ecdh1.getPublicKey('buffer', 'hybrid'), { + code: 'ERR_CRYPTO_OPERATION_FAILED', + message: 'Failed to get public key length', + }); + } else { + firstByte = ecdh1.getPublicKey('buffer', 'hybrid')[0]; + assert(firstByte === 6 || firstByte === 7); + } // Format value should be string assert.throws( @@ -121,127 +130,128 @@ if (availableCurves.has('prime256v1') && availableCurves.has('secp256k1')) { message: 'Invalid ECDH format: 10' }); - // ECDH should check that point is on curve - const ecdh3 = crypto.createECDH('secp256k1'); - if (hasFIPS(3)) { - assert.throws(() => ecdh3.generateKeys(), { - code: 'ERR_CRYPTO_OPERATION_FAILED', - }); - } else { - const key3 = ecdh3.generateKeys(); - - assert.throws( - () => ecdh2.computeSecret(key3, 'latin1', 'buffer'), - { - code: 'ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY', - name: 'Error', - message: 'Public key is not valid for specified curve' + // ECDH should allow .setPrivateKey()/.setPublicKey() + const ecdh4 = crypto.createECDH('prime256v1'); + + ecdh4.setPrivateKey(ecdh1.getPrivateKey()); + ecdh4.setPublicKey(ecdh1.getPublicKey()); + + const ecdh4Secret = ecdh4.computeSecret(ecdh2.getPublicKey()); + assert.deepStrictEqual(ecdh4.computeSecret(ecdh2.getPublicKey()), ecdh4Secret); + + if (availableCurves.has('secp256k1')) { + // ECDH should check that point is on curve + const ecdh3 = crypto.createECDH('secp256k1'); + if (hasFIPS(3)) { + assert.throws(() => ecdh3.generateKeys(), { + code: 'ERR_CRYPTO_OPERATION_FAILED', }); + } else { + const key3 = ecdh3.generateKeys(); + + assert.throws( + () => ecdh2.computeSecret(key3, 'latin1', 'buffer'), + { + code: 'ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY', + name: 'Error', + message: 'Public key is not valid for specified curve' + }); + + assert.throws(() => { + ecdh4.setPublicKey(ecdh3.getPublicKey()); + }, { message: 'Failed to convert Buffer to EC_POINT' }); + assert.deepStrictEqual(ecdh4.computeSecret(ecdh2.getPublicKey()), + ecdh4Secret); + + // Verify that we can use ECDH without having to use newly generated keys. + const ecdh5 = crypto.createECDH('secp256k1'); + + // Verify errors are thrown when retrieving keys from an uninitialized object. + assert.throws(() => { + ecdh5.getPublicKey(); + }, /^Error: Failed to get ECDH public key$/); - // ECDH should allow .setPrivateKey()/.setPublicKey() - const ecdh4 = crypto.createECDH('prime256v1'); - - ecdh4.setPrivateKey(ecdh1.getPrivateKey()); - ecdh4.setPublicKey(ecdh1.getPublicKey()); - - const ecdh4Secret = ecdh4.computeSecret(ecdh2.getPublicKey()); - assert.deepStrictEqual(ecdh4.computeSecret(ecdh2.getPublicKey()), - ecdh4Secret); - - assert.throws(() => { - ecdh4.setPublicKey(ecdh3.getPublicKey()); - }, { message: 'Failed to convert Buffer to EC_POINT' }); - assert.deepStrictEqual(ecdh4.computeSecret(ecdh2.getPublicKey()), - ecdh4Secret); - - // Verify that we can use ECDH without having to use newly generated keys. - const ecdh5 = crypto.createECDH('secp256k1'); - - // Verify errors are thrown when retrieving keys from an uninitialized object. - assert.throws(() => { - ecdh5.getPublicKey(); - }, /^Error: Failed to get ECDH public key$/); - - assert.throws(() => { - ecdh5.getPrivateKey(); - }, /^Error: Failed to get ECDH private key$/); - - // A valid private key for the secp256k1 curve. - const cafebabeKey = 'cafebabe'.repeat(8); - // Associated compressed and uncompressed public keys (points). - const cafebabePubPtComp = - '03672a31bfc59d3f04548ec9b7daeeba2f61814e8ccc40448045007f5479f693a3'; - const cafebabePubPtUnComp = - '04672a31bfc59d3f04548ec9b7daeeba2f61814e8ccc40448045007f5479f693a3' + - '2e02c7f93d13dc2732b760ca377a5897b9dd41a1c1b29dc0442fdce6d0a04d1d'; - ecdh5.setPrivateKey(cafebabeKey, 'hex'); - assert.strictEqual(ecdh5.getPrivateKey('hex'), cafebabeKey); - // Show that the public point (key) is generated while setting the - // private key. - assert.strictEqual(ecdh5.getPublicKey('hex'), cafebabePubPtUnComp); - - // Compressed and uncompressed public points/keys for other party's - // private key. - // 0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF - const peerPubPtComp = - '02c6b754b20826eb925e052ee2c25285b162b51fdca732bcf67e39d647fb6830ae'; - const peerPubPtUnComp = - '04c6b754b20826eb925e052ee2c25285b162b51fdca732bcf67e39d647fb6830ae' + - 'b651944a574a362082a77e3f2b5d9223eb54d7f2f76846522bf75f3bedb8178e'; - - const sharedSecret = - '1da220b5329bbe8bfd19ceef5a5898593f411a6f12ea40f2a8eead9a5cf59970'; - - assert.strictEqual(ecdh5.computeSecret(peerPubPtComp, 'hex', 'hex'), - sharedSecret); - assert.strictEqual(ecdh5.computeSecret(peerPubPtUnComp, 'hex', 'hex'), - sharedSecret); - assert.strictEqual(ecdh5.computeSecret(peerPubPtComp, 'hex', 'hex'), - sharedSecret); - - // Verify that we still have the same key pair as before the computation. - assert.strictEqual(ecdh5.getPrivateKey('hex'), cafebabeKey); - assert.strictEqual(ecdh5.getPublicKey('hex'), cafebabePubPtUnComp); - - // Verify setting and getting compressed and non-compressed serializations. - ecdh5.setPublicKey(cafebabePubPtComp, 'hex'); - assert.strictEqual(ecdh5.getPublicKey('hex'), cafebabePubPtUnComp); - assert.strictEqual( - ecdh5.getPublicKey('hex', 'compressed'), - cafebabePubPtComp - ); - ecdh5.setPublicKey(cafebabePubPtUnComp, 'hex'); - assert.strictEqual(ecdh5.getPublicKey('hex'), cafebabePubPtUnComp); - assert.strictEqual( - ecdh5.getPublicKey('hex', 'compressed'), - cafebabePubPtComp - ); - - // Show why allowing the public key to be set on this type - // does not make sense. - ecdh5.setPublicKey(peerPubPtComp, 'hex'); - assert.strictEqual(ecdh5.getPublicKey('hex'), peerPubPtUnComp); - assert.throws(() => { - // Error because the public key does not match the private key anymore. - ecdh5.computeSecret(peerPubPtComp, 'hex', 'hex'); - }, /Invalid key pair/); - - // Set to a valid key to show that later attempts to set an invalid key are - // rejected. - ecdh5.setPrivateKey(cafebabeKey, 'hex'); - - // Some invalid private keys for the secp256k1 curve. - const errMessage = /Private key is not valid for specified curve/; - ['0000000000000000000000000000000000000000000000000000000000000000', - 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141', - 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF', - ].forEach((element) => { assert.throws(() => { - ecdh5.setPrivateKey(element, 'hex'); - }, errMessage); - // Verify object state did not change. + ecdh5.getPrivateKey(); + }, /^Error: Failed to get ECDH private key$/); + + // A valid private key for the secp256k1 curve. + const cafebabeKey = 'cafebabe'.repeat(8); + // Associated compressed and uncompressed public keys (points). + const cafebabePubPtComp = + '03672a31bfc59d3f04548ec9b7daeeba2f61814e8ccc40448045007f5479f693a3'; + const cafebabePubPtUnComp = + '04672a31bfc59d3f04548ec9b7daeeba2f61814e8ccc40448045007f5479f693a3' + + '2e02c7f93d13dc2732b760ca377a5897b9dd41a1c1b29dc0442fdce6d0a04d1d'; + ecdh5.setPrivateKey(cafebabeKey, 'hex'); assert.strictEqual(ecdh5.getPrivateKey('hex'), cafebabeKey); - }); + // Show that the public point (key) is generated while setting the + // private key. + assert.strictEqual(ecdh5.getPublicKey('hex'), cafebabePubPtUnComp); + + // Compressed and uncompressed public points/keys for other party's + // private key. + // 0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF + const peerPubPtComp = + '02c6b754b20826eb925e052ee2c25285b162b51fdca732bcf67e39d647fb6830ae'; + const peerPubPtUnComp = + '04c6b754b20826eb925e052ee2c25285b162b51fdca732bcf67e39d647fb6830ae' + + 'b651944a574a362082a77e3f2b5d9223eb54d7f2f76846522bf75f3bedb8178e'; + + const sharedSecret = + '1da220b5329bbe8bfd19ceef5a5898593f411a6f12ea40f2a8eead9a5cf59970'; + + assert.strictEqual(ecdh5.computeSecret(peerPubPtComp, 'hex', 'hex'), + sharedSecret); + assert.strictEqual(ecdh5.computeSecret(peerPubPtUnComp, 'hex', 'hex'), + sharedSecret); + assert.strictEqual(ecdh5.computeSecret(peerPubPtComp, 'hex', 'hex'), + sharedSecret); + + // Verify that we still have the same key pair as before the computation. + assert.strictEqual(ecdh5.getPrivateKey('hex'), cafebabeKey); + assert.strictEqual(ecdh5.getPublicKey('hex'), cafebabePubPtUnComp); + + // Verify setting and getting compressed and non-compressed serializations. + ecdh5.setPublicKey(cafebabePubPtComp, 'hex'); + assert.strictEqual(ecdh5.getPublicKey('hex'), cafebabePubPtUnComp); + assert.strictEqual( + ecdh5.getPublicKey('hex', 'compressed'), + cafebabePubPtComp + ); + ecdh5.setPublicKey(cafebabePubPtUnComp, 'hex'); + assert.strictEqual(ecdh5.getPublicKey('hex'), cafebabePubPtUnComp); + assert.strictEqual( + ecdh5.getPublicKey('hex', 'compressed'), + cafebabePubPtComp + ); + + // Show why allowing the public key to be set on this type + // does not make sense. + ecdh5.setPublicKey(peerPubPtComp, 'hex'); + assert.strictEqual(ecdh5.getPublicKey('hex'), peerPubPtUnComp); + assert.throws(() => { + // Error because the public key does not match the private key anymore. + ecdh5.computeSecret(peerPubPtComp, 'hex', 'hex'); + }, /Invalid key pair/); + + // Set to a valid key to show that later attempts to set an invalid key are + // rejected. + ecdh5.setPrivateKey(cafebabeKey, 'hex'); + + // Some invalid private keys for the secp256k1 curve. + const errMessage = /Private key is not valid for specified curve/; + ['0000000000000000000000000000000000000000000000000000000000000000', + 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141', + 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF', + ].forEach((element) => { + assert.throws(() => { + ecdh5.setPrivateKey(element, 'hex'); + }, errMessage); + // Verify object state did not change. + assert.strictEqual(ecdh5.getPrivateKey('hex'), cafebabeKey); + }); + } } } diff --git a/test/parallel/test-crypto-dh-group-setters.js b/test/parallel/test-crypto-dh-group-setters.js index ccc370e2352..f759d29be0f 100644 --- a/test/parallel/test-crypto-dh-group-setters.js +++ b/test/parallel/test-crypto-dh-group-setters.js @@ -1,19 +1,14 @@ 'use strict'; const common = require('../common'); -const { isBoringSSL } = require('../common/crypto'); if (!common.hasCrypto) common.skip('missing crypto'); const assert = require('assert'); const crypto = require('crypto'); -if (isBoringSSL) { - common.skip('Skipping unsupported Diffie-Hellman tests'); -} - // Unlike DiffieHellman, DiffieHellmanGroup does not have any setters. -const dhg = crypto.getDiffieHellman('modp1'); +const dhg = crypto.getDiffieHellman('modp5'); assert.strictEqual(dhg.constructor, crypto.DiffieHellmanGroup); assert.strictEqual(dhg.setPrivateKey, undefined); assert.strictEqual(dhg.setPublicKey, undefined); diff --git a/test/parallel/test-crypto-dh-modp2-views.js b/test/parallel/test-crypto-dh-modp2-views.js index ce2d8823bee..0ce2f3d8af6 100644 --- a/test/parallel/test-crypto-dh-modp2-views.js +++ b/test/parallel/test-crypto-dh-modp2-views.js @@ -8,7 +8,11 @@ const crypto = require('crypto'); const { hasFIPS, modp2buf, isBoringSSL } = require('../common/crypto'); if (isBoringSSL) { - common.skip('Skipping unsupported Diffie-Hellman tests'); + // BoringSSL omits this named group but accepts its raw parameters. + assert.throws(() => crypto.createDiffieHellmanGroup('modp2'), { + code: 'ERR_CRYPTO_UNKNOWN_DH_GROUP', + message: 'Unknown DH group', + }); } if (hasFIPS(3)) { @@ -16,7 +20,8 @@ if (hasFIPS(3)) { code: 'ERR_INVALID_ARG_VALUE', }); } else { - const modp2 = crypto.createDiffieHellmanGroup('modp2'); + const modp2 = isBoringSSL ? crypto.createDiffieHellman(modp2buf, 2) : + crypto.createDiffieHellmanGroup('modp2'); const views = common.getArrayBufferViews(modp2buf); for (const buf of [modp2buf, ...views]) { diff --git a/test/parallel/test-crypto-dh-modp2.js b/test/parallel/test-crypto-dh-modp2.js index a0ec31a1eb4..45e6eee319b 100644 --- a/test/parallel/test-crypto-dh-modp2.js +++ b/test/parallel/test-crypto-dh-modp2.js @@ -8,7 +8,11 @@ const crypto = require('crypto'); const { hasFIPS, modp2buf, isBoringSSL } = require('../common/crypto'); if (isBoringSSL) { - common.skip('Skipping unsupported Diffie-Hellman tests'); + // BoringSSL omits this named group but accepts its raw parameters. + assert.throws(() => crypto.createDiffieHellmanGroup('modp2'), { + code: 'ERR_CRYPTO_UNKNOWN_DH_GROUP', + message: 'Unknown DH group', + }); } if (hasFIPS(3)) { @@ -16,7 +20,8 @@ if (hasFIPS(3)) { code: 'ERR_INVALID_ARG_VALUE', }); } else { - const modp2 = crypto.createDiffieHellmanGroup('modp2'); + const modp2 = isBoringSSL ? crypto.createDiffieHellman(modp2buf, 2) : + crypto.createDiffieHellmanGroup('modp2'); { // Ensure specific generator (buffer) works as expected. diff --git a/test/parallel/test-crypto-getcipherinfo.js b/test/parallel/test-crypto-getcipherinfo.js index faf45c766c5..4c8e0c01c08 100644 --- a/test/parallel/test-crypto-getcipherinfo.js +++ b/test/parallel/test-crypto-getcipherinfo.js @@ -54,21 +54,13 @@ if (ciphers.includes('aes-128-wrap-inv')) { } assert(!ciphers.some((cipher) => /^\d+(?:\.\d+)+$/.test(cipher))); -if (!isBoringSSL) { - // A failed provider fetch must not contaminate the OpenSSL error queue. - assert.throws(() => createHash('sha256', { outputLength: 28 }), { - code: 'ERR_OSSL_EVP_NOT_XOF_OR_INVALID_LENGTH', - }); -} +// A failed provider fetch must not contaminate the OpenSSL error queue. +assert.throws(() => createHash('sha256', { outputLength: 28 }), { + code: 'ERR_OSSL_EVP_NOT_XOF_OR_INVALID_LENGTH', +}); for (const cipher of ciphers) { const info = getCipherInfo(cipher); - if (isBoringSSL && !info) { - // BoringSSL reports some legacy ciphers in getCiphers() but returns no - // info for them (e.g. des-ede3, des-ede3-ecb, rc2-40-cbc). - common.printSkipMessage(`Skipping unsupported ${cipher} test case`); - continue; - } assert(info); if (info.nid !== undefined) { const info2 = getCipherInfo(info.nid); diff --git a/test/parallel/test-crypto-key-objects-raw.js b/test/parallel/test-crypto-key-objects-raw.js index 4a129d1a618..7cf4e7bb169 100644 --- a/test/parallel/test-crypto-key-objects-raw.js +++ b/test/parallel/test-crypto-key-objects-raw.js @@ -121,12 +121,8 @@ if (hasOpenSSL(3, 5)) { { const unsupportedKeyTypes = [ ['rsa', 'rsa_public_2048.pem', 'rsa_private_2048.pem'], + ['dsa', 'dsa_public.pem', 'dsa_private.pem'], ]; - if (!isBoringSSL) { - unsupportedKeyTypes.push(['dsa', 'dsa_public.pem', 'dsa_private.pem']); - } else { - common.printSkipMessage('Skipping unsupported dsa test case'); - } for (const [type, pub, priv] of unsupportedKeyTypes) { const pubKeyObj = crypto.createPublicKey( fixtures.readKey(pub, 'ascii')); diff --git a/test/parallel/test-crypto-x509.js b/test/parallel/test-crypto-x509.js index 8e8ae2773d1..1af8a8a6269 100644 --- a/test/parallel/test-crypto-x509.js +++ b/test/parallel/test-crypto-x509.js @@ -177,10 +177,8 @@ for (const [commonName, property] of [ assert.deepStrictEqual(x509.raw, der); - if (!isBoringSSL) { - assert.deepStrictEqual(x509.validFromDate, new Date('2022-09-03T21:40:37Z')); - assert.deepStrictEqual(x509.validToDate, new Date('2296-06-17T21:40:37Z')); - } + assert.deepStrictEqual(x509.validFromDate, new Date('2022-09-03T21:40:37Z')); + assert.deepStrictEqual(x509.validToDate, new Date('2296-06-17T21:40:37Z')); assert(x509.publicKey); assert.strictEqual(x509.publicKey.type, 'public'); @@ -565,10 +563,8 @@ UidvpWWipVLZgK+oDks+bKTobcoXGW9oXobiIYqslXPy -----END CERTIFICATE-----`.trim(); const c1 = new X509Certificate(certPemUTCTime); - if (!isBoringSSL) { - assert.deepStrictEqual(c1.validFromDate, new Date('1949-12-25T23:59:58Z')); - assert.deepStrictEqual(c1.validToDate, new Date('1950-01-01T23:59:58Z')); - } + assert.deepStrictEqual(c1.validFromDate, new Date('1949-12-25T23:59:58Z')); + assert.deepStrictEqual(c1.validToDate, new Date('1950-01-01T23:59:58Z')); // The GeneralizedTime format is used for dates in 2050 or later. const certPemGeneralizedTime = `-----BEGIN CERTIFICATE----- @@ -602,10 +598,8 @@ CWwQO8JZjJqFtqtuzy2n+gLCvqePgG/gmSqHOPm2ZbLW -----END CERTIFICATE-----`.trim(); const c2 = new X509Certificate(certPemGeneralizedTime); - if (!isBoringSSL) { - assert.deepStrictEqual(c2.validFromDate, new Date('2049-12-26T00:00:01Z')); - assert.deepStrictEqual(c2.validToDate, new Date('2050-01-02T00:00:01Z')); - } + assert.deepStrictEqual(c2.validFromDate, new Date('2049-12-26T00:00:01Z')); + assert.deepStrictEqual(c2.validToDate, new Date('2050-01-02T00:00:01Z')); } { diff --git a/test/parallel/test-https-options-boolean-check.js b/test/parallel/test-https-options-boolean-check.js index 776e966211c..f4193fdf737 100644 --- a/test/parallel/test-https-options-boolean-check.js +++ b/test/parallel/test-https-options-boolean-check.js @@ -42,20 +42,6 @@ const keyDataView = toDataView(keyBuff); const certDataView = toDataView(certBuff); const caArrDataView = toDataView(caCert); -function filterBoringSSLKeyCertArrayCases(options, setName) { - if (!isBoringSSL) - return options; - - // The array-valued cases exercise multi-identity key/cert handling. - // BoringSSL may reject those cases with backend key/cert mismatch errors - // before the boolean/type validation this test is targeting. Keep the scalar - // cases so https.createServer() option type validation is still covered. - common.printSkipMessage( - `BoringSSL: skipping ${setName} key/cert array cases`); - return options.filter(([key, cert]) => !Array.isArray(key) && - !Array.isArray(cert)); -} - // Checks to ensure https.createServer doesn't throw an error // Format ['key', 'cert'] const validOptions = [ @@ -72,18 +58,24 @@ const validOptions = [ [keyDataView, certDataView], [keyDataView, false], [false, certDataView], - [[keyBuff, keyBuff2], [certBuff, certBuff2]], - [[keyStr, keyStr2], [certStr, certStr2]], [[keyStr, keyStr2], false], [false, [certStr, certStr2]], [[{ pem: keyBuff }], false], [[{ pem: keyBuff }, { pem: keyBuff }], false], ]; -filterBoringSSLKeyCertArrayCases(validOptions, 'valid') - .forEach(([key, cert]) => { - https.createServer({ key, cert }); - }); +// Node's BoringSSL setup keeps one identity, so mixed RSA/EC key and +// certificate arrays fail with a key-type mismatch before option validation. +if (!isBoringSSL) { + validOptions.push( + [[keyBuff, keyBuff2], [certBuff, certBuff2]], + [[keyStr, keyStr2], [certStr, certStr2]], + ); +} + +validOptions.forEach(([key, cert]) => { + https.createServer({ key, cert }); +}); // Checks to ensure https.createServer predictably throws an error // Format ['key', 'cert', 'expected message'] @@ -96,14 +88,18 @@ const invalidKeyOptions = [ [true, false], [{ pem: keyBuff }, false], [1, false], - [[keyBuff, true], [certBuff, certBuff2], 1], [[true, keyStr2], [certStr, certStr2], 0], [[true, false], [certBuff, certBuff2], 0], [true, [certBuff, certBuff2]], ]; -for (const [key, cert, index] of - filterBoringSSLKeyCertArrayCases(invalidKeyOptions, 'invalid key')) { +// With both certificates loaded, BoringSSL rejects the RSA key against the +// last (EC) certificate before reaching the invalid second key. +if (!isBoringSSL) { + invalidKeyOptions.push([[keyBuff, true], [certBuff, certBuff2], 1]); +} + +for (const [key, cert, index] of invalidKeyOptions) { const val = index === undefined ? key : key[index]; assert.throws(() => { https.createServer({ key, cert }); @@ -131,8 +127,7 @@ const invalidCertOptions = [ [[keyStr, keyStr2], true], ]; -for (const [key, cert, index] of - filterBoringSSLKeyCertArrayCases(invalidCertOptions, 'invalid cert')) { +for (const [key, cert, index] of invalidCertOptions) { const val = index === undefined ? cert : cert[index]; assert.throws(() => { https.createServer({ key, cert }); diff --git a/test/parallel/test-tls-getprotocol.js b/test/parallel/test-tls-getprotocol.js index e3e0a1fa241..6695d7a37bb 100644 --- a/test/parallel/test-tls-getprotocol.js +++ b/test/parallel/test-tls-getprotocol.js @@ -13,7 +13,7 @@ const tls = require('tls'); const fixtures = require('../common/fixtures'); const fips3 = hasFIPS(3); -let clientConfigs = [ +const clientConfigs = [ { secureProtocol: 'TLSv1_method', version: 'TLSv1', @@ -28,24 +28,16 @@ let clientConfigs = [ }, ]; -if (isBoringSSL) { - // Remove the TLSv1 and TLSv1.1 cases. BoringSSL does not negotiate those - // legacy protocols in this configuration; keep TLSv1.2 to cover getProtocol() - // on a successful BoringSSL TLS handshake. - common.printSkipMessage('BoringSSL: skipping TLSv1/TLSv1.1 getProtocol cases'); - clientConfigs = clientConfigs.filter(({ version }) => version === 'TLSv1.2'); -} - const serverConfig = { - secureProtocol: 'TLS_method', + // BoringSSL's library default minimum is TLSv1.2, so enable legacy versions + // explicitly instead of relying on TLS_method's default minimum. + ...(isBoringSSL ? { minVersion: 'TLSv1' } : { secureProtocol: 'TLS_method' }), key: fixtures.readKey('agent2-key.pem'), cert: fixtures.readKey('agent2-cert.pem') }; -if (!isBoringSSL) { - serverConfig.ciphers = fips3 ? - 'ECDHE-RSA-AES256-GCM-SHA384' : 'RSA@SECLEVEL=0'; -} +serverConfig.ciphers = fips3 ? + 'ECDHE-RSA-AES256-GCM-SHA384' : isBoringSSL ? 'RSA' : 'RSA@SECLEVEL=0'; const expectedConnections = fips3 ? 1 : clientConfigs.length; const server = tls.createServer(serverConfig, common.mustCall(expectedConnections)); diff --git a/test/parallel/test-tls-min-max-version.js b/test/parallel/test-tls-min-max-version.js index 932ad7f0f21..3f91d946c23 100644 --- a/test/parallel/test-tls-min-max-version.js +++ b/test/parallel/test-tls-min-max-version.js @@ -11,11 +11,6 @@ const { hasFIPS, } = require('../common/crypto'); -if (isBoringSSL) { - require('../common/boringssl').testLegacyProtocolUnsupported(); - return; -} - const fixtures = require('../common/fixtures'); const { inspect } = require('util'); @@ -168,20 +163,39 @@ test(U, 'TLSv1.2', 'TLS1_2_method', U, U, U, test('TLSv1.2', U, 'TLS1_2_method', U, U, U, U, 'ERR_TLS_PROTOCOL_VERSION_CONFLICT'); -// TLS_method means "any supported protocol". +// TLS_method uses the library's default minimum protocol version. BoringSSL's +// default is TLSv1.2, even when older versions are explicitly enabled by the +// other peer. test(U, U, 'TLSv1_2_method', U, U, 'TLS_method', 'TLSv1.2'); -test(U, U, 'TLSv1_1_method', U, U, 'TLS_method', 'TLSv1.1'); -test(U, U, 'TLSv1_method', U, U, 'TLS_method', 'TLSv1'); test(U, U, 'TLS_method', U, U, 'TLSv1_2_method', 'TLSv1.2'); -test(U, U, 'TLS_method', U, U, 'TLSv1_1_method', 'TLSv1.1'); -test(U, U, 'TLS_method', U, U, 'TLSv1_method', 'TLSv1'); +for (const [method, version] of [ + ['TLSv1_1_method', 'TLSv1.1'], + ['TLSv1_method', 'TLSv1'], +]) { + const expected = isBoringSSL ? + [U, 'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION', 'ERR_SSL_UNSUPPORTED_PROTOCOL'] : + [version]; + test(U, U, method, U, U, 'TLS_method', ...expected); + test(U, U, 'TLS_method', U, U, method, ...expected); +} // OpenSSL 1.1.1 and 3.0 use a different error code and alert (sent to the // client) when no protocols are enabled on the server. -const NO_PROTOCOLS_AVAILABLE_SERVER = hasOpenSSL(3) ? - 'ERR_SSL_NO_PROTOCOLS_AVAILABLE' : 'ERR_SSL_INTERNAL_ERROR'; -const NO_PROTOCOLS_AVAILABLE_SERVER_ALERT = hasOpenSSL(3) ? - 'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION' : 'ERR_SSL_TLSV1_ALERT_INTERNAL_ERROR'; +// BoringSSL closes the connection without sending an alert in this case. +const NO_PROTOCOLS_AVAILABLE_SERVER = isBoringSSL ? + 'ERR_SSL_NO_SUPPORTED_VERSIONS_ENABLED' : hasOpenSSL(3) ? + 'ERR_SSL_NO_PROTOCOLS_AVAILABLE' : 'ERR_SSL_INTERNAL_ERROR'; +const NO_PROTOCOLS_AVAILABLE_SERVER_ALERT = isBoringSSL ? + 'ECONNRESET' : hasOpenSSL(3) ? + 'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION' : 'ERR_SSL_TLSV1_ALERT_INTERNAL_ERROR'; +const NO_PROTOCOLS_AVAILABLE_CLIENT = isBoringSSL ? + 'ERR_SSL_NO_SUPPORTED_VERSIONS_ENABLED' : 'ERR_SSL_NO_PROTOCOLS_AVAILABLE'; +const NO_PROTOCOLS_AVAILABLE_CLIENT_ALERT = isBoringSSL ? + 'ECONNRESET' : 'ERR_SSL_UNEXPECTED_MESSAGE'; +// When a client rejects the server's legacy version, BoringSSL surfaces the +// protocol-version alert while OpenSSL reports a record version mismatch. +const UNSUPPORTED_PROTOCOL_SERVER_ERROR = isBoringSSL ? + 'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION' : 'ERR_SSL_WRONG_VERSION_NUMBER'; // SSLv23 also means "any supported protocol" greater than the default // minimum (which is configurable via command line). @@ -198,9 +212,9 @@ if (DEFAULT_MIN_VERSION === 'TLSv1.3') { test(U, U, 'TLSv1_method', U, U, 'SSLv23_method', U, NO_PROTOCOLS_AVAILABLE_SERVER_ALERT, NO_PROTOCOLS_AVAILABLE_SERVER); test(U, U, 'SSLv23_method', U, U, 'TLSv1_1_method', - U, 'ERR_SSL_NO_PROTOCOLS_AVAILABLE', 'ERR_SSL_UNEXPECTED_MESSAGE'); + U, NO_PROTOCOLS_AVAILABLE_CLIENT, NO_PROTOCOLS_AVAILABLE_CLIENT_ALERT); test(U, U, 'SSLv23_method', U, U, 'TLSv1_method', - U, 'ERR_SSL_NO_PROTOCOLS_AVAILABLE', 'ERR_SSL_UNEXPECTED_MESSAGE'); + U, NO_PROTOCOLS_AVAILABLE_CLIENT, NO_PROTOCOLS_AVAILABLE_CLIENT_ALERT); } if (DEFAULT_MIN_VERSION === 'TLSv1.2') { @@ -211,9 +225,9 @@ if (DEFAULT_MIN_VERSION === 'TLSv1.2') { U, 'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION', 'ERR_SSL_UNSUPPORTED_PROTOCOL'); test(U, U, 'SSLv23_method', U, U, 'TLSv1_1_method', - U, 'ERR_SSL_UNSUPPORTED_PROTOCOL', 'ERR_SSL_WRONG_VERSION_NUMBER'); + U, 'ERR_SSL_UNSUPPORTED_PROTOCOL', UNSUPPORTED_PROTOCOL_SERVER_ERROR); test(U, U, 'SSLv23_method', U, U, 'TLSv1_method', - U, 'ERR_SSL_UNSUPPORTED_PROTOCOL', 'ERR_SSL_WRONG_VERSION_NUMBER'); + U, 'ERR_SSL_UNSUPPORTED_PROTOCOL', UNSUPPORTED_PROTOCOL_SERVER_ERROR); } if (DEFAULT_MIN_VERSION === 'TLSv1.1') { @@ -223,7 +237,7 @@ if (DEFAULT_MIN_VERSION === 'TLSv1.1') { 'ERR_SSL_UNSUPPORTED_PROTOCOL'); test(U, U, 'SSLv23_method', U, U, 'TLSv1_1_method', 'TLSv1.1'); test(U, U, 'SSLv23_method', U, U, 'TLSv1_method', - U, 'ERR_SSL_UNSUPPORTED_PROTOCOL', 'ERR_SSL_WRONG_VERSION_NUMBER'); + U, 'ERR_SSL_UNSUPPORTED_PROTOCOL', UNSUPPORTED_PROTOCOL_SERVER_ERROR); } if (DEFAULT_MIN_VERSION === 'TLSv1') { @@ -250,9 +264,9 @@ if (DEFAULT_MIN_VERSION === 'TLSv1.2') { if (DEFAULT_MAX_VERSION === 'TLSv1.2') { test(U, U, U, U, U, 'TLSv1_1_method', - U, 'ERR_SSL_UNSUPPORTED_PROTOCOL', 'ERR_SSL_WRONG_VERSION_NUMBER'); + U, 'ERR_SSL_UNSUPPORTED_PROTOCOL', UNSUPPORTED_PROTOCOL_SERVER_ERROR); test(U, U, U, U, U, 'TLSv1_method', - U, 'ERR_SSL_UNSUPPORTED_PROTOCOL', 'ERR_SSL_WRONG_VERSION_NUMBER'); + U, 'ERR_SSL_UNSUPPORTED_PROTOCOL', UNSUPPORTED_PROTOCOL_SERVER_ERROR); } else { // TLS1.3 client hellos are not understood by TLS1.1 or below. test(U, U, U, U, U, 'TLSv1_1_method', @@ -274,7 +288,7 @@ if (DEFAULT_MIN_VERSION === 'TLSv1.1') { if (DEFAULT_MAX_VERSION === 'TLSv1.2') { test(U, U, U, U, U, 'TLSv1_method', - U, 'ERR_SSL_UNSUPPORTED_PROTOCOL', 'ERR_SSL_WRONG_VERSION_NUMBER'); + U, 'ERR_SSL_UNSUPPORTED_PROTOCOL', UNSUPPORTED_PROTOCOL_SERVER_ERROR); } else { // TLS1.3 client hellos are not understood by TLS1.1 or below. test(U, U, U, U, U, 'TLSv1_method', diff --git a/test/parallel/test-tls-name-constraints-cn.js b/test/parallel/test-tls-name-constraints-cn.js index 0aae9502eeb..22b87e4e019 100644 --- a/test/parallel/test-tls-name-constraints-cn.js +++ b/test/parallel/test-tls-name-constraints-cn.js @@ -3,9 +3,6 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); const { isBoringSSL } = require('../common/crypto'); -// BoringSSL rejects DNS-like CNs without SANs under name constraints, -// even when the CN is permitted by those constraints. -if (isBoringSSL) common.skip('requires OpenSSL CN name constraints'); const assert = require('assert'); const tls = require('tls'); @@ -14,14 +11,19 @@ const fixtures = require('../common/fixtures'); const ca = fixtures.readKey('name-constraints-ca-cert.pem'); const key = fixtures.readKey('agent1-key.pem'); -// A DNS SAN prevents CN fallback; an email SAN does not. Name constraints -// must cover the CN whenever hostname verification can use it. +// A DNS SAN prevents CN fallback; an email SAN does not. OpenSSL constrains +// the CN whenever hostname verification can use it. BoringSSL instead rejects +// DNS-like CNs when the SAN extension is absent, but does not constrain the CN +// when an email SAN is present, so that case remains authorized. +const constraintError = isBoringSSL ? + /Issuer has name constraints but leaf has no SANs/ : + /permitted subtree violation/; for (const version of ['TLSv1.2', 'TLSv1.3']) { for (const [name, servername, valid] of [ - ['permitted', 'www.example.com', true], + ['permitted', 'www.example.com', !isBoringSSL], ['excluded', 'outside.invalid', false], ['dns-san', 'www.example.com', true], - ['email-san', 'outside.invalid', false], + ['email-san', 'outside.invalid', isBoringSSL], ]) { for (const rejectUnauthorized of [true, false]) { const rejected = !valid && rejectUnauthorized; @@ -46,7 +48,7 @@ for (const version of ['TLSv1.2', 'TLSv1.3']) { })); client.on('error', rejected ? common.mustCall((err) => { assert.strictEqual(err.code, 'UNSPECIFIED'); - assert.match(err.message, /permitted subtree violation/); + assert.match(err.message, constraintError); }) : common.mustNotCall()); client.on('close', common.mustCall(() => server.close())); })); diff --git a/test/parallel/test-tls-options-boolean-check.js b/test/parallel/test-tls-options-boolean-check.js index 4366502aacb..776548c838f 100644 --- a/test/parallel/test-tls-options-boolean-check.js +++ b/test/parallel/test-tls-options-boolean-check.js @@ -42,20 +42,6 @@ const keyDataView = toDataView(keyBuff); const certDataView = toDataView(certBuff); const caArrDataView = toDataView(caCert); -function filterBoringSSLKeyCertArrayCases(options, setName) { - if (!isBoringSSL) - return options; - - // The array-valued cases exercise multi-identity key/cert handling. - // BoringSSL may reject those cases with backend key/cert mismatch errors - // before the boolean/type validation this test is targeting. Keep the scalar - // cases so tls.createServer() option type validation is still covered. - common.printSkipMessage( - `BoringSSL: skipping ${setName} key/cert array cases`); - return options.filter(([key, cert]) => !Array.isArray(key) && - !Array.isArray(cert)); -} - // Checks to ensure tls.createServer doesn't throw an error // Format ['key', 'cert'] const validOptions = [ @@ -72,18 +58,24 @@ const validOptions = [ [keyDataView, certDataView], [keyDataView, false], [false, certDataView], - [[keyBuff, keyBuff2], [certBuff, certBuff2]], - [[keyStr, keyStr2], [certStr, certStr2]], [[keyStr, keyStr2], false], [false, [certStr, certStr2]], [[{ pem: keyBuff }], false], [[{ pem: keyBuff }, { pem: keyBuff }], false], ]; -filterBoringSSLKeyCertArrayCases(validOptions, 'valid') - .forEach(([key, cert]) => { - tls.createServer({ key, cert }); - }); +// Node's BoringSSL setup keeps one identity, so mixed RSA/EC key and +// certificate arrays fail with a key-type mismatch before option validation. +if (!isBoringSSL) { + validOptions.push( + [[keyBuff, keyBuff2], [certBuff, certBuff2]], + [[keyStr, keyStr2], [certStr, certStr2]], + ); +} + +validOptions.forEach(([key, cert]) => { + tls.createServer({ key, cert }); +}); // Checks to ensure tls.createServer predictably throws an error // Format ['key', 'cert', 'expected message'] @@ -95,14 +87,18 @@ const invalidKeyOptions = [ [true, false], [true, false], [{ pem: keyBuff }, false], - [[keyBuff, true], [certBuff, certBuff2], 1], [[true, keyStr2], [certStr, certStr2], 0], [[true, false], [certBuff, certBuff2], 0], [true, [certBuff, certBuff2]], ]; -for (const [key, cert, index] of - filterBoringSSLKeyCertArrayCases(invalidKeyOptions, 'invalid key')) { +// With both certificates loaded, BoringSSL rejects the RSA key against the +// last (EC) certificate before reaching the invalid second key. +if (!isBoringSSL) { + invalidKeyOptions.push([[keyBuff, true], [certBuff, certBuff2], 1]); +} + +for (const [key, cert, index] of invalidKeyOptions) { const val = index === undefined ? key : key[index]; assert.throws(() => { tls.createServer({ key, cert }); @@ -130,8 +126,7 @@ const invalidCertOptions = [ [[keyStr, keyStr2], true], ]; -for (const [key, cert, index] of - filterBoringSSLKeyCertArrayCases(invalidCertOptions, 'invalid cert')) { +for (const [key, cert, index] of invalidCertOptions) { const val = index === undefined ? cert : cert[index]; assert.throws(() => { tls.createServer({ key, cert }); diff --git a/test/parallel/test-tls-psk-alpn-callback-exception-handling.js b/test/parallel/test-tls-psk-alpn-callback-exception-handling.js index 0045517b022..50701b633e9 100644 --- a/test/parallel/test-tls-psk-alpn-callback-exception-handling.js +++ b/test/parallel/test-tls-psk-alpn-callback-exception-handling.js @@ -15,11 +15,6 @@ const { isBoringSSL } = require('../common/crypto'); if (!common.hasCrypto) common.skip('missing crypto'); -if (isBoringSSL) { - require('../common/boringssl').testPskTls13Unsupported(); - return; -} - const assert = require('assert'); const { describe, it } = require('node:test'); const https = require('node:https'); @@ -27,6 +22,8 @@ const tls = require('tls'); const fixtures = require('../common/fixtures'); const CIPHERS = 'PSK+HIGH'; +// BoringSSL's PSK callbacks support the certificate-less setup under TLS 1.2. +const pskOptions = isBoringSSL ? { maxVersion: 'TLSv1.2' } : {}; const TEST_TIMEOUT = 5000; // Helper to create a promise that rejects on uncaughtException or timeout @@ -75,6 +72,7 @@ describe('TLS callback exception handling', () => { it('pskCallback returning invalid type emits tlsClientError', async (t) => { const server = tls.createServer({ ciphers: CIPHERS, + ...pskOptions, pskCallback: () => { // Return invalid type (string instead of object/Buffer) return 'invalid-should-be-object-or-buffer'; @@ -116,7 +114,10 @@ describe('TLS callback exception handling', () => { await promise; }); - it('newSession synchronous error emits error', async (t) => { + it('newSession synchronous error emits error', { + skip: isBoringSSL && + 'BoringSSL does not trigger the TLS 1.3 newSession callback in this test', + }, async (t) => { const server = tls.createServer({ key: fixtures.readKey('agent2-key.pem'), cert: fixtures.readKey('agent2-cert.pem'), @@ -284,6 +285,7 @@ describe('TLS callback exception handling', () => { it('pskCallback throwing emits tlsClientError', async (t) => { const server = tls.createServer({ ciphers: CIPHERS, + ...pskOptions, pskCallback: () => { throw new Error('Intentional callback error'); }, @@ -411,6 +413,7 @@ describe('TLS callback exception handling', () => { const server = tls.createServer({ ciphers: CIPHERS, + ...pskOptions, pskCallback: () => PSK, pskIdentityHint: 'test-hint', }); @@ -453,6 +456,7 @@ describe('TLS callback exception handling', () => { const server = tls.createServer({ ciphers: CIPHERS, + ...pskOptions, pskCallback: () => PSK, pskIdentityHint: 'test-hint', }); diff --git a/test/parallel/test-tls-psk-circuit.js b/test/parallel/test-tls-psk-circuit.js index 9cd4a68676e..0e4bf3a09f2 100644 --- a/test/parallel/test-tls-psk-circuit.js +++ b/test/parallel/test-tls-psk-circuit.js @@ -7,11 +7,6 @@ if (!common.hasCrypto) { const { isBoringSSL, hasOpenSSL } = require('../common/crypto'); -if (isBoringSSL) { - require('../common/boringssl').testPskTls13Unsupported(); - return; -} - const assert = require('assert'); const tls = require('tls'); @@ -64,8 +59,16 @@ function test(secret, opts, error) { })); } -test({ psk: USERS.UserA, identity: 'UserA' }); test({ psk: USERS.UserA, identity: 'UserA' }, { maxVersion: 'TLSv1.2' }); + +if (isBoringSSL) { + // Keep the TLS 1.2 callback and data checks above. The remaining cases use + // TLS 1.3, which Node's BoringSSL PSK integration does not support yet. + require('../common/boringssl').testPskTls13Unsupported(); + return; +} + +test({ psk: USERS.UserA, identity: 'UserA' }); test({ psk: USERS.UserA, identity: 'UserA' }, { minVersion: 'TLSv1.3' }); test({ psk: USERS.UserB, identity: 'UserB' }); test({ psk: USERS.UserB, identity: 'UserB' }, { minVersion: 'TLSv1.3' }); diff --git a/test/parallel/test-tls-psk-server.js b/test/parallel/test-tls-psk-server.js index 29d164f019d..527c06d553a 100644 --- a/test/parallel/test-tls-psk-server.js +++ b/test/parallel/test-tls-psk-server.js @@ -5,14 +5,7 @@ if (!common.hasCrypto) { common.skip('missing crypto'); } -const { isBoringSSL } = require('../common/crypto'); - -if (isBoringSSL) { - require('../common/boringssl').testPskTls13Unsupported(); - return; -} - -const { opensslCli } = require('../common/crypto'); +const { isBoringSSL, opensslCli } = require('../common/crypto'); if (!opensslCli) { common.skip('missing openssl cli'); @@ -29,6 +22,8 @@ const IDENTITY = 'TestUser'; const server = tls.createServer({ ciphers: CIPHERS, + // BoringSSL requires TLS 1.2 for this certificate-less PSK handshake. + ...(isBoringSSL ? { maxVersion: 'TLSv1.2' } : {}), pskIdentityHint: IDENTITY, pskCallback: common.mustCall((socket, identity) => { assert.ok(socket instanceof tls.TLSSocket); diff --git a/test/sequential/test-tls-psk-client.js b/test/sequential/test-tls-psk-client.js index 5cb429f47de..37aa43a841f 100644 --- a/test/sequential/test-tls-psk-client.js +++ b/test/sequential/test-tls-psk-client.js @@ -5,14 +5,7 @@ if (!common.hasCrypto) { common.skip('missing crypto'); } -const { isBoringSSL } = require('../common/crypto'); - -if (isBoringSSL) { - require('../common/boringssl').testPskTls13Unsupported(); - return; -} - -const { opensslCli } = require('../common/crypto'); +const { isBoringSSL, opensslCli } = require('../common/crypto'); if (!opensslCli) { common.skip('missing openssl cli'); @@ -95,6 +88,8 @@ waitForPort(common.PORT, common.mustCall((err) => { function runClient(message, cb) { const s = tls.connect(common.PORT, { ciphers: CIPHERS, + // BoringSSL requires TLS 1.2 for this certificate-less PSK handshake. + ...(isBoringSSL ? { maxVersion: 'TLSv1.2' } : {}), checkServerIdentity: () => {}, pskCallback(hint) { // 'hint' will be null in TLS1.3. From fbbacb939db8d948d42ea4964a0e08a0bba1b902 Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Sat, 24 Oct 2026 23:39:02 -0700 Subject: [PATCH 110/331] sqlite: skip return() on exhausted virtual table iterators MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closing a virtual table cursor invoked the iterator's return() even after next() had already reported done: true, deviating from for...of semantics where return() only runs on abrupt termination. An empty custom iterable with a throwing return() made an otherwise successful query fail. Only close the iterator when the scan stopped early, as with LIMIT, a break, or a cursor re-filter; a normally finished iterator already ran its cleanup. Signed-off-by: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Assisted-by: claude:opus-5.5 PR-URL: https://github.com/nodejs/node/pull/66519 Fixes: https://github.com/nodejs/node/issues/66518 Reviewed-By: Guilherme Araújo --- src/node_sqlite.cc | 12 ++- test/parallel/test-sqlite-virtual-table.js | 109 +++++++++++++++++++++ 2 files changed, 119 insertions(+), 2 deletions(-) diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index 7c13ff9f2d6..5dd9165c70f 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -1120,7 +1120,7 @@ bool VirtualTableModule::CanCallIntoJS() const { bool VirtualTableModule::CloseIterator(NodeVTabCursor* cursor) { VirtualTableModule* mod = cursor->module; - // Skipped in two cases: + // Skipped in three cases: // // - While the database is being torn down from a destructor, because those // run from a garbage collection callback where JavaScript cannot be @@ -1131,7 +1131,11 @@ bool VirtualTableModule::CloseIterator(NodeVTabCursor* cursor) { // A generator whose own body threw has already run its `finally` as part of // that throw, so this only affects an iterator abandoned while suspended // because something else failed. - if (cursor->iterator.IsEmpty() || !mod->CanCallIntoJS() || + // - When next() has already reported `done: true`, because the iteration ran + // to completion. `return()` is only called on abrupt termination in + // `for...of`; a finished iterator must not be asked to clean up again, and + // a custom iterable may throw from `return()` even after completion. + if (cursor->iterator.IsEmpty() || cursor->done || !mod->CanCallIntoJS() || mod->env_->isolate()->HasPendingException()) { return false; } @@ -1445,7 +1449,10 @@ int VirtualTableModule::xNext(sqlite3_vtab_cursor* pCursor) { .ToLocal(&next_method_val)) { return mod->PropagateJSError(); } + // On a protocol error, drop the iterator so it is not closed later. + // `for...of` does not call return() when next() is invalid either. if (!next_method_val->IsFunction()) { + cursor->iterator.Reset(); return ReportProtocolError( pCursor->pVtab, "The \"options.rows\" iterator must have a next() method"); @@ -1458,6 +1465,7 @@ int VirtualTableModule::xNext(sqlite3_vtab_cursor* pCursor) { return mod->PropagateJSError(); } if (!next_val->IsObject()) { + cursor->iterator.Reset(); return ReportProtocolError( pCursor->pVtab, "The \"options.rows\" iterator's next() method must return an object"); diff --git a/test/parallel/test-sqlite-virtual-table.js b/test/parallel/test-sqlite-virtual-table.js index c10b343b12b..cc520f72344 100644 --- a/test/parallel/test-sqlite-virtual-table.js +++ b/test/parallel/test-sqlite-virtual-table.js @@ -622,6 +622,115 @@ suite('Database.prototype.createModule()', () => { assert.deepStrictEqual(cleanedUp, [1, 2]); }); + test('does not call return() on a normally exhausted iterator', () => { + // Once next() reports `done: true` the iterator is finished, so no + // cleanup should run. A throwing return() must not fail an otherwise + // successful query. Matches `for...of`, which only calls return() on + // abrupt termination. + const db = new Database(':memory:'); + let returnCalls = 0; + function cleanup() { + returnCalls++; + throw new Error('cleanup boom'); + } + for (const [label, makeRows] of [ + ['empty', () => { + return { + [Symbol.iterator]() { return this; }, + next() { return { value: [], done: true }; }, + return: cleanup, + }; + }], + ['fully_consumed', () => { + let i = 0; + return { + [Symbol.iterator]() { return this; }, + next() { return { value: [i++], done: i > 2 }; }, + return: cleanup, + }; + }], + ]) { + db.createModule(`exhausted_${label}`, { + columns: [{ name: 'v', type: 'INTEGER' }], + rows: makeRows, + }); + + const rows = db.prepare(`SELECT v FROM exhausted_${label}`).all(); + assert.deepStrictEqual( + rows.map((row) => row.v), + label === 'empty' ? [] : [0, 1]); + } + assert.strictEqual(returnCalls, 0); + }); + + test('does not call return() on an exhausted iterator when re-filtered', () => { + // A scalar subquery drains the inner iterator for each outer row, so + // xFilter re-filters a cursor whose iterator already reported done. + const db = new Database(':memory:'); + let returnCalls = 0; + + db.createModule('exhausted_refilter', { + columns: [ + { name: 'v', type: 'INTEGER' }, + { name: 'input', type: 'INTEGER', hidden: true }, + ], + rows() { + let i = 0; + return { + [Symbol.iterator]() { return this; }, + next() { return { value: [i++], done: i > 2 }; }, + return() { + returnCalls++; + throw new Error('cleanup boom'); + }, + }; + }, + }); + + db.exec('CREATE TABLE t(a); INSERT INTO t VALUES (1), (2), (3)'); + const rows = db.prepare( + 'SELECT a, (SELECT count(*) FROM exhausted_refilter(t.a)) AS c FROM t' + ).all(); + assert.deepStrictEqual(rows, [ + { __proto__: null, a: 1, c: 2 }, + { __proto__: null, a: 2, c: 2 }, + { __proto__: null, a: 3, c: 2 }, + ]); + assert.strictEqual(returnCalls, 0); + }); + + test('does not call return() after an iterator protocol error', () => { + // `for...of` does not close an iterator whose next() is invalid, so the + // protocol error is reported and return() is never called. + const db = new Database(':memory:'); + let returnCalls = 0; + for (const [label, next, message] of [ + ['next_not_function', 5, + /iterator must have a next\(\) method/], + ['next_non_object', () => 42, + /iterator's next\(\) method must return an object/], + ]) { + db.createModule(`protocol_${label}`, { + columns: [{ name: 'v', type: 'INTEGER' }], + rows() { + return { + [Symbol.iterator]() { return this; }, + next, + return() { + returnCalls++; + throw new Error('cleanup boom'); + }, + }; + }, + }); + + assert.throws( + () => db.prepare(`SELECT v FROM protocol_${label}`).all(), + { code: 'ERR_SQLITE_ERROR', message }); + } + assert.strictEqual(returnCalls, 0); + }); + test('does not run cleanup when the statement is collected', () => { // The destructor runs from a GC callback, where JavaScript cannot be // executed. An abandoned generator does not run `finally` in JavaScript From bae10aa8225ea5a837aebceaf16b7dc517f2a9f6 Mon Sep 17 00:00:00 2001 From: Trevor Burnham Date: Sun, 25 Oct 2026 03:24:48 -0400 Subject: [PATCH 111/331] diagnostics_channel: fix dangling binding pointer MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `Channel` reads its subscriber count through a raw `BindingData*` that was never cleared, so any native holder that outlives environment cleanup reads a destroyed object. The null check in `HasSubscribers()` could not fire, because the pointer was only ever assigned in the constructor. `node:sqlite` holds a strong `BaseObjectPtr` for the lifetime of a `Database`, which made this reachable from ordinary JavaScript. A statement left mid-step at exit is finalized by the destructor chain after `Environment::RunCleanup()` has destroyed the binding, and `sqlite3_finalize()` invokes the profile callback for such a statement. The result was a segfault at normal process exit; inside a worker it took down the whole process. Clear `binding_data_` on every `Channel` the binding owns whenever it gives up that ownership, both in the destructor and in `PrepareForSerialization()`, so that the existing null check in `HasSubscribers()` does its job. The second check in `Publish()` is now unreachable and is dropped. This protects any holder that is itself a `BaseObject`, and so is destroyed later in the same cleanup. A holder that is not a `BaseObject` still needs a cleanup hook or a weak reference, because `Realm::~Realm()` checks that no `BaseObject`s remain. On the `node:sqlite` side, switch `Database::trace_channel_` to a `BaseObjectWeakPtr`, so that it follows the same convention `permission` documents, where `BindingData` is the sole owner of channels. `TraceCallback` already null-checks, so this needs no other change there. Also check `AreTraceEventsSuppressed()` before the channel in `TraceCallback()`, so that a suppressed callback does not dereference it at all. `Statement::Finalize()` already suppresses trace events, so the reported path was meant to be a no-op; only the order of the `||` operands took it through the channel first. Fixes: https://github.com/nodejs/node/issues/65858 Assisted-by: Claude Opus 5 Signed-off-by: Trevor Burnham PR-URL: https://github.com/nodejs/node/pull/65860 Reviewed-By: Bryan English Reviewed-By: Gerhard Stöbich --- src/node_diagnostics_channel.cc | 18 ++++- src/node_diagnostics_channel.h | 5 ++ src/node_sqlite.cc | 7 +- src/node_sqlite.h | 4 +- test/cctest/test_diagnostics_channel.cc | 73 +++++++++++++++++++ .../test-sqlite-diagnostic-channel-exit.js | 51 +++++++++++++ 6 files changed, 153 insertions(+), 5 deletions(-) create mode 100644 test/parallel/test-sqlite-diagnostic-channel-exit.js diff --git a/src/node_diagnostics_channel.cc b/src/node_diagnostics_channel.cc index 2593f6eab90..2cc3309542f 100644 --- a/src/node_diagnostics_channel.cc +++ b/src/node_diagnostics_channel.cc @@ -44,6 +44,21 @@ BindingData::BindingData(Realm* realm, subscribers_.MakeWeak(); } +void BindingData::DetachChannels() { + // A native holder may keep a strong reference to a Channel that outlives this + // binding's ownership of it, and the binding is destroyed during environment + // cleanup while BaseObject destructors still run after it. Drop the + // back-pointer so that the null check in HasSubscribers() stops those holders + // from reading the subscribers_ array of a binding that no longer owns them. + for (auto& channel : channels_) { + if (channel) channel->binding_data_ = nullptr; + } +} + +BindingData::~BindingData() { + DetachChannels(); +} + void BindingData::MemoryInfo(MemoryTracker* tracker) const { tracker->TrackField("subscribers", subscribers_); } @@ -104,6 +119,7 @@ bool BindingData::PrepareForSerialization(Local context, internal_field_info_->subscribers_capacity = subscribers_.Length(); link_callback_.Reset(); channel_wrap_template_.Reset(); + DetachChannels(); channels_.clear(); return true; } @@ -281,8 +297,6 @@ void Channel::CachePublishFn(Isolate* isolate, Local js_channel) { void Channel::Publish(Environment* env, Local message) { if (!HasSubscribers()) return; - if (binding_data_ == nullptr) return; - if (js_channel_.IsEmpty()) return; // Publishing is not possible during shutdown or GC. diff --git a/src/node_diagnostics_channel.h b/src/node_diagnostics_channel.h index c8c1a79994b..b1da5fcee3d 100644 --- a/src/node_diagnostics_channel.h +++ b/src/node_diagnostics_channel.h @@ -31,6 +31,7 @@ class BindingData : public SnapshotableObject { BindingData(Realm* realm, v8::Local wrap, InternalFieldInfo* info = nullptr); + ~BindingData() override; SERIALIZABLE_OBJECT_METHODS() SET_BINDING_ID(diagnostics_channel_binding_data) @@ -70,6 +71,10 @@ class BindingData : public SnapshotableObject { static void RegisterExternalReferences(ExternalReferenceRegistry* registry); private: + // Clears the back-pointer of every Channel in channels_, so that a Channel + // this binding no longer owns cannot read through it. + void DetachChannels(); + InternalFieldInfo* internal_field_info_ = nullptr; std::unordered_map channel_status_callbacks_; }; diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index 5dd9165c70f..162b4e50010 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -3424,8 +3424,11 @@ int Database::TraceCallback(unsigned int type, Environment* env = db->env(); diagnostics_channel::Channel* ch = db->trace_channel_.get(); - if (ch == nullptr || !ch->HasSubscribers() || - db->AreTraceEventsSuppressed()) { + // Checked before the channel, so that a suppressed callback does not + // dereference it at all. Statement finalization suppresses trace events, and + // that is the path SQLite takes during environment teardown. + if (db->AreTraceEventsSuppressed() || ch == nullptr || + !ch->HasSubscribers()) { return 0; } diff --git a/src/node_sqlite.h b/src/node_sqlite.h index 6a51dbffaf3..60d70e90139 100644 --- a/src/node_sqlite.h +++ b/src/node_sqlite.h @@ -354,7 +354,9 @@ class Database : public BaseObject { std::set backups_; std::unordered_set sessions_; std::unordered_set statements_; - BaseObjectPtr trace_channel_; + // Weak ref: BindingData is the sole owner of Channels, so a strong ref here + // would outlive the binding that backs it during environment cleanup. + BaseObjectWeakPtr trace_channel_; friend class UserDefinedFunction; friend class CustomAggregate; diff --git a/test/cctest/test_diagnostics_channel.cc b/test/cctest/test_diagnostics_channel.cc index d4d1fd1c9fa..6932a27640e 100644 --- a/test/cctest/test_diagnostics_channel.cc +++ b/test/cctest/test_diagnostics_channel.cc @@ -1,5 +1,6 @@ #include "node_diagnostics_channel.h" +#include "base_object-inl.h" #include "gtest/gtest.h" #include "node_test_fixture.h" @@ -302,3 +303,75 @@ TEST_F(DiagnosticsChannelTest, NativeChannelsGrowSubscriberStorage) { " globalThis.__lastSubscriber);"); EXPECT_TRUE(last->HasSubscribers()); } + +// Mirrors how node:sqlite holds a Channel: a strong reference kept for the +// lifetime of a BaseObject, which is destroyed during environment cleanup +// after the BindingData that owns the channel is already gone. +class ChannelHolder : public node::BaseObject { + public: + ChannelHolder(node::Environment* env, + v8::Local obj, + BaseObjectPtr channel) + : BaseObject(env, obj), channel_(std::move(channel)) {} + + ~ChannelHolder() override { + destroyed = true; + // Would read the destroyed BindingData if the back-pointer were stale. + had_subscribers = channel_->HasSubscribers(); + } + + static bool destroyed; + static bool had_subscribers; + + SET_NO_MEMORY_INFO() + SET_MEMORY_INFO_NAME(ChannelHolder) + SET_SELF_SIZE(ChannelHolder) + + private: + BaseObjectPtr channel_; +}; + +bool ChannelHolder::destroyed = false; +bool ChannelHolder::had_subscribers = false; + +// A Channel whose holder outlives the BindingData must report no subscribers +// rather than reading the destroyed binding's subscriber array. +TEST_F(DiagnosticsChannelTest, ChannelOutlivingBindingHasNoSubscribers) { + const v8::HandleScope handle_scope(isolate_); + Argv argv; + + ChannelHolder::destroyed = false; + ChannelHolder::had_subscribers = false; + + { + Env env{handle_scope, argv}; + + SetProcessExitHandler(*env, [&](node::Environment* env_, int exit_code) { + EXPECT_EQ(exit_code, 0); + node::Stop(*env); + }); + + node::LoadEnvironment( + *env, + "const dc = require('diagnostics_channel');" + "dc.subscribe('test:cctest:outlives-binding', () => {});"); + + auto channel = Channel::Get(*env, "test:cctest:outlives-binding"); + ASSERT_TRUE(channel); + ASSERT_TRUE(channel->HasSubscribers()); + + v8::Local context = (*env)->context(); + v8::Local obj = + node::BaseObject::MakeLazilyInitializedJSTemplate(*env) + ->GetFunction(context) + .ToLocalChecked() + ->NewInstance(context) + .ToLocalChecked(); + // MakeBaseObject leaves the holder a strong root, so it survives until the + // environment is torn down, like a DatabaseSync still reachable at exit. + node::MakeBaseObject(*env, obj, channel); + } + + EXPECT_TRUE(ChannelHolder::destroyed); + EXPECT_FALSE(ChannelHolder::had_subscribers); +} diff --git a/test/parallel/test-sqlite-diagnostic-channel-exit.js b/test/parallel/test-sqlite-diagnostic-channel-exit.js new file mode 100644 index 00000000000..9f754522e96 --- /dev/null +++ b/test/parallel/test-sqlite-diagnostic-channel-exit.js @@ -0,0 +1,51 @@ +'use strict'; + +// A statement left unfinished at exit is finalized by the destructor chain, +// which runs after the diagnostics channel binding has been destroyed. SQLite +// invokes the profile callback for such a statement, so the channel must not +// read through the destroyed binding. + +const common = require('../common'); +common.skipIfSQLiteMissing(); + +const { spawnSyncAndExitWithoutError } = require('../common/child_process'); + +// Stays reachable for the rest of the process so the statement is finalized +// during teardown rather than by the garbage collector. +const keepAlive = []; + +function leaveStatementUnfinished() { + const dc = require('node:diagnostics_channel'); + const { Database } = require('node:sqlite'); + + dc.subscribe('sqlite.db.query', () => {}); + + const db = new Database(':memory:'); + db.exec('CREATE TABLE t (x INTEGER)'); + const insert = db.prepare('INSERT INTO t VALUES (?)'); + for (let i = 0; i < 200; i++) insert.run(i); + + const iterator = db.prepare('SELECT x FROM t').iterate(); + iterator.next(); + keepAlive.push({ db, iterator }); +} + +switch (process.argv[2]) { + case 'main': + leaveStatementUnfinished(); + break; + + case 'worker': { + const { Worker, isMainThread } = require('node:worker_threads'); + if (isMainThread) { + new Worker(__filename, { argv: ['worker'] }); + } else { + leaveStatementUnfinished(); + } + break; + } + + default: + spawnSyncAndExitWithoutError(process.execPath, [__filename, 'main']); + spawnSyncAndExitWithoutError(process.execPath, [__filename, 'worker']); +} From c08a79da41b7da73eae1f41d6a70be84ae3e45ee Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Sun, 25 Oct 2026 07:56:04 -0400 Subject: [PATCH 112/331] deps: update googletest to cd8e73f067129f8489e35c7b51c7a68552b289d2 PR-URL: https://github.com/nodejs/node/pull/66814 Reviewed-By: Colin Ihrig Reviewed-By: Luigi Pinca Reviewed-By: Filip Skokan --- .../include/gtest/gtest-typed-test.h | 41 ++++++----- .../include/gtest/internal/gtest-internal.h | 72 ++++++++++++++----- deps/googletest/src/gtest-typed-test.cc | 11 ++- deps/googletest/src/gtest.cc | 15 ++-- 4 files changed, 93 insertions(+), 46 deletions(-) diff --git a/deps/googletest/include/gtest/gtest-typed-test.h b/deps/googletest/include/gtest/gtest-typed-test.h index 8575a41076e..19b49228981 100644 --- a/deps/googletest/include/gtest/gtest-typed-test.h +++ b/deps/googletest/include/gtest/gtest-typed-test.h @@ -256,8 +256,11 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes); // The variables defined in the type-parameterized test macros are // static as typically these macros are used in a .h file that can be // #included in multiple translation units linked together. -#define TYPED_TEST_SUITE_P(SuiteName) \ - static ::testing::internal::TypedTestSuitePState \ +// Marked [[maybe_unused]] because TypedTestSuitePState is +// constexpr-constructible and trivially destructible, so an uninstantiated +// suite would otherwise trigger -Wunused-variable. +#define TYPED_TEST_SUITE_P(SuiteName) \ + [[maybe_unused]] static ::testing::internal::TypedTestSuitePState \ GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName) // Legacy API is deprecated but still available @@ -267,22 +270,24 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes); TYPED_TEST_SUITE_P #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -#define TYPED_TEST_P(SuiteName, TestName) \ - namespace GTEST_SUITE_NAMESPACE_(SuiteName) { \ - template \ - class TestName : public SuiteName { \ - private: \ - typedef SuiteName TestFixture; \ - typedef gtest_TypeParam_ TypeParam; \ - void TestBody() override; \ - }; \ - [[maybe_unused]] static bool gtest_##TestName##_defined_ = \ - GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName( \ - __FILE__, __LINE__, GTEST_STRINGIFY_(SuiteName), \ - GTEST_STRINGIFY_(TestName)); \ - } \ - template \ - void GTEST_SUITE_NAMESPACE_( \ +#define TYPED_TEST_P(SuiteName, TestName) \ + namespace GTEST_SUITE_NAMESPACE_(SuiteName) { \ + template \ + class TestName : public SuiteName { \ + private: \ + typedef SuiteName TestFixture; \ + typedef gtest_TypeParam_ TypeParam; \ + void TestBody() override; \ + }; \ + static ::testing::internal::TypedTestSuitePState::RegisteredTest \ + gtest_##TestName##_registered_test_ = {GTEST_STRINGIFY_(TestName), \ + __FILE__, __LINE__, nullptr}; \ + [[maybe_unused]] static bool gtest_##TestName##_defined_ = \ + GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTest( \ + >est_##TestName##_registered_test_, GTEST_STRINGIFY_(SuiteName)); \ + } \ + template \ + void GTEST_SUITE_NAMESPACE_( \ SuiteName)::TestName::TestBody() // Note: this won't work correctly if the trailing arguments are macros. diff --git a/deps/googletest/include/gtest/internal/gtest-internal.h b/deps/googletest/include/gtest/internal/gtest-internal.h index f845ffed298..5a83b4edd60 100644 --- a/deps/googletest/include/gtest/internal/gtest-internal.h +++ b/deps/googletest/include/gtest/internal/gtest-internal.h @@ -577,51 +577,87 @@ GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ /* class A needs to have dll-interface to be used by clients of class B */) // State of the definition of a type-parameterized test suite. +// Uses an intrusive linked list of caller-allocated POD RegisteredTest nodes +// rather than an STL container. +// REQUIRES: TypedTestSuitePState must be constexpr-constructible and trivially +// destructible so that namespace-scope static instances defined by +// TYPED_TEST_SUITE_P avoid -Wglobal-constructors and -Wexit-time-destructors. class GTEST_API_ [[nodiscard]] TypedTestSuitePState { public: - TypedTestSuitePState() : registered_(false) {} - - // Adds the given test name to defined_test_names_ and return true - // if the test suite hasn't been registered; otherwise aborts the - // program. - bool AddTestName(const char* file, int line, const char* case_name, - const char* test_name) { + // Caller-owned POD node linked into registered_tests_; must outlive this + // TypedTestSuitePState instance. + struct RegisteredTest { + const char* name; + const char* file; + int line; + RegisteredTest* next; + }; + + constexpr TypedTestSuitePState() = default; + + // Adds the given test to registered_tests_ and returns true if the test + // suite hasn't been registered; otherwise aborts the program. + bool AddTest(RegisteredTest* test, const char* case_name) { if (registered_) { fprintf(stderr, "%s Test %s must be defined before " "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n", - FormatFileLocation(file, line).c_str(), test_name, case_name); + FormatFileLocation(test->file, test->line).c_str(), test->name, + case_name); fflush(stderr); posix::Abort(); } - registered_tests_.emplace(test_name, CodeLocation(file, line)); + // Insert into registered_tests_ in lexicographical order by test name + // (ignoring duplicates) so VerifyRegisteredTestNames reports missing tests + // in deterministic sorted order. + RegisteredTest** p = ®istered_tests_; + while (*p != nullptr && strcmp((*p)->name, test->name) < 0) { + p = &(*p)->next; + } + if (*p == nullptr || strcmp((*p)->name, test->name) != 0) { + test->next = *p; + *p = test; + } return true; } bool TestExists(const std::string& test_name) const { - return registered_tests_.count(test_name) > 0; + return FindTest(test_name) != nullptr; } - const CodeLocation& GetCodeLocation(const std::string& test_name) const { - RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name); - GTEST_CHECK_(it != registered_tests_.end()); - return it->second; + CodeLocation GetCodeLocation(const std::string& test_name) const { + const RegisteredTest* test = FindTest(test_name); + GTEST_CHECK_(test != nullptr); + return CodeLocation(test->file, test->line); } // Verifies that registered_tests match the test names in - // defined_test_names_; returns registered_tests if successful, or + // registered_tests_; returns registered_tests if successful, or // aborts the program otherwise. const char* VerifyRegisteredTestNames(const char* test_suite_name, const char* file, int line, const char* registered_tests); private: - typedef ::std::map> RegisteredTestsMap; + const RegisteredTest* FindTest(const std::string& test_name) const { + for (const RegisteredTest* it = registered_tests_; it != nullptr; + it = it->next) { + if (test_name == it->name) { + return it; + } + } + return nullptr; + } - bool registered_; - RegisteredTestsMap registered_tests_; + bool registered_ = false; + RegisteredTest* registered_tests_ = nullptr; }; +static_assert((static_cast(TypedTestSuitePState{}), true), + "TypedTestSuitePState must be constexpr-constructible"); +static_assert(std::is_trivially_destructible_v, + "TypedTestSuitePState must be trivially destructible"); + // Legacy API is deprecated but still available #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ using TypedTestCasePState = TypedTestSuitePState; diff --git a/deps/googletest/src/gtest-typed-test.cc b/deps/googletest/src/gtest-typed-test.cc index b251c09deb8..e2cfaa019a9 100644 --- a/deps/googletest/src/gtest-typed-test.cc +++ b/deps/googletest/src/gtest-typed-test.cc @@ -62,7 +62,6 @@ const char* TypedTestSuitePState::VerifyRegisteredTestNames( const char* registered_tests) { RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line)); - typedef RegisteredTestsMap::const_iterator RegisteredTestIter; registered_ = true; std::vector name_vec = SplitIntoTestNames(registered_tests); @@ -78,7 +77,7 @@ const char* TypedTestSuitePState::VerifyRegisteredTestNames( continue; } - if (registered_tests_.count(name) != 0) { + if (TestExists(name)) { tests.insert(name); } else { errors << "No test named " << name @@ -86,10 +85,10 @@ const char* TypedTestSuitePState::VerifyRegisteredTestNames( } } - for (RegisteredTestIter it = registered_tests_.begin(); - it != registered_tests_.end(); ++it) { - if (tests.count(it->first) == 0) { - errors << "You forgot to list test " << it->first << ".\n"; + for (const RegisteredTest* it = registered_tests_; it != nullptr; + it = it->next) { + if (tests.count(it->name) == 0) { + errors << "You forgot to list test " << it->name << ".\n"; } } diff --git a/deps/googletest/src/gtest.cc b/deps/googletest/src/gtest.cc index 3772f18552d..d66756e88f5 100644 --- a/deps/googletest/src/gtest.cc +++ b/deps/googletest/src/gtest.cc @@ -6857,6 +6857,16 @@ static void LoadFlagsFromFile(const std::string& path) { if (!ParseGoogleTestFlag(lines[i].c_str())) g_help_flag = true; } } + +static bool ParseFlagFileFlag(const char* const arg) { + std::string flagfile_value; + if (!ParseFlag(arg, "flagfile", &flagfile_value)) { + return false; + } + GTEST_FLAG_SET(flagfile, flagfile_value); + LoadFlagsFromFile(flagfile_value); + return true; +} #endif // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM // Parses the command line for Google Test flags, without initializing @@ -6864,7 +6874,6 @@ static void LoadFlagsFromFile(const std::string& path) { // instantiated to either char or wchar_t. template void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { - std::string flagfile_value; for (int i = 1; i < *argc; i++) { const std::string arg_string = StreamableToString(argv[i]); const char* const arg = arg_string.c_str(); @@ -6875,9 +6884,7 @@ void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { if (ParseGoogleTestFlag(arg)) { remove_flag = true; #if GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM - } else if (ParseFlag(arg, "flagfile", &flagfile_value)) { - GTEST_FLAG_SET(flagfile, flagfile_value); - LoadFlagsFromFile(flagfile_value); + } else if (ParseFlagFileFlag(arg)) { remove_flag = true; #endif // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM } else if (arg_string == "--help" || HasGoogleTestFlagPrefix(arg)) { From ac1666a023ce46faf4ccf70f1f7de022eafdddc9 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Sun, 25 Oct 2026 16:54:41 +0100 Subject: [PATCH 113/331] test: adapt `test-blocklist` to libuv 1.53+ Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/67002 Reviewed-By: Filip Skokan Reviewed-By: Colin Ihrig --- test/parallel/test-blocklist.js | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/parallel/test-blocklist.js b/test/parallel/test-blocklist.js index b0fe4303bfb..fc00516bba7 100644 --- a/test/parallel/test-blocklist.js +++ b/test/parallel/test-blocklist.js @@ -888,7 +888,9 @@ const util = require('util'); const mixed = 'ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255'; blockList.addAddress(mixed, 'ipv6'); assert.strictEqual(blockList.check(mixed, 'ipv6'), true); - assert.strictEqual(blockList.check(`${mixed}%${'z'.repeat(200)}`, 'ipv6'), false); + assert.strictEqual(blockList.check(`${mixed}%${'z'.repeat(200)}`, 'ipv6'), + // This returns true as of libuv 1.53.0 (there are no 0.53.0 version) + (([major, minor]) => major > 1 || minor > 52)(process.versions.uv.split('.'))); } // check() family parameter is case-insensitive. From 4c5cc142c5440b674afa1541c09081931f5ba4ac Mon Sep 17 00:00:00 2001 From: Christian Aurich Zanettini Martins Date: Sun, 25 Oct 2026 14:19:12 -0300 Subject: [PATCH 114/331] vfs: fix readlink, realpath and mkdtemp encoding On a mounted VFS, `readlink()`, `realpath()` and `mkdtemp()` only returned a Buffer for `{ encoding: 'buffer' }`. The string form `'buffer'`, any other encoding, and a Buffer `mkdtemp()` prefix were ignored. The `VirtualFileSystem` `readlink` and `realpath` methods ignored the encoding with `MemoryProvider` and passed it on to `RealFSProvider`, which threw `ERR_INVALID_ARG_TYPE` for `'buffer'`, while for other encodings `realpath()` failed and `readlink()` returned the host path of absolute targets. Get these paths from the provider as strings and apply the encoding to the result, normalizing the options with `getOptions()` and converting with `encodeRealpathResult()` as `fs` does. The latter moves to `internal/fs/utils` so the VFS can use it. Signed-off-by: Christian Aurich Zanettini Martins PR-URL: https://github.com/nodejs/node/pull/66352 Reviewed-By: Matteo Collina --- lib/fs.js | 11 +-- lib/internal/fs/utils.js | 11 +++ lib/internal/vfs/file_system.js | 37 +++++---- lib/internal/vfs/setup.js | 55 ++++++------- test/parallel/test-vfs-path-encoding.js | 104 ++++++++++++++++++++++++ 5 files changed, 164 insertions(+), 54 deletions(-) create mode 100644 test/parallel/test-vfs-path-encoding.js diff --git a/lib/fs.js b/lib/fs.js index b1cebe6945f..0718c7775ba 100644 --- a/lib/fs.js +++ b/lib/fs.js @@ -103,6 +103,7 @@ const { collectRecursiveReaddirResult, copyObject, Dirent, + encodeRealpathResult, getDirents, getRecursiveDirents, getOptions, @@ -3320,16 +3321,6 @@ if (isWindows) { } -function encodeRealpathResult(result, options) { - if (!options || !options.encoding || options.encoding === 'utf8') - return result; - const asBuffer = Buffer.from(result); - if (options.encoding === 'buffer') { - return asBuffer; - } - return asBuffer.toString(options.encoding); -} - // Finds the next portion of a (partial) path, up to the next path delimiter let nextPart; if (isWindows) { diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js index 29f254d9250..2d7c9139970 100644 --- a/lib/internal/fs/utils.js +++ b/lib/internal/fs/utils.js @@ -427,6 +427,16 @@ function getOptions(options, defaultOptions = kEmptyObject) { return options; } +function encodeRealpathResult(result, options) { + if (!options || !options.encoding || options.encoding === 'utf8') + return result; + const asBuffer = Buffer.from(result); + if (options.encoding === 'buffer') { + return asBuffer; + } + return asBuffer.toString(options.encoding); +} + /** * @param {InternalFSBinding.FSSyncContext} ctx */ @@ -1209,6 +1219,7 @@ module.exports = { copyObject, Dirent, DirentFromStats, + encodeRealpathResult, getDirent, getDirents, getOptions, diff --git a/lib/internal/vfs/file_system.js b/lib/internal/vfs/file_system.js index 370eaa7ea41..220951b100f 100644 --- a/lib/internal/vfs/file_system.js +++ b/lib/internal/vfs/file_system.js @@ -36,6 +36,7 @@ const { createEBUSY, createEISDIR, } = require('internal/vfs/errors'); +const { encodeRealpathResult, getOptions } = require('internal/fs/utils'); const { VirtualReadStream, VirtualWriteStream } = require('internal/vfs/streams'); const { VirtualDir } = require('internal/vfs/dir'); const { emitExperimentalWarning, kEmptyObject } = require('internal/util'); @@ -458,24 +459,26 @@ class VirtualFileSystem { /** * Gets the real path by resolving all symlinks. * @param {string} filePath The path - * @param {object} [options] Options - * @returns {string} + * @param {object|string} [options] Options or encoding + * @returns {string|Buffer} */ realpathSync(filePath, options) { + options = getOptions(options); const providerPath = this.#toProviderPath(filePath); - const realProviderPath = this[kProvider].realpathSync(providerPath, options); - return this.#toMountedPath(realProviderPath); + const realProviderPath = this[kProvider].realpathSync(providerPath); + return encodeRealpathResult(this.#toMountedPath(realProviderPath), options); } /** * Reads the target of a symbolic link. * @param {string} linkPath The symlink path - * @param {object} [options] Options - * @returns {string} + * @param {object|string} [options] Options or encoding + * @returns {string|Buffer} */ readlinkSync(linkPath, options) { + options = getOptions(options); const providerPath = this.#toProviderPath(linkPath); - return this[kProvider].readlinkSync(providerPath, options); + return encodeRealpathResult(this[kProvider].readlinkSync(providerPath), options); } /** @@ -826,7 +829,7 @@ class VirtualFileSystem { /** * Gets the real path asynchronously. * @param {string} filePath The path - * @param {object|Function} [options] Options or callback + * @param {object|string|Function} [options] Options, encoding, or callback * @param {Function} [callback] Callback (err, resolvedPath) */ realpath(filePath, options, callback) { @@ -834,16 +837,17 @@ class VirtualFileSystem { callback = options; options = undefined; } + options = getOptions(options); - this[kProvider].realpath(this.#toProviderPath(filePath), options) - .then((realPath) => callback(null, this.#toMountedPath(realPath)), + this[kProvider].realpath(this.#toProviderPath(filePath)) + .then((realPath) => callback(null, encodeRealpathResult(this.#toMountedPath(realPath), options)), (err) => callback(err)); } /** * Reads symlink target asynchronously. * @param {string} linkPath The symlink path - * @param {object|Function} [options] Options or callback + * @param {object|string|Function} [options] Options, encoding, or callback * @param {Function} [callback] Callback (err, target) */ readlink(linkPath, options, callback) { @@ -851,9 +855,10 @@ class VirtualFileSystem { callback = options; options = undefined; } + options = getOptions(options); - this[kProvider].readlink(this.#toProviderPath(linkPath), options) - .then((target) => callback(null, target), (err) => callback(err)); + this[kProvider].readlink(this.#toProviderPath(linkPath)) + .then((target) => callback(null, encodeRealpathResult(target, options)), (err) => callback(err)); } /** @@ -1266,13 +1271,15 @@ class VirtualFileSystem { }, async realpath(filePath, options) { + options = getOptions(options); const providerPath = toProviderPath(filePath); - return toMountedPath(await provider.realpath(providerPath, options)); + return encodeRealpathResult(toMountedPath(await provider.realpath(providerPath)), options); }, async readlink(linkPath, options) { + options = getOptions(options); const providerPath = toProviderPath(linkPath); - return provider.readlink(providerPath, options); + return encodeRealpathResult(await provider.readlink(providerPath), options); }, async symlink(target, path, type) { diff --git a/lib/internal/vfs/setup.js b/lib/internal/vfs/setup.js index 6ad0824f85e..0827100c2d8 100644 --- a/lib/internal/vfs/setup.js +++ b/lib/internal/vfs/setup.js @@ -37,7 +37,12 @@ const { } = require('internal/vfs/router'); const { ReservedRootProvider } = require('internal/vfs/root'); const { getVirtualFd, closeVirtualFd, createVfsFileHandle } = require('internal/vfs/fd'); -const { assertEncoding, setVfsHandlers } = require('internal/fs/utils'); +const { + assertEncoding, + encodeRealpathResult, + getOptions, + setVfsHandlers, +} = require('internal/fs/utils'); const permission = require('internal/process/permission'); const { getOptionValue } = require('internal/options'); const nativeModulesBinding = internalBinding('modules'); @@ -73,6 +78,14 @@ function toWriteBuffer(data, options) { return Buffer.from(data, encoding || 'utf8'); } +function getMkdtempOptions(prefix, options) { + options = getOptions(options); + if (Buffer.isBuffer(prefix)) { + options = { __proto__: null, ...options, encoding: 'buffer' }; + } + return options; +} + function writeFileSyncFd(fd, data, options) { const vfd = getVirtualFd(fd); if (vfd === undefined) return undefined; @@ -433,11 +446,7 @@ function createVfsHandlers() { return vfsRead(path, 'stat', (vfs, n) => vfs.statSync(n, options)); }, realpathSync(path, options) { - const result = vfsRead(path, 'realpath', (vfs, n) => vfs.realpathSync(n)); - if (result !== undefined && options?.encoding === 'buffer') { - return Buffer.from(result); - } - return result; + return vfsRead(path, 'realpath', (vfs, n) => vfs.realpathSync(n, options)); }, accessSync(path, mode) { const pathStr = toPathStr(path); @@ -458,9 +467,7 @@ function createVfsHandlers() { if (pathStr === null) return undefined; const r = findVFS(pathStr); if (r === null) return undefined; - const result = r.vfs.readlinkSync(pathStr, options); - if (options?.encoding === 'buffer') return Buffer.from(result); - return result; + return r.vfs.readlinkSync(pathStr, options); }, statfsSync(path, options) { const pathStr = toPathStr(path); @@ -526,11 +533,10 @@ function createVfsHandlers() { }); }, mkdtempSync(prefix, options) { - const result = vfsOp(prefix, (vfs, n) => vfs.mkdtempSync(n)); - if (result !== undefined && options?.encoding === 'buffer') { - return Buffer.from(result); - } - return result; + return vfsOp(prefix, (vfs, n) => { + options = getMkdtempOptions(prefix, options); + return encodeRealpathResult(vfs.mkdtempSync(n), options); + }); }, mkstempSync(prefix, options) { const result = vfsOp(prefix, (vfs, n) => vfs.mkstempSync(n)); @@ -768,11 +774,7 @@ function createVfsHandlers() { return vfsOp(path, (vfs, n) => vfs.promises.readFile(n, options)); }, realpath(path, options) { - const promise = vfsOp(path, (vfs, n) => vfs.promises.realpath(n, options)); - if (promise !== undefined && options?.encoding === 'buffer') { - return promise.then((result) => Buffer.from(result)); - } - return promise; + return vfsOp(path, (vfs, n) => vfs.promises.realpath(n, options)); }, access(path, mode) { return vfsOp(path, (vfs, n) => { @@ -787,11 +789,7 @@ function createVfsHandlers() { if (pathStr === null) return undefined; const r = findVFS(pathStr); if (r === null) return undefined; - const promise = r.vfs.promises.readlink(pathStr, options); - if (options?.encoding === 'buffer') { - return promise.then((result) => Buffer.from(result)); - } - return promise; + return r.vfs.promises.readlink(pathStr, options); }, chown: (path, uid, gid) => vfsOp(path, (vfs, n) => vfs.promises.chown(n, uid, gid).then(() => true)), @@ -863,11 +861,10 @@ function createVfsHandlers() { }); }, mkdtemp(prefix, options) { - const promise = vfsOp(prefix, (vfs, n) => vfs.promises.mkdtemp(n)); - if (promise !== undefined && options?.encoding === 'buffer') { - return promise.then((result) => Buffer.from(result)); - } - return promise; + return vfsOp(prefix, (vfs, n) => { + options = getMkdtempOptions(prefix, options); + return vfs.promises.mkdtemp(n).then((result) => encodeRealpathResult(result, options)); + }); }, // Wrapped in async functions so provider throws become rejections. mkstemp(prefix, options) { diff --git a/test/parallel/test-vfs-path-encoding.js b/test/parallel/test-vfs-path-encoding.js new file mode 100644 index 00000000000..2f1293d78c2 --- /dev/null +++ b/test/parallel/test-vfs-path-encoding.js @@ -0,0 +1,104 @@ +// Flags: --experimental-vfs --disable-warning=ExperimentalWarning +'use strict'; + +// readlink(), realpath() and mkdtemp() on a mounted VFS apply the encoding +// option the way fs does: given as a string or in an object, 'buffer' or any +// other encoding, and a Buffer mkdtemp() prefix always gives a Buffer. The +// VirtualFileSystem readlink and realpath methods do the same. + +const common = require('../common'); +const assert = require('assert'); +const fs = require('fs'); +const path = require('path'); +const { promisify } = require('util'); +const vfs = require('node:vfs'); +const tmpdir = require('../common/tmpdir'); + +function decode(value, encoding) { + if (encoding === 'buffer') { + assert.ok(Buffer.isBuffer(value)); + return value.toString(); + } + assert.strictEqual(typeof value, 'string'); + return Buffer.from(value, encoding).toString(); +} + +const memoryVfs = vfs.create(); +memoryVfs.writeFileSync('/file.txt', 'x'); +memoryVfs.symlinkSync('file.txt', '/link'); +memoryVfs.symlinkSync('/file.txt', '/abs-link'); +const vfsInstances = [memoryVfs]; + +if (common.canCreateSymLink()) { + tmpdir.refresh(); + fs.writeFileSync(tmpdir.resolve('file.txt'), 'x'); + fs.symlinkSync('file.txt', tmpdir.resolve('link')); + // RealFSProvider returns an absolute target inside its root as a VFS path. + fs.symlinkSync(tmpdir.resolve('file.txt'), tmpdir.resolve('abs-link')); + vfsInstances.push(vfs.create(new vfs.RealFSProvider(tmpdir.path))); +} + +const readlinks = [ + fs.readlinkSync, + promisify(fs.readlink), + fs.promises.readlink, +]; +const realpaths = [ + fs.realpathSync, + fs.realpathSync.native, + promisify(fs.realpath), + promisify(fs.realpath.native), + fs.promises.realpath, +]; +const mkdtemps = [ + fs.mkdtempSync, + promisify(fs.mkdtemp), + fs.promises.mkdtemp, +]; + +(async () => { + for (const myVfs of vfsInstances) { + const mountPoint = myVfs.mount(); + const prefix = path.join(mountPoint, 'tmp-'); + const vfsReadlinks = [ + myVfs.readlinkSync.bind(myVfs), + promisify(myVfs.readlink.bind(myVfs)), + myVfs.promises.readlink, + ]; + const vfsRealpaths = [ + myVfs.realpathSync.bind(myVfs), + promisify(myVfs.realpath.bind(myVfs)), + myVfs.promises.realpath, + ]; + + for (const options of ['buffer', { encoding: 'buffer' }, 'hex', { encoding: 'hex' }]) { + const encoding = options.encoding ?? options; + + for (const name of ['link', 'abs-link']) { + const link = path.join(mountPoint, name); + for (const readlink of [...readlinks, ...vfsReadlinks]) { + assert.strictEqual(decode(await readlink(link, options), encoding), + fs.readlinkSync(link)); + } + for (const realpath of [...realpaths, ...vfsRealpaths]) { + assert.strictEqual(decode(await realpath(link, options), encoding), + fs.realpathSync(link)); + } + } + + for (const mkdtemp of mkdtemps) { + const dir = decode(await mkdtemp(prefix, options), encoding); + assert.ok(dir.startsWith(prefix)); + assert.ok(fs.statSync(dir).isDirectory()); + } + } + + for (const mkdtemp of mkdtemps) { + const dir = await mkdtemp(Buffer.from(prefix), 'hex'); + assert.ok(Buffer.isBuffer(dir)); + assert.ok(fs.statSync(dir).isDirectory()); + } + + myVfs.unmount(); + } +})().then(common.mustCall()); From 6360b8ab53f25d0ccf85a31de73db33b7f92a98d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guilherme=20Ara=C3=BAjo?= Date: Sun, 25 Oct 2026 18:35:13 -0300 Subject: [PATCH 115/331] sqlite: validate backup() source is a Database MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit backup() only checked that the source argument was a BaseObject before casting it to Database, so passing a Statement or Session caused a type confusion. Check against the Database constructor template instead. Signed-off-by: Guilherme Araújo PR-URL: https://github.com/nodejs/node/pull/66797 Reviewed-By: Colin Ihrig Reviewed-By: Trivikram Kamat --- src/env_properties.h | 1 + src/node_sqlite.cc | 99 +++++++++++++++------------- test/parallel/test-sqlite-backup.mjs | 18 ++++- 3 files changed, 73 insertions(+), 45 deletions(-) diff --git a/src/env_properties.h b/src/env_properties.h index 69cc0d2ea93..1507a5e0386 100644 --- a/src/env_properties.h +++ b/src/env_properties.h @@ -450,6 +450,7 @@ V(socketaddress_constructor_template, v8::FunctionTemplate) \ V(space_stats_template, v8::DictionaryTemplate) \ V(sqlite_column_template, v8::DictionaryTemplate) \ + V(sqlite_database_constructor_template, v8::FunctionTemplate) \ V(sqlite_limits_template, v8::ObjectTemplate) \ V(sqlite_run_result_template, v8::DictionaryTemplate) \ V(sqlite_statement_sync_constructor_template, v8::FunctionTemplate) \ diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index 162b4e50010..65c0d6225a4 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -2909,9 +2909,11 @@ void Database::CreateSession(const FunctionCallbackInfo& args) { void Backup(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); - if (args.Length() < 1 || !args[0]->IsObject()) { - THROW_ERR_INVALID_ARG_TYPE(env->isolate(), - "The \"sourceDb\" argument must be an object."); + if (!args[0]->IsObject() || + !env->sqlite_database_constructor_template()->HasInstance(args[0])) { + THROW_ERR_INVALID_ARG_TYPE( + env->isolate(), + "The \"sourceDb\" argument must be an instance of Database."); return; } @@ -5085,51 +5087,60 @@ static void Initialize(Local target, } }); } - Local db_tmpl = NewFunctionTemplate(isolate, Database::New); - db_tmpl->InstanceTemplate()->SetInternalFieldCount( - Database::kInternalFieldCount); Local constants = Object::New(isolate); DefineConstants(constants); - SetProtoMethod(isolate, db_tmpl, "open", Database::Open); - SetProtoMethod(isolate, db_tmpl, "close", Database::Close); - SetProtoDispose(isolate, db_tmpl, Database::Dispose); - SetProtoMethod(isolate, db_tmpl, "prepare", Database::Prepare); - SetProtoMethod(isolate, db_tmpl, "exec", Database::Exec); - SetProtoMethod(isolate, db_tmpl, "function", Database::CustomFunction); - SetProtoMethod(isolate, db_tmpl, "createTagStore", Database::CreateTagStore); - SetProtoMethodNoSideEffect(isolate, db_tmpl, "location", Database::Location); - SetProtoMethod(isolate, db_tmpl, "aggregate", Database::AggregateFunction); - SetProtoMethod(isolate, db_tmpl, "createSession", Database::CreateSession); - SetProtoMethod(isolate, db_tmpl, "applyChangeset", Database::ApplyChangeset); - SetProtoMethod( - isolate, db_tmpl, "enableLoadExtension", Database::EnableLoadExtension); - SetProtoMethod( - isolate, db_tmpl, "enableDefensive", Database::EnableDefensive); - SetProtoMethod(isolate, db_tmpl, "loadExtension", Database::LoadExtension); - SetProtoMethod(isolate, db_tmpl, "serialize", Database::Serialize); - SetProtoMethod(isolate, db_tmpl, "deserialize", Database::Deserialize); - SetProtoMethod(isolate, db_tmpl, "setAuthorizer", Database::SetAuthorizer); - SetProtoMethod(isolate, db_tmpl, "createModule", Database::CreateModule); - SetSideEffectFreeGetter(isolate, - db_tmpl, - FIXED_ONE_BYTE_STRING(isolate, "isOpen"), - Database::IsOpenGetter); - SetSideEffectFreeGetter(isolate, - db_tmpl, - FIXED_ONE_BYTE_STRING(isolate, "isTransaction"), - Database::IsTransactionGetter); - SetSideEffectFreeGetter( - isolate, db_tmpl, env->limits_string(), Database::LimitsGetter); - Local sqlite_type_key = FIXED_ONE_BYTE_STRING(isolate, "sqlite-type"); - Local sqlite_type_symbol = - v8::Symbol::For(isolate, sqlite_type_key); - Local database_sync_string = - FIXED_ONE_BYTE_STRING(isolate, "node:sqlite"); - db_tmpl->InstanceTemplate()->Set(sqlite_type_symbol, database_sync_string); - - SetConstructorFunction(context, target, "Database", db_tmpl); + Local db_tmpl = env->sqlite_database_constructor_template(); + if (db_tmpl.IsEmpty()) { + db_tmpl = NewFunctionTemplate(isolate, Database::New); + db_tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "Database")); + db_tmpl->InstanceTemplate()->SetInternalFieldCount( + Database::kInternalFieldCount); + SetProtoMethod(isolate, db_tmpl, "open", Database::Open); + SetProtoMethod(isolate, db_tmpl, "close", Database::Close); + SetProtoDispose(isolate, db_tmpl, Database::Dispose); + SetProtoMethod(isolate, db_tmpl, "prepare", Database::Prepare); + SetProtoMethod(isolate, db_tmpl, "exec", Database::Exec); + SetProtoMethod(isolate, db_tmpl, "function", Database::CustomFunction); + SetProtoMethod( + isolate, db_tmpl, "createTagStore", Database::CreateTagStore); + SetProtoMethodNoSideEffect( + isolate, db_tmpl, "location", Database::Location); + SetProtoMethod(isolate, db_tmpl, "aggregate", Database::AggregateFunction); + SetProtoMethod(isolate, db_tmpl, "createSession", Database::CreateSession); + SetProtoMethod( + isolate, db_tmpl, "applyChangeset", Database::ApplyChangeset); + SetProtoMethod( + isolate, db_tmpl, "enableLoadExtension", Database::EnableLoadExtension); + SetProtoMethod( + isolate, db_tmpl, "enableDefensive", Database::EnableDefensive); + SetProtoMethod(isolate, db_tmpl, "loadExtension", Database::LoadExtension); + SetProtoMethod(isolate, db_tmpl, "serialize", Database::Serialize); + SetProtoMethod(isolate, db_tmpl, "deserialize", Database::Deserialize); + SetProtoMethod(isolate, db_tmpl, "setAuthorizer", Database::SetAuthorizer); + SetProtoMethod(isolate, db_tmpl, "createModule", Database::CreateModule); + SetSideEffectFreeGetter(isolate, + db_tmpl, + FIXED_ONE_BYTE_STRING(isolate, "isOpen"), + Database::IsOpenGetter); + SetSideEffectFreeGetter(isolate, + db_tmpl, + FIXED_ONE_BYTE_STRING(isolate, "isTransaction"), + Database::IsTransactionGetter); + SetSideEffectFreeGetter( + isolate, db_tmpl, env->limits_string(), Database::LimitsGetter); + Local sqlite_type_key = + FIXED_ONE_BYTE_STRING(isolate, "sqlite-type"); + Local sqlite_type_symbol = + v8::Symbol::For(isolate, sqlite_type_key); + Local database_sync_string = + FIXED_ONE_BYTE_STRING(isolate, "node:sqlite"); + db_tmpl->InstanceTemplate()->Set(sqlite_type_symbol, database_sync_string); + env->set_sqlite_database_constructor_template(db_tmpl); + } + SetConstructorFunction( + context, target, "Database", db_tmpl, SetConstructorFunctionFlag::NONE); SetConstructorFunction(context, target, "Statement", diff --git a/test/parallel/test-sqlite-backup.mjs b/test/parallel/test-sqlite-backup.mjs index cae097aa92e..633c7da7735 100644 --- a/test/parallel/test-sqlite-backup.mjs +++ b/test/parallel/test-sqlite-backup.mjs @@ -48,10 +48,26 @@ describe('backup()', () => { backup(); }, { code: 'ERR_INVALID_ARG_TYPE', - message: 'The "sourceDb" argument must be an object.' + message: 'The "sourceDb" argument must be an instance of Database.' }); }); + test('throws if the source is not an instance of Database', (t) => { + const database = makeSourceDb(); + for (const source of [ + {}, + database.prepare('SELECT 1'), + database.createSession(), + ]) { + t.assert.throws(() => { + backup(source, 'out.db'); + }, { + code: 'ERR_INVALID_ARG_TYPE', + message: 'The "sourceDb" argument must be an instance of Database.' + }); + } + }); + test('throws if path is not a string, URL, or Buffer', (t) => { const database = makeSourceDb(); From fd7dc863d01f1b99d1ad50e9e925bb55e111bd44 Mon Sep 17 00:00:00 2001 From: Lazizbek Ergashev Date: Mon, 26 Oct 2026 04:33:24 +0500 Subject: [PATCH 116/331] sqlite: retry busy or locked backup steps Signed-off-by: lazerg PR-URL: https://github.com/nodejs/node/pull/66769 Fixes: https://github.com/nodejs/node/issues/66760 Reviewed-By: Trivikram Kamat --- src/node_sqlite.cc | 5 +++++ test/parallel/test-sqlite-backup.mjs | 27 +++++++++++++++++++++++++++ 2 files changed, 32 insertions(+) diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index 65c0d6225a4..12a9dd125ef 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -680,6 +680,11 @@ class BackupJob : public ThreadPoolWork { return; } + if (backup_status_ == SQLITE_BUSY || backup_status_ == SQLITE_LOCKED) { + this->ScheduleWork(); + return; + } + int total_pages = sqlite3_backup_pagecount(backup_.get()); int remaining_pages = sqlite3_backup_remaining(backup_.get()); if (remaining_pages != 0) { diff --git a/test/parallel/test-sqlite-backup.mjs b/test/parallel/test-sqlite-backup.mjs index 633c7da7735..d3d6a433993 100644 --- a/test/parallel/test-sqlite-backup.mjs +++ b/test/parallel/test-sqlite-backup.mjs @@ -1,6 +1,7 @@ // Flags: --expose-gc import { isWindows, + platformTimeout, skipIfSQLiteMissing, spawnPromisified, } from '../common/index.mjs'; @@ -351,6 +352,32 @@ test('backup fails when path cannot be opened', async (t) => { }); }); +test('backup waits for a write transaction on the source to end', async (t) => { + const database = makeSourceDb(); + const destDb = nextDb(); + + t.after(() => { database.close(); }); + + database.exec('BEGIN IMMEDIATE'); + database.exec("INSERT INTO data (key, value) VALUES (3, 'value-3')"); + const p = backup(database, destDb); + setTimeout(() => database.exec('COMMIT'), platformTimeout(100)); + + await p; + + const backupDb = new Database(destDb); + + t.after(() => { backupDb.close(); }); + + const rows = backupDb.prepare('SELECT * FROM data').all(); + + t.assert.deepStrictEqual(rows, [ + { __proto__: null, key: 1, value: 'value-1' }, + { __proto__: null, key: 2, value: 'value-2' }, + { __proto__: null, key: 3, value: 'value-3' }, + ]); +}); + test('backup has correct name and length', (t) => { t.assert.strictEqual(backup.name, 'backup'); t.assert.strictEqual(backup.length, 2); From a2858eaaee695c28422281ee92c5859072e6da99 Mon Sep 17 00:00:00 2001 From: Ravi Arnan Irianto Date: Mon, 26 Oct 2026 03:56:41 -0400 Subject: [PATCH 117/331] doc: fix grammar and phrasing in typescript.md Fix grammatical issues and heading phrasing in `doc/api/typescript.md`: - Correct subject-verb agreement ("files that contains" -> "files that contain"). - Add missing indefinite article ("result in an ... error"). - Change heading from "Paths aliases" to "Path aliases" to match standard TypeScript terminology. - Clarify verb parallelism ("won't be transformed and will therefore produce an error"). Signed-off-by: Ravi Arnan PR-URL: https://github.com/nodejs/node/pull/66977 Reviewed-By: Colin Ihrig Reviewed-By: Mike McCready <66998419+MikeMcC399@users.noreply.github.com> --- doc/api/typescript.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/doc/api/typescript.md b/doc/api/typescript.md index 5ea7dea0202..674fa9efff2 100644 --- a/doc/api/typescript.md +++ b/doc/api/typescript.md @@ -76,7 +76,7 @@ changes: description: Type stripping is now stable. --> -By default Node.js will execute TypeScript files that contains only +By default Node.js will execute TypeScript files that contain only erasable TypeScript syntax. Node.js will replace TypeScript syntax with whitespace, and no type checking is performed. @@ -164,7 +164,7 @@ namespace TypeOnly { } ``` -This will result in [`ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX`][] error: +This will result in an [`ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX`][] error: ```ts // This namespace is exporting a value @@ -231,9 +231,9 @@ is highly discouraged. Stripping types inside `node_modules` is intended only for local development. -### Paths aliases +### Path aliases -[`tsconfig` "paths"][] won't be transformed and therefore produce an error. The closest +[`tsconfig` "paths"][] won't be transformed and will therefore produce an error. The closest feature available is [subpath imports][] with the limitation that they need to start with `#`. From f033c5aa2c6b299de41bae8126b83b527617a466 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C5=82=20Fox?= Date: Mon, 26 Oct 2026 16:21:02 +0100 Subject: [PATCH 118/331] sqlite: avoid sqlite3_clear_bindings() before every run Since SQLite 3.54, sqlite3_clear_bindings() invalidates the query plan of the statement, so a statement was re-prepared on every run. Bind NULL only to the parameters that were not bound in this run instead, and skip clearing in the tag store, which always binds every parameter. Refs: https://github.com/nodejs/node/issues/66800 Signed-off-by: dualfroz PR-URL: https://github.com/nodejs/node/pull/66983 Reviewed-By: Colin Ihrig Reviewed-By: Trivikram Kamat --- src/node_sqlite.cc | 22 ++++++++++++------- test/parallel/test-sqlite-data-types.js | 28 +++++++++++++++++++++++++ 2 files changed, 43 insertions(+), 7 deletions(-) diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index 12a9dd125ef..ae8fa360a20 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -3563,8 +3563,10 @@ inline int Statement::ResetStatement() { } bool Statement::BindParams(const FunctionCallbackInfo& args) { - int r = sqlite3_clear_bindings(statement_.get()); - CHECK_ERROR_OR_THROW(env()->isolate(), db_.get(), r, SQLITE_OK, false); + int param_count = sqlite3_bind_parameter_count(statement_.get()); + // Parameter indexing starts at one. + MaybeStackBuffer bound(param_count + 1); + std::fill_n(bound.out(), param_count + 1, false); int anon_idx = 1; int anon_start = 0; @@ -3580,8 +3582,6 @@ bool Statement::BindParams(const FunctionCallbackInfo& args) { if (allow_bare_named_params_ && !bare_named_params_.has_value()) { bare_named_params_.emplace(); - int param_count = sqlite3_bind_parameter_count(statement_.get()); - // Parameter indexing starts at one. for (int i = 1; i <= param_count; ++i) { const char* name = sqlite3_bind_parameter_name(statement_.get(), i); if (name == nullptr) { @@ -3644,6 +3644,7 @@ bool Statement::BindParams(const FunctionCallbackInfo& args) { if (!BindValue(value, r)) { return false; } + bound[r] = true; } anon_start++; } @@ -3659,10 +3660,20 @@ bool Statement::BindParams(const FunctionCallbackInfo& args) { if (!BindValue(args[i], anon_idx)) { return false; } + bound[anon_idx] = true; anon_idx++; } + // sqlite3_clear_bindings() would expire statements whose query plan depends + // on a bound value, so only reset the parameters that were not bound. + for (int i = 1; i <= param_count; ++i) { + if (!bound[i]) { + int r = sqlite3_bind_null(statement_.get(), i); + CHECK_ERROR_OR_THROW(env()->isolate(), db_.get(), r, SQLITE_OK, false); + } + } + return true; } @@ -4424,9 +4435,6 @@ bool SQLTagStore::ResetAndBindStatement( int r = stmt->ResetStatement(); CHECK_ERROR_OR_THROW(isolate, stmt->db_.get(), r, SQLITE_OK, false); - r = sqlite3_clear_bindings(stmt->statement_.get()); - CHECK_ERROR_OR_THROW(isolate, stmt->db_.get(), r, SQLITE_OK, false); - uint32_t n_params = args.Length() - 1; int param_count = sqlite3_bind_parameter_count(stmt->statement_.get()); if (param_count != static_cast(n_params)) { diff --git a/test/parallel/test-sqlite-data-types.js b/test/parallel/test-sqlite-data-types.js index 473e504ead2..3e4768c5714 100644 --- a/test/parallel/test-sqlite-data-types.js +++ b/test/parallel/test-sqlite-data-types.js @@ -256,4 +256,32 @@ suite('data binding and mapping', () => { [{ __proto__: null, key: 1, val: 5 }, { __proto__: null, key: 2, val: null }], ); }); + + test('omitted named parameters are unbound on each call', (t) => { + const db = new Database(':memory:'); + t.after(() => { db.close(); }); + const setup = db.exec( + 'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;' + ); + t.assert.strictEqual(setup, undefined); + const named = db.prepare('INSERT INTO data (key, val) VALUES ($k, $v)'); + const mixed = db.prepare('INSERT INTO data (key, val) VALUES ($k, ?)'); + named.run({ k: 1, v: 5 }); + named.run({ k: 2 }); + named.run({ k: 3, v: 6 }); + named.run({ k: 4, $k: 4 }); + mixed.run({ k: 5 }, 7); + mixed.run({ k: 6 }); + t.assert.deepStrictEqual( + db.prepare('SELECT * FROM data ORDER BY key').all(), + [ + { __proto__: null, key: 1, val: 5 }, + { __proto__: null, key: 2, val: null }, + { __proto__: null, key: 3, val: 6 }, + { __proto__: null, key: 4, val: null }, + { __proto__: null, key: 5, val: 7 }, + { __proto__: null, key: 6, val: null }, + ], + ); + }); }); From f87b1d56375c237fcb6c6579f6122701aa1bea86 Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Mon, 26 Oct 2026 13:32:08 -0300 Subject: [PATCH 119/331] doc: document the alpha release process Document how to prepare, version, tag and promote the Alpha releases introduced by the new release schedule, starting with Node.js 27, and how the first Alpha and semver-major releases are prepared with git node release. Refs: https://github.com/nodejs/Release/issues/1187 Signed-off-by: RafaelGSS PR-URL: https://github.com/nodejs/node/pull/66796 Reviewed-By: Antoine du Hamel Reviewed-By: Richard Lau --- .github/workflows/create-release-proposal.yml | 7 +- .github/workflows/lint-release-proposal.yml | 6 +- .github/workflows/major-release.yml | 2 +- Makefile | 2 +- doc/contributing/releases.md | 127 ++++++++++++++++-- test/parallel/test-release-changelog.js | 19 ++- test/parallel/test-release-npm.js | 2 +- tools/actions/create-release-proposal.sh | 6 +- .../lint-release-proposal-commit-list.mjs | 3 +- tools/getnodeversion.py | 24 +++- tools/release.sh | 5 +- vcbuild.bat | 5 +- 12 files changed, 180 insertions(+), 28 deletions(-) diff --git a/.github/workflows/create-release-proposal.yml b/.github/workflows/create-release-proposal.yml index 735b15ffd12..84300d8a169 100644 --- a/.github/workflows/create-release-proposal.yml +++ b/.github/workflows/create-release-proposal.yml @@ -14,6 +14,10 @@ on: required: true type: string description: The release date in YYYY-MM-DD format + release-version: + required: false + type: string + description: 'The version to release, if it cannot be inferred. e.g: 27.0.0-alpha.0.0.0' concurrency: ${{ github.workflow }} @@ -31,6 +35,7 @@ jobs: RELEASE_BRANCH: v${{ inputs.release-line }}.x RELEASE_DATE: ${{ inputs.release-date }} RELEASE_LINE: ${{ inputs.release-line }} + RELEASE_VERSION: ${{ inputs.release-version }} runs-on: ubuntu-slim steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 @@ -74,7 +79,7 @@ jobs: # The curl command is to make sure we run the version of the script corresponding to the current workflow. run: | curl -fsSL https://github.com/${GITHUB_REPOSITORY}/raw/${GITHUB_SHA}/tools/actions/create-release-proposal.sh |\ - sh -s -- "${RELEASE_DATE}" "${RELEASE_LINE}" "${GITHUB_ACTOR}" + sh -s -- "${RELEASE_DATE}" "${RELEASE_LINE}" "${GITHUB_ACTOR}" "${RELEASE_VERSION}" env: GH_TOKEN: ${{ github.token }} # We want the bot to push the push the release commit so CI runs on it. diff --git a/.github/workflows/lint-release-proposal.yml b/.github/workflows/lint-release-proposal.yml index 9652eea91b8..989a57cd885 100644 --- a/.github/workflows/lint-release-proposal.yml +++ b/.github/workflows/lint-release-proposal.yml @@ -4,6 +4,7 @@ on: push: branches: - v[0-9]+.[0-9]+.[0-9]+-proposal + - v[0-9]+.0.0-alpha.[0-9]+.[0-9]+.[0-9]+-proposal concurrency: group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} @@ -34,8 +35,11 @@ jobs: $2 == "NODE_MAJOR_VERSION" { maj = $3 } $2 == "NODE_MINOR_VERSION" { min = $3 } $2 == "NODE_PATCH_VERSION" { pat = $3 } + $2 == "NODE_ALPHA_MAJOR_VERSION" { amaj = $3 } + $2 == "NODE_ALPHA_MINOR_VERSION" { amin = $3 } + $2 == "NODE_ALPHA_PATCH_VERSION" { apat = $3 } $2 == "NODE_VERSION_LTS_CODENAME" { gsub(/^"|"$/, "'"'"'",$3); lts = $3 } - END { if (maj) print maj "\\." min "\\." pat " " (lts != "'"''"'" ? lts " \\(LTS" : "\\(Current" ) "\\)" } + END { if (maj) print maj "\\." min "\\." pat (amaj != "" ? "-alpha\\." amaj "\\." amin "\\." apat " \\(Alpha" : " " (lts != "'"''"'" ? lts " \\(LTS" : "\\(Current" )) "\\)" } ') MAJOR=${VERSION%%\\.*} EXPECTED_TITLE='^[[:digit:]]{4}-[[:digit:]]{2}-[[:digit:]]{2}, Version '"$VERSION"'$' diff --git a/.github/workflows/major-release.yml b/.github/workflows/major-release.yml index 1b15a00c8df..6641571aecc 100644 --- a/.github/workflows/major-release.yml +++ b/.github/workflows/major-release.yml @@ -21,7 +21,7 @@ jobs: MONTH=$(date +'%m') DAY=$(date +'%d') # We'll create the reminder issue two months prior the release - if [[ "$MONTH" == "02" || "$MONTH" == "08" ]] && [[ "$DAY" == "15" ]]; then + if [[ "$MONTH" == "02" ]] && [[ "$DAY" == "15" ]]; then echo "create_issue=true" >> "$GITHUB_ENV" fi - name: Retrieve next major release info from nodejs/Release diff --git a/Makefile b/Makefile index d1de619ff2d..fa007444d3d 100644 --- a/Makefile +++ b/Makefile @@ -992,7 +992,7 @@ ifndef DISTTYPE DISTTYPE=release endif ifeq ($(DISTTYPE),release) -FULLVERSION=$(VERSION) +FULLVERSION=v$(shell $(PYTHON) tools/getnodeversion.py --full) else # ifeq ($(DISTTYPE),release) ifeq ($(DISTTYPE),custom) ifndef CUSTOMTAG diff --git a/doc/contributing/releases.md b/doc/contributing/releases.md index 0b50c014c3b..bb48cb17b7b 100644 --- a/doc/contributing/releases.md +++ b/doc/contributing/releases.md @@ -499,8 +499,9 @@ The new entry should take the following form: * Include the full list of commits since the last release here. Do not include "Working on X.Y.Z+1" commits. ``` -The release type should be either Current, LTS, or Maintenance, depending on the -type of release being produced. +The release type should be either Alpha, Current, or LTS, depending +on the type of release being produced. Release lines before Node.js 27 +also have a Maintenance phase. By default, the `### Notable changes` section should be populated with the commits in the release that have either the `notable-change` or `semver-minor` @@ -903,13 +904,20 @@ git secure-tag -sm "YYYY-MM-DD Node.js vx.y.z (The commit-sha is the release commit. You can get it easily by running `git rev-parse HEAD` -`release-type` is either "Current" or "LTS". For LTS releases, you should also -include the release code name. +`release-type` is either "Alpha", "Current" or "LTS". For LTS releases, you +should also include the release code name. ```text 2019-10-22 Node.js v10.17.0 'Dubnium' (LTS) Release ``` +For Alpha releases, the tag name includes the full pre-release version (see +[Alpha releases](#alpha-releases-october-to-april)): + +```text +2026-10-28 Node.js v27.0.0-alpha.0.0.0 (Alpha) Release +``` + The tag **must** be signed using the GPG key that's listed for you on the project README. @@ -930,6 +938,9 @@ Working on vx.y.z # where 'z' is the incremented patch number PR-URL: ``` +For Alpha releases, use the full pre-release version, e.g. +`Working on v27.0.0-alpha.1.0.1`. + This sets up the branch so that nightly builds are produced with the next version number _and_ a pre-release tag. @@ -1394,6 +1405,13 @@ announced immediately following the release of 12.0.0). ### Branch-off (October) +#### Tracking issue + +Open an issue in the [Release repository][] titled `Prepare for vN`, listing +the pull requests needed to prepare the release line (e.g. tooling updates or +the expected assets in the Build repository). Keep it updated as pull requests +are opened and land. + #### Release branch Approximately six months before a major release, new `vN.x` and @@ -1427,10 +1445,25 @@ labels of previous releases. #### Initial Alpha release proposal -A draft release proposal should be created before the release. A -separate `vN.x-proposal` branch should be created that tracks the `vN.x` -branch. This branch will contain the draft release commit (with the draft -changelog). +A draft release proposal should be created before the release. Once the +`vN.x-staging` branch exists, use the [`create-release-proposal`][] action with +the first Alpha version: + +```bash +gh workflow run "Create Release Proposal" -f release-line=N -f release-date=YYYY-MM-DD -f release-version=N.0.0-alpha.0.0.0 +``` + +Or run it locally: + +```bash +git node release -S --prepare --newVersion=N.0.0-alpha.0.0.0 +``` + +This creates the `vN.0.0-alpha.0.0.0-proposal` branch with the draft release +commit, which also creates `doc/changelogs/CHANGELOG_V{N}.md`, updates the +navigation headers and the root `CHANGELOG.md`, and generates the changelog +against `vN-1.x`, as described in the sections below. Review those changes +before opening the release proposal. Notify the `@nodejs/npm` team in the release proposal PR to inform them of the upcoming release. @@ -1526,14 +1559,77 @@ version of the release), in the [expected assets][] folder. The change will need to be deployed onto the web server by a member of the [build-infra team][] before the release is promoted. +### Alpha releases (October to April) + +Between the branch-off and the semver-major release, the `vN.x` line is +released as Alpha versions. Unlike Current and LTS lines, Alpha releases may +contain `SEMVER-MAJOR` changes. + +#### Versioning + +Alpha versions use the `vN.0.0-alpha.X.Y.Z` format, where `X.Y.Z` follows +[Semantic Versioning][] relative to the previous Alpha release, so users can +tell the kind of changes between two Alpha releases. The first Alpha release of +a line is `vN.0.0-alpha.0.0.0`. + +Set the `NODE_ALPHA_*_VERSION` macros in `src/node_version.h` as follows, +leaving `NODE_MAJOR_VERSION` at `N` and `NODE_MINOR_VERSION` and +`NODE_PATCH_VERSION` at `0`: + +* If the release contains at least one `SEMVER-MAJOR` commit, increment + `NODE_ALPHA_MAJOR_VERSION` and reset `NODE_ALPHA_MINOR_VERSION` and + `NODE_ALPHA_PATCH_VERSION` to `0`. +* Otherwise, if it contains at least one `SEMVER-MINOR` commit, increment + `NODE_ALPHA_MINOR_VERSION` and reset `NODE_ALPHA_PATCH_VERSION` to `0`. +* Otherwise, increment `NODE_ALPHA_PATCH_VERSION`. + +For example, `v27.0.0-alpha.0.0.0` followed by a release containing a +`SEMVER-MAJOR` commit is `v27.0.0-alpha.1.0.0`. The git tag, the release commit +title and the changelog entries all use this full version: + +```text +2026-10-28, Version 27.0.0-alpha.0.0.0 (Alpha) +``` + +#### Preparing an Alpha release + +Alpha releases pick up commits from `main`, including `SEMVER-MAJOR` ones. To +list the commits to land on `vN.x-staging`, do not exclude the `semver-major` +label: + +```bash +N=27 sh -c 'branch-diff v$N.x-staging upstream/main --exclude-label=dont-land-on-v$N.x,backport-requested-v$N.x,backport-blocked-v$N.x,backport-open-v$N.x,backported-to-v$N.x --filter-release --format=simple' +``` + +The [`create-release-proposal`][] action and `git node release --prepare` +compute the next Alpha version from the commit labels. The proposal branch is +named after the full version, e.g. `v27.0.0-alpha.1.0.0-proposal`. + +Alpha releases are added to `doc/changelogs/CHANGELOG_V{N}.md`, in the same way +as Current releases, and are labeled "Alpha" in the changelog tables. List all +`SEMVER-MAJOR` commits that are not strictly internal, test, or doc-related as +notable changes. + +Alpha releases are published on GitHub as pre-releases, so they are not marked +as the latest release. + +`REPLACEME` placeholders are replaced with the full Alpha version (e.g. +`v27.0.0-alpha.1.0.0`). + ### Semver-major release (April) #### Release proposal -A draft release proposal should be created 6 weeks before the release. A -separate `vN.x-proposal` branch should be created that tracks the `vN.x` -branch. This branch will contain the draft release commit (with the draft -changelog). +A draft release proposal should be created 2 weeks before the release, using +the [`create-release-proposal`][] action with `-f release-version=N.0.0`, or +locally: + +```bash +git node release -S --prepare --newVersion=N.0.0 +``` + +This creates the `vN.0.0-proposal` branch with the draft release commit (with +the draft changelog). Notify the `@nodejs/npm` team in the release proposal PR to inform them of the upcoming release. @@ -1551,6 +1647,11 @@ To mark a release line as stable, the following changes must be made to * Remove `NODE_ALPHA_MAJOR_VERSION`, `NODE_ALPHA_MINOR_VERSION`, and `NODE_ALPHA_PATCH_VERSION`. +The "Alpha" labels in `doc/changelogs/CHANGELOG_V{N}.md` and `CHANGELOG.md` +must be changed to "Current". `git node release --prepare --newVersion=N.0.0` +does both, and `git node release --promote` bumps `NODE_MAJOR_VERSION` on +`main` when cherry-picking the release commit. + #### Generate the notable changes For a major release, all SEMVER-MAJOR commits that are not strictly internal, @@ -1606,6 +1707,8 @@ Typical resolution: sign the release again. [Build issue tracker]: https://github.com/nodejs/build/issues/new [Node.js Snap management repository]: https://github.com/nodejs/snap +[Release repository]: https://github.com/nodejs/Release +[Semantic Versioning]: https://semver.org/ [Snap]: https://snapcraft.io/node [`create-release-post.yml`]: https://github.com/nodejs/nodejs.org/actions/workflows/create-release-post.yml [`create-release-proposal`]: https://github.com/nodejs/node/actions/workflows/create-release-proposal.yml diff --git a/test/parallel/test-release-changelog.js b/test/parallel/test-release-changelog.js index 6b8e6ece43a..1775d7afc7c 100644 --- a/test/parallel/test-release-changelog.js +++ b/test/parallel/test-release-changelog.js @@ -27,7 +27,16 @@ if (!release) { const major = getDefine(versionText, 'NODE_MAJOR_VERSION'); const minor = getDefine(versionText, 'NODE_MINOR_VERSION'); const patch = getDefine(versionText, 'NODE_PATCH_VERSION'); -const versionForRegex = RegExp.escape(`${major}.${minor}.${patch}`); +let version = `${major}.${minor}.${patch}`; +const alpha = /#define\s+NODE_ALPHA_MAJOR_VERSION\s/.test(versionText); +if (alpha) { + const alphaMajor = getDefine(versionText, 'NODE_ALPHA_MAJOR_VERSION'); + const alphaMinor = getDefine(versionText, 'NODE_ALPHA_MINOR_VERSION'); + const alphaPatch = getDefine(versionText, 'NODE_ALPHA_PATCH_VERSION'); + version += `-alpha.${alphaMajor}.${alphaMinor}.${alphaPatch}`; +} +const versionForRegex = RegExp.escape(version); +const releaseType = alpha ? 'Alpha' : 'Current'; const lts = getDefine(versionText, 'NODE_VERSION_IS_LTS') !== '0'; const codename = getDefine(versionText, 'NODE_VERSION_LTS_CODENAME').slice(1, -1); @@ -47,7 +56,7 @@ const changelogPath = `doc/changelogs/CHANGELOG_V${major}.md`; if (lts) { tableHeader = new RegExp(`LTS '${RegExp.escape(codename)}'`); } else { - tableHeader = /Current<\/th>/; + tableHeader = new RegExp(`${releaseType}`); } assert.match(changelog, tableHeader); // Check table contains link to this release. @@ -59,7 +68,7 @@ const changelogPath = `doc/changelogs/CHANGELOG_V${major}.md`; if (lts) { title = new RegExp(`## \\d{4}-\\d{2}-\\d{2}, Version ${versionForRegex} '${RegExp.escape(codename)}' \\(LTS\\), @\\S+`); } else { - title = new RegExp(`## \\d{4}-\\d{2}-\\d{2}, Version ${versionForRegex} \\(Current\\), @\\S+`); + title = new RegExp(`## \\d{4}-\\d{2}-\\d{2}, Version ${versionForRegex} \\(${releaseType}\\), @\\S+`); } assert.match(changelog, title); } @@ -72,7 +81,7 @@ const changelogPath = `doc/changelogs/CHANGELOG_V${major}.md`; if (lts) { linkToChangelog = new RegExp(`\\[Node\\.js ${major}\\]\\(${RegExp.escape(changelogPath)}\\) \\*\\*Long Term Support\\*\\*`); } else { - linkToChangelog = new RegExp(`\\[Node\\.js ${major}\\]\\(${RegExp.escape(changelogPath)}\\) \\*\\*Current\\*\\*`); + linkToChangelog = new RegExp(`\\[Node\\.js ${major}\\]\\(${RegExp.escape(changelogPath)}\\) \\*\\*${releaseType}\\*\\*`); } assert.match(mainChangelog, linkToChangelog); // Check table header. @@ -80,7 +89,7 @@ const changelogPath = `doc/changelogs/CHANGELOG_V${major}.md`; if (lts) { tableHeader = new RegExp(`${major} \\(LTS\\)`); } else { - tableHeader = new RegExp(`${major} \\(Current\\)`); + tableHeader = new RegExp(`${major} \\(${releaseType}\\)`); } assert.match(mainChangelog, tableHeader); // Check the table contains a link to the release in the appropriate CHANGELOG_V*.md file. diff --git a/test/parallel/test-release-npm.js b/test/parallel/test-release-npm.js index 5544ef79313..a9aff0b7579 100644 --- a/test/parallel/test-release-npm.js +++ b/test/parallel/test-release-npm.js @@ -5,7 +5,7 @@ const assert = require('assert'); const child_process = require('child_process'); const path = require('path'); -const releaseReg = /^v\d+\.\d+\.\d+$/; +const releaseReg = /^v\d+(?:\.0\.0-alpha\.\d+)?\.\d+\.\d+$/; // Npm requires crypto support. if (!releaseReg.test(process.version) || !common.hasCrypto) { diff --git a/tools/actions/create-release-proposal.sh b/tools/actions/create-release-proposal.sh index 9240fa2ad7f..673fd070b67 100755 --- a/tools/actions/create-release-proposal.sh +++ b/tools/actions/create-release-proposal.sh @@ -6,9 +6,10 @@ BOT_TOKEN=${BOT_TOKEN:-} RELEASE_DATE=$1 RELEASE_LINE=$2 RELEASER=$3 +RELEASE_VERSION=$4 if [ -z "$RELEASE_DATE" ] || [ -z "$RELEASE_LINE" ]; then - echo "Usage: $0 " + echo "Usage: $0 [ []]" exit 1 fi @@ -28,7 +29,8 @@ done set -xe -git node release --prepare --skipBranchDiff --yes --releaseDate "$RELEASE_DATE" +git node release --prepare --skipBranchDiff --yes --releaseDate "$RELEASE_DATE" \ + ${RELEASE_VERSION:+--newVersion "$RELEASE_VERSION"} HEAD_BRANCH="$(git rev-parse --abbrev-ref HEAD)" HEAD_SHA="$(git rev-parse HEAD^)" diff --git a/tools/actions/lint-release-proposal-commit-list.mjs b/tools/actions/lint-release-proposal-commit-list.mjs index a51f0c59002..fa5ebf79cdf 100755 --- a/tools/actions/lint-release-proposal-commit-list.mjs +++ b/tools/actions/lint-release-proposal-commit-list.mjs @@ -30,7 +30,7 @@ if (commitListingStart === -1) { } else { // We can't assume the Commits section is the one for this release in case of // a release to transition to LTS (i.e. with no commits). - const releaseStart = /\n<\/a>\n\n## \d+-\d+-\d+, Version \1/.exec(changelog); + const releaseStart = /\n<\/a>\n\n## \d+-\d+-\d+, Version \1/.exec(changelog); assert.ok(releaseStart, 'Could not determine the start of the release section'); const releaseEnd = changelog.indexOf('\n\n Date: Mon, 26 Oct 2026 21:25:41 +0000 Subject: [PATCH 120/331] test: check html and json doc files are generated Signed-off-by: Richard Lau PR-URL: https://github.com/nodejs/node/pull/66613 Refs: https://github.com/nodejs/node/issues/66571 Reviewed-By: Claudio Wunder Reviewed-By: Luigi Pinca Reviewed-By: James M Snell Reviewed-By: Antoine du Hamel --- test/doctool/test-docs.mjs | 54 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 test/doctool/test-docs.mjs diff --git a/test/doctool/test-docs.mjs b/test/doctool/test-docs.mjs new file mode 100644 index 00000000000..3685a0cf40e --- /dev/null +++ b/test/doctool/test-docs.mjs @@ -0,0 +1,54 @@ +import * as common from '../common/index.mjs'; + +import assert from 'node:assert'; +import fs from 'node:fs/promises'; +import path from 'node:path'; + +// This tests that `make doc` generates HTML and JSON. +// Note that for this test to pass, `make doc` must be run first. + +if (common.isWindows) { + common.skip('`make doc` does not run on Windows'); +} + +// Not all files under `doc/api` are expected in the generated output. +// Parse out list of excluded files. +let excludes = []; +const makefile = await fs.open(new URL('../../Makefile', import.meta.url)); +try { + // Find the `skip_apidoc_files = ` line and parse out the list of files. + for await (const line of makefile.readLines()) { + if (line.startsWith('skip_apidoc_files')) { + excludes = line.split('=')[1]?.trim().split(/\s/).map((n) => path.basename(n)); + } + } +} finally { + makefile.close(); +} + +const outdir = new URL('../../out/doc/api', import.meta.url); +const files = await fs.readdir(outdir); + +// Explicitly check for `all.html` and `all.json` as there is no corresponding `all.md` file in `doc/api`. +assert(files.includes('all.html'), `all.html was not generated (checked ${files})`); +assert(files.includes('all.json'), `all.json was not generated (checked ${files})`); + +// Check that every markdown file in `doc/api` was processed. +for await (const file of await fs.opendir(new URL('../../doc/api/', import.meta.url))) { + // Only expect markdown files in doc/api. + assert(path.extname(file.name), 'md'); + + // Always expect markdown file in out/doc/api. + assert(files.includes(file.name), `${file.name} not found (checked ${files})`); + + const htmlFile = `${path.basename(file.name, '.md')}.html`; + const jsonFile = `${path.basename(file.name, '.md')}.json`; + // Excluded files should not generate HTML and json files. + if (excludes.includes(file.name)) { + assert(!files.includes(htmlFile), `${htmlFile} was unexpectedly generated (checked ${files})`); + assert(!files.includes(jsonFile), `${jsonFile} was unexpectedly generated (checked ${files})`); + } else { + assert(files.includes(htmlFile), `${htmlFile} was not generated (checked ${files})`); + assert(files.includes(jsonFile), `${jsonFile} was not generated (checked ${files})`); + } +} From c55e6091ebccee87b4ba9f05ee7d4b4c2c5879ac Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Mon, 26 Oct 2026 21:11:13 -0400 Subject: [PATCH 121/331] deps: update zlib to 1.3.2.1-motley-9f9f52c PR-URL: https://github.com/nodejs/node/pull/66989 Reviewed-By: Filip Skokan Reviewed-By: Colin Ihrig --- deps/zlib/chromeconf.h | 4 ++++ src/zlib_version.h | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/deps/zlib/chromeconf.h b/deps/zlib/chromeconf.h index 77f0e29e0d6..e59a89966eb 100644 --- a/deps/zlib/chromeconf.h +++ b/deps/zlib/chromeconf.h @@ -196,6 +196,7 @@ /* Symbols added by crc32_simd.c */ #define crc32_sse42_simd_ Cr_z_crc32_sse42_simd_ +#define crc32_avx512_simd_ Cr_z_crc32_avx512_simd_ /* Symbols added by armv8_crc32 */ #define arm_cpu_enable_crc32 Cr_z_arm_cpu_enable_crc32 @@ -207,5 +208,8 @@ /* Symbols added by cpu_features.c */ #define cpu_check_features Cr_z_cpu_check_features #define x86_cpu_enable_sse2 Cr_z_x86_cpu_enable_sse2 +#define x86_cpu_enable_avx512 Cr_z_x86_cpu_enable_avx512 +#define riscv_cpu_enable_rvv Cr_z_riscv_cpu_enable_rvv +#define riscv_cpu_enable_vclmul Cr_z_riscv_cpu_enable_vclmul #endif /* THIRD_PARTY_ZLIB_CHROMECONF_H_ */ diff --git a/src/zlib_version.h b/src/zlib_version.h index 59b9853e7ed..5e85dbba976 100644 --- a/src/zlib_version.h +++ b/src/zlib_version.h @@ -2,5 +2,5 @@ // Refer to tools/dep_updaters/update-zlib.sh #ifndef SRC_ZLIB_VERSION_H_ #define SRC_ZLIB_VERSION_H_ -#define ZLIB_VERSION "1.3.2.1-motley-456ae73" +#define ZLIB_VERSION "1.3.2.1-motley-9f9f52c" #endif // SRC_ZLIB_VERSION_H_ From 53a5bd6560a1435e4ec5c2e62dc8821c2f934327 Mon Sep 17 00:00:00 2001 From: Ved Chaudhari <84765263+vedchaudhari@users.noreply.github.com> Date: Tue, 27 Oct 2026 16:28:13 +0530 Subject: [PATCH 122/331] events: report original once() listener on removal When a `once()` listener is removed, emit the original user-defined function in the `removeListener` event instead of the internal wrapper, matching the behavior of the single-listener path. Assisted-by: claude:opus-5.5 Signed-off-by: vedchaudhari PR-URL: https://github.com/nodejs/node/pull/66621 Refs: https://github.com/nodejs/node/issues/5551 Refs: https://github.com/nodejs/node/pull/6394 Refs: https://github.com/nodejs/node/pull/33596 Reviewed-By: Chemi Atlow --- lib/events.js | 2 +- test/parallel/test-event-emitter-remove-listeners.js | 12 ++++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/lib/events.js b/lib/events.js index 8b20ea994d6..4866073de81 100644 --- a/lib/events.js +++ b/lib/events.js @@ -725,7 +725,7 @@ EventEmitter.prototype.removeListener = events[type] = list[0]; if (events.removeListener !== undefined) - this.emit('removeListener', type, listener); + this.emit('removeListener', type, listener.listener || listener); } return this; diff --git a/test/parallel/test-event-emitter-remove-listeners.js b/test/parallel/test-event-emitter-remove-listeners.js index e9e4a74a5b6..fe36554cc64 100644 --- a/test/parallel/test-event-emitter-remove-listeners.js +++ b/test/parallel/test-event-emitter-remove-listeners.js @@ -138,6 +138,18 @@ function listener2() {} ee.emit('hello'); } +{ + const ee = new EventEmitter(); + + ee.once('hello', listener1); + ee.on('hello', listener2); + ee.on('removeListener', common.mustCall((eventName, listener) => { + assert.strictEqual(eventName, 'hello'); + assert.strictEqual(listener, listener1); + })); + ee.emit('hello'); +} + { const ee = new EventEmitter(); From 92b6c09ed78bc949653ed531b46aafbe59cd9434 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 27 Oct 2026 17:31:29 +0000 Subject: [PATCH 123/331] tools: bump remark-preset-lint-node Bumps the lint-md group in /tools/lint-md with 1 update: [remark-preset-lint-node](https://github.com/nodejs/remark-preset-lint-node). Updates `remark-preset-lint-node` from 5.1.2 to 5.2.0 - [Release notes](https://github.com/nodejs/remark-preset-lint-node/releases) - [Commits](https://github.com/nodejs/remark-preset-lint-node/compare/v5.1.2...v5.2.0) --- updated-dependencies: - dependency-name: remark-preset-lint-node dependency-version: 5.2.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: lint-md ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/67023 Reviewed-By: Rafael Gonzaga Reviewed-By: Antoine du Hamel Reviewed-By: Richard Lau --- tools/lint-md/package-lock.json | 163 +++++++------------------------- tools/lint-md/package.json | 2 +- 2 files changed, 34 insertions(+), 131 deletions(-) diff --git a/tools/lint-md/package-lock.json b/tools/lint-md/package-lock.json index ea6663dc369..d70ba0e5791 100644 --- a/tools/lint-md/package-lock.json +++ b/tools/lint-md/package-lock.json @@ -9,7 +9,7 @@ "version": "1.0.0", "dependencies": { "remark-parse": "^11.0.0", - "remark-preset-lint-node": "^5.1.2", + "remark-preset-lint-node": "^5.2.0", "remark-stringify": "^11.0.0", "to-vfile": "^8.0.0", "unified": "^11.0.5", @@ -89,10 +89,20 @@ } }, "node_modules/argparse": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", - "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", - "license": "Python-2.0" + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-3.0.4.tgz", + "integrity": "sha512-fwWK3Zq22l4XJJjx5mcBHGikIk+hJqO+32dPm0Jur7+rtG5x1scOjSfdT9ZKeWHPpsya/l0HHK4tDImBkTrtvA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/puzrin" + }, + { + "type": "github", + "url": "https://github.com/sponsors/nodeca" + } + ], + "license": "PSF-2.0" }, "node_modules/bail": { "version": "2.0.2", @@ -270,29 +280,6 @@ "url": "https://github.com/sponsors/wooorm" } }, - "node_modules/is-buffer": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz", - "integrity": "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/feross" - }, - { - "type": "patreon", - "url": "https://www.patreon.com/feross" - }, - { - "type": "consulting", - "url": "https://feross.org/support" - } - ], - "license": "MIT", - "engines": { - "node": ">=4" - } - }, "node_modules/is-decimal": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.1.tgz", @@ -326,9 +313,9 @@ } }, "node_modules/js-yaml": { - "version": "4.3.2", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.2.tgz", - "integrity": "sha512-SFNOvSJ+Dgf/9An904Yx+CgSlIPCkIpao4qo51lpee25TIRejdH3rhR4EZMGoNx3/TP3O+wzWuiTFl4sqbltzA==", + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-5.5.0.tgz", + "integrity": "sha512-paNr4LFIFPjeeSmwNYdrb8FafLLG/Cr2Af3GjbsHJ5CxIjH4r0c2emlmRdAtpPAieP1gRVzk6buBbVP5gBMGAg==", "funding": [ { "type": "github", @@ -341,10 +328,10 @@ ], "license": "MIT", "dependencies": { - "argparse": "^2.0.1" + "argparse": "^3.0.3" }, "bin": { - "js-yaml": "bin/js-yaml.js" + "js-yaml": "bin/js-yaml.mjs" } }, "node_modules/longest-streak": { @@ -1862,9 +1849,9 @@ } }, "node_modules/remark-lint-no-trailing-spaces": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/remark-lint-no-trailing-spaces/-/remark-lint-no-trailing-spaces-3.0.2.tgz", - "integrity": "sha512-4KxOdzZ+BlCZDu9yYsKGOfB8fknukxYD+9VhI1I5l7Ns7TgqdYq4k/qwUfTHpQ4TF9aokL/tOpsEGOc4PGKTKw==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/remark-lint-no-trailing-spaces/-/remark-lint-no-trailing-spaces-5.0.0.tgz", + "integrity": "sha512-O9nk0/PwZaHMeabfGuPDfmWRzwloZW6hL4j1nA2flF27EWXbOWSFkihRPyUAgVSm2wRs2lPjDV97Ey+liHeLGw==", "license": "MIT", "dependencies": { "unified-lint-rule": "^3.0.0", @@ -1927,102 +1914,18 @@ } }, "node_modules/remark-lint-prohibited-strings": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/remark-lint-prohibited-strings/-/remark-lint-prohibited-strings-4.0.0.tgz", - "integrity": "sha512-dfLF4da5v3klRAdkHBLpNIC7WpvNdN7Eylgf+p19HPJn53CaxqlGjFvAQDAJU83xXEPWAmdonlx04GIS5ryLow==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/remark-lint-prohibited-strings/-/remark-lint-prohibited-strings-5.0.0.tgz", + "integrity": "sha512-t2U6nB+UnDMkOQQZ0oTaT8kzjDD1+fYRyLpqSrY9O5shy9sGkx/9f8mEJ4uuCuJO5pjtI0bJmucbieEfoFTztA==", "license": "MIT", "dependencies": { "escape-string-regexp": "^5.0.0", - "unified-lint-rule": "^2.0.0", + "unified-lint-rule": "^3.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", "vfile-location": "^5.0.1" } }, - "node_modules/remark-lint-prohibited-strings/node_modules/@types/unist": { - "version": "2.0.11", - "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz", - "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==", - "license": "MIT" - }, - "node_modules/remark-lint-prohibited-strings/node_modules/unified": { - "version": "10.1.2", - "resolved": "https://registry.npmjs.org/unified/-/unified-10.1.2.tgz", - "integrity": "sha512-pUSWAi/RAnVy1Pif2kAoeWNBa3JVrx0MId2LASj8G+7AiHWoKZNTomq6LG326T68U7/e263X6fTdcXIy7XnF7Q==", - "license": "MIT", - "dependencies": { - "@types/unist": "^2.0.0", - "bail": "^2.0.0", - "extend": "^3.0.0", - "is-buffer": "^2.0.0", - "is-plain-obj": "^4.0.0", - "trough": "^2.0.0", - "vfile": "^5.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/remark-lint-prohibited-strings/node_modules/unified-lint-rule": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.1.2.tgz", - "integrity": "sha512-JWudPtRN7TLFHVLEVZ+Rm8FUb6kCAtHxEXFgBGDxRSdNMnGyTU5zyYvduHSF/liExlFB3vdFvsAHnNVE/UjAwA==", - "license": "MIT", - "dependencies": { - "@types/unist": "^2.0.0", - "trough": "^2.0.0", - "unified": "^10.0.0", - "vfile": "^5.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/remark-lint-prohibited-strings/node_modules/unist-util-stringify-position": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.3.tgz", - "integrity": "sha512-k5GzIBZ/QatR8N5X2y+drfpWG8IDBzdnVj6OInRNWm1oXrzydiaAT2OQiA8DPRRZyAKb9b6I2a6PxYklZD0gKg==", - "license": "MIT", - "dependencies": { - "@types/unist": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/remark-lint-prohibited-strings/node_modules/vfile": { - "version": "5.3.7", - "resolved": "https://registry.npmjs.org/vfile/-/vfile-5.3.7.tgz", - "integrity": "sha512-r7qlzkgErKjobAmyNIkkSpizsFPYiUPuJb5pNW1RB4JcYVZhs4lIbVqk8XPk033CV/1z8ss5pkax8SuhGpcG8g==", - "license": "MIT", - "dependencies": { - "@types/unist": "^2.0.0", - "is-buffer": "^2.0.0", - "unist-util-stringify-position": "^3.0.0", - "vfile-message": "^3.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/remark-lint-prohibited-strings/node_modules/vfile-message": { - "version": "3.1.4", - "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-3.1.4.tgz", - "integrity": "sha512-fa0Z6P8HUrQN4BZaX05SIVXic+7kE3b05PWAtPuYP9QLHsLKYR7/AlLW3NtOrpXRLeawpDLMsVkmk5DG0NXgWw==", - "license": "MIT", - "dependencies": { - "@types/unist": "^2.0.0", - "unist-util-stringify-position": "^3.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, "node_modules/remark-lint-rule-style": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/remark-lint-rule-style/-/remark-lint-rule-style-4.0.0.tgz", @@ -2148,12 +2051,12 @@ } }, "node_modules/remark-preset-lint-node": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/remark-preset-lint-node/-/remark-preset-lint-node-5.1.2.tgz", - "integrity": "sha512-ukBPfLqD05AomGL+Z3tbmBCKTaEM+9Dv8Pn0r/0vok8F95Z0wj/AY70cFhm038ID1vKBD07anky11dvigDAHlw==", + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/remark-preset-lint-node/-/remark-preset-lint-node-5.2.0.tgz", + "integrity": "sha512-OYi6Pn5USK/aFkUfeZ02eU4ui8UZixZefHsDygVuzvXGhVP+fuKeYnpu30ZsiFjP/HVliFTLE6yZ1DODXvoFjQ==", "license": "MIT", "dependencies": { - "js-yaml": "^4.1.0", + "js-yaml": "^5.2.2", "remark-gfm": "^4.0.0", "remark-lint-blockquote-indentation": "^4.0.0", "remark-lint-checkbox-character-style": "^5.0.0", @@ -2176,8 +2079,8 @@ "remark-lint-no-shell-dollars": "^4.0.0", "remark-lint-no-table-indentation": "^5.0.0", "remark-lint-no-tabs": "^4.0.0", - "remark-lint-no-trailing-spaces": "^3.0.2", - "remark-lint-prohibited-strings": "^4.0.0", + "remark-lint-no-trailing-spaces": "^5.0.0", + "remark-lint-prohibited-strings": "^5.0.0", "remark-lint-rule-style": "^4.0.0", "remark-lint-strong-marker": "^4.0.0", "remark-lint-table-cell-padding": "^5.0.0", diff --git a/tools/lint-md/package.json b/tools/lint-md/package.json index f7272f493d6..5c05d342d88 100644 --- a/tools/lint-md/package.json +++ b/tools/lint-md/package.json @@ -4,7 +4,7 @@ "version": "1.0.0", "dependencies": { "remark-parse": "^11.0.0", - "remark-preset-lint-node": "^5.1.2", + "remark-preset-lint-node": "^5.2.0", "remark-stringify": "^11.0.0", "to-vfile": "^8.0.0", "unified": "^11.0.5", From 91cd10a8684b0966885d1d52eee4d73812d448d5 Mon Sep 17 00:00:00 2001 From: Philipp Dunkel Date: Tue, 27 Oct 2026 18:45:32 +0100 Subject: [PATCH 124/331] zlib: add raw content read methods to ZipEntry zipEntry.rawContent was a getter that exposed the retained buffer of an in-memory entry and returned null for a file-backed or streaming one, so the still-compressed bytes of a member read through ZipFile could not be obtained at all. Replace it with rawContent(), rawContentSync() and rawContentIterator(), which mirror content(), contentSync() and contentIterator() but return the bytes as stored, without decompressing or verifying them. They work for every entry that has readable content, return caller-owned buffers from the buffered variants, and accept a maxSize bound on the compressed size. Signed-off-by: Philipp Dunkel PR-URL: https://github.com/nodejs/node/pull/66801 Reviewed-By: Matteo Collina Reviewed-By: James M Snell --- doc/api/zlib.md | 59 +++++++++-- lib/internal/zip/entry.js | 54 +++++++++- test/parallel/test-zlib-zip-raw-content.js | 114 +++++++++++++++++++++ test/parallel/test-zlib-zip-vfs.js | 2 +- test/parallel/test-zlib-zip-writable.js | 7 +- test/parallel/test-zlib-zip.js | 2 +- 6 files changed, 221 insertions(+), 17 deletions(-) create mode 100644 test/parallel/test-zlib-zip-raw-content.js diff --git a/doc/api/zlib.md b/doc/api/zlib.md index b4cf51c5b3f..713a28133ff 100644 --- a/doc/api/zlib.md +++ b/doc/api/zlib.md @@ -1521,8 +1521,7 @@ which streaming never makes. Output is still bounded per chunk to the declared uncompressed size; pass `maxSize` to impose an explicit ceiling. For an in-memory entry stored without compression, the yielded chunks are -zero-copy views of the entry's retained content (see -[`zipEntry.rawContent`][]); do not mutate them. +zero-copy views of the entry's retained content; do not mutate them. The yielded chunks are **provisional until the iterator completes**. CRC-32 verification (and the final declared-size check) can only run once every byte @@ -1665,20 +1664,56 @@ The entry's raw name bytes, before any character decoding. Useful when the archive's names are in an encoding other than UTF-8 or CP437 and the caller wants to decode them itself. -### `zipEntry.rawContent` +### `zipEntry.rawContent([options])` -* Type: {Buffer|null} +* `options` {Object} + * `maxSize` {number} Reject content with more than this many compressed + bytes, before allocating anything. **Default:** + [`zlib.getMaxZipContentSize()`][]. +* Returns: {Promise} Fulfilled with a {Buffer} containing the entry's raw + content: the bytes as stored in the archive, still compressed if + [`zipEntry.compressed`][] is `true`. The buffer is a fresh copy that shares + no memory with the archive or with data the entry was created from. + +The content is neither decompressed nor checked against +[`zipEntry.crc32`][], which covers the uncompressed bytes. + +Throws an [`ERR_ZIP_ENTRY_TOO_LARGE`][] error if the entry's compressed size +exceeds `maxSize`, and an [`ERR_INVALID_STATE`][] error for a streaming entry +([`zlib.ZipEntry.createStream()`][]) whose content is not yet available. + +### `zipEntry.rawContentSync([options])` + + + +* `options` {Object} See [`zipEntry.rawContent()`][]. +* Returns: {Buffer} The entry's raw content. -The entry's raw (still compressed, if applicable) content when it is held in -memory, or `null` when there is no in-memory buffer to expose - for an entry -created with [`zlib.ZipEntry.createStream()`][], or a file-backed entry -returned by [`zipFile.get()`][], whose bytes are read from disk on demand -rather than retained. Use [`zipEntry.content()`][] or -[`zipEntry.contentIterator()`][] to read a file-backed entry. +The synchronous version of [`zipEntry.rawContent()`][]. + +### `zipEntry.rawContentIterator([options])` + + + +* `options` {Object} + * `maxSize` {number} Reject content with more than this many compressed + bytes, before reading anything. **Default:** no limit. +* Returns: {AsyncIterator} of {Buffer} chunks of the entry's raw content. + +Unlike [`zipEntry.rawContent()`][], this does not buffer the whole member in +memory. For a file-backed entry (one returned by [`zipFile.get()`][]) the +bytes are read from disk as the iterator is consumed and nothing is retained; +the entry is valid only while its `ZipFile` is open. For an in-memory entry, +the yielded chunk is a zero-copy view of the entry's retained content; do not +mutate it. ### `zipEntry.size` @@ -3461,15 +3496,17 @@ Create a Zstandard decompression transform. [`zipBuffer.comment`]: #zipbuffercomment [`zipBuffer.toBuffer()`]: #zipbuffertobufferoptions [`zipBuffer.toBufferSync()`]: #zipbuffertobuffersyncoptions +[`zipEntry.compressed`]: #zipentrycompressed [`zipEntry.content()`]: #zipentrycontentoptions [`zipEntry.contentIterator()`]: #zipentrycontentiteratoroptions [`zipEntry.contentSync()`]: #zipentrycontentsyncoptions +[`zipEntry.crc32`]: #zipentrycrc32 [`zipEntry.isDirectory`]: #zipentryisdirectory [`zipEntry.isSymlink`]: #zipentryissymlink [`zipEntry.modified`]: #zipentrymodified [`zipEntry.nameBuffer`]: #zipentrynamebuffer [`zipEntry.name`]: #zipentryname -[`zipEntry.rawContent`]: #zipentryrawcontent +[`zipEntry.rawContent()`]: #zipentryrawcontentoptions [`zipFile.add()`]: #zipfileaddfilename-data-options [`zipFile.addEntry()`]: #zipfileaddentryentry [`zipFile.close()`]: #zipfileclose diff --git a/lib/internal/zip/entry.js b/lib/internal/zip/entry.js index c9d46c9688a..5ac649c4f48 100644 --- a/lib/internal/zip/entry.js +++ b/lib/internal/zip/entry.js @@ -222,7 +222,6 @@ class ZipEntry { // Whether the content is stored in compressed form, whatever the method. get compressed() { return this.method !== METHOD_STORE; } - get rawContent() { return this.#content; } get method() { return this.#meta ? this.#meta.method : this.#central.compressionMethod; } @@ -664,6 +663,59 @@ class ZipEntry { }, options); } + #assertRawWithin(maxSize) { + const declared = this.compressedSize; + if (declared > maxSize) { + throw new ERR_ZIP_ENTRY_TOO_LARGE( + `entry ${JSONStringify(this.name)} declares ${declared} compressed ` + + `bytes, exceeding the ${maxSize} byte limit`); + } + } + + /** + * Reads the entry's raw (still-compressed) content into a single `Buffer`, + * without decompressing or CRC-32-verifying it. + * @param {{ maxSize?: number }} [options] + * @returns {Promise} + */ + async rawContent(options) { + this.#assertRawWithin(options?.maxSize ?? getMaxZipContentSize()); + const handle = this.#fd; + if (handle === null) return Buffer.from(this.#inMemoryCompressed()); + if (handle.closing) { + throw new ERR_INVALID_STATE( + 'cannot read a ZipEntry after its backing ZipFile has been closed'); + } + handle.reads++; + try { + return await this.#compressedBytes(); + } finally { + endHandleRead(handle); + } + } + + /** + * The synchronous counterpart of `rawContent()`. + * @param {{ maxSize?: number }} [options] + * @returns {Buffer} + */ + rawContentSync(options) { + this.#assertRawWithin(options?.maxSize ?? getMaxZipContentSize()); + const compressed = this.#compressedBytesSync(); + return this.#fd === null ? Buffer.from(compressed) : compressed; + } + + /** + * Yields the entry's raw (still-compressed) content as a bounded-memory + * async iterator of `Buffer` chunks, without decompressing or verifying it. + * @param {{ maxSize?: number }} [options] + * @returns {AsyncGenerator} + */ + rawContentIterator(options) { + if (options?.maxSize !== undefined) this.#assertRawWithin(options.maxSize); + return this.#rawSource(); + } + // Synchronous serialization: emit the local file header (sec. 4.3.7) // followed by the raw (already-compressed) content bytes. Streaming // (source-backed) entries cannot be serialized this way. diff --git a/test/parallel/test-zlib-zip-raw-content.js b/test/parallel/test-zlib-zip-raw-content.js new file mode 100644 index 00000000000..f40c9919859 --- /dev/null +++ b/test/parallel/test-zlib-zip-raw-content.js @@ -0,0 +1,114 @@ +'use strict'; + +require('../common'); + +const assert = require('node:assert'); +const zlib = require('node:zlib'); +const fs = require('node:fs/promises'); +const path = require('node:path'); +const tmpdir = require('../common/tmpdir'); +const { test } = require('node:test'); + +tmpdir.refresh(); + +async function buildArchive(entries) { + const chunks = []; + for await (const chunk of zlib.createZipArchive(entries)) chunks.push(chunk); + return Buffer.concat(chunks); +} + +async function collect(iterator) { + const chunks = []; + for await (const chunk of iterator) chunks.push(chunk); + return Buffer.concat(chunks); +} + +const text = Buffer.from('raw content '.repeat(500)); + +function decode(entry, raw) { + switch (entry.method) { + case 0: return raw; + case 8: return zlib.inflateRawSync(raw); + case 93: return zlib.zstdDecompressSync(raw); + } + assert.fail(`unexpected method ${entry.method}`); +} + +async function assertRawReads(entry, expected) { + const raw = await entry.rawContent(); + assert.strictEqual(raw.length, entry.compressedSize); + assert.deepStrictEqual(decode(entry, raw), expected); + assert.deepStrictEqual(entry.rawContentSync(), raw); + assert.deepStrictEqual(await collect(entry.rawContentIterator()), raw); +} + +test('in-memory entries expose their raw bytes for every method', async () => { + for (const method of ['deflate', 'store', 'zstd']) { + const entry = await zlib.ZipEntry.create(`${method}.txt`, text, { method }); + assert.strictEqual(entry.compressed, method !== 'store'); + await assertRawReads(entry, text); + } +}); + +test('parsed and file-backed entries expose their raw bytes', async () => { + const archive = await buildArchive([ + await zlib.ZipEntry.create('d.txt', text), + await zlib.ZipEntry.create('s.txt', text, { method: 'store' }), + await zlib.ZipEntry.create('z.txt', text, { method: 'zstd' }), + await zlib.ZipEntry.create('empty.txt', Buffer.alloc(0)), + ]); + for (const entry of zlib.ZipEntry.read(archive)) { + await assertRawReads(entry, entry.name === 'empty.txt' ? Buffer.alloc(0) : text); + } + + const dir = await fs.mkdtemp(path.join(tmpdir.path, 'zlib-zip-raw-')); + const filePath = path.join(dir, 'archive.zip'); + await fs.writeFile(filePath, archive); + const zip = await zlib.ZipFile.open(filePath); + let entry; + try { + for (const name of zip.keys()) { + entry = await zip.get(name); + await assertRawReads(entry, name === 'empty.txt' ? Buffer.alloc(0) : text); + } + } finally { + await zip.close(); + } + await assert.rejects(entry.rawContent(), { code: 'ERR_INVALID_STATE' }); + assert.throws(() => entry.rawContentSync(), { code: 'ERR_INVALID_STATE' }); + await assert.rejects(collect(entry.rawContentIterator()), { code: 'ERR_INVALID_STATE' }); +}); + +test('rawContent() and rawContentSync() return caller-owned copies', async () => { + const data = Buffer.from('stored bytes'); + const entry = await zlib.ZipEntry.create('s.txt', data, { method: 'store' }); + const raw = await entry.rawContent(); + raw.fill(0); + const rawSync = entry.rawContentSync(); + assert.deepStrictEqual(rawSync, data); + rawSync.fill(0); + assert.deepStrictEqual(await entry.content(), data); + assert.deepStrictEqual(data, Buffer.from('stored bytes')); +}); + +test('maxSize bounds the compressed size', async () => { + const entry = await zlib.ZipEntry.create('s.txt', text, { method: 'store' }); + const limit = { maxSize: text.length - 1 }; + await assert.rejects(entry.rawContent(limit), { code: 'ERR_ZIP_ENTRY_TOO_LARGE' }); + assert.throws(() => entry.rawContentSync(limit), { code: 'ERR_ZIP_ENTRY_TOO_LARGE' }); + assert.throws(() => entry.rawContentIterator(limit), { code: 'ERR_ZIP_ENTRY_TOO_LARGE' }); + + const exact = { maxSize: text.length }; + assert.deepStrictEqual(await entry.rawContent(exact), text); + assert.deepStrictEqual(entry.rawContentSync(exact), text); + assert.deepStrictEqual(await collect(entry.rawContentIterator(exact)), text); +}); + +test('a pending streaming entry has no raw content yet', async () => { + async function* source() { yield text; } + const entry = zlib.ZipEntry.createStream('s.txt', source()); + await assert.rejects(entry.rawContent(), { code: 'ERR_INVALID_STATE' }); + assert.throws(() => entry.rawContentSync(), { code: 'ERR_INVALID_STATE' }); + assert.throws(() => entry.rawContentIterator(), { code: 'ERR_INVALID_STATE' }); + await entry[Symbol.asyncDispose](); +}); diff --git a/test/parallel/test-zlib-zip-vfs.js b/test/parallel/test-zlib-zip-vfs.js index 213dcad0f28..75d2f72e34b 100644 --- a/test/parallel/test-zlib-zip-vfs.js +++ b/test/parallel/test-zlib-zip-vfs.js @@ -49,7 +49,7 @@ test('ZipFile.open() reads a VFS-backed archive through an async virtual fd', as // A lazy, file-backed entry: it retains no content and reads straight // from the virtual fd on demand. const a = await zf.get('a.txt'); - assert.strictEqual(a.rawContent, null); + assert.strictEqual((await a.rawContent()).length, a.compressedSize); assert.strictEqual((await a.content()).toString(), 'hello vfs'); assert.strictEqual(await zf.get('a.txt'), a); // Cached handle identity diff --git a/test/parallel/test-zlib-zip-writable.js b/test/parallel/test-zlib-zip-writable.js index 9e036f62de3..5beb4751ad7 100644 --- a/test/parallel/test-zlib-zip-writable.js +++ b/test/parallel/test-zlib-zip-writable.js @@ -150,6 +150,7 @@ test('ZipFile addEntry() promotes a spent streaming entry into a readable file-b ]); try { const zip = await zlib.ZipFile.open(filePath, { writable: true }); + let mem; try { const payload = 'streamed payload'.repeat(64); async function* source() { @@ -177,13 +178,13 @@ test('ZipFile addEntry() promotes a spent streaming entry into a readable file-b assert.strictEqual(copy.get('s.txt').crc32 >>> 0, streamEntry.crc32 >>> 0); // An in-memory entry added alongside keeps its own buffer (not promoted). - const mem = await zlib.ZipEntry.create('m.txt', Buffer.from('in memory')); + mem = await zlib.ZipEntry.create('m.txt', Buffer.from('in memory')); await zip.addEntry(mem); - assert.deepStrictEqual(mem.rawContent, mem.rawContent); // still a Buffer - assert.notStrictEqual(mem.rawContent, null); } finally { await zip.close(); } + // Still readable once the ZipFile is closed, so it was not promoted. + assert.strictEqual((await mem.content()).toString(), 'in memory'); // The bytes persisted correctly and re-open sees the streamed member. const reread = await zlib.ZipFile.open(filePath); diff --git a/test/parallel/test-zlib-zip.js b/test/parallel/test-zlib-zip.js index 910c17122d8..a83159a72b8 100644 --- a/test/parallel/test-zlib-zip.js +++ b/test/parallel/test-zlib-zip.js @@ -83,7 +83,7 @@ test('explicit store option is honored even for compressible data', async () => const data = Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'); const entry = await zlib.ZipEntry.create('stored.txt', data, { method: 'store' }); assert.strictEqual(entry.method, 0); - assert.deepStrictEqual(entry.rawContent, data); + assert.deepStrictEqual(await entry.rawContent(), data); }); test('the zstd method compresses and round-trips through an archive', async () => { From e68efadc33e2b6405a5da343521bef6f735db2f7 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Sun, 25 Oct 2026 09:47:47 +0100 Subject: [PATCH 125/331] tools: do not lint GYP JS files They are not maintained in this repository. Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/66988 Reviewed-By: Antoine du Hamel Reviewed-By: Colin Ihrig Reviewed-By: Luigi Pinca --- eslint.config.mjs | 1 + 1 file changed, 1 insertion(+) diff --git a/eslint.config.mjs b/eslint.config.mjs index c19e8f3cf46..9c4ad8f0565 100644 --- a/eslint.config.mjs +++ b/eslint.config.mjs @@ -57,6 +57,7 @@ export default [ 'lib/punycode.js', 'test/.tmp.*/**', 'test/addons/??_*', + 'tools/gyp/**', // We want to lint only a few specific fixtures folders 'test/fixtures/*', From d14f217a90bac66695241175479a567f87fe3b6a Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Sun, 25 Oct 2026 00:54:19 +0000 Subject: [PATCH 126/331] tools: update gyp-next to 0.22.4 PR-URL: https://github.com/nodejs/node/pull/66988 Reviewed-By: Antoine du Hamel Reviewed-By: Colin Ihrig Reviewed-By: Luigi Pinca --- tools/gyp/CHANGELOG.md | 10 ++++ ...itlint.config.mjs => commitlint.config.js} | 0 tools/gyp/pylib/gyp/common.py | 8 ++- tools/gyp/pylib/gyp/common_test.py | 12 +++++ tools/gyp/pylib/gyp/generator/make.py | 40 +++++++++++--- tools/gyp/pylib/gyp/generator/ninja.py | 24 +++++++-- tools/gyp/pylib/gyp/xcode_emulation.py | 5 +- tools/gyp/pyproject.toml | 2 +- tools/gyp/test/fixtures/pch_action.h | 1 + tools/gyp/test/fixtures/pch_asm.S | 2 + tools/gyp/test/fixtures/pch_dep.h | 1 + tools/gyp/test/fixtures/pch_prefix.gyp | 47 +++++++++++++++++ tools/gyp/test/integration_test.py | 52 +++++++++++++++++++ 13 files changed, 189 insertions(+), 15 deletions(-) rename tools/gyp/{commitlint.config.mjs => commitlint.config.js} (100%) create mode 100644 tools/gyp/test/fixtures/pch_action.h create mode 100644 tools/gyp/test/fixtures/pch_asm.S create mode 100644 tools/gyp/test/fixtures/pch_dep.h create mode 100644 tools/gyp/test/fixtures/pch_prefix.gyp diff --git a/tools/gyp/CHANGELOG.md b/tools/gyp/CHANGELOG.md index e590b6fdb8c..c0f014ba294 100644 --- a/tools/gyp/CHANGELOG.md +++ b/tools/gyp/CHANGELOG.md @@ -1,5 +1,15 @@ # Changelog +## [0.22.4](https://github.com/nodejs/gyp-next/compare/v0.22.3...v0.22.4) (2026-10-20) + + +### Bug Fixes + +* avoid deprecated os.path.commonprefix() in RelativePath ([#365](https://github.com/nodejs/gyp-next/issues/365)) ([428343e](https://github.com/nodejs/gyp-next/commit/428343ee58c05e7b817d3603688fe7cdb7a10846)), closes [#364](https://github.com/nodejs/gyp-next/issues/364) +* build precompiled headers after generated inputs ([#360](https://github.com/nodejs/gyp-next/issues/360)) ([d8888e9](https://github.com/nodejs/gyp-next/commit/d8888e932040eae90604b77ec6030a25714f0077)) +* include the prefix header itself in assembly sources ([#360](https://github.com/nodejs/gyp-next/issues/360)) ([d8888e9](https://github.com/nodejs/gyp-next/commit/d8888e932040eae90604b77ec6030a25714f0077)) +* **make:** compile the C prefix header with CFLAGS ([#360](https://github.com/nodejs/gyp-next/issues/360)) ([d8888e9](https://github.com/nodejs/gyp-next/commit/d8888e932040eae90604b77ec6030a25714f0077)) + ## [0.22.3](https://github.com/nodejs/gyp-next/compare/v0.22.2...v0.22.3) (2026-09-29) diff --git a/tools/gyp/commitlint.config.mjs b/tools/gyp/commitlint.config.js similarity index 100% rename from tools/gyp/commitlint.config.mjs rename to tools/gyp/commitlint.config.js diff --git a/tools/gyp/pylib/gyp/common.py b/tools/gyp/pylib/gyp/common.py index 223ce47b003..c034f69c0af 100644 --- a/tools/gyp/pylib/gyp/common.py +++ b/tools/gyp/pylib/gyp/common.py @@ -157,8 +157,12 @@ def RelativePath(path, relative_to, follow_path_symlink=True): path_split = path.split(os.path.sep) relative_to_split = relative_to.split(os.path.sep) - # Determine how much of the prefix the two paths share. - prefix_len = len(os.path.commonprefix([path_split, relative_to_split])) + # Determine how much of the path prefix the two paths share. + prefix_len = 0 + for path_part, relative_to_part in zip(path_split, relative_to_split): + if path_part != relative_to_part: + break + prefix_len += 1 # Put enough ".." components to back up out of relative_to to the common # prefix, and then append the part of path_split after the common prefix. diff --git a/tools/gyp/pylib/gyp/common_test.py b/tools/gyp/pylib/gyp/common_test.py index b5988816c04..d3e860534de 100755 --- a/tools/gyp/pylib/gyp/common_test.py +++ b/tools/gyp/pylib/gyp/common_test.py @@ -182,5 +182,17 @@ def mock_run(env, defines_stdout, expected_cmd, throws=False): assert flavor6 == "wasi" +class TestRelativePath(unittest.TestCase): + def test_common_parent(self): + assert gyp.common.RelativePath("/a/b", "/a/c") == os.path.join("..", "b") + + def test_only_root_in_common(self): + """Paths whose only common ancestor is the filesystem root.""" + assert gyp.common.RelativePath("/a/b", "/c") == os.path.join("..", "a", "b") + + def test_same_path(self): + assert gyp.common.RelativePath("/a/b", "/a/b") == "" + + if __name__ == "__main__": unittest.main() diff --git a/tools/gyp/pylib/gyp/generator/make.py b/tools/gyp/pylib/gyp/generator/make.py index 16b6f4e80b1..c47050a5228 100644 --- a/tools/gyp/pylib/gyp/generator/make.py +++ b/tools/gyp/pylib/gyp/generator/make.py @@ -603,7 +603,7 @@ def CalculateGeneratorInputInfo(params): # Commands for precompiled header files. quiet_cmd_pch_c = CXX($(TOOLSET)) $@ -cmd_pch_c = $(CC.$(TOOLSET)) $(GYP_PCH_CFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $< +cmd_pch_c = $(CC.$(TOOLSET)) $(GYP_PCH_CFLAGS) $(DEPFLAGS) $(CFLAGS.$(TOOLSET)) -c -o $@ $< quiet_cmd_pch_cc = CXX($(TOOLSET)) $@ cmd_pch_cc = $(CC.$(TOOLSET)) $(GYP_PCH_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $< quiet_cmd_pch_m = CXX($(TOOLSET)) $@ @@ -1485,13 +1485,29 @@ def WriteSources( # See "Target-specific Variable Values" in the GNU Make manual.""" ) self.WriteLn("$(OBJS): TOOLSET := $(TOOLSET)") - self.WriteLn( - "$(OBJS): GYP_CFLAGS := " + gyp_cflags = ( "$(DEFS_$(BUILDTYPE)) " "$(INCS_$(BUILDTYPE)) " - "%s " % precompiled_header.GetInclude("c") + "$(CFLAGS_$(BUILDTYPE)) " + "%s " + "$(CFLAGS_$(BUILDTYPE)) " "$(CFLAGS_C_$(BUILDTYPE))" ) + self.WriteLn( + "$(OBJS): GYP_CFLAGS := " + + gyp_cflags % precompiled_header.GetInclude("c") + ) + asm_objs = [ + obj + for source, obj in zip(compilable, objs) + if source.endswith((".s", ".S")) + ] + if asm_objs and precompiled_header.compile_headers: + # Assembly is compiled with GYP_CFLAGS too, but without a gch + # for it, the -include of the C one fails. + self.WriteLn( + "%s: GYP_CFLAGS := " % " ".join(asm_objs) + + gyp_cflags % precompiled_header.GetInclude("asm") + ) self.WriteLn( "$(OBJS): GYP_CXXFLAGS := " "$(DEFS_$(BUILDTYPE)) " @@ -1521,7 +1537,9 @@ def WriteSources( "$(CFLAGS_OBJCC_$(BUILDTYPE))" ) - self.WritePchTargets(precompiled_header.GetPchBuildCommands()) + self.WritePchTargets( + precompiled_header.GetPchBuildCommands(), deps + extra_outputs + ) # If there are any object files in our input file list, link them into our # output. @@ -1529,8 +1547,13 @@ def WriteSources( self.WriteLn() - def WritePchTargets(self, pch_commands): - """Writes make rules to compile prefix headers.""" + def WritePchTargets(self, pch_commands, order_only_deps): + """Writes make rules to compile prefix headers. + + A prefix header may include generated headers, so like the object files, + the gch files are built after |order_only_deps|: the target's dependencies + and the outputs of its actions and rules. + """ if not pch_commands: return @@ -1547,6 +1570,9 @@ def WritePchTargets(self, pch_commands): "m": "GYP_PCH_OBJCFLAGS", "mm": "GYP_PCH_OBJCXXFLAGS", }[lang] + if order_only_deps: + self.WriteMakeRule([gch], order_only_deps, order_only=True) + self.WriteLn(f"{gch}: TOOLSET := $(TOOLSET)") self.WriteLn( f"{gch}: {var_name} := {lang_flag} " + "$(DEFS_$(BUILDTYPE)) " "$(INCS_$(BUILDTYPE)) " diff --git a/tools/gyp/pylib/gyp/generator/ninja.py b/tools/gyp/pylib/gyp/generator/ninja.py index 3ceaf470cec..49ce563ea7a 100644 --- a/tools/gyp/pylib/gyp/generator/ninja.py +++ b/tools/gyp/pylib/gyp/generator/ninja.py @@ -1253,6 +1253,12 @@ def WriteSourcesForArch( cflags_cc, self.ExpandSpecial, ) + elif ext in ("s", "S") and precompiled_header.compile_headers: + # Assembly gets $cflags_pch_c too, but without a gch for it, the + # -include of the C one fails. + variables = [ + ("cflags_pch_c", precompiled_header.GetInclude("asm", arch)) + ] ninja_file.build( output, command, @@ -1274,13 +1280,17 @@ def WriteSourcesForArch( ], ) - self.WritePchTargets(ninja_file, pch_commands) + self.WritePchTargets(ninja_file, pch_commands, predepends) ninja_file.newline() return outputs - def WritePchTargets(self, ninja_file, pch_commands): - """Writes ninja rules to compile prefix headers.""" + def WritePchTargets(self, ninja_file, pch_commands, predepends): + """Writes ninja rules to compile prefix headers. + + A prefix header may include generated headers, so like the object files, + the gch files are built after |predepends|. + """ if not pch_commands: return @@ -1299,7 +1309,13 @@ def WritePchTargets(self, ninja_file, pch_commands): "mm": "objcxx", } cmd = map.get(lang) - ninja_file.build(gch, cmd, input, variables=[(var_name, lang_flag)]) + ninja_file.build( + gch, + cmd, + input, + order_only=predepends, + variables=[(var_name, lang_flag)], + ) def WriteLink(self, spec, config_name, config, link_deps, compile_deps): """Write out a link step. Fills out target.binary.""" diff --git a/tools/gyp/pylib/gyp/xcode_emulation.py b/tools/gyp/pylib/gyp/xcode_emulation.py index d13eaa9af24..7ae3c4f9c42 100644 --- a/tools/gyp/pylib/gyp/xcode_emulation.py +++ b/tools/gyp/pylib/gyp/xcode_emulation.py @@ -1429,7 +1429,10 @@ def _CompiledHeader(self, lang, arch): return h def GetInclude(self, lang, arch=None): - """Gets the cflags to include the prefix header for language |lang|.""" + """Gets the cflags to include the prefix header for language |lang|. + + There is no compiled header for assembly ('asm'), which includes the + prefix header itself.""" if self.compile_headers and lang in self.compiled_headers: return "-include %s" % self._CompiledHeader(lang, arch) elif self.header: diff --git a/tools/gyp/pyproject.toml b/tools/gyp/pyproject.toml index 9ce52a6785e..71c24110cd4 100644 --- a/tools/gyp/pyproject.toml +++ b/tools/gyp/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "gyp-next" -version = "0.22.3" +version = "0.22.4" authors = [ { name="Node.js contributors", email="ryzokuken@disroot.org" }, ] diff --git a/tools/gyp/test/fixtures/pch_action.h b/tools/gyp/test/fixtures/pch_action.h new file mode 100644 index 00000000000..5e3d629b3e2 --- /dev/null +++ b/tools/gyp/test/fixtures/pch_action.h @@ -0,0 +1 @@ +#include "action_generated.h" diff --git a/tools/gyp/test/fixtures/pch_asm.S b/tools/gyp/test/fixtures/pch_asm.S new file mode 100644 index 00000000000..84d6417a91d --- /dev/null +++ b/tools/gyp/test/fixtures/pch_asm.S @@ -0,0 +1,2 @@ +// Assembly gets the prefix header too, but has no precompiled header. +.text diff --git a/tools/gyp/test/fixtures/pch_dep.h b/tools/gyp/test/fixtures/pch_dep.h new file mode 100644 index 00000000000..7df152ab9b1 --- /dev/null +++ b/tools/gyp/test/fixtures/pch_dep.h @@ -0,0 +1 @@ +#include "dep_generated.h" diff --git a/tools/gyp/test/fixtures/pch_prefix.gyp b/tools/gyp/test/fixtures/pch_prefix.gyp new file mode 100644 index 00000000000..c505559c761 --- /dev/null +++ b/tools/gyp/test/fixtures/pch_prefix.gyp @@ -0,0 +1,47 @@ +{ + 'targets': [ + { + # The prefix header includes a header generated by the target's action. + 'target_name': 'pch_action', + 'type': 'static_library', + 'sources': [ 'pch.cc', 'pch_asm.S' ], + 'include_dirs': [ '<(SHARED_INTERMEDIATE_DIR)' ], + 'xcode_settings': { + 'GCC_PREFIX_HEADER': 'pch_action.h', + 'GCC_PRECOMPILE_PREFIX_HEADER': 'YES', + }, + 'actions': [ + { + 'action_name': 'generate_action_header', + 'inputs': [], + 'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/action_generated.h' ], + 'action': [ 'touch', '<@(_outputs)' ], + }, + ], + }, + { + # The prefix header includes a header generated by a dependency. + 'target_name': 'pch_dep', + 'type': 'static_library', + 'dependencies': [ 'generate_dep_header' ], + 'sources': [ 'pch.cc', 'pch_asm.S' ], + 'include_dirs': [ '<(SHARED_INTERMEDIATE_DIR)' ], + 'xcode_settings': { + 'GCC_PREFIX_HEADER': 'pch_dep.h', + 'GCC_PRECOMPILE_PREFIX_HEADER': 'YES', + }, + }, + { + 'target_name': 'generate_dep_header', + 'type': 'none', + 'actions': [ + { + 'action_name': 'generate_dep_header', + 'inputs': [], + 'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/dep_generated.h' ], + 'action': [ 'touch', '<@(_outputs)' ], + }, + ], + }, + ], +} diff --git a/tools/gyp/test/integration_test.py b/tools/gyp/test/integration_test.py index 8244708a9bd..c93c8669482 100644 --- a/tools/gyp/test/integration_test.py +++ b/tools/gyp/test/integration_test.py @@ -5,6 +5,7 @@ import os import re import shutil +import subprocess import sys import unittest @@ -13,6 +14,7 @@ fixture_dir = os.path.join(os.path.dirname(__file__), "fixtures") gyp_file = os.path.join(fixture_dir, "integration.gyp") pch_gyp_file = os.path.join(fixture_dir, "pch.gyp") +pch_prefix_gyp_file = os.path.join(fixture_dir, "pch_prefix.gyp") if sys.platform == "win32": sysname = sys.platform @@ -80,6 +82,56 @@ def test_cmake(self) -> None: assert_file(self, "out/Default/CMakeLists.txt", "cmake/CMakeLists.txt") +class TestGypMac(unittest.TestCase): + # The prefix header of each target includes a header generated by its + # action (pch_action) or by its dependency (pch_dep). Each output is built + # on its own from a clean build, so it fails unless it waits for that header. + pch_targets = ("pch_action", "pch_dep") + pch_langs = ("c", "cc", "m", "mm") + + def setUp(self) -> None: + if sysname != "darwin": + self.skipTest("macOS-only test") + shutil.rmtree(os.path.join(fixture_dir, "out"), ignore_errors=True) + + def test_make_precompiled_prefix_header(self) -> None: + rc = gyp.main( + [ + "-f", + "make", + "--depth", + fixture_dir, + "--generator-output", + "out", + pch_prefix_gyp_file, + ] + ) + assert rc == 0 + + makefile_dir = os.path.join(fixture_dir, "out") + # CXXFLAGS that a C compile rejects check the C gch doesn't get them. + env = {**os.environ, "CXXFLAGS": "-std=c++17"} + for target in self.pch_targets: + obj = f"out/Default/obj.target/{target}" + gchs = [f"{obj}/pch-{lang}/{target}.h.gch" for lang in self.pch_langs] + for output in [*gchs, f"{obj}/pch_asm.o"]: + shutil.rmtree(os.path.join(makefile_dir, "out"), ignore_errors=True) + subprocess.run( + ["make", "-C", makefile_dir, output], env=env, check=True + ) + + def test_ninja_precompiled_prefix_header(self) -> None: + rc = gyp.main(["-f", "ninja", "--depth", fixture_dir, pch_prefix_gyp_file]) + assert rc == 0 + + build_dir = os.path.join(fixture_dir, "out", "Default") + for target in self.pch_targets: + gchs = [f"obj/{target}.{target}.h-{lang}.gch" for lang in self.pch_langs] + for output in [*gchs, f"obj/{target}.pch_asm.o"]: + subprocess.run(["ninja", "-C", build_dir, "-t", "clean"], check=True) + subprocess.run(["ninja", "-C", build_dir, output], check=True) + + class TestGypWindows(unittest.TestCase): def setUp(self) -> None: if sys.platform != "win32": From 62f8c7485e5fa297af6ace93c4a03895e2ead3b7 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Tue, 27 Oct 2026 17:17:42 -0400 Subject: [PATCH 127/331] test: update test426-fixtures to fae1fa49815813088c433e8486e330e8d953a44 PR-URL: https://github.com/nodejs/node/pull/66815 Reviewed-By: Colin Ihrig Reviewed-By: Luigi Pinca Reviewed-By: Antoine du Hamel --- .../fixtures/test426/.github/workflows/ci.yml | 70 +++ test/fixtures/test426/.gitignore | 6 + test/fixtures/test426/README.md | 39 ++ .../debug-id/debug-id-index-section.map | 4 +- .../debug-id-index-section.map.golden | 2 +- .../decoding/debug-id/debug-id-index.map | 4 +- .../test426/decoding/debug-id/debug-id.d.ts | 2 +- test/fixtures/test426/npm-package/README.md | 5 + .../test426/npm-package/package.template.json | 26 ++ .../test426/npm-package/types/index.d.ts | 2 + .../test426/npm-package/types/modules.d.ts | 14 + .../test426/npm-package/types/types.d.ts | 90 ++++ test/fixtures/test426/package-lock.json | 405 ++++++++++++++++++ test/fixtures/test426/package.json | 11 + .../test426/scripts/build-npm-package.js | 240 +++++++++++ test/fixtures/test426/scripts/check-types.js | 150 +++++++ test/test426/README.md | 2 +- 17 files changed, 1065 insertions(+), 7 deletions(-) create mode 100644 test/fixtures/test426/.github/workflows/ci.yml create mode 100644 test/fixtures/test426/.gitignore create mode 100644 test/fixtures/test426/npm-package/README.md create mode 100644 test/fixtures/test426/npm-package/package.template.json create mode 100644 test/fixtures/test426/npm-package/types/index.d.ts create mode 100644 test/fixtures/test426/npm-package/types/modules.d.ts create mode 100644 test/fixtures/test426/npm-package/types/types.d.ts create mode 100644 test/fixtures/test426/package-lock.json create mode 100644 test/fixtures/test426/package.json create mode 100644 test/fixtures/test426/scripts/build-npm-package.js create mode 100644 test/fixtures/test426/scripts/check-types.js diff --git a/test/fixtures/test426/.github/workflows/ci.yml b/test/fixtures/test426/.github/workflows/ci.yml new file mode 100644 index 00000000000..72d33dddb54 --- /dev/null +++ b/test/fixtures/test426/.github/workflows/ci.yml @@ -0,0 +1,70 @@ +name: CI + +on: + push: + branches: [main] + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + build: + name: Validate tests and build npm package + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + with: + # Fetch all to count number of commits and compute pkg version + fetch-depth: 0 + - uses: actions/setup-node@v6 + with: + node-version: lts/* + cache: npm + - name: Install dependencies + run: npm ci + - name: Build npm package + run: node scripts/build-npm-package.js + - name: Check that JSON files match their TypeScript types + run: node scripts/check-types.js + - name: Pack npm package + run: mkdir -p dist && npm pack ./npm-package --pack-destination dist + - name: Upload package tarball + uses: actions/upload-artifact@v7 + with: + name: npm-package + path: dist/*.tgz + if-no-files-found: error + retention-days: 7 + + publish: + name: Publish to npm + needs: build + if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main' && github.repository == 'tc39/source-map-tests' + runs-on: ubuntu-latest + permissions: + contents: read + id-token: write # for npm trusted publishing + concurrency: + group: npm-publish + cancel-in-progress: false + steps: + - uses: actions/checkout@v6 + with: + fetch-depth: 0 + - uses: actions/setup-node@v6 + with: + node-version: lts/* + registry-url: https://registry.npmjs.org + - name: Build npm package + run: node scripts/build-npm-package.js + - name: Publish + run: | + name=$(node -p "require('./npm-package/package.json').name") + version=$(node -p "require('./npm-package/package.json').version") + if [ -n "$(npm view "$name@$version" version 2>/dev/null)" ]; then + echo "$name@$version is already published, skipping." + else + npm publish ./npm-package --access public + fi diff --git a/test/fixtures/test426/.gitignore b/test/fixtures/test426/.gitignore new file mode 100644 index 00000000000..a311c506246 --- /dev/null +++ b/test/fixtures/test426/.gitignore @@ -0,0 +1,6 @@ +npm-package/* +!npm-package/README.md +!npm-package/package.template.json +!npm-package/types/ +node_modules/ +.tmp/ diff --git a/test/fixtures/test426/README.md b/test/fixtures/test426/README.md index 1eb2818fcfa..98dcb05da24 100644 --- a/test/fixtures/test426/README.md +++ b/test/fixtures/test426/README.md @@ -58,3 +58,42 @@ More information about running Chrome Devtools without building Chromium can be Follow the [running Node.js tests guide](https://github.com/nodejs/node/blob/main/BUILDING.md#running-tests) to build Node.js and run tests locally. Read more about running the source map tests at [here](https://github.com/nodejs/node/tree/main/test/test426). + +## npm package + +The test cases are published to npm as [`@tc39/source-map-tests`](https://www.npmjs.com/package/@tc39/source-map-tests), so that source map implementations can run them in their own test suites. A new version is published for every commit to `main`. + +```sh +npm install --save-dev --save-exact @tc39/source-map-tests +``` + +### Usage + +`@tc39/source-map-tests/suites.json` lists the test suites: + +```json +{ + "suites": [ + { "kind": "interpreting", "file": "interpreting/source-map-spec.json" }, + { "kind": "decoding", "file": "decoding/scopes.json" } + ] +} +``` + +There are two types of test suites: `interpreting` and `decoding`: +- **interpreting** provided a source map to apply to a generated file, together with some actions to perform through it to check that it has been applied correctly. +- **decoding** suites check that a source map is correctly decoded into a [Decoded Source Map Record](https://tc39.es/ecma426/#decoded-source-map-record). + +### TypeScript + +The package's root exports the types of the JSON files: + +```ts +import type { InterpretingSuite, DecodingSuite, TestAction } from "@tc39/source-map-tests"; +``` + +With TypeScript 7.1 or later, you can load type definitions for the various suites by adding `"types": ["@tc39/source-map-tests"]` to your `tsconfig.json`. Imported JSON modules then will be typed appropriately: +```ts +import spec from "@tc39/source-map-tests/interpreting/source-map-spec.json" with { type: "json" }; +spec.tests[0].testActions; // TestAction[] +``` diff --git a/test/fixtures/test426/decoding/debug-id/debug-id-index-section.map b/test/fixtures/test426/decoding/debug-id/debug-id-index-section.map index 9c6f3fbde1e..7a6d25afc73 100644 --- a/test/fixtures/test426/decoding/debug-id/debug-id-index-section.map +++ b/test/fixtures/test426/decoding/debug-id/debug-id-index-section.map @@ -4,7 +4,7 @@ "sections": [{ "offset": { "line": 0, - "column": 0, + "column": 0 }, "map": { "version": 3, @@ -16,7 +16,7 @@ }, { "offset": { "line": 1, - "column": 0, + "column": 0 }, "map": { "version": 3, diff --git a/test/fixtures/test426/decoding/debug-id/debug-id-index-section.map.golden b/test/fixtures/test426/decoding/debug-id/debug-id-index-section.map.golden index 7c3a8456e6b..69f6ebf9dcb 100644 --- a/test/fixtures/test426/decoding/debug-id/debug-id-index-section.map.golden +++ b/test/fixtures/test426/decoding/debug-id/debug-id-index-section.map.golden @@ -1,5 +1,5 @@ { "file": "app.js", "sources": [], - "mappings": [], + "mappings": [] } \ No newline at end of file diff --git a/test/fixtures/test426/decoding/debug-id/debug-id-index.map b/test/fixtures/test426/decoding/debug-id/debug-id-index.map index 11de486e1a9..0b7231929e4 100644 --- a/test/fixtures/test426/decoding/debug-id/debug-id-index.map +++ b/test/fixtures/test426/decoding/debug-id/debug-id-index.map @@ -5,7 +5,7 @@ "sections": [{ "offset": { "line": 0, - "column": 0, + "column": 0 }, "map": { "version": 3, @@ -17,7 +17,7 @@ }, { "offset": { "line": 1, - "column": 0, + "column": 0 }, "map": { "version": 3, diff --git a/test/fixtures/test426/decoding/debug-id/debug-id.d.ts b/test/fixtures/test426/decoding/debug-id/debug-id.d.ts index 1f9862f012e..526b584ca19 100644 --- a/test/fixtures/test426/decoding/debug-id/debug-id.d.ts +++ b/test/fixtures/test426/decoding/debug-id/debug-id.d.ts @@ -2,5 +2,5 @@ /// interface SourceMapRecord { - debugId: string|null; + debugId?: string|null; } diff --git a/test/fixtures/test426/npm-package/README.md b/test/fixtures/test426/npm-package/README.md new file mode 100644 index 00000000000..11012332c54 --- /dev/null +++ b/test/fixtures/test426/npm-package/README.md @@ -0,0 +1,5 @@ +# @tc39/source-map-tests + +Cross-implementation test cases for the [ECMA-426 source map specification](https://tc39.es/ecma426/). + +See the [tc39/source-map-tests README](https://github.com/tc39/source-map-tests#npm-package) for the package contents and usage. diff --git a/test/fixtures/test426/npm-package/package.template.json b/test/fixtures/test426/npm-package/package.template.json new file mode 100644 index 00000000000..68c0ae4ac29 --- /dev/null +++ b/test/fixtures/test426/npm-package/package.template.json @@ -0,0 +1,26 @@ +{ + "name": "@tc39/source-map-tests", + "version": "X.X.X", + "description": "Cross-implementation test cases for the ECMA-426 source map specification", + "license": "BSD-3-Clause", + "repository": { + "type": "git", + "url": "git+https://github.com/tc39/source-map-tests.git" + }, + "homepage": "https://github.com/tc39/source-map-tests#readme", + "bugs": "https://github.com/tc39/source-map-tests/issues", + "keywords": [ + "source-map", + "sourcemap", + "ecma-426", + "test-suite", + "tests" + ], + "files": [ + "suites.json", + "interpreting/", + "decoding/", + "types/", + "LICENSE.md" + ] +} diff --git a/test/fixtures/test426/npm-package/types/index.d.ts b/test/fixtures/test426/npm-package/types/index.d.ts new file mode 100644 index 00000000000..658794c6f1d --- /dev/null +++ b/test/fixtures/test426/npm-package/types/index.d.ts @@ -0,0 +1,2 @@ +/// +export * from "./types.js"; diff --git a/test/fixtures/test426/npm-package/types/modules.d.ts b/test/fixtures/test426/npm-package/types/modules.d.ts new file mode 100644 index 00000000000..08300745aff --- /dev/null +++ b/test/fixtures/test426/npm-package/types/modules.d.ts @@ -0,0 +1,14 @@ +declare module "@tc39/source-map-tests/suites*.json" with { type: "json" } { + const index: import("./types.js").SuitesIndex; + export default index; +} + +declare module "@tc39/source-map-tests/interpreting/*.json" with { type: "json" } { + const suite: import("./types.js").InterpretingSuite; + export default suite; +} + +declare module "@tc39/source-map-tests/decoding/*.json" with { type: "json" } { + const suite: import("./types.js").DecodingSuite; + export default suite; +} diff --git a/test/fixtures/test426/npm-package/types/types.d.ts b/test/fixtures/test426/npm-package/types/types.d.ts new file mode 100644 index 00000000000..7cbe9d48892 --- /dev/null +++ b/test/fixtures/test426/npm-package/types/types.d.ts @@ -0,0 +1,90 @@ +/** + * Types for the JSON files in this package. + * + * All paths are relative to the package root. + */ + +/** The format of `suites.json`. */ +export interface SuitesIndex { + suites: SuiteInfo[]; +} + +export type SuiteInfo = + | { kind: "interpreting"; file: string } + | { kind: "decoding"; file: string }; + +/** A file from the test suite, with its contents inlined. */ +export interface TestFile { + path: string; + content: string; +} + +/** The format of interpreting suite files (`interpreting/.json`). */ +export interface InterpretingSuite { + tests: InterpretingTest[]; +} + +export interface InterpretingTest { + name: string; + description: string; + sourceMapIsValid: boolean; + testActions: TestAction[]; + /** + * The transpiled source that the source map refers to. + */ + baseFile: TestFile; + sourceMapFile: TestFile; +} + +export type TestAction = + | CheckMappingAction + | CheckMappingTransitiveAction + | CheckIgnoreListAction; + +export interface CheckMappingAction { + actionType: "checkMapping"; + /** 0-based. */ + generatedLine: number; + /** 0-based. */ + generatedColumn: number; + originalSource: string | null; + /** 0-based. */ + originalLine: number | null; + /** 0-based. */ + originalColumn: number | null; + mappedName: string | null; +} + +export interface CheckMappingTransitiveAction + extends Omit { + actionType: "checkMappingTransitive"; + /** Source maps to apply after `sourceMapFile`, in order. */ + intermediateMaps: TestFile[]; +} + +export interface CheckIgnoreListAction { + actionType: "checkIgnoreList"; + /** Sources that must be in the ignore list. */ + present: string[]; +} + +/** The format of decoding suite files (`decoding/.json`). */ +export interface DecodingSuite { + tests: DecodingTest[]; +} + +export interface DecodingTest { + name: string; + sourceMapFile: TestFile; + /** + * The expected Decoded Source Map Record, as JSON in the format described by + * `decoding/source-map-record.d.ts` (and extended by the proposal-specific + * `decoding//.d.ts` files). + */ + goldenFile: TestFile; + /** + * Whether decoding this source map should optionally report an error + * (https://tc39.es/ecma426/#sec-optional-errors). + */ + optionalErrors: boolean; +} diff --git a/test/fixtures/test426/package-lock.json b/test/fixtures/test426/package-lock.json new file mode 100644 index 00000000000..daf25a482c9 --- /dev/null +++ b/test/fixtures/test426/package-lock.json @@ -0,0 +1,405 @@ +{ + "name": "source-map-tests", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "devDependencies": { + "typescript": "7.1.0-beta" + } + }, + "node_modules/@typescript/typescript-aix-ppc64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-aix-ppc64/-/typescript-aix-ppc64-7.1.0-beta.tgz", + "integrity": "sha512-DXDG+jIWxBHGdoO70tcHON33rCnSzsEZj9P13oyf/r/KEGIo6awsdSNVNjAw0uMwEpqRu75IrgCcW58YcVkZHg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-android-arm64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-android-arm64/-/typescript-android-arm64-7.1.0-beta.tgz", + "integrity": "sha512-UZx6PxoQavuvaVTrSf3aw0Oy/J/uJpRylipA0kzc038jMvZXh0UtE8vnQp20FqtdgD5bhXZ0aJrRJyoTSUO58Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-darwin-arm64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-darwin-arm64/-/typescript-darwin-arm64-7.1.0-beta.tgz", + "integrity": "sha512-q7mxblcyX0E7hXsY4k+Q6KWKK5mGmfVq+BDesdTgRVgjodk27aIxER77Zyj9+TgSTlCje8F7+JM6f6hl2BuNdw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-darwin-x64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-darwin-x64/-/typescript-darwin-x64-7.1.0-beta.tgz", + "integrity": "sha512-D5EYqG5Wm/guw9+0j8+Mn1Jbr/gfS/VtFTuoH8PJtFbcqeDaQGMulc7SW8q51QG6Y3wGOGX3nbsTOw6fIKWWAA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-freebsd-arm64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-freebsd-arm64/-/typescript-freebsd-arm64-7.1.0-beta.tgz", + "integrity": "sha512-9A0XX0tcnH9qPdolSKKzSjTb93dlB0UEcAJbHYEsrFX2fkFNSum9+dvkQQJ9vLc+7vxHetDPujq9Qe6wx+Xhow==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-freebsd-x64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-freebsd-x64/-/typescript-freebsd-x64-7.1.0-beta.tgz", + "integrity": "sha512-EDf/dBHfY0TxX3NmUTek0hbffeyZlh3+ls6WQW3ICB8vYxwYLFnzg7wkgEUvl9eRlpiJ/nmc2S8arPMzINJ7rg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-linux-arm": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-arm/-/typescript-linux-arm-7.1.0-beta.tgz", + "integrity": "sha512-AvN9HmzOQh46G4312ooSgMHhbB7DtnLwg8D9mo324X49B7weMwtJrBG1MxT9IyI8kzDd7YRtW+1hWGun7WG7Qw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-linux-arm64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-arm64/-/typescript-linux-arm64-7.1.0-beta.tgz", + "integrity": "sha512-hNqQBgQ5b5oGqN76QqbAU6CwYhJZ6iOcWc2kPTUs2OentgpxZktETziH6KIyRFJPaiBncognwn2ZLu3DNhHiWw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-linux-loong64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-loong64/-/typescript-linux-loong64-7.1.0-beta.tgz", + "integrity": "sha512-xbUustlBrFflt2pNEyG5ye+d4WGPc/rfr2xK29MXeobPSw297JqwuKRrvbKM5o3fE/eUM/c+urVm6jQ3IaMVTw==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-linux-mips64el": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-mips64el/-/typescript-linux-mips64el-7.1.0-beta.tgz", + "integrity": "sha512-fS4/G7/0bXZ3NSq3nBMAXyg65I3tO4S7j08VNQ2g1aNC/qq79gE7Qne1BNjVsjMFfHBVBFjQYoTQCjmVU2iFlg==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-linux-ppc64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-ppc64/-/typescript-linux-ppc64-7.1.0-beta.tgz", + "integrity": "sha512-0upCCxYPX8X6gOwkvfv+Ee7/ufyy7k97mTrGE0e5BxLlnUEa+w+rtgnv2dsKcxFdwdeZYVlZKCqgN/xCBV08+A==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-linux-riscv64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-riscv64/-/typescript-linux-riscv64-7.1.0-beta.tgz", + "integrity": "sha512-0jKU9YRgOPRgiy5V/UWv37kB53PaTpIbwGCbbOMUPPAkrjVRNOIAJaz7Wa7s3H7mdDebX1LopUEPEJR+7Xa7zg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-linux-s390x": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-s390x/-/typescript-linux-s390x-7.1.0-beta.tgz", + "integrity": "sha512-j+d04s2kxaPQh6DLPb01sknAQfzsrdSZy15jBRHyLEZoaaQ19dVjbFRlkNVvYwUG7ZdP8+y5b/7RmPxdtHUKdQ==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-linux-x64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-x64/-/typescript-linux-x64-7.1.0-beta.tgz", + "integrity": "sha512-kcD51ihf+pnI5KT4uQQYG04OpwznaZYBlIQhDhl8fflFd27NktxXsUeguxZyvUMyWfum7IF2bBS6Jv7ox0AgFQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-netbsd-arm64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-netbsd-arm64/-/typescript-netbsd-arm64-7.1.0-beta.tgz", + "integrity": "sha512-8W85YyoGK+rgGoSU9jJQUpELbrKcZcbdJk2jPNQ6UKDKI7ryPlPFTrV2jCE5RQuv4Tt96hMDTc33s4YfRrLFBA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-netbsd-x64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-netbsd-x64/-/typescript-netbsd-x64-7.1.0-beta.tgz", + "integrity": "sha512-iGsTE0ve2PG0AcyZinwAR0LnGEZhu/y4dceS0hZsYCaKdYETvQtvtlNWlmYKempsBr6C7Il7dMXHVk+VFm9u0g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-openbsd-arm64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-openbsd-arm64/-/typescript-openbsd-arm64-7.1.0-beta.tgz", + "integrity": "sha512-Z2FERdHB9fAKI+KGqdWn04O7uNlnB+VYiEm6INE1aZuzzLNd3KBqQ6IpKUJF2ny4GigGU6nVu75XD9tAUODPng==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-openbsd-x64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-openbsd-x64/-/typescript-openbsd-x64-7.1.0-beta.tgz", + "integrity": "sha512-NVG3qeyCq/rJEOhaRjR3LsWgjrjo5vJW25omVLeHAVnpKIG4pE4cenwwKGR06DiJ1s0QTOymcJeKXMEpsiNBVg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-sunos-x64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-sunos-x64/-/typescript-sunos-x64-7.1.0-beta.tgz", + "integrity": "sha512-ovAdoWXEn2B5/fyWG69pLU3FWmQwPWOjQV5TFbcxtpnOv+R3g8ySGHl1NYRq7Lb/GYdFDvaGcZ+SiU7iKuiMsA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-win32-arm64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-win32-arm64/-/typescript-win32-arm64-7.1.0-beta.tgz", + "integrity": "sha512-lJbo71IEOfL7ZZIZnArRaOLqjn9BAfoSzyUQn0aSjfSpDZL4ru0afUsdBfo6PQEjD6ssdmi0n/RwaPADX6bsvQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/@typescript/typescript-win32-x64": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/@typescript/typescript-win32-x64/-/typescript-win32-x64-7.1.0-beta.tgz", + "integrity": "sha512-UKcHvbybY2tDTvFW2b1vwiAvDlIRooo69lh8CXWVhOQejcvpM5+IgbiFW9EIwR5Wi5X/v+BdN7gdWbigBuJ3rw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/typescript": { + "version": "7.1.0-beta", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-7.1.0-beta.tgz", + "integrity": "sha512-cjWjZAJDsmZzsNC5GwHNlW0YPM65jZa5oR0KyQcYX3KSVIfTvtBq//vewISyatKk4OLi5grZjHhIVE9fdrw1UQ==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc" + }, + "engines": { + "node": ">=16.20.0" + }, + "optionalDependencies": { + "@typescript/typescript-aix-ppc64": "7.1.0-beta", + "@typescript/typescript-android-arm64": "7.1.0-beta", + "@typescript/typescript-darwin-arm64": "7.1.0-beta", + "@typescript/typescript-darwin-x64": "7.1.0-beta", + "@typescript/typescript-freebsd-arm64": "7.1.0-beta", + "@typescript/typescript-freebsd-x64": "7.1.0-beta", + "@typescript/typescript-linux-arm": "7.1.0-beta", + "@typescript/typescript-linux-arm64": "7.1.0-beta", + "@typescript/typescript-linux-loong64": "7.1.0-beta", + "@typescript/typescript-linux-mips64el": "7.1.0-beta", + "@typescript/typescript-linux-ppc64": "7.1.0-beta", + "@typescript/typescript-linux-riscv64": "7.1.0-beta", + "@typescript/typescript-linux-s390x": "7.1.0-beta", + "@typescript/typescript-linux-x64": "7.1.0-beta", + "@typescript/typescript-netbsd-arm64": "7.1.0-beta", + "@typescript/typescript-netbsd-x64": "7.1.0-beta", + "@typescript/typescript-openbsd-arm64": "7.1.0-beta", + "@typescript/typescript-openbsd-x64": "7.1.0-beta", + "@typescript/typescript-sunos-x64": "7.1.0-beta", + "@typescript/typescript-win32-arm64": "7.1.0-beta", + "@typescript/typescript-win32-x64": "7.1.0-beta" + } + } + } +} diff --git a/test/fixtures/test426/package.json b/test/fixtures/test426/package.json new file mode 100644 index 00000000000..f760360f8fe --- /dev/null +++ b/test/fixtures/test426/package.json @@ -0,0 +1,11 @@ +{ + "private": true, + "type": "module", + "scripts": { + "build": "node scripts/build-npm-package.js", + "check-types": "node scripts/build-npm-package.js && node scripts/check-types.js" + }, + "devDependencies": { + "typescript": "7.1.0-beta" + } +} diff --git a/test/fixtures/test426/scripts/build-npm-package.js b/test/fixtures/test426/scripts/build-npm-package.js new file mode 100644 index 00000000000..7570fefce1d --- /dev/null +++ b/test/fixtures/test426/scripts/build-npm-package.js @@ -0,0 +1,240 @@ +// Builds the contents for the @tc39/source-map-tests npm package, +// in the `npm-package` folder. + +import { execFileSync } from "node:child_process"; +import fs from "node:fs"; +import path from "node:path"; + +const root = path.resolve(import.meta.dirname, ".."); +const outDir = path.join(root, "npm-package"); +const committedFiles = new Set([ + "README.md", + "package.template.json", + "types", +]); + +const errors = []; +const error = msg => errors.push(msg); + +const rel = abs => path.relative(root, abs).split(path.sep).join("/"); +const abs = relPath => path.join(root, relPath); +const out = relPath => path.join(outDir, relPath); + +function walk(dir) { + return fs + .readdirSync(dir, { withFileTypes: true }) + .flatMap(e => + e.isDirectory() ? walk(path.join(dir, e.name)) : [path.join(dir, e.name)] + ); +} + +/** + * Returns `{ path, content }` for a repo-relative path, or null if missing. + * `packagePath` is where the file ends up in the npm package. + */ +function fileEntry(relPath, context, packagePath = relPath) { + if (!fs.existsSync(abs(relPath))) { + error(`${context}: referenced file ${relPath} does not exist`); + return null; + } + return { path: packagePath, content: fs.readFileSync(abs(relPath), "utf8") }; +} + +function checkUniqueNames(suiteName, tests) { + const seen = new Set(); + for (const { name } of tests) { + if (seen.has(name)) error(`${suiteName}: duplicate test name ${name}`); + seen.add(name); + } +} + +// Interpreting suites: [-proposal]-tests.json manifests in the repo root, +// whose files live in resources/. In the package, resources/ +// is copied to interpreting/resources/. + +const referencedResources = new Set(); + +function buildInterpretingSuite(manifestFile) { + const name = manifestFile.replace(/-tests\.json$/, "").replace(/-proposal$/, ""); + const manifest = JSON.parse(fs.readFileSync(abs(manifestFile), "utf8")); + const base = path.posix.join("resources", manifest.resourceBasePath ?? ""); + const resource = (file, context) => { + const relPath = path.posix.join(base, file); + referencedResources.add(relPath); + return fileEntry(relPath, context, `interpreting/${relPath}`); + }; + + const tests = manifest.tests.map(test => { + const context = `${manifestFile} (${test.name})`; + return { + name: test.name, + description: test.description, + sourceMapIsValid: test.sourceMapIsValid, + baseFile: resource(test.baseFile, context), + sourceMapFile: resource(test.sourceMapFile, context), + testActions: (test.testActions ?? []).map(action => + action.intermediateMaps + ? { + ...action, + intermediateMaps: action.intermediateMaps.map(m => + resource(m, context) + ), + } + : action + ), + }; + }); + checkUniqueNames(name, tests); + return { name, kind: "interpreting", tests }; +} + +// Decoding suites: each directory under decoding/ containing .map files, +// each with a .map.golden and an optional .error/.map.error. + +function buildDecodingSuite(dir) { + const name = path.basename(dir); + const files = fs.readdirSync(dir).sort(); + const used = new Set(); + const tests = []; + + for (const file of files.filter(f => f.endsWith(".map"))) { + const testName = file.slice(0, -".map".length); + const context = `${rel(dir)} (${testName})`; + const sourceMapFile = fileEntry(rel(path.join(dir, file)), context); + const goldenFile = fileEntry(rel(path.join(dir, `${file}.golden`)), context); + const errorFile = [`${testName}.error`, `${file}.error`].find(f => + files.includes(f) + ); + used.add(file).add(`${file}.golden`).add(errorFile); + + if (goldenFile) { + try { + JSON.parse(goldenFile.content); + } catch (e) { + error(`${goldenFile.path}: invalid JSON (${e.message})`); + } + } + tests.push({ + name: testName, + sourceMapFile, + goldenFile, + optionalErrors: errorFile !== undefined, + }); + } + + for (const file of files) { + if (/\.(golden|error)$/.test(file) && !used.has(file)) { + error(`${rel(path.join(dir, file))}: no matching .map file`); + } + } + + checkUniqueNames(name, tests); + return { name, kind: "decoding", tests }; +} + +// Stable spec tests come first, followed by proposals. +const isProposal = f => f.endsWith("-proposal-tests.json"); +const interpretingSuites = fs + .readdirSync(root) + .filter(f => f.endsWith("-tests.json")) + .sort((a, b) => isProposal(a) - isProposal(b) || a.localeCompare(b)) + .map(buildInterpretingSuite); + +const decodingDirs = [ + path.join(root, "decoding"), + ...fs + .readdirSync(path.join(root, "decoding"), { withFileTypes: true }) + .filter(e => e.isDirectory()) + .map(e => path.join(root, "decoding", e.name)) + .sort(), +]; +const decodingSuites = decodingDirs + .filter(dir => fs.readdirSync(dir).some(f => f.endsWith(".map"))) + .map(buildDecodingSuite); + +const suites = [...interpretingSuites, ...decodingSuites]; + +// Suites go in /.json, next to the directory with their files. +const suiteFile = ({ name, kind }) => `${kind}/${name}.json`; + +const suiteFiles = new Set(); +for (const suite of suites) { + const file = suiteFile(suite); + if (suiteFiles.has(file)) error(`two suites would be written to ${file}`); + suiteFiles.add(file); +} + +for (const file of walk(path.join(root, "resources"))) { + if (file.endsWith(".map") && !referencedResources.has(rel(file))) { + error(`${rel(file)}: source map not referenced by any test`); + } +} + +if (errors.length > 0) { + console.error(`Found ${errors.length} problem(s) in the test data:`); + for (const msg of errors) console.error(` - ${msg}`); + process.exit(1); +} + +// Write the package. + +const writeJSON = (relPath, data) => { + fs.mkdirSync(path.dirname(out(relPath)), { recursive: true }); + fs.writeFileSync(out(relPath), JSON.stringify(data, null, 2) + "\n"); +}; + +const git = (...gitArgs) => + execFileSync("git", gitArgs, { cwd: root, encoding: "utf8" }).trim(); +const version = `0.0.${git("rev-list", "--count", "HEAD")}`; +const gitHead = git("rev-parse", "HEAD"); + +for (const entry of fs.readdirSync(outDir)) { + if (!committedFiles.has(entry)) { + fs.rmSync(out(entry), { recursive: true, force: true }); + } +} + +fs.cpSync(abs("resources"), out("interpreting/resources"), { recursive: true }); +fs.cpSync(abs("decoding"), out("decoding"), { recursive: true }); +fs.copyFileSync(abs("LICENSE.md"), out("LICENSE.md")); + +for (const suite of suites) { + writeJSON(suiteFile(suite), { tests: suite.tests }); +} +const packageJson = JSON.parse( + fs.readFileSync(out("package.template.json"), "utf8") +); + +const decodingTypes = walk(abs("decoding")) + .filter(f => f.endsWith(".d.ts")) + .map(rel) + .sort(); +const exportedFiles = [ + "package.json", + "suites.json", + ...suites.map(suiteFile), + ...decodingTypes, +]; +writeJSON("package.json", { + ...packageJson, + version, + gitHead, + exports: { + ".": { + "types@>=7.1.0-0": "./types/index.d.ts", + types: "./types/types.d.ts", + }, + ...Object.fromEntries(exportedFiles.map(f => [`./${f}`, `./${f}`])), + }, +}); +writeJSON("suites.json", { + suites: suites.map(suite => ({ + kind: suite.kind, + file: suiteFile(suite), + })), +}); + +console.log(`Built ${packageJson.name}@${version} in ${rel(outDir)}/`); +for (const { name, kind, tests } of suites) { + console.log(` ${name} (${kind}): ${tests.length} tests`); +} diff --git a/test/fixtures/test426/scripts/check-types.js b/test/fixtures/test426/scripts/check-types.js new file mode 100644 index 00000000000..7c5cbf0d67e --- /dev/null +++ b/test/fixtures/test426/scripts/check-types.js @@ -0,0 +1,150 @@ +// Checks that the JSON files in the generated npm package match +// the TS definitions. Run build-npm-package.js first. + +import { spawnSync } from "node:child_process"; +import fs from "node:fs"; +import path from "node:path"; + +const root = path.resolve(import.meta.dirname, ".."); +const outDir = path.join(root, ".tmp", "check-types"); +const tsc = path.join(root, "node_modules", ".bin", "tsc"); + +const compilerOptions = { + strict: true, + noEmit: true, + skipLibCheck: false, + module: "nodenext", + moduleResolution: "nodenext", + target: "esnext", + types: [], +}; + +const relFrom = (from, to) => { + const rel = path.relative(path.dirname(from), to).split(path.sep).join("/"); + return rel.startsWith(".") ? rel : `./${rel}`; +}; + +function writeCheck(tsFile, header, type, jsonFile) { + const json = fs.readFileSync(jsonFile, "utf8"); + fs.mkdirSync(path.dirname(tsFile), { recursive: true }); + fs.writeFileSync( + tsFile, + `${header}\nexport default ${json.trim()} satisfies ${type};\n` + ); +} + +function runTsc(name, projectDir, files) { + const tsconfig = path.join(projectDir, "tsconfig.json"); + fs.writeFileSync(tsconfig, JSON.stringify({ compilerOptions, files }, null, 2)); + const { status } = spawnSync(tsc, ["-p", tsconfig, "--pretty"], { + stdio: "inherit", + }); + console.log(`${status === 0 ? "ok" : "FAIL"} ${name}`); + return status === 0; +} + +fs.rmSync(outDir, { recursive: true, force: true }); +let ok = true; + +// npm package files. + +const pkgDir = path.join(root, "npm-package"); +if (!fs.existsSync(path.join(pkgDir, "suites.json"))) { + console.error("npm-package/suites.json not found, run scripts/build-npm-package.js first."); + process.exit(1); +} +{ + const projectDir = path.join(outDir, "npm-package"); + const typesFile = path.join(pkgDir, "types", "types.d.ts"); + const files = []; + const check = (jsonRel, type) => { + const tsFile = path.join(projectDir, `${jsonRel}.ts`); + const header = `import type { ${type} } from "${relFrom(tsFile, typesFile)}";`; + writeCheck(tsFile, header, type, path.join(pkgDir, jsonRel)); + files.push(path.relative(projectDir, tsFile)); + }; + + const index = JSON.parse(fs.readFileSync(path.join(pkgDir, "suites.json"), "utf8")); + const expectedTypes = new Map([["suites.json", "SuitesIndex"]]); + for (const { kind, file } of index.suites) { + expectedTypes.set(file, kind === "interpreting" ? "InterpretingSuite" : "DecodingSuite"); + } + for (const [file, type] of expectedTypes) check(file, type); + + // Check that importing each exported JSON file `with { type: "json" }` gets + // its declared type from modules.d.ts. + const { name: pkgName, exports } = JSON.parse( + fs.readFileSync(path.join(pkgDir, "package.json"), "utf8") + ); + const exportedJSON = Object.keys(exports) + .filter(key => key.endsWith(".json") && key !== "./package.json") + .map(key => key.slice(2)); + const importsFile = path.join(projectDir, "imports.ts"); + const typeNames = [...new Set(expectedTypes.values())]; + fs.writeFileSync( + importsFile, + [ + `import type { ${typeNames.join(", ")} } from "${relFrom(importsFile, path.join(pkgDir, "types", "index.js"))}";`, + "type Equals = (() => T extends A ? 1 : 2) extends (() => T extends B ? 1 : 2) ? true : false;", + ...exportedJSON.flatMap((file, i) => { + const type = expectedTypes.get(file); + if (!type) throw new Error(`Exported ${file} is not a known suite file`); + return [ + `import json${i} from "${pkgName}/${file}" with { type: "json" };`, + `export const check${i}: Equals = true; // ${file}`, + ]; + }), + ].join("\n") + "\n" + ); + files.push(path.relative(projectDir, importsFile)); + + ok = runTsc("npm-package", projectDir, files) && ok; + + // Check that each exported decoding/**/*.d.ts file can be loaded through the + // package's exports. Each one is checked separately, because they extend + // the same global interfaces. + for (const key of Object.keys(exports).filter(k => k.endsWith(".d.ts"))) { + const name = `npm-package ${key.slice(2)}`; + const dtsDir = path.join(outDir, "exports", key.slice(2)); + const linkDir = path.join(dtsDir, "node_modules", ...pkgName.split("/")); + fs.mkdirSync(path.dirname(linkDir), { recursive: true }); + fs.symlinkSync(pkgDir, linkDir, "dir"); + fs.writeFileSync( + path.join(dtsDir, "index.ts"), + `/// \nexport type T = SourceMapRecord;\n` + ); + ok = runTsc(name, dtsDir, ["index.ts"]) && ok; + } +} + +// Check golden files + +const decodingDir = path.join(root, "decoding"); +const decodingSuiteDirs = [ + decodingDir, + ...fs + .readdirSync(decodingDir, { withFileTypes: true }) + .filter(e => e.isDirectory()) + .map(e => path.join(decodingDir, e.name)), +]; +for (const dir of decodingSuiteDirs) { + const goldens = fs.readdirSync(dir).filter(f => f.endsWith(".golden")).sort(); + if (goldens.length === 0) continue; + + const name = path.relative(root, dir).split(path.sep).join("/"); + const projectDir = path.join(outDir, name); + const suiteTypes = path.join(dir, `${path.basename(dir)}.d.ts`); + const typesFile = fs.existsSync(suiteTypes) + ? suiteTypes + : path.join(decodingDir, "source-map-record.d.ts"); + + const files = goldens.map(golden => { + const tsFile = path.join(projectDir, `${golden}.ts`); + const header = `/// `; + writeCheck(tsFile, header, "SourceMapRecord", path.join(dir, golden)); + return path.relative(projectDir, tsFile); + }); + ok = runTsc(name, projectDir, files) && ok; +} + +process.exit(ok ? 0 : 1); diff --git a/test/test426/README.md b/test/test426/README.md index 6935fc43c3d..85db408434b 100644 --- a/test/test426/README.md +++ b/test/test426/README.md @@ -7,7 +7,7 @@ suite ensures that the Node.js source map implementation conforms to the The [`test/fixtures/test426`](../fixtures/test426/) contains a copy of the set of [Source Map Tests][] suite. The last updated hash is: -* +* See the json files in [the `status` folder](./status) for prerequisites, expected failures, and support status for specific tests. From 7145dcb47cb03739c0e564cefc3da60caf4be34a Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Tue, 27 Oct 2026 15:28:19 -0700 Subject: [PATCH 128/331] ffi: free libuv error message on failed dlopen When uv_dlopen() fails, the error message it allocates is only released by uv_dlclose(). DynamicLibrary::Close() skips uv_dlclose() when the handle is null, so each failed ffi.dlopen() leaked the message. Call uv_dlclose() on the failure path, as DLib::Open() does. Signed-off-by: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Assisted-by: claude:opus-5.5 PR-URL: https://github.com/nodejs/node/pull/67007 Fixes: https://github.com/nodejs/node/issues/67006 Reviewed-By: Daeyeon Jeong Reviewed-By: Paolo Insogna --- src/node_ffi.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/node_ffi.cc b/src/node_ffi.cc index afdc8f1fd36..42da08c0658 100644 --- a/src/node_ffi.cc +++ b/src/node_ffi.cc @@ -578,6 +578,8 @@ void DynamicLibrary::New(const FunctionCallbackInfo& args) { opened ? static_cast(lib->lib_.handle) : nullptr); if (!opened) { THROW_ERR_FFI_CALL_FAILED(env, "dlopen failed: %s", uv_dlerror(&lib->lib_)); + // Free the error message. Close() skips uv_dlclose() for a null handle. + uv_dlclose(&lib->lib_); return; } } From 04e5a39ebfd39d3b65c82c15f8932df0010adeaa Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Sun, 30 Aug 2026 09:04:52 +0200 Subject: [PATCH 129/331] crypto,tls: clone X.509 chains across isolates X509Certificate cloning drops issuerCertificate and shares its native X509 object with the receiving isolate. Snapshot the leaf and supplied peer chain as DER, then parse separate native certificates in each isolate. Construct the JavaScript chain iteratively for TLS inspection, structuredClone(), MessagePort, and workers. Each supplied position gets its own object, including repeated certificate encodings. Refs: https://github.com/nodejs/node/pull/65602 Assisted-by: Codex Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/66898 Reviewed-By: Tim Perry --- src/crypto/crypto_x509.cc | 272 ++++++++++++++---- src/crypto/crypto_x509.h | 83 ++++-- .../test-crypto-x509-chain-snapshot.js | 95 ++++++ test/parallel/test-crypto-x509-peer-chain.js | 110 +++++++ 4 files changed, 480 insertions(+), 80 deletions(-) create mode 100644 test/parallel/test-crypto-x509-chain-snapshot.js create mode 100644 test/parallel/test-crypto-x509-peer-chain.js diff --git a/src/crypto/crypto_x509.cc b/src/crypto/crypto_x509.cc index c7dbe956149..3c208082f94 100644 --- a/src/crypto/crypto_x509.cc +++ b/src/crypto/crypto_x509.cc @@ -13,6 +13,7 @@ #include #include +#include #include #include #include @@ -55,17 +56,94 @@ using v8::Value; namespace crypto { -ManagedX509::ManagedX509(X509Pointer&& cert) : cert_(std::move(cert)) {} +namespace { + +std::optional EncodeCertificate( + const X509View& cert) { + MarkPopErrorOnReturn mark_pop_error_on_return; + if (!cert) return std::nullopt; + + const int size = i2d_X509(cert.get(), nullptr); + if (size <= 0) return std::nullopt; + + X509CertificateSnapshot::DER der(static_cast(size)); + unsigned char* cursor = der.data(); + if (i2d_X509(cert.get(), &cursor) != size || + cursor != der.data() + der.size()) { + return std::nullopt; + } + return der; +} + +X509Pointer ParseCertificate(const X509CertificateSnapshot::DER& certificate) { + MarkPopErrorOnReturn mark_pop_error_on_return; + constexpr size_t kMaximumCertificateSize = static_cast( + std::numeric_limits::max()); // NOLINT(runtime/int) + if (certificate.empty() || certificate.size() > kMaximumCertificateSize) { + return {}; + } -ManagedX509::ManagedX509(const ManagedX509& that) { - *this = that; + const unsigned char* cursor = certificate.data(); + const unsigned char* const end = cursor + certificate.size(); + X509Pointer cert( + d2i_X509(nullptr, + &cursor, + static_cast(certificate.size()))); // NOLINT(runtime/int) + if (!cert || cursor != end) return {}; + return cert; } -ManagedX509& ManagedX509::operator=(const ManagedX509& that) { - cert_.reset(that.get()); - if (cert_) [[likely]] - X509_up_ref(cert_.get()); - return *this; +} // namespace + +ManagedX509::ManagedX509(X509Pointer cert) : cert_(std::move(cert)) {} + +std::shared_ptr ManagedX509::Adopt(X509Pointer cert) { + if (!cert) return {}; + return std::shared_ptr(new ManagedX509(std::move(cert))); +} + +X509CertificateSnapshot::X509CertificateSnapshot(std::vector certificates) + : certificates_(std::move(certificates)) {} + +std::shared_ptr X509CertificateSnapshot::Create( + X509View leaf, + const STACK_OF(X509) * issuer_chain, + OPENSSL_SIZE_T issuers_start) { + auto leaf_der = EncodeCertificate(leaf); + if (!leaf_der.has_value()) return {}; + + const OPENSSL_SIZE_T count = + issuer_chain == nullptr ? 0 : sk_X509_num(issuer_chain); + std::vector certificates; + certificates.reserve(static_cast(count) + 1); + certificates.push_back(std::move(leaf_der.value())); + for (OPENSSL_SIZE_T i = issuers_start; i < count; i++) { + const X509View candidate(sk_X509_value(issuer_chain, i)); + auto candidate_der = EncodeCertificate(candidate); + if (!candidate_der.has_value()) return {}; + certificates.push_back(std::move(candidate_der.value())); + } + + return std::shared_ptr( + new X509CertificateSnapshot(std::move(certificates))); +} + +X509Pointer X509CertificateSnapshot::Parse(size_t index) const { + if (index >= certificates_.size()) return {}; + return ParseCertificate(certificates_[index]); +} + +size_t X509CertificateSnapshot::size_bytes() const { + return std::accumulate(certificates_.begin(), + certificates_.end(), + size_t{0}, + [](size_t total, const DER& certificate) { + return total + certificate.size(); + }); +} + +void X509CertificateSnapshot::MemoryInfo(MemoryTracker* tracker) const { + tracker->TrackFieldWithSize("certificates", size_bytes()); } void ManagedX509::MemoryInfo(MemoryTracker* tracker) const { @@ -947,9 +1025,25 @@ void X509Certificate::NewFromHandle(const FunctionCallbackInfo& args) { if (!result.value) [[unlikely]] { return ThrowCryptoError(env, result.error.value_or(0)); } + + auto snapshot = X509CertificateSnapshot::Create(result.value.view()); + if (!snapshot) [[unlikely]] { + THROW_ERR_CRYPTO_OPERATION_FAILED(env, + "Failed to snapshot X.509 certificate"); + return; + } + + auto parsed = snapshot->Parse(0); + if (!parsed) [[unlikely]] { + THROW_ERR_CRYPTO_OPERATION_FAILED( + env, "Failed to parse X.509 certificate snapshot"); + return; + } new X509Certificate(env, args.This(), - std::make_shared(std::move(result.value))); + ManagedX509::Adopt(std::move(parsed)), + std::move(snapshot), + 0); return; } @@ -963,7 +1057,12 @@ void X509Certificate::NewFromHandle(const FunctionCallbackInfo& args) { CHECK_NOT_NULL(handle); Local issuer; if (handle->issuer_cert_) issuer = handle->issuer_cert_->object(); - new X509Certificate(env, args.This(), handle->cert_, issuer); + new X509Certificate(env, + args.This(), + handle->cert_, + handle->snapshot_, + handle->snapshot_index_, + issuer); } void X509Certificate::CreateX509CertificateClass( @@ -1002,50 +1101,95 @@ void X509Certificate::IsX509Certificate( MaybeLocal X509Certificate::New(Environment* env, X509Pointer cert, - const STACK_OF(X509) * issuer_chain) { - std::shared_ptr mcert(new ManagedX509(std::move(cert))); - return New(env, std::move(mcert), issuer_chain); -} + const STACK_OF(X509) * issuer_chain, + OPENSSL_SIZE_T issuers_start) { + if (!cert) return {}; + + auto snapshot = + X509CertificateSnapshot::Create(cert.view(), issuer_chain, issuers_start); + if (!snapshot) [[unlikely]] { + THROW_ERR_CRYPTO_OPERATION_FAILED(env, + "Failed to snapshot X.509 certificate"); + return {}; + } -MaybeLocal X509Certificate::New(Environment* env, - std::shared_ptr cert, - const STACK_OF(X509) * issuer_chain) { - return NewWithIssuers(env, std::move(cert), issuer_chain, 0); + // Keep the live certificate independent from the backend object that was + // serialized while creating the immutable snapshot. Some backends populate + // or invalidate lazy caches while encoding malformed-but-parseable input. + auto parsed = snapshot->Parse(0); + if (!parsed) [[unlikely]] { + THROW_ERR_CRYPTO_OPERATION_FAILED( + env, "Failed to parse X.509 certificate snapshot"); + return {}; + } + return New(env, ManagedX509::Adopt(std::move(parsed)), std::move(snapshot)); } -MaybeLocal X509Certificate::NewWithIssuers( +MaybeLocal X509Certificate::New( Environment* env, std::shared_ptr cert, - const STACK_OF(X509) * issuer_chain, - int start) { + std::shared_ptr snapshot, + size_t snapshot_index) { + CHECK(cert); + CHECK(snapshot); + CHECK_LT(snapshot_index, snapshot->size()); + EscapableHandleScope scope(env->isolate()); + Local context = env->context(); + Local issuer; + + for (size_t i = snapshot->size(); i > snapshot_index + 1; i--) { + const size_t index = i - 1; + auto parsed = snapshot->Parse(index); + if (!parsed) [[unlikely]] { + THROW_ERR_CRYPTO_OPERATION_FAILED( + env, "Failed to parse X.509 certificate snapshot"); + return {}; + } + + Local issuer_object; + if (!GetConstructorTemplate(env) + ->InstanceTemplate() + ->NewInstance(context) + .ToLocal(&issuer_object)) { + return {}; + } + new X509Certificate(env, + issuer_object, + ManagedX509::Adopt(std::move(parsed)), + snapshot, + index, + issuer); + issuer = issuer_object; + } + Local obj; if (!GetConstructorTemplate(env) ->InstanceTemplate() - ->NewInstance(env->context()) + ->NewInstance(context) .ToLocal(&obj)) { - return MaybeLocal(); + return {}; } + new X509Certificate( + env, obj, std::move(cert), std::move(snapshot), snapshot_index, issuer); + return scope.Escape(obj); +} - Local issuer; - if (issuer_chain != nullptr && - static_cast(start) < sk_X509_num(issuer_chain)) { - X509Pointer issuer_cert = - X509View(sk_X509_value(issuer_chain, start)).clone(); - if (!issuer_cert) [[unlikely]] { - return MaybeLocal(); - } - if (!NewWithIssuers(env, - std::make_shared(std::move(issuer_cert)), - issuer_chain, - start + 1) - .ToLocal(&issuer)) [[unlikely]] { - return MaybeLocal(); - } +MaybeLocal X509Certificate::New( + Environment* env, + std::shared_ptr snapshot, + size_t snapshot_index) { + if (!snapshot || snapshot_index >= snapshot->size()) return {}; + auto cert = snapshot->Parse(snapshot_index); + if (!cert) [[unlikely]] { + THROW_ERR_CRYPTO_OPERATION_FAILED( + env, "Failed to parse X.509 certificate snapshot"); + return {}; } - - new X509Certificate(env, obj, std::move(cert), issuer); - return scope.Escape(obj); + return New(env, + ManagedX509::Adopt(std::move(cert)), + std::move(snapshot), + snapshot_index); } MaybeLocal X509Certificate::GetCert(Environment* env, @@ -1064,26 +1208,25 @@ MaybeLocal X509Certificate::GetPeerCert(Environment* env, // The peer chain is owned by the SSL session and must not be modified. Its // first entry is the peer certificate on the client but not on the server. const STACK_OF(X509)* ssl_certs = SSL_get_peer_cert_chain(ssl.get()); - int issuers_start = 0; + OPENSSL_SIZE_T issuers_start = 0; X509Pointer cert; if ((flag & GetPeerCertificateFlag::SERVER) == GetPeerCertificateFlag::SERVER) { cert = X509Pointer::PeerFrom(ssl); } + + if (!cert && (ssl_certs == nullptr || sk_X509_num(ssl_certs) == 0)) + return MaybeLocal(); + if (!cert) { - if (ssl_certs == nullptr || sk_X509_num(ssl_certs) == 0) - return MaybeLocal(); - cert = X509View(sk_X509_value(ssl_certs, 0)).clone(); - if (!cert) [[unlikely]] - return MaybeLocal(); + const X509* leaf = sk_X509_value(ssl_certs, 0); + if (leaf != nullptr) cert = X509View(leaf).clone(); issuers_start = 1; } - return NewWithIssuers(env, - std::make_shared(std::move(cert)), - ssl_certs, - issuers_start); + if (!cert) return {}; + return New(env, std::move(cert), ssl_certs, issuers_start); } v8::MaybeLocal X509Certificate::toObject(Environment* env) { @@ -1097,11 +1240,17 @@ v8::MaybeLocal X509Certificate::toObject(Environment* env, return X509ToObject(env, cert).FromMaybe(Local()); } -X509Certificate::X509Certificate(Environment* env, - Local object, - std::shared_ptr cert, - Local issuer_chain) - : BaseObject(env, object), cert_(std::move(cert)) { +X509Certificate::X509Certificate( + Environment* env, + Local object, + std::shared_ptr cert, + std::shared_ptr snapshot, + size_t snapshot_index, + Local issuer_chain) + : BaseObject(env, object), + cert_(std::move(cert)), + snapshot_(std::move(snapshot)), + snapshot_index_(snapshot_index) { MakeWeak(); if (!issuer_chain.IsEmpty()) { @@ -1111,6 +1260,12 @@ X509Certificate::X509Certificate(Environment* env, void X509Certificate::MemoryInfo(MemoryTracker* tracker) const { tracker->TrackField("cert", cert_); + tracker->TrackField("snapshot", snapshot_); +} + +void X509Certificate::X509CertificateTransferData::MemoryInfo( + MemoryTracker* tracker) const { + tracker->TrackField("snapshot", snapshot_); } BaseObjectPtr @@ -1124,7 +1279,7 @@ X509Certificate::X509CertificateTransferData::Deserialize( } Local handle; - if (!X509Certificate::New(env, data_).ToLocal(&handle)) + if (!X509Certificate::New(env, snapshot_, snapshot_index_).ToLocal(&handle)) return {}; Local module = @@ -1157,7 +1312,8 @@ BaseObject::TransferMode X509Certificate::GetTransferMode() const { std::unique_ptr X509Certificate::CloneForMessaging() const { - return std::make_unique(cert_); + return std::make_unique(snapshot_, + snapshot_index_); } void X509Certificate::Initialize(Environment* env, Local target) { diff --git a/src/crypto/crypto_x509.h b/src/crypto/crypto_x509.h index a6f64d4f2d4..44714d1bcca 100644 --- a/src/crypto/crypto_x509.h +++ b/src/crypto/crypto_x509.h @@ -11,22 +11,24 @@ #include "node_worker.h" #include "v8.h" +#include +#include +#include + namespace node { namespace crypto { -// The ManagedX509 class is essentially a smart pointer for -// X509 objects that allows an X509Certificate instance to -// be cloned at the JS level while pointing at the same -// underlying X509 instance. +// ManagedX509 owns one isolate-local X509. Adopt makes the ownership transfer +// explicit at each call site. class ManagedX509 final : public MemoryRetainer { public: - ManagedX509() = default; - explicit ManagedX509(ncrypto::X509Pointer&& cert); - ManagedX509(const ManagedX509& that); - ManagedX509& operator=(const ManagedX509& that); + static std::shared_ptr Adopt(ncrypto::X509Pointer cert); + + ManagedX509(const ManagedX509&) = delete; + ManagedX509& operator=(const ManagedX509&) = delete; inline operator bool() const { return !!cert_; } - inline X509* get() const { return cert_.get(); } + inline X509* get() { return cert_.get(); } inline ncrypto::X509View view() const { return cert_; } inline operator ncrypto::X509View() const { return cert_; } @@ -35,9 +37,40 @@ class ManagedX509 final : public MemoryRetainer { SET_SELF_SIZE(ManagedX509) private: + explicit ManagedX509(ncrypto::X509Pointer cert); + ncrypto::X509Pointer cert_; }; +// An immutable certificate-encoding snapshot. Certificate zero is the leaf and +// all remaining certificates follow in the supplied order. Sharing this +// snapshot between isolates is safe; the isolate-local X509 objects are always +// reparsed from it. +class X509CertificateSnapshot final : public MemoryRetainer { + public: + using DER = std::vector; + + static std::shared_ptr Create( + ncrypto::X509View leaf, + const STACK_OF(X509) * issuer_chain = nullptr, + OPENSSL_SIZE_T issuers_start = 0); + + ncrypto::X509Pointer Parse(size_t index) const; + + inline size_t size() const { return certificates_.size(); } + inline const DER& at(size_t index) const { return certificates_.at(index); } + size_t size_bytes() const; + + void MemoryInfo(MemoryTracker* tracker) const override; + SET_MEMORY_INFO_NAME(X509CertificateSnapshot) + SET_SELF_SIZE(X509CertificateSnapshot) + + private: + explicit X509CertificateSnapshot(std::vector certificates); + + const std::vector certificates_; +}; + class X509Certificate final : public BaseObject { public: enum class GetPeerCertificateFlag { @@ -60,12 +93,19 @@ class X509Certificate final : public BaseObject { static v8::MaybeLocal New( Environment* env, ncrypto::X509Pointer cert, - const STACK_OF(X509) * issuer_chain = nullptr); + const STACK_OF(X509) * issuer_chain = nullptr, + OPENSSL_SIZE_T issuers_start = 0); static v8::MaybeLocal New( Environment* env, std::shared_ptr cert, - const STACK_OF(X509) * issuer_chain = nullptr); + std::shared_ptr snapshot, + size_t snapshot_index = 0); + + static v8::MaybeLocal New( + Environment* env, + std::shared_ptr snapshot, + size_t snapshot_index = 0); static v8::MaybeLocal GetCert(Environment* env, const ncrypto::SSLPointer& ssl); @@ -96,20 +136,22 @@ class X509Certificate final : public BaseObject { class X509CertificateTransferData : public worker::TransferData { public: explicit X509CertificateTransferData( - const std::shared_ptr& data) - : data_(data) {} + std::shared_ptr snapshot, + size_t snapshot_index) + : snapshot_(std::move(snapshot)), snapshot_index_(snapshot_index) {} BaseObjectPtr Deserialize( Environment* env, v8::Local context, std::unique_ptr self) override; + void MemoryInfo(MemoryTracker* tracker) const override; SET_MEMORY_INFO_NAME(X509CertificateTransferData) SET_SELF_SIZE(X509CertificateTransferData) - SET_NO_MEMORY_INFO() private: - std::shared_ptr data_; + std::shared_ptr snapshot_; + size_t snapshot_index_; }; BaseObject::TransferMode GetTransferMode() const override; @@ -119,16 +161,13 @@ class X509Certificate final : public BaseObject { X509Certificate(Environment* env, v8::Local object, std::shared_ptr cert, + std::shared_ptr snapshot, + size_t snapshot_index, v8::Local issuer_chain = v8::Local()); - // Like New(), but reads the issuer chain from issuer_chain[start] upward. - static v8::MaybeLocal NewWithIssuers( - Environment* env, - std::shared_ptr cert, - const STACK_OF(X509) * issuer_chain, - int start); - std::shared_ptr cert_; + std::shared_ptr snapshot_; + size_t snapshot_index_ = 0; BaseObjectPtr issuer_cert_; }; diff --git a/test/parallel/test-crypto-x509-chain-snapshot.js b/test/parallel/test-crypto-x509-chain-snapshot.js new file mode 100644 index 00000000000..5a0f696da0f --- /dev/null +++ b/test/parallel/test-crypto-x509-chain-snapshot.js @@ -0,0 +1,95 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { X509Certificate } = require('node:crypto'); +const { once } = require('node:events'); +const tls = require('node:tls'); +const { + MessageChannel, + Worker, +} = require('node:worker_threads'); +const fixtures = require('../common/fixtures'); + +const leaf = new X509Certificate(fixtures.readKey('agent6-cert.pem')); +const issuer = new X509Certificate(fixtures.readKey('ca3-cert.pem')); + +function assertChain(actual) { + assert(actual instanceof X509Certificate); + assert.deepStrictEqual(actual.raw, leaf.raw); + assert.strictEqual(actual.issuerCertificate, actual.issuerCertificate); + assert(actual.issuerCertificate instanceof X509Certificate); + assert.deepStrictEqual(actual.issuerCertificate.raw, issuer.raw); + assert.strictEqual(actual.issuerCertificate.issuerCertificate, undefined); +} + +function legacyChainRaw(certificate) { + const result = []; + const seen = new Set(); + while (certificate !== undefined && !seen.has(certificate)) { + seen.add(certificate); + result.push(certificate.raw); + certificate = certificate.issuerCertificate; + } + return result; +} + +async function cloneViaMessagePort(certificate) { + const { port1, port2 } = new MessageChannel(); + port1.postMessage(certificate); + const [clone] = await once(port2, 'message'); + port1.close(); + port2.close(); + return clone; +} + +async function cloneViaWorker(certificate) { + const worker = new Worker(` + 'use strict'; + const { parentPort } = require('node:worker_threads'); + parentPort.once('message', (certificate) => { + parentPort.postMessage(certificate); + }); + `, { eval: true }); + worker.postMessage(certificate); + const [clone] = await once(worker, 'message'); + await worker.terminate(); + return clone; +} + +const server = tls.createServer({ + key: fixtures.readKey('agent6-key.pem'), + cert: fixtures.readKey('agent6-cert.pem'), +}, (socket) => socket.end()); + +(async () => { + server.listen(0); + await once(server, 'listening'); + + const socket = tls.connect({ + port: server.address().port, + rejectUnauthorized: false, + }); + await once(socket, 'secureConnect'); + + const first = socket.getPeerX509Certificate(); + assertChain(first); + + const firstLegacy = socket.getPeerCertificate(true); + const second = socket.getPeerX509Certificate(); + const secondLegacy = socket.getPeerCertificate(true); + assertChain(second); + assert.deepStrictEqual(legacyChainRaw(firstLegacy), [leaf.raw, issuer.raw]); + assert.deepStrictEqual(legacyChainRaw(secondLegacy), [leaf.raw, issuer.raw]); + + assertChain(structuredClone(first)); + assertChain(await cloneViaMessagePort(first)); + assertChain(await cloneViaWorker(first)); + + socket.destroy(); + server.close(); + await once(server, 'close'); +})().then(common.mustCall()); diff --git a/test/parallel/test-crypto-x509-peer-chain.js b/test/parallel/test-crypto-x509-peer-chain.js new file mode 100644 index 00000000000..b60f3d00acc --- /dev/null +++ b/test/parallel/test-crypto-x509-peer-chain.js @@ -0,0 +1,110 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { X509Certificate } = require('node:crypto'); +const { once } = require('node:events'); +const tls = require('node:tls'); +const { MessageChannel, Worker } = require('node:worker_threads'); +const fixtures = require('../common/fixtures'); + +const leaf = new X509Certificate(fixtures.readKey('agent6-cert.pem')); +const issuer = new X509Certificate(fixtures.readKey('ca3-cert.pem')); +const unrelated = new X509Certificate(fixtures.readKey('agent1-cert.pem')); +const key = fixtures.readKey('agent6-key.pem'); +const chains = [ + [leaf, issuer, unrelated], + [leaf, unrelated, issuer], + [leaf, issuer, issuer], + [leaf, issuer, unrelated, issuer], + [leaf, leaf, issuer], +]; + +function assertChain(actual, expected) { + const seen = new Set(); + for (const certificate of expected) { + assert(actual instanceof X509Certificate); + assert(!seen.has(actual)); + seen.add(actual); + assert.deepStrictEqual(actual.raw, certificate.raw); + assert.strictEqual(actual.issuerCertificate, actual.issuerCertificate); + actual = actual.issuerCertificate; + } + assert.strictEqual(actual, undefined); +} + +async function assertClones(certificate, chain) { + assertChain(structuredClone(certificate), chain); + + const { port1, port2 } = new MessageChannel(); + port1.postMessage(certificate); + const [messageClone] = await once(port2, 'message'); + port1.close(); + port2.close(); + assertChain(messageClone, chain); + + const worker = new Worker(` + const { parentPort } = require('node:worker_threads'); + parentPort.once('message', (certificate) => { + parentPort.postMessage(certificate); + }); + `, { eval: true }); + worker.postMessage(certificate); + const [workerClone] = await once(worker, 'message'); + await worker.terminate(); + assertChain(workerClone, chain); +} + +async function checkPeer(socket, chain) { + const first = socket.getPeerX509Certificate(); + assertChain(first, chain); + for (let i = 0; i < 2; i++) { + assert.deepStrictEqual(socket.getPeerCertificate(true).raw, leaf.raw); + assertChain(socket.getPeerX509Certificate(), chain); + } + await assertClones(first, chain); +} + +async function test(chain) { + // Encode each certificate separately: agent6-cert.pem contains its issuer. + const cert = chain.map((certificate) => certificate.toString()).join(''); + const server = tls.createServer({ + key, + cert, + requestCert: true, + rejectUnauthorized: false, + }); + server.listen(0); + await once(server, 'listening'); + + const peer = once(server, 'secureConnection'); + const client = tls.connect({ + port: server.address().port, + key, + cert, + rejectUnauthorized: false, + }); + await once(client, 'secureConnect'); + const [socket] = await peer; + + // Client and server certificate stacks handle the leaf differently; both + // sockets must expose every certificate sent by the peer exactly once. + await checkPeer(client, chain); + await checkPeer(socket, chain); + + // Clones must remain usable after their TLS session has been destroyed. + const clone = structuredClone(client.getPeerX509Certificate()); + client.destroy(); + socket.destroy(); + const closed = once(server, 'close'); + server.close(); + await closed; + assertChain(clone, chain); +} + +(async () => { + for (const chain of chains) await test(chain); +})().then(common.mustCall()); From 8d169a89ccba0982e92c48b7854fd266c0461c03 Mon Sep 17 00:00:00 2001 From: Huang-404-Q <129407632+Huang-404-Q@users.noreply.github.com> Date: Wed, 28 Oct 2026 21:31:19 +0800 Subject: [PATCH 130/331] http2: clear the session timeout before marking it destroyed closeSession() set SESSION_FLAGS_DESTROYED and then called session.setTimeout(0). setStreamTimeout() returns early when the session is destroyed, so the idle timer stayed armed and retained the session until the server timeout fired. Clear the timeout and remove its listeners before setting the destroyed flag. Fixes: https://github.com/nodejs/node/issues/66885 Signed-off-by: huang <13165998033@163.com> PR-URL: https://github.com/nodejs/node/pull/66886 Reviewed-By: Tim Perry --- lib/internal/http2/core.js | 9 +++-- ...ion-timeout-cleared-on-close-raw-socket.js | 38 +++++++++++++++++++ ...-http2-session-timeout-cleared-on-close.js | 32 ++++++++++++++++ 3 files changed, 76 insertions(+), 3 deletions(-) create mode 100644 test/parallel/test-http2-session-timeout-cleared-on-close-raw-socket.js create mode 100644 test/parallel/test-http2-session-timeout-cleared-on-close.js diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js index 96f03779681..4e6d211999c 100644 --- a/lib/internal/http2/core.js +++ b/lib/internal/http2/core.js @@ -1242,13 +1242,16 @@ function closeSession(session, code, error) { debugSessionObj(session, 'start closing/destroying', error); const state = session[kState]; - state.flags |= SESSION_FLAGS_DESTROYED; - state.destroyCode = code; - // Clear timeout and remove timeout listeners. + // Clear timeout and remove timeout listeners before marking the session + // destroyed: setTimeout() is a no-op once destroyed, so the idle timer + // would otherwise stay armed and retain the session. session.setTimeout(0); session.removeAllListeners('timeout'); + state.flags |= SESSION_FLAGS_DESTROYED; + state.destroyCode = code; + const socket = session[kSocket]; const handle = session[kHandle]; diff --git a/test/parallel/test-http2-session-timeout-cleared-on-close-raw-socket.js b/test/parallel/test-http2-session-timeout-cleared-on-close-raw-socket.js new file mode 100644 index 00000000000..1df70ec9b52 --- /dev/null +++ b/test/parallel/test-http2-session-timeout-cleared-on-close-raw-socket.js @@ -0,0 +1,38 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); +const assert = require('assert'); +const http2 = require('http2'); +const net = require('net'); + +// Same as test-http2-session-timeout-cleared-on-close.js, but the client's +// TCP socket is destroyed without sending GOAWAY. +const server = http2.createServer(); +server.setTimeout(30_000, common.mustNotCall()); + +server.on('session', common.mustCall((session) => { + session.on('goaway', common.mustNotCall()); + session.on('close', common.mustCall(() => { + assert.strictEqual(session.timeout, 0); + server.close(); + })); +})); + +server.on('stream', common.mustCall((stream) => { + stream.respond({ ':status': 200 }); + stream.end('ok'); +})); + +server.listen(0, common.mustCall(() => { + let socket; + const client = http2.connect(`http://localhost:${server.address().port}`, { + createConnection: (url) => (socket = net.connect(url.port, url.hostname)), + }); + client.on('error', () => {}); + const req = client.request(); + req.on('error', () => {}); + req.resume(); + req.on('end', common.mustCall(() => socket.destroy())); +})); diff --git a/test/parallel/test-http2-session-timeout-cleared-on-close.js b/test/parallel/test-http2-session-timeout-cleared-on-close.js new file mode 100644 index 00000000000..476e60702ab --- /dev/null +++ b/test/parallel/test-http2-session-timeout-cleared-on-close.js @@ -0,0 +1,32 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); +const assert = require('assert'); +const http2 = require('http2'); + +// A destroyed session must not keep its idle timer armed: setTimeout() is a +// no-op once the session is marked destroyed, so closeSession() has to clear +// the timer first. +const server = http2.createServer(); +server.setTimeout(30_000, common.mustNotCall()); + +server.on('session', common.mustCall((session) => { + session.on('close', common.mustCall(() => { + assert.strictEqual(session.timeout, 0); + server.close(); + })); +})); + +server.on('stream', common.mustCall((stream) => { + stream.respond({ ':status': 200 }); + stream.end('ok'); +})); + +server.listen(0, common.mustCall(() => { + const client = http2.connect(`http://localhost:${server.address().port}`); + const req = client.request(); + req.resume(); + req.on('end', common.mustCall(() => client.close())); +})); From 1ab11281a7892add7968a79213c100901458e102 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 14:33:23 +0100 Subject: [PATCH 131/331] meta: bump github/codeql-action/init from 4.38.2 to 4.39.1 Bumps [github/codeql-action/init](https://github.com/github/codeql-action) from 4.38.2 to 4.39.1. - [Release notes](https://github.com/github/codeql-action/releases) - [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md) - [Commits](https://github.com/github/codeql-action/compare/2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2...9b3254085494b55a0f7c4c2b3d2d52cc712ce370) Bumps [github/codeql-action/upload-sarif](https://github.com/github/codeql-action) from 4.38.2 to 4.39.1. - [Release notes](https://github.com/github/codeql-action/releases) - [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md) - [Commits](https://github.com/github/codeql-action/compare/2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2...9b3254085494b55a0f7c4c2b3d2d52cc712ce370) Bumps [github/codeql-action/autobuild](https://github.com/github/codeql-action) from 4.38.2 to 4.39.1. - [Release notes](https://github.com/github/codeql-action/releases) - [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md) - [Commits](https://github.com/github/codeql-action/compare/2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2...9b3254085494b55a0f7c4c2b3d2d52cc712ce370) Bumps [github/codeql-action/analyze](https://github.com/github/codeql-action) from 4.38.2 to 4.39.1. - [Release notes](https://github.com/github/codeql-action/releases) - [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md) - [Commits](https://github.com/github/codeql-action/compare/2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2...9b3254085494b55a0f7c4c2b3d2d52cc712ce370) --- updated-dependencies: - dependency-name: github/codeql-action/init dependency-version: 4.39.1 dependency-type: direct:production update-type: version-update:semver-minor - dependency-name: github/codeql-action/upload-sarif dependency-version: 4.39.1 dependency-type: direct:production update-type: version-update:semver-minor - dependency-name: github/codeql-action/autobuild dependency-version: 4.39.1 dependency-type: direct:production update-type: version-update:semver-minor - dependency-name: github/codeql-action/analyze dependency-version: 4.39.1 dependency-type: direct:production update-type: version-update:semver-minor ... PR-URL: https://github.com/nodejs/node/pull/67028 Reviewed-By: Christian Clauss Reviewed-By: Colin Ihrig --- .github/workflows/codeql.yml | 6 +++--- .github/workflows/scorecard.yml | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index d8eca1f2b79..6ad66a72676 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -30,15 +30,15 @@ jobs: # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL - uses: github/codeql-action/init@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2 + uses: github/codeql-action/init@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1 with: languages: ${{ matrix.language }} config-file: ./.github/codeql-config.yml - name: Autobuild - uses: github/codeql-action/autobuild@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2 + uses: github/codeql-action/autobuild@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1 - name: Perform CodeQL Analysis - uses: github/codeql-action/analyze@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2 + uses: github/codeql-action/analyze@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1 with: category: /language:${{matrix.language}} diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml index 2663019bcc2..ee20d5a045e 100644 --- a/.github/workflows/scorecard.yml +++ b/.github/workflows/scorecard.yml @@ -76,6 +76,6 @@ jobs: # Upload the results to GitHub's code scanning dashboard. - name: Upload to code-scanning - uses: github/codeql-action/upload-sarif@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2 + uses: github/codeql-action/upload-sarif@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1 with: sarif_file: results.sarif From 2d64e56faabecdf294eca615720b1e775c728db8 Mon Sep 17 00:00:00 2001 From: Yagiz Nizipli Date: Wed, 28 Oct 2026 09:56:55 -0400 Subject: [PATCH 132/331] zlib: skip the stream in sync convenience calls without options `zlib.inflateSync(buffer)` and the other synchronous convenience methods constructed a Transform stream for every call, even though only its native handle is used and, without options, the stream is never exposed. They also allocated a fresh output chunk for every call. When no options are passed, drive a native handle created with the default settings directly, and decompress into a scratch buffer kept between calls, copying the result out. Calls with options, including `info`, keep the existing path. Results and errors are unchanged. Signed-off-by: Yagiz Nizipli Assisted-by: Grok PR-URL: https://github.com/nodejs/node/pull/66864 Reviewed-By: Matteo Collina --- lib/zlib.js | 181 ++++++++++++++++-- .../test-zlib-sync-without-options.js | 136 +++++++++++++ 2 files changed, 298 insertions(+), 19 deletions(-) create mode 100644 test/parallel/test-zlib-sync-without-options.js diff --git a/lib/zlib.js b/lib/zlib.js index d03a394e423..40bc1d5a7fa 100644 --- a/lib/zlib.js +++ b/lib/zlib.js @@ -32,6 +32,7 @@ const { ObjectKeys, ObjectSetPrototypeOf, ReflectApply, + SafeMap, Symbol, SymbolHasInstance, Uint32Array, @@ -178,43 +179,128 @@ function zlibBufferOnEnd() { this.cb(null, buf); } -function zlibBufferSync(engine, buffer) { +function toSyncInput(buffer) { if (typeof buffer === 'string') { - buffer = Buffer.from(buffer); - } else if (!isArrayBufferView(buffer)) { + return Buffer.from(buffer); + } + if (!isArrayBufferView(buffer)) { if (isAnyArrayBuffer(buffer)) { - buffer = Buffer.from(buffer); - } else { - throw new ERR_INVALID_ARG_TYPE( - 'buffer', - ['string', 'Buffer', 'TypedArray', 'DataView', 'ArrayBuffer'], - buffer, - ); + return Buffer.from(buffer); } + throw new ERR_INVALID_ARG_TYPE( + 'buffer', + ['string', 'Buffer', 'TypedArray', 'DataView', 'ArrayBuffer'], + buffer, + ); } + return buffer; +} + +function zlibBufferSync(engine, buffer) { + buffer = toSyncInput(buffer); buffer = processChunkSync(engine, buffer, engine._finishFlushFlag); if (engine._info) return { buffer, engine }; return buffer; } +function zlibError(message, errno, code) { + if (code === 'ERR_TRAILING_JUNK_AFTER_STREAM_END') { + return new ERR_TRAILING_JUNK_AFTER_STREAM_END(); + } + const error = genericNodeError(message, { errno, code }); + error.errno = errno; + error.code = code; + return error; +} + function zlibOnError(message, errno, code) { const self = this[owner_symbol]; // There is no way to cleanly recover. // Continuing only obscures problems. - - let error; - if (code === 'ERR_TRAILING_JUNK_AFTER_STREAM_END') { - error = new ERR_TRAILING_JUNK_AFTER_STREAM_END(); - } else { - error = genericNodeError(message, { errno, code }); - error.errno = errno; - error.code = code; - } + const error = zlibError(message, errno, code); self.destroy(error); self[kError] = error; } +// Without options, a synchronous convenience call (zlib.inflateSync(buffer), +// ...) uses the defaults and its engine is never exposed, so it drives a +// native handle directly instead of constructing a Transform stream. It also +// decompresses into a scratch buffer kept between calls and copies the result +// out, instead of allocating a whole output chunk per call. +let syncScratchBuffer; + +function zlibSyncOnError(message, errno, code) { + this[kError] = zlibError(message, errno, code); +} + +function zlibBufferSyncWithDefaults(ctor, buffer) { + const chunk = toSyncInput(buffer); + const mode = kEngineModes.get(ctor); + const writeState = new Uint32Array(2); + const handle = createDefaultHandle(mode, writeState); + handle.onerror = zlibSyncOnError; + // Take the scratch buffer, so that a nested call (e.g. from an async hook) + // allocates its own. + const scratch = syncScratchBuffer ?? Buffer.allocUnsafeSlow(Z_DEFAULT_CHUNK); + syncScratchBuffer = undefined; + try { + return processSyncWithDefaults(handle, writeState, chunk, + defaultFinishFlush(mode), scratch); + } finally { + handle.close(); + syncScratchBuffer = scratch; + } +} + +// Same as processChunkSync() for an engine created without options. +function processSyncWithDefaults(handle, writeState, chunk, flushFlag, + scratch) { + const chunkSize = Z_DEFAULT_CHUNK; + let out = scratch; + let inOff = 0; + let availIn = chunk.byteLength; + let buffers = null; + let nread = 0; + + while (true) { + handle.writeSync(flushFlag, chunk, inOff, availIn, out, 0, chunkSize); + if (handle[kError] !== undefined) + throw handle[kError]; + + const availOutAfter = writeState[0]; + const availInAfter = writeState[1]; + const have = chunkSize - availOutAfter; + if (have > 0) { + nread += have; + if (nread > kMaxLength) + throw new ERR_BUFFER_TOO_LARGE(kMaxLength); + if (out !== scratch) { + buffers.push(out.subarray(0, have)); + } else if (availOutAfter === 0) { + buffers = [out]; + } + } + if (availOutAfter !== 0) + break; + + // The output buffer is full. Continue with the rest of the input. + inOff += availIn - availInAfter; + availIn = availInAfter; + out = Buffer.allocUnsafe(chunkSize); + } + + if (nread === 0) + return new FastBuffer(); + if (buffers === null) { + // All of the output is in the scratch buffer. + const result = Buffer.allocUnsafe(nread); + scratch.copy(result, 0, 0, nread); + return result; + } + return Buffer.concat(buffers, nread); +} + const FLUSH_BOUND = [ [ Z_NO_FLUSH, Z_BLOCK ], [ BROTLI_OPERATION_PROCESS, BROTLI_OPERATION_EMIT_METADATA ], @@ -830,6 +916,8 @@ ObjectSetPrototypeOf(Unzip, Zlib); function createConvenienceMethod(ctor, sync, prepareOpts) { if (sync) { return function syncBufferWrapper(buffer, opts) { + if (opts === undefined) + return zlibBufferSyncWithDefaults(ctor, buffer); return zlibBufferSync(new ctor(opts), buffer); }; } @@ -1039,6 +1127,61 @@ class ZstdDecompress extends Zstd { } } +const kEngineModes = new SafeMap([ + [Deflate, DEFLATE], + [Inflate, INFLATE], + [Gzip, GZIP], + [Gunzip, GUNZIP], + [DeflateRaw, DEFLATERAW], + [InflateRaw, INFLATERAW], + [Unzip, UNZIP], + [BrotliCompress, BROTLI_ENCODE], + [BrotliDecompress, BROTLI_DECODE], + [ZstdCompress, ZSTD_COMPRESS], + [ZstdDecompress, ZSTD_DECOMPRESS], +]); + +// Creates the native handle that the engine for `mode` creates when its +// constructor gets no options. +function createDefaultHandle(mode, writeState) { + let handle; + switch (mode) { + case BROTLI_ENCODE: + case BROTLI_DECODE: + handle = mode === BROTLI_DECODE ? + new binding.BrotliDecoder(mode) : new binding.BrotliEncoder(mode); + brotliInitParamsArray.fill(-1); + handle.init(brotliInitParamsArray, writeState, processCallback, undefined); + return handle; + case ZSTD_COMPRESS: + zstdInitCParamsArray.fill(-1); + handle = new binding.ZstdCompress(); + handle.init(zstdInitCParamsArray, undefined, writeState, processCallback, + undefined, false); + return handle; + case ZSTD_DECOMPRESS: + zstdInitDParamsArray.fill(-1); + handle = new binding.ZstdDecompress(); + handle.init(zstdInitDParamsArray, undefined, writeState, processCallback, + undefined, false); + return handle; + default: + handle = new binding.Zlib(mode); + handle.init(Z_DEFAULT_WINDOWBITS, Z_DEFAULT_COMPRESSION, + Z_DEFAULT_MEMLEVEL, Z_DEFAULT_STRATEGY, writeState, + processCallback, undefined, false); + return handle; + } +} + +function defaultFinishFlush(mode) { + if (mode === BROTLI_ENCODE || mode === BROTLI_DECODE) + return brotliDefaultOpts.finishFlush; + if (mode === ZSTD_COMPRESS || mode === ZSTD_DECOMPRESS) + return zstdDefaultOpts.finishFlush; + return zlibDefaultOpts.finishFlush; +} + function createProperty(ctor) { return { __proto__: null, diff --git a/test/parallel/test-zlib-sync-without-options.js b/test/parallel/test-zlib-sync-without-options.js new file mode 100644 index 00000000000..d155f926442 --- /dev/null +++ b/test/parallel/test-zlib-sync-without-options.js @@ -0,0 +1,136 @@ +'use strict'; +// Synchronous convenience methods called without options skip the stream and +// reuse an internal output buffer. Check that they behave exactly like calls +// that pass an empty options object, which go through the stream. + +const common = require('../common'); +const assert = require('assert'); +const async_hooks = require('async_hooks'); +const fs = require('fs'); +const zlib = require('zlib'); + +const { Z_DEFAULT_CHUNK } = zlib.constants; + +const pairs = [ + ['deflateSync', 'inflateSync'], + ['gzipSync', 'gunzipSync'], + ['gzipSync', 'unzipSync'], + ['deflateRawSync', 'inflateRawSync'], + ['brotliCompressSync', 'brotliDecompressSync'], + ['zstdCompressSync', 'zstdDecompressSync'], +]; + +const random = Buffer.alloc(3 * Z_DEFAULT_CHUNK); +{ + let seed = 0x9e3779b9; + for (let i = 0; i < random.length; i++) { + seed ^= seed << 13; + seed ^= seed >>> 17; + seed ^= seed << 5; + random[i] = seed & 0xff; + } +} +const text = fs.readFileSync(__filename); + +// Outputs that fit in one output buffer, fill it exactly, and span several. +const inputs = [ + Buffer.alloc(0), + Buffer.from('hello'), + text, + Buffer.alloc(Z_DEFAULT_CHUNK, 'a'), + Buffer.alloc(Z_DEFAULT_CHUNK + 1, 'b'), + Buffer.concat([text, random, text]), +]; + +for (const [compress, decompress] of pairs) { + for (const input of inputs) { + const label = `${compress}/${decompress} ${input.length}`; + const compressed = zlib[compress](input); + assert.ok(Buffer.isBuffer(compressed), label); + assert.deepStrictEqual(compressed, zlib[compress](input, {}), label); + + const decompressed = zlib[decompress](compressed); + assert.ok(Buffer.isBuffer(decompressed), label); + assert.deepStrictEqual(decompressed, input, label); + assert.deepStrictEqual(decompressed, zlib[decompress](compressed, {}), + label); + } + + // Every input type. + const expected = zlib[decompress](zlib[compress]('blah'.repeat(8))); + for (const view of [ + 'blah'.repeat(8), + ...common.getBufferSources(Buffer.from('blah'.repeat(8))), + ]) { + assert.deepStrictEqual(zlib[decompress](zlib[compress](view)), expected); + } +} + +// Results never share memory with each other. +{ + const a = zlib.deflateSync('first'); + const b = zlib.deflateSync('second'); + const first = zlib.inflateSync(a); + const second = zlib.inflateSync(b); + assert.strictEqual(first.toString(), 'first'); + assert.strictEqual(second.toString(), 'second'); + second.fill(0); + assert.strictEqual(first.toString(), 'first'); + assert.strictEqual(zlib.inflateSync(a).toString(), 'first'); +} + +// Errors are the same as through the stream. +for (const [method, input] of [ + ['inflateSync', Buffer.from('not compressed')], + ['gunzipSync', Buffer.from('not compressed')], + ['unzipSync', Buffer.from('not compressed')], + ['inflateRawSync', Buffer.from('not compressed')], + ['brotliDecompressSync', Buffer.from('not compressed')], + ['zstdDecompressSync', Buffer.from('not compressed')], + ['inflateSync', zlib.deflateSync(text).subarray(0, 100)], + ['gunzipSync', zlib.gzipSync(text).subarray(0, 100)], + ['brotliDecompressSync', zlib.brotliCompressSync(text).subarray(0, 100)], + ['zstdDecompressSync', zlib.zstdCompressSync(text).subarray(0, 100)], +]) { + let expected; + assert.throws(() => zlib[method](input, {}), (err) => { + expected = err; + return true; + }); + assert.throws(() => zlib[method](input), (err) => { + assert.strictEqual(err.constructor, expected.constructor); + assert.strictEqual(err.message, expected.message); + assert.strictEqual(err.code, expected.code); + assert.strictEqual(err.errno, expected.errno); + return true; + }, method); +} + +for (const [compress] of pairs) { + assert.throws(() => zlib[compress](42), { + code: 'ERR_INVALID_ARG_TYPE', + name: 'TypeError', + }); +} + +// A synchronous call made from an async hook while another one is running. +{ + const compressed = zlib.deflateSync(text); + let nested; + const hook = async_hooks.createHook({ + before() { + if (nested === undefined) { + nested = null; + nested = zlib.inflateSync(compressed); + } + }, + }).enable(); + // The error is reported through a callback into JavaScript, which runs the + // before hook. + assert.throws(() => zlib.inflateSync(Buffer.from('not compressed')), { + code: 'Z_DATA_ERROR', + }); + hook.disable(); + assert.deepStrictEqual(nested, text); + assert.deepStrictEqual(zlib.inflateSync(compressed), text); +} From 34134917a3e841058c5e06a552b6074df3afc860 Mon Sep 17 00:00:00 2001 From: Yagiz Nizipli Date: Mon, 19 Oct 2026 12:08:21 -0400 Subject: [PATCH 133/331] zlib: finish async convenience calls in one write The asynchronous convenience methods (`zlib.deflate()`, `zlib.inflate()`, `zlib.gunzip()`, ...) wrote the input to a Transform stream and then ended it. That took two threadpool round trips, one for the data and one for the final flush, and ran the result through the stream machinery. The whole input is known up front, so unless `info` or a custom `flush` is requested, process it with the finish flush directly, the way the synchronous methods already do, and collect the output in the write callback. A call whose output fits in one buffer now takes a single threadpool round trip. The output is unchanged: the previous two-write sequence already produced the same bytes as the synchronous methods. `zstdCompress()` keeps the separate end-of-frame write, because a single `ZSTD_e_end` call can produce slightly larger frames. benchmark/compare.js, 40 runs, n=100000: confidence improvement zlib/inflate.js method='inflate' *** +94.91 % zlib/deflate.js method='deflate' *** +66.27 % Signed-off-by: Yagiz Nizipli Assisted-by: Grok PR-URL: https://github.com/nodejs/node/pull/66863 Reviewed-By: Robert Nagy Reviewed-By: Matteo Collina --- lib/zlib.js | 95 ++++-- .../test-zlib-convenience-async-round-trip.js | 74 +++++ test/parallel/test-zlib-convenience-async.js | 309 ++++++++++++++++++ 3 files changed, 454 insertions(+), 24 deletions(-) create mode 100644 test/parallel/test-zlib-convenience-async-round-trip.js create mode 100644 test/parallel/test-zlib-convenience-async.js diff --git a/lib/zlib.js b/lib/zlib.js index 40bc1d5a7fa..aded73c1307 100644 --- a/lib/zlib.js +++ b/lib/zlib.js @@ -90,6 +90,7 @@ const { const kFlushFlag = Symbol('kFlushFlag'); const kError = Symbol('kError'); +const kBufferResult = Symbol('kBufferResult'); const constants = internalBinding('constants').zlib; const { @@ -127,7 +128,7 @@ for (const ckey of ObjectKeys(codes)) { codes[codes[ckey]] = ckey; } -function zlibBuffer(engine, buffer, callback) { +function zlibBuffer(engine, buffer, callback, finishInOneWrite) { validateFunction(callback, 'callback'); // Streams do not support non-Uint8Array ArrayBufferViews yet. Convert it to a // Buffer without copying. @@ -139,44 +140,81 @@ function zlibBuffer(engine, buffer, callback) { engine.buffers = null; engine.nread = 0; engine.cb = callback; - engine.on('data', zlibBufferOnData); engine.on('error', zlibBufferOnError); + + // The whole input is known up front. Unless the engine is handed to the + // caller (`info`) or a custom flush is requested, process it with the finish + // flush directly, like the synchronous methods do. This takes one threadpool + // round trip instead of a write followed by a separate final flush, and skips + // the stream machinery. + if (finishInOneWrite && !engine._info && + engine._defaultFlushFlag === FLUSH_BOUND[engine._flushBoundIdx][0]) { + if (typeof buffer === 'string') { + // Encode strings like Writable#write() does. + buffer = Buffer.from(buffer, engine._writableState.defaultEncoding); + } + if (isUint8Array(buffer)) { + engine[kBufferResult] = true; + processChunk(engine, buffer, engine._finishFlushFlag, + zlibBufferOnWriteDone); + return; + } + } + + engine.on('data', zlibBufferOnData); engine.on('end', zlibBufferOnEnd); engine.end(buffer); } -function zlibBufferOnData(chunk) { - if (!this.buffers) { - this.buffers = [chunk]; +function zlibBufferAddChunk(engine, chunk) { + if (!engine.buffers) { + engine.buffers = [chunk]; } else { - this.buffers.push(chunk); + engine.buffers.push(chunk); } - this.nread += chunk.length; - if (this.nread > this._maxOutputLength) { - this.close(); - this.removeAllListeners('end'); - this.cb(new ERR_BUFFER_TOO_LARGE(this._maxOutputLength)); + engine.nread += chunk.length; + if (engine.nread > engine._maxOutputLength) { + engine.close(); + engine.removeAllListeners('end'); + engine.cb(new ERR_BUFFER_TOO_LARGE(engine._maxOutputLength)); } } +function zlibBufferOnData(chunk) { + zlibBufferAddChunk(this, chunk); +} + function zlibBufferOnError(err) { this.removeAllListeners('end'); this.cb(err); } -function zlibBufferOnEnd() { +function zlibBufferFinish(engine) { let buf; - if (this.nread === 0) { + if (engine.nread === 0) { buf = new FastBuffer(); } else { - const bufs = this.buffers; - buf = (bufs.length === 1 ? bufs[0] : Buffer.concat(bufs, this.nread)); + const bufs = engine.buffers; + buf = (bufs.length === 1 ? bufs[0] : Buffer.concat(bufs, engine.nread)); } - this.close(); - if (this._info) - this.cb(null, { buffer: buf, engine: this }); + engine.close(); + if (engine._info) + engine.cb(null, { buffer: buf, engine }); else - this.cb(null, buf); + engine.cb(null, buf); +} + +function zlibBufferOnEnd() { + zlibBufferFinish(this); +} + +// Called by processCallback(), with the handle as `this`, once the whole input +// has been processed. Errors have already been reported to the callback, either +// through the 'error' event or by zlibBufferAddChunk(). +function zlibBufferOnWriteDone(err) { + const engine = this[owner_symbol]; + if (err === undefined && !engine.destroyed) + zlibBufferFinish(engine); } function toSyncInput(buffer) { @@ -653,7 +691,10 @@ function processCallback() { if (have > 0) { const out = self._outBuffer.slice(self._outOffset, self._outOffset + have); self._outOffset += have; - streamBufferIsFull = !self.push(out); + if (self[kBufferResult] === true) + zlibBufferAddChunk(self, out); + else + streamBufferIsFull = !self.push(out); } else { assert(have === 0, 'have should not go down'); } @@ -719,7 +760,8 @@ function processCallback() { return; } - self.push(null); + if (self[kBufferResult] !== true) + self.push(null); } // Finished with the chunk. @@ -913,7 +955,8 @@ function Unzip(opts) { ObjectSetPrototypeOf(Unzip.prototype, Zlib.prototype); ObjectSetPrototypeOf(Unzip, Zlib); -function createConvenienceMethod(ctor, sync, prepareOpts) { +function createConvenienceMethod(ctor, sync, prepareOpts, + finishInOneWrite = true) { if (sync) { return function syncBufferWrapper(buffer, opts) { if (opts === undefined) @@ -929,7 +972,7 @@ function createConvenienceMethod(ctor, sync, prepareOpts) { if (prepareOpts !== undefined) { opts = prepareOpts(buffer, opts); } - return zlibBuffer(new ctor(opts), buffer, callback); + return zlibBuffer(new ctor(opts), buffer, callback, finishInOneWrite); }; } @@ -1312,7 +1355,11 @@ module.exports = { brotliCompressSync: createConvenienceMethod(BrotliCompress, true), brotliDecompress: createConvenienceMethod(BrotliDecompress, false), brotliDecompressSync: createConvenienceMethod(BrotliDecompress, true), - zstdCompress: createConvenienceMethod(ZstdCompress, false, withPledgedSrcSize), + // A zstd frame written by a single ZSTD_e_end call can be a few bytes larger + // than one written by ZSTD_e_continue followed by ZSTD_e_end, so + // zstdCompress() keeps writing the input and ending the frame separately. + zstdCompress: createConvenienceMethod(ZstdCompress, false, withPledgedSrcSize, + false), zstdCompressSync: createConvenienceMethod(ZstdCompress, true), zstdDecompress: createConvenienceMethod(ZstdDecompress, false), zstdDecompressSync: createConvenienceMethod(ZstdDecompress, true), diff --git a/test/parallel/test-zlib-convenience-async-round-trip.js b/test/parallel/test-zlib-convenience-async-round-trip.js new file mode 100644 index 00000000000..ab48f885272 --- /dev/null +++ b/test/parallel/test-zlib-convenience-async-round-trip.js @@ -0,0 +1,74 @@ +'use strict'; +// The asynchronous convenience methods know the whole input up front, so they +// process it with the finish flush in a single write. Check that a call whose +// output fits in one output buffer takes exactly one threadpool round trip. + +const common = require('../common'); +const assert = require('assert'); +const async_hooks = require('async_hooks'); +const zlib = require('zlib'); + +const input = Buffer.from('hello world '.repeat(64)); +// [method, argument, function that turns the result back into `input`] +const cases = [ + ['deflate', input, zlib.inflateSync], + ['inflate', zlib.deflateSync(input)], + ['gzip', input, zlib.gunzipSync], + ['gunzip', zlib.gzipSync(input)], + ['unzip', zlib.gzipSync(input)], + ['deflateRaw', input, zlib.inflateRawSync], + ['inflateRaw', zlib.deflateRawSync(input)], + ['brotliCompress', input, zlib.brotliDecompressSync], + ['brotliDecompress', zlib.brotliCompressSync(input)], + ['zstdDecompress', zlib.zstdCompressSync(input)], +]; + +// Counts the callbacks into JavaScript (`before` hooks) of each ZLIB resource +// created while `fn` runs. +async function countRoundTrips(fn) { + const callbacks = new Map(); + const hook = async_hooks.createHook({ + init(asyncId, type) { + if (type === 'ZLIB') callbacks.set(asyncId, 0); + }, + before(asyncId) { + if (callbacks.has(asyncId)) + callbacks.set(asyncId, callbacks.get(asyncId) + 1); + }, + }).enable(); + try { + await fn(); + } finally { + hook.disable(); + } + return [...callbacks.values()]; +} + +function callAsync(method, buffer, options = {}) { + return new Promise((resolve, reject) => { + zlib[method](buffer, options, common.mustCall((err, result) => { + if (err) reject(err); + else resolve(result); + })); + }); +} + +(async () => { + for (const [method, buffer, undo = (result) => result] of cases) { + let result; + const roundTrips = await countRoundTrips(async () => { + result = await callAsync(method, buffer); + }); + assert.deepStrictEqual(roundTrips, [1], method); + assert.deepStrictEqual(undo(result), input, method); + } + + // Errors are also reported after a single round trip. + let error; + const roundTrips = await countRoundTrips(async () => { + error = await callAsync('inflate', Buffer.from('not zlib data')) + .catch((err) => err); + }); + assert.deepStrictEqual(roundTrips, [1]); + assert.strictEqual(error.code, 'Z_DATA_ERROR'); +})().then(common.mustCall()); diff --git a/test/parallel/test-zlib-convenience-async.js b/test/parallel/test-zlib-convenience-async.js new file mode 100644 index 00000000000..c66f259fea0 --- /dev/null +++ b/test/parallel/test-zlib-convenience-async.js @@ -0,0 +1,309 @@ +'use strict'; +// Tests the contract of the asynchronous convenience methods +// (zlib.deflate(), zlib.gunzip(), zlib.brotliCompress(), ...). + +const common = require('../common'); +const assert = require('assert'); +const { AsyncLocalStorage } = require('async_hooks'); +const fs = require('fs'); +const { promisify } = require('util'); +const zlib = require('zlib'); + +const { + Z_SYNC_FLUSH, + Z_FULL_FLUSH, + Z_BUF_ERROR, + Z_DATA_ERROR, + Z_NEED_DICT, + Z_MIN_CHUNK, + Z_DEFAULT_CHUNK, + BROTLI_OPERATION_FLUSH, + ZSTD_e_flush, +} = zlib.constants; + +const pairs = [ + { compress: 'deflate', decompress: 'inflate', engine: 'Inflate' }, + { compress: 'gzip', decompress: 'gunzip', engine: 'Gunzip' }, + { compress: 'gzip', decompress: 'unzip', engine: 'Unzip' }, + { compress: 'deflateRaw', decompress: 'inflateRaw', engine: 'InflateRaw' }, + { + compress: 'brotliCompress', + decompress: 'brotliDecompress', + engine: 'BrotliDecompress', + partialFlush: BROTLI_OPERATION_FLUSH, + }, + { + compress: 'zstdCompress', + decompress: 'zstdDecompress', + engine: 'ZstdDecompress', + partialFlush: ZSTD_e_flush, + }, +]; + +// Calls an asynchronous convenience method and resolves with its result. +// The callback must be called exactly once, and never synchronously. +function callAsync(method, input, options) { + return new Promise((resolve, reject) => { + let returned = false; + const callback = common.mustCall((err, result) => { + assert.strictEqual(returned, true, + `${method}() called its callback synchronously`); + if (err) reject(err); + else resolve(result); + }); + if (options === undefined) { + zlib[method](input, callback); + } else { + zlib[method](input, options, callback); + } + returned = true; + }); +} + +// Text plus pseudo-random bytes, large enough that the output of every +// algorithm spans several Z_DEFAULT_CHUNK-sized output buffers. +const text = fs.readFileSync(__filename); +const random = Buffer.alloc(3 * Z_DEFAULT_CHUNK); +{ + let seed = 0x9e3779b9; + for (let i = 0; i < random.length; i++) { + seed ^= seed << 13; + seed ^= seed >>> 17; + seed ^= seed << 5; + random[i] = seed & 0xff; + } +} +const data = Buffer.concat([text, random, Buffer.alloc(8 * Z_DEFAULT_CHUNK, 'a')]); +const shortString = 'blah'.repeat(8); + +async function testRoundTrip({ compress, decompress, partialFlush }) { + const syncCompress = `${compress}Sync`; + const syncDecompress = `${decompress}Sync`; + + // Every documented input type. + const inputs = [ + ['string', shortString, Buffer.from(shortString)], + ['long string', text.toString(), text], + ['Buffer', data, data], + ['large ArrayBuffer', new Uint8Array(data).buffer, data], + ...common.getBufferSources(Buffer.from(shortString)).map((view) => [ + view[Symbol.toStringTag], view, Buffer.from(shortString), + ]), + ]; + + for (const [type, input, expected] of inputs) { + const label = `${compress}/${decompress} with ${type}`; + const compressed = await callAsync(compress, input); + assert.ok(Buffer.isBuffer(compressed), label); + // zstdCompress() pledges the input size and ends the frame separately, + // which yields different (not larger) frames than zstdCompressSync(). + if (compress !== 'zstdCompress') { + assert.deepStrictEqual(compressed, zlib[syncCompress](input), label); + } + // Interoperable with the synchronous API in both directions. + assert.deepStrictEqual(zlib[syncDecompress](compressed), expected, label); + const decompressed = + await callAsync(decompress, zlib[syncCompress](input)); + assert.ok(Buffer.isBuffer(decompressed), label); + assert.deepStrictEqual(decompressed, expected, label); + assert.deepStrictEqual(await callAsync(decompress, compressed), expected, + label); + } + + // A minimal chunkSize makes the work for one call span many output + // buffers. + const options = { chunkSize: Z_MIN_CHUNK }; + const compressed = await callAsync(compress, data, options); + if (compress !== 'zstdCompress') { + assert.deepStrictEqual(compressed, zlib[syncCompress](data, options)); + } + assert.deepStrictEqual(await callAsync(decompress, compressed, options), + data); + + // Empty input. + const empty = await callAsync(compress, Buffer.alloc(0)); + assert.deepStrictEqual(await callAsync(decompress, empty), Buffer.alloc(0)); + assert.deepStrictEqual( + await callAsync(decompress, Buffer.alloc(0), + { finishFlush: partialFlush ?? Z_SYNC_FLUSH }), + Buffer.alloc(0)); +} + +async function testErrors({ compress, decompress, partialFlush }) { + const compressed = zlib[`${compress}Sync`](data); + + // Truncated input. + const truncated = compressed.subarray(0, compressed.length >> 1); + await assert.rejects(callAsync(decompress, truncated), { + name: 'Error', + code: 'Z_BUF_ERROR', + errno: Z_BUF_ERROR, + message: 'unexpected end of file', + }); + + // A non-finalizing finishFlush returns as much as can be decompressed. + const partial = await callAsync(decompress, truncated, { + finishFlush: partialFlush ?? Z_SYNC_FLUSH, + }); + // Zstd only emits whole blocks, and this input is truncated inside the + // first one. + if (decompress !== 'zstdDecompress') assert.ok(partial.length > 0); + assert.deepStrictEqual(partial, data.subarray(0, partial.length)); + + // maxOutputLength applies to the output of the whole call. + await assert.rejects(callAsync(decompress, compressed, + { maxOutputLength: data.length - 1 }), { + name: 'RangeError', + code: 'ERR_BUFFER_TOO_LARGE', + message: `Cannot create a Buffer larger than ${data.length - 1} bytes`, + }); + assert.deepStrictEqual( + await callAsync(decompress, compressed, { maxOutputLength: data.length }), + data); + await assert.rejects(callAsync(compress, data, { maxOutputLength: 64 }), { + name: 'RangeError', + code: 'ERR_BUFFER_TOO_LARGE', + message: 'Cannot create a Buffer larger than 64 bytes', + }); +} + +async function testInfo({ compress, decompress, engine }) { + const compressed = zlib[`${compress}Sync`](data); + const result = await callAsync(decompress, compressed, { info: true }); + assert.deepStrictEqual(result.buffer, data); + assert.ok(result.engine instanceof zlib[engine]); + assert.strictEqual(result.engine.bytesWritten, compressed.length); +} + +async function testTrailingGarbage({ compress, decompress }) { + const compressed = zlib[`${compress}Sync`](data); + const withJunk = Buffer.concat([compressed, Buffer.from('junk')]); + await assert.rejects( + callAsync(decompress, withJunk, { rejectGarbageAfterEnd: true }), { + name: 'TypeError', + code: 'ERR_TRAILING_JUNK_AFTER_STREAM_END', + }); + // Gzip treats bytes after a member as the start of another member. + if (decompress !== 'gunzip' && decompress !== 'unzip') { + assert.deepStrictEqual(await callAsync(decompress, withJunk), data); + } +} + +(async () => { + for (const pair of pairs) { + await testRoundTrip(pair); + await testErrors(pair); + await testInfo(pair); + await testTrailingGarbage(pair); + } + + // Invalid compressed data. + for (const [method, expected] of [ + ['inflate', { code: 'Z_DATA_ERROR', errno: Z_DATA_ERROR, + message: 'incorrect header check' }], + ['gunzip', { code: 'Z_DATA_ERROR', errno: Z_DATA_ERROR, + message: 'incorrect header check' }], + ['unzip', { code: 'Z_DATA_ERROR', errno: Z_DATA_ERROR, + message: 'incorrect header check' }], + ['inflateRaw', { code: 'Z_DATA_ERROR', errno: Z_DATA_ERROR }], + ['brotliDecompress', { code: /^ERR__ERROR_FORMAT_/, + message: 'Decompression failed' }], + ['zstdDecompress', { code: 'ZSTD_error_prefix_unknown', + message: 'Unknown frame descriptor' }], + ]) { + await assert.rejects( + callAsync(method, Buffer.from('this is not compressed data')), + { name: 'Error', ...expected }); + } + + // Concatenated gzip members are all decompressed. + { + const members = Buffer.concat([zlib.gzipSync('abc'), zlib.gzipSync('def')]); + assert.strictEqual((await callAsync('gunzip', members)).toString(), + 'abcdef'); + } + + // Dictionaries. + { + const dictionary = Buffer.from('a dictionary for the zlib tests'); + const input = 'zlib tests, a dictionary for the zlib tests'; + const compressed = await callAsync('deflate', input, { dictionary }); + assert.strictEqual( + (await callAsync('inflate', compressed, { dictionary })).toString(), + input); + await assert.rejects(callAsync('inflate', compressed), { + code: 'Z_NEED_DICT', + errno: Z_NEED_DICT, + message: 'Missing dictionary', + }); + await assert.rejects( + callAsync('inflate', compressed, { dictionary: Buffer.from('nope') }), { + code: 'Z_NEED_DICT', + message: 'Bad dictionary', + }); + } + + // Non-default flush and compression options still round-trip. + for (const options of [ + { flush: Z_SYNC_FLUSH }, + { flush: Z_FULL_FLUSH, level: 1 }, + { level: 9, memLevel: 9, windowBits: 9, strategy: zlib.constants.Z_RLE }, + ]) { + const compressed = await callAsync('deflate', data, options); + assert.deepStrictEqual(zlib.inflateSync(compressed, options), data); + } + + // Strings are encoded with the stream defaultEncoding option. + { + const compressed = await callAsync('deflate', 'ff00', + { defaultEncoding: 'hex' }); + assert.deepStrictEqual(zlib.inflateSync(compressed), + Buffer.from([0xff, 0x00])); + } + + // Many concurrent calls. + { + const inputs = Array.from({ length: 64 }, + (_, i) => data.subarray(i * 512, i * 1024 + 7)); + const results = await Promise.all(inputs.map(async (input) => { + const compressed = await callAsync('gzip', input); + return callAsync('gunzip', compressed); + })); + for (let i = 0; i < inputs.length; i++) { + assert.deepStrictEqual(results[i], inputs[i]); + } + } + + // util.promisify() works. + assert.deepStrictEqual( + zlib.inflateSync(await promisify(zlib.deflate)(data)), data); + + // The callback runs in the caller's AsyncLocalStorage context. + { + const als = new AsyncLocalStorage(); + const compressed = zlib.deflateSync(data); + await new Promise((resolve) => { + als.run('store', () => { + zlib.inflate(compressed, common.mustSucceed((result) => { + assert.strictEqual(als.getStore(), 'store'); + assert.deepStrictEqual(result, data); + resolve(); + })); + }); + }); + } + + // Invalid arguments throw synchronously without calling the callback. + assert.throws(() => zlib.deflate(1, common.mustNotCall()), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + }); + assert.throws(() => zlib.deflate(data), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + }); + assert.throws(() => zlib.deflate(data, { level: 42 }, common.mustNotCall()), { + name: 'RangeError', + code: 'ERR_OUT_OF_RANGE', + }); +})().then(common.mustCall()); From ba673eb18b993b1d3b66b0de98c73e28b5e88675 Mon Sep 17 00:00:00 2001 From: Yagiz Nizipli Date: Mon, 19 Oct 2026 13:07:51 -0400 Subject: [PATCH 134/331] zlib: grow the output buffer of large async one-shot calls The asynchronous convenience methods hand the whole input to zlib in one write, but still take one threadpool round trip per `chunkSize` (16 KiB by default) of output. Decompressing 4 MiB took 257 round trips. Only the concatenated result of these calls is observable, so double the output buffer whenever it fills up, up to 1 MiB. 4 MiB of output now takes 10 round trips. The buffer never grows past what is needed to tell that `maxOutputLength` was exceeded, and results that fit in the first buffer are unchanged. Signed-off-by: Yagiz Nizipli Assisted-by: Grok PR-URL: https://github.com/nodejs/node/pull/66863 Reviewed-By: Robert Nagy Reviewed-By: Matteo Collina --- lib/zlib.js | 15 ++++ .../test-zlib-convenience-async-large.js | 82 +++++++++++++++++++ .../test-zlib-convenience-async-round-trip.js | 16 +++- 3 files changed, 112 insertions(+), 1 deletion(-) create mode 100644 test/parallel/test-zlib-convenience-async-large.js diff --git a/lib/zlib.js b/lib/zlib.js index aded73c1307..d5ded609e55 100644 --- a/lib/zlib.js +++ b/lib/zlib.js @@ -24,6 +24,7 @@ const { ArrayBuffer, MathMax, + MathMin, NumberIsNaN, ObjectDefineProperties, ObjectDefineProperty, @@ -184,6 +185,18 @@ function zlibBufferOnData(chunk) { zlibBufferAddChunk(this, chunk); } +// Only the concatenated output of a one-shot call is observable, so its output +// buffer can double in size whenever it fills up, and large results take far +// fewer threadpool round trips. It never grows past what is needed to detect +// that maxOutputLength was exceeded. +const kMaxBufferResultChunkSize = 1024 * 1024; +function zlibBufferGrowChunkSize(engine) { + const size = MathMin(engine._chunkSize * 2, kMaxBufferResultChunkSize, + engine._maxOutputLength - engine.nread + 1); + if (size > engine._chunkSize) + engine._chunkSize = size; +} + function zlibBufferOnError(err) { this.removeAllListeners('end'); this.cb(err); @@ -706,6 +719,8 @@ function processCallback() { // Exhausted the output buffer, or used all the input create a new one. if (availOutAfter === 0 || self._outOffset >= self._chunkSize) { + if (availOutAfter === 0 && self[kBufferResult] === true) + zlibBufferGrowChunkSize(self); handle.availOutBefore = self._chunkSize; self._outOffset = 0; self._outBuffer = Buffer.allocUnsafe(self._chunkSize); diff --git a/test/parallel/test-zlib-convenience-async-large.js b/test/parallel/test-zlib-convenience-async-large.js new file mode 100644 index 00000000000..03a7dab8684 --- /dev/null +++ b/test/parallel/test-zlib-convenience-async-large.js @@ -0,0 +1,82 @@ +'use strict'; +// The asynchronous convenience methods grow their output buffer while +// processing large inputs. Check that large results, custom chunkSize values +// and maxOutputLength behave exactly like the synchronous methods. + +const common = require('../common'); +const assert = require('assert'); +const fs = require('fs'); +const zlib = require('zlib'); + +const { Z_MIN_CHUNK, BROTLI_PARAM_QUALITY } = zlib.constants; + +// Text plus pseudo-random bytes, so that both the compressed and the +// decompressed output span many output buffers. +const random = Buffer.alloc(256 * 1024); +{ + let seed = 0x2545f491; + for (let i = 0; i < random.length; i++) { + seed ^= seed << 13; + seed ^= seed >>> 17; + seed ^= seed << 5; + random[i] = seed & 0xff; + } +} +const data = Buffer.concat([ + Buffer.alloc(2 * 1024 * 1024, fs.readFileSync(__filename)), + random, +]); + +// Keep brotli fast enough for a test. +const brotliOptions = { params: { [BROTLI_PARAM_QUALITY]: 4 } }; +const pairs = [ + ['deflate', 'inflate'], + ['gzip', 'gunzip'], + ['gzip', 'unzip'], + ['deflateRaw', 'inflateRaw'], + ['brotliCompress', 'brotliDecompress', brotliOptions], + ['zstdCompress', 'zstdDecompress'], +]; + +function callAsync(method, input, options) { + return new Promise((resolve, reject) => { + zlib[method](input, options, common.mustCall((err, result) => { + if (err) reject(err); + else resolve(result); + })); + }); +} + +(async () => { + for (const [compress, decompress, options = {}] of pairs) { + const label = `${compress}/${decompress}`; + const compressed = await callAsync(compress, data, options); + const expected = zlib[`${compress}Sync`](data, options); + // zstdCompress() pledges the input size and ends the frame separately, + // which yields different (not larger) frames than zstdCompressSync(). + if (compress !== 'zstdCompress') { + assert.deepStrictEqual(compressed, expected, label); + } + assert.deepStrictEqual(await callAsync(decompress, compressed, {}), data, + label); + + for (const chunkSize of [Z_MIN_CHUNK, data.length + 1]) { + assert.deepStrictEqual( + await callAsync(decompress, compressed, { chunkSize }), data, + `${label} chunkSize=${chunkSize}`); + } + + for (const maxOutputLength of [data.length - 1, 100000, 1]) { + await assert.rejects( + callAsync(decompress, compressed, { maxOutputLength }), { + name: 'RangeError', + code: 'ERR_BUFFER_TOO_LARGE', + message: `Cannot create a Buffer larger than ${maxOutputLength} bytes`, + }, `${label} maxOutputLength=${maxOutputLength}`); + } + assert.deepStrictEqual( + await callAsync(decompress, compressed, + { maxOutputLength: data.length }), + data, label); + } +})().then(common.mustCall()); diff --git a/test/parallel/test-zlib-convenience-async-round-trip.js b/test/parallel/test-zlib-convenience-async-round-trip.js index ab48f885272..e7b9fb217b0 100644 --- a/test/parallel/test-zlib-convenience-async-round-trip.js +++ b/test/parallel/test-zlib-convenience-async-round-trip.js @@ -1,7 +1,8 @@ 'use strict'; // The asynchronous convenience methods know the whole input up front, so they // process it with the finish flush in a single write. Check that a call whose -// output fits in one output buffer takes exactly one threadpool round trip. +// output fits in one output buffer takes exactly one threadpool round trip, +// and that larger results need few round trips. const common = require('../common'); const assert = require('assert'); @@ -71,4 +72,17 @@ function callAsync(method, buffer, options = {}) { }); assert.deepStrictEqual(roundTrips, [1]); assert.strictEqual(error.code, 'Z_DATA_ERROR'); + + // The output buffer doubles from the 16 KiB default up to 1 MiB, so 4 MiB of + // output takes 6 + 4 round trips instead of 256. + { + const large = Buffer.alloc(4 * 1024 * 1024, input); + const compressed = zlib.deflateSync(large); + let result; + const roundTrips = await countRoundTrips(async () => { + result = await callAsync('inflate', compressed); + }); + assert.deepStrictEqual(roundTrips, [10]); + assert.deepStrictEqual(result, large); + } })().then(common.mustCall()); From c77f2e339bbc1e7ba1864672da53c44ce50ee8bb Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 15:21:29 +0000 Subject: [PATCH 135/331] tools: bump undici from 6.28.0 to 6.29.1 in /tools/doc MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [undici](https://github.com/nodejs/undici) from 6.28.0 to 6.29.1. - [Release notes](https://github.com/nodejs/undici/releases) - [Commits](https://github.com/nodejs/undici/compare/v6.28.0...v6.29.1) --- updated-dependencies: - dependency-name: undici dependency-version: 6.29.1 dependency-type: indirect ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/67027 Reviewed-By: Trivikram Kamat Reviewed-By: Colin Ihrig Reviewed-By: Ulises Gascón --- tools/doc/package-lock.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tools/doc/package-lock.json b/tools/doc/package-lock.json index 20912317efc..42d6c3814f9 100644 --- a/tools/doc/package-lock.json +++ b/tools/doc/package-lock.json @@ -4572,9 +4572,9 @@ } }, "node_modules/undici": { - "version": "6.28.0", - "resolved": "https://registry.npmjs.org/undici/-/undici-6.28.0.tgz", - "integrity": "sha512-LIY910g9TI13YS95lrMFrs8Rm/u/irgHeTWoKCoteeJ04CUJ92eEfj0rVn+7VKMPBpUPiUoBKfhNyLI23EE/KA==", + "version": "6.29.1", + "resolved": "https://registry.npmjs.org/undici/-/undici-6.29.1.tgz", + "integrity": "sha512-EvRlUt/QqAEvXdQeRMYUfwOQsfzpDztykrG2owGEE/rBOBoYv9uF39ZzsNDh4lTFHhTr2XOZjKkYgueD12ZmGA==", "license": "MIT", "engines": { "node": ">=18.17" From 5dcb9b1d222b2d27616437b1d6066fa10b48a6ec Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 15:21:46 +0000 Subject: [PATCH 136/331] tools: bump piscina from 5.2.0 to 5.3.2 in /tools/doc Bumps [piscina](https://github.com/piscinajs/piscina) from 5.2.0 to 5.3.2. - [Release notes](https://github.com/piscinajs/piscina/releases) - [Changelog](https://github.com/piscinajs/piscina/blob/v5.3.2/CHANGELOG.md) - [Commits](https://github.com/piscinajs/piscina/compare/v5.2.0...v5.3.2) --- updated-dependencies: - dependency-name: piscina dependency-version: 5.3.2 dependency-type: indirect ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/67026 Reviewed-By: Antoine du Hamel Reviewed-By: Luigi Pinca Reviewed-By: Colin Ihrig --- tools/doc/package-lock.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tools/doc/package-lock.json b/tools/doc/package-lock.json index 42d6c3814f9..e6dae3df5de 100644 --- a/tools/doc/package-lock.json +++ b/tools/doc/package-lock.json @@ -3980,9 +3980,9 @@ } }, "node_modules/piscina": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/piscina/-/piscina-5.2.0.tgz", - "integrity": "sha512-DszUCKeVN/5G5QKo6jAVHL8fmKnkJvQ0ACiVgY7YGCq3TUB2oznAOayvZPIAdEThvhczkXR+qm3IHsNXpFCYfA==", + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/piscina/-/piscina-5.3.2.tgz", + "integrity": "sha512-vv7l/mM7B9WgrhDaudIqv1x6v4LOBRYYmpWGdWushhpbCmVHp11sUB2v4hj1CAeTGXVxuZFz6xOU1RalAiPKfQ==", "license": "MIT", "engines": { "node": ">=20.x" From 52ad018f3ce3c519fda2107bd6b33985cdc79d87 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 15:22:00 +0000 Subject: [PATCH 137/331] meta: bump actions/upload-artifact from 7.0.1 to 7.0.2 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 7.0.1 to 7.0.2. - [Release notes](https://github.com/actions/upload-artifact/releases) - [Commits](https://github.com/actions/upload-artifact/compare/043fb46d1a93c77aae656e7c1c64a875d1fc6a0a...cf430e030ddbb5b0abf93d22962f4752f3646cd9) --- updated-dependencies: - dependency-name: actions/upload-artifact dependency-version: 7.0.2 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/67024 Reviewed-By: Luigi Pinca Reviewed-By: Antoine du Hamel Reviewed-By: Ulises Gascón Reviewed-By: Tierney Cyren Reviewed-By: Colin Ihrig --- .github/workflows/benchmark.yml | 2 +- .github/workflows/build-tarball.yml | 2 +- .github/workflows/daily-wpt-fyi.yml | 2 +- .github/workflows/doc.yml | 2 +- .github/workflows/nix-changes.yml | 2 +- .github/workflows/scorecard.yml | 2 +- .github/workflows/test-shared.yml | 4 ++-- 7 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml index 9f4ed58447d..226ae811960 100644 --- a/.github/workflows/benchmark.yml +++ b/.github/workflows/benchmark.yml @@ -185,7 +185,7 @@ jobs: RUNS: ${{ inputs.runs }} - name: Upload raw benchmark results - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: name: csv-${{ matrix.system }} path: ${{ matrix.system }}.csv diff --git a/.github/workflows/build-tarball.yml b/.github/workflows/build-tarball.yml index b3ac6aad475..bea8e1dde3c 100644 --- a/.github/workflows/build-tarball.yml +++ b/.github/workflows/build-tarball.yml @@ -91,7 +91,7 @@ jobs: export COMMIT=$(git rev-parse --short=10 "$GITHUB_SHA") ./configure && make tar -j4 SKIP_XZ=1 GZIP_COMPRESSION=6 - name: Upload tarball artifact - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: path: '*.tar.gz' archive: false diff --git a/.github/workflows/daily-wpt-fyi.yml b/.github/workflows/daily-wpt-fyi.yml index b16b640a084..5a7bca0f395 100644 --- a/.github/workflows/daily-wpt-fyi.yml +++ b/.github/workflows/daily-wpt-fyi.yml @@ -128,7 +128,7 @@ jobs: NODE_VERSION: ${{ steps.setup-node.outputs.node-version }} - name: Upload GitHub Actions artifact if: ${{ env.WPT_REPORT != '' }} - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: path: out/wpt/wptreport-*.json name: WPT Report for ${{ steps.setup-node.outputs.node-version }} diff --git a/.github/workflows/doc.yml b/.github/workflows/doc.yml index 693d9ad3dd2..f2341c56c86 100644 --- a/.github/workflows/doc.yml +++ b/.github/workflows/doc.yml @@ -33,7 +33,7 @@ jobs: node-version: ${{ env.NODE_VERSION }} - name: Build run: NODE=$(command -v node) make doc-only - - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: name: docs path: out/doc diff --git a/.github/workflows/nix-changes.yml b/.github/workflows/nix-changes.yml index e077276e5dd..1ccc58fccf0 100644 --- a/.github/workflows/nix-changes.yml +++ b/.github/workflows/nix-changes.yml @@ -100,7 +100,7 @@ jobs: - name: Upload requisites lists if: ${{ github.event.pull_request }} - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: name: requisites-${{ matrix.system }} path: | diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml index ee20d5a045e..994538ab4cd 100644 --- a/.github/workflows/scorecard.yml +++ b/.github/workflows/scorecard.yml @@ -68,7 +68,7 @@ jobs: # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF # format to the repository Actions tab. - name: Upload artifact - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: name: SARIF file path: results.sarif diff --git a/.github/workflows/test-shared.yml b/.github/workflows/test-shared.yml index 8292ac253fd..b96b5cdf215 100644 --- a/.github/workflows/test-shared.yml +++ b/.github/workflows/test-shared.yml @@ -140,7 +140,7 @@ jobs: DISTTYPE: nightly - name: Upload tarball artifact - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: path: '*.tar.gz' archive: false @@ -222,7 +222,7 @@ jobs: - name: Upload libv8-aarch64-linux.nar if: ${{ steps.v8-drv.outputs.ALREADY_CACHED != 'true' && env.HAS_CACHIX_AUTH_TOKEN != 'true' }} id: upload - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: name: libv8-aarch64-linux.nar path: libv8-aarch64-linux.nar From e233b55e0dd8b651ae4b48a35a9d8466dace5cf5 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 15:22:13 +0000 Subject: [PATCH 138/331] meta: bump actions/download-artifact from 8.0.1 to 8.0.2 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [actions/download-artifact](https://github.com/actions/download-artifact) from 8.0.1 to 8.0.2. - [Release notes](https://github.com/actions/download-artifact/releases) - [Commits](https://github.com/actions/download-artifact/compare/3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c...9000827ccba6bdab643e8b6fd33ac0654aef8333) --- updated-dependencies: - dependency-name: actions/download-artifact dependency-version: 8.0.2 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/67018 Reviewed-By: Luigi Pinca Reviewed-By: Antoine du Hamel Reviewed-By: Ulises Gascón --- .github/workflows/benchmark.yml | 2 +- .github/workflows/build-shared.yml | 4 ++-- .github/workflows/build-tarball.yml | 2 +- .github/workflows/nix-changes-comment.yml | 2 +- .github/workflows/test-shared.yml | 2 +- 5 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml index 226ae811960..f0f8f972e1c 100644 --- a/.github/workflows/benchmark.yml +++ b/.github/workflows/benchmark.yml @@ -209,7 +209,7 @@ jobs: sparse-checkout-cone-mode: false - name: Download benchmark raw results - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2 with: pattern: csv-* merge-multiple: true diff --git a/.github/workflows/build-shared.yml b/.github/workflows/build-shared.yml index 73f7ec6afbb..ad212b43777 100644 --- a/.github/workflows/build-shared.yml +++ b/.github/workflows/build-shared.yml @@ -41,7 +41,7 @@ jobs: build: runs-on: ${{ inputs.runner }} steps: - - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2 with: path: tarballs pattern: '*.tar.gz' @@ -62,7 +62,7 @@ jobs: name: nodejs authToken: ${{ secrets.CACHIX_AUTH_TOKEN }} - - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2 if: inputs.v8-nar with: name: ${{ inputs.v8-nar }} diff --git a/.github/workflows/build-tarball.yml b/.github/workflows/build-tarball.yml index bea8e1dde3c..ecf390917e8 100644 --- a/.github/workflows/build-tarball.yml +++ b/.github/workflows/build-tarball.yml @@ -119,7 +119,7 @@ jobs: with: version: v0.17.0 - name: Download tarball - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2 with: path: tarballs - name: Extract tarball diff --git a/.github/workflows/nix-changes-comment.yml b/.github/workflows/nix-changes-comment.yml index db96ff4a09c..1eccc6a710d 100644 --- a/.github/workflows/nix-changes-comment.yml +++ b/.github/workflows/nix-changes-comment.yml @@ -18,7 +18,7 @@ jobs: pull-requests: write steps: - name: Download artefacts - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2 with: run-id: ${{ github.event.workflow_run.id }} # Using privileged token to be able to download file from a different workflow diff --git a/.github/workflows/test-shared.yml b/.github/workflows/test-shared.yml index b96b5cdf215..1b215cfe514 100644 --- a/.github/workflows/test-shared.yml +++ b/.github/workflows/test-shared.yml @@ -181,7 +181,7 @@ jobs: env: HAS_CACHIX_AUTH_TOKEN: ${{ secrets.CACHIX_AUTH_TOKEN && 'true' }} steps: - - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2 with: path: tarballs From 0805564c464b2c513911ee243e4c4d930392d8c5 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 15:34:52 +0000 Subject: [PATCH 139/331] meta: bump actions/setup-node from 7.0.0 to 7.1.0 Bumps [actions/setup-node](https://github.com/actions/setup-node) from 7.0.0 to 7.1.0. - [Release notes](https://github.com/actions/setup-node/releases) - [Commits](https://github.com/actions/setup-node/compare/820762786026740c76f36085b0efc47a31fe5020...949feb2413d6458794dcd2491c4babbbce0c15c1) --- updated-dependencies: - dependency-name: actions/setup-node dependency-version: 7.1.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/67032 Reviewed-By: Christian Clauss Reviewed-By: Trivikram Kamat Reviewed-By: Colin Ihrig Reviewed-By: Luigi Pinca --- .github/workflows/auto-start-ci.yml | 2 +- .github/workflows/commit-lint.yml | 2 +- .github/workflows/commit-queue.yml | 2 +- .github/workflows/create-release-proposal.yml | 2 +- .github/workflows/daily-wpt-fyi.yml | 2 +- .github/workflows/daily.yml | 2 +- .github/workflows/doc.yml | 2 +- .github/workflows/find-inactive-collaborators.yml | 2 +- .github/workflows/find-inactive-tsc.yml | 2 +- .github/workflows/linters.yml | 6 +++--- .github/workflows/notify-on-push.yml | 2 +- .github/workflows/update-v8.yml | 2 +- .github/workflows/update-wpt.yml | 2 +- 13 files changed, 15 insertions(+), 15 deletions(-) diff --git a/.github/workflows/auto-start-ci.yml b/.github/workflows/auto-start-ci.yml index 3c7872baab7..c4a404825e1 100644 --- a/.github/workflows/auto-start-ci.yml +++ b/.github/workflows/auto-start-ci.yml @@ -64,7 +64,7 @@ jobs: runs-on: ubuntu-slim steps: - name: Install Node.js - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} diff --git a/.github/workflows/commit-lint.yml b/.github/workflows/commit-lint.yml index 6b173d8bc97..29b599d1d9e 100644 --- a/.github/workflows/commit-lint.yml +++ b/.github/workflows/commit-lint.yml @@ -21,7 +21,7 @@ jobs: runs-on: ubuntu-slim steps: - name: Install Node.js - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} - name: Validate first commit message diff --git a/.github/workflows/commit-queue.yml b/.github/workflows/commit-queue.yml index 520b0239ff4..d0027dd6bd7 100644 --- a/.github/workflows/commit-queue.yml +++ b/.github/workflows/commit-queue.yml @@ -67,7 +67,7 @@ jobs: runs-on: ubuntu-slim steps: - name: Install Node.js - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} diff --git a/.github/workflows/create-release-proposal.yml b/.github/workflows/create-release-proposal.yml index 84300d8a169..3b309460c01 100644 --- a/.github/workflows/create-release-proposal.yml +++ b/.github/workflows/create-release-proposal.yml @@ -45,7 +45,7 @@ jobs: # Install dependencies - name: Install Node.js - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} diff --git a/.github/workflows/daily-wpt-fyi.yml b/.github/workflows/daily-wpt-fyi.yml index 5a7bca0f395..d8ea4588fc4 100644 --- a/.github/workflows/daily-wpt-fyi.yml +++ b/.github/workflows/daily-wpt-fyi.yml @@ -51,7 +51,7 @@ jobs: run: echo "NIGHTLY=$(curl -s https://nodejs.org/download/nightly/index.json | jq -r '[.[] | select(.files[] | contains("linux-arm64"))][0].version')" >> $GITHUB_ENV - name: Install Node.js id: setup-node - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NIGHTLY || matrix.node-version }} check-latest: true diff --git a/.github/workflows/daily.yml b/.github/workflows/daily.yml index b7a616e2df5..9fb09d56bbb 100644 --- a/.github/workflows/daily.yml +++ b/.github/workflows/daily.yml @@ -20,7 +20,7 @@ jobs: with: persist-credentials: false - name: Use Node.js ${{ env.NODE_VERSION }} - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} - name: Build lto diff --git a/.github/workflows/doc.yml b/.github/workflows/doc.yml index f2341c56c86..9d06f0b2124 100644 --- a/.github/workflows/doc.yml +++ b/.github/workflows/doc.yml @@ -28,7 +28,7 @@ jobs: with: persist-credentials: false - name: Use Node.js ${{ env.NODE_VERSION }} - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} - name: Build diff --git a/.github/workflows/find-inactive-collaborators.yml b/.github/workflows/find-inactive-collaborators.yml index 8c74fda2242..61af1a2bf13 100644 --- a/.github/workflows/find-inactive-collaborators.yml +++ b/.github/workflows/find-inactive-collaborators.yml @@ -25,7 +25,7 @@ jobs: persist-credentials: false - name: Use Node.js ${{ env.NODE_VERSION }} - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} diff --git a/.github/workflows/find-inactive-tsc.yml b/.github/workflows/find-inactive-tsc.yml index d59f26b73b2..67ff96a6743 100644 --- a/.github/workflows/find-inactive-tsc.yml +++ b/.github/workflows/find-inactive-tsc.yml @@ -34,7 +34,7 @@ jobs: repository: nodejs/TSC - name: Use Node.js ${{ env.NODE_VERSION }} - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} diff --git a/.github/workflows/linters.yml b/.github/workflows/linters.yml index f6945f9df51..3f7e254b69f 100644 --- a/.github/workflows/linters.yml +++ b/.github/workflows/linters.yml @@ -33,7 +33,7 @@ jobs: !/deps/ sparse-checkout-cone-mode: false - name: Use Node.js ${{ env.NODE_VERSION }} - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} - name: Lint addon docs @@ -68,7 +68,7 @@ jobs: fetch-depth: 2 persist-credentials: false - name: Use Node.js ${{ env.NODE_VERSION }} - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} - name: Set up Python ${{ env.PYTHON_VERSION }} @@ -105,7 +105,7 @@ jobs: persist-credentials: false - name: Use Node.js ${{ env.NODE_VERSION }} id: setup-node - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} cache: npm diff --git a/.github/workflows/notify-on-push.yml b/.github/workflows/notify-on-push.yml index 25421b8447d..dfded4d76af 100644 --- a/.github/workflows/notify-on-push.yml +++ b/.github/workflows/notify-on-push.yml @@ -40,7 +40,7 @@ jobs: runs-on: ubuntu-24.04-arm steps: - name: Install Node.js - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} - name: Validate commits diff --git a/.github/workflows/update-v8.yml b/.github/workflows/update-v8.yml index 8e71e563896..44137ab2fde 100644 --- a/.github/workflows/update-v8.yml +++ b/.github/workflows/update-v8.yml @@ -30,7 +30,7 @@ jobs: ~/.npm key: ${{ runner.os }}-build-${{ env.cache-name }} - name: Install Node.js - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} - name: Install @node-core/utils diff --git a/.github/workflows/update-wpt.yml b/.github/workflows/update-wpt.yml index 7b59a2f137f..ccf81e1b3d1 100644 --- a/.github/workflows/update-wpt.yml +++ b/.github/workflows/update-wpt.yml @@ -32,7 +32,7 @@ jobs: persist-credentials: false - name: Install Node.js - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 + uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0 with: node-version: ${{ env.NODE_VERSION }} From 755d919ae745b30e1e0daecd519e354930a512ff Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 15:35:06 +0000 Subject: [PATCH 140/331] tools: bump the eslint group in /tools/eslint with 5 updates Bumps the eslint group in /tools/eslint with 5 updates: | Package | From | To | | --- | --- | --- | | [@babel/core](https://github.com/babel/babel/tree/HEAD/packages/babel-core) | `8.0.6` | `8.0.7` | | [@babel/eslint-parser](https://github.com/babel/babel/tree/HEAD/eslint/babel-eslint-parser) | `8.0.6` | `8.0.7` | | [eslint](https://github.com/eslint/eslint) | `10.11.0` | `10.13.0` | | [eslint-plugin-jsdoc](https://github.com/gajus/eslint-plugin-jsdoc) | `64.5.4` | `65.4.0` | | [globals](https://github.com/sindresorhus/globals) | `17.12.0` | `17.13.0` | Updates `@babel/core` from 8.0.6 to 8.0.7 - [Release notes](https://github.com/babel/babel/releases) - [Changelog](https://github.com/babel/babel/blob/main/CHANGELOG.md) - [Commits](https://github.com/babel/babel/commits/v8.0.7/packages/babel-core) Updates `@babel/eslint-parser` from 8.0.6 to 8.0.7 - [Release notes](https://github.com/babel/babel/releases) - [Changelog](https://github.com/babel/babel/blob/main/CHANGELOG.md) - [Commits](https://github.com/babel/babel/commits/v8.0.7/eslint/babel-eslint-parser) Updates `eslint` from 10.11.0 to 10.13.0 - [Release notes](https://github.com/eslint/eslint/releases) - [Commits](https://github.com/eslint/eslint/compare/v10.11.0...v10.13.0) Updates `eslint-plugin-jsdoc` from 64.5.4 to 65.4.0 - [Release notes](https://github.com/gajus/eslint-plugin-jsdoc/releases) - [Commits](https://github.com/gajus/eslint-plugin-jsdoc/compare/v64.5.4...v65.4.0) Updates `globals` from 17.12.0 to 17.13.0 - [Release notes](https://github.com/sindresorhus/globals/releases) - [Commits](https://github.com/sindresorhus/globals/compare/v17.12.0...v17.13.0) --- updated-dependencies: - dependency-name: "@babel/core" dependency-version: 8.0.7 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: eslint - dependency-name: "@babel/eslint-parser" dependency-version: 8.0.7 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: eslint - dependency-name: eslint dependency-version: 10.13.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: eslint - dependency-name: eslint-plugin-jsdoc dependency-version: 65.4.0 dependency-type: direct:production update-type: version-update:semver-major dependency-group: eslint - dependency-name: globals dependency-version: 17.13.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: eslint ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/67025 Reviewed-By: Luigi Pinca Reviewed-By: Colin Ihrig --- lib/internal/modules/esm/utils.js | 1 - test/parallel/test-tls-pause.js | 1 + tools/eslint/package-lock.json | 342 +++++++++++++++++++----------- tools/eslint/package.json | 10 +- 4 files changed, 228 insertions(+), 126 deletions(-) diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js index c6b101fb907..8937b8a6129 100644 --- a/lib/internal/modules/esm/utils.js +++ b/lib/internal/modules/esm/utils.js @@ -106,7 +106,6 @@ function getConditionsSet(conditions) { return getDefaultConditionsSet(); } -/* eslint-disable jsdoc/valid-types */ /** * @typedef {{ * [Symbol.toStringTag]: () => 'Module' diff --git a/test/parallel/test-tls-pause.js b/test/parallel/test-tls-pause.js index f98d8d9b745..0b4428e9167 100644 --- a/test/parallel/test-tls-pause.js +++ b/test/parallel/test-tls-pause.js @@ -64,6 +64,7 @@ server.listen(0, common.mustCall(() => { console.error('write again'); sent += bufSize; assert.ok(sent < 100 * 1024 * 1024); // max 100MB + // eslint-disable-next-line no-use-before-define return process.nextTick(send); } sent += bufSize; diff --git a/tools/eslint/package-lock.json b/tools/eslint/package-lock.json index 26247efca8b..dd6b553cfea 100644 --- a/tools/eslint/package-lock.json +++ b/tools/eslint/package-lock.json @@ -8,18 +8,18 @@ "name": "eslint-tools", "version": "0.0.0", "dependencies": { - "@babel/core": "^8.0.6", - "@babel/eslint-parser": "^8.0.6", + "@babel/core": "^8.0.7", + "@babel/eslint-parser": "^8.0.7", "@babel/plugin-syntax-import-defer": "^8.0.1", "@babel/plugin-syntax-import-source": "^8.0.1", "@eslint/js": "^10.0.1", "@eslint/markdown": "^8.0.3", "@stylistic/eslint-plugin": "^5.10.0", - "eslint": "^10.11.0", + "eslint": "^10.13.0", "eslint-formatter-tap": "^9.0.1", - "eslint-plugin-jsdoc": "^64.5.4", + "eslint-plugin-jsdoc": "^65.4.0", "eslint-plugin-regexp": "^3.3.1", - "globals": "^17.12.0" + "globals": "^17.13.0" } }, "node_modules/@babel/code-frame": { @@ -45,18 +45,18 @@ } }, "node_modules/@babel/core": { - "version": "8.0.6", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-8.0.6.tgz", - "integrity": "sha512-5zwYt1V4ji3mXKKRIAkohSJ29WepxNwxQi+7y7P5AcVPh1dcxnZBU2cfxHnPwS+u9+lZnXPsv30TQaF2xg+Tfg==", + "version": "8.0.7", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-8.0.7.tgz", + "integrity": "sha512-ZIsZWBG6Y1oa+8fkQVp0xeCdjCHBkXFCCIWrmg9SvejVvfcVQgKKRmGrBDWfM7rilhvnRoEuaqa5dkK7KB3pHA==", "license": "MIT", "dependencies": { "@babel/code-frame": "^8.0.6", "@babel/generator": "^8.0.6", - "@babel/helper-compilation-targets": "^8.0.6", - "@babel/helpers": "^8.0.5", - "@babel/parser": "^8.0.6", + "@babel/helper-compilation-targets": "^8.0.7", + "@babel/helpers": "^8.0.7", + "@babel/parser": "^8.0.7", "@babel/template": "^8.0.0", - "@babel/traverse": "^8.0.6", + "@babel/traverse": "^8.0.7", "@babel/types": "^8.0.6", "@types/gensync": "^1.0.5", "convert-source-map": "^2.0.0", @@ -64,8 +64,8 @@ "gensync": "^1.0.0-beta.2", "import-meta-resolve": "^4.2.0", "json5": "^2.2.3", - "obug": "^2.1.1", - "verkit": "^0.3.2" + "obug": "^3.0.0", + "verkit": "^0.5.0" }, "engines": { "node": "^22.18.0 || >=24.11.0" @@ -76,14 +76,14 @@ } }, "node_modules/@babel/eslint-parser": { - "version": "8.0.6", - "resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-8.0.6.tgz", - "integrity": "sha512-mXx93HLovamLnDDLQ4i48gm4HHtaoqJrbMAuJqrMfpCGJkJ5M4sXhRgKGTrxykg1P8tAN5myrJxsRZuMuTq+OQ==", + "version": "8.0.7", + "resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-8.0.7.tgz", + "integrity": "sha512-ik5I+U64QuQQPohw0A1wVWPR+vTRYVfWBDLOLc1KwZQ2SKayQLD52DgoB3W/kmwc4MP1E37qh7nZuDD9xsKYcA==", "license": "MIT", "dependencies": { "eslint-scope": "^9.1.0", "eslint-visitor-keys": "^5.0.0", - "verkit": "^0.3.2" + "verkit": "^0.5.0" }, "engines": { "node": "^22.18.0 || >=24.11.0" @@ -111,16 +111,16 @@ } }, "node_modules/@babel/helper-compilation-targets": { - "version": "8.0.6", - "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-8.0.6.tgz", - "integrity": "sha512-HTrtZ4+iA0+kzdbCgvdSk1U4pEl3BvpGnlUbualCGNbrVhhQvhgBzurTUmqpWyvyHbWYWaIfdx2mOlL9LJjsew==", + "version": "8.0.7", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-8.0.7.tgz", + "integrity": "sha512-ilAZCdOOlOVA7dQbaFNw2f/59p6GW33NxTopc3DvEE3efp3ZXTrGX/yZScaKw8/vd9bq31Ag0EcXiLw32bAgJg==", "license": "MIT", "dependencies": { "@babel/compat-data": "^8.0.5", "@babel/helper-validator-option": "^8.0.0", "browserslist": "^4.24.0", "flru": "1.0.2", - "verkit": "^0.3.2" + "verkit": "^0.5.0" }, "engines": { "node": "^22.18.0 || >=24.11.0" @@ -148,9 +148,9 @@ } }, "node_modules/@babel/helper-string-parser": { - "version": "8.0.6", - "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-8.0.6.tgz", - "integrity": "sha512-+6HYEBnsDRZHJtUTAEfMQd0zMDqdFHS7C+5vAsEZqBUr3vEMWOWlHJ0Jz1gS8jJIlCvLsuA6ivmeoqzH936YcA==", + "version": "8.0.8", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-8.0.8.tgz", + "integrity": "sha512-fVM+gSuKbdv9cpmyRNh5EvsDHUZCdxQH3FdnFKSkNYHpbsn95bbrxm+ES3MVeQjcqwi2O5ur/DjLfmTQaO60ng==", "license": "MIT", "engines": { "node": "^22.18.0 || >=24.11.0" @@ -175,25 +175,25 @@ } }, "node_modules/@babel/helpers": { - "version": "8.0.5", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-8.0.5.tgz", - "integrity": "sha512-fQtPOXjYOYv85PIdwotp2TJGVYOycX0PQq+l844fFAxOULtBy8BVF35GyeueX0r4KvDthqPH5xAI1clQPk/2uA==", + "version": "8.0.8", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-8.0.8.tgz", + "integrity": "sha512-FBmhiDWs625wHg03OKiLQDeT6LOc2lWBbW97Yqs2iI1tZcucjpmYnO29NHsQ83XxKvredcvUymW/AAn2UtnakA==", "license": "MIT", "dependencies": { "@babel/template": "^8.0.0", - "@babel/types": "^8.0.5" + "@babel/types": "^8.0.8" }, "engines": { "node": "^22.18.0 || >=24.11.0" } }, "node_modules/@babel/parser": { - "version": "8.0.6", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-8.0.6.tgz", - "integrity": "sha512-LpGDIYJAzc3Y3PT9x+FxBrGYu2PlWxLmyN7SwPTzaX0LSwEmFJBsRnPBqmaXF2r1v+Zhz6lNiEJ+7yKtM5+Ugg==", + "version": "8.0.8", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-8.0.8.tgz", + "integrity": "sha512-Gq65JogAr0S2p0BzvfSJboyuiRnxDQApyOqHkKmkrvm+VlLK4gC3pKsiOKEdnhFBemrFbSnOu90mZZWDpiJnmQ==", "license": "MIT", "dependencies": { - "@babel/types": "^8.0.6" + "@babel/types": "^8.0.8" }, "bin": { "parser": "bin/babel-parser.js" @@ -247,30 +247,30 @@ } }, "node_modules/@babel/traverse": { - "version": "8.0.6", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-8.0.6.tgz", - "integrity": "sha512-ilYV+qLStGzSKLipJlETdvdtpK3rAuwfCmCoGKv15MU4EoeIuLkespSNoNLFGOPSciEHx9TLWtN5mv0fz5w5mQ==", + "version": "8.0.7", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-8.0.7.tgz", + "integrity": "sha512-bVV0brinsTWgc6ptSIoQo3GbITtl0VZAqEUJbHHcyfDPEu+q/fEvlYEa+6H85HoK8IdksKBFtKJbJFZ6Kff+zg==", "license": "MIT", "dependencies": { "@babel/code-frame": "^8.0.6", "@babel/generator": "^8.0.6", "@babel/helper-globals": "^8.0.6", - "@babel/parser": "^8.0.6", + "@babel/parser": "^8.0.7", "@babel/template": "^8.0.0", "@babel/types": "^8.0.6", - "obug": "^2.1.1" + "obug": "^3.0.0" }, "engines": { "node": "^22.18.0 || >=24.11.0" } }, "node_modules/@babel/types": { - "version": "8.0.6", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-8.0.6.tgz", - "integrity": "sha512-c+xgSWboV2pdwXP67BUWDVRHi2BO5Q3KwxyFVs7taVTY+fsK47/L51ZXQoV9rozHJDNHvJ4v4WEsI/IlxV2l2A==", + "version": "8.0.8", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-8.0.8.tgz", + "integrity": "sha512-iXSSZAKQWmaeAwGtFw10v9fg5hUiUs0L+w+Z2K11kym3pDNK+SF0VcAQPsEFvWcTSZ7LMgClMXDBvTbH0IlICg==", "license": "MIT", "dependencies": { - "@babel/helper-string-parser": "^8.0.6", + "@babel/helper-string-parser": "^8.0.8", "@babel/helper-validator-identifier": "^8.0.6" }, "engines": { @@ -299,17 +299,95 @@ "keyv": "^5.6.0" } }, + "node_modules/@es-joy/escodegen": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/@es-joy/escodegen/-/escodegen-4.2.0.tgz", + "integrity": "sha512-jWqqS3StW6vGwJeT8yu6alS4nipOBi3kD/pR63+9hG2NfGafCJ4viDME15mVf+fyupyptcUJDXfv63gFF5Gzfg==", + "license": "BSD-2-Clause", + "dependencies": { + "@es-joy/estraverse": "^7.1.1", + "@es-joy/jsdoccomment": "^0.62.0", + "esprima": "^4.0.1", + "esutils": "^2.0.3", + "optionator": "^0.9.4" + }, + "bin": { + "escodegen": "bin/escodegen.js", + "esgenerate": "bin/esgenerate.js" + }, + "engines": { + "node": ">=6.0" + }, + "optionalDependencies": { + "source-map": "~0.7.6" + } + }, + "node_modules/@es-joy/escodegen/node_modules/@es-joy/jsdoccomment": { + "version": "0.62.0", + "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.62.0.tgz", + "integrity": "sha512-yWi6sm7INEwnfS7IJvE0dU+RTrwzLPFcY7e7eGpu/l5Q9lWfQ2ROwZ0qVnc242jw2TUPsfHX3XMIISkGBv57RQ==", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.8", + "@typescript-eslint/types": "^8.44.1", + "comment-parser": "1.4.1", + "esquery": "^1.6.0", + "jsdoc-type-pratt-parser": "~5.9.0" + }, + "engines": { + "node": ">=20.11.0" + } + }, + "node_modules/@es-joy/escodegen/node_modules/comment-parser": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/comment-parser/-/comment-parser-1.4.1.tgz", + "integrity": "sha512-buhp5kePrmda3vhc5B9t7pUQXAb2Tnd0qgpkIhPhkHXxJpiPJ11H0ZEU0oBpJ2QztSbzG/ZxMj/CHsYJqRHmyg==", + "license": "MIT", + "engines": { + "node": ">= 12.0.0" + } + }, + "node_modules/@es-joy/escodegen/node_modules/jsdoc-type-pratt-parser": { + "version": "5.9.2", + "resolved": "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-5.9.2.tgz", + "integrity": "sha512-TYzkACp/wPvDJLRY7qpHXtrhgwoAaojIOnLaaVNi+AbPU2u1kkjfKd9hXXTq0qSAGsyYXvwUXt99h9I5iCmjjw==", + "license": "MIT", + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@es-joy/estraverse": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/@es-joy/estraverse/-/estraverse-7.1.1.tgz", + "integrity": "sha512-h2d737iS0LFAqypZOmXizu54qAbHofI/RpD30Zom03O6BCXKHuFevWKPcGarZbGq82h7qSBb5G6kLdhTMO+caw==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, "node_modules/@es-joy/jsdoccomment": { - "version": "0.98.0", - "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.98.0.tgz", - "integrity": "sha512-QS+b7I2aaSM+gZfDz1b9E4B367JJ2qTjFXRKF289iKkh9sYdZ21Q5MiF/Duzouy3J0C4VhM3I/8f2F4+zT8gYQ==", + "version": "0.100.0", + "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.100.0.tgz", + "integrity": "sha512-QuIT5kMg3XWN22Wa1rcXmR/GkfSg6Ygs/ikMiHihdSpu+o3O59LygkFV9srKa5xHplBFwNd5ZCo3bywL4k7qMQ==", "license": "MIT", "dependencies": { "@types/estree": "^1.0.9", - "@typescript-eslint/types": "^8.70.0", + "@typescript-eslint/types": "^8.72.0", "comment-parser": "1.4.9", "esquery": "^1.7.0", - "jsdoc-type-pratt-parser": "~9.2.2" + "jsdoc-type-pratt-parser": "~9.3.0" + }, + "engines": { + "node": "^22.22.2 || >=24.15.0" + } + }, + "node_modules/@es-joy/jsdoccomment/node_modules/jsdoc-type-pratt-parser": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-9.3.0.tgz", + "integrity": "sha512-JZ8lKMCZXDlM1jAjAK5tTmtFJtgv6iFQQfjE3Fza6jBRACUueaEXLY17n1u05JO1lcPkNxgP+ddEDtiPsk5ktg==", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.9" }, "engines": { "node": "^22.22.2 || >=24.15.0" @@ -715,13 +793,13 @@ "license": "MIT" }, "node_modules/@typescript-eslint/project-service": { - "version": "8.70.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.70.0.tgz", - "integrity": "sha512-hFHbTNqhU9G+2eKFXCBVb1tjFT/LceiJ4+HfLO4pTpDI0KHi6iajpcFFkaSQ9gXmCh7n82A0PthaayEdN6mspQ==", + "version": "8.72.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.72.0.tgz", + "integrity": "sha512-bzHngBbmIgzj6TsTjVUCntGx6FFLgE7mPjpO0PzHycOaZHXqS43XnrkFIHRS16LLr/xO6FHSXG3GJFo/F4bSBQ==", "license": "MIT", "dependencies": { - "@typescript-eslint/tsconfig-utils": "^8.70.0", - "@typescript-eslint/types": "^8.70.0", + "@typescript-eslint/tsconfig-utils": "^8.72.0", + "@typescript-eslint/types": "^8.72.0", "debug": "^4.4.3" }, "engines": { @@ -736,13 +814,13 @@ } }, "node_modules/@typescript-eslint/scope-manager": { - "version": "8.70.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.70.0.tgz", - "integrity": "sha512-8nP3Kwh5hlgZ4FicGvmznAmJe8UL4sdU8tLukrPaMuQmDuk4Y8xYfzu/aYZW4xT2JCgc7H/TpDI5cGlxcWJSqQ==", + "version": "8.72.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.72.0.tgz", + "integrity": "sha512-JewPyJOYcXBSAS7PIgufscHOwZqhTGyBRiQJhhuDln66tMchxvvt7nJ90JKKIoOelmdHA3kAQbm9cEUHc4JSEA==", "license": "MIT", "dependencies": { - "@typescript-eslint/types": "8.70.0", - "@typescript-eslint/visitor-keys": "8.70.0" + "@typescript-eslint/types": "8.72.0", + "@typescript-eslint/visitor-keys": "8.72.0" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -753,9 +831,9 @@ } }, "node_modules/@typescript-eslint/tsconfig-utils": { - "version": "8.70.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.70.0.tgz", - "integrity": "sha512-adnkeeNq9Sq1sUf4+FRVc0KdgYghzsgFpZSQVZVvY0LCuUuN0FnQgyGzCJeC4fW1cdXseBAjU2EOqUIjbNcZUw==", + "version": "8.72.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.72.0.tgz", + "integrity": "sha512-0vbxCf7xLVPSjcOdm6eQbgViH8EDJ8xnl1laLT9yoqSz2YmcSfSg5Vdl0JUvZf6rcuJ0ZivJIuMD4edTg8obaA==", "license": "MIT", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -769,9 +847,9 @@ } }, "node_modules/@typescript-eslint/types": { - "version": "8.70.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.70.0.tgz", - "integrity": "sha512-asTOIYhDg4zdzOScCyaytrsV3cR6B4ecPQlXw/dJIm7J/MZTtCtfVII9JD8Geh4jTCrK/Xe6cg5UevoleMcoJQ==", + "version": "8.72.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.72.0.tgz", + "integrity": "sha512-Adfoy59kxNEjT5E5fnyrp7GpHYuWs8ONbdohu4ez6IU46qDq8LltG90tLmkucZB2uhYL8mqBjtXqGd8yhfjXqQ==", "license": "MIT", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -782,15 +860,15 @@ } }, "node_modules/@typescript-eslint/typescript-estree": { - "version": "8.70.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.70.0.tgz", - "integrity": "sha512-d9NmHMPEKQ7QCLLm1jI3zmoQBwT5KwFYjXBJ9ymZfKCUU+5rmTRykKAFvH5Qn/ZCds3CEAFS9OC9M/jkl0X2bA==", + "version": "8.72.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.72.0.tgz", + "integrity": "sha512-gwLfFgWcw15tN2KXDCJvxEOQjPn+P3j/n3eSqkZ5sX4VpW9Cosodr+tWwBZRvJT3TcKx6HnPRGZMCNAiP1Xhug==", "license": "MIT", "dependencies": { - "@typescript-eslint/project-service": "8.70.0", - "@typescript-eslint/tsconfig-utils": "8.70.0", - "@typescript-eslint/types": "8.70.0", - "@typescript-eslint/visitor-keys": "8.70.0", + "@typescript-eslint/project-service": "8.72.0", + "@typescript-eslint/tsconfig-utils": "8.72.0", + "@typescript-eslint/types": "8.72.0", + "@typescript-eslint/visitor-keys": "8.72.0", "debug": "^4.4.3", "minimatch": "^10.2.2", "semver": "^7.7.3", @@ -809,15 +887,15 @@ } }, "node_modules/@typescript-eslint/utils": { - "version": "8.70.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.70.0.tgz", - "integrity": "sha512-oZmtKJz/4fufZ2p3+Cn3ijEojcdfR+1zYDH2xKYrEly0dR/Q/1xUPRCOlKGxod78nWlU2UnDe09GZ3TaknBFGA==", + "version": "8.72.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.72.0.tgz", + "integrity": "sha512-0up3oArJZBYnzOaEXKo8DmI43QvMZyPoFEt9LWzRJcyl/RcJjfKKPebknN1VbTgXBf3M/KggUh5uUMdURLnseg==", "license": "MIT", "dependencies": { "@eslint-community/eslint-utils": "^4.9.1", - "@typescript-eslint/scope-manager": "8.70.0", - "@typescript-eslint/types": "8.70.0", - "@typescript-eslint/typescript-estree": "8.70.0" + "@typescript-eslint/scope-manager": "8.72.0", + "@typescript-eslint/types": "8.72.0", + "@typescript-eslint/typescript-estree": "8.72.0" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -832,12 +910,12 @@ } }, "node_modules/@typescript-eslint/visitor-keys": { - "version": "8.70.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.70.0.tgz", - "integrity": "sha512-BoC8PiO4Hkdo0TVJh9Ntxr5MxPDI7/oFsrygN5ADelFSeXG/qgNuucIGA+L5Z6JpPTE/uRfcTWtscjbUaufepQ==", + "version": "8.72.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.72.0.tgz", + "integrity": "sha512-E2mroviasaWecDzTGiGMtuEguuLVOeRggnrIn93CJuxYJzQBHbyymlT08aVQydbBal5538o+JkBKXh2sRuCyIA==", "license": "MIT", "dependencies": { - "@typescript-eslint/types": "8.70.0", + "@typescript-eslint/types": "8.72.0", "eslint-visitor-keys": "^5.0.0" }, "engines": { @@ -910,9 +988,9 @@ } }, "node_modules/baseline-browser-mapping": { - "version": "2.11.26", - "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.26.tgz", - "integrity": "sha512-GLQdD3y6UF8iVuMJl5fHgE4jdn/ua7n+toKfLgNlg3BqQtOZjpy68T8Tup8/wGWZCDlm7KMg7tPb4MPn7oN0TQ==", + "version": "2.11.33", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.33.tgz", + "integrity": "sha512-yiVKDX+qCMRKBE084lXvq9EcwFUhKZ2nU8TK1EQQuOgPNR/lmbGxXOeDdlGUqC2Zz11Cs9rk1d/8NfgBmlkt0w==", "license": "Apache-2.0", "bin": { "baseline-browser-mapping": "dist/cli.cjs" @@ -934,9 +1012,9 @@ } }, "node_modules/browserslist": { - "version": "4.29.3", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.3.tgz", - "integrity": "sha512-1R4kiYKXGViqEN0CnoDrXc1StD9niAwu+j2dukWzrD4bJgsD4lDmEp0CRbc6E/vYJIfTHwPmwyaKtVSudICdPA==", + "version": "4.29.4", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.4.tgz", + "integrity": "sha512-2TcbbiwXEq+N0kD36tykpCfyyQigUXmuwNQbnPp4Xk4PX9JOqVIKjJlIDjpH7uY6tmRGoAd+apeT1p60T8wsdA==", "funding": [ { "type": "opencollective", @@ -953,11 +1031,11 @@ ], "license": "MIT", "dependencies": { - "baseline-browser-mapping": "^2.11.26", - "caniuse-lite": "^1.0.30001813", - "electron-to-chromium": "^1.5.439", - "node-releases": "^2.0.57", - "update-browserslist-db": "^1.3.3" + "baseline-browser-mapping": "^2.11.29", + "caniuse-lite": "^1.0.30001816", + "electron-to-chromium": "^1.5.459", + "node-releases": "^2.0.59", + "update-browserslist-db": "^1.3.4" }, "bin": { "browserslist": "cli.js" @@ -980,9 +1058,9 @@ } }, "node_modules/caniuse-lite": { - "version": "1.0.30001814", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001814.tgz", - "integrity": "sha512-/Uaf1lAzr59XcMpW0o96WoEfr+VXK2OX4U9AgFoiSHsVJ4HppnIFUjtYzsyDH2+tgANaQb2/oxYGwCPapN1FpA==", + "version": "1.0.30001819", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001819.tgz", + "integrity": "sha512-LFUqIIAwpzsIuevnKnsR9qnStBcgzPShTX61lBwN9uFkkf8o8zLiebEjbW8AYtZiF+1YKDWfdt/pWDtMuG8Xwg==", "funding": [ { "type": "opencollective", @@ -1116,9 +1194,9 @@ } }, "node_modules/electron-to-chromium": { - "version": "1.5.443", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.443.tgz", - "integrity": "sha512-TDJG36L9A3CWWwZ97HKaE+Iz1sW80pNp6sAU0owzCIV3Zc9eVyRqZK8Vz6NKuMIU8WjP0pIkoqCa0VRf/yFD0Q==", + "version": "1.5.464", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.464.tgz", + "integrity": "sha512-nRa65aFge40viPAKxMKULIY8tcXKwKboJWNn4RoKwyWXJ6SP7BnrDGKUTzc64818jIciH0PK7LSF8QzZes19GA==", "license": "ISC" }, "node_modules/empathic": { @@ -1152,9 +1230,9 @@ } }, "node_modules/eslint": { - "version": "10.11.0", - "resolved": "https://registry.npmjs.org/eslint/-/eslint-10.11.0.tgz", - "integrity": "sha512-P7a6UEEqb9G95MYAtqkmsTbVXIYyzIfl6NGOIJk162PaahFxFyeGcrlXYFSiagECg4sEm8IseJdZBKR3rx6MsQ==", + "version": "10.13.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-10.13.0.tgz", + "integrity": "sha512-UohDjD4zSzEwhf58M3O7vc/ycc8O1I7dNlhtD0WxE8Px8EHNJKtUwzBqrzeGhisRuv2ag4sAYswszCJRgKXYUg==", "license": "MIT", "workspaces": [ "packages/*" @@ -1222,14 +1300,15 @@ } }, "node_modules/eslint-plugin-jsdoc": { - "version": "64.5.4", - "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-64.5.4.tgz", - "integrity": "sha512-xfRhXPSSWT612muJ6XTvxuVJ8zYHv99qNgBqPVqF28aSqoy4s4XbSkrWXnYA2hl5ejC02yEpk6fqkj3BmJ6Xbg==", + "version": "65.4.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-65.4.0.tgz", + "integrity": "sha512-bRiU6LfCFmLL7GuePKvA6ZIcXLonhZGCg2TgQLmkcExeVdAirQp2Hsf3xeSUTmlKwAAsREVEOLbZYD8F7oA69g==", "license": "BSD-3-Clause", "dependencies": { - "@es-joy/jsdoccomment": "~0.98.0", + "@es-joy/escodegen": "^4.2.0", + "@es-joy/jsdoccomment": "~0.100.0", "@es-joy/resolve.exports": "1.2.0", - "@typescript-eslint/utils": "^8.70.0", + "@typescript-eslint/utils": "^8.72.0", "are-docs-informative": "^0.1.1", "comment-parser": "1.4.9", "debug": "^4.4.3", @@ -1382,6 +1461,19 @@ "url": "https://opencollective.com/eslint" } }, + "node_modules/esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "license": "BSD-2-Clause", + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=4" + } + }, "node_modules/esquery": { "version": "1.7.0", "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz", @@ -1559,9 +1651,9 @@ } }, "node_modules/globals": { - "version": "17.12.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-17.12.0.tgz", - "integrity": "sha512-cezEd/DTyyht9cvSSURyygXPfy04GtWO/5e6ZPvH7fCtjKz9PYOmuawphw1Ctd1f6C+5JypXfGD7ahNMXvevBA==", + "version": "17.13.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-17.13.0.tgz", + "integrity": "sha512-RwMTC61u7hrG3ZJMkZQOK4JLJrKS8QtoTii63EmWvFXHqycY9FObBJQCbsLxSO8kjKhWE5kV1GC+Vb1g3RI0Zg==", "license": "MIT", "engines": { "node": ">=18" @@ -2685,9 +2777,9 @@ "license": "MIT" }, "node_modules/node-releases": { - "version": "2.0.57", - "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.57.tgz", - "integrity": "sha512-kQK9LGGFiHtrWiNhZtA7Qbw17AQz+dmsEKODRIVTXA9+e5MS/2gZEBhYJt13GrAz5/IOZKddH/0Z3TP/Zgo+yw==", + "version": "2.0.60", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.60.tgz", + "integrity": "sha512-OmO8+GM1JUZqXET720VrJCwkjUCXmCMQm0Z3UDDRbfNLHS4NEAvY60j5jiFv0tkKw2PNNlqOLhahVmwJIOLDIQ==", "license": "MIT", "engines": { "node": ">=18" @@ -2700,9 +2792,9 @@ "license": "MIT" }, "node_modules/obug": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/obug/-/obug-2.2.1.tgz", - "integrity": "sha512-XrsrhT5sybtKI6wakr2SPOlGZWWYbUXZ7a0jT8/QOeAPau+1X/bSegNe5YR75oJmEZQbKningirmGOEJCIk61Q==", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/obug/-/obug-3.0.0.tgz", + "integrity": "sha512-5vvB5+W7ePv+p3uqxi+RcW1XAzLW0/hxt3/4X4Lc4qHudzOhmBiBwOY6DRob4WnanAEGvNcLjF+KNOufrUoEQw==", "funding": [ "https://github.com/sponsors/sxzz", "https://opencollective.com/debug" @@ -2930,6 +3022,16 @@ "node": ">=8" } }, + "node_modules/source-map": { + "version": "0.7.6", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.6.tgz", + "integrity": "sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==", + "license": "BSD-3-Clause", + "optional": true, + "engines": { + "node": ">= 12" + } + }, "node_modules/spdx-exceptions": { "version": "2.5.0", "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz", @@ -3098,9 +3200,9 @@ } }, "node_modules/update-browserslist-db": { - "version": "1.3.3", - "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.3.tgz", - "integrity": "sha512-pJ2sYawQS0R/WI928Gj5GlPhTGzbMelq0+4INtSYNDV9ErKJcX6xjGWkoG/VnB3dpUm00zALaqkrUD77pO5TDQ==", + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.4.tgz", + "integrity": "sha512-t8wonIOdQyOjtPd2VktlBu6QjTVTks6v8bSi7kd0r2Vll8TK1JYDZtRRdbmCHOAMphkZgrzK+L+vXK4pyZ8t4A==", "funding": [ { "type": "opencollective", @@ -3137,9 +3239,9 @@ } }, "node_modules/verkit": { - "version": "0.3.2", - "resolved": "https://registry.npmjs.org/verkit/-/verkit-0.3.2.tgz", - "integrity": "sha512-zj/ob3UsvJGN0whEAKFp53REA5X66hvffVqoCtVQAakJKnKlH+/PcOfMoFwIG/o4rElqLv/ycAFlx8ZlXUorCg==", + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/verkit/-/verkit-0.5.0.tgz", + "integrity": "sha512-u4J1hr6Y+C/hit34GwL3eIcUf3wngT8TlYUjK7tk0jxydKLAq3sYvifjdTDA6U3KCKRcQCQDGf/srjxfZF3l7g==", "license": "MIT", "engines": { "node": ">=18.12.0" diff --git a/tools/eslint/package.json b/tools/eslint/package.json index 70fb0a1825f..47a99e4fec4 100644 --- a/tools/eslint/package.json +++ b/tools/eslint/package.json @@ -3,17 +3,17 @@ "version": "0.0.0", "private": true, "dependencies": { - "@babel/core": "^8.0.6", - "@babel/eslint-parser": "^8.0.6", + "@babel/core": "^8.0.7", + "@babel/eslint-parser": "^8.0.7", "@babel/plugin-syntax-import-defer": "^8.0.1", "@babel/plugin-syntax-import-source": "^8.0.1", "@eslint/js": "^10.0.1", "@eslint/markdown": "^8.0.3", "@stylistic/eslint-plugin": "^5.10.0", - "eslint": "^10.11.0", + "eslint": "^10.13.0", "eslint-formatter-tap": "^9.0.1", - "eslint-plugin-jsdoc": "^64.5.4", + "eslint-plugin-jsdoc": "^65.4.0", "eslint-plugin-regexp": "^3.3.1", - "globals": "^17.12.0" + "globals": "^17.13.0" } } From d2446118fe34f13b99882e8837426372610e44fd Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 15:35:19 +0000 Subject: [PATCH 141/331] meta: bump actions/setup-python from 7.0.0 to 7.1.0 Bumps [actions/setup-python](https://github.com/actions/setup-python) from 7.0.0 to 7.1.0. - [Release notes](https://github.com/actions/setup-python/releases) - [Commits](https://github.com/actions/setup-python/compare/5fda3b95a4ea91299a34e894583c3862153e4b97...6d4fd22b20465ccc0f7354476588e8df7c9ca0e0) --- updated-dependencies: - dependency-name: actions/setup-python dependency-version: 7.1.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/67021 Reviewed-By: Antoine du Hamel Reviewed-By: Christian Clauss --- .github/workflows/build-tarball.yml | 4 ++-- .github/workflows/coverage-linux-without-intl.yml | 2 +- .github/workflows/coverage-linux.yml | 2 +- .github/workflows/coverage-windows.yml | 2 +- .github/workflows/daily-wpt-fyi.yml | 2 +- .github/workflows/linters.yml | 8 ++++---- .github/workflows/stress-test.yml | 2 +- .github/workflows/test-internet.yml | 2 +- .github/workflows/test-linux-perfetto.yml | 2 +- .github/workflows/test-linux-quic.yml | 2 +- .github/workflows/test-linux.yml | 2 +- .github/workflows/test-macos.yml | 2 +- .github/workflows/tools.yml | 2 +- 13 files changed, 17 insertions(+), 17 deletions(-) diff --git a/.github/workflows/build-tarball.yml b/.github/workflows/build-tarball.yml index ecf390917e8..009b753f4fa 100644 --- a/.github/workflows/build-tarball.yml +++ b/.github/workflows/build-tarball.yml @@ -80,7 +80,7 @@ jobs: with: persist-credentials: false - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true @@ -109,7 +109,7 @@ jobs: with: clang-version: ${{ env.CLANG_VERSION }} - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true diff --git a/.github/workflows/coverage-linux-without-intl.yml b/.github/workflows/coverage-linux-without-intl.yml index 4ab6975305b..889500fd43d 100644 --- a/.github/workflows/coverage-linux-without-intl.yml +++ b/.github/workflows/coverage-linux-without-intl.yml @@ -58,7 +58,7 @@ jobs: with: clang-version: ${{ env.CLANG_VERSION }} - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true diff --git a/.github/workflows/coverage-linux.yml b/.github/workflows/coverage-linux.yml index a642c0fada0..5b8c91973aa 100644 --- a/.github/workflows/coverage-linux.yml +++ b/.github/workflows/coverage-linux.yml @@ -58,7 +58,7 @@ jobs: with: clang-version: ${{ env.CLANG_VERSION }} - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true diff --git a/.github/workflows/coverage-windows.yml b/.github/workflows/coverage-windows.yml index b6bb989198e..749884c6138 100644 --- a/.github/workflows/coverage-windows.yml +++ b/.github/workflows/coverage-windows.yml @@ -76,7 +76,7 @@ jobs: with: persist-credentials: false - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true diff --git a/.github/workflows/daily-wpt-fyi.yml b/.github/workflows/daily-wpt-fyi.yml index d8ea4588fc4..9b7916e17d1 100644 --- a/.github/workflows/daily-wpt-fyi.yml +++ b/.github/workflows/daily-wpt-fyi.yml @@ -40,7 +40,7 @@ jobs: runs-on: ubuntu-24.04-arm steps: - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true diff --git a/.github/workflows/linters.yml b/.github/workflows/linters.yml index 3f7e254b69f..2d959d6bda7 100644 --- a/.github/workflows/linters.yml +++ b/.github/workflows/linters.yml @@ -52,7 +52,7 @@ jobs: !/deps/v8/ sparse-checkout-cone-mode: false - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true @@ -72,7 +72,7 @@ jobs: with: node-version: ${{ env.NODE_VERSION }} - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true @@ -178,7 +178,7 @@ jobs: *.py sparse-checkout-cone-mode: false - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true @@ -200,7 +200,7 @@ jobs: *.yaml sparse-checkout-cone-mode: false - name: Use Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true diff --git a/.github/workflows/stress-test.yml b/.github/workflows/stress-test.yml index e47c114d2f3..bd14c39ea99 100644 --- a/.github/workflows/stress-test.yml +++ b/.github/workflows/stress-test.yml @@ -67,7 +67,7 @@ jobs: if: runner.os == 'macOS' run: sudo xcode-select -s /Applications/Xcode_${{ env.XCODE_VERSION }}.app - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true diff --git a/.github/workflows/test-internet.yml b/.github/workflows/test-internet.yml index 09f52ed2aa4..f0da4104536 100644 --- a/.github/workflows/test-internet.yml +++ b/.github/workflows/test-internet.yml @@ -55,7 +55,7 @@ jobs: with: clang-version: ${{ env.CLANG_VERSION }} - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true diff --git a/.github/workflows/test-linux-perfetto.yml b/.github/workflows/test-linux-perfetto.yml index befb1700705..33215d41212 100644 --- a/.github/workflows/test-linux-perfetto.yml +++ b/.github/workflows/test-linux-perfetto.yml @@ -50,7 +50,7 @@ jobs: rustup override set "$RUSTC_VERSION" rustup --version - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true diff --git a/.github/workflows/test-linux-quic.yml b/.github/workflows/test-linux-quic.yml index f9ccef85978..15cd7e2842c 100644 --- a/.github/workflows/test-linux-quic.yml +++ b/.github/workflows/test-linux-quic.yml @@ -61,7 +61,7 @@ jobs: rustup override set "$RUSTC_VERSION" rustup --version - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true diff --git a/.github/workflows/test-linux.yml b/.github/workflows/test-linux.yml index cf10c654676..2d9c1185b8f 100644 --- a/.github/workflows/test-linux.yml +++ b/.github/workflows/test-linux.yml @@ -73,7 +73,7 @@ jobs: rustup override set "$RUSTC_VERSION" rustup --version - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true diff --git a/.github/workflows/test-macos.yml b/.github/workflows/test-macos.yml index 22292f2112f..fa27c2aeeb3 100644 --- a/.github/workflows/test-macos.yml +++ b/.github/workflows/test-macos.yml @@ -90,7 +90,7 @@ jobs: persist-credentials: false path: node - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true diff --git a/.github/workflows/tools.yml b/.github/workflows/tools.yml index 24c80cdf81a..f6e7bc5c86e 100644 --- a/.github/workflows/tools.yml +++ b/.github/workflows/tools.yml @@ -355,7 +355,7 @@ jobs: persist-credentials: false - name: Set up Python ${{ env.PYTHON_VERSION }} if: matrix.requires-python && (github.event_name == 'schedule' || inputs.id == 'all' || inputs.id == matrix.id) && steps.check-pr.outputs.hasNonBotCommits != 'true' - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ env.PYTHON_VERSION }} allow-prereleases: true From c085cec88e03c0a3c06a0fca981822da462e8ed0 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Wed, 28 Oct 2026 18:58:03 +0100 Subject: [PATCH 142/331] tools: fix number comparison if Nix diff viewer Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/66904 Reviewed-By: Filip Skokan --- .github/workflows/nix-changes-comment.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/nix-changes-comment.yml b/.github/workflows/nix-changes-comment.yml index 1eccc6a710d..371ed669d1f 100644 --- a/.github/workflows/nix-changes-comment.yml +++ b/.github/workflows/nix-changes-comment.yml @@ -54,7 +54,7 @@ jobs: AFTER=$(wc -l < "requisites-${PLATFORM}-after.list") TOTAL_AFTER=$(($TOTAL_AFTER + $AFTER)) DIFF="_no changes_" - [ "$BEFORE" = "$AFTER" ] || DIFF="**$([ "$AFTER" < "$BEFORE" ] || echo '+')$(($AFTER - $BEFORE))**" + [ "$BEFORE" = "$AFTER" ] || DIFF="**$([ "$AFTER" -lt "$BEFORE" ] || echo '+')$(($AFTER - $BEFORE))**" CHANGED=$(git diff --no-index "requisites-${PLATFORM}-before.list" "requisites-${PLATFORM}-after.list" | grep -c '^+[^+]') TOTAL_CHANGED=$(($TOTAL_CHANGED + $CHANGED)) PERCENT=100 @@ -68,7 +68,7 @@ jobs: done DIFF="_no changes_" - [ "$TOTAL_BEFORE" = "$TOTAL_AFTER" ] || DIFF="**$([ "$TOTAL_AFTER" < "$TOTAL_BEFORE" ] || echo '+')$(($TOTAL_AFTER - $TOTAL_BEFORE))**" + [ "$TOTAL_BEFORE" = "$TOTAL_AFTER" ] || DIFF="**$([ "$TOTAL_AFTER" -lt "$TOTAL_BEFORE" ] || echo '+')$(($TOTAL_AFTER - $TOTAL_BEFORE))**" PERCENT=100 [ "$TOTAL_CHANGED" = "$TOTAL_AFTER" ] || { PERMILLE=$((1000 * $TOTAL_CHANGED / $TOTAL_AFTER)) From 6a9db450cb00ee06e8fadb97ecfd04ab1507c40a Mon Sep 17 00:00:00 2001 From: Harjoth Khara Date: Wed, 28 Oct 2026 12:34:49 -0700 Subject: [PATCH 143/331] net,tls: fix session reuse with provided sockets Preserve literal IP hosts on net.Socket before connection. This keeps wrapped TLS sessions bound to the correct peer when tls.connect() uses a provided socket. Fixes: https://github.com/nodejs/node/issues/64402 Signed-off-by: harjoth Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/64430 Reviewed-By: Tim Perry --- lib/net.js | 3 +- .../test-tls-session-reuse-provided-socket.js | 99 +++++++++++++++++++ 2 files changed, 101 insertions(+), 1 deletion(-) create mode 100644 test/parallel/test-tls-session-reuse-provided-socket.js diff --git a/lib/net.js b/lib/net.js index 727a9312ed6..a59fee66a65 100644 --- a/lib/net.js +++ b/lib/net.js @@ -1774,6 +1774,8 @@ function lookupAndConnect(self, options) { // If host is an IP, skip performing a lookup const addressType = isIP(host); + // Retain the host before the IP fast path for TLS session identity binding. + self._host = host; if (addressType) { // An adopted BoundSocket needs no lookup: issue connect(2) in-tick so the // kernel-resolved concrete source address is observable synchronously. @@ -1815,7 +1817,6 @@ function lookupAndConnect(self, options) { debug('connect: find host', host); debug('connect: dns options', dnsopts); - self._host = host; const lookup = options.lookup || dns.lookup; if (dnsopts.family !== 4 && dnsopts.family !== 6 && !localAddress && autoSelectFamily) { diff --git a/test/parallel/test-tls-session-reuse-provided-socket.js b/test/parallel/test-tls-session-reuse-provided-socket.js new file mode 100644 index 00000000000..e23d4424463 --- /dev/null +++ b/test/parallel/test-tls-session-reuse-provided-socket.js @@ -0,0 +1,99 @@ +// Flags: --expose-internals +'use strict'; +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('assert'); +const fixtures = require('../common/fixtures'); +const { hasMultiLocalhost } = require('../common/net'); +const net = require('net'); +const tls = require('tls'); +const { once } = require('events'); + +async function connectWithSession( + socket, session, maxVersion, expectedReuse = true, servername, +) { + const tlsSocket = tls.connect({ + socket, + session, + servername, + maxVersion, + rejectUnauthorized: false, + }); + const close = once(tlsSocket, 'close'); + tlsSocket.resume(); + await once(tlsSocket, 'secureConnect'); + assert.strictEqual(tlsSocket.isSessionReused(), expectedReuse); + await close; +} + +async function connectAndCaptureSession( + port, maxVersion, host = '127.0.0.1', lookup, +) { + const socket = tls.connect({ + host, + lookup, + port, + maxVersion, + rejectUnauthorized: false, + }); + const close = once(socket, 'close'); + const sessionPromise = once(socket, 'session').then(([session]) => session); + socket.resume(); + await once(socket, 'secureConnect'); + assert.strictEqual(socket.isSessionReused(), false); + const session = await sessionPromise; + assert(Buffer.isBuffer(session)); + await close; + return session; +} + +async function testVersion(maxVersion) { + const server = tls.createServer({ + key: fixtures.readKey('agent1-key.pem'), + cert: fixtures.readKey('agent1-cert.pem'), + minVersion: maxVersion, + maxVersion, + }, (socket) => socket.end('ok')); + + server.listen(0, '0.0.0.0'); + await once(server, 'listening'); + const { port } = server.address(); + const session = await connectAndCaptureSession(port, maxVersion); + + let socket = net.connect({ host: '127.0.0.1', port }); + await once(socket, 'connect'); + await connectWithSession(socket, session, maxVersion); + + socket = net.connect({ host: '127.0.0.1', port }); + await connectWithSession(socket, session, maxVersion); + + if (hasMultiLocalhost()) { + socket = net.connect({ host: '127.0.0.2', port }); + await connectWithSession(socket, session, maxVersion, false); + } + + const lookup = (_hostname, _options, callback) => { + if (_options.all) { + callback(null, [{ address: '127.0.0.1', family: 4 }]); + } else { + callback(null, '127.0.0.1', 4); + } + }; + const hostnameSession = await connectAndCaptureSession( + port, maxVersion, 'localhost', lookup); + socket = net.connect({ host: 'localhost', port, lookup }); + await connectWithSession(socket, hostnameSession, maxVersion); + + socket = net.connect({ host: '127.0.0.1', port }); + await connectWithSession(socket, session, maxVersion, false, 'localhost'); + + server.close(); + await once(server, 'close'); +} + +(async function() { + await testVersion('TLSv1.2'); + await testVersion('TLSv1.3'); +})().then(common.mustCall()); From af7b97d57434af3881ad0cc0f0fa8e769baad171 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 20:53:22 +0000 Subject: [PATCH 144/331] meta: bump ossf/scorecard-action from 2.4.4 to 2.5.0 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [ossf/scorecard-action](https://github.com/ossf/scorecard-action) from 2.4.4 to 2.5.0. - [Release notes](https://github.com/ossf/scorecard-action/releases) - [Changelog](https://github.com/ossf/scorecard-action/blob/main/RELEASE.md) - [Commits](https://github.com/ossf/scorecard-action/compare/2d1146689b8cda280b9bc96326124645441f03bc...fa7117db83c52d787ae5a89f350999701505d78e) --- updated-dependencies: - dependency-name: ossf/scorecard-action dependency-version: 2.5.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/67020 Reviewed-By: Ulises Gascón Reviewed-By: Luigi Pinca --- .github/workflows/scorecard.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml index 994538ab4cd..16f1846a81a 100644 --- a/.github/workflows/scorecard.yml +++ b/.github/workflows/scorecard.yml @@ -46,7 +46,7 @@ jobs: persist-credentials: false - name: Run analysis - uses: ossf/scorecard-action@2d1146689b8cda280b9bc96326124645441f03bc # v2.4.4 + uses: ossf/scorecard-action@fa7117db83c52d787ae5a89f350999701505d78e # v2.5.0 with: results_file: results.sarif results_format: sarif From f69426a7c5cea3dbbbf898d3b06fcdbad5ab2c12 Mon Sep 17 00:00:00 2001 From: Donghoon Kang Date: Thu, 29 Oct 2026 08:17:28 +0900 Subject: [PATCH 145/331] doc: fix sqlite tagged template examples MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: HoonDongKang PR-URL: https://github.com/nodejs/node/pull/66920 Reviewed-By: Trivikram Kamat Reviewed-By: Guilherme Araújo --- doc/api/sqlite.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md index c041f89b096..8569b5fc036 100644 --- a/doc/api/sqlite.md +++ b/doc/api/sqlite.md @@ -779,13 +779,13 @@ statement for future use. > literals, where it performs string interpolation. > > ```js -> // This a safe example of binding a parameter to a tagged statement. +> // This is a safe example of binding a parameter to a tagged statement. > sqlTagStore.run`INSERT INTO t1 (id) VALUES (${id})`; > > // This is an *unsafe* example of an untagged template string. > // `id` is interpolated into the query text as a string. > // This can lead to SQL injection and data corruption. -> db.run(`INSERT INTO t1 (id) VALUES (${id})`); +> db.exec(`INSERT INTO t1 (id) VALUES (${id})`); > ``` The tag store will match a statement from the cache if the query strings From 1fb58b93fcdd3fd927b4b2a1fb98024d019e8c98 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guilherme=20Ara=C3=BAjo?= Date: Tue, 20 Oct 2026 22:49:34 -0300 Subject: [PATCH 146/331] sqlite: track statements in the Statement constructor MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Statement::Close() untracks itself, so the constructor should track itself too, like Session does, instead of relying on every caller. Signed-off-by: Guilherme Araújo PR-URL: https://github.com/nodejs/node/pull/66912 Reviewed-By: Trivikram Kamat --- src/node_sqlite.cc | 7 +++++-- src/node_sqlite.h | 1 + 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index ae8fa360a20..e83006d7db4 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -1769,6 +1769,10 @@ void Database::FinalizeStatements() { statements_.clear(); } +void Database::TrackStatement(Statement* statement) { + statements_.insert(statement); +} + void Database::UntrackStatement(Statement* statement) { statements_.erase(statement); } @@ -2182,7 +2186,6 @@ void Database::Prepare(const FunctionCallbackInfo& args) { if (!stmt) { return; } - db->statements_.insert(stmt.get()); if (return_arrays.has_value()) { stmt->return_arrays_ = return_arrays.value(); @@ -3491,6 +3494,7 @@ Statement::Statement(Environment* env, BaseObjectPtr db, StatementPtr stmt) : BaseObject(env, object), db_(std::move(db)), statement_(std::move(stmt)) { + db_->TrackStatement(this); MakeWeak(); use_big_ints_ = db_->use_big_ints(); return_arrays_ = db_->return_arrays(); @@ -4660,7 +4664,6 @@ BaseObjectPtr SQLTagStore::PrepareStatement( return BaseObjectPtr(); } - session->database_->statements_.insert(stmt_obj.get()); session->sql_tags_.Put(sql, stmt_obj); stmt = stmt_obj; } diff --git a/src/node_sqlite.h b/src/node_sqlite.h index 60d70e90139..47dd1a77423 100644 --- a/src/node_sqlite.h +++ b/src/node_sqlite.h @@ -262,6 +262,7 @@ class Database : public BaseObject { void RemoveBackup(BackupJob* backup); void AddBackup(BackupJob* backup); void FinalizeBackups(); + void TrackStatement(Statement* statement); void UntrackStatement(Statement* statement); bool IsOpen(); // SQL functions are one of several paths by which SQLite can invoke JS. From 8e9fef532162b91b4b3375af2d8a7f0584eb093b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guilherme=20Ara=C3=BAjo?= Date: Tue, 20 Oct 2026 22:51:22 -0300 Subject: [PATCH 147/331] sqlite: use DeleteFnPtr for all SQLite handles MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace the custom deleter structs and OnScopeLeave cleanups with DeleteFnPtr aliases, and pass session ownership to Session::Create. Signed-off-by: Guilherme Araújo PR-URL: https://github.com/nodejs/node/pull/66912 Reviewed-By: Trivikram Kamat --- src/node_sqlite.cc | 46 ++++++++++++++++++---------------------------- src/node_sqlite.h | 25 +++++++++++++++---------- 2 files changed, 33 insertions(+), 38 deletions(-) diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index e83006d7db4..e43debae709 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -743,9 +743,7 @@ class BackupJob : public ThreadPoolWork { } void Cleanup() { - if (backup_) { - sqlite3_backup_finish(backup_.release()); - } + backup_.reset(); if (dest_) { backup_status_ = sqlite3_errcode(dest_.get()); @@ -786,14 +784,8 @@ class BackupJob : public ThreadPoolWork { BaseObjectPtr source_; Global resolver_; Global progressFunc_; - struct Sqlite3Deleter { - void operator()(sqlite3* db) const { sqlite3_close_v2(db); } - }; - struct BackupDeleter { - void operator()(sqlite3_backup* b) const { sqlite3_backup_finish(b); } - }; - std::unique_ptr dest_; - std::unique_ptr backup_; + ConnectionPtr dest_; + BackupPtr backup_; int pages_; int backup_status_ = SQLITE_OK; std::string source_db_; @@ -2101,6 +2093,8 @@ void Database::Close(const FunctionCallbackInfo& args) { env, db->IsInCallback(), "database cannot be closed while in a callback"); db->FinalizeStatements(); db->DeleteSessions(); + // Close through the raw handle instead of reset() so that a failed close + // keeps the handle, which the error below is read from. int r = sqlite3_close_v2(db->connection_.get()); CHECK_ERROR_OR_THROW(env->isolate(), db, r, SQLITE_OK, void()); db->connection_.release(); @@ -2892,26 +2886,21 @@ void Database::CreateSession(const FunctionCallbackInfo& args) { // getter, which may have closed the database since it was checked. THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open"); - sqlite3_session* pSession; - int r = - sqlite3session_create(db->connection_.get(), db_name.c_str(), &pSession); + sqlite3_session* raw_session; + int r = sqlite3session_create( + db->connection_.get(), db_name.c_str(), &raw_session); CHECK_ERROR_OR_THROW(env->isolate(), db, r, SQLITE_OK, void()); - bool wrapper_owns_session = false; - auto delete_session_on_failure = OnScopeLeave([&]() { - if (!wrapper_owns_session) { - sqlite3session_delete(pSession); - } - }); + SessionPtr pSession(raw_session); - r = sqlite3session_attach(pSession, table == "" ? nullptr : table.c_str()); + r = sqlite3session_attach(pSession.get(), + table == "" ? nullptr : table.c_str()); CHECK_ERROR_OR_THROW(env->isolate(), db, r, SQLITE_OK, void()); BaseObjectPtr session = - Session::Create(env, BaseObjectPtr(db), pSession); + Session::Create(env, BaseObjectPtr(db), std::move(pSession)); if (!session) { return; } - wrapper_owns_session = true; args.GetReturnValue().Set(session->object()); } @@ -4898,9 +4887,9 @@ void StatementIterator::Return(const FunctionCallbackInfo& args) { Session::Session(Environment* env, Local object, BaseObjectPtr database, - sqlite3_session* session) + SessionPtr session) : BaseObject(env, object), - session_(std::unique_ptr(session)), + session_(std::move(session)), database_(std::move(database)) { database_->sessions_.insert(this); MakeWeak(); @@ -4912,7 +4901,7 @@ Session::~Session() { BaseObjectPtr Session::Create(Environment* env, BaseObjectPtr database, - sqlite3_session* session) { + SessionPtr session) { Local obj; if (!GetConstructorTemplate(env) ->InstanceTemplate() @@ -4921,7 +4910,8 @@ BaseObjectPtr Session::Create(Environment* env, return nullptr; } - return MakeBaseObject(env, obj, std::move(database), session); + return MakeBaseObject( + env, obj, std::move(database), std::move(session)); } Local Session::GetConstructorTemplate(Environment* env) { @@ -4970,7 +4960,7 @@ void Session::Changeset(const FunctionCallbackInfo& args) { CHECK_ERROR_OR_THROW( env->isolate(), session->database_.get(), r, SQLITE_OK, void()); - auto freeChangeset = OnScopeLeave([&] { sqlite3_free(pChangeset); }); + DeleteFnPtr changeset(pChangeset); Local buffer = ArrayBuffer::New(env->isolate(), nChangeset); if (nChangeset > 0) { diff --git a/src/node_sqlite.h b/src/node_sqlite.h index 47dd1a77423..529cf2b40ef 100644 --- a/src/node_sqlite.h +++ b/src/node_sqlite.h @@ -173,7 +173,18 @@ inline void FinalizeStatement(sqlite3_stmt* stmt) { sqlite3_finalize(stmt); } +inline void CloseConnection(sqlite3* db) { + sqlite3_close_v2(db); +} + +inline void FinishBackup(sqlite3_backup* backup) { + sqlite3_backup_finish(backup); +} + using StatementPtr = DeleteFnPtr; +using ConnectionPtr = DeleteFnPtr; +using BackupPtr = DeleteFnPtr; +using SessionPtr = DeleteFnPtr; class StatementExecutionHelper { public: @@ -338,10 +349,7 @@ class Database : public BaseObject { DatabaseOpenConfiguration open_config_; bool allow_load_extension_; bool enable_load_extension_; - struct ConnectionDeleter { - void operator()(sqlite3* db) const { sqlite3_close_v2(db); } - }; - std::unique_ptr connection_; + ConnectionPtr connection_; bool ignore_next_sqlite_error_; int callback_depth_ = 0; int destructor_depth_ = 0; @@ -465,7 +473,7 @@ class Session : public BaseObject { Session(Environment* env, v8::Local object, BaseObjectPtr database, - sqlite3_session* session); + SessionPtr session); ~Session() override; template static void Changeset(const v8::FunctionCallbackInfo& args); @@ -475,7 +483,7 @@ class Session : public BaseObject { Environment* env); static BaseObjectPtr Create(Environment* env, BaseObjectPtr database, - sqlite3_session* session); + SessionPtr session); void MemoryInfo(MemoryTracker* tracker) const override; SET_MEMORY_INFO_NAME(Session) @@ -483,10 +491,7 @@ class Session : public BaseObject { private: void Delete(); - struct SessionDeleter { - void operator()(sqlite3_session* s) const { sqlite3session_delete(s); } - }; - std::unique_ptr session_; + SessionPtr session_; BaseObjectPtr database_; // The Parent Database bool is_generating_changeset_ = false; From 2ae36bda765e5262215c072d855ccb70ad9a8893 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guilherme=20Ara=C3=BAjo?= Date: Tue, 20 Oct 2026 22:52:14 -0300 Subject: [PATCH 148/331] sqlite: settle BackupJob through a single exit point MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Route every exit through Settle(), which finalizes, settles the promise and deletes the job once. This also frees the job when building the progress object fails. Signed-off-by: Guilherme Araújo PR-URL: https://github.com/nodejs/node/pull/66912 Reviewed-By: Trivikram Kamat --- src/node_sqlite.cc | 52 ++++++++++++++++------------------------------ 1 file changed, 18 insertions(+), 34 deletions(-) diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index e43debae709..ef117ceb6fc 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -645,7 +645,7 @@ class BackupJob : public ThreadPoolWork { Local resolver = Local::New(env()->isolate(), resolver_); if (backup_status_ != SQLITE_OK) { - HandleBackupError(resolver); + Settle(resolver, CreateSQLiteError(isolate, dest_.get()), {}); return; } @@ -654,7 +654,7 @@ class BackupJob : public ThreadPoolWork { source_->Connection(), source_db_.c_str())); if (!backup_) { - HandleBackupError(resolver); + Settle(resolver, CreateSQLiteError(isolate, dest_.get()), {}); return; } @@ -676,7 +676,7 @@ class BackupJob : public ThreadPoolWork { if (!(backup_status_ == SQLITE_OK || backup_status_ == SQLITE_DONE || backup_status_ == SQLITE_BUSY || backup_status_ == SQLITE_LOCKED)) { - HandleBackupError(resolver, backup_status_); + Settle(resolver, CreateSQLiteError(isolate, backup_status_), {}); return; } @@ -702,6 +702,7 @@ class BackupJob : public ThreadPoolWork { env()->remaining_pages_string(), Integer::New(env()->isolate(), remaining_pages)) .IsNothing()) { + Settle(resolver, {}, {}); return; } @@ -709,10 +710,7 @@ class BackupJob : public ThreadPoolWork { TryCatch try_catch(env()->isolate()); USE(fn->Call(env()->context(), Null(env()->isolate()), 1, argv)); if (try_catch.HasCaught()) { - Local exception = try_catch.Exception(); - Finalize(); - resolver->Reject(env()->context(), exception).ToChecked(); - delete this; + Settle(resolver, try_catch.Exception(), {}); return; } } @@ -723,15 +721,11 @@ class BackupJob : public ThreadPoolWork { } if (backup_status_ != SQLITE_DONE) { - HandleBackupError(resolver); + Settle(resolver, CreateSQLiteError(isolate, dest_.get()), {}); return; } - Finalize(); - resolver - ->Resolve(env()->context(), Integer::New(env()->isolate(), total_pages)) - .ToChecked(); - delete this; + Settle(resolver, {}, Integer::New(isolate, total_pages)); } void Finalize() { @@ -752,29 +746,19 @@ class BackupJob : public ThreadPoolWork { } private: - void HandleBackupError(Local resolver) { - Local e; - if (!CreateSQLiteError(env()->isolate(), dest_.get()).ToLocal(&e)) { - Finalize(); - delete this; - return; - } - + // The single exit point of a backup. Rejects with `error` if it is set, + // otherwise resolves with `value` if it is set. Neither being set means an + // exception is already pending. Deletes the job. + void Settle(Local resolver, + MaybeLocal error, + Local value) { Finalize(); - resolver->Reject(env()->context(), e).ToChecked(); - delete this; - } - - void HandleBackupError(Local resolver, int errcode) { - Local e; - if (!CreateSQLiteError(env()->isolate(), errcode).ToLocal(&e)) { - Finalize(); - delete this; - return; + Local e; + if (error.ToLocal(&e)) { + resolver->Reject(env()->context(), e).ToChecked(); + } else if (!value.IsEmpty()) { + resolver->Resolve(env()->context(), value).ToChecked(); } - - Finalize(); - resolver->Reject(env()->context(), e).ToChecked(); delete this; } From 1dd9dbef18ee8e0da576eafbbb9bce1ab6616e71 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guilherme=20Ara=C3=BAjo?= Date: Tue, 20 Oct 2026 22:53:03 -0300 Subject: [PATCH 149/331] sqlite: cache the SQLTagStore constructor template MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Store the template on the environment like the other sqlite classes, so stores no longer get a fresh template and prototype each time. Signed-off-by: Guilherme Araújo PR-URL: https://github.com/nodejs/node/pull/66912 Reviewed-By: Trivikram Kamat --- src/env_properties.h | 1 + src/node_sqlite.cc | 39 ++++++++++++----------- test/parallel/test-sqlite-template-tag.js | 6 ++++ 3 files changed, 28 insertions(+), 18 deletions(-) diff --git a/src/env_properties.h b/src/env_properties.h index 1507a5e0386..22876f8f971 100644 --- a/src/env_properties.h +++ b/src/env_properties.h @@ -456,6 +456,7 @@ V(sqlite_statement_sync_constructor_template, v8::FunctionTemplate) \ V(sqlite_statement_sync_iterator_constructor_template, v8::FunctionTemplate) \ V(sqlite_session_constructor_template, v8::FunctionTemplate) \ + V(sqlite_tag_store_constructor_template, v8::FunctionTemplate) \ V(srv_record_template, v8::DictionaryTemplate) \ V(streambaseoutputstream_constructor_template, v8::ObjectTemplate) \ V(tcp_constructor_template, v8::FunctionTemplate) \ diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index ef117ceb6fc..712e2177641 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -4353,24 +4353,27 @@ static inline void SetSideEffectFreeGetter( SQLTagStore::~SQLTagStore() {} Local SQLTagStore::GetConstructorTemplate(Environment* env) { - Isolate* isolate = env->isolate(); - Local tmpl = - NewFunctionTemplate(isolate, IllegalConstructor); - tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "SQLTagStore")); - tmpl->InstanceTemplate()->SetInternalFieldCount( - SQLTagStore::kInternalFieldCount); - SetProtoMethod(isolate, tmpl, "get", Get); - SetProtoMethod(isolate, tmpl, "all", All); - SetProtoMethod(isolate, tmpl, "iterate", Iterate); - SetProtoMethod(isolate, tmpl, "run", Run); - SetProtoMethod(isolate, tmpl, "clear", Clear); - SetSideEffectFreeGetter(isolate, - tmpl, - FIXED_ONE_BYTE_STRING(isolate, "capacity"), - CapacityGetter); - SetSideEffectFreeGetter( - isolate, tmpl, FIXED_ONE_BYTE_STRING(isolate, "db"), DatabaseGetter); - SetSideEffectFreeGetter(isolate, tmpl, env->size_string(), SizeGetter); + Local tmpl = env->sqlite_tag_store_constructor_template(); + if (tmpl.IsEmpty()) { + Isolate* isolate = env->isolate(); + tmpl = NewFunctionTemplate(isolate, IllegalConstructor); + tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "SQLTagStore")); + tmpl->InstanceTemplate()->SetInternalFieldCount( + SQLTagStore::kInternalFieldCount); + SetProtoMethod(isolate, tmpl, "get", Get); + SetProtoMethod(isolate, tmpl, "all", All); + SetProtoMethod(isolate, tmpl, "iterate", Iterate); + SetProtoMethod(isolate, tmpl, "run", Run); + SetProtoMethod(isolate, tmpl, "clear", Clear); + SetSideEffectFreeGetter(isolate, + tmpl, + FIXED_ONE_BYTE_STRING(isolate, "capacity"), + CapacityGetter); + SetSideEffectFreeGetter( + isolate, tmpl, FIXED_ONE_BYTE_STRING(isolate, "db"), DatabaseGetter); + SetSideEffectFreeGetter(isolate, tmpl, env->size_string(), SizeGetter); + env->set_sqlite_tag_store_constructor_template(tmpl); + } return tmpl; } diff --git a/test/parallel/test-sqlite-template-tag.js b/test/parallel/test-sqlite-template-tag.js index f7a5053a330..5ecf055523f 100644 --- a/test/parallel/test-sqlite-template-tag.js +++ b/test/parallel/test-sqlite-template-tag.js @@ -295,6 +295,12 @@ test('sql.db returns the associated Database instance', () => { assert.strictEqual(sql.db, db); }); +test('tag stores share a prototype', () => { + const other = new Database(':memory:').createTagStore(); + assert.strictEqual(Object.getPrototypeOf(other), Object.getPrototypeOf(sql)); + assert.strictEqual(other.constructor, sql.constructor); +}); + test('sql error messages are descriptive', () => { assert.strictEqual(sql.run`INSERT INTO foo (text) VALUES (${'test'})`.changes, 1); From 04f072c9b16543986b71ff863b431b86d72426c4 Mon Sep 17 00:00:00 2001 From: Seongeun Lee Date: Thu, 29 Oct 2026 17:47:51 +0900 Subject: [PATCH 150/331] typings: share Sign and Verify handle methods Extract SignBaseHandle for the shared init and update methods. Preserve existing signatures and runtime behavior. Assisted-by: Codex Signed-off-by: leah-1ee PR-URL: https://github.com/nodejs/node/pull/66499 Reviewed-By: Tim Perry --- typings/internalBinding/crypto.d.ts | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/typings/internalBinding/crypto.d.ts b/typings/internalBinding/crypto.d.ts index 22ee303f599..14da4e83fb4 100644 --- a/typings/internalBinding/crypto.d.ts +++ b/typings/internalBinding/crypto.d.ts @@ -665,9 +665,12 @@ declare namespace InternalCryptoBinding { setPrivateKey(key: ByteSource): void; } - interface SignHandle { + interface SignBaseHandle { init(algorithm: string): void; update(data: ByteSource, encoding?: string): void; + } + + interface SignHandle extends SignBaseHandle { sign( ...args: [ ...key: PreparedAsymmetricKeyArgs, @@ -678,9 +681,7 @@ declare namespace InternalCryptoBinding { ): Buffer; } - interface VerifyHandle { - init(algorithm: string): void; - update(data: ByteSource, encoding?: string): void; + interface VerifyHandle extends SignBaseHandle { verify( ...args: [ ...key: PreparedAsymmetricKeyArgs, From c1b8f0e9718cb8ec4efa8e36cf264069402d005e Mon Sep 17 00:00:00 2001 From: Marco Date: Thu, 29 Oct 2026 09:56:09 +0100 Subject: [PATCH 151/331] child_process: add subprocess.timedOut When the timeout option of spawn(), exec(), execFile() or fork() expires, the child is sent the kill signal and exits with that signal. Nothing told the caller that the timeout was the reason. Set subprocess.timedOut to true when the kill signal is sent because of the timeout, and add the same flag to the error passed to the exec() and execFile() callback. Fixes: https://github.com/nodejs/node/issues/51561 Refs: https://github.com/nodejs/node/pull/51608 Signed-off-by: marcopiraccini PR-URL: https://github.com/nodejs/node/pull/66639 Reviewed-By: Paolo Insogna --- doc/api/child_process.md | 30 +++++++++- lib/child_process.js | 12 +++- lib/internal/child_process.js | 1 + .../test-child-process-exec-timeout-expire.js | 1 + .../test-child-process-exec-timeout-kill.js | 4 +- ...-child-process-exec-timeout-not-expired.js | 40 ++++++++++++- ...child-process-spawn-timeout-kill-signal.js | 59 ++++++++++++++++++- 7 files changed, 139 insertions(+), 8 deletions(-) diff --git a/doc/api/child_process.md b/doc/api/child_process.md index 3f82fb56a88..87b17ae441b 100644 --- a/doc/api/child_process.md +++ b/doc/api/child_process.md @@ -233,7 +233,8 @@ If a `callback` function is provided, it is called with the arguments `error` will be an instance of [`Error`][]. The `error.code` property will be the exit code of the process. By convention, any exit code other than `0` indicates an error. `error.signal` will be the signal that terminated the -process. +process. `error.timedOut` will be `true` if the process was killed because +the `timeout` option expired. The `stdout` and `stderr` arguments passed to the callback will contain the stdout and stderr output of the child process. By default, Node.js will decode @@ -2314,6 +2315,32 @@ subprocess.stdout.on('data', (data) => { The `subprocess.stdout` property can be `null` or `undefined` if the child process could not be successfully spawned. +### `subprocess.timedOut` + + + +* Type: {boolean} Set to `true` when the child process is killed because the + `timeout` option expired. + +The `subprocess.timedOut` property indicates whether the `timeout` option of +[`child_process.spawn()`][], [`child_process.exec()`][], +[`child_process.execFile()`][] or [`child_process.fork()`][] expired and the +child process was sent the `killSignal` as a result. Like +[`subprocess.killed`][], it does not indicate that the child process has +terminated yet. + +```js +const { spawn } = require('node:child_process'); + +const subprocess = spawn('sleep', ['10'], { timeout: 100 }); + +subprocess.on('exit', (code, signal) => { + console.log(subprocess.timedOut); // true +}); +``` + ### `subprocess.unref()` |<- atomic32 ->| +// atomic +// +// Writers check capacity by loading rw_positions once. In memory: +// - The first four bytes hold read_pos. +// - The next four bytes hold write_pos. +// Keeping both in one atomic avoids combining counters read at different times. +// +// The reader is the only one that moves read_pos. It publishes a new value once +// per drain pass and then wakes any writer parked on a full ring buffer. +// read_pos is also the first four bytes of rw_positions, which is the address +// the futex waits on. +// +// num_writers_waiting lets the reader skip a futex wake when nobody is waiting +// for space. It is only an optimization and never decides whether the ring +// buffer is full or who owns a chunk. +// +// Bytes 12..63 pad the header to one cache line. +// +static_assert(sizeof(std::atomic) == 4 && + alignof(std::atomic) <= 4, + "Chunk state must fit in a 4-byte-aligned ABI word"); +static_assert(sizeof(std::atomic) == 8, + "The packed positions must occupy 8 bytes"); +static_assert(std::atomic::is_always_lock_free && + std::atomic::is_always_lock_free, + "Shared-memory atomics must be lock-free"); + +struct alignas(64) RingBufferHeader { + std::atomic rw_positions; + std::atomic num_writers_waiting; + uint8_t reserved[52]; +}; + +static_assert(offsetof(RingBufferHeader, num_writers_waiting) == 8 && + offsetof(RingBufferHeader, reserved) == 12 && + sizeof(RingBufferHeader) == 64, + "RingBufferHeader does not match the shared-memory ABI"); + +// Logical positions and chunk indexing +// ------------------------------------ +// +// write_pos is the next position a writer can reserve. read_pos is the next +// position the reader must consume. These are logical positions: +// - They keep advancing past num_chunks across successive traversals. +// - As uint32_t counters, they roll over from UINT32_MAX to zero. +// - Both reader and writer map a position to a physical chunk before access. +// ChunkIndex::FromPosition() performs that mapping modulo num_chunks. +// +// A writer reserves a position by advancing write_pos, then tries to claim +// its physical chunk. +// +// The number of reserved positions not yet handled by the reader is: +// +// outstanding = uint32_t(write_pos - read_pos) <= num_chunks < 2^31 +// +// - If outstanding is zero, write_pos == read_pos and the ring buffer is empty. +// - If outstanding equals num_chunks, the ring buffer is full: +// write_pos == uint32_t(read_pos + num_chunks). Writers cannot advance +// write_pos until the reader advances read_pos to make space. +// +// Unsigned subtraction also works when write_pos wraps back to zero. For +// example: +// +// read_pos = UINT32_MAX - 3 +// write_pos = 2 +// uint32_t(write_pos - read_pos) = 6 +// +// A legal result is at most num_chunks. A larger result means that the two +// positions do not describe a valid ring buffer state. +// +// At most one outstanding reservation maps to each physical chunk. An exact +// comparison of the chunk's state word therefore determines ownership. +// A delayed claim can match a later traversal after the wrap count repeats. +// See WrapCountForPosition() for this limit. + +// The unsigned subtraction above is unambiguous only while fewer than 2^31 +// positions are outstanding. num_chunks is a power of two, so 2^30 is the +// largest legal chunk count. +constexpr uint32_t kMaxChunksPerRing = 1u << 30; + +// True if |chunk_size| is in [kMinChunkSize, kMaxChunkSize] and a multiple of +// kChunkAlignmentBytes. +constexpr bool IsValidChunkSize(uint32_t chunk_size) { + return chunk_size >= kMinChunkSize && chunk_size <= kMaxChunkSize && + chunk_size % kChunkAlignmentBytes == 0; +} + +// Validates the layout of an untrusted ring buffer and returns its chunk +// count, or an error describing why the layout is invalid. +// The service calls it on the ring buffer that a producer attaches. +// +// - Any thread can call it. It reads no shared bytes. +// - The transport limits the mapping size separately. +// - The SharedRingBuffer constructor treats validation errors as fatal. +// - RingBufferSizeForShmSizeHint() works the other way, it picks a size that +// passes this check. +inline base::StatusOr NumChunksForRingBufferLayout( + const void* start, + size_t size, + uint32_t chunk_size) { + if (!start || + reinterpret_cast(start) % alignof(RingBufferHeader) != 0) { + return base::ErrStatus("ring buffer start is null or misaligned"); + } + if (!IsValidChunkSize(chunk_size)) + return base::ErrStatus("invalid chunk size %u", chunk_size); + // Subtract the header after this check to avoid overflow on 32-bit builds. + if (size < sizeof(RingBufferHeader)) + return base::ErrStatus("ring buffer size %zu is below the header", size); + const size_t chunks_size = size - sizeof(RingBufferHeader); + if (chunks_size % chunk_size != 0) { + return base::ErrStatus("ring buffer size %zu is not header + N * %u", size, + chunk_size); + } + const size_t count = chunks_size / chunk_size; + // Two chunks form the minimum useful configuration. One chunk satisfies + // the ABI: write_pos - read_pos is 0 when empty and 1 when full. + // The Free wrap count distinguishes successive uses of that chunk. + // + // The power-of-two rule permits chunk indexing with a mask. The maximum + // keeps outstanding positions below 2^31 for unambiguous unsigned + // subtraction. + if (count < kMinChunksPerRing || count > kMaxChunksPerRing || + !base::IsPowerOfTwo(count)) { + return base::ErrStatus("invalid chunk count %zu", count); } + return static_cast(count); } -} // namespace +// Picks the size of a new ring buffer. +// The producer calls this before it allocates its ring buffer, to turn a byte +// size hint into a size that NumChunksForRingBufferLayout() accepts. +// +// - Returns the size, header included, of the largest valid ring buffer +// whose chunks fit in |shmem_size_hint_bytes| bytes. +// - Uses kDefaultChunkBudgetBytes if |shmem_size_hint_bytes| is zero. +// - The header comes on top of the hint. +// The returned size is capped at |max_shmem_size_bytes|. +// - Returns an error status if fewer than kMinChunksPerRing chunks fit, or if +// |chunk_size| is invalid. +// - Any thread can call it, because it reads no shared memory. +inline base::StatusOr RingBufferSizeForShmSizeHint( + size_t shmem_size_hint_bytes, + size_t max_shmem_size_bytes, + uint32_t chunk_size) { + if (!IsValidChunkSize(chunk_size)) + return base::ErrStatus("invalid chunk size %u", chunk_size); + if (max_shmem_size_bytes < sizeof(RingBufferHeader)) { + return base::ErrStatus("maximum size %zu is below the header", + max_shmem_size_bytes); + } + + const size_t available_chunk_bytes = std::min( + shmem_size_hint_bytes ? shmem_size_hint_bytes : kDefaultChunkBudgetBytes, + max_shmem_size_bytes - sizeof(RingBufferHeader)); + const size_t max_count = available_chunk_bytes / chunk_size; + + // Find the largest power of two that is at most |max_count|: start at + // kMaxChunksPerRing, a power of two, and halve it until it fits. + // Every value on the way is a power of two and at most the maximum, so only + // the minimum chunk count is left to check. + static_assert(base::IsPowerOfTwo(kMaxChunksPerRing)); + size_t count = kMaxChunksPerRing; + while (count > max_count) + count /= 2; + + if (count < kMinChunksPerRing) { + return base::ErrStatus("no ring buffer of %u-byte chunks fits in %zu bytes", + chunk_size, available_chunk_bytes); + } + const size_t size = sizeof(RingBufferHeader) + count * chunk_size; + PERFETTO_CHECK(size <= max_shmem_size_bytes); + return size; +} -void StringFilter::AddRule(Policy policy, - std::string_view pattern_str, - std::string atrace_payload_starts_with, - std::string name, - SemanticTypeMask semantic_type_mask) { - perfetto::base::CopyableRegex re( - perfetto::base::Regex::CreateOrCheck(std::string(pattern_str))); - Rule new_rule{policy, std::move(re), std::move(atrace_payload_starts_with), - std::move(name), semantic_type_mask}; - // If name is non-empty, look for existing rule with same name and replace. - if (!new_rule.name.empty()) { - for (Rule& existing : rules_) { - if (existing.name == new_rule.name) { - existing = std::move(new_rule); - return; - } - } - } - rules_.push_back(std::move(new_rule)); +constexpr uint64_t PackRwPositions(uint32_t write_pos, uint32_t read_pos) { + return (static_cast(write_pos) << 32) | read_pos; } -bool StringFilter::MaybeFilterInternal(char* ptr, - size_t len, - uint32_t semantic_type) const { - bool atrace_find_tried = false; - const char* atrace_payload_ptr = nullptr; - std::string_view input(ptr, len); +constexpr uint32_t WritePosOf(uint64_t rw_positions) { + return static_cast(rw_positions >> 32); +} - for (const Rule& rule : rules_) { - if (!rule.semantic_type_mask.IsSet(semantic_type)) { - continue; - } - switch (rule.policy) { - case Policy::kMatchBreak: - if (PERFETTO_UNLIKELY(rule.pattern->FullMatch(input))) - return false; - break; - case Policy::kMatchRedactGroups: - if (PERFETTO_UNLIKELY( - rule.pattern->FullMatchWithGroups(input, matches_))) { - RedactMatches(matches_); - return true; - } - break; - case Policy::kAtraceMatchBreak: - atrace_payload_ptr = atrace_find_tried - ? atrace_payload_ptr - : FindAtracePayloadPtr(ptr, ptr + len); - atrace_find_tried = true; - if (atrace_payload_ptr && - StartsWith(atrace_payload_ptr, ptr + len, - rule.atrace_payload_starts_with) && - rule.pattern->FullMatch(input)) { - return false; - } - break; - case Policy::kAtraceMatchRedactGroups: - atrace_payload_ptr = atrace_find_tried - ? atrace_payload_ptr - : FindAtracePayloadPtr(ptr, ptr + len); - atrace_find_tried = true; - if (atrace_payload_ptr && - StartsWith(atrace_payload_ptr, ptr + len, - rule.atrace_payload_starts_with) && - PERFETTO_UNLIKELY( - rule.pattern->FullMatchWithGroups(input, matches_))) { - RedactMatches(matches_); - return true; - } - break; - case Policy::kAtraceRepeatedSearchRedactGroups: - atrace_payload_ptr = atrace_find_tried - ? atrace_payload_ptr - : FindAtracePayloadPtr(ptr, ptr + len); - atrace_find_tried = true; - if (atrace_payload_ptr && StartsWith(atrace_payload_ptr, ptr + len, - rule.atrace_payload_starts_with)) { - bool has_any_matches = false; - for (auto iter = rule.pattern->PartialMatchAll(input); - iter.NextWithGroups(matches_);) { - RedactMatches(matches_); - has_any_matches = true; - } - if (has_any_matches) { - return true; - } - } - break; - } - } - return false; +constexpr uint32_t ReadPosOf(uint64_t rw_positions) { + return static_cast(rw_positions); } -} // namespace protozero -// gen_amalgamated begin source: src/protozero/filtering/message_filter.cc -// gen_amalgamated begin header: src/protozero/filtering/message_filter.h -// gen_amalgamated begin header: src/protozero/filtering/message_tokenizer.h -/* - * Copyright (C) 2021 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ +// Replaces the read half of a previously loaded rw_positions value, leaving +// write_pos unchanged. The reader publishes read_pos this way. +constexpr uint64_t ReplaceReadPos(uint64_t rw_positions, uint32_t read_pos) { + return PackRwPositions(WritePosOf(rw_positions), read_pos); +} -#ifndef SRC_PROTOZERO_FILTERING_MESSAGE_TOKENIZER_H_ -#define SRC_PROTOZERO_FILTERING_MESSAGE_TOKENIZER_H_ +constexpr uint32_t NumOutstandingPositions(uint32_t write_pos, + uint32_t read_pos) { + return write_pos - read_pos; +} -#include +// A physical chunk index. Variable names distinguish indices from positions: +// - *_idx selects a chunk in memory, from 0 to num_chunks - 1. +// Successive positions cycle through these indices, then return to zero. +// - *_pos identifies a reservation in logical order. +// It keeps advancing across traversals, past num_chunks. +// It rolls over from UINT32_MAX to zero. +// +// For a ring buffer with four chunks: +// +// chunk_pos: 0 1 2 3 4 5 6 7 8 +// chunk_idx: 0 1 2 3 0 1 2 3 0 +class ChunkIndex { + public: + // Maps a logical position to its physical chunk in a validated ring buffer. + // + // num_chunks = 2^k, so the low k bits of a position select the physical chunk + // and the remaining bits count completed traversals: + // + // bits 0..k-1 bits k..31 + // +----------------------------+----------------------------+ + // | physical chunk index | traversal number | + // +----------------------------+----------------------------+ + // k bits 32 - k bits + // + // For example, an eight-chunk ring buffer has three chunk-index bits. The low + // three bits select chunks 0 through 7. The remaining 29 bits count completed + // traversals. + static constexpr ChunkIndex FromPosition(uint32_t chunk_pos, + uint32_t num_chunks) { + return ChunkIndex{chunk_pos & (num_chunks - 1)}; + } -// gen_amalgamated expanded: #include "perfetto/base/compiler.h" -// gen_amalgamated expanded: #include "perfetto/base/logging.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + // Builds from an existing physical chunk index. + // Uses |chunk_idx| unchanged, without applying modulo num_chunks. + static constexpr ChunkIndex FromIndex(uint32_t chunk_idx) { + return ChunkIndex{chunk_idx}; + } -namespace protozero { + constexpr uint32_t value() const { return chunk_idx_; } -// A helper class for schema-less tokenizing of protobuf messages. -// This class takes a stream of proto-encoded bytes, pushed one by one in input -// via Push(octet), and returns a stream of tokens (each Push() call can return -// 0 or 1 token). -// A "token" contains metadata about a field, specifically: its ID, its wire -// type and: -// - For varint and fixed32/64 fields: its payload. -// - For string and bytes fields: the length of its payload. -// In this case the caller is supposed to "eat" those N bytes before calling -// Push() again. -// Note that this class cannot differentiate between a string/bytes field or -// a submessage, because they are encoded in the same way. The caller is -// supposed to know whether a field can be recursed into by just keep calling -// Push() or is a string that should be skipped. -// This is inline to allow the compiler to see through the Push method and -// avoid a function call for each byte. -class MessageTokenizer { - public: - struct Token { - uint32_t field_id; // 0 == not valid. - proto_utils::ProtoWireType type; + private: + explicit constexpr ChunkIndex(uint32_t chunk_idx) : chunk_idx_(chunk_idx) {} - // For kLengthDelimited, |value| represent the length of the payload. - uint64_t value; + uint32_t chunk_idx_; +}; - inline bool valid() const { return field_id != 0; } - bool operator==(const Token& o) const { - return field_id == o.field_id && type == o.type && value == o.value; - } - }; +// Chunk state word +// ---------------- +// +// Each chunk starts with a 32-bit atomic state word (std::atomic). +// +// There are five states: +// 1. kFree +// 2. kBeingWritten +// 3. kComplete +// 4. kRewriteRequested +// 5. kRewriteAcknowledged +// +// The low control byte (8 bits) determines how to interpret the upper 24 bits: +// - Free has 8 unused bits that must be zero, followed by wrap_count (16 bits). +// - BeingWritten, Complete and RewriteRequested carry num_fragments (8 bits) +// and WriterID (16 bits). +// - RewriteAcknowledged has no other fields so its upper bits are all zero. +// +// A Free word contains: +// +// +------------------+------------------+------------------+ +// | byte 0 | byte 1 | bytes 2-3 | +// +------------------+------------------+------------------+ +// | control = 0 | num_fragments = 0| wrap_count | +// | (Free, format 0, | | | +// | no flags) | | | +// +------------------+------------------+------------------+ +// +// On the first traversal, wrap_count is zero and every chunk's Free word is +// zero. A zero-filled ring buffer therefore starts with all chunks Free and +// read_pos == write_pos == 0. Later traversals use wrap_count << 16 as the +// Free word. +// +// BeingWritten, Complete and RewriteRequested contain: +// +// +------------------+------------------+------------------+ +// | byte 0 | byte 1 | bytes 2-3 | +// +------------------+------------------+------------------+ +// | control byte | num_fragments | WriterID | +// +------------------+------------------+------------------+ +// +// The control byte is: +// +// +---------+---------+---------+---------+---------+ +// |bits 0-2 |bits 3-4 | bit 5 | bit 6 | bit 7 | +// +---------+---------+---------+---------+---------+ +// | state | format | data |continues|continues| +// | | | loss | on next |from prev| +// +---------+---------+---------+---------+---------+ +// +// RewriteAcknowledged carries no other fields so every other bit is zero. + +enum class ChunkState : uint32_t { + // No writer owns this chunk: + // - A writer whose reserved position selects this chunk and has the same + // wrap count can change Free to BeingWritten before writing. + // - To consume an unclaimed reservation, the reader must first advance the + // wrap count atomically. The delayed writer's claim then fails. + kFree = 0, + + // One writer owns the chunk: + // - The first N = num_fragments fragments are published and can be read. + // - The writer may be appending fragment N + 1 after those published bytes. + // + // The writer publishes by changing BeingWritten to Complete. The reader + // can instead copy the first N fragments and request a rewrite, without + // waiting for the writer to finish. + kBeingWritten = 1, + + // The writer has published all num_fragments fragments and stopped writing. + // The reader and writer can now race to change the state: + // - The reader consumes the fragments and changes Complete to Free. + // - The same writer changes Complete back to BeingWritten to append more. + // If the reader wins, the writer drops its cached handle to the chunk. + kComplete = 2, + + // A partial chunk read won the race against the writer's publication: + // - The reader consumed N = num_fragments and can move on. + // - The writer still owns the chunk and may be writing fragment N + 1. + // + // The writer notices the request when it tries to publish. It must save + // any unpublished fragment before acknowledging. The reader cannot free + // the chunk until that acknowledgement. + kRewriteRequested = 3, + + // The writer notices RewriteRequested when it next tries to publish: + // - It saves any unpublished fragment in private memory. + // - It changes the old chunk to RewriteAcknowledged and stops touching it. + // + // Acknowledgement happens before waiting for a replacement chunk. + // Only the reader changes RewriteAcknowledged to Free, when it next visits + // this chunk on a later traversal. + kRewriteAcknowledged = 4, + + // A reader that does not know a state cannot tell who owns the chunk. It + // stops rather than reclaiming it. + kReserved5 = 5, + kReserved6 = 6, + kReserved7 = 7, +}; - // Pushes a byte in input and returns a token, only when getting to the last - // byte of each field. Specifically: - // - For varint and fixed32 fields, the Token is returned after the last byte - // of the numeric payload is pushed. - // - For length-delimited fields, this returns after the last byte of the - // length is pushed (i.e. right before the payload starts). The caller is - // expected to either skip the next |value| bytes (in the case of a string - // or bytes fields) or keep calling Push, in the case of a submessage. - inline Token Push(uint8_t octet) { - using protozero::proto_utils::ProtoWireType; +enum class ChunkFormat : uint32_t { + // Bytes 4..5 contain a little-endian target BufferID. Payload starts at 6. + kTargetBuffer = 0, - // Parsing a fixed32/64 field is the only case where we don't have to do - // any varint decoding. This is why this block is before the remaining - // switch statement below (all the rest is a varint). - if (PERFETTO_UNLIKELY(state_ == kFixedIntValue)) { - PERFETTO_DCHECK(fixed_int_bits_ == 32 || fixed_int_bits_ == 64); - fixed_int_value_ |= static_cast(octet) << fixed_int_shift_; - fixed_int_shift_ += 8; - if (fixed_int_shift_ < fixed_int_bits_) - return Token{}; // Intermediate byte of a fixed32/64. - auto wire_type = fixed_int_bits_ == 32 ? ProtoWireType::kFixed32 - : ProtoWireType::kFixed64; - uint64_t fixed_int_value = fixed_int_value_; - fixed_int_value_ = fixed_int_shift_ = fixed_int_bits_ = 0; - state_ = kFieldPreamble; - return Token{field_id_, wire_type, fixed_int_value}; - } + // Reserved for a format carrying per-packet routing information. + kReservedRouting = 1, + kReserved2 = 2, + kReserved3 = 3, +}; - // At this point either we are: (i) parsing a field preamble; (ii) parsing a - // varint field paylod; (iii) parsing the length of a length-delimited - // field. In all cases, we need to decode a varint before proceeding. - varint_ |= static_cast(octet & 0x7F) << varint_shift_; - if (octet & 0x80) { - varint_shift_ += 7; - if (PERFETTO_UNLIKELY(varint_shift_ >= 64)) { - varint_shift_ = 0; - state_ = kInvalidVarInt; - } - return Token{}; // Still parsing a varint. - } +// Field widths and positions in the 32-bit word. The low byte is the control +// byte, followed by the fragment count and WriterID. +constexpr uint32_t kPayloadFlagsBits = 3; +constexpr uint32_t kChunkFormatBits = 2; +constexpr uint32_t kChunkStateBits = 3; +constexpr uint32_t kNumFragmentsBits = 8; +constexpr uint32_t kWriterIDBits = 16; + +constexpr uint32_t kChunkStateShift = 0; +constexpr uint32_t kChunkFormatShift = kChunkStateShift + kChunkStateBits; +constexpr uint32_t kPayloadFlagsShift = kChunkFormatShift + kChunkFormatBits; +constexpr uint32_t kNumFragmentsShift = kPayloadFlagsShift + kPayloadFlagsBits; +constexpr uint32_t kWriterIDShift = kNumFragmentsShift + kNumFragmentsBits; + +constexpr uint32_t kChunkStateMask = (1u << kChunkStateBits) - 1; +constexpr uint32_t kChunkFormatMask = ((1u << kChunkFormatBits) - 1) + << kChunkFormatShift; +constexpr uint32_t kPayloadFlagsMask = ((1u << kPayloadFlagsBits) - 1) + << kPayloadFlagsShift; +constexpr uint32_t kNumFragmentsMask = ((1u << kNumFragmentsBits) - 1) + << kNumFragmentsShift; +constexpr uint32_t kWriterIDMask = ((1u << kWriterIDBits) - 1) + << kWriterIDShift; + +constexpr uint32_t kMaxFragmentsPerChunk = (1u << kNumFragmentsBits) - 1; + +// Free uses the WriterID field for the wrap count. Its other data bits must be +// zero. +constexpr uint32_t kWrapCountShift = kWriterIDShift; + +enum PayloadFlags : uint32_t { + // The writer lost data before or while filling this chunk. + // - The flag does not identify where data was lost within the chunk. + // - The reader discards all published fragments and reports loss. + // This includes complete, good packets before or after the gap. + // - A writer may keep appending. The flag stays set for that reservation. + // Fragments appended to this chunk are also discarded once published. + // This allows cached reuse after loss without forcing a new reservation. + // + // TODO(sashwinbalaji): Carry the cause of the loss. TBv2 reports this flag + // as DATA_LOSS_READ_GAP. v1 reports a full buffer as DATA_LOSS_SMB_FULL. + kFlagDataLoss = 1u << kPayloadFlagsShift, + + // The last fragment is not the end of its packet. The packet continues in + // this writer's next chunk. Only Complete may carry this flag, and the + // writer must not reuse a chunk carrying it. + kFlagContinuesOnNextChunk = 1u << (kPayloadFlagsShift + 1), + + // The first fragment contains the next part of a packet that started in this + // writer's previous chunk. + kFlagContinuesFromPrevChunk = 1u << (kPayloadFlagsShift + 2), +}; - uint64_t varint = varint_; - varint_ = 0; - varint_shift_ = 0; +// Chunk ownership and wrap identity +// --------------------------------- +// +// Only the reader writes Free. The writer publishes each closed fragment and +// may reuse its Complete chunk to append another. +// +// The reader can make progress even when a writer is descheduled: +// +// 1. The writer pauses before claiming the chunk. +// - The position is reserved. The chunk has not been claimed. +// - The reader atomically changes Free(wrap) to Free(next wrap). +// Only the wrap count changes. The state stays Free. +// - The reader advances read_pos without delivering fragments. +// - The chunk is ready for chunk_pos + num_chunks. That position's writer +// can claim it by changing the state to BeingWritten. +// - The original writer resumes with the old wrap count. Its claim fails +// without changing the chunk. It tries a new reservation. +// - If the writer claims first, the reader's update fails instead. +// The reader leaves read_pos unchanged and retries the position. +// +// 2. The writer pauses after claiming the chunk. +// - The reader copies the published fragments. +// - The reader changes BeingWritten to RewriteRequested, then advances +// read_pos. The writer still owns the chunk. +// - Later reservations cannot claim this chunk while it awaits +// acknowledgement. The reader advances past those reservations without +// changing the chunk's state word or delivering fragments. +// - The owning writer resumes and saves any unpublished fragment. +// Only that writer can change RewriteRequested to RewriteAcknowledged. +// - On a later traversal, the reader changes RewriteAcknowledged to +// Free(next wrap). It then advances read_pos without delivering fragments. +// - The chunk is now available for a subsequent reservation. +// +// An unclaimed reservation that the reader skips is called a hole. Skipping +// means advancing read_pos without delivering fragments for that reservation. +// It can also require a state word update, as in the Free and +// RewriteAcknowledged cases above. +// +// writer claims writer publishes +// Free(wrap) ------------> BeingWritten(N) -----------> Complete(M) +// | | | +// | reader | reader | reader +// v v v +// Free(next wrap) RewriteRequested(N) Free(next wrap) +// | +// | writer finishes with old chunk +// v +// RewriteAcknowledged +// | +// | reader, on a later traversal +// v +// Free(next wrap) +// +// N and M count published fragments. A claim starts at N = 0. Reuse takes +// Complete(M) back to BeingWritten(M). +// +// The writer's publication and the reader's rewrite request compare the entire +// BeingWritten word, including format, flags, num_fragments and WriterID. +// Only one CAS can succeed against that word. No second atomic is needed. +// If scraping wins, the writer relocates only the unpublished fragment after +// the N published fragments. +// +// A reservation allows one claim against Free(wrap_count(chunk_pos)). +// On failure, the writer must reserve a new position. The returned word can +// belong to another writer or a position beyond the one the reader consumed. +// A retry against that word can overwrite another reservation's chunk. +// +// Actor From Action To +// ------ --------------------- ----------------------- ------------------- +// writer Free(wrap) claim BeingWritten(0) +// writer Free(wrap) gone reserve a new position unchanged +// reader Free(wrap) consume unclaimed Free(next wrap) +// reader Free(other wrap) protocol error, stop unchanged +// writer BeingWritten(N) publish Complete(M) +// reader BeingWritten(N) read N fragments RewriteRequested(N) +// writer Complete(N) reuse BeingWritten(N) +// writer Complete gone drop cached handle unchanged +// reader Complete consume Free(next wrap) +// writer RewriteRequested copy fragment, release RewriteAcknowledged +// reader RewriteRequested advance read_pos unchanged +// reader RewriteAcknowledged reclaim Free(next wrap) +// reader reserved state 5..7 unknown owner, stop unchanged +// reader Free CAS lost retry immediately unchanged +// reader BeingWritten CAS lost discard copy, retry unchanged +// reader Complete CAS lost discard copy, retry unchanged +// reader acknowledgement lost protocol error, stop unchanged +// writer publication CAS lost handle rewrite or abort unchanged +// writer any other lost CAS bug, abort unchanged +// +// Lost-CAS rows describe a failed attempt. It does not change the shared word. +// The reader retries within Drain(), subject to its per-position attempt limit. +// A failed publication must find RewriteRequested(N), or the writer aborts. +// The reader also stops on reserved bits in Free or RewriteAcknowledged. +// +// Free stores the low 16 bits of the traversal number: +// +// wrap_count = uint16_t(chunk_pos / num_chunks) +// +// For the same chunk, that value repeats after: +// +// min(num_chunks * 65536, 2^32) reservations +// +// A writer delayed between reservation and claim for that long can match a +// later Free word. Its data is delivered at that later position, whose writer +// loses the claim. Chunk ownership holds, but reservation order is lost for +// the delayed writer. This is the limit of the 16-bit wrap count. +// +// Computes the wrap from a position. It does not inspect the chunk's state. +inline uint16_t WrapCountForPosition(uint32_t chunk_pos, uint32_t num_chunks) { + PERFETTO_DCHECK(base::IsPowerOfTwo(num_chunks)); + return static_cast(chunk_pos >> base::CountTrailZeros(num_chunks)); +} - switch (state_) { - case kFieldPreamble: { - auto field_type = static_cast(varint & 7u); // 7 = 0..0111 - field_id_ = static_cast(varint >> 3); +constexpr ChunkState ChunkStateOf(uint32_t state_word) { + return static_cast((state_word & kChunkStateMask) >> + kChunkStateShift); +} - // The field type is legit, now check it's well formed and within - // boundaries. - if (field_type == static_cast(ProtoWireType::kVarInt)) { - state_ = kVarIntValue; - } else if (field_type == - static_cast(ProtoWireType::kFixed32) || - field_type == - static_cast(ProtoWireType::kFixed64)) { - state_ = kFixedIntValue; - fixed_int_shift_ = 0; - fixed_int_value_ = 0; - fixed_int_bits_ = - field_type == static_cast(ProtoWireType::kFixed32) ? 32 - : 64; - } else if (field_type == - static_cast(ProtoWireType::kLengthDelimited)) { - state_ = kLenDelimited; - } else { - state_ = kInvalidFieldType; - } - return Token{}; - } +constexpr bool HasDataFields(ChunkState state) { + return state == ChunkState::kBeingWritten || state == ChunkState::kComplete || + state == ChunkState::kRewriteRequested; +} - case kVarIntValue: { - // Return the varint field payload and go back to the next field. - state_ = kFieldPreamble; - return Token{field_id_, ProtoWireType::kVarInt, varint}; - } +constexpr uint32_t MakeFreeStateWord(uint16_t wrap_count) { + return static_cast(wrap_count) << kWrapCountShift; +} - case kLenDelimited: { - const auto payload_len = varint; - if (payload_len > protozero::proto_utils::kMaxMessageLength) { - state_ = kMessageTooBig; - return Token{}; - } - state_ = kFieldPreamble; - // At this point the caller is expected to consume the next - // |payload_len| bytes. - return Token{field_id_, ProtoWireType::kLengthDelimited, payload_len}; - } +// The Free word a reservation at |chunk_pos| must find, and the word the +// reader leaves for the next traversal when called with chunk_pos + num_chunks. +inline uint32_t MakeFreeStateWordForPosition(uint32_t chunk_pos, + uint32_t num_chunks) { + return MakeFreeStateWord(WrapCountForPosition(chunk_pos, num_chunks)); +} - case kFixedIntValue: - // Unreachable because of the if before the switch. - PERFETTO_DCHECK(false); - break; +// These accessors apply to BeingWritten, Complete and RewriteRequested. +// PayloadFlagsOf() leaves the flags in their encoded bit positions, so its +// result can be passed to MakeDataStateWord(). +constexpr ChunkFormat ChunkFormatOf(uint32_t state_word) { + return static_cast((state_word & kChunkFormatMask) >> + kChunkFormatShift); +} - // Unrecoverable error states. - case kInvalidFieldType: - case kMessageTooBig: - case kInvalidVarInt: - break; - } // switch(state_) +constexpr uint32_t PayloadFlagsOf(uint32_t state_word) { + return state_word & kPayloadFlagsMask; +} + +constexpr uint32_t NumFragmentsOf(uint32_t state_word) { + return (state_word & kNumFragmentsMask) >> kNumFragmentsShift; +} + +constexpr WriterID WriterIDOf(uint32_t state_word) { + return static_cast((state_word & kWriterIDMask) >> kWriterIDShift); +} + +inline uint32_t MakeDataStateWord(ChunkState state, + ChunkFormat format, + uint32_t payload_flags, + uint32_t num_fragments, + WriterID writer_id) { + PERFETTO_DCHECK(HasDataFields(state)); + PERFETTO_DCHECK(static_cast(format) < (1u << kChunkFormatBits)); + PERFETTO_DCHECK((payload_flags & ~kPayloadFlagsMask) == 0); + PERFETTO_DCHECK(num_fragments <= kMaxFragmentsPerChunk); + return (static_cast(state) << kChunkStateShift) | + (static_cast(format) << kChunkFormatShift) | + (payload_flags & kPayloadFlagsMask) | + ((num_fragments << kNumFragmentsShift) & kNumFragmentsMask) | + (static_cast(writer_id) << kWriterIDShift); +} + +constexpr uint32_t kRewriteAcknowledgedStateWord = + static_cast(ChunkState::kRewriteAcknowledged) << kChunkStateShift; + +// Replaces only the state bits, preserving format, flags, count and WriterID. +// The reader uses this to request a rewrite without understanding the chunk +// format. The writer uses it to take a Complete chunk back to BeingWritten +// while the word keeps describing the fragments it already published. +constexpr uint32_t ReplaceChunkState(uint32_t state_word, ChunkState state) { + return (state_word & ~kChunkStateMask) | + (static_cast(state) << kChunkStateShift); +} + +// Target-buffer chunk format +// -------------------------- +// +// A data-bearing format-0 chunk begins with this six-byte header. The remaining +// chunk_size - 6 bytes hold payload and size entries: +// +// +---------+---------+-------------------+-------------------+ +// | byte 0 | byte 1 | bytes 2-3 | bytes 4-5 | +// +---------+---------+-------------------+-------------------+ +// | control | num | WriterID | target BufferID | +// | byte |fragments| | | +// +---------+---------+-------------------+-------------------+ +// \_____________ atomic state word _______/ +// +// The rest of a format-0 chunk is laid out as follows: +// +// low address high address +// 0 4 6 chunk_size +// +-----------------+----------+-----------+------+--------------+ +// | atomic state | BufferID | payloads | free | size varints | +// | word | | grow ---> | | <--- grow | +// +-----------------+----------+-----------+------+--------------+ +// ... N-1 1 0 +// +// Fragment 0's size is at the end of the chunk. num_fragments specifies the +// number of published payload fragments and size varints. +// +// Publication and access: +// - The writer fills each fragment and its size entry before the release +// transition from BeingWritten to Complete. +// - The reader acquire-loads the state word. It decodes and validates each size +// before it copies the payload. +// +// BufferID becomes visible with the first fragment publication. +// If num_fragments is zero, the reader must not load BufferID. +// +// If kFlagDataLoss is set, the reader discards the chunk's published fragments +// without access to their payload. - return Token{}; // Keep GCC happy. - } +constexpr uint32_t kTargetBufferIdOffset = 4; +constexpr uint32_t kTargetBufferPayloadOffset = 6; - // Returns true if the tokenizer FSM has reached quiescence (i.e. if we are - // NOT in the middle of parsing a field). - bool idle() const { - return state_ == kFieldPreamble && varint_shift_ == 0 && - fixed_int_shift_ == 0; - } +inline void StoreTargetBufferId(uint8_t* chunk, BufferID buffer_id) { + memcpy(&chunk[kTargetBufferIdOffset], &buffer_id, sizeof(buffer_id)); +} - // Only for reporting parser errors in the trace. - uint32_t state() const { return static_cast(state_); } +inline BufferID LoadTargetBufferId(const uint8_t* chunk) { + BufferID buffer_id; + memcpy(&buffer_id, &chunk[kTargetBufferIdOffset], sizeof(buffer_id)); + return buffer_id; +} - private: - enum State { - kFieldPreamble = 0, // Parsing the varint for the field preamble. - kVarIntValue = 1, // Parsing the payload of a varint field. - kFixedIntValue = 2, // Parsing the payload of a fixed32/64 field. - kLenDelimited = 3, // Parsing the length of a length-delimited field. +// Fragment size directory +// ----------------------- +// +// The fragment sizes are reversed varints at the end of the chunk. +// - Fragment 0's size ends at chunk_size. +// - Each later size is prepended at a lower address. +// +// low address high address +// +----------+----------+----------+----------+----------+ +// | size N-1 | ... | size 2 | size 1 | size 0 | +// +----------+----------+----------+----------+----------+ +// +// Within each size entry: +// - Each byte carries seven value bits and a continuation bit (0x80). +// - The least significant group is at the highest address. +// - The reader moves towards lower addresses until the continuation bit is +// clear. It does not read the next, unpublished entry. + +// Fragment sizes share Protozero's message-length limit: four varint bytes. +constexpr uint32_t kMaxFragmentSizeVarIntBytes = 4; + +// Returns the largest supported n with n + varint_size(n) <= available_bytes. +// Returns zero if no payload byte fits. +// |available_bytes| includes both the payload and its size entry. Each size +// byte carries seven bits, so the limits below include the corresponding +// number of size bytes. +inline uint32_t MaxFragmentSizeForAvailableBytes(uint32_t available_bytes) { + if (available_bytes <= 1) + return 0; - // Unrecoverable error states: - kInvalidFieldType = 4, // Encountered an invalid field type. - kMessageTooBig = 5, // Size of the length delimited message was too big. - kInvalidVarInt = 6, // Varint larger than 64 bits. - }; + // One size byte: (2^7 - 1) + 1 = 2^7 total. Subtract one size byte. + if (available_bytes <= (1u << 7)) + return available_bytes - 1; + // Two size bytes: (2^14 - 1) + 2 = 2^14 + 1 total. Subtract two. + if (available_bytes <= (1u << 14) + 1) + return available_bytes - 2; + // Three size bytes: (2^21 - 1) + 3 = 2^21 + 2 total. Subtract three. + if (available_bytes <= (1u << 21) + 2) + return available_bytes - 3; + return std::min( + available_bytes - 4, + static_cast(protozero::proto_utils::kMaxMessageLength)); +} + +inline uint32_t MaxFragmentSizeForEmptyChunk(uint32_t chunk_size) { + // Callers use a validated ring buffer, so a size below 256 is a caller error. + PERFETTO_CHECK(chunk_size >= kMinChunkSize); + const uint32_t available_bytes = chunk_size - kTargetBufferPayloadOffset; + return MaxFragmentSizeForAvailableBytes(available_bytes); +} + +// Writes the size into the directory immediately before |sizes_begin| and +// returns the new directory start. +// Requires varint_size(size) writable bytes before |sizes_begin|. +// |size| must be at most protozero::proto_utils::kMaxMessageLength. +inline uint8_t* WriteFragmentSizeReversed(uint8_t* sizes_begin, uint32_t size) { + PERFETTO_DCHECK(size <= protozero::proto_utils::kMaxMessageLength); + // TODO(sashwinbalaji): Add proto_utils::WriteVarIntReversed to write directly + // into the directory. This would avoid the temporary buffer and copy below. + uint8_t encoded[kMaxFragmentSizeVarIntBytes]; + const uint8_t* const encoded_end = + protozero::proto_utils::WriteVarInt(size, encoded); + const size_t encoded_size = static_cast(encoded_end - encoded); + // Put the first varint byte at the highest address: the reader starts + // there and reads towards lower addresses (see ReadFragmentSizeReversed()). + for (size_t i = 0; i < encoded_size; ++i) { + --sizes_begin; + *sizes_begin = encoded[i]; + } + return sizes_begin; +} + +// Decodes one reversed size varint, starting just below |*sizes_cursor|. +// +// For example, 300 is stored as 02 AC from low to high address. +// The reader visits AC first, then 02: +// +// ... | 02 | AC | <- chunk_size +// ^ ^ +// | first byte read: AC, continuation bit set +// second byte read: 02, no continuation bit, stop +// +// The reader validates the chunk in two steps: +// 1. Decode the sizes with |lower_bound| set to the payload start. +// This keeps reads out of the header. The payload end is not yet known. +// 2. Add up the decoded sizes. The payload must end at or before the directory +// start. Reject the chunk on overlap, without copying payload. +// +// Rejects truncated entries and entries needing more than four bytes. +// Four bytes limit the decoded size to Protozero's kMaxMessageLength. +// +// - Success returns the size, which may be zero. |*sizes_cursor| moves to the +// last byte read, just above the next entry. +// - Failure returns std::nullopt and leaves |*sizes_cursor| unchanged. +inline std::optional ReadFragmentSizeReversed( + const uint8_t* lower_bound, + const uint8_t** sizes_cursor) { + PERFETTO_DCHECK(lower_bound <= *sizes_cursor); + const uint8_t* cursor = *sizes_cursor; + uint32_t value = 0; + uint32_t num_bytes = 0; + // TODO(sashwinbalaji): Benchmark alternatives: + // - Increment a running shift by seven instead of multiplying each time. + // - Find the terminator first, then decode forwards with shift-and-or. + for (;;) { + if (cursor == lower_bound || num_bytes == kMaxFragmentSizeVarIntBytes) + return std::nullopt; + --cursor; + const uint8_t cur = *cursor; + // Reading down the directory yields the least significant group first. + const uint32_t data_bits = cur & 0x7f; + const uint32_t shift = 7 * num_bytes; + value |= data_bits << shift; + ++num_bytes; + if ((cur & 0x80) == 0) + break; + } - State state_ = kFieldPreamble; - uint32_t field_id_ = 0; - uint64_t varint_ = 0; - uint32_t varint_shift_ = 0; - uint32_t fixed_int_shift_ = 0; - uint32_t fixed_int_bits_ = 0; - uint64_t fixed_int_value_ = 0; -}; + *sizes_cursor = cursor; + return value; +} -} // namespace protozero +} // namespace perfetto::tracing_v2 -#endif // SRC_PROTOZERO_FILTERING_MESSAGE_TOKENIZER_H_ +#endif // SRC_TRACING_V2_SHARED_RING_BUFFER_ABI_H_ /* - * Copyright (C) 2021 The Android Open Source Project + * Copyright (C) 2026 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -58761,249 +64434,294 @@ class MessageTokenizer { * limitations under the License. */ -#ifndef SRC_PROTOZERO_FILTERING_MESSAGE_FILTER_H_ -#define SRC_PROTOZERO_FILTERING_MESSAGE_FILTER_H_ +#ifndef SRC_TRACING_V2_SHARED_RING_BUFFER_H_ +#define SRC_TRACING_V2_SHARED_RING_BUFFER_H_ +#include #include -#include -#include -#include +#include -// gen_amalgamated expanded: #include "src/protozero/filtering/filter_bytecode_parser.h" -// gen_amalgamated expanded: #include "src/protozero/filtering/message_tokenizer.h" -// gen_amalgamated expanded: #include "src/protozero/filtering/string_filter.h" +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/futex.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_abi.h" -namespace protozero { +namespace perfetto::tracing_v2 { -// A class to filter binary-encoded proto messages using an allow-list of field -// ids, also known as "filter bytecode". The filter determines which fields are -// allowed to be passed through in output and strips all the other fields. -// See go/trace-filtering for full design. -// This class takes in input: -// 1) The filter bytecode, loaded once via the LoadFilterBytecode() method. -// 2) A proto-encoded binary message. The message doesn't have to be contiguous, -// it can be passed as an array of arbitrarily chunked fragments. -// The FilterMessage*() method returns in output a proto message, stripping out -// all unknown fields. If the input is malformed (e.g., unknown proto field wire -// types, lengths out of bound) the whole filtering failed and the |error| flag -// of the FilteredMessage object is set to true. -// The filtering operation is based on rewriting a copy of the message into a -// self-allocated buffer, which is then returned in the output. The input buffer -// is NOT altered. -// Note also that the process of rewriting the protos gets rid of most redundant -// varint encoding (if present). So even if all fields are allow-listed, the -// output might NOT be bitwise identical to the input (but it will be -// semantically equivalent). -// Furthermore the enable_field_usage_tracking() method allows to keep track of -// a histogram of allowed / denied fields. It slows down filtering and is -// intended only on host tools. -class MessageFilter { - public: - class Config { - public: - // Loads filter bytecode. If a filter is already loaded, it is replaced. - // Optionally accepts an overlay (pass nullptr/0 if not needed). - // See FilterBytecodeParser::Load() for overlay format details. - bool LoadFilterBytecode(const void* filter_data, - size_t len, - const void* overlay_data = nullptr, - size_t overlay_len = 0); +namespace test { +class SharedRingBufferInternalsForTest; +} - bool SetFilterRoot(std::initializer_list field_ids); +// Provides the atomic operations on a shared ring buffer. +// +// Like SharedMemoryABI in v1, this class interprets memory from its owner. +// The owner must keep the region mapped until this view, its reader and its +// writers are destroyed. +// +// The ring buffer is lock-free, with multiple writers and a single reader: +// - Writers reserve positions concurrently. When the ring buffer is full, +// each writer applies its BufferExhaustedPolicy and records any data it +// drops. +// - The reader consumes positions in order and is the only actor that makes a +// chunk Free again. +// - All updates to rw_positions and the chunk state words go through this +// class. +// +// Chunk transitions use compare-and-exchange (CAS): +// - Each CAS compares the entire state word, including all fields. +// - For BeingWritten, Complete and RewriteRequested, those fields are format, +// flags, num_fragments and WriterID. Free contains the wrap count instead. +// - In transition comments, N and M are published fragment counts. +// +// TODO(sashwinbalaji): CAS operations currently use the default seq_cst order. +// Their implementation comments propose weaker orders for a later optimization +// pass. Audit the synchronization guarantees and measure the benefit before +// replacing seq_cst. +class SharedRingBuffer { + public: + // Attaches to a ring buffer at |start|. Its layout is: + // + // size = sizeof(RingBufferHeader) + num_chunks * chunk_size + // + // - sizeof(RingBufferHeader) is 64 bytes. |start| must be 64-byte aligned. + // - num_chunks must be a power of two, from 2 to 2^30. + // - |chunk_size| must be in [256 B, 64 KiB] and a multiple of four. + // It does not need to be a power of two. + // - |size| must match the equation exactly, with no trailing bytes. + // It does not need to be a power of two. + // + // A newly created ring buffer must be zero-filled. + SharedRingBuffer(uint8_t* start, size_t size, uint32_t chunk_size); + ~SharedRingBuffer() = default; - const FilterBytecodeParser& filter() const { return filter_; } - const StringFilter& string_filter() const { return string_filter_; } - StringFilter& string_filter() { return string_filter_; } - uint32_t root_msg_index() const { return root_msg_index_; } + SharedRingBuffer(const SharedRingBuffer&) = delete; + SharedRingBuffer& operator=(const SharedRingBuffer&) = delete; + SharedRingBuffer(SharedRingBuffer&&) = delete; + SharedRingBuffer& operator=(SharedRingBuffer&&) = delete; - private: - FilterBytecodeParser filter_; - StringFilter string_filter_; - uint32_t root_msg_index_ = 0; - }; + // Immutable for the life of the ring buffer. + uint32_t num_chunks() const { return num_chunks_; } + uint32_t chunk_size() const { return chunk_size_; } - MessageFilter(); - explicit MessageFilter(Config); - ~MessageFilter(); + uint8_t* chunk_at(ChunkIndex chunk_idx) { + PERFETTO_DCHECK(chunk_idx.value() < num_chunks_); + return start_ + sizeof(RingBufferHeader) + + static_cast(chunk_idx.value()) * chunk_size_; + } + const uint8_t* chunk_at(ChunkIndex chunk_idx) const { + PERFETTO_DCHECK(chunk_idx.value() < num_chunks_); + return start_ + sizeof(RingBufferHeader) + + static_cast(chunk_idx.value()) * chunk_size_; + } - struct InputSlice { - const void* data; - size_t len; + // Writer-side reservation. + // + // A writer reserves a position and acquires its physical chunk in separate + // operations: + // 1. TryReserveWritePos() advances write_pos. + // 2. TryAcquireChunkForWriting() changes Free(wrap_count(chunk_pos)) to + // BeingWritten. + // + // If the reader reaches the reservation before step 2, it must atomically + // advance the chunk's wrap count before it advances read_pos. + // The delayed writer's claim then fails because its expected wrap count no + // longer matches. This prevents publication at a consumed position. + + enum class ReserveResult { + kReserved, + // num_chunks positions are already outstanding. Nothing was reserved, + // so a stalling policy may wait and try again. + kFull, }; - struct FilteredMessage { - FilteredMessage(std::unique_ptr d, size_t s) - : data(std::move(d)), size(s) {} - std::unique_ptr data; - size_t size; // The used bytes in |data|. This is <= sizeof(data). - bool error = false; + struct Reservation { + ReserveResult result = ReserveResult::kFull; + // Valid only for kReserved. This is a position in the reservation order, + // not a physical chunk index. + uint32_t chunk_pos = 0; + // The read_pos sampled by the last reservation attempt. If the writer has + // to wait, the futex sleeps only while read_pos still has this value. + uint32_t read_pos_for_wait = 0; }; - // Loads the filter bytecode that will be used to filter any subsequent - // message. Must be called before the first call to FilterMessage*(). - // |filter_data| must point to a byte buffer for a proto-encoded ProtoFilter - // message (see proto_filter.proto). - // Optionally accepts an overlay (pass nullptr/0 if not needed). - bool LoadFilterBytecode(const void* filter_data, - size_t len, - const void* overlay_data = nullptr, - size_t overlay_len = 0) { - return config_.LoadFilterBytecode(filter_data, len, overlay_data, - overlay_len); - } - - // This affects the filter starting point of the subsequent FilterMessage*() - // calls. By default the filtering process starts from the message @ index 0, - // the root message passed to proto_filter when generating the bytecode - // (in typical tracing use-cases, this is perfetto.protos.Trace). However, the - // caller (TracingServiceImpl) might want to filter packets from the 2nd level - // (perfetto.protos.TracePacket) because the root level is prepended after - // the fact. This call allows to change the root message for the filter. - // The argument |field_ids| is an array of proto field ids and determines the - // path to the new root. For instance, in the case of [1,2,3] SetFilterRoot - // will identify the sub-message for the field "root.1.2.3" and use that. - // In order for this to succeed all the fields in the path must be allowed - // in the filter and must be a nested message type. - bool SetFilterRoot(std::initializer_list field_ids) { - return config_.SetFilterRoot(field_ids); - } - - // Takes an input message, fragmented in arbitrary slices, and returns a - // filtered message in output. - FilteredMessage FilterMessageFragments(const InputSlice*, size_t num_slices); - - // Helper for tests, where the input is a contiguous buffer. - FilteredMessage FilterMessage(const void* data, size_t len) { - InputSlice slice{data, len}; - return FilterMessageFragments(&slice, 1); - } + // Reserves the next position if the ring buffer has room. + // If another writer or the reader updates rw_positions first, it rechecks + // capacity with the updated positions before another reservation attempt. + Reservation TryReserveWritePos(); - // When enabled returns a map of "field path" to "usage counter". - // The key (std::string) is a binary buffer (i.e. NOT an ASCII/UTF-8 string) - // which contains a varint for each field. Consider the following: - // message Root { Sub1 f1 = 1; }; - // message Sub1 { Sub2 f2 = 7;} - // message Sub2 { string f3 = 5; } - // The field .f1.f2.f3 will be encoded as \x01\0x07\x05. - // The value is the number of times that field has been encountered. If the - // field is not allow-listed in the bytecode (the field is stripped in output) - // the count will be negative. - void enable_field_usage_tracking(bool x) { track_field_usage_ = x; } - const std::unordered_map& field_usage() const { - return field_usage_; - } + // Writer-side chunk transitions. - const Config& config() const { return config_; } - Config& config() { return config_; } + // Free(wrap_count(chunk_pos)) -> BeingWritten(0). + // |being_written_word| supplies this writer's WriterID, format and initial + // flags. Its fragment count must be zero because the chunk has no published + // payload for this reservation. + // + // On failure, reserve a later position. The reader can consume this position + // before the claim, or a writer from an earlier reservation can still own + // the chunk. A retry against the returned word can overwrite that writer's + // chunk or claim a position the reader already consumed. + bool TryAcquireChunkForWriting(uint32_t chunk_pos, + uint32_t being_written_word); + + // BeingWritten(N) -> Complete(M). |*expected| is the last BeingWritten word. + // + // On failure, |*expected| receives the reader's RewriteRequested(N) word, + // which must preserve the format, flags, fragment count and WriterID. + // Only the reader's rewrite request can change the word while this writer + // owns the chunk. The caller must relocate any unpublished fragment. + bool TryReleaseChunkAsComplete(ChunkIndex chunk_idx, + uint32_t complete_word, + uint32_t* expected); + + // Complete(N) -> BeingWritten(N), so the writer can append fragments to its + // cached chunk. |observed| is the Complete word this writer published. + // + // On failure, the reader reclaimed the chunk first. The writer must discard + // its cached handle and acquire another chunk. + bool TryReacquireChunkForWriting(ChunkIndex chunk_idx, uint32_t observed); - // Returns the helper class used to perform string filtering. - StringFilter& string_filter() { return config_.string_filter(); } + // RewriteRequested -> RewriteAcknowledged after the writer saves any + // unpublished fragment and stops access to the old chunk. + // + // On failure, report a protocol error. Only this writer can change + // RewriteRequested, so |observed| must still match the shared word. + bool TryAcknowledgeRewrite(ChunkIndex chunk_idx, uint32_t observed); + + // Reader side. + + // Returns the current chunk state word with acquire ordering. For a data + // state, the reader can access the published fragments and their sizes. + // BufferID is visible only when the published fragment count is nonzero. + uint32_t LoadChunkStateWordAcquire(ChunkIndex chunk_idx) const; + + // Returns the next logical position a writer can reserve. + // - This bounds the reservations the reader can consume. + // - It does not say which chunks have published fragments. + // The reader checks each chunk's state word for that. + // - An older position can shorten a drain pass. A later pass can consume + // the remaining reservations. + uint32_t LoadWritePosRelaxed() const; + + // Returns write_pos - read_pos from one relaxed load of both positions. + // - Includes chunks that writers have not published yet. + // - Includes positions reserved but left unclaimed when a chunk claim failed. + // They still count until the reader advances past them. + // + // Concurrent updates can make this snapshot out of date, but that only + // affects when a drain is requested. Space reservation and chunk access use + // separate checks. + uint32_t LoadNumOutstandingPositionsRelaxed() const; - private: - // This is called by FilterMessageFragments(). - // Inlining allows the compiler turn the per-byte call/return into a for loop, - // while, at the same time, keeping the code easy to read and reason about. - // It gives a 20-25% speedup (265ms vs 215ms for a 25MB trace). - void FilterOneByte(uint8_t octet) PERFETTO_ALWAYS_INLINE; + // BeingWritten(N) -> RewriteRequested(N), with all other fields unchanged. + // |*expected| must be the word the reader used to copy the fragments. + // + // On failure, the writer published first and |*expected| receives the current + // word. The reader must discard its copy and retry this position in Drain(). + bool TryRequestRewrite(ChunkIndex chunk_idx, uint32_t* expected); - // No-inline because this is a slowpath (only when usage tracking is enabled). - void IncrementCurrentFieldUsage(uint32_t field_id, - bool allowed) PERFETTO_NO_INLINE; + // The following transitions are the only ones that expose a chunk to the + // next pass around the ring buffer. The new wrap count comes from + // |chunk_pos|, not from the old state word. - // Gets into an error state which swallows all the input and emits no output. - void SetUnrecoverableErrorState(); + // Free(wrap_count(chunk_pos)) -> Free(next_wrap(chunk_pos)). + // Consumes an unclaimed position and prepares the chunk for + // chunk_pos + num_chunks. |*expected| must be this position's Free word. + // + // On failure, the delayed writer claimed the chunk first and |*expected| + // receives the current word. The reader must retry this position in Drain(). + bool TryMoveFreeChunkToNextWrap(uint32_t chunk_pos, uint32_t* expected); - // We keep track of the nest of messages in a stack. Each StackState - // object corresponds to a level of nesting in the proto message structure. - // Every time a new field of type len-delimited that has a corresponding - // sub-message in the bytecode is encountered, a new StackState is pushed in - // |stack_|. stack_[0] is a sentinel to prevent over-popping without adding - // extra branches in the fastpath. - // |stack_|. stack_[1] is the state of the root message. - struct StackState { - uint32_t in_bytes = 0; // Number of input bytes processed. + // Complete(N) -> Free(next_wrap(chunk_pos)). + // |*expected| must be the word the reader used to copy the fragments. + // + // On failure, the writer reused the chunk first and |*expected| receives the + // current word. The reader must discard its copy and retry this position in + // Drain(). If the chunk is now BeingWritten, that retry requests a rewrite. + bool TryReleaseCompleteChunkAsFree(uint32_t chunk_pos, uint32_t* expected); - // When |in_bytes| reaches this value, the current state should be popped. - // This is set when recursing into nested submessages. This is 0 only for - // stack_[0] (we don't know the size of the root message upfront). - uint32_t in_bytes_limit = 0; + // RewriteAcknowledged -> Free(next_wrap(chunk_pos)). + // + // On failure, |*observed| receives the unexpected word. This is a protocol + // error because only this reader can change an acknowledged chunk. + bool TryReleaseRewriteAcknowledgedChunkAsFree(uint32_t chunk_pos, + uint32_t* observed); - // This is set when a len-delimited message is encountered, either a string - // or a nested submessage that is NOT allow-listed in the bytecode. - // This causes input bytes to be consumed without being parsed from the - // input stream. If |passthrough_eaten_bytes| == true, they will be copied - // as-is in output (e.g. in the case of an allowed string/bytes field). - uint32_t eat_next_bytes = 0; + // Backpressure: the writer's path when the ring buffer is full. + // + // Writers wait on read_pos. The reader publishes a new value and wakes them. + // The waiter count only avoids an unnecessary wake syscall. Capacity is + // always decided from rw_positions. + + enum class WriterWaitResult { + // The writer must recheck capacity after a wake, timeout, interruption or + // spurious return. The writer's deadline determines when it stops retries. + kRetry, + // This build or kernel cannot provide the wait. Do not retry the syscall. + // The writer can sleep and retry acquisition instead. + kUnavailable, + }; - // Keeps tracks of the stream_writer output counter (out_.written()) then - // the StackState is pushed. This is used to work out, when popping, how - // many bytes have been written for the current submessage. - uint32_t out_bytes_written_at_start = 0; + // Whether WaitForReadPosChange() is implemented on this platform. + static constexpr bool SupportsWriterWait() { return PERFETTO_HAS_FUTEX(); } - uint32_t field_id = 0; // The proto field id for the current message. - uint32_t msg_index = 0; // The index of the message filter in the bytecode. + // Blocks until read_pos differs from |read_pos_for_wait| or |timeout_ms| + // elapses. |read_pos_for_wait| comes from the last Reservation, whether it + // reported kFull or a position whose claim failed. + WriterWaitResult WaitForReadPosChange(uint32_t read_pos_for_wait, + uint32_t timeout_ms); - // This is a pointer to the proto preamble for the current submessage - // (it's nullptr for stack_[0] and non-null elsewhere). This will be filled - // with the actual size of the message (out_.written() - - // |out_bytes_written_at_start|) when finishing (popping) the message. - // This must be filled using WriteRedundantVarint(). Note that the - // |size_field_len| is variable and depends on the actual length of the - // input message. If the output message has roughly the same size of the - // input message, the length will not be redundant. - // In other words: the length of the field is reserved when the submessage - // starts. At that point we know the upper-bound for the output message - // (a filtered submessage can be <= the original one, but not >). So we - // reserve as many bytes it takes to write the input length in varint. - // Then, when the message is finalized and we know the actual output size - // we backfill the field. - // Consider the example of a submessage where the input size = 130 (>127, - // 2 varint bytes) and the output is 120 bytes. The length will be 2 bytes - // wide even though could have been encoded with just one byte. - uint8_t* size_field = nullptr; - uint32_t size_field_len = 0; + // Publishes read_pos without overwriting a concurrent write_pos update, then + // wakes waiting writers. Called once per drain pass, so the shared read_pos + // can lag the reader's local value. The lag only under-reports free capacity. + void PublishReadPos(uint32_t read_pos); - // The pointer to the start of the string to update the string if it is - // filtered. - uint8_t* filter_string_ptr = nullptr; + private: + friend class test::SharedRingBufferInternalsForTest; - // The semantic type of the string field being filtered (0 = unspecified). - uint32_t filter_string_semantic_type = 0; + // The production entry points load the initial expected value themselves. + // Tests supply an older value to exercise the CAS retry path + // deterministically. + Reservation TryReserveWritePosFromSnapshot(uint64_t rw_positions); + void PublishReadPosFromSnapshot(uint64_t rw_positions, uint32_t read_pos); - // How |eat_next_bytes| should be handled. It seems that keeping this field - // at the end rather than next to |eat_next_bytes| makes the filter a little - // (but measurably) faster. (likely something related with struct layout vs - // cache sizes). - enum FilterAction { - kDrop, - kPassthrough, - kFilterString, - }; - FilterAction action = FilterAction::kDrop; - }; + // Shared-memory address and wrap-count helpers. - uint32_t out_written() { return static_cast(out_ - &out_buf_[0]); } + std::atomic* chunk_state_word_at(ChunkIndex chunk_idx) { + return reinterpret_cast*>(chunk_at(chunk_idx)); + } + const std::atomic* chunk_state_word_at(ChunkIndex chunk_idx) const { + return reinterpret_cast*>(chunk_at(chunk_idx)); + } - Config config_; + std::atomic* chunk_state_word_for_position(uint32_t chunk_pos) { + return chunk_state_word_at( + ChunkIndex::FromPosition(chunk_pos, num_chunks_)); + } - std::unique_ptr out_buf_; - uint8_t* out_ = nullptr; - uint8_t* out_end_ = nullptr; + // Returns the Free word for the next position that uses the same chunk. + uint32_t MakeFreeWordForNextWrap(uint32_t chunk_pos) const { + // Deriving the value from the next position also handles uint32_t rollover. + const uint32_t next_pos = chunk_pos + num_chunks_; + return MakeFreeStateWordForPosition(next_pos, num_chunks_); + } - MessageTokenizer tokenizer_; - std::vector stack_; + RingBufferHeader* header() { + return reinterpret_cast(start_); + } + const RingBufferHeader* header() const { + return reinterpret_cast(start_); + } - bool error_ = false; - bool track_field_usage_ = false; - std::unordered_map field_usage_; + uint8_t* const start_; + const uint32_t num_chunks_; + const uint32_t chunk_size_; }; -} // namespace protozero +} // namespace perfetto::tracing_v2 -#endif // SRC_PROTOZERO_FILTERING_MESSAGE_FILTER_H_ +#endif // SRC_TRACING_V2_SHARED_RING_BUFFER_H_ /* - * Copyright (C) 2021 The Android Open Source Project + * Copyright (C) 2026 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -59018,325 +64736,353 @@ class MessageFilter { * limitations under the License. */ -// gen_amalgamated expanded: #include "src/protozero/filtering/message_filter.h" - -// gen_amalgamated expanded: #include "perfetto/base/logging.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" -// gen_amalgamated expanded: #include "src/protozero/filtering/string_filter.h" - -namespace protozero { - -namespace { - -// Inline helpers to append proto fields in output. They are the equivalent of -// the protozero::Message::AppendXXX() fields but don't require building and -// maintaining a full protozero::Message object or dealing with scattered -// output slices. -// All these functions assume there is enough space in the output buffer, which -// should be always the case assuming that we don't end up generating more -// output than input. - -inline void AppendVarInt(uint32_t field_id, uint64_t value, uint8_t** out) { - *out = proto_utils::WriteVarInt(proto_utils::MakeTagVarInt(field_id), *out); - *out = proto_utils::WriteVarInt(value, *out); -} - -// For fixed32 / fixed64. -template -inline void AppendFixed(uint32_t field_id, INT_T value, uint8_t** out) { - *out = proto_utils::WriteVarInt(proto_utils::MakeTagFixed(field_id), - *out); - memcpy(*out, &value, sizeof(value)); - *out += sizeof(value); -} - -// For length-delimited (string, bytes) fields. Note: this function appends only -// the proto preamble and the varint field that states the length of the payload -// not the payload itself. -// In the case of submessages, the caller needs to re-write the length at the -// end in the in the returned memory area. -// The problem here is that, because of filtering, the length of a submessage -// might be < original length (the original length is still an upper-bound). -// Returns a pair with: (1) the pointer where the final length should be written -// into, (2) the length of the size field. -// The caller must write a redundant varint to match the original size (i.e. -// needs to use WriteRedundantVarInt()). -inline std::pair AppendLenDelim(uint32_t field_id, - uint32_t len, - uint8_t** out) { - *out = proto_utils::WriteVarInt(proto_utils::MakeTagLengthDelimited(field_id), - *out); - uint8_t* size_field_start = *out; - *out = proto_utils::WriteVarInt(len, *out); - const size_t size_field_len = static_cast(*out - size_field_start); - return std::make_pair(size_field_start, size_field_len); -} -} // namespace - -MessageFilter::MessageFilter(Config config) : config_(std::move(config)) { - // Push a state on the stack for the implicit root message. - stack_.emplace_back(); -} +#ifndef SRC_TRACING_V2_PRODUCER_RING_BUFFER_ARBITER_H_ +#define SRC_TRACING_V2_PRODUCER_RING_BUFFER_ARBITER_H_ -MessageFilter::MessageFilter() : MessageFilter(Config()) {} +#include +#include -MessageFilter::~MessageFilter() = default; +#include +#include +#include -bool MessageFilter::Config::LoadFilterBytecode(const void* filter_data, - size_t len, - const void* overlay_data, - size_t overlay_len) { - return filter_.Load(filter_data, len, overlay_data, overlay_len); -} +// gen_amalgamated expanded: #include "perfetto/ext/base/status_or.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h" +// gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h" +// gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer.h" -bool MessageFilter::Config::SetFilterRoot( - std::initializer_list field_ids) { - uint32_t root_msg_idx = 0; - for (uint32_t field_id : field_ids) { - auto res = filter_.Query(root_msg_idx, field_id); - if (!res.allowed || !res.nested_msg_field()) - return false; - root_msg_idx = res.nested_msg_index; - } - root_msg_index_ = root_msg_idx; - return true; -} +namespace perfetto { -MessageFilter::FilteredMessage MessageFilter::FilterMessageFragments( - const InputSlice* slices, - size_t num_slices) { - // First compute the upper bound for the output. The filtered message cannot - // be > the original message. - uint32_t total_len = 0; - for (size_t i = 0; i < num_slices; ++i) - total_len += slices[i].len; - out_buf_.reset(new uint8_t[total_len]); - out_ = out_buf_.get(); - out_end_ = out_ + total_len; +namespace base { +class TaskRunner; +} // namespace base - // Reset the parser state. - tokenizer_ = MessageTokenizer(); - error_ = false; - stack_.clear(); - stack_.resize(2); - // stack_[0] is a sentinel and should never be hit in nominal cases. If we - // end up there we will just keep consuming the input stream and detecting - // at the end, without hurting the fastpath. - stack_[0].in_bytes_limit = UINT32_MAX; - stack_[0].eat_next_bytes = UINT32_MAX; - // stack_[1] is the actual root message. - stack_[1].in_bytes_limit = total_len; - stack_[1].msg_index = config_.root_msg_index(); +class ProducerEndpoint; +class SharedMemory; +class SharedMemoryArbiter; +class TraceWriter; - // Process the input data and write the output. - for (size_t slice_idx = 0; slice_idx < num_slices; ++slice_idx) { - const InputSlice& slice = slices[slice_idx]; - const uint8_t* data = static_cast(slice.data); - for (size_t i = 0; i < slice.len; ++i) - FilterOneByte(data[i]); - } +namespace tracing_v2 { - // Construct the output object. - PERFETTO_CHECK(out_ >= out_buf_.get() && out_ <= out_end_); - auto used_size = static_cast(out_ - out_buf_.get()); - FilteredMessage res{std::move(out_buf_), used_size}; - res.error = error_; - if (stack_.size() != 1 || !tokenizer_.idle() || - stack_[0].in_bytes != total_len) { - res.error = true; - } - return res; -} +namespace test { +class ProducerRingBufferArbiterTestPeer; +} // namespace test -void MessageFilter::FilterOneByte(uint8_t octet) { - PERFETTO_DCHECK(!stack_.empty()); +// The producer side of one tracing v2 ring buffer. +// +// The producer's ProducerEndpoint (for example ProducerIPCClientImpl) creates +// one arbiter for each ring buffer that it shares with the service. In this +// file: +// - "endpoint" means that ProducerEndpoint. +// - "SMB arbiter" means the SharedMemoryArbiter used for v1 tracing. +// - "writer" means TraceWriterV2Impl. +// +// This class: +// - Keeps the ring buffer mapping alive and owns the SharedRingBuffer view. +// - Creates writers. Their WriterIDs come from the SMB arbiter, because v1 +// and v2 writers of one producer share one ID pool. +// - Tracks the service reader. See ReaderState. +// - Delivers drain requests to the endpoint thread, which sends +// DrainV2RingBuffer to the service. See DrainUrgency. +// - Runs each Flush() callback after its drain request. +// +// Threads: +// - Writers call ring_buffer(), RequestDrain(), IsReaderAttached(), Flush() +// and OnWriterDestroyed() from any thread. CreateTraceWriter() can also run +// on any thread. +// - Creation, state changes, posted tasks, flush callbacks and service +// requests run on the endpoint thread. +// +// The caller selects v2, then calls InitializeV2RingBuffer() on the endpoint +// thread before it lets writers use the ring buffer. +// Time goes down. +// "--->" is a direct call, and "===>" is an IPC message. +// +// endpoint this class service +// | | | +// | Create() | | +// |-------------------------->| kPending | +// |== AttachV2RingBuffer, with the memfd ================>| maps, checks, +// |<== reply =============================================| attaches +// | OnReaderAttachReply() | | +// |-------------------------->| kAttached, or | +// | | kDetached if rejected | +// +// - Later instances reuse the ring buffer. +// - If Create() fails, the endpoint has no arbiter and returns +// NullTraceWriters for v2 requests. +// +// Flush(callback) posts its own drain task, then the callback. Time goes +// down. "===>" is a posted task, or an IPC request to the service. +// +// writer thread endpoint thread service +// | | | +// | Flush(callback) | | +// |==== drain task ======>| | +// |==== callback ========>| | +// | |== DrainV2RingBuffer =>| copies chunks +// | | callback() | +// +// A message that the callback sends reaches the service after the drain +// request. The service handles them in order. +// +// Ownership: +// +// - "owns": the owner destroys it, as a member or through a unique_ptr. +// - "shares": a shared_ptr keeps it alive while any owner holds it. +// - "uses": a raw pointer. The object must outlive the user. +// - "holds": an allocated ID. The holder must release it. +// +// endpoint (for example ProducerIPCClientImpl) +// |-- owns --> SharedMemoryArbiterImpl: the WriterID pool +// |-- owns --> ProducerRingBufferArbiter (this class) +// |-- shares-> SharedMemory: the ring buffer mapping +// |-- owns --> SharedRingBuffer: the view +// |-- uses --> endpoint, SharedMemoryArbiterImpl +// +// data source (SDK) +// |-- owns --> TraceWriterV2Impl +// |-- uses --> ProducerRingBufferArbiter +// |-- holds -> a WriterID from SharedMemoryArbiterImpl +// |-- owns --> SharedRingBufferWriter +// |-- uses --> SharedRingBuffer +// +// Writers use raw pointers into objects that the endpoint owns. The WriterID +// keeps these pointers valid: +// - While a writer holds a WriterID, TryShutdown() of the SMB arbiter fails. +// - So the endpoint keeps the SMB arbiter, this object and the mapping. +// - The writer releases its WriterID last, in OnWriterDestroyed(). +class ProducerRingBufferArbiter { + public: + // Whether writers can rely on a service reader to free space. + // - Only the endpoint thread changes the state, but writers can read it + // from any thread. + // - This class sends drain requests in every state. The service handles + // attach and drain requests in order. It ignores a drain for a ring + // buffer that it did not accept. + // + // Create() OnReaderAttachReply(true) + // ----------> [ kPending ] --------------------------> [ kAttached ] + // | | + // +-------------------+--------------------+ + // | Disconnect() or + // | OnReaderAttachReply(false) + // v + // [ kDetached ] + // (terminal) + enum class ReaderState { + // The endpoint has not received an attach reply yet. + // - Writers can already publish. + // - The service can still reject the ring buffer. + // - A writer does not wait for space in a full ring buffer. It drops the + // packet instead, also under kStall. + kPending, + + // The service accepted the ring buffer. Its reader drains it. + // - A writer can wait for space in a full ring buffer. + kAttached, + + // Terminal. No reader now or later. Disconnect() enters it after + // rejection, disconnect or destruction of this class. + // - New writers are NullTraceWriters. + // - Existing writers keep the mapping. They drop packets when the ring + // buffer is full. + kDetached, + }; - auto* state = &stack_.back(); - StackState next_state{}; - bool push_next_state = false; + // How soon RequestDrain() must send the drain request. + // + // Only the endpoint thread sends requests. Normally RequestDrain() posts a + // task there, and all requests made before the task runs share it. This + // saves IPC traffic. But if the caller is on the endpoint thread and blocks + // it right after RequestDrain(), the task cannot run until the caller + // unblocks, and the caller waits for that drain. The urgency tells + // RequestDrain() whether the request can wait for a task. + // + // It changes only when the request is sent. The service handles every + // request the same way, and RequestDrain() never waits for the drain. + enum class DrainUrgency { + // Set it when the caller does not block after RequestDrain(). + // A task on the endpoint thread sends the request. Requests made before + // that task runs share it, so a burst of calls costs one request. + kRoutine, + + // Set it when the caller blocks right after RequestDrain(), until the + // service reads the ring buffer. + // - On the endpoint thread, sends the request at once, before + // RequestDrain() returns. + // - On other threads, the same as kRoutine. The endpoint thread is free + // to run the task. + kUrgent, + }; - if (state->eat_next_bytes > 0) { - // This is the case where the previous tokenizer_.Push() call returned a - // length delimited message which is NOT a submessage (a string or a bytes - // field). We just want to consume it, and pass it through/filter strings - // if the field was allowed. - --state->eat_next_bytes; - if (state->action == StackState::kPassthrough) { - *(out_++) = octet; - } else if (state->action == StackState::kFilterString) { - *(out_++) = octet; - if (state->eat_next_bytes == 0) { - config_.string_filter().MaybeFilter( - reinterpret_cast(state->filter_string_ptr), - static_cast(out_ - state->filter_string_ptr), - state->filter_string_semantic_type); - } - } - } else { - MessageTokenizer::Token token = tokenizer_.Push(octet); - // |token| will not be valid() in most cases and this is WAI. When pushing - // a varint field, only the last byte yields a token, all the other bytes - // return an invalid token, they just update the internal tokenizer state. - if (token.valid()) { - auto filter = config_.filter().Query(state->msg_index, token.field_id); - switch (token.type) { - case proto_utils::ProtoWireType::kVarInt: - if (filter.allowed && filter.simple_field()) - AppendVarInt(token.field_id, token.value, &out_); - break; - case proto_utils::ProtoWireType::kFixed32: - if (filter.allowed && filter.simple_field()) - AppendFixed(token.field_id, static_cast(token.value), - &out_); - break; - case proto_utils::ProtoWireType::kFixed64: - if (filter.allowed && filter.simple_field()) - AppendFixed(token.field_id, static_cast(token.value), - &out_); - break; - case proto_utils::ProtoWireType::kLengthDelimited: - // Here we have two cases: - // A. A simple string/bytes field: we just want to consume the next - // bytes (the string payload), optionally passing them through in - // output if the field is allowed. - // B. This is a nested submessage. In this case we want to recurse and - // push a new state on the stack. - // Note that we can't tell the difference between a - // "non-allowed string" and a "non-allowed submessage". But it doesn't - // matter because in both cases we just want to skip the next N bytes. - const auto submessage_len = static_cast(token.value); - auto in_bytes_left = state->in_bytes_limit - state->in_bytes - 1; - if (PERFETTO_UNLIKELY(submessage_len > in_bytes_left)) { - // This is a malicious / malformed string/bytes/submessage that - // claims to be larger than the outer message that contains it. - return SetUnrecoverableErrorState(); - } + // Allocates the shared memory for a ring buffer of |size| bytes, header + // included, or returns an error status on failure. + using AllocateSharedMemoryFn = + base::StatusOr> (*)(size_t size); + + // Sizes and allocates a ring buffer from |config|, then creates its arbiter + // in kPending. + // - The chunk size and the drain occupancy threshold come from |config|. + // - |task_runner| and |endpoint| must outlive the arbiter. + // - |allocate_shared_memory| must return a mapping of the size it is given. + // - Returns an error status if sizing or allocation fails. + // - The endpoint then attaches memory() to the service, and passes the reply + // to OnReaderAttachReply(). + static base::StatusOr> Create( + base::TaskRunner* task_runner, + ProducerEndpoint* endpoint, + const DataSourceConfig& config, + size_t shmem_size_hint_bytes, + AllocateSharedMemoryFn allocate_shared_memory); + + // The endpoint destroys this on its thread after all writers release their + // IDs. Calls Disconnect(). + ~ProducerRingBufferArbiter(); + + // Writers keep a pointer to this object. + ProducerRingBufferArbiter(const ProducerRingBufferArbiter&) = delete; + ProducerRingBufferArbiter& operator=(const ProducerRingBufferArbiter&) = + delete; - if (filter.allowed && filter.nested_msg_field() && - submessage_len > 0) { - // submessage_len == 0 is the edge case of a message with a 0-len - // (but present) submessage. In this case, if allowed, we don't want - // to push any further state (doing so would desync the FSM) but we - // still want to emit it. - // At this point |submessage_len| is only an upper bound. The - // final message written in output can be <= the one in input, - // only some of its fields might be allowed (also remember that - // this class implicitly removes redundancy varint encoding of - // len-delimited field lengths). The final length varint (the - // return value of AppendLenDelim()) will be filled when popping - // from |stack_|. - auto size_field = - AppendLenDelim(token.field_id, submessage_len, &out_); - push_next_state = true; - next_state.field_id = token.field_id; - next_state.msg_index = filter.nested_msg_index; - next_state.in_bytes_limit = submessage_len; - next_state.size_field = size_field.first; - next_state.size_field_len = size_field.second; - next_state.out_bytes_written_at_start = out_written(); - } else { - // A string or bytes field, or a 0 length submessage. - state->eat_next_bytes = submessage_len; - if (filter.allowed && filter.filter_string_field()) { - state->action = StackState::kFilterString; - AppendLenDelim(token.field_id, submessage_len, &out_); - state->filter_string_ptr = out_; - state->filter_string_semantic_type = filter.semantic_type; - } else if (filter.allowed) { - state->action = StackState::kPassthrough; - AppendLenDelim(token.field_id, submessage_len, &out_); - } else { - state->action = StackState::kDrop; - } - } - break; - } // switch(type) + // The mapping that holds the ring buffer, which the endpoint attaches to the + // service. + // Fixed for the life of this object. + const std::shared_ptr& memory() const { return memory_; } - if (PERFETTO_UNLIKELY(track_field_usage_)) { - IncrementCurrentFieldUsage(token.field_id, filter.allowed); - } - } // if (token.valid) - } // if (eat_next_bytes == 0) + // Reader state: - ++state->in_bytes; - while (state->in_bytes >= state->in_bytes_limit) { - PERFETTO_DCHECK(state->in_bytes == state->in_bytes_limit); - push_next_state = false; + // Called by the endpoint with the attach reply, on the endpoint thread. + // Enters kAttached on acceptance or kDetached on rejection. Does nothing + // after Disconnect(), because the reply can arrive after it. + void OnReaderAttachReply(bool reader_attached); - // We can't possibly write more than we read. - const uint32_t msg_bytes_written = static_cast( - out_written() - state->out_bytes_written_at_start); - PERFETTO_DCHECK(msg_bytes_written <= state->in_bytes_limit); + // True in kAttached only. If false, nothing frees space in a full ring + // buffer. Writers call it on their own thread. + bool IsReaderAttached() const; - // Backfill the length field of the - proto_utils::WriteRedundantVarInt(msg_bytes_written, state->size_field, - state->size_field_len); + // Enters kDetached after rejection or disconnect, on the endpoint thread. + // Repeated calls are safe. + void Disconnect(); - const uint32_t in_bytes_processes_for_last_msg = state->in_bytes; - stack_.pop_back(); - PERFETTO_CHECK(!stack_.empty()); - state = &stack_.back(); - state->in_bytes += in_bytes_processes_for_last_msg; - if (PERFETTO_UNLIKELY(!tokenizer_.idle())) { - // If we hit this case, it means that we got to the end of a submessage - // while decoding a field. We can't recover from this and we don't want to - // propagate a broken sub-message. - return SetUnrecoverableErrorState(); - } + // Writers: + + // Creates a writer for |target_buffer|, on any thread. The caller owns the + // writer. + // + // Never returns null. Returns a NullTraceWriter, which discards all + // packets, if: + // - the state is kDetached, or + // - the SMB arbiter has no free WriterID (exhaustion or shutdown). + std::unique_ptr CreateTraceWriter(BufferID target_buffer, + BufferExhaustedPolicy); + + // The writer calls this on its thread after its final publication. + // - Releases its WriterID in the SMB arbiter. + // - The release can let the endpoint destroy this object. So the call must + // be the writer's last access to it. + void OnWriterDestroyed(WriterID); + + // The view that writers borrow. Fixed for the life of this object. + SharedRingBuffer* ring_buffer() { return &ring_buffer_; } + + uint32_t drain_occupancy_threshold() const { + return drain_occupancy_threshold_; } - if (push_next_state) { - PERFETTO_DCHECK(tokenizer_.idle()); - stack_.emplace_back(std::move(next_state)); - state = &stack_.back(); + // Drain requests, from writers on their own thread: + + // Asks the service to read the ring buffer. See DrainUrgency. + void RequestDrain(DrainUrgency); + + // Requests a drain after the writer publishes its data. Then runs |callback| + // on the endpoint thread. See the class comment for the order. + // - Does not wait for a service ack. + // - If the endpoint destroys this object before the drain task runs, the + // task sends nothing. The endpoint thread still runs |callback|. + void Flush(std::function); + + // The returned pointer can only be dereferenced on the endpoint thread. + base::WeakPtr GetWeakPtr() const { + return weak_factory_.GetWeakPtr(); } -} -void MessageFilter::SetUnrecoverableErrorState() { - error_ = true; - stack_.clear(); - stack_.resize(1); - auto& state = stack_[0]; - state.eat_next_bytes = UINT32_MAX; - state.in_bytes_limit = UINT32_MAX; - state.action = StackState::kDrop; - out_ = out_buf_.get(); // Reset the write pointer. -} + private: + friend class test::ProducerRingBufferArbiterTestPeer; + + // Only Create() calls this. + // |memory| must be non-null and satisfy NumChunksForRingBufferLayout(). + // |drain_occupancy_threshold| is the number of outstanding positions at + // which a publication requests a drain, from 1 to the ring's chunk count. + ProducerRingBufferArbiter(base::TaskRunner* task_runner, + ProducerEndpoint* endpoint, + std::shared_ptr memory, + uint32_t chunk_size, + uint32_t drain_occupancy_threshold); + + // Runs on the endpoint thread. CHECKs that the transition is valid. + void SetReaderState(ReaderState); + + // Posts a drain task to the endpoint thread. Callable from any thread. + // - Without |force|, requests share a pending task. + // - |force| posts a new task so Flush() can place its callback after it. + // - The task clears |drain_task_pending_|, then sends DrainV2RingBuffer. + void PostDrainTask(bool force); + + // --- Borrowed. They must outlive this object. --- + + // Runs tasks on the endpoint thread. Writers post drain and flush + // requests here. + base::TaskRunner* const task_runner_; + // Sends drain requests to the service, on the endpoint thread only. + ProducerEndpoint* const endpoint_; + // The SMB arbiter. Any thread allocates and releases WriterIDs here. + SharedMemoryArbiter* const shared_memory_arbiter_; -void MessageFilter::IncrementCurrentFieldUsage(uint32_t field_id, - bool allowed) { - // Slowpath. Used mainly in offline tools and tests to workout used fields in - // a proto. - PERFETTO_DCHECK(track_field_usage_); + // --- Ring buffer mapping and view. Fixed after construction. --- - // Field path contains a concatenation of varints, one for each nesting level. - // e.g. y in message Root { Sub x = 2; }; message Sub { SubSub y = 7; } - // is encoded as [varint(2) + varint(7)]. - // We use varint to take the most out of SSO (small string opt). In most cases - // the path will fit in the on-stack 22 bytes, requiring no heap. - std::string field_path; + // The shared memory that holds the ring buffer. Declared before + // |ring_buffer_|, which points into it. + // + // Mapping ownership depends on the transport: + // - In-process, producer and service share this pointer. The mapping stays + // alive until both release it. + // - Over IPC, the service maps the fd separately and owns that mapping. + const std::shared_ptr memory_; + // The view that writers borrow. + SharedRingBuffer ring_buffer_; + // A publication asks for a drain when the ring buffer has at least this many + // outstanding positions. + // - The count covers the positions of all writers. + // - It includes reservations whose chunks are not published yet. + // - Fixed at construction and shared by all writers. + const uint32_t drain_occupancy_threshold_; + + // --- Shared with writer threads. --- + + // Writers read it from any thread. Only SetReaderState() writes it. + std::atomic reader_state_{ReaderState::kPending}; + // Nonzero while a shared drain task is pending. A request without |force| + // sets it before it posts that task. The task clears it before it sends + // DrainV2RingBuffer. + std::atomic drain_task_pending_{0}; - auto append_field_id = [&field_path](uint32_t id) { - uint8_t buf[10]; - uint8_t* end = proto_utils::WriteVarInt(id, buf); - field_path.append(reinterpret_cast(buf), - static_cast(end - buf)); - }; + PERFETTO_THREAD_CHECKER(thread_checker_) - // Append all the ancestors IDs from the state stack. - // The first entry of the stack has always ID 0 and we skip it (we don't know - // the ID of the root message itself). - PERFETTO_DCHECK(stack_.size() >= 2 && stack_[1].field_id == 0); - for (size_t i = 2; i < stack_.size(); ++i) - append_field_id(stack_[i].field_id); - // Append the id of the field in the current message. - append_field_id(field_id); - field_usage_[field_path] += allowed ? 1 : -1; -} + // Any thread can call GetWeakPtr(). Only the endpoint thread dereferences + // the weak pointers. + base::WeakPtrFactory weak_factory_{this}; +}; -} // namespace protozero -// gen_amalgamated begin source: src/protozero/filtering/message_filter_config.cc -// gen_amalgamated begin header: src/protozero/filtering/message_filter_config.h +} // namespace tracing_v2 +} // namespace perfetto + +#endif // SRC_TRACING_V2_PRODUCER_RING_BUFFER_ARBITER_H_ +// gen_amalgamated begin header: src/tracing/v2/trace_writer_v2_impl.h +// gen_amalgamated begin header: src/tracing/v2/shared_ring_buffer_writer.h /* * Copyright (C) 2026 The Android Open Source Project * @@ -59353,28 +65099,347 @@ void MessageFilter::IncrementCurrentFieldUsage(uint32_t field_id, * limitations under the License. */ -#ifndef SRC_PROTOZERO_FILTERING_MESSAGE_FILTER_CONFIG_H_ -#define SRC_PROTOZERO_FILTERING_MESSAGE_FILTER_CONFIG_H_ +#ifndef SRC_TRACING_V2_SHARED_RING_BUFFER_WRITER_H_ +#define SRC_TRACING_V2_SHARED_RING_BUFFER_WRITER_H_ -// gen_amalgamated expanded: #include "perfetto/base/status.h" -// gen_amalgamated expanded: #include "protos/perfetto/config/trace_config.gen.h" -// gen_amalgamated expanded: #include "src/protozero/filtering/message_filter.h" +#include -namespace protozero { +#include +#include +#include -// Loads a MessageFilter from the trace_filter field of a TraceConfig. -// This sets up the string filter rules (both base and v54 chains) and loads -// the bytecode (v1/v2 + v54 overlay). -// On failure, returns a non-ok status with a descriptive error message. -// On success, the caller may optionally call SetFilterRoot() to adjust the -// root message (e.g. for per-packet filtering in the tracing service). -perfetto::base::Status LoadMessageFilterConfig( - const perfetto::protos::gen::TraceConfig::TraceFilter& filt, - MessageFilter* filter); +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_abi.h" -} // namespace protozero +namespace perfetto::tracing_v2 { -#endif // SRC_PROTOZERO_FILTERING_MESSAGE_FILTER_CONFIG_H_ +// Writes the packet fragments produced by one TraceWriter into a +// SharedRingBuffer. +// +// - A fragment is one packet, or part of a packet that crosses a chunk +// boundary. A chunk can hold several fragments. The writer handles their +// byte ranges and sizes without interpreting their contents. +// - Use each instance from one thread at a time. Several instances can write +// to the same ring buffer concurrently. +// - Keep the ring buffer's memory and SharedRingBuffer view alive until +// every writer is destroyed. The destructor still publishes its chunk. +// - The writer gets a chunk in two steps: +// 1. Reserve a write position. This moves write_pos. +// 2. Claim the chunk at that position: change its state from Free to +// BeingWritten. +// Step 2 can fail, for example if an older writer still holds the chunk. +// The reserved position then stays unused, and only the reader can move +// past it. +// - The writer only accesses the ring buffer. It does not contact the reader, +// and it does not apply a BufferExhaustedPolicy. TraceWriterV2Impl does +// both. +// - A call that needs a new chunk makes at most num_chunks attempts to +// reserve and claim one. If none succeeds, the call returns at once with +// kFull or kClaimFailed. Only WaitForReadPosChange() blocks. +// +// The writer is in one of three states: +// - Ready: no fragment is open. The writer can still hold the chunk that it +// published last. It appends the next fragment there if the fragment fits, +// without a new reservation. +// - Fragment open: BeginFragment() returned a range. The caller writes the +// fragment's bytes into it. +// - Relocation pending: the reader took the chunk before EndFragment() +// published the fragment, and the writer could not claim a replacement +// chunk. The writer keeps a copy of the fragment. See EndFragment(). +// +// The calls and the states that allow them: +// - BeginFragment(): Ready. On success, opens a fragment. +// - EndFragment(): Fragment open. Publishes the fragment and returns to +// Ready, or enters Relocation pending. +// - RetryRelocation(): Relocation pending. Publishes the saved copy and +// returns to Ready, or stays in Relocation pending. +// - DropRelocation(): Relocation pending. Drops the saved copy and returns to +// Ready. +// - FinishCurrentChunk(): Ready or Fragment open. Releases the held chunk, so +// the next fragment needs a new one. TraceWriterV2Impl::Flush() uses it. +// - In Fragment open, it abandons the open fragment and publishes the +// earlier fragments of the chunk. +// - WaitForReadPosChange(): after a call returned kFull or kClaimFailed. +// - RecordDataLoss(), has_pending_data_loss(), accessors and GetStats(): any +// state. +class SharedRingBufferWriter { + public: + // Result of BeginFragment(), which may need a new chunk. + enum class BeginFragmentResult { + kSuccess, + // The ring buffer is structurally full: num_chunks positions are + // outstanding and the reader is behind. The call reserved nothing. + kFull, + // The call reserved a position, but could not claim its chunk, for example + // because an older writer still holds it. + // + // The reserved position stays unused until the reader moves past it. + // Chunks pinned by a stalled writer produce this without the ring buffer + // being full. + kClaimFailed, + // The request is larger than a freshly claimed chunk could hold. This is a + // caller bug, not backpressure. + kTooLarge, + }; + + // Result of EndFragment(), RetryRelocation() and FinishCurrentChunk(), which + // publish. + enum class EndFragmentResult { + kSuccess, + // The reader took the chunk before the publication, and the writer could + // not claim a replacement chunk. The reasons are the same as in + // BeginFragmentResult. The writer is then in Relocation pending. + kFull, + kClaimFailed, + }; + + // Result of RetryRelocation(). + struct RetryRelocationResult { + EndFragmentResult result = EndFragmentResult::kFull; + // True if the call claimed at least one replacement chunk. + // - A successful claim ends one acquisition. A caller that limits each + // acquisition, such as TraceWriterV2Impl, then starts a new limit. + // - With kFull or kClaimFailed, the reader also took the last replacement + // before its publication, and the next claim attempts failed. + bool acquired_replacement = false; + }; + + // A contiguous range for the caller to fill. Valid until the next call on + // this SharedRingBufferWriter. + struct FragmentRange { + BeginFragmentResult result = BeginFragmentResult::kFull; + uint8_t* begin = nullptr; + uint8_t* end = nullptr; + }; + + SharedRingBufferWriter(SharedRingBuffer* ring, + WriterID writer_id, + BufferID target_buffer); + ~SharedRingBufferWriter(); + + SharedRingBufferWriter(const SharedRingBufferWriter&) = delete; + SharedRingBufferWriter& operator=(const SharedRingBufferWriter&) = delete; + SharedRingBufferWriter(SharedRingBufferWriter&&) = delete; + SharedRingBufferWriter& operator=(SharedRingBufferWriter&&) = delete; + + // Starts a fragment for the caller to fill. + // - On success, returns a writable range of at least |min_size| bytes. + // - Reuses space in the current chunk when possible. Otherwise, tries to + // claim a new chunk. See the class comment. + // - Call EndFragment() after writing the bytes. + // - Only one fragment can be open at a time. + // + // |continues_from_prev| describes the packet this fragment belongs to: + // - true: continues the packet from this writer's previous chunk. + // - false: starts a new packet. + // The flag describes the first fragment of a chunk. + // + // If BeginFragment(..., true) cannot acquire space, the caller can abandon + // the rest of the packet. The next packet must start with + // BeginFragment(..., false), even though the previous chunk still marks a + // continuation. Only the caller knows that a new packet starts. The writer + // cannot infer |continues_from_prev| from the previous chunk's flag. + FragmentRange BeginFragment(uint32_t min_size, bool continues_from_prev); + + // Ends the open fragment at |size| bytes and publishes it, so the reader + // can copy it. |size| must fit the range from BeginFragment(). + // + // Set |continues_on_next| if the packet continues in the next chunk, which + // then starts with BeginFragment(..., true). The flag marks the chunk's last + // fragment, so the writer appends nothing more to this chunk. + // + // The reader can take a chunk while its last fragment is still open: it + // copies the published fragments and asks the writer to move the open one. + // EndFragment() then relocates the fragment: + // 1. It saves a copy and acknowledges the request, so the reader can reuse + // the old chunk. + // 2. It claims a new chunk, copies the fragment there and publishes it. If + // the reader takes this chunk too, it repeats. + // If step 2 cannot claim a chunk, returns kFull or kClaimFailed. The + // relocation is then pending: call RetryRelocation() or DropRelocation(). + EndFragmentResult EndFragment(uint32_t size, bool continues_on_next); + + // Tries again to claim a chunk for the saved fragment, and publishes it + // there, as EndFragment() does. Only in Relocation pending. + RetryRelocationResult RetryRelocation(); + + // Drops the saved fragment. The next publication sets kFlagDataLoss. Only in + // Relocation pending. + void DropRelocation(); + + // Blocks the calling thread. The wait requests at most |timeout_ms|. + // Scheduling can make the elapsed time longer. + // + // Call it after kFull or kClaimFailed. A return does not reserve space. Call + // again to try for a chunk. + // - With a futex: returns when read_pos differs from the value that the + // last reservation attempt saw, at the timeout, or on a spurious wake. So + // if the reader moved read_pos after that attempt, it returns at once. + // - Without a futex: sleeps for the next step of v1's backoff, 0, 8, 72, ... + // microseconds, at most 100 ms per step. No sleep requests more than + // |timeout_ms|. It does not check read_pos. + void WaitForReadPosChange(uint32_t timeout_ms); + + // Publishes whatever is held and lets go of the chunk. Any open fragment is + // abandoned: its bytes were never counted, so nothing is published for it. + // Safe to call with nothing held. The destructor calls it. + EndFragmentResult FinishCurrentChunk(); + + // Records loss for the next chunk publication. + // - A cached chunk can still be reused, even when the ring buffer is full. + // - The publication sets kFlagDataLoss. The reader discards all published + // fragments in that chunk. Even complete packets before or after the gap + // are discarded. The flag cannot identify which packets are safe. + // - Data already delivered by the reader cannot be retracted. + void RecordDataLoss() { data_loss_pending_ = true; } + + // True until a claimed or published chunk carries the recorded loss. This + // includes a loss flag that a pending relocation inherited from the + // rewritten chunk. + // + // TraceWriterV2Impl uses it so that kStallThenDrop does not stall again for + // each dropped packet. + bool has_pending_data_loss() const { + return data_loss_pending_ || + (pending_relocation_ && + (pending_relocation_->chunk_flags & kFlagDataLoss)); + } + + WriterID writer_id() const { return writer_id_; } + // Largest range that BeginFragment() can return. + uint32_t max_fragment_size() const { return max_fragment_size_; } + + // For diagnostics only. The protocol never reads these counters. + // TODO(sashwinbalaji): Wire these counters into service statistics. + struct Stats { + uint64_t failed_claims = 0; + uint64_t fragments_dropped = 0; + uint64_t relocations = 0; + }; + Stats GetStats() const { return stats_; } + + private: + friend class test::SharedRingBufferInternalsForTest; + + static constexpr uint32_t kNoFragmentOpen = UINT32_MAX; + + // A saved fragment that waits for a replacement chunk. Its bytes are in + // |relocation_payload_|. + struct PendingRelocation { + // Flags for the replacement chunk's BeingWritten word. Only + // kFlagContinuesFromPrevChunk and kFlagDataLoss, inherited from the + // rewritten chunk. + uint32_t chunk_flags = 0; + // Sets kFlagContinuesOnNextChunk on the replacement's publication. + bool continues_on_next = false; + }; + + // Maximum payload available to one more fragment in the cached chunk, which + // must exist. + uint32_t MaxFragmentSizeInCurrentChunk() const; + ChunkState cur_chunk_state() const { + return ChunkStateOf(expected_state_word_); + } + bool has_open_fragment() const { + return cur_fragment_begin_ != kNoFragmentOpen; + } + + FragmentRange BeginFragmentInCurrentChunk(uint32_t available); + BeginFragmentResult AcquireNewChunk(uint32_t continuation_flags); + // Only the just-ended fragment can be complete but unpublished: + // - A size of zero is a valid empty fragment. + // - nullopt means FinishCurrentChunk() has no fragment to publish. + EndFragmentResult ReleaseCurrentChunkAsComplete( + std::optional fragment_size, + bool continues_on_next); + // Writes the saved fragment into the newly claimed chunk, as its only + // fragment. + void CopyRelocatedFragment(uint32_t fragment_size); + // Clears only this writer's cached chunk state. It does not modify the ring + // buffer. + void ResetCurrentChunk(); + + SharedRingBuffer* const ring_; + const WriterID writer_id_; + const BufferID target_buffer_; + const uint32_t chunk_size_; + // MaxFragmentSizeForEmptyChunk(chunk_size_), computed once. + const uint32_t max_fragment_size_; + + // State cached for the chunk this writer currently owns. + uint8_t* cur_chunk_ = nullptr; + ChunkIndex cur_chunk_idx_ = ChunkIndex::FromIndex(0); + // The exact word this writer's next compare-and-swap expects. It can differ + // from the shared word once the reader has requested a rewrite. + uint32_t expected_state_word_ = 0; + // Payload grows from the header. Size entries grow backwards from the end. + // - payload_end_ is measured from the chunk start. + // - size_directory_bytes_ counts bytes used from the chunk end. + // + // Example: a 256-byte chunk with 200 payload bytes and 4 directory bytes. + // + // 0 6 206 252 256 + // +--------+---------------------+------------------+-----------+ + // | header | payload grows ---> | free space | <-- sizes | + // +--------+---------------------+------------------+-----------+ + // + // Here: chunk_size_ = 256, payload_end_ = 206, size_directory_bytes_ = 4. + // Directory start = chunk_size_ - size_directory_bytes_ = 252. + // Free bytes = chunk_size_ - payload_end_ - size_directory_bytes_ = 46. + // + // Byte offset from the chunk start to the end of finalized payload. + uint32_t payload_end_ = 0; + // Size-directory bytes used from the chunk end. Zero means no entries. + uint32_t size_directory_bytes_ = 0; + // Finalized fragments, published or not. expected_state_word_ contains the + // count already visible to the reader. + uint32_t num_fragments_ = 0; + // Byte offset from the chunk start to the open fragment, or kNoFragmentOpen. + uint32_t cur_fragment_begin_ = kNoFragmentOpen; + + // Whether kFlagDataLoss still needs to be set in a chunk's state word. + // - Cleared after successfully claiming or publishing a chunk with the flag. + // - Kept pending if the reader requests a rewrite before publication. + // AcquireNewChunk() then sets the flag in the replacement chunk. + // - A rewrite of BeingWritten(0) can move the chunk's loss flag into + // |pending_relocation_|, not back into this flag. has_pending_data_loss() + // checks both. + bool data_loss_pending_ = false; + + // The read_pos that the last reservation attempt saw. + // WaitForReadPosChange() waits while read_pos keeps this value. + uint32_t read_pos_for_wait_ = 0; + + // Stop trying the syscall if the build or kernel cannot provide it. + // Once false, this writer uses sleep backoff for later waits too. + bool use_futex_ = SharedRingBuffer::SupportsWriterWait(); + + // The next sleep of the backoff without futex. It grows with each sleep, up + // to 100 ms, across calls. It resets when the writer claims a chunk. + uint32_t fallback_sleep_us_ = 0; + + // Set when a relocation cannot claim a replacement chunk. RetryRelocation() + // clears it after a claim. DropRelocation() also clears it. + std::optional pending_relocation_; + + // Unpublished fragment saved while changing chunks. Allocated on demand and + // reused. Writers that never relocate need no payload storage here. + std::vector relocation_payload_; + + // Test callback, called after each replacement claim, before the + // publication. + // - The callback requests a rewrite of the replacement, as the reader can. + // The publication then fails, and the writer relocates again. + // Empty in production. Tests force the race without scheduling threads. + std::function after_replacement_claim_for_testing_; + + Stats stats_; +}; + +} // namespace perfetto::tracing_v2 + +#endif // SRC_TRACING_V2_SHARED_RING_BUFFER_WRITER_H_ /* * Copyright (C) 2026 The Android Open Source Project * @@ -59391,118 +65456,537 @@ perfetto::base::Status LoadMessageFilterConfig( * limitations under the License. */ -// gen_amalgamated expanded: #include "src/protozero/filtering/message_filter_config.h" +#ifndef SRC_TRACING_V2_TRACE_WRITER_V2_IMPL_H_ +#define SRC_TRACING_V2_TRACE_WRITER_V2_IMPL_H_ #include +#include +#include #include -#include -// gen_amalgamated expanded: #include "perfetto/base/status.h" -// gen_amalgamated expanded: #include "protos/perfetto/config/trace_config.gen.h" -// gen_amalgamated expanded: #include "src/protozero/filtering/message_filter.h" -// gen_amalgamated expanded: #include "src/protozero/filtering/string_filter.h" +// gen_amalgamated expanded: #include "perfetto/base/proc_utils.h" +// gen_amalgamated expanded: #include "perfetto/base/time.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message_handle.h" +// gen_amalgamated expanded: #include "perfetto/protozero/root_message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/scattered_stream_writer.h" +// gen_amalgamated expanded: #include "perfetto/tracing/buffer_exhausted_policy.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_writer.h" -namespace protozero { +namespace perfetto::tracing_v2 { -namespace { +class ProducerRingBufferArbiter; -using TraceFilter = perfetto::protos::gen::TraceConfig::TraceFilter; -using StringFilterRule = TraceFilter::StringFilterRule; +namespace test { +class TraceWriterV2ImplTestPeer; +} // namespace test -std::optional ConvertPolicy( - TraceFilter::StringFilterPolicy policy) { - switch (policy) { - case TraceFilter::SFP_UNSPECIFIED: - return std::nullopt; - case TraceFilter::SFP_MATCH_REDACT_GROUPS: - return StringFilter::Policy::kMatchRedactGroups; - case TraceFilter::SFP_ATRACE_MATCH_REDACT_GROUPS: - return StringFilter::Policy::kAtraceMatchRedactGroups; - case TraceFilter::SFP_MATCH_BREAK: - return StringFilter::Policy::kMatchBreak; - case TraceFilter::SFP_ATRACE_MATCH_BREAK: - return StringFilter::Policy::kAtraceMatchBreak; - case TraceFilter::SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS: - return StringFilter::Policy::kAtraceRepeatedSearchRedactGroups; +// TraceWriter implementation backed by a tracing v2 shared ring buffer. +// +// Data path from the SDK to the service. "v" is a call or a write. "^" is a +// read by the service. "<--" is an IPC request. +// +// v1: SMB v2: ring buffer +// +// data source (SDK) data source (SDK) +// | NewTracePacket() | NewTracePacket() +// v v +// TraceWriterImpl TraceWriterV2Impl (this class) +// | | +// | GetNewChunk() | BeginFragment(), EndFragment() +// v v +// SharedMemoryArbiterImpl SharedRingBufferWriter +// | picks a free chunk, | claims and publishes chunks +// | batches completed chunks | lock-free. The bytes do not +// | | go through +// | | ProducerRingBufferArbiter. +// v v +// [ SMB ] [ ring buffer ] +// ^ ^ +// | copies the listed chunks | copies all published chunks +// | | +// service <-- CommitData IPC service <-- DrainV2RingBuffer IPC +// from the arbiter: from the ring buffer arbiter: +// "chunks N, M are "read what is +// complete" published" +// +// The ring buffer arbiter is ProducerRingBufferArbiter. It sends the drain +// requests of all writers of the ring buffer. +// +// Only this class calls both SharedRingBufferWriter and +// ProducerRingBufferArbiter: +// - SharedRingBufferWriter claims chunks, and publishes and relocates +// fragments. +// - The arbiter delivers drain requests to the endpoint thread. +// +// This class decides: +// - When to ask for a drain: +// - After a publication, if the ring buffer's outstanding positions reach +// the arbiter's drain occupancy threshold. +// - After failed claims, if the writer drops the data. Only the reader can +// move past those positions. +// - Before each wait for space. +// - What to do when no chunk is free: wait for the reader and try again, or +// drop the packet. See TryStallForSpace(). +// +// A nested message can span chunks, and the reader can copy an earlier +// fragment while the message is still open. So this writer cannot patch +// length fields later, as v1 does. It uses proto group encoding instead: +// - The format: proto_utils::kProtoGroupEndByte. +// - The service converts each packet back to length-delimited protobuf: see +// ProtoGroupRewriter. +// +// If the writer drops any part of a packet: +// - Its remaining bytes go to the drop buffer. +// - The next publication sets kFlagDataLoss. The reader discards all +// published fragments in that chunk and reports the gap. +// - The service discards orphan continuations. It still delivers later +// complete packets from chunks without the flag. +// +// Threads: +// - As with TraceWriterImpl, use each instance from one thread at a time. +class TraceWriterV2Impl : public TraceWriter, + public protozero::MessageFinalizationListener, + public protozero::ScatteredStreamWriter::Delegate { + public: + // ProducerRingBufferArbiter::CreateTraceWriter() creates each writer. + // + // |ring_buffer_arbiter| supplies the ring buffer. Packet bytes go directly + // into it. The arbiter also receives drain requests and flushes. The + // destructor releases |id| through it. + // + // - |id|: the arbiter allocates it from the shared WriterID pool. See the + // ownership diagram in ProducerRingBufferArbiter. + // - |target_buffer|: the service buffer for the packets. Each chunk header + // stores it. + // - |policy|: what the writer does when the ring buffer is full. See + // BufferExhaustedPolicy. + TraceWriterV2Impl(ProducerRingBufferArbiter* ring_buffer_arbiter, + WriterID id, + BufferID target_buffer, + BufferExhaustedPolicy policy); + ~TraceWriterV2Impl() override; + + TraceWriterV2Impl(const TraceWriterV2Impl&) = delete; + TraceWriterV2Impl& operator=(const TraceWriterV2Impl&) = delete; + TraceWriterV2Impl(TraceWriterV2Impl&&) = delete; + TraceWriterV2Impl& operator=(TraceWriterV2Impl&&) = delete; + + // TraceWriter: + TracePacketHandle NewTracePacket() override; + void FinishTracePacket() override; + // Unlike v1, |callback| does not wait for a service ack. See + // ProducerRingBufferArbiter::Flush(). + void Flush(std::function callback = {}) override; + WriterID writer_id() const override { + return ring_buffer_writer_.writer_id(); } - return std::nullopt; -} + uint64_t written() const override { return stream_writer_.written(); } + uint64_t drop_count() const override { return drop_count_; } -std::optional ConvertSemanticTypeMask( - const StringFilterRule& rule) { - // UNSPECIFIED (0) is treated as its own category - it only matches rules - // that explicitly include bit 0 in their mask. If no semantic types are - // specified, default to matching only UNSPECIFIED (bit 0). - if (rule.semantic_type().empty()) { - return StringFilter::SemanticTypeMask::Unspecified(); - } - StringFilter::SemanticTypeMask mask; - for (const auto& type : rule.semantic_type()) { - auto semantic_type = static_cast(type); - if (semantic_type >= StringFilter::SemanticTypeMask::kLimit) { - return std::nullopt; - } - mask.Set(semantic_type); - } - return mask; + private: + friend class test::TraceWriterV2ImplTestPeer; + + using ClockFunction = base::TimeMillis (*)(); + + // protozero::MessageFinalizationListener: + void OnMessageFinalized(protozero::Message*) override; + + // protozero::ScatteredStreamWriter::Delegate: + protozero::ContiguousMemoryRange GetNewBuffer() override; + uint8_t* AnnotatePatch(uint8_t*) override; + + // Checks that no packet is open, before a new packet or a flush. + // - A caller can call Message::Finalize() directly, without the handle. + // The message is then closed, but its last fragment stays unpublished. + // This publishes it. + // - Raw stream callers skip finalization. They must call + // FinishTracePacket() first, or the CHECK fails. + void EnsurePacketClosed(); + + // Obtains storage for the next fragment of the current packet: a new + // fragment in the ring buffer, or the drop buffer. NewTracePacket() calls it + // for the first fragment, GetNewBuffer() for each continuation. + // - On success, returns the fragment's range and ends drop mode. + // - If no chunk is free, applies the policy through TryStallForSpace(). If + // the policy drops the packet, enters drop mode and returns the drop + // buffer. + protozero::ContiguousMemoryRange BeginPacketFragment( + bool continues_from_prev); + + // Publishes the open fragment, if any. + // - |continues_on_next| sets kFlagContinuesOnNextChunk. + // - After the publication, asks for a drain at the threshold. + // - If a relocation needs a new chunk, applies the policy through + // TryStallForSpace(), with one stall deadline for each replacement + // acquisition. + // - If the policy drops the fragment, enters drop mode for the rest of the + // packet. + // - Returns with no relocation pending in |ring_buffer_writer_|. + void EndPacketFragment(bool continues_on_next); + + // Decides what to do after |ring_buffer_writer_| found no free chunk: wait + // for the reader, or drop the data. + // + // Returns true after a wait. The caller then tries again to get a chunk. + // Returns false, without a wait, if the writer must drop the data: + // - The policy is kDrop. + // - The policy is kStallThenDrop, and an earlier loss is still unreported. + // - No reader is attached, so nothing frees space. + // - The stall deadline passed. Under kStall, this aborts instead. + // + // |claim_failed|: the failed call returned kClaimFailed. Its reserved + // positions stay unused until the reader moves past them. So a drop also + // asks for a drain. + // + // |stall_deadline|: the deadline of the current chunk acquisition. Pass an + // unset value on the first call for an acquisition, and the same value on + // each retry. The first wait sets it. + bool TryStallForSpace(bool claim_failed, + std::optional* stall_deadline); + + // Drops the rest of the open packet: its bytes go to GetDropBuffer() from now + // on. + // - If drop mode is not active yet, counts one drop and records the loss + // for the next publication. + // - Drop mode lasts until a later packet gets a fragment in the ring buffer. + void EnterDropMode(); + + // Returns the process-wide drop buffer as a writable range. Only in drop + // mode. + protozero::ContiguousMemoryRange GetDropBuffer(); + + // Receives drain requests, Flush() and OnWriterDestroyed(). See the + // constructor. + ProducerRingBufferArbiter* const ring_buffer_arbiter_; + + // Claims chunks and publishes fragments in the ring buffer. + SharedRingBufferWriter ring_buffer_writer_; + + // What this writer does when the ring buffer has no free chunk. + const BufferExhaustedPolicy buffer_exhausted_policy_; + + // Time source for stall deadlines. Tests replace it to advance time + // deterministically across acquisition attempts. + ClockFunction get_time_ms_ = &base::GetWallTimeMs; + + // PID of the process that created this writer. A DCHECK uses it to detect + // a process fork during tracing, which this writer does not support. + const base::PlatformProcessId process_id_; + + // Protozero writes packet bytes through this. It points into the open + // fragment, or into the drop buffer in drop mode. + protozero::ScatteredStreamWriter stream_writer_; + + // A pointer, so this header does not need the generated TracePacket header. + // NewTracePacket() resets and reuses the same root message for every packet. + // + // TODO(sashwinbalaji): Consider std::optional>. + // - It saves one heap allocation per writer, but needs the generated + // TracePacket header here. + // - It waits because TraceWriterImpl makes the same choice. One decision + // must cover both writers. + // - Revisit if a profile shows this allocation at writer creation. + std::unique_ptr> + cur_packet_; + + // Start of the open fragment in shared memory. + // Null after the fragment closes, and in drop mode. + uint8_t* fragment_begin_ = nullptr; + + // True from NewTracePacket() until FinishTracePacket(). + bool packet_open_ = false; + + // True while writes go to the drop buffer. Stays true until a later + // NewTracePacket() gets a fragment in the ring buffer. + bool in_drop_mode_ = false; + + // Sets first_packet_on_sequence on the first packet of this writer. + bool first_packet_on_sequence_ = true; + + // Number of times this writer entered drop mode. Consecutive dropped + // packets count once, as in TraceWriterImpl. + uint64_t drop_count_ = 0; +}; + +} // namespace perfetto::tracing_v2 + +#endif // SRC_TRACING_V2_TRACE_WRITER_V2_IMPL_H_ +/* + * Copyright (C) 2026 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "src/tracing/v2/producer_ring_buffer_arbiter.h" + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "perfetto/base/task_runner.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/status_macros.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/uuid.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_arbiter.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h" +// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h" +// gen_amalgamated expanded: #include "src/tracing/core/null_trace_writer.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_abi.h" +// gen_amalgamated expanded: #include "src/tracing/v2/trace_writer_v2_impl.h" + +namespace perfetto::tracing_v2 { +namespace { + +// Chooses a chunk size by weight, defaulting to kMinChunkSize. +uint32_t ChooseChunkSize(const DataSourceConfig& config) { + using ChunkSizeOption = + DataSourceConfig::ExperimentalTracingV2Config::ChunkSizeOption; + + const auto& options = config.experimental_tracing_v2().chunk_size_options(); + auto weight_of = [](const ChunkSizeOption& option) -> uint64_t { + if (!IsValidChunkSize(option.size_bytes())) + return 0; + return option.has_weight() ? option.weight() : 1; + }; + + uint64_t total_weight = 0; + for (const ChunkSizeOption& option : options) + total_weight += weight_of(option); + + if (total_weight == 0) + return kMinChunkSize; + + // Walk the options until their cumulative weight passes |target|. + const uint64_t target = + static_cast(base::Uuidv4().lsb()) % total_weight; + uint64_t cumulative_weight = 0; + for (const ChunkSizeOption& option : options) { + cumulative_weight += weight_of(option); + if (target < cumulative_weight) + return option.size_bytes(); + } + + // Not reached: the last cumulative weight is the total, which is above + // |target|, so the loop returns. + PERFETTO_DFATAL("ChooseChunkSize: no option for the target"); + return kMinChunkSize; +} + +// Returns the drain threshold, in positions, for a ring buffer of +// |num_chunks| chunks. +// |drain_occupancy_percent| must be -1 to 100, as validated by the service: +// - -1: 1, so a writer asks for a drain after every publication. +// - 0: |kDefaultDrainOccupancyPercent|% of |num_chunks|. +// - 1 to 100: that percent of |num_chunks|. +// The result is at least 1. +uint32_t ComputeDrainOccupancyThreshold(uint32_t num_chunks, + int32_t drain_occupancy_percent) { + constexpr uint32_t kDefaultDrainOccupancyPercent = 25; + + PERFETTO_DCHECK(drain_occupancy_percent >= -1 && + drain_occupancy_percent <= 100); + if (drain_occupancy_percent == -1) + return 1; + const uint32_t percent = drain_occupancy_percent == 0 + ? kDefaultDrainOccupancyPercent + : static_cast(drain_occupancy_percent); + const uint64_t threshold = uint64_t{num_chunks} * percent / 100; + return std::max(1u, static_cast(threshold)); } } // namespace -perfetto::base::Status LoadMessageFilterConfig(const TraceFilter& filt, - MessageFilter* filter) { - StringFilter& string_filter = filter->string_filter(); +// static +base::StatusOr> +ProducerRingBufferArbiter::Create( + base::TaskRunner* task_runner, + ProducerEndpoint* endpoint, + const DataSourceConfig& config, + size_t shmem_size_hint_bytes, + AllocateSharedMemoryFn allocate_shared_memory) { + const uint32_t chunk_size_bytes = ChooseChunkSize(config); - auto add_rule = [&](const auto& rule) -> perfetto::base::Status { - auto policy = ConvertPolicy(rule.policy()); - if (!policy.has_value()) { - return perfetto::base::ErrStatus( - "Trace filter has invalid string filtering rules"); - } - auto semantic_type = ConvertSemanticTypeMask(rule); - if (!semantic_type.has_value()) { - return perfetto::base::ErrStatus( - "Trace filter has invalid semantic types in string filtering rules"); - } - string_filter.AddRule(*policy, rule.regex_pattern(), - rule.atrace_payload_starts_with(), rule.name(), - *semantic_type); - return perfetto::base::OkStatus(); - }; + ASSIGN_OR_RETURN(const size_t shmem_size_bytes, + RingBufferSizeForShmSizeHint(shmem_size_hint_bytes, + TracingService::kMaxShmSize, + chunk_size_bytes)); - // Load base string filter chain. - for (const auto& rule : filt.string_filter_chain().rules()) { - auto status = add_rule(rule); - if (!status.ok()) - return status; - } + ASSIGN_OR_RETURN(std::shared_ptr memory, + allocate_shared_memory(shmem_size_bytes)); - // Load v54 string filter chain. Rules with matching names will replace - // existing rules; others will be appended. - for (const auto& rule : filt.string_filter_chain_v54().rules()) { - auto status = add_rule(rule); - if (!status.ok()) - return status; + const uint32_t num_chunks = static_cast( + (shmem_size_bytes - sizeof(RingBufferHeader)) / chunk_size_bytes); + const uint32_t drain_occupancy_threshold = ComputeDrainOccupancyThreshold( + num_chunks, config.experimental_tracing_v2().drain_occupancy_percent()); + + return std::unique_ptr( + new ProducerRingBufferArbiter(task_runner, endpoint, std::move(memory), + chunk_size_bytes, + drain_occupancy_threshold)); +} + +ProducerRingBufferArbiter::ProducerRingBufferArbiter( + base::TaskRunner* task_runner, + ProducerEndpoint* endpoint, + std::shared_ptr memory, + uint32_t chunk_size, + uint32_t drain_occupancy_threshold) + : task_runner_(task_runner), + endpoint_(endpoint), + shared_memory_arbiter_(endpoint->MaybeSharedMemoryArbiter()), + memory_(std::move(memory)), + ring_buffer_(static_cast(memory_->start()), + memory_->size(), + chunk_size), + drain_occupancy_threshold_(drain_occupancy_threshold) { + PERFETTO_CHECK(shared_memory_arbiter_); +} + +ProducerRingBufferArbiter::~ProducerRingBufferArbiter() { + Disconnect(); +} + +void ProducerRingBufferArbiter::OnReaderAttachReply(bool reader_attached) { + PERFETTO_DCHECK_THREAD(thread_checker_); + // The attach reply can arrive after Disconnect(). + if (reader_state_.load() == ReaderState::kDetached) + return; + if (!reader_attached) { + PERFETTO_ELOG("tracing v2: ring buffer attachment failed"); + Disconnect(); + return; } + SetReaderState(ReaderState::kAttached); +} - const std::string& bytecode_v1 = filt.bytecode(); - const std::string& bytecode_v2 = filt.bytecode_v2(); - const std::string& bytecode = bytecode_v2.empty() ? bytecode_v1 : bytecode_v2; - const std::string& overlay = filt.bytecode_overlay_v54(); - if (!filter->LoadFilterBytecode(bytecode.data(), bytecode.size(), - overlay.empty() ? nullptr : overlay.data(), - overlay.size())) { - return perfetto::base::ErrStatus("Trace filter bytecode invalid"); +bool ProducerRingBufferArbiter::IsReaderAttached() const { + return reader_state_.load() == ReaderState::kAttached; +} + +void ProducerRingBufferArbiter::Disconnect() { + PERFETTO_DCHECK_THREAD(thread_checker_); + SetReaderState(ReaderState::kDetached); +} + +void ProducerRingBufferArbiter::SetReaderState(ReaderState next) { + PERFETTO_DCHECK_THREAD(thread_checker_); + const ReaderState current = reader_state_.load(); + PERFETTO_CHECK( + next == ReaderState::kDetached || + (current == ReaderState::kPending && next == ReaderState::kAttached)); + reader_state_.store(next); +} + +std::unique_ptr ProducerRingBufferArbiter::CreateTraceWriter( + BufferID target_buffer, + BufferExhaustedPolicy policy) { + if (PERFETTO_UNLIKELY(reader_state_.load() == ReaderState::kDetached)) + return std::make_unique(); + + const WriterID writer_id = + shared_memory_arbiter_->AllocateTracingV2WriterID(); + if (PERFETTO_UNLIKELY(!writer_id)) + return std::make_unique(); + + return std::make_unique(this, writer_id, target_buffer, + policy); +} + +void ProducerRingBufferArbiter::OnWriterDestroyed(WriterID id) { + // TODO(sashwinbalaji): Make WriterID reuse safe between v2 and v1 writers. + // The problem: + // - The SMB arbiter can give this ID to a v1 writer at once. + // - The last ring buffer chunk of this writer can still wait for a drain. + // - TraceBufferV2 accepts one input format for each (producer, writer) + // sequence. While it keeps the sequence, it rejects chunks of the other + // format as ABI violations. So one of the two writers loses data. + + // After this release, the endpoint can destroy this object. Do not access + // members after it. + shared_memory_arbiter_->ReleaseTracingV2WriterID(id); +} + +void ProducerRingBufferArbiter::RequestDrain(DrainUrgency urgency) { + // See DrainUrgency::kUrgent. + if (urgency == DrainUrgency::kUrgent && + task_runner_->RunsTasksOnCurrentThread()) { + endpoint_->DrainV2RingBuffer(); + return; } + PostDrainTask(/*force=*/false); +} - return perfetto::base::OkStatus(); +void ProducerRingBufferArbiter::Flush(std::function callback) { + // Set force=true to queue our own drain task before the callback. The + // endpoint thread then sends the drain request before it runs the callback. + // + // A shared drain task would leave a race: + // 1. Another writer sets the flag, then pauses before PostTask(). + // 2. Flush() sees the flag and queues only its callback. + // 3. The callback runs before the other writer queues the drain task. + PostDrainTask(/*force=*/true); + + if (callback) + task_runner_->PostTask(std::move(callback)); } -} // namespace protozero -// gen_amalgamated begin source: src/tracing/service/zlib_compressor.cc -// gen_amalgamated begin header: src/tracing/service/zlib_compressor.h +void ProducerRingBufferArbiter::PostDrainTask(bool force) { + // When |force| is false, requests share a pending drain task. The writer + // sets |drain_task_pending_| after it changes the ring buffer, so that task + // covers the change. The atomic operations below act on + // |drain_task_pending_|: + // + // writer thread endpoint thread (the pending task) + // ------------- ---------------------------------- + // W1. publish a chunk, or E1. exchange(0) + // leave a failed claim E2. send DrainV2RingBuffer + // W2. fetch_or(1) + // - was set: post nothing + // - was clear: post a task + // + // If W2 finds |drain_task_pending_| already set, a drain is still due after + // W1. That request covers this change too, so this writer needs no extra + // task. E1 must be a read-modify-write for this: + // - Only W2 and E1 write the flag, and both are read-modify-writes. + // - If W2 reads 1, an earlier W2 posted the pending task. In the + // modification order of the flag, no E1 comes between those two W2s. + // - So the next E1 comes after this W2. It reads the value of this W2 or + // of a later W2. + // - So this W2 synchronizes with that E1, and W1 happens before the E2 + // after it. + // + // Flush() sets |force|. See Flush() for why it cannot share a pending task. + if (!force && drain_task_pending_.fetch_or(1)) + return; + + task_runner_->PostTask([weak_this = weak_factory_.GetWeakPtr()] { + if (!weak_this) + return; + PERFETTO_DCHECK_THREAD(weak_this->thread_checker_); + // E1, then E2. Clearing the flag first lets a later request post another + // task. E1 must be a read-modify-write: see above. + weak_this->drain_task_pending_.exchange(0); + weak_this->endpoint_->DrainV2RingBuffer(); + }); +} + +} // namespace perfetto::tracing_v2 +// gen_amalgamated begin source: src/tracing/v2/shared_ring_buffer.cc /* - * Copyright (C) 2023 The Android Open Source Project + * Copyright (C) 2026 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -59517,25 +66001,411 @@ perfetto::base::Status LoadMessageFilterConfig(const TraceFilter& filt, * limitations under the License. */ -#ifndef SRC_TRACING_SERVICE_ZLIB_COMPRESSOR_H_ -#define SRC_TRACING_SERVICE_ZLIB_COMPRESSOR_H_ +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer.h" -#include +#include +#include -// gen_amalgamated expanded: #include "perfetto/base/build_config.h" -// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h" +#include -namespace perfetto { +// gen_amalgamated expanded: #include "perfetto/base/compiler.h" +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/futex.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_abi.h" -#if PERFETTO_BUILDFLAG(PERFETTO_ZLIB) -void ZlibCompressFn(std::vector*); -#endif +namespace perfetto::tracing_v2 { +namespace { + +static_assert(kMaxFragmentSizeVarIntBytes == + protozero::proto_utils::kMessageLengthFieldSize, + "Ring buffer fragment sizes must use the same varint byte limit " + "as Protozero message lengths"); + +// The buffer stores read_pos in the low 32 bits of rw_positions. Pass its +// address to the futex API, but keep all C++ accesses on the containing +// atomic. +// +// The supported CPU/ABI set provides atomic observation of that 32-bit half +// during the 64-bit CAS. +const uint32_t* ReadPosFutexAddress(const std::atomic* rw_positions) { + static_assert(PERFETTO_IS_LITTLE_ENDIAN(), + "The low-word futex requires read_pos to be the first four " + "bytes of rw_positions"); + return reinterpret_cast(rw_positions); +} + +// Callers validate untrusted layouts with NumChunksForRingBufferLayout() +// first. An invalid layout here is a bug. +uint32_t CheckedNumChunks(const void* start, size_t size, uint32_t chunk_size) { + base::StatusOr num_chunks = + NumChunksForRingBufferLayout(start, size, chunk_size); + if (!num_chunks.ok()) + PERFETTO_FATAL("tracing v2: %s", num_chunks.status().c_message()); + return *num_chunks; +} + +} // namespace + +// --- Construction. --- + +SharedRingBuffer::SharedRingBuffer(uint8_t* start, + size_t size, + uint32_t chunk_size) + : start_(start), + num_chunks_(CheckedNumChunks(start, size, chunk_size)), + chunk_size_(chunk_size) {} + +// --- Writer-side reservation. --- + +SharedRingBuffer::Reservation SharedRingBuffer::TryReserveWritePos() { + // The reader marks chunks Free before publishing read_pos. + // A writer that sees the new read_pos also sees those Free state words. + return TryReserveWritePosFromSnapshot( + header()->rw_positions.load(std::memory_order_acquire)); +} + +SharedRingBuffer::Reservation SharedRingBuffer::TryReserveWritePosFromSnapshot( + uint64_t rw_positions) { + RingBufferHeader* ring_header = header(); + Reservation reservation{}; + for (;;) { + const uint32_t write_pos = WritePosOf(rw_positions); + const uint32_t read_pos = ReadPosOf(rw_positions); + reservation.read_pos_for_wait = read_pos; + + if (NumOutstandingPositions(write_pos, read_pos) >= num_chunks_) { + reservation.result = ReserveResult::kFull; + return reservation; + } + + // (write_pos, read_pos) -> (write_pos + 1, read_pos). + // + // On failure, no position is reserved. The CAS stores the current write_pos + // and read_pos in the local rw_positions value. The loop rechecks capacity + // before another attempt. A competing update can come from: + // - Another writer that advances write_pos. + // - The reader that publishes read_pos. + // + // compare_exchange_weak can also fail spuriously. + // + // Proposed memory ordering: + // - Success: acquire to observe the Free words published with read_pos. + // - Failure: acquire for the same reason. The refreshed read_pos feeds + // the next capacity check. + if (ring_header->rw_positions.compare_exchange_weak( + rw_positions, PackRwPositions(write_pos + 1, read_pos))) { + reservation.result = ReserveResult::kReserved; + reservation.chunk_pos = write_pos; + return reservation; + } + } +} + +// --- Writer-side chunk transitions. --- + +bool SharedRingBuffer::TryAcquireChunkForWriting(uint32_t chunk_pos, + uint32_t being_written_word) { + PERFETTO_DCHECK(ChunkStateOf(being_written_word) == + ChunkState::kBeingWritten); + PERFETTO_DCHECK(NumFragmentsOf(being_written_word) == 0); + + // Free(wrap_count(chunk_pos)) -> BeingWritten(0). + // + // On failure, the chunk does not match this reservation's Free word: + // - The reader advanced the wrap count before this writer claimed the chunk. + // - A writer from an earlier reservation still owns the physical chunk, or + // the reader has not reclaimed its RewriteAcknowledged state yet. + // + // The caller must reserve a new position. A retry against the returned word + // can claim a consumed position or overwrite another writer's chunk. + // + // Proposed memory ordering: + // - Success: acquire to observe the reader's release of Free. + // The reader must finish copying before this writer overwrites the chunk. + // - Failure: relaxed because the returned word is ignored. + uint32_t expected = MakeFreeStateWordForPosition(chunk_pos, num_chunks_); + std::atomic* state_word = chunk_state_word_for_position(chunk_pos); + return state_word->compare_exchange_strong(expected, being_written_word); +} + +bool SharedRingBuffer::TryReleaseChunkAsComplete(ChunkIndex chunk_idx, + uint32_t complete_word, + uint32_t* expected) { + PERFETTO_DCHECK(ChunkStateOf(*expected) == ChunkState::kBeingWritten); + PERFETTO_DCHECK(ChunkStateOf(complete_word) == ChunkState::kComplete); + + // BeingWritten(N) -> Complete(M). + // + // On failure, the reader requested a rewrite first. |*expected| receives + // RewriteRequested(N), and the caller relocates any unpublished fragment. + // + // Proposed memory ordering: + // - Success: release to publish M fragments and their sizes. + // The first publication also makes BufferID visible. + // - Failure: acquire to observe the reader's RewriteRequested(N). + // The reader must finish copying N fragments before the writer relocates. + std::atomic* state_word = chunk_state_word_at(chunk_idx); + return state_word->compare_exchange_strong(*expected, complete_word); +} + +bool SharedRingBuffer::TryReacquireChunkForWriting(ChunkIndex chunk_idx, + uint32_t observed) { + PERFETTO_DCHECK(ChunkStateOf(observed) == ChunkState::kComplete); + + // Complete(N) -> BeingWritten(N). + // + // On failure, the reader reclaimed the chunk first. The writer discards its + // cached handle and acquires another chunk. + // + // Proposed memory ordering: + // - Success: relaxed because reuse publishes no new bytes. + // The read-modify-write extends Complete(N)'s release sequence. + // The reader's acquire load still sees the N published fragments. + // - Failure: relaxed because the returned word is ignored. + uint32_t expected = observed; + std::atomic* state_word = chunk_state_word_at(chunk_idx); + return state_word->compare_exchange_strong( + expected, ReplaceChunkState(observed, ChunkState::kBeingWritten)); +} + +bool SharedRingBuffer::TryAcknowledgeRewrite(ChunkIndex chunk_idx, + uint32_t observed) { + PERFETTO_DCHECK(ChunkStateOf(observed) == ChunkState::kRewriteRequested); + + // RewriteRequested -> RewriteAcknowledged, with all other bits zero. + // + // On failure, report a protocol error. Only this writer can change + // RewriteRequested, so the observed word must still match. + // + // Proposed memory ordering: + // - Success: release to save the unpublished fragment before + // acknowledgement. The reader can then reclaim the chunk. + // - Failure: relaxed because it only reports a protocol error. + uint32_t expected = observed; + std::atomic* state_word = chunk_state_word_at(chunk_idx); + return state_word->compare_exchange_strong(expected, + kRewriteAcknowledgedStateWord); +} + +// --- Reader-side chunk transitions. --- + +uint32_t SharedRingBuffer::LoadChunkStateWordAcquire( + ChunkIndex chunk_idx) const { + // The acquire load pairs with the writer's release publication of fragments + // and their sizes. The first publication also makes BufferID visible. + // + // If the writer reuses Complete(N) as BeingWritten(N), its CAS preserves the + // fragment count and extends the release sequence. This load still makes + // those N fragments, their sizes and BufferID visible when N is nonzero. + return chunk_state_word_at(chunk_idx)->load(std::memory_order_acquire); +} + +uint32_t SharedRingBuffer::LoadWritePosRelaxed() const { + // This bounds the reader's pass. It does not show whether each reservation + // has published data. LoadChunkStateWordAcquire() provides that information. + return WritePosOf(header()->rw_positions.load(std::memory_order_relaxed)); +} + +uint32_t SharedRingBuffer::LoadNumOutstandingPositionsRelaxed() const { + const uint64_t rw_positions = + header()->rw_positions.load(std::memory_order_relaxed); + return NumOutstandingPositions(WritePosOf(rw_positions), + ReadPosOf(rw_positions)); +} + +bool SharedRingBuffer::TryRequestRewrite(ChunkIndex chunk_idx, + uint32_t* expected) { + PERFETTO_DCHECK(ChunkStateOf(*expected) == ChunkState::kBeingWritten); + + // BeingWritten(N) -> RewriteRequested(N). + // |*expected| is the word the reader used to copy the N fragments. + // + // On failure, the writer published first. The reader discards its copy and + // retries this position immediately in Drain() to include the new fragments. + // + // Proposed memory ordering: + // - Success: release to finish that copy before the writer observes + // RewriteRequested and relocates its unpublished fragment. + // - Failure: relaxed because the copy is discarded. The next attempt + // acquire-loads the state word again before reading any payload. + std::atomic* state_word = chunk_state_word_at(chunk_idx); + return state_word->compare_exchange_strong( + *expected, ReplaceChunkState(*expected, ChunkState::kRewriteRequested)); +} + +bool SharedRingBuffer::TryMoveFreeChunkToNextWrap(uint32_t chunk_pos, + uint32_t* expected) { + PERFETTO_DCHECK(ChunkStateOf(*expected) == ChunkState::kFree); + + // Free(wrap_count(chunk_pos)) -> Free(next wrap). + // + // On failure, the delayed writer claimed the chunk first. The reader retries + // this position immediately in Drain() to consume BeingWritten or Complete. + // + // Proposed memory ordering: + // - Success: release to publish the next Free wrap to a claiming writer. + // - Failure: relaxed because the next attempt acquire-loads the state + // word again before reading any payload. + std::atomic* state_word = chunk_state_word_for_position(chunk_pos); + return state_word->compare_exchange_strong( + *expected, MakeFreeWordForNextWrap(chunk_pos)); +} + +bool SharedRingBuffer::TryReleaseCompleteChunkAsFree(uint32_t chunk_pos, + uint32_t* expected) { + PERFETTO_DCHECK(ChunkStateOf(*expected) == ChunkState::kComplete); + + // Complete(N) -> Free(next wrap). + // |*expected| is the word the reader used to copy the N fragments. + // + // On failure, the writer reused the chunk first. It can also publish more + // fragments before the reader retries, so the N-fragment copy can be stale. + // Drain() reloads the state and copies the current published fragments. + // If the state is BeingWritten, the reader then requests a rewrite. + // Otherwise, it tries to release Complete again. The reader delivers the + // copy only after a successful transition, so retries cannot duplicate data. + // + // Proposed memory ordering: + // - Success: release to finish the copy before another writer acquires + // Free and overwrites the chunk. + // - Failure: relaxed because the copy is discarded. The next attempt + // acquire-loads the state word again before reading any payload. + std::atomic* state_word = chunk_state_word_for_position(chunk_pos); + return state_word->compare_exchange_strong( + *expected, MakeFreeWordForNextWrap(chunk_pos)); +} + +bool SharedRingBuffer::TryReleaseRewriteAcknowledgedChunkAsFree( + uint32_t chunk_pos, + uint32_t* observed) { + // RewriteAcknowledged -> Free(next wrap). + // The expected word contains only the RewriteAcknowledged state bits. + // + // On failure, |*observed| receives the unexpected word. This is a protocol + // error because only this reader can change an acknowledged chunk. + // + // Proposed memory ordering: + // - Success: acq_rel for two handoffs: + // - Acquire observes the writer's acknowledgement after it saves its + // unpublished fragment. + // - Release passes the chunk to the next writer after that copy. + // - Failure: relaxed because the returned word only diagnoses the + // protocol error. + uint32_t expected = kRewriteAcknowledgedStateWord; + std::atomic* state_word = chunk_state_word_for_position(chunk_pos); + const bool reclaimed = state_word->compare_exchange_strong( + expected, MakeFreeWordForNextWrap(chunk_pos)); + if (PERFETTO_UNLIKELY(!reclaimed)) + *observed = expected; + return reclaimed; +} + +// --- Backpressure. --- + +SharedRingBuffer::WriterWaitResult SharedRingBuffer::WaitForReadPosChange( + uint32_t read_pos_for_wait, + uint32_t timeout_ms) { + PERFETTO_DCHECK(timeout_ms > 0); + if (!SupportsWriterWait()) + return WriterWaitResult::kUnavailable; + + RingBufferHeader* ring_header = header(); + + // To avoid a missed wake: + // - the writer counts itself as waiting before checking read_pos. + // - the reader publishes read_pos before checking the waiter count. + // + // The fences order each update before the other side's check. Together + // they prevent both checks from seeing an older value: + // + // writer reader + // ------ ------ + // num_writers_waiting += 1 publish read_pos + // seq_cst fence seq_cst fence + // load read_pos load num_writers_waiting + // FutexWait if unchanged FutexWake if nonzero + // + // - Writer's fence first: the reader sees the waiter and wakes it. + // - Reader's fence first: the writer sees the new read_pos. + // It does not sleep. + // + // num_writers_waiting is only a wake hint, so its accesses use relaxed order. + ring_header->num_writers_waiting.fetch_add(1, std::memory_order_relaxed); + std::atomic_thread_fence(std::memory_order_seq_cst); + + WriterWaitResult result = WriterWaitResult::kRetry; + const uint32_t read_pos = + ReadPosOf(ring_header->rw_positions.load(std::memory_order_relaxed)); + if (read_pos == read_pos_for_wait) { + // FutexWait checks the value again before sleeping. If read_pos changed + // after the load above, the call returns kValueMismatch and no wake is + // lost. + // + // Every result other than kError means "recheck capacity". + const base::FutexWaitResult wait_result = + base::FutexWait(ReadPosFutexAddress(&ring_header->rw_positions), + read_pos_for_wait, timeout_ms); + result = wait_result == base::FutexWaitResult::kError + ? WriterWaitResult::kUnavailable + : WriterWaitResult::kRetry; + } + + ring_header->num_writers_waiting.fetch_sub(1, std::memory_order_relaxed); + return result; +} + +void SharedRingBuffer::PublishReadPos(uint32_t read_pos) { + // This load only supplies the initial expected value for the CAS below. + PublishReadPosFromSnapshot( + header()->rw_positions.load(std::memory_order_relaxed), read_pos); +} + +void SharedRingBuffer::PublishReadPosFromSnapshot(uint64_t rw_positions, + uint32_t read_pos) { + RingBufferHeader* ring_header = header(); + + // (write_pos, old read_pos) -> (write_pos, read_pos). + // + // On failure, the CAS stores the current positions in the local rw_positions. + // A writer can advance write_pos first, or compare_exchange_weak can fail + // spuriously. The loop preserves that write_pos and retries the read_pos + // update. + // + // Proposed memory ordering: + // - Success: release so writers that acquire the new read_pos also see + // this pass's Free words. + // - Failure: relaxed because the returned word only supplies the next + // CAS attempt. No payload access depends on it. + while (!ring_header->rw_positions.compare_exchange_weak( + rw_positions, ReplaceReadPos(rw_positions, read_pos))) { + } + + if (!SupportsWriterWait()) + return; + + // See the missed-wake schedule in WaitForReadPosChange(). The fence + // orders read_pos publication before the waiter-count load. + std::atomic_thread_fence(std::memory_order_seq_cst); + + if (ring_header->num_writers_waiting.load(std::memory_order_relaxed) == 0) + return; -} // namespace perfetto + // Wake everyone because one drain pass can free many chunks. Waking one + // writer could leave capacity unused. + // + // This runs once per pass rather than once per reclaimed chunk. + // + // Waits are bounded, so a failed wake delays writers but cannot strand them. + base::FutexWake(ReadPosFutexAddress(&ring_header->rw_positions), INT_MAX); +} -#endif // SRC_TRACING_SERVICE_ZLIB_COMPRESSOR_H_ +} // namespace perfetto::tracing_v2 +// gen_amalgamated begin source: src/tracing/v2/shared_ring_buffer_reader.cc +// gen_amalgamated begin header: src/tracing/v2/shared_ring_buffer_reader.h /* - * Copyright (C) 2023 The Android Open Source Project + * Copyright (C) 2026 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -59550,149 +66420,593 @@ void ZlibCompressFn(std::vector*); * limitations under the License. */ -// gen_amalgamated expanded: #include "src/tracing/service/zlib_compressor.h" +#ifndef SRC_TRACING_V2_SHARED_RING_BUFFER_READER_H_ +#define SRC_TRACING_V2_SHARED_RING_BUFFER_READER_H_ -// gen_amalgamated expanded: #include "perfetto/base/build_config.h" +#include -// File compiles to nothing when the buildflag is off (e.g. SDK opt-out). -#if PERFETTO_BUILDFLAG(PERFETTO_ZLIB) +#include +#include -#include +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h" +// gen_amalgamated expanded: #include "perfetto/protozero/field.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_abi.h" -// gen_amalgamated expanded: #include "protos/perfetto/trace/trace.pbzero.h" -// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h" -// gen_amalgamated expanded: #include "src/tracing/service/packet_compressor_common.h" +namespace perfetto::tracing_v2 { -namespace perfetto { +namespace test { +class SharedRingBufferInternalsForTest; +} -namespace { +// Reads packet fragments from one SharedRingBuffer. +// +// - Use each instance from one execution context. The ring buffer's storage and +// SharedRingBuffer view must outlive the reader. +// - Reservations are consumed in order. A relocated fragment gets a later +// reservation. +// - The reader never waits for a writer, but may retry when it loses a +// concurrent state transition. +// - If a writer still owns a chunk, the reader copies its published fragments. +// This is a partial chunk read. The writer moves its unpublished fragment to +// a later reservation. +// - A chunk marked kFlagDataLoss is consumed without delivering its fragments. +// The delegate receives a loss report instead. +// - Fragment sizes are decoded once into reader-owned values, and the payload +// copy uses those values without rereading the shared size bytes. The +// delegate only ever sees reader-owned scratch, never a view of +// producer-controlled shared memory. +class SharedRingBufferReader { + public: + // Result of consuming one position. + enum class ConsumeResult { + // No reservation at read_pos is visible yet. + // read_pos has caught up with the observed write_pos. + kNoData, + // A chunk was handed to the delegate and read_pos advanced. + kChunkRead, + // No payload was delivered. read_pos advanced and data can no longer be + // published for this position. + kPositionSkipped, + // A writer changed the chunk before the reader's CAS: + // - Claimed Free before the reader advanced its wrap count. + // - Published Complete before the reader requested a rewrite. + // - Reused Complete before the reader reclaimed it. + // read_pos stays unchanged. Drain() retries the same position immediately, + // within its per-position attempt limit. + kRetryImmediately, + // Invalid ring buffer state. This reader cannot continue. + // - The offending position is neither advanced nor reclaimed. + // - Earlier chunks in this drain may already have been delivered. + // - Drain() still publishes any progress made before the error. + kProtocolError, + }; -using packet_compressor::GetPreamble; -using packet_compressor::kCompressSliceSize; -using packet_compressor::Preamble; -using packet_compressor::PreambleToSlice; + struct ChunkContents { + WriterID writer_id = 0; + BufferID target_buffer = 0; + // A bitwise OR of PayloadFlags. + uint32_t payload_flags = 0; + // A view into reader-owned scratch. Valid only for the duration of the + // Delegate call. + const protozero::ConstBytes* fragments = nullptr; + uint32_t num_fragments = 0; + }; -// A compressor for `TracePacket`s that uses zlib. The class is exposed for -// testing. -class ZlibPacketCompressor { - public: - ZlibPacketCompressor(); - ~ZlibPacketCompressor(); + struct DrainResult { + uint32_t positions_consumed = 0; + ConsumeResult last_result = ConsumeResult::kNoData; - // Can be called multiple times, before Finish() is called. - void PushPacket(const TracePacket& packet); + // The caller should schedule another Drain() call. + bool needs_another_drain() const { + return last_result != ConsumeResult::kNoData && + last_result != ConsumeResult::kProtocolError; + } + }; - // Returned the compressed data. Can be called at most once. After this call, - // the object is unusable (PushPacket should not be called) and must be - // destroyed. - TracePacket Finish(); + // Handles the drained fragments and loss reports. Must outlive the reader. + // Calls run synchronously from Drain() and must not reenter or destroy the + // reader. + class Delegate { + public: + virtual ~Delegate(); + + // Called after a chunk's published payload has been copied into + // reader-owned memory. The view is valid only for this call. + virtual void OnChunkRead(const ChunkContents&) = 0; + + // Called when published data is discarded after validation fails or the + // chunk carries kFlagDataLoss. Also handles a flagged Complete chunk with + // no fragments. No OnChunkRead() call delivers those fragments. + // + // The delegate must handle packet recovery for this writer: + // - Discard any partial packet and remember the gap. + // - A later unflagged chunk may start with an orphan continuation. + // Discard that fragment because its earlier bytes were lost. + // - Later fragments in that chunk can start complete, valid packets. + // Deliver those packets and report the gap on the first one. + virtual void OnDataLoss(WriterID) = 0; + }; + + SharedRingBufferReader(SharedRingBuffer* ring, Delegate* delegate); + ~SharedRingBufferReader(); + + SharedRingBufferReader(const SharedRingBufferReader&) = delete; + SharedRingBufferReader& operator=(const SharedRingBufferReader&) = delete; + SharedRingBufferReader(SharedRingBufferReader&&) = delete; + SharedRingBufferReader& operator=(SharedRingBufferReader&&) = delete; + + // Consumes up to |max_positions| logical reservations: + // - A position counts even when it delivers no fragments. + // - An unclaimed reservation uses the budget when the reader passes it. + // - A lost CAS retries the same position without using the position budget. + // A separate attempt limit bounds retries at each position. Reaching it + // leaves that position unchanged and requests another drain. + // + // Publishes read_pos once and wakes writers parked on a full ring buffer. + // The budget bounds copying and delegate callbacks in this pass. + // This lets other tasks run between passes over a large ring buffer. + DrainResult Drain(uint32_t max_positions); + + bool has_protocol_error() const { return has_protocol_error_; } + uint32_t read_pos() const { return read_pos_; } + + // For diagnostics only. The protocol never reads these counters. + // TODO(sashwinbalaji): Wire these counters into service statistics. + struct Stats { + uint64_t positions_skipped = 0; + // Successful BeingWritten -> RewriteRequested transitions. + uint64_t rewrite_requests = 0; + uint64_t chunks_read = 0; + uint64_t malformed_chunks = 0; + uint64_t unsupported_format_chunks = 0; + }; + Stats GetStats() const { return stats_; } private: - void PushData(const void* data, uint32_t size); - void NewOutputSlice(); - void PushCurSlice(); + friend class test::SharedRingBufferInternalsForTest; - z_stream stream_; - size_t total_new_slices_size_ = 0; - std::vector new_slices_; - std::unique_ptr cur_slice_; -}; + // Consumes at most one position. Drain() publishes read_pos once per pass. + ConsumeResult ConsumeNextPosition(); -ZlibPacketCompressor::ZlibPacketCompressor() { - memset(&stream_, 0, sizeof(stream_)); - int status = deflateInit(&stream_, 6); - PERFETTO_CHECK(status == Z_OK); -} + enum class CopiedChunkStatus { + kNoFragments, + kReady, + kMalformed, + kUnsupportedFormat, + kDataLoss, + }; -ZlibPacketCompressor::~ZlibPacketCompressor() { - int status = deflateEnd(&stream_); - PERFETTO_CHECK(status == Z_OK); -} + // Validates and copies the published fragments. + // Skips payload access if kFlagDataLoss is set. Otherwise validates sizes + // and format before copying. + // The caller handles ownership before reporting any data loss. + CopiedChunkStatus CopyPublishedFragments(ChunkIndex chunk_idx, + uint32_t state_word); + + // Called only after winning the position's compare-and-swap. + // Delivers valid, unflagged fragments to the delegate. Reports discarded + // chunks as loss. + ConsumeResult HandleCopiedChunk(CopiedChunkStatus); + + // Latches the error and logs |reason| once, together with the position and + // the offending word. read_pos is not advanced. + ConsumeResult StopOnProtocolError(const char* reason, uint32_t state_word); + + SharedRingBuffer* const ring_; + Delegate* const delegate_; + const uint32_t num_chunks_; + const uint32_t chunk_size_; + + // The reader owns this value and publishes it once per Drain(). + uint32_t read_pos_ = 0; + bool has_protocol_error_ = false; + + // Test callback, called just before the reader's chunk-state CAS. + // - The reader has loaded the state and copied any readable fragments. + // - The callback makes a writer claim, publish or reuse the chunk. + // The reader's CAS then fails because it expects the earlier state. + // - Tests verify that Drain() retries without advancing read_pos or + // delivering fragments from the failed attempt. + // Empty in production. Tests force the race without scheduling threads. + std::function before_state_transition_for_testing_; + + // TODO(sashwinbalaji): Revisit both scratch vectors: + // - Check heap/stack allocation in production and tests before enlarging + // the reader with inline std::array members. + // - copied_payload_: establish a common maximum chunk size, then use a byte + // array of that size. + // - copied_fragments_: use kMaxFragmentsPerChunk inline ConstBytes entries. + // - Measure whether this + offset access improves the read/copy path over + // following pointers to separate vector allocations. + + // Published fragment bytes copied out of shared memory. + std::vector copied_payload_; + + // Each fragment's decoded size and pointer into copied_payload_. + std::vector copied_fragments_; + + // Chunk metadata and a view of copied_fragments_ passed to OnChunkRead(). + ChunkContents copied_chunk_; + + Stats stats_; +}; -void ZlibPacketCompressor::PushPacket(const TracePacket& packet) { - // We need to be able to tokenize packets in the compressed stream, so we - // prefix a proto preamble to each packet. The compressed stream looks like a - // valid Trace proto. - Preamble preamble = - GetPreamble(packet.size()); - PushData(preamble.buf.data(), preamble.size); - for (const Slice& slice : packet.slices()) { - PushData(slice.start, static_cast(slice.size)); - } -} +} // namespace perfetto::tracing_v2 -void ZlibPacketCompressor::PushData(const void* data, uint32_t size) { - stream_.next_in = const_cast(static_cast(data)); - stream_.avail_in = static_cast(size); - while (stream_.avail_in != 0) { - if (stream_.avail_out == 0) { - NewOutputSlice(); - } - int status = deflate(&stream_, Z_NO_FLUSH); - PERFETTO_CHECK(status == Z_OK); - } -} +#endif // SRC_TRACING_V2_SHARED_RING_BUFFER_READER_H_ +/* + * Copyright (C) 2026 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ -TracePacket ZlibPacketCompressor::Finish() { - for (;;) { - int status = deflate(&stream_, Z_FINISH); - if (status == Z_STREAM_END) - break; - PERFETTO_CHECK(status == Z_OK || status == Z_BUF_ERROR); - NewOutputSlice(); - } +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_reader.h" - PushCurSlice(); +#include - TracePacket packet; - packet.AddSlice(PreambleToSlice( - GetPreamble( - total_new_slices_size_))); - for (auto& slice : new_slices_) { - packet.AddSlice(std::move(slice)); - } - return packet; -} +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_abi.h" -void ZlibPacketCompressor::NewOutputSlice() { - PushCurSlice(); - cur_slice_ = std::make_unique(kCompressSliceSize); - stream_.next_out = reinterpret_cast(cur_slice_.get()); - stream_.avail_out = kCompressSliceSize; -} +namespace perfetto::tracing_v2 { +namespace { -void ZlibPacketCompressor::PushCurSlice() { - if (cur_slice_) { - total_new_slices_size_ += kCompressSliceSize - stream_.avail_out; - new_slices_.push_back(Slice::TakeOwnership( - std::move(cur_slice_), kCompressSliceSize - stream_.avail_out)); - } +// Bound attempts at one position. For M = kMaxFragmentsPerChunk: +// - Each fragment can defeat the reader's CAS twice: +// 1. Publication: BeingWritten(N) -> Complete(N + 1). +// 2. Reuse: Complete(N + 1) -> BeingWritten(N + 1). +// Allow M attempts for each, giving 2 * M. +// - Add one for the initial Free -> BeingWritten claim. +// - Add one for the reader's successful CAS, giving 2 * M + 2. +// +// This is conservative. SharedRingBufferWriter stops reusing at M fragments, +// so there are at most M - 1 reuses. Zero-byte fragments still use the count. +// FinishCurrentChunk() drops the cached handle even when abandoning a fragment. +// The limit also bounds work if another producer keeps changing the state +// without increasing the fragment count. +constexpr uint32_t kMaxAttemptsPerPosition = 2 * kMaxFragmentsPerChunk + 2; + +// For the protocol-error log only. +const char* ChunkStateName(ChunkState state) { + switch (state) { + case ChunkState::kFree: + return "Free"; + case ChunkState::kBeingWritten: + return "BeingWritten"; + case ChunkState::kComplete: + return "Complete"; + case ChunkState::kRewriteRequested: + return "RewriteRequested"; + case ChunkState::kRewriteAcknowledged: + return "RewriteAcknowledged"; + case ChunkState::kReserved5: + case ChunkState::kReserved6: + case ChunkState::kReserved7: + return "reserved"; + } + return "unknown"; } } // namespace -void ZlibCompressFn(std::vector* packets) { - if (packets->empty()) { - return; +SharedRingBufferReader::Delegate::~Delegate() = default; + +SharedRingBufferReader::SharedRingBufferReader(SharedRingBuffer* ring, + Delegate* delegate) + : ring_(ring), + delegate_(delegate), + num_chunks_(ring->num_chunks()), + chunk_size_(ring->chunk_size()) { + // Reserve enough scratch for any chunk format so draining does not allocate. + copied_payload_.reserve(chunk_size_); + copied_fragments_.reserve(kMaxFragmentsPerChunk); +} + +SharedRingBufferReader::~SharedRingBufferReader() = default; + +SharedRingBufferReader::DrainResult SharedRingBufferReader::Drain( + uint32_t max_positions) { + const uint32_t start_pos = read_pos_; + DrainResult result{}; + for (uint32_t i = 0; i < max_positions; ++i) { + // A failed CAS leaves read_pos_ unchanged. Retry the same position with + // a fresh state and fragment copy before it counts towards max_positions. + // Limit attempts so repeated writer updates cannot monopolize this pass. + for (uint32_t attempt = 0; attempt < kMaxAttemptsPerPosition; ++attempt) { + result.last_result = ConsumeNextPosition(); + if (result.last_result != ConsumeResult::kRetryImmediately) + break; + } + // If every attempt lost, yield with another drain requested. Contention + // alone is not a protocol error. Publish earlier progress below. + if (result.last_result != ConsumeResult::kChunkRead && + result.last_result != ConsumeResult::kPositionSkipped) { + break; + } } - ZlibPacketCompressor stream; - - for (const TracePacket& packet : *packets) { - stream.PushPacket(packet); + // Unsigned subtraction also counts positions across uint32_t rollover. + // Advancing from UINT32_MAX to zero consumes one position. + result.positions_consumed = read_pos_ - start_pos; + if (result.positions_consumed != 0) { + // One publication and at most one wake cover the whole pass. Until this + // point writers can only under-estimate free capacity. + // + // TODO(sashwinbalaji): benchmark useful publication batch sizes. + ring_->PublishReadPos(read_pos_); } + return result; +} - TracePacket packet = stream.Finish(); +// The shared lifecycle is in shared_ring_buffer_abi.h. +// +// The races this function has to handle: +// +// 1. Free: advance to the next wrap, racing the delayed writer's claim. +// 2. BeingWritten: copy N fragments, then request RewriteRequested(N), racing +// the writer's publication of Complete(M). +// 3. Complete: copy the fragments, then reclaim, racing the writer's reuse. +// 4. RewriteRequested: skip. The writer still owns the chunk. Once it becomes +// RewriteAcknowledged, only the reader may reclaim it on a later traversal. +// +// In the first three cases, a failed CAS leaves read_pos unchanged. Drain() +// retries immediately. Deliver the copy only after a successful transition, +// so a retry cannot deliver the same fragments twice. +// +// RewriteAcknowledged has no competing writer transition. On failure to reclaim +// it, report a protocol error. +SharedRingBufferReader::ConsumeResult +SharedRingBufferReader::ConsumeNextPosition() { + if (PERFETTO_UNLIKELY(has_protocol_error_)) + return ConsumeResult::kProtocolError; + + // A relaxed load is enough here. An older write_pos only shortens this + // drain pass, which is still correct. A later pass can consume the rest. + const uint32_t write_pos = ring_->LoadWritePosRelaxed(); + const uint32_t outstanding = NumOutstandingPositions(write_pos, read_pos_); + if (outstanding == 0) + return ConsumeResult::kNoData; + if (PERFETTO_UNLIKELY(outstanding > num_chunks_)) { + // A legal writer cannot reserve more than num_chunks outstanding + // positions. + has_protocol_error_ = true; + PERFETTO_ELOG( + "tracing v2: stopping ring buffer reader: write_pos %u is %u " + "positions ahead of read_pos %u, which is more than the %u chunks " + "in the ring buffer", + write_pos, outstanding, read_pos_, num_chunks_); + return ConsumeResult::kProtocolError; + } + + // read_pos_ is the next logical position. + const uint32_t chunk_pos = read_pos_; + const ChunkIndex chunk_idx = ChunkIndex::FromPosition(chunk_pos, num_chunks_); + + // A failed compare-and-swap replaces this with the word that won. + uint32_t state_word = ring_->LoadChunkStateWordAcquire(chunk_idx); + + switch (ChunkStateOf(state_word)) { + case ChunkState::kFree: { + // Check reserved bits first. Reclaiming must not hide an invalid word. + if (PERFETTO_UNLIKELY((state_word & ~kWriterIDMask) != 0)) + return StopOnProtocolError("Free word has reserved bits", state_word); + // Only this reader advances the wrap. A different wrap here is an error. + const uint32_t expected_free_word = + MakeFreeStateWordForPosition(chunk_pos, num_chunks_); + if (PERFETTO_UNLIKELY(state_word != expected_free_word)) { + return StopOnProtocolError( + "Free word carries another position's wrap count", state_word); + } + if (before_state_transition_for_testing_) + before_state_transition_for_testing_(); + // Advance the wrap count to consume this unclaimed reservation. + // On failure, the delayed writer claimed first. Drain() retries this + // position with the writer's BeingWritten or Complete state. + if (!ring_->TryMoveFreeChunkToNextWrap(chunk_pos, &state_word)) + return ConsumeResult::kRetryImmediately; + ++read_pos_; + ++stats_.positions_skipped; + return ConsumeResult::kPositionSkipped; + } + + case ChunkState::kBeingWritten: { + const auto status = CopyPublishedFragments(chunk_idx, state_word); + if (before_state_transition_for_testing_) + before_state_transition_for_testing_(); + // Request a rewrite before read_pos_ advances, even if validation failed. + // On failure, the writer published first. Drain() retries with a fresh + // copy before it delivers fragments or reports loss for this position. + if (!ring_->TryRequestRewrite(chunk_idx, &state_word)) + return ConsumeResult::kRetryImmediately; + ++read_pos_; + ++stats_.rewrite_requests; + return HandleCopiedChunk(status); + } + + case ChunkState::kComplete: { + const auto status = CopyPublishedFragments(chunk_idx, state_word); + if (before_state_transition_for_testing_) + before_state_transition_for_testing_(); + // Reclaim the chunk before read_pos_ advances, even if validation failed. + // On failure, the writer reused the chunk and can publish more fragments. + // Drain() reloads the state and copies the current published fragments. + // If the state is BeingWritten, that attempt requests a rewrite. + // Deliver fragments or report loss only after a successful transition. + if (!ring_->TryReleaseCompleteChunkAsFree(chunk_pos, &state_word)) + return ConsumeResult::kRetryImmediately; + ++read_pos_; + // Report loss even if the Complete chunk has no fragments. The writer + // cannot reuse the reclaimed chunk, so no later publication can report + // its flag. + // + // For BeingWritten(0), the writer still owns the chunk and transfers + // kFlagDataLoss to the relocated fragment instead. + if (status == CopiedChunkStatus::kNoFragments && + (copied_chunk_.payload_flags & kFlagDataLoss)) { + delegate_->OnDataLoss(copied_chunk_.writer_id); + } + return HandleCopiedChunk(status); + } - packets->clear(); - packets->push_back(std::move(packet)); + case ChunkState::kRewriteRequested: + // This chunk is still awaiting rewrite acknowledgement from its owner. + // The current reservation could not claim it. Advance read_pos without + // changing the chunk's state word or delivering fragments. + ++read_pos_; + ++stats_.positions_skipped; + return ConsumeResult::kPositionSkipped; + + case ChunkState::kRewriteAcknowledged: + // Reclaim the chunk before advancing past this unclaimed reservation. + // No fragments are delivered. The chunk becomes available for a later + // reservation. + // + // The expected word contains only the RewriteAcknowledged state bits. + // Only this reader can change it after the writer's acknowledgement. + // On failure, the word was invalid or another actor changed it. + if (!ring_->TryReleaseRewriteAcknowledgedChunkAsFree(chunk_pos, + &state_word)) { + return StopOnProtocolError( + ChunkStateOf(state_word) == ChunkState::kRewriteAcknowledged + ? "RewriteAcknowledged word has payload bits set" + : "RewriteAcknowledged word changed under the reader", + state_word); + } + ++read_pos_; + ++stats_.positions_skipped; + return ConsumeResult::kPositionSkipped; + + case ChunkState::kReserved5: + case ChunkState::kReserved6: + case ChunkState::kReserved7: + // The reader cannot safely reclaim an unknown state. + return StopOnProtocolError("reserved chunk state", state_word); + } + PERFETTO_FATAL("tracing v2: unhandled chunk state word 0x%08x", state_word); +} + +SharedRingBufferReader::CopiedChunkStatus +SharedRingBufferReader::CopyPublishedFragments(ChunkIndex chunk_idx, + uint32_t state_word) { + copied_fragments_.clear(); + copied_chunk_ = ChunkContents{}; + copied_chunk_.writer_id = WriterIDOf(state_word); + copied_chunk_.payload_flags = PayloadFlagsOf(state_word); + + const uint32_t num_fragments = NumFragmentsOf(state_word); + if (num_fragments == 0) { + // A writer may still be storing BufferID after claiming BeingWritten(0). + // Only its first fragment publication makes that store visible. Do not + // touch any bytes beyond the state word when no fragment is published. + return CopiedChunkStatus::kNoFragments; + } + + // The loss flag does not identify where data was lost within the chunk. + // - Drop every published fragment, even a complete packet after the gap. + // - Do not read an unpublished fragment. The writer may relocate it. + // The caller must win the state transition before reporting the gap or + // advancing read_pos. See Delegate::OnDataLoss() for packet recovery. + if (state_word & kFlagDataLoss) + return CopiedChunkStatus::kDataLoss; + + if (ChunkFormatOf(state_word) != ChunkFormat::kTargetBuffer) + return CopiedChunkStatus::kUnsupportedFormat; + + // Decode first to find the payload end and the directory start. + // Until then, payload_begin is the decoder's lower bound. It prevents size + // reads from reaching the header, but does not prove the payload fits. + const uint32_t capacity = chunk_size_ - kTargetBufferPayloadOffset; + const uint8_t* chunk = ring_->chunk_at(chunk_idx); + const uint8_t* const payload_begin = chunk + kTargetBufferPayloadOffset; + const uint8_t* sizes_cursor = chunk + chunk_size_; + uint32_t total = 0; + for (uint32_t i = 0; i < num_fragments; ++i) { + const auto fragment_size = + ReadFragmentSizeReversed(payload_begin, &sizes_cursor); + if (!fragment_size || *fragment_size > capacity - total) { + return CopiedChunkStatus::kMalformed; + } + total += *fragment_size; + copied_fragments_.push_back(protozero::ConstBytes{nullptr, *fragment_size}); + } + + // The sizes are valid varints. Their payloads may still overlap the + // directory: + // - Count the bytes actually read, including non-minimal size encodings. + // - On overlap, reject the chunk before copying or delivering any payload. + // - sizes_cursor is local to this read attempt. Returning discards it. + // No cursor change needs to be undone. + const uint32_t sizes_bytes = + static_cast(chunk + chunk_size_ - sizes_cursor); + if (total > capacity - sizes_bytes) + return CopiedChunkStatus::kMalformed; + + // Copy the published payload out of shared memory. + copied_payload_.assign(payload_begin, payload_begin + total); + + // Point each fragment at its copy and collect the chunk metadata. + size_t offset = 0; + for (protozero::ConstBytes& fragment : copied_fragments_) { + fragment.data = copied_payload_.data() + offset; + offset += fragment.size; + } + copied_chunk_.target_buffer = LoadTargetBufferId(chunk); + copied_chunk_.fragments = copied_fragments_.data(); + copied_chunk_.num_fragments = num_fragments; + return CopiedChunkStatus::kReady; +} + +SharedRingBufferReader::ConsumeResult SharedRingBufferReader::HandleCopiedChunk( + CopiedChunkStatus status) { + switch (status) { + case CopiedChunkStatus::kReady: + ++stats_.chunks_read; + delegate_->OnChunkRead(copied_chunk_); + return ConsumeResult::kChunkRead; + case CopiedChunkStatus::kMalformed: + ++stats_.malformed_chunks; + delegate_->OnDataLoss(copied_chunk_.writer_id); + break; + case CopiedChunkStatus::kUnsupportedFormat: + ++stats_.unsupported_format_chunks; + delegate_->OnDataLoss(copied_chunk_.writer_id); + break; + case CopiedChunkStatus::kDataLoss: + delegate_->OnDataLoss(copied_chunk_.writer_id); + break; + case CopiedChunkStatus::kNoFragments: + break; + } + + ++stats_.positions_skipped; + return ConsumeResult::kPositionSkipped; } -} // namespace perfetto +SharedRingBufferReader::ConsumeResult +SharedRingBufferReader::StopOnProtocolError(const char* reason, + uint32_t state_word) { + // Stop rather than trusting a malformed word from a producer. Log once. + has_protocol_error_ = true; + PERFETTO_ELOG( + "tracing v2: stopping ring buffer reader at position %u: %s " + "(chunk state word 0x%08x, %s)", + read_pos_, reason, state_word, ChunkStateName(ChunkStateOf(state_word))); + return ConsumeResult::kProtocolError; +} -#endif // PERFETTO_BUILDFLAG(PERFETTO_ZLIB) -// gen_amalgamated begin source: src/tracing/service/zstd_compressor.cc -// gen_amalgamated begin header: src/tracing/service/zstd_compressor.h +} // namespace perfetto::tracing_v2 +// gen_amalgamated begin source: src/tracing/v2/shared_ring_buffer_writer.cc /* * Copyright (C) 2026 The Android Open Source Project * @@ -59709,24 +67023,495 @@ void ZlibCompressFn(std::vector* packets) { * limitations under the License. */ -#ifndef SRC_TRACING_SERVICE_ZSTD_COMPRESSOR_H_ -#define SRC_TRACING_SERVICE_ZSTD_COMPRESSOR_H_ +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_writer.h" -#include +#include +#include -// gen_amalgamated expanded: #include "perfetto/base/build_config.h" -// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h" +#include +#include -namespace perfetto { +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "perfetto/base/time.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_abi.h" -#if PERFETTO_BUILDFLAG(PERFETTO_ZSTD) -// Compresses `packets` with zstd at the given compression `level`. -void ZstdCompressFn(std::vector*, int level); -#endif +namespace perfetto::tracing_v2 { +namespace { -} // namespace perfetto +// The 100 ms sleep limit matches SharedMemoryArbiterImpl::GetNewChunk(). +constexpr uint32_t kMaxFallbackSleepUs = 100000; -#endif // SRC_TRACING_SERVICE_ZSTD_COMPRESSOR_H_ +} // namespace + +SharedRingBufferWriter::SharedRingBufferWriter(SharedRingBuffer* ring, + WriterID writer_id, + BufferID target_buffer) + : ring_(ring), + writer_id_(writer_id), + target_buffer_(target_buffer), + chunk_size_(ring->chunk_size()), + max_fragment_size_(MaxFragmentSizeForEmptyChunk(chunk_size_)) { + // The WriterID goes into every chunk that this writer claims. The caller + // controls its lifetime. + // + // TraceWriterV2Impl releases it after its final publication. The service + // can still read chunks under the ID after that. See the TODO in + // ProducerRingBufferArbiter::OnWriterDestroyed(). + PERFETTO_DCHECK(writer_id_ != 0 && writer_id_ <= kMaxWriterID); +} + +SharedRingBufferWriter::~SharedRingBufferWriter() { + FinishCurrentChunk(); +} + +SharedRingBufferWriter::FragmentRange SharedRingBufferWriter::BeginFragment( + uint32_t min_size, + bool continues_from_prev) { + PERFETTO_DCHECK(!has_open_fragment()); + // A new chunk now would put the next packet ahead of the saved fragment. + PERFETTO_DCHECK(!pending_relocation_); + // EndFragment(..., /*continues_on_next=*/true) discards the cached handle + // when a packet continues into another chunk. A continuation must claim a + // new chunk because only AcquireNewChunk() sets kFlagContinuesFromPrevChunk. + PERFETTO_DCHECK(!continues_from_prev || !cur_chunk_); + + if (min_size > max_fragment_size_) + return FragmentRange{BeginFragmentResult::kTooLarge}; + + // Try the cached Complete chunk before a new reservation. + if (cur_chunk_) { + PERFETTO_DCHECK(cur_chunk_state() == ChunkState::kComplete); + const uint32_t available = MaxFragmentSizeInCurrentChunk(); + // Pending loss does not prevent reuse, which requires no new reservation. + // The next publication sets kFlagDataLoss. The reader then discards all + // published fragments in this chunk, including those before the loss. + if (available >= min_size && ring_->TryReacquireChunkForWriting( + cur_chunk_idx_, expected_state_word_)) { + expected_state_word_ = + ReplaceChunkState(expected_state_word_, ChunkState::kBeingWritten); + return BeginFragmentInCurrentChunk(available); + } + // The chunk has insufficient space or the reader reclaimed it first. + // Discard the handle before the next claim. + ResetCurrentChunk(); + } + + const uint32_t flags = continues_from_prev ? kFlagContinuesFromPrevChunk : 0u; + const BeginFragmentResult result = AcquireNewChunk(flags); + if (result != BeginFragmentResult::kSuccess) + return FragmentRange{result}; + return BeginFragmentInCurrentChunk(max_fragment_size_); +} + +SharedRingBufferWriter::FragmentRange +SharedRingBufferWriter::BeginFragmentInCurrentChunk(uint32_t available) { + PERFETTO_DCHECK(cur_chunk_); + PERFETTO_DCHECK(cur_chunk_state() == ChunkState::kBeingWritten); + PERFETTO_DCHECK(available > 0); + cur_fragment_begin_ = payload_end_; + return FragmentRange{/*result=*/BeginFragmentResult::kSuccess, + /*begin=*/cur_chunk_ + cur_fragment_begin_, + /*end=*/cur_chunk_ + cur_fragment_begin_ + available}; +} + +SharedRingBufferWriter::EndFragmentResult SharedRingBufferWriter::EndFragment( + uint32_t size, + bool continues_on_next) { + PERFETTO_DCHECK(has_open_fragment()); + PERFETTO_DCHECK(cur_chunk_); + PERFETTO_DCHECK(cur_chunk_state() == ChunkState::kBeingWritten); + PERFETTO_DCHECK(size_directory_bytes_ <= chunk_size_); + PERFETTO_DCHECK(cur_fragment_begin_ <= chunk_size_ - size_directory_bytes_); + // The fragment must leave space for its size entry before the directory. + PERFETTO_DCHECK( + size <= MaxFragmentSizeForAvailableBytes( + chunk_size_ - size_directory_bytes_ - cur_fragment_begin_)); + + // The reader cannot access this fragment until publication updates the shared + // fragment count. Write the size entry before that publication. + uint8_t* const chunk_end = cur_chunk_ + chunk_size_; + uint8_t* const sizes_begin = + WriteFragmentSizeReversed(chunk_end - size_directory_bytes_, size); + // sizes_begin points to the new size entry, before the existing entries. + // Subtract it from chunk_end to count all directory bytes, including the new + // entry. The directory grows towards lower addresses. + size_directory_bytes_ = static_cast(chunk_end - sizes_begin); + payload_end_ = cur_fragment_begin_ + size; + ++num_fragments_; + cur_fragment_begin_ = kNoFragmentOpen; + + return ReleaseCurrentChunkAsComplete(size, continues_on_next); +} + +SharedRingBufferWriter::EndFragmentResult +SharedRingBufferWriter::FinishCurrentChunk() { + PERFETTO_DCHECK(!pending_relocation_); + // Abandon any open fragment. Its bytes are outside the published count, so + // this does not affect the fragments the reader can already access. + cur_fragment_begin_ = kNoFragmentOpen; + + EndFragmentResult result = EndFragmentResult::kSuccess; + if (cur_chunk_ && cur_chunk_state() == ChunkState::kBeingWritten) { + result = ReleaseCurrentChunkAsComplete(std::nullopt, + /*continues_on_next=*/false); + } + ResetCurrentChunk(); + return result; +} + +uint32_t SharedRingBufferWriter::MaxFragmentSizeInCurrentChunk() const { + PERFETTO_DCHECK(cur_chunk_); + if (num_fragments_ >= kMaxFragmentsPerChunk) + return 0; + PERFETTO_DCHECK(payload_end_ <= chunk_size_); + PERFETTO_DCHECK(size_directory_bytes_ <= chunk_size_ - payload_end_); + const uint32_t available_bytes = + chunk_size_ - payload_end_ - size_directory_bytes_; + return MaxFragmentSizeForAvailableBytes(available_bytes); +} + +SharedRingBufferWriter::BeginFragmentResult +SharedRingBufferWriter::AcquireNewChunk(uint32_t continuation_flags) { + PERFETTO_DCHECK(!cur_chunk_); + + // A new chunk must preserve loss from either source: + // - data_loss_pending_: this writer has a loss to report. + // - continuation_flags: a rewrite of BeingWritten(0) left a loss unreported. + // The replacement inherits that flag even if data_loss_pending_ is false. + const uint32_t flags = + continuation_flags | (data_loss_pending_ ? kFlagDataLoss : 0u); + const uint32_t being_written_word = + MakeDataStateWord(ChunkState::kBeingWritten, ChunkFormat::kTargetBuffer, + flags, 0, writer_id_); + const uint32_t num_chunks = ring_->num_chunks(); + + // After num_chunks failed claims, return without a chunk. + // + // Other writers can reserve intervening positions, so our attempts + // can select the same physical chunk on different traversals. + // This limit bounds attempts, but does not guarantee a visit to every chunk. + uint32_t num_failed_claims = 0; + + // Each attempt reserves a position, then tries to claim its physical chunk: + // + // 1. TryReserveWritePos() finds the ring buffer full. + // - write_pos stays unchanged. No position was reserved. + // - Return without a chunk below. + // + // 2. Reservation and TryAcquireChunkForWriting() both succeed. + // - This writer now owns the chunk. Return it to the caller. + // + // 3. Reservation succeeds, but TryAcquireChunkForWriting() fails. + // - The reader advanced the wrap count before we claimed the chunk. + // We may have been descheduled after advancing write_pos. + // - Or the chunk still belongs to an older reservation: + // - Its writer claimed the chunk, then got descheduled. + // - The reader copied its published fragments and set RewriteRequested. + // - The reader advanced read_pos. It did not release the chunk. + // - Advancing read_pos made room for another reservation. + // TryReserveWritePos() checks the positions, not the chunk state. + // - Our new reservation selects that same physical chunk. + // The claim fails because the older writer has not acknowledged yet. + // - Leave the reservation unclaimed. Try a new reservation with continue. + // - After num_chunks failed claims, return without a chunk instead. + for (;;) { + const auto reservation = ring_->TryReserveWritePos(); + read_pos_for_wait_ = reservation.read_pos_for_wait; + + if (reservation.result == SharedRingBuffer::ReserveResult::kReserved) { + // Claim the chunk only if its Free word matches this reservation's wrap. + if (ring_->TryAcquireChunkForWriting(reservation.chunk_pos, + being_written_word)) { + cur_chunk_idx_ = + ChunkIndex::FromPosition(reservation.chunk_pos, num_chunks); + cur_chunk_ = ring_->chunk_at(cur_chunk_idx_); + expected_state_word_ = being_written_word; + payload_end_ = kTargetBufferPayloadOffset; + size_directory_bytes_ = 0; + num_fragments_ = 0; + // The shared word now contains any pending loss. If a rewrite prevents + // publication, relocation preserves the flag from that word. + data_loss_pending_ = false; + fallback_sleep_us_ = 0; + StoreTargetBufferId(cur_chunk_, target_buffer_); + return BeginFragmentResult::kSuccess; + } + + ++stats_.failed_claims; + // write_pos advanced, but the writer did not acquire the physical chunk. + // This leaves an unclaimed position for the reader to consume, unless it + // already consumed the position before our claim. + // + // Retry with a new reservation, which supplies both the index and wrap + // count. Other writers can reserve intervening positions, so this need + // not select the next physical chunk. A different Free wrap belongs to + // a position we did not reserve. Do not use it to retry the failed claim. + if (++num_failed_claims < num_chunks) + continue; + } + + // If we reach this point, either: + // - TryReserveWritePos() found the ring buffer full and did not increment + // write_pos. + // - TryAcquireChunkForWriting() failed num_chunks times in this round. + // Earlier failures took continue above to try another reservation. + // The last failure reached the attempt limit. + + // The result tells why the call found no chunk: + // - kClaimFailed: a claim failed at least once in this call, even if a + // later reservation found the ring buffer full. + // - kFull: every reservation found the ring buffer full. + // + // The caller applies its BufferExhaustedPolicy. To wait, it calls + // WaitForReadPosChange() and then calls again. + return num_failed_claims != 0 ? BeginFragmentResult::kClaimFailed + : BeginFragmentResult::kFull; + } +} + +void SharedRingBufferWriter::WaitForReadPosChange(uint32_t timeout_ms) { + if (use_futex_) { + // Wait while read_pos equals the value from the last reservation attempt. + const SharedRingBuffer::WriterWaitResult result = + ring_->WaitForReadPosChange(read_pos_for_wait_, timeout_ms); + if (result == SharedRingBuffer::WriterWaitResult::kRetry) + return; + // If the futex is unavailable, use fallback sleeps for this writer's later + // waits. This avoids repeated calls to an unsupported syscall. + use_futex_ = false; + } + + // No futex. Sleep with v1's backoff: 0, 8, 72, ... microseconds, up to + // kMaxFallbackSleepUs. No sleep requests more than |timeout_ms|. + const uint64_t timeout_us = uint64_t{timeout_ms} * 1000; + base::SleepMicroseconds(static_cast( + std::min(fallback_sleep_us_, timeout_us))); + fallback_sleep_us_ = + std::min(kMaxFallbackSleepUs, (fallback_sleep_us_ + 1) * 8); +} + +SharedRingBufferWriter::EndFragmentResult +SharedRingBufferWriter::ReleaseCurrentChunkAsComplete( + std::optional fragment_size, + bool continues_on_next) { + PERFETTO_DCHECK(cur_chunk_); + PERFETTO_DCHECK(cur_chunk_state() == ChunkState::kBeingWritten); + PERFETTO_DCHECK(!has_open_fragment()); + + // Publication competes with the reader's rewrite request. For N published + // fragments, the possible transitions are: + // - Writer: BeingWritten(N) -> Complete(num_fragments_). + // - Reader: BeingWritten(N) -> RewriteRequested(N). + // + // On failure, relocate any unpublished fragment and retry publication. + // The reader can also request a rewrite of the replacement chunk. + // Repeat until publication succeeds or acquisition of a replacement fails. + // + // A failed acquisition leaves the relocation pending. + for (;;) { + uint32_t flags = PayloadFlagsOf(expected_state_word_); + // Publish pending loss and the fragment count in the same state word. + // The reader must observe the loss flag before it can deliver fragments. + if (data_loss_pending_) + flags |= kFlagDataLoss; + if (continues_on_next) + flags |= kFlagContinuesOnNextChunk; + const uint32_t complete_word = + MakeDataStateWord(ChunkState::kComplete, ChunkFormat::kTargetBuffer, + flags, num_fragments_, writer_id_); + + uint32_t expected = expected_state_word_; + if (ring_->TryReleaseChunkAsComplete(cur_chunk_idx_, complete_word, + &expected)) { + expected_state_word_ = complete_word; + data_loss_pending_ = false; + PERFETTO_DCHECK(payload_end_ <= chunk_size_); + PERFETTO_DCHECK(size_directory_bytes_ <= chunk_size_ - payload_end_); + + // Discard the cached handle if any of these limits prevents reuse: + // - continues_on_next: kFlagContinuesOnNextChunk describes the last + // fragment. If another fragment follows, the flag describes the wrong + // fragment and the reader cannot identify the split packet. + // - num_fragments_ reached kMaxFragmentsPerChunk. + // - At most one byte remains between the payload and the size directory. + // BeginFragment() requires a non-empty range plus one size byte, even + // if the caller later ends the fragment with a size of zero. + if (continues_on_next || num_fragments_ >= kMaxFragmentsPerChunk || + chunk_size_ - payload_end_ - size_directory_bytes_ <= 1) { + ResetCurrentChunk(); + } + return EndFragmentResult::kSuccess; + } + + // On failure, expected must be RewriteRequested for this writer. Only the + // reader can change the word before publication, so any other value is a + // protocol error. + if (PERFETTO_UNLIKELY(ChunkStateOf(expected) != + ChunkState::kRewriteRequested || + WriterIDOf(expected) != writer_id_)) { + PERFETTO_FATAL( + "tracing v2: publication of chunk %u by writer %u lost to state word " + "0x%08x, which is not a rewrite request for this writer", + cur_chunk_idx_.value(), writer_id_, expected); + } + + // expected is RewriteRequested: the reader did a partial chunk read while + // this writer prepared another fragment. + // - It consumed NumFragmentsOf(expected) published fragments. It discarded + // them if kFlagDataLoss was set or validation failed. + // - It did not consume the unpublished fragment. The reader will not return + // to this reservation for more fragments. + // - The writer must publish the remaining + // num_fragments_ - NumFragmentsOf(expected) fragments in a new chunk. + const uint32_t num_fragments_read = NumFragmentsOf(expected); + + // The rewrite request preserves the count from our last publication. + PERFETTO_DCHECK(num_fragments_read == NumFragmentsOf(expected_state_word_)); + + // At most one fragment needs relocation because EndFragment() publishes + // before another fragment can begin: + // - EndFragment() adds the finished fragment to num_fragments_. + // - FinishCurrentChunk() abandons the open fragment without increasing it. + PERFETTO_DCHECK(num_fragments_ == + num_fragments_read + (fragment_size.has_value() ? 1u : 0u)); + + // The unpublished fragment occupies the last |*fragment_size| bytes before + // payload_end_. The reader already consumed the earlier fragments. + // Save these bytes before acknowledgement. The reader can then reclaim + // the chunk. + if (fragment_size) { + // TODO(sashwinbalaji): Measure allocation latency on the first relocation + // and retained memory per writer. Use the results to decide when to + // allocate this scratch buffer and whether to retain it for later use. + relocation_payload_.assign(cur_chunk_ + payload_end_ - *fragment_size, + cur_chunk_ + payload_end_); + } + + // Acknowledge before the next acquisition. The reader can then reclaim the + // old chunk even if this writer must wait for replacement space. + if (PERFETTO_UNLIKELY( + !ring_->TryAcknowledgeRewrite(cur_chunk_idx_, expected))) { + PERFETTO_FATAL( + "tracing v2: writer %u could not acknowledge chunk %u: only its " + "owner may leave RewriteRequested", + writer_id_, cur_chunk_idx_.value()); + } + ++stats_.relocations; + + // If num_fragments_read is zero, preserve both flags: + // - kFlagContinuesFromPrevChunk still describes the unpublished fragment. + // - kFlagDataLoss still needs a report because the reader ignores loss in + // BeingWritten(0). + // + // Otherwise, clear both flags: + // - The reader consumed the first fragment, so its continuation flag no + // longer applies. The unpublished fragment starts a new packet because + // EndFragment(..., /*continues_on_next=*/true) prevents further fragments + // in the old chunk. + // - The reader handles the old loss. The delegate tracks that gap for the + // next complete packet. Repeating the flag would discard the replacement. + // + // kFlagContinuesOnNextChunk comes from this call's continues_on_next value. + const uint32_t inherited_flags = + PayloadFlagsOf(expected) & + (kFlagContinuesFromPrevChunk | kFlagDataLoss); + const uint32_t relocated_flags = + num_fragments_read == 0 ? inherited_flags : 0; + + ResetCurrentChunk(); + + if (!fragment_size) { + PERFETTO_DCHECK(!continues_on_next); + // FinishCurrentChunk() has no fragment to relocate. If the reader did not + // report the old loss, the next acquired chunk must report it. + if (relocated_flags & kFlagDataLoss) + data_loss_pending_ = true; + return EndFragmentResult::kSuccess; + } + + // AcquireNewChunk() also includes data_loss_pending_. A loss recorded after + // the old publication must survive even if the reader handled the old flag. + const BeginFragmentResult claim = AcquireNewChunk(relocated_flags); + if (claim != BeginFragmentResult::kSuccess) { + // Keep the saved fragment. The caller retries or drops it. + pending_relocation_ = + PendingRelocation{relocated_flags, continues_on_next}; + return claim == BeginFragmentResult::kFull + ? EndFragmentResult::kFull + : EndFragmentResult::kClaimFailed; + } + if (PERFETTO_UNLIKELY(after_replacement_claim_for_testing_)) + after_replacement_claim_for_testing_(); + CopyRelocatedFragment(*fragment_size); + } +} + +SharedRingBufferWriter::RetryRelocationResult +SharedRingBufferWriter::RetryRelocation() { + PERFETTO_DCHECK(pending_relocation_); + PERFETTO_DCHECK(!cur_chunk_); + + RetryRelocationResult retry; + const BeginFragmentResult claim = + AcquireNewChunk(pending_relocation_->chunk_flags); + if (claim != BeginFragmentResult::kSuccess) { + retry.result = claim == BeginFragmentResult::kFull + ? EndFragmentResult::kFull + : EndFragmentResult::kClaimFailed; + return retry; + } + retry.acquired_replacement = true; + if (PERFETTO_UNLIKELY(after_replacement_claim_for_testing_)) + after_replacement_claim_for_testing_(); + + const auto fragment_size = static_cast(relocation_payload_.size()); + const bool continues_on_next = pending_relocation_->continues_on_next; + pending_relocation_.reset(); + CopyRelocatedFragment(fragment_size); + // If the reader also takes this replacement, this relocates again. + retry.result = + ReleaseCurrentChunkAsComplete(fragment_size, continues_on_next); + return retry; +} + +void SharedRingBufferWriter::DropRelocation() { + PERFETTO_DCHECK(pending_relocation_); + pending_relocation_.reset(); + ++stats_.fragments_dropped; + // Also covers a loss flag that the relocation inherited. + data_loss_pending_ = true; +} + +void SharedRingBufferWriter::CopyRelocatedFragment(uint32_t fragment_size) { + // All chunks have the same capacity, so the saved fragment and its size + // entry fit in the empty replacement. An empty payload still needs a size + // entry and contributes one to the fragment count. + if (!relocation_payload_.empty()) { + memcpy(cur_chunk_ + kTargetBufferPayloadOffset, relocation_payload_.data(), + relocation_payload_.size()); + } + payload_end_ = kTargetBufferPayloadOffset + fragment_size; + uint8_t* const chunk_end = cur_chunk_ + chunk_size_; + uint8_t* const sizes_begin = + WriteFragmentSizeReversed(chunk_end, fragment_size); + size_directory_bytes_ = static_cast(chunk_end - sizes_begin); + num_fragments_ = 1; +} + +void SharedRingBufferWriter::ResetCurrentChunk() { + cur_chunk_ = nullptr; + cur_chunk_idx_ = ChunkIndex::FromIndex(0); + expected_state_word_ = 0; + payload_end_ = 0; + size_directory_bytes_ = 0; + num_fragments_ = 0; + cur_fragment_begin_ = kNoFragmentOpen; +} + +} // namespace perfetto::tracing_v2 +// gen_amalgamated begin source: src/tracing/v2/trace_writer_v2_impl.cc /* * Copyright (C) 2026 The Android Open Source Project * @@ -59743,175 +67528,338 @@ void ZstdCompressFn(std::vector*, int level); * limitations under the License. */ -// gen_amalgamated expanded: #include "src/tracing/service/zstd_compressor.h" - -// gen_amalgamated expanded: #include "perfetto/base/build_config.h" - -#if PERFETTO_BUILDFLAG(PERFETTO_ZSTD) - -#include +// gen_amalgamated expanded: #include "src/tracing/v2/trace_writer_v2_impl.h" -#include +#include +#include +#include +#include +#include // gen_amalgamated expanded: #include "perfetto/base/logging.h" -// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h" -// gen_amalgamated expanded: #include "protos/perfetto/trace/trace.pbzero.h" -// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h" -// gen_amalgamated expanded: #include "src/tracing/service/packet_compressor_common.h" +// gen_amalgamated expanded: #include "perfetto/base/proc_utils.h" +// gen_amalgamated expanded: #include "perfetto/base/time.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/thread_annotations.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" +// gen_amalgamated expanded: #include "src/tracing/v2/producer_ring_buffer_arbiter.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_abi.h" -namespace perfetto { +// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h" +namespace perfetto::tracing_v2 { namespace { -using packet_compressor::GetPreamble; -using packet_compressor::kCompressSliceSize; -using packet_compressor::Preamble; -using packet_compressor::PreambleToSlice; +// A new fragment must fit Protozero's largest scalar field. +constexpr uint32_t kMinFragmentPayloadSize = + static_cast(protozero::proto_utils::kMaxSimpleFieldEncodedSize); -// ScopedResource's close function must return int; ZSTD_freeCStream returns -// size_t, so wrap it. It only fails for a static-allocated stream, not the -// heap one ZSTD_createCStream gives us, so returning 0 is safe. -inline int ZstdFreeCStream(ZSTD_CStream* cstream) { - ZSTD_freeCStream(cstream); - return 0; +// Each wait for space requests at most this time. A wait can end early, for +// example when the reader moves read_pos. +// SharedRingBufferWriter::WaitForReadPosChange() states the exact guarantees. +// +// The limit makes the writer check again also without reader progress: +// - If the reader detached during the wait, the writer drops the data. It +// does not wait until the stall deadline and crash. +// - If the last drain did not free space, the writer asks for another one. +// +// The 100 ms limit matches the longest sleep in +// SharedMemoryArbiterImpl::GetNewChunk(). +constexpr uint32_t kMaxWaitMs = 100; + +// After this time, kStall aborts and kStallThenDrop drops the data. +// - The time starts when one chunk acquisition first needs to wait. +// - It covers all failed claim rounds and waits of that acquisition. +// - It does not limit the time to finish a fragment: a relocation can claim +// several replacements, each with its own deadline. +// +// The 30-second limit matches v1's approximate timeout from kAssertAtNStalls +// in SharedMemoryArbiterImpl::GetNewChunk(). +constexpr uint32_t kStallTimeoutMs = 30000; + +// Drop mode writes go here, so the data source can finish the packet. Nobody +// reads it. +// - All writers of the process share it, as v1 writers share +// g_garbage_chunk. Their concurrent writes are a benign race. +// - Sized to the largest chunk. A raw stream caller can then request a +// contiguous range as large as in a normal fragment. +uint8_t g_drop_buffer[kMaxChunkSize]; + +} // namespace + +TraceWriterV2Impl::TraceWriterV2Impl( + ProducerRingBufferArbiter* ring_buffer_arbiter, + WriterID id, + BufferID target_buffer, + BufferExhaustedPolicy policy) + : ring_buffer_arbiter_(ring_buffer_arbiter), + ring_buffer_writer_(ring_buffer_arbiter->ring_buffer(), + id, + target_buffer), + buffer_exhausted_policy_(policy), + process_id_(base::GetProcessId()), + stream_writer_(this), + cur_packet_(std::make_unique< + protozero::RootMessage>()) {} + +TraceWriterV2Impl::~TraceWriterV2Impl() { + // Flush implicitly, as TraceWriterBase documents: publish the last packet + // and ask for a drain. A publication alone makes the bytes readable, but it + // does not make the service read them. + // + // Both happen before the arbiter releases this WriterID: + // - The release can let the endpoint destroy the arbiter. + // - Ring buffer reservations keep the order if another ring buffer writer + // reuses the ID. Nothing handles reuse by a v1 writer yet. See the TODO + // in ProducerRingBufferArbiter::OnWriterDestroyed(). + FinishTracePacket(); + Flush(); + ring_buffer_arbiter_->OnWriterDestroyed(writer_id()); } -using ScopedZstdCStream = base::ScopedResource; -// A compressor for `TracePacket`s that uses zstd's streaming API: data is fed -// in with ZSTD_compressStream2(ZSTD_e_continue) and the frame is finalized with -// ZSTD_e_end, emitting output in fixed-size slices (kCompressSliceSize). -// zstd API reference: https://facebook.github.io/zstd/zstd_manual.html -class ZstdPacketCompressor { - public: - explicit ZstdPacketCompressor(int level); +TraceWriter::TracePacketHandle TraceWriterV2Impl::NewTracePacket() { + PERFETTO_DCHECK(process_id_ == base::GetProcessId()); + EnsurePacketClosed(); - // Can be called multiple times, before Finish() is called. - void PushPacket(const TracePacket& packet); + stream_writer_.Reset(BeginPacketFragment(/*continues_from_prev=*/false)); + cur_packet_->Reset(&stream_writer_, + protozero::Message::Encoding::kProtoGroup); + packet_open_ = true; + if (PERFETTO_UNLIKELY(first_packet_on_sequence_)) { + cur_packet_->set_first_packet_on_sequence(true); + first_packet_on_sequence_ = false; + } - // Returns the compressed data. Can be called at most once. After this call, - // the object is unusable (PushPacket should not be called) and must be - // destroyed. - TracePacket Finish(); + TracePacketHandle handle(cur_packet_.get()); + handle.set_finalization_listener(this); + return handle; +} - private: - void PushData(const void* data, uint32_t size); - void NewOutputSlice(); - void PushCurSlice(); +void TraceWriterV2Impl::FinishTracePacket() { + PERFETTO_DCHECK(process_id_ == base::GetProcessId()); + if (!packet_open_) + return; - ScopedZstdCStream cstream_; - // Points into `cur_slice_`. Zero-initialized so that the first compression - // call observes a full output buffer and allocates the initial slice. - ZSTD_outBuffer out_{/*dst=*/nullptr, /*size=*/0, /*pos=*/0}; - size_t total_new_slices_size_ = 0; - std::vector new_slices_; - std::unique_ptr cur_slice_; -}; + // Finalize() can append closing bytes that cross a chunk boundary. Keep + // packet_open_ true until it returns so GetNewBuffer() can obtain space for + // those bytes. Then publish the final fragment without a continuation flag. + cur_packet_->Finalize(); + packet_open_ = false; + EndPacketFragment(/*continues_on_next=*/false); +} -ZstdPacketCompressor::ZstdPacketCompressor(int level) { - cstream_.reset(ZSTD_createCStream()); - PERFETTO_CHECK(cstream_); - // zstd maps 0 to its default level, clamps levels above its max, and treats - // negatives as fast modes, so any int is safe to pass through here. - size_t rc = - ZSTD_CCtx_setParameter(cstream_.get(), ZSTD_c_compressionLevel, level); - PERFETTO_CHECK(!ZSTD_isError(rc)); +void TraceWriterV2Impl::Flush(std::function callback) { + EnsurePacketClosed(); + + // A completed fragment leaves its chunk cached for later packets. Release + // that chunk before ring_buffer_arbiter_->Flush() so later packets use new + // reservations. + ring_buffer_writer_.FinishCurrentChunk(); + stream_writer_.Reset({nullptr, nullptr}); + ring_buffer_arbiter_->Flush(std::move(callback)); } -void ZstdPacketCompressor::PushPacket(const TracePacket& packet) { - // Prefix each packet with its proto preamble so the compressed stream itself - // parses as a valid Trace proto, and its packets can be tokenized back out. - Preamble preamble = - GetPreamble(packet.size()); - PushData(preamble.buf.data(), preamble.size); - for (const Slice& slice : packet.slices()) { - PushData(slice.start, static_cast(slice.size)); - } +void TraceWriterV2Impl::OnMessageFinalized(protozero::Message*) { + FinishTracePacket(); } -void ZstdPacketCompressor::PushData(const void* data, uint32_t size) { - // ZSTD_e_continue hands data to the encoder, which buffers and emits at its - // own discretion. It may not consume all input in one call (e.g. when the - // output slice fills), so loop until `in` is drained, giving it a fresh slice - // whenever `out_` is full. - ZSTD_inBuffer in = {/*src=*/data, /*size=*/size, /*pos=*/0}; - while (in.pos < in.size) { - if (out_.pos == out_.size) { - NewOutputSlice(); - } - size_t rc = - ZSTD_compressStream2(cstream_.get(), &out_, &in, ZSTD_e_continue); - PERFETTO_CHECK(!ZSTD_isError(rc)); +protozero::ContiguousMemoryRange TraceWriterV2Impl::GetNewBuffer() { + if (!packet_open_) { + // A stale handle can request space without an open packet. This caller + // error violates the data-source API contract. + PERFETTO_DFATAL("TraceWriterV2Impl: write outside an open packet"); + EnterDropMode(); + return GetDropBuffer(); } -} -TracePacket ZstdPacketCompressor::Finish() { - // ZSTD_e_end flushes buffered data and writes the frame epilogue. Per the - // contract, keep calling (draining `out_` into new slices) until it reports 0 - // bytes remaining. - size_t remaining; - do { - if (out_.pos == out_.size) { - NewOutputSlice(); - } - ZSTD_inBuffer in = {/*src=*/nullptr, /*size=*/0, /*pos=*/0}; - remaining = ZSTD_compressStream2(cstream_.get(), &out_, &in, ZSTD_e_end); - PERFETTO_CHECK(!ZSTD_isError(remaining)); - } while (remaining != 0); + // If the writer loses part of a packet, the remaining bytes are not useful. + // Send the rest to the drop buffer. Try the ring buffer for the next packet. + if (in_drop_mode_) + return GetDropBuffer(); - PushCurSlice(); + // The current range cannot satisfy the stream's request. Publish this + // fragment with kFlagContinuesOnNextChunk and continue in another chunk. + EndPacketFragment(/*continues_on_next=*/true); - TracePacket packet; - packet.AddSlice(PreambleToSlice( - GetPreamble< - protos::pbzero::TracePacket::kZstdCompressedPacketsFieldNumber>( - total_new_slices_size_))); - for (auto& slice : new_slices_) { - packet.AddSlice(std::move(slice)); - } - return packet; + // EndPacketFragment() can fail to relocate after the reader requests a + // rewrite. Then the rest of the packet goes to the drop buffer, not to a + // continuation fragment. + if (in_drop_mode_) + return GetDropBuffer(); + + return BeginPacketFragment(/*continues_from_prev=*/true); } -void ZstdPacketCompressor::NewOutputSlice() { - PushCurSlice(); - cur_slice_ = std::make_unique(kCompressSliceSize); - out_.dst = cur_slice_.get(); - out_.size = kCompressSliceSize; - out_.pos = 0; +uint8_t* TraceWriterV2Impl::AnnotatePatch(uint8_t*) { + PERFETTO_FATAL("TraceWriterV2Impl cannot patch previously written bytes"); } -void ZstdPacketCompressor::PushCurSlice() { - if (!cur_slice_) { - return; - } - total_new_slices_size_ += out_.pos; - new_slices_.push_back(Slice::TakeOwnership(std::move(cur_slice_), out_.pos)); +void TraceWriterV2Impl::EnsurePacketClosed() { + if (packet_open_ && cur_packet_->is_finalized()) + FinishTracePacket(); + PERFETTO_CHECK(!packet_open_); } -} // namespace +protozero::ContiguousMemoryRange TraceWriterV2Impl::BeginPacketFragment( + bool continues_from_prev) { + std::optional stall_deadline; + for (;;) { + const auto range = ring_buffer_writer_.BeginFragment( + kMinFragmentPayloadSize, continues_from_prev); + if (range.result == SharedRingBufferWriter::BeginFragmentResult::kSuccess) { + fragment_begin_ = range.begin; + in_drop_mode_ = false; + return {range.begin, range.end}; + } + // Every valid chunk size holds kMinFragmentPayloadSize. + PERFETTO_DCHECK(range.result != + SharedRingBufferWriter::BeginFragmentResult::kTooLarge); -void ZstdCompressFn(std::vector* packets, int level) { - if (packets->empty()) { + const bool claim_failed = + range.result == + SharedRingBufferWriter::BeginFragmentResult::kClaimFailed; + if (!TryStallForSpace(claim_failed, &stall_deadline)) { + EnterDropMode(); + return GetDropBuffer(); + } + } +} + +void TraceWriterV2Impl::EndPacketFragment(bool continues_on_next) { + if (!fragment_begin_) { + // The packet went to the drop buffer. The next publication carries + // kFlagDataLoss, even if it reuses a cached chunk. return; } - ZstdPacketCompressor stream(level); + const uint32_t used = + static_cast(stream_writer_.write_ptr() - fragment_begin_); + fragment_begin_ = nullptr; - for (const TracePacket& packet : *packets) { - stream.PushPacket(packet); + // If the reader took the chunk, EndFragment() relocates the fragment and + // needs a replacement chunk. See SharedRingBufferWriter::EndFragment(). + // + // If EndFragment() cannot claim a replacement, the relocation stays pending + // until the policy lets the writer try again or drop it. + SharedRingBufferWriter::EndFragmentResult result = + ring_buffer_writer_.EndFragment(used, continues_on_next); + // The stall deadline of the current replacement acquisition. It starts at + // the first wait after EndFragment() returns. + std::optional stall_deadline; + while (result != SharedRingBufferWriter::EndFragmentResult::kSuccess) { + const bool claim_failed = + result == SharedRingBufferWriter::EndFragmentResult::kClaimFailed; + if (!TryStallForSpace(claim_failed, &stall_deadline)) { + // Discard the saved fragment and the rest of the packet. + ring_buffer_writer_.DropRelocation(); + EnterDropMode(); + return; + } + const auto retry = ring_buffer_writer_.RetryRelocation(); + // A claimed replacement ends the current acquisition, even if the reader + // then took it before publication. The next acquisition gets its own + // deadline at its first wait. Retries without a claim keep the deadline. + if (retry.acquired_replacement) + stall_deadline.reset(); + result = retry.result; + } + + // Batch drain requests until occupancy reaches the threshold: + // - This reduces task and IPC traffic when packets arrive separately. + // - It lets this writer reuse its cached Complete chunk for longer. A drain + // frees that chunk, and the next fragment then needs a new one. + const uint32_t outstanding_positions = + ring_buffer_arbiter_->ring_buffer()->LoadNumOutstandingPositionsRelaxed(); + if (outstanding_positions >= + ring_buffer_arbiter_->drain_occupancy_threshold()) { + ring_buffer_arbiter_->RequestDrain( + ProducerRingBufferArbiter::DrainUrgency::kRoutine); + } +} + +bool TraceWriterV2Impl::TryStallForSpace( + bool claim_failed, + std::optional* stall_deadline) { + // While a loss waits for its report, kStallThenDrop acts as kDrop. + // Otherwise each dropped packet can cost another full timeout. + // + // A later + // acquisition can stall again after a chunk carries the loss. This matches + // v1's drop_packets_ behavior. + bool can_stall = buffer_exhausted_policy_ != BufferExhaustedPolicy::kDrop; + if (buffer_exhausted_policy_ == BufferExhaustedPolicy::kStallThenDrop && + ring_buffer_writer_.has_pending_data_loss()) { + can_stall = false; + } + + // Time left before the stall deadline. Zero means drop. + // Without an attached reader, nothing frees space. So drop, also under + // kStall. A wait would only end at the deadline, where kStall crashes. + uint32_t time_left_ms = 0; + if (can_stall && ring_buffer_arbiter_->IsReaderAttached()) { + const base::TimeMillis now = get_time_ms_(); + if (!stall_deadline->has_value()) + *stall_deadline = now + base::TimeMillis(kStallTimeoutMs); + const base::TimeMillis deadline = **stall_deadline; + if (now < deadline) { + time_left_ms = static_cast((deadline - now).count()); + } else if (buffer_exhausted_policy_ == BufferExhaustedPolicy::kStall) { + PERFETTO_FATAL( + "tracing v2: writer %u could not acquire a chunk for %u ms: " + "possible deadlock", + writer_id(), kStallTimeoutMs); + } } - TracePacket packet = stream.Finish(); + // Every drop takes this exit. + if (time_left_ms == 0) { + // Failed claims left reserved positions that only the reader can move + // past. Until it does, they block the reservations of all writers. An + // earlier drain does not cover positions reserved after it. + if (claim_failed) { + ring_buffer_arbiter_->RequestDrain( + ProducerRingBufferArbiter::DrainUrgency::kRoutine); + } + PERFETTO_DLOG( + "tracing v2: writer %u: %s: dropping data", writer_id(), + claim_failed ? "no chunk could be claimed" : "ring buffer full"); + return false; + } - packets->clear(); - packets->push_back(std::move(packet)); + // Make the reader run before the wait. Its drain frees space, and moves + // read_pos past the positions of failed claims. + ring_buffer_arbiter_->RequestDrain( + ProducerRingBufferArbiter::DrainUrgency::kUrgent); + + // With a futex, the wait compares read_pos with the value that the last + // reservation attempt saw, before the request above. So it also sees reader + // progress that happens between the request and the wait. + // + // The requested wait time comes from the time left before the deadline, + // measured before the request above. So the wait can end slightly after the + // deadline. The next check then drops or aborts. + ring_buffer_writer_.WaitForReadPosChange(std::min(kMaxWaitMs, time_left_ms)); + return true; } -} // namespace perfetto +void TraceWriterV2Impl::EnterDropMode() { + fragment_begin_ = nullptr; + // Consecutive dropped packets count as one drop. + if (in_drop_mode_) + return; + in_drop_mode_ = true; + ++drop_count_; + ring_buffer_writer_.RecordDataLoss(); +} -#endif // PERFETTO_BUILDFLAG(PERFETTO_ZSTD) +protozero::ContiguousMemoryRange TraceWriterV2Impl::GetDropBuffer() { + PERFETTO_DCHECK(in_drop_mode_); + PERFETTO_ANNOTATE_BENIGN_RACE_SIZED(&g_drop_buffer, sizeof(g_drop_buffer), + "nobody reads the drop buffer") + return {&g_drop_buffer[0], &g_drop_buffer[0] + sizeof(g_drop_buffer)}; +} + +} // namespace perfetto::tracing_v2 // gen_amalgamated begin source: src/tracing/service/clock.cc // gen_amalgamated begin header: src/tracing/service/clock.h /* @@ -60501,8 +68449,8 @@ double RandomImpl::GetValue() { } } // namespace perfetto::tracing_service -// gen_amalgamated begin source: src/tracing/service/trace_buffer_v1.cc -// gen_amalgamated begin header: src/tracing/service/trace_buffer_v1.h +// gen_amalgamated begin source: src/tracing/service/service_ring_buffer_drainer.cc +// gen_amalgamated begin header: src/tracing/service/service_ring_buffer_drainer.h // gen_amalgamated begin header: include/perfetto/ext/tracing/core/client_identity.h /* * Copyright (C) 2023 The Android Open Source Project @@ -60555,6 +68503,157 @@ class ClientIdentity { } // namespace perfetto #endif // INCLUDE_PERFETTO_EXT_TRACING_CORE_CLIENT_IDENTITY_H_ +/* + * Copyright (C) 2026 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SRC_TRACING_SERVICE_SERVICE_RING_BUFFER_DRAINER_H_ +#define SRC_TRACING_SERVICE_SERVICE_RING_BUFFER_DRAINER_H_ + +#include +#include + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/ext/base/thread_checker.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/weak_runner.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_reader.h" + +namespace perfetto { +class TraceBuffer; +namespace tracing_v2 { + +namespace test { +class ServiceRingBufferDrainerTestPeer; +} // namespace test + +// Copies published data from one producer connection's v2 ring buffer into +// authorized trace buffers that support SMB v2. ProducerRingBufferArbiter +// manages the producer side. See AttachV2RingBuffer in producer_port.proto for +// the IPC flow. +// +// All operations, including construction and destruction, run on the service +// sequence. +// +// ProducerEndpointImpl +// |-- owns ---> ServiceRingBufferDrainer (this class) +// |-- shares -> SharedMemory: the ring buffer mapping +// |-- owns ---> SharedRingBuffer: the view +// |-- owns ---> SharedRingBufferReader +// |-- uses ---> Delegate (the ProducerEndpointImpl) +// |-- uses ---> the service task runner +// +// Over IPC, |memory_| holds the service's separate mapping. In-process, the +// producer and service share the same mapping. +class ServiceRingBufferDrainer : public SharedRingBufferReader::Delegate { + public: + // Delegate calls must not destroy or reenter the drainer. + class Delegate { + public: + virtual ~Delegate(); + + // Returns a trace buffer that the producer may write to and that supports + // SMB v2, or nullptr. The service owns the buffer, which must remain valid + // during OnChunkRead(). + virtual TraceBuffer* GetV2RingBufferDestination(BufferID) = 0; + + // Calls |callback| inline for each buffer that GetV2RingBufferDestination() + // would return. Buffer references are valid only during the callback. + // The callback must not change the set of destinations or destroy a buffer. + virtual void ForEachV2RingBufferDestination( + const std::function& callback) = 0; + + // Adds |count| to the service's chunks_discarded statistic for chunks that + // never reached a trace buffer. Excludes loss reported by the producer. + virtual void OnRingBufferChunksDiscarded(uint64_t count) = 0; + }; + + // Shares ownership of |memory|. The mapping and |chunk_size_bytes| must + // describe a valid ring buffer layout. |delegate| and |task_runner| must + // remain valid until destruction. + ServiceRingBufferDrainer(std::shared_ptr memory, + uint32_t chunk_size_bytes, + ProducerID, + ClientIdentity, + Delegate* delegate, + base::TaskRunner* task_runner); + + // Cancels pending retry tasks. Destruction does not call Drain() or copy any + // remaining data from |ring_buffer_|. + ~ServiceRingBufferDrainer() override; + ServiceRingBufferDrainer(const ServiceRingBufferDrainer&) = delete; + ServiceRingBufferDrainer& operator=(const ServiceRingBufferDrainer&) = delete; + ServiceRingBufferDrainer(ServiceRingBufferDrainer&&) = delete; + ServiceRingBufferDrainer& operator=(ServiceRingBufferDrainer&&) = delete; + + // Reads at most |ring_buffer_.num_chunks()| logical positions. Reaching the + // position or retry limit schedules another pass after a delay. At most one + // retry task is pending at a time. + // + // A protocol error stops all future reads and records one ABI violation in + // each authorized destination. Data already copied is kept. The producer + // stays connected without notification or a v1 fallback. When the ring buffer + // fills, its writers drop packets, or stall and time out. + void Drain(); + + // Mapping size for the service's memory guardrail. + size_t size_bytes() const { return memory_->size(); } + + private: + friend class test::ServiceRingBufferDrainerTestPeer; + + // SharedRingBufferReader::Delegate implementation. + // The reader calls these inline during Drain(). + void OnChunkRead(const SharedRingBufferReader::ChunkContents&) override; + void OnDataLoss(WriterID) override; + + // Marks a gap in the sequence for |writer_id| in its destination buffer. + void RecordWriterLoss(WriterID writer_id); + + // Trusted identity supplied by the endpoint. + const ProducerID producer_id_; + const ClientIdentity client_identity_; + + Delegate* const delegate_; + + // Declared before |ring_buffer_| and |reader_| so the mapping outlives them. + std::shared_ptr memory_; + + // Constructing |ring_buffer_| leaves the contents of |memory_| unchanged, + // preserving any data the producer has already written. + SharedRingBuffer ring_buffer_; + SharedRingBufferReader reader_; + + bool retry_scheduled_ = false; + + PERFETTO_THREAD_CHECKER(thread_checker_) + + // Declared last to cancel retry tasks before reader or mapping destruction. + base::WeakRunner weak_runner_; +}; + +} // namespace tracing_v2 +} // namespace perfetto + +#endif // SRC_TRACING_SERVICE_SERVICE_RING_BUFFER_DRAINER_H_ +// gen_amalgamated begin header: src/tracing/service/trace_buffer.h // gen_amalgamated begin header: src/tracing/service/histogram.h /* * Copyright (C) 2023 The Android Open Source Project @@ -60649,7 +68748,6 @@ class Histogram { } // namespace perfetto #endif // SRC_TRACING_SERVICE_HISTOGRAM_H_ -// gen_amalgamated begin header: src/tracing/service/trace_buffer.h /* * Copyright (C) 2018 The Android Open Source Project * @@ -60672,6 +68770,7 @@ class Histogram { #include #include #include +#include // gen_amalgamated expanded: #include "perfetto/ext/base/flat_hash_map.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h" @@ -60679,9 +68778,14 @@ class Histogram { // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_stats.h" // gen_amalgamated expanded: #include "src/tracing/service/histogram.h" +namespace protozero { +struct ConstBytes; +} // namespace protozero + namespace perfetto { class TracePacket; +class TraceBufferProtoVms; class TraceBuffer_WriterStats; // Virtual interface for trace buffers to enable multiple implementations. @@ -60743,6 +68847,54 @@ class TraceBuffer { size_t patches_size, bool other_patches_pending) = 0; + // Returns true if the buffer accepts tracing v2 data through + // CopyChunkV2Untrusted(). The service offers tracing v2 only to data sources + // that write into such a buffer. + virtual bool supports_tracing_v2() const = 0; + + // Copies a batch of SMB v2 fragments into the buffer. The caller must pass + // fragments and batches in write order for each {ProducerID, WriterID}. + // The caller owns the fragment array and payloads. Both must remain valid + // and unchanged until this call returns. + // + // Each fragment is a whole packet unless a continuation flag is set. + // - |first_continues_from_prev| means the first fragment continues a packet + // that started in this writer's previous batch. + // - |last_continues_on_next| means the last fragment continues in this + // writer's next batch. + // The caller decodes these flags from its transport. If the transport marks + // a batch as lossy, call RecordChunkV2DataLoss() instead of copying it. + // + // Returns true if the whole batch was stored. Returns false if the batch + // was rejected: + // - The rejection of a nonempty batch records loss as RecordChunkV2DataLoss() + // does. An empty batch changes nothing. + // - Invalid input increments abi_violations. Other rejections increment + // chunks_discarded. + // + // If supports_tracing_v2() is false, returns false and changes nothing. + virtual bool CopyChunkV2Untrusted(const PacketSequenceProperties&, + const protozero::ConstBytes* fragments, + size_t num_fragments, + bool first_continues_from_prev, + bool last_continues_on_next) = 0; + + // Records a gap after the last SMB v2 batch that the writer appended. + // Packets already in the buffer remain readable. The gap stays pending + // until the next stored batch carries it or the writer's state is discarded. + // Reads report the gap on the first readable packet after it. This does not + // increment any statistics. + // + // Does nothing if the buffer holds no SMB v2 state for the writer. A caller + // that cannot identify the destination can call this on every candidate + // buffer without creating state for writers that never used it. + virtual void RecordChunkV2DataLoss(ProducerID, WriterID) = 0; + + // Increments abi_violations for a violation that the caller found outside + // this buffer, e.g. a protocol error in a producer's ring buffer. This only + // updates the statistic and does not record a gap on any packet sequence. + virtual void RecordAbiViolation() = 0; + // To read the contents of the buffer the caller needs to: // BeginRead() // while (ReadNextTracePacket(packet_fragments)) { ... } @@ -60763,10 +68915,23 @@ class TraceBuffer { PacketSequenceProperties* sequence_properties, uint32_t* previous_packet_on_sequence_dropped) = 0; + // Attempts to reclaim unused buffer space. + // The caller must release all packets from previous reads before this call, + // because their slices can point into the buffer. + // Call BeginRead() before reading again. + virtual void MaybeCompact() = 0; + // Creates a read-only clone of the trace buffer. The read iterators of the // new buffer will be reset, as if no Read() had been called. virtual std::unique_ptr CloneReadOnly() const = 0; + // Returns the ProtoVM state owned by this buffer, or nullptr if the + // implementation cannot run a ProtoVM. The pointer remains valid until the + // buffer is destroyed. + // The service uses it to set up VMs and emit their state. The buffer feeds + // packets to the VMs before overwriting them. + virtual TraceBufferProtoVms* protovms() = 0; + virtual void set_read_only() = 0; virtual const TraceStats::BufferStats& stats() const = 0; virtual const WriterStats& writer_stats() const = 0; @@ -60791,6 +68956,19 @@ class TraceBuffer_WriterStats { base::QuadraticProbe, /*AppendOnly=*/true>; + TraceBuffer_WriterStats() = default; + TraceBuffer_WriterStats(const TraceBuffer_WriterStats& other) { + for (auto it = other.map_.GetIterator(); it; ++it) + map_.Insert(it.key(), it.value()); + } + TraceBuffer_WriterStats& operator=(const TraceBuffer_WriterStats& other) { + if (this != &other) { + this->~TraceBuffer_WriterStats(); + new (this) TraceBuffer_WriterStats(other); + } + return *this; + } + void Insert(ProducerAndWriterID key, HistValue val) { map_.Insert(key, {}).first->Add(val); } @@ -60804,6 +68982,405 @@ class TraceBuffer_WriterStats { } // namespace perfetto #endif // SRC_TRACING_SERVICE_TRACE_BUFFER_H_ +/* + * Copyright (C) 2026 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "src/tracing/service/service_ring_buffer_drainer.h" + +#include + +// gen_amalgamated expanded: #include "perfetto/base/compiler.h" +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer.h" + +namespace perfetto::tracing_v2 { + +namespace { + +// Delay retries so writers that repeatedly win chunk state transitions +// cannot keep the service sequence busy. +constexpr uint32_t kDrainRetryDelayMs = 1; + +} // namespace + +ServiceRingBufferDrainer::Delegate::~Delegate() = default; + +ServiceRingBufferDrainer::ServiceRingBufferDrainer( + std::shared_ptr memory, + uint32_t chunk_size_bytes, + ProducerID producer_id, + ClientIdentity client_identity, + Delegate* delegate, + base::TaskRunner* task_runner) + : producer_id_(producer_id), + client_identity_(client_identity), + delegate_(delegate), + memory_(std::move(memory)), + ring_buffer_(static_cast(memory_->start()), + memory_->size(), + chunk_size_bytes), + reader_(&ring_buffer_, this), + weak_runner_(task_runner) {} + +ServiceRingBufferDrainer::~ServiceRingBufferDrainer() { + PERFETTO_DCHECK_THREAD(thread_checker_); +} + +void ServiceRingBufferDrainer::Drain() { + PERFETTO_DCHECK_THREAD(thread_checker_); + + if (PERFETTO_UNLIKELY(reader_.has_protocol_error())) + return; + + // Bound each pass to num_chunks() logical positions, including positions + // reserved during the pass. + const SharedRingBufferReader::Stats stats_before = reader_.GetStats(); + const auto result = reader_.Drain(ring_buffer_.num_chunks()); + const SharedRingBufferReader::Stats stats_after = reader_.GetStats(); + + // The reader discards malformed chunks and chunks in an unknown format. It + // reports them as loss for the writer. Count them here, once per pass. + const uint64_t num_rejected = + (stats_after.malformed_chunks - stats_before.malformed_chunks) + + (stats_after.unsupported_format_chunks - + stats_before.unsupported_format_chunks); + if (PERFETTO_UNLIKELY(num_rejected != 0)) + delegate_->OnRingBufferChunksDiscarded(num_rejected); + + if (PERFETTO_UNLIKELY(reader_.has_protocol_error())) { + // Record the error in every authorized destination. Later drains return + // above, so each destination counts this violation only once. + delegate_->ForEachV2RingBufferDestination( + [](TraceBuffer& buffer) { buffer.RecordAbiViolation(); }); + return; + } + + if (result.needs_another_drain() && !retry_scheduled_) { + retry_scheduled_ = true; + weak_runner_.PostDelayedTask( + [this] { + // Clear the flag so Drain() can schedule another retry if needed. + retry_scheduled_ = false; + Drain(); + }, + kDrainRetryDelayMs); + } +} + +void ServiceRingBufferDrainer::OnChunkRead( + const SharedRingBufferReader::ChunkContents& chunk) { + if (PERFETTO_UNLIKELY(!chunk.writer_id || chunk.writer_id > kMaxWriterID)) { + delegate_->OnRingBufferChunksDiscarded(1); + return; + } + + TraceBuffer* buffer = + delegate_->GetV2RingBufferDestination(chunk.target_buffer); + if (PERFETTO_UNLIKELY(!buffer)) { + delegate_->OnRingBufferChunksDiscarded(1); + RecordWriterLoss(chunk.writer_id); + return; + } + + // The reader reports a chunk with kFlagDataLoss through OnDataLoss(). Only + // the continuation flags can reach this point. + PERFETTO_DCHECK(!(chunk.payload_flags & kFlagDataLoss)); + const TraceBuffer::PacketSequenceProperties sequence{ + producer_id_, client_identity_, chunk.writer_id}; + // On rejection, the trace buffer counts the chunk in its own statistics and + // records the loss on the sequence. + // + // TODO(sashwinbalaji): the payload is copied twice: from shared memory into + // the reader's scratch, then into a TBv2 chunk. The reader could pass the + // decoded sizes and one payload range, so that TBv2 copies once. Measure + // the drain cost in a profile first. + buffer->CopyChunkV2Untrusted( + sequence, chunk.fragments, chunk.num_fragments, + chunk.payload_flags & kFlagContinuesFromPrevChunk, + chunk.payload_flags & kFlagContinuesOnNextChunk); +} + +void ServiceRingBufferDrainer::OnDataLoss(WriterID writer_id) { + // Record the loss in |writer_id|'s sequence so it can be reported through + // previous_packet_dropped. + // + // Drain() counts chunks discarded by the reader in chunks_discarded. + // Loss reported by the producer does not increase that counter. + RecordWriterLoss(writer_id); +} + +void ServiceRingBufferDrainer::RecordWriterLoss(WriterID writer_id) { + if (!writer_id || writer_id > kMaxWriterID) + return; + // The destination of a lost chunk is unknown. RecordChunkV2DataLoss() changes + // only a buffer that holds this writer's sequence. + // - A writer has one destination, so at most one buffer matches. + // - Before the writer's first stored chunk, no buffer matches. + delegate_->ForEachV2RingBufferDestination( + [this, writer_id](TraceBuffer& buffer) { + buffer.RecordChunkV2DataLoss(producer_id_, writer_id); + }); +} + +} // namespace perfetto::tracing_v2 +// gen_amalgamated begin source: src/tracing/service/trace_buffer_protovms.cc +// gen_amalgamated begin header: src/tracing/service/trace_buffer_protovms.h +/* + * Copyright (C) 2026 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SRC_TRACING_SERVICE_TRACE_BUFFER_PROTOVMS_H_ +#define SRC_TRACING_SERVICE_TRACE_BUFFER_PROTOVMS_H_ + +#include +#include + +#include +#include +#include + +// gen_amalgamated expanded: #include "perfetto/base/flat_set.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h" + +namespace perfetto { + +class TracePacket; + +namespace protovm { +class Vm; +} + +// Owns the ProtoVM instances for one trace buffer (go/perfetto-proto-vm). +// When the buffer is about to overwrite a packet, it passes the packet to +// MaybeProcessOverwrittenPacket() to merge it into a ProtoVM's incremental +// state. The service emits this state when it reads the buffer. +// +// The buffer decides which packets to pass here. They must be length-delimited +// protobuf and arrive in write order within each packet sequence. +class TraceBufferProtoVms { + public: + // A ProtoVM instance and the producers whose packets it processes. + struct Vm { + Vm(); + ~Vm(); + Vm(Vm&&) noexcept; + + Vm CloneReadOnly() const; + + std::unique_ptr instance; + std::string data_source_name; + uint64_t program_hash = 0; + uint32_t memory_limit_kb = 0; + base::FlatSet producers; + }; + + TraceBufferProtoVms(); + ~TraceBufferProtoVms(); + + TraceBufferProtoVms(const TraceBufferProtoVms&) = delete; + TraceBufferProtoVms& operator=(const TraceBufferProtoVms&) = delete; + + // Adds |producer_id| to the ProtoVM that runs |program_bytes| for + // |data_source_name|. Creates that ProtoVM if it does not exist. + void MaybeSetUp(const std::string& data_source_name, + const std::string& program_bytes, + uint32_t memory_limit_kb, + ProducerID producer_id); + + // Tries each ProtoVM registered for |producer| until ApplyPatch() succeeds. + // Does nothing if the producer has no ProtoVM. + void MaybeProcessOverwrittenPacket(const TracePacket&, ProducerID producer); + + // Replaces this object's instances with read-only clones from |src|. + // If any clone fails, clears all instances from this object. + void CloneReadOnlyFrom(const TraceBufferProtoVms& src); + + bool HasProducer(ProducerID) const; + size_t GetMemoryUsageBytes() const; + + bool empty() const { return vms_.empty(); } + const std::vector& instances() const { return vms_; } + + private: + std::vector vms_; + + // Contiguous storage for a packet's slices, as required by ProtoVM's + // protozero decoder. We reuse it across packets and only allocate when + // it needs to grow. + std::string patch_; +}; + +} // namespace perfetto + +#endif // SRC_TRACING_SERVICE_TRACE_BUFFER_PROTOVMS_H_ +/* + * Copyright (C) 2026 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_protovms.h" + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/murmur_hash.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h" +// gen_amalgamated expanded: #include "perfetto/protozero/field.h" +// gen_amalgamated expanded: #include "src/protovm/vm.h" + +namespace perfetto { + +TraceBufferProtoVms::Vm::Vm() = default; +TraceBufferProtoVms::Vm::~Vm() = default; +TraceBufferProtoVms::Vm::Vm(Vm&&) noexcept = default; + +TraceBufferProtoVms::Vm TraceBufferProtoVms::Vm::CloneReadOnly() const { + Vm cloned_vm; + cloned_vm.data_source_name = data_source_name; + cloned_vm.program_hash = program_hash; + cloned_vm.memory_limit_kb = memory_limit_kb; + cloned_vm.producers = producers; + cloned_vm.instance = instance->CloneReadOnly(); + return cloned_vm; +} + +TraceBufferProtoVms::TraceBufferProtoVms() = default; +TraceBufferProtoVms::~TraceBufferProtoVms() = default; + +void TraceBufferProtoVms::MaybeSetUp(const std::string& data_source_name, + const std::string& program_bytes, + uint32_t memory_limit_kb, + ProducerID producer_id) { + Vm* vm = nullptr; + // Re-use existing ProtoVM instance, if any. + uint64_t program_hash = base::MurmurHashValue(program_bytes); + auto vm_it = std::find_if(vms_.begin(), vms_.end(), [&](const Vm& other) { + return other.data_source_name == data_source_name && + other.program_hash == program_hash; + }); + if (vm_it != vms_.end()) { + vm = &(*vm_it); + } else { + // Otherwise instantiate new ProtoVM + Vm new_vm; + new_vm.data_source_name = data_source_name; + new_vm.program_hash = program_hash; + new_vm.memory_limit_kb = memory_limit_kb; + + protozero::ConstBytes program_bytes_view{ + reinterpret_cast(program_bytes.data()), + program_bytes.size()}; + + new_vm.instance = std::make_unique( + program_bytes_view, new_vm.memory_limit_kb * 1024); + if (!new_vm.instance) { + PERFETTO_ELOG("Failed to allocate ProtoVM"); + return; + } + + vms_.push_back(std::move(new_vm)); + vm = &vms_.back(); + } + // Update ProtoVM's producer IDs + vm->producers.insert(producer_id); +} + +void TraceBufferProtoVms::MaybeProcessOverwrittenPacket( + const TracePacket& packet, + ProducerID producer) { + patch_.clear(); + + for (auto& vm : vms_) { + if (vm.producers.find(producer) == vm.producers.end()) { + continue; + } + // TODO(keanmariotti): add an optimized path for the case + // "packet.slices().size() == 1" (zero copy) + if (patch_.empty()) { + packet.GetRawBytes(&patch_); + } + protozero::ConstBytes bytes{reinterpret_cast(patch_.data()), + patch_.size()}; + auto status = vm.instance->ApplyPatch(bytes); + if (status.IsOk()) { + break; + } + if (status.IsAbort()) { + // TODO(keanmariotti): consider doing something more here. Ideally + // triggering a field upload containing the stacktrace. + PERFETTO_ELOG("ProtoVM abort while applying patch. Stacktrace:\n%s", + base::Join(status.stacktrace(), "\n").c_str()); + } + } +} + +void TraceBufferProtoVms::CloneReadOnlyFrom(const TraceBufferProtoVms& src) { + vms_.clear(); + for (const auto& vm : src.vms_) { + auto vm_cloned = vm.CloneReadOnly(); + if (!vm_cloned.instance) { + PERFETTO_ELOG("Failed to clone ProtoVMs"); + vms_.clear(); + break; + } + vms_.push_back(std::move(vm_cloned)); + } +} + +bool TraceBufferProtoVms::HasProducer(ProducerID producer) const { + return std::any_of(vms_.begin(), vms_.end(), [&](const Vm& vm) { + return vm.producers.count(producer) != 0; + }); +} + +size_t TraceBufferProtoVms::GetMemoryUsageBytes() const { + size_t total_bytes = 0; + for (const Vm& vm : vms_) + total_bytes += vm.instance->GetMemoryUsageBytes(); + return total_bytes; +} + +} // namespace perfetto +// gen_amalgamated begin source: src/tracing/service/trace_buffer_v1.cc +// gen_amalgamated begin header: src/tracing/service/trace_buffer_v1.h /* * Copyright (C) 2018 The Android Open Source Project * @@ -61013,6 +69590,21 @@ class TraceBufferV1 : public TraceBuffer { size_t patches_size, bool other_patches_pending) override; + // Returns false as TraceBufferV1 only accepts SMB v1 chunks. + bool supports_tracing_v2() const override; + + // Returns false without changing the buffer or its statistics. + bool CopyChunkV2Untrusted(const PacketSequenceProperties&, + const protozero::ConstBytes* fragments, + size_t num_fragments, + bool first_continues_from_prev, + bool last_continues_on_next) override; + + // No-op because TraceBufferV1 holds no SMB v2 state. + void RecordChunkV2DataLoss(ProducerID, WriterID) override; + + void RecordAbiViolation() override; + // To read the contents of the buffer the caller needs to: // BeginRead() // while (ReadNextTracePacket(packet_fragments)) { ... } @@ -61054,11 +69646,17 @@ class TraceBufferV1 : public TraceBuffer { PacketSequenceProperties* sequence_properties, uint32_t* previous_packet_on_sequence_dropped) override; + // No-op. TraceBufferV1 does not compact its buffer. + void MaybeCompact() override; + // Creates a read-only clone of the trace buffer. Calls to // CopyChunkUntrusted() and TryPatchChunkContents() on the returned cloned // TraceBuffer will CHECK(). std::unique_ptr CloneReadOnly() const override; + // Returns nullptr because TraceBufferV1 cannot run a ProtoVM. + TraceBufferProtoVms* protovms() override; + void set_read_only() override { read_only_ = true; } const TraceStats::BufferStats& stats() const override { return stats_; } const WriterStats& writer_stats() const override { return writer_stats_; } @@ -61984,6 +70582,24 @@ bool TraceBufferV1::TryPatchChunkContents(ProducerID producer_id, return true; } +bool TraceBufferV1::supports_tracing_v2() const { + return false; +} + +bool TraceBufferV1::CopyChunkV2Untrusted(const PacketSequenceProperties&, + const protozero::ConstBytes*, + size_t, + bool, + bool) { + return false; +} + +void TraceBufferV1::RecordChunkV2DataLoss(ProducerID, WriterID) {} + +void TraceBufferV1::RecordAbiViolation() { + stats_.set_abi_violations(stats_.abi_violations() + 1); +} + void TraceBufferV1::BeginRead() { read_iter_ = GetReadIterForSequence(index_.begin()); #if PERFETTO_DCHECK_IS_ON() @@ -62247,6 +70863,8 @@ bool TraceBufferV1::ReadNextTracePacket( } // for(;;MoveNext()) [iterate over chunks]. } +void TraceBufferV1::MaybeCompact() {} + TraceBufferV1::ReadAheadResult TraceBufferV1::ReadAhead(TracePacket* packet) { static_assert(static_cast(kMaxChunkID + 1) == 0, "relying on kMaxChunkID to wrap naturally"); @@ -62433,6 +71051,10 @@ std::unique_ptr TraceBufferV1::CloneReadOnly() const { return buf; } +TraceBufferProtoVms* TraceBufferV1::protovms() { + return nullptr; +} + TraceBufferV1::TraceBufferV1(CloneCtor, const TraceBufferV1& src) : overwrite_policy_(src.overwrite_policy_), read_only_(true), @@ -62876,203 +71498,6 @@ class CircularQueue { } // namespace perfetto #endif // INCLUDE_PERFETTO_EXT_BASE_CIRCULAR_QUEUE_H_ -// gen_amalgamated begin header: include/perfetto/ext/base/small_vector.h -/* - * Copyright (C) 2021 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef INCLUDE_PERFETTO_EXT_BASE_SMALL_VECTOR_H_ -#define INCLUDE_PERFETTO_EXT_BASE_SMALL_VECTOR_H_ - -#include -#include -#include - -// gen_amalgamated expanded: #include "perfetto/base/compiler.h" -// gen_amalgamated expanded: #include "perfetto/base/logging.h" -// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h" - -namespace perfetto { -namespace base { - -// Uses inline storage first, switches to dynamic storage when it overflows. -template -class SmallVector { - public: - static constexpr size_t kInlineSize = kSize; - - explicit SmallVector() = default; - - ~SmallVector() { - clear(); - if (PERFETTO_UNLIKELY(is_using_heap())) - AlignedFree(begin_); - begin_ = end_ = end_of_storage_ = nullptr; - } - - // Move operators. - SmallVector(SmallVector&& other) noexcept( - std::is_nothrow_move_constructible::value) { - if (other.is_using_heap()) { - // Move the heap content, no need to move the individual objects as their - // location won't change. - begin_ = other.begin_; - end_ = other.end_; - end_of_storage_ = other.end_of_storage_; - } else { - const size_t other_size = other.size(); - PERFETTO_DCHECK(other_size <= capacity()); - for (size_t i = 0; i < other_size; i++) { - // Move the entries and destroy the ones in the moved-from object. - new (&begin_[i]) T(std::move(other.begin_[i])); - other.begin_[i].~T(); - } - end_ = begin_ + other_size; - } - auto* const other_inline_storage = other.inline_storage_begin(); - other.end_ = other.begin_ = other_inline_storage; - other.end_of_storage_ = other_inline_storage + kInlineSize; - } - - SmallVector& operator=(SmallVector&& other) noexcept( - std::is_nothrow_move_constructible::value) { - this->~SmallVector(); - new (this) SmallVector(std::move(other)); - return *this; - } - - // Copy operators. - SmallVector(const SmallVector& other) { - const size_t other_size = other.size(); - if (other_size > capacity()) - Grow(other_size); - // Copy-construct the elements. - for (size_t i = 0; i < other_size; ++i) - new (&begin_[i]) T(other.begin_[i]); - end_ = begin_ + other_size; - } - - SmallVector& operator=(const SmallVector& other) { - if (PERFETTO_UNLIKELY(this == &other)) - return *this; - this->~SmallVector(); - new (this) SmallVector(other); - return *this; - } - - T* data() { return begin_; } - const T* data() const { return begin_; } - - T* begin() { return begin_; } - const T* begin() const { return begin_; } - - T* end() { return end_; } - const T* end() const { return end_; } - - size_t size() const { return static_cast(end_ - begin_); } - - bool empty() const { return end_ == begin_; } - - size_t capacity() const { - return static_cast(end_of_storage_ - begin_); - } - - T& front() { - PERFETTO_DCHECK(!empty()); - return begin_[0]; - } - const T& front() const { - PERFETTO_DCHECK(!empty()); - return begin_[0]; - } - - T& back() { - PERFETTO_DCHECK(!empty()); - return end_[-1]; - } - const T& back() const { - PERFETTO_DCHECK(!empty()); - return end_[-1]; - } - - T& operator[](size_t index) { - PERFETTO_DCHECK(index < size()); - return begin_[index]; - } - - const T& operator[](size_t index) const { - PERFETTO_DCHECK(index < size()); - return begin_[index]; - } - - template - void emplace_back(Args&&... args) { - T* end = end_; - if (PERFETTO_UNLIKELY(end == end_of_storage_)) - end = Grow(); - new (end) T(std::forward(args)...); - end_ = end + 1; - } - - void pop_back() { - PERFETTO_DCHECK(!empty()); - back().~T(); - --end_; - } - - // Clear without reverting back to inline storage. - void clear() { - while (!empty()) - pop_back(); - } - - private: - PERFETTO_NO_INLINE T* Grow(size_t desired_capacity = 0) { - size_t cur_size = size(); - size_t new_capacity = desired_capacity; - if (desired_capacity <= cur_size) - new_capacity = std::max(capacity() * 2, size_t(128)); - T* new_storage = - static_cast(AlignedAlloc(alignof(T), new_capacity * sizeof(T))); - for (size_t i = 0; i < cur_size; ++i) { - // Move the elements into the new heap buffer and destroy the old ones. - new (&new_storage[i]) T(std::move(begin_[i])); - begin_[i].~T(); - } - if (is_using_heap()) - AlignedFree(begin_); - begin_ = new_storage; - end_ = new_storage + cur_size; - end_of_storage_ = new_storage + new_capacity; - return end_; - } - - T* inline_storage_begin() { return reinterpret_cast(inline_storage_); } - bool is_using_heap() { return begin_ != inline_storage_begin(); } - - T* begin_ = inline_storage_begin(); - T* end_ = begin_; - T* end_of_storage_ = begin_ + kInlineSize; - - alignas(T) char inline_storage_[sizeof(T) * kInlineSize]; -}; - -} // namespace base -} // namespace perfetto - -#endif // INCLUDE_PERFETTO_EXT_BASE_SMALL_VECTOR_H_ /* * Copyright (C) 2025 The Android Open Source Project * @@ -63098,8 +71523,8 @@ class SmallVector { #include #include #include +#include -// gen_amalgamated expanded: #include "perfetto/base/flat_set.h" // gen_amalgamated expanded: #include "perfetto/base/logging.h" // gen_amalgamated expanded: #include "perfetto/ext/base/circular_queue.h" // gen_amalgamated expanded: #include "perfetto/ext/base/flat_hash_map.h" @@ -63112,18 +71537,17 @@ class SmallVector { // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/slice.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_stats.h" +// gen_amalgamated expanded: #include "perfetto/protozero/field.h" // gen_amalgamated expanded: #include "src/tracing/service/histogram.h" +// gen_amalgamated expanded: #include "src/tracing/service/proto_group_rewriter.h" // gen_amalgamated expanded: #include "src/tracing/service/trace_buffer.h" +// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_protovms.h" namespace perfetto { class TracePacket; class TraceBufferV2; -namespace protovm { -class Vm; -} - namespace internal { // See /docs/design-docs/trace-buffer.md for details about the design and @@ -63132,8 +71556,8 @@ namespace internal { // +---------------------------------------------------------------------------+ // | TBChunk | // +---------------------------------------------------------------------------+ -// TBChunk is the struct, stored in the trace buffer memory as a result of -// calling CopyChunkUntrusted from a SMB chunk. +// TBChunk stores fragments copied into the trace buffer, either from SMB chunks +// by CopyChunkUntrusted() or from the newer SMB v2 by CopyChunkV2Untrusted(). // TBChunk exists only in the TraceBuffer PagedMemory `data_`, never on the // stack or on the heap. It is followed by the fragments and alignment padding. // A TBChunk is very similar to a SMB chunk with the following caveats: @@ -63161,6 +71585,7 @@ struct TBChunk { } // The ChunkID, as specified by the TraceWriter in the original SMB chunk. + // Unused for SMB v2 sequences, whose chunks are appended in order. ChunkID chunk_id = 0; // A combination of producer and writer ID. This forms the primary key to @@ -63186,9 +71611,10 @@ struct TBChunk { // unconsumed fragment header (the varint with the size). uint16_t payload_avail = 0; - // These are == the SharedMemoryABI's chunk flags, with the addition of - // MSB flags added by TraceBufferV2 like kChunkIncomplete (0x80) which doesn't - // exist at the ABI level, but are synthesized here. + // SharedMemoryABI chunk flags, with additional bits set by TraceBufferV2: + // kChunkIncomplete (0x80) for scraped chunks and kChunkLossBefore (0x40) for + // a gap before an SMB v2 chunk. These additional bits never come from + // the producer. uint8_t flags = 0; // This is used for (D)CHECKS to verify the integrity of the chunk. @@ -63272,11 +71698,38 @@ struct SequenceState { // copies it into previous_packet_dropped and resets it. Zero means no loss. uint32_t data_loss_reasons = 0; - // An ordered list of chunk offsets, sorted by their ChunkID. Each member - // corresponsds to the offset within buf_ for the chunk. + // An ordered list of chunk offsets, sorted by ChunkID for SMB sequences or + // by append order for SMB v2 sequences. // We store buffer offsets rather than pointers to make buffer cloning easier. // This is effectively a deque of TBChunk* (% a call to GetTBChunkAt(off)). base::CircularQueue chunks; + + // All chunks of a sequence use the same format: either the legacy SMB v1 or + // the newer proto-group based SMB v2. SMB v2 chunks are immutable, arrive in + // order and need rewriting at readback. + bool is_smb_v2 = false; + + // A gap after the last appended SMB v2 chunk, not yet stamped on a + // chunk. + // - SMB sequences need no such state. A gap shows up as a non-successor + // ChunkID, so the reader finds it at the right position by itself. + // - SMB v2 chunks have no ChunkID. The gap must be recorded when it + // happens, at the position between two chunks. + // - data_loss_reasons cannot hold it. The reader reports that on the next + // packet it reads, which can be an older packet buffered before the gap. + // The next append moves this flag to kChunkLossBefore on its chunk. The + // reader then reports the loss on the first packet after the gap. + // + // Example for one writer: + // + // Step Buffer pending_chunk_v2_data_loss + // Append(A) [A] false + // RecordChunkV2DataLoss() [A] true + // Append(C) [A] [C*] false, moved to C as * + // + // * = kChunkLossBefore. A read returns A with no loss, then C with + // DATA_LOSS_READ_GAP. + bool pending_chunk_v2_data_loss = false; }; // +---------------------------------------------------------------------------+ @@ -63464,6 +71917,10 @@ class ChunkSeqReader { // +---------------------------------------------------------------------------+ // | TraceBufferV2 | // +---------------------------------------------------------------------------+ +// TODO(b/559531402): Rename trace_buffer_v1 to trace_buffer_legacy +// (TraceBufferLegacy), and trace_buffer_v2 to trace_buffer_impl +// (TraceBufferImpl). The "v2" here is easy to confuse with tracing v2 (the +// SMB v2 transport), which this buffer also stores. class TraceBufferV2 : public TraceBuffer { public: using TBChunk = internal::TBChunk; @@ -63471,20 +71928,6 @@ class TraceBufferV2 : public TraceBuffer { using Patch = TraceBuffer::Patch; using PacketSequenceProperties = TraceBuffer::PacketSequenceProperties; - // Represents a ProtoVM instance and some metadata - struct Vm { - Vm(); - ~Vm(); - Vm(Vm&&) noexcept; - Vm CloneReadOnly() const; - - std::unique_ptr instance; - std::string data_source_name; - uint64_t program_hash = 0; - uint32_t memory_limit_kb = 0; - base::FlatSet producers; - }; - // Can return nullptr if the memory allocation fails. static std::unique_ptr Create(size_t size_in_bytes, OverwritePolicy = kOverwrite); @@ -63540,12 +71983,34 @@ class TraceBufferV2 : public TraceBuffer { size_t patches_size, bool other_patches_pending) override; - void MaybeSetUpProtoVm(const std::string& data_source_name, - const std::string& program_bytes, - uint32_t memory_limit_kb, - ProducerID producer_id); + // Returns true. Both SMB v1 and SMB v2 writers can use this buffer, but each + // {ProducerID, WriterID} sequence must use one format throughout its + // lifetime. + bool supports_tracing_v2() const override; - const std::vector& GetProtoVmInstances() const { return protovms_; } + // Stores the batch in one TBChunk. See TraceBuffer::CopyChunkV2Untrusted() + // for ownership, ordering, continuation flags and loss reporting. + // + // Invalid input increments abi_violations. This includes a null fragment + // array, a nonempty fragment with a null payload, a batch larger than one + // TBChunk or than the whole buffer, or a writer ID whose sequence already + // holds SMB v1 chunks. + // + // Rejection because a kDiscard buffer is full or the producer has a ProtoVM + // on this buffer increments chunks_discarded. Once a kDiscard buffer stops + // accepting writes, it rejects later batches without validating their input. + bool CopyChunkV2Untrusted(const PacketSequenceProperties& sequence, + const protozero::ConstBytes* fragments, + size_t num_fragments, + bool first_continues_from_prev, + bool last_continues_on_next) override; + + // Keeps the gap in the writer's SequenceState until the next stored batch + // carries it as kChunkLossBefore. If DeleteStaleEmptySequences() prunes the + // state before another batch arrives, the pending gap is forgotten. + void RecordChunkV2DataLoss(ProducerID, WriterID) override; + + void RecordAbiViolation() override; // To read the contents of the buffer the caller needs to: // BeginRead() @@ -63556,13 +72021,18 @@ class TraceBufferV2 : public TraceBuffer { void BeginRead() override; // Returns the next packet in the buffer, if any, and the producer/writer - // identity that wrote it (as passed in the CopyChunkUntrusted() call). + // identity supplied when the sequence was created. // Returns false if no packets can be read at this point. // If a packet was read successfully, |previous_packet_on_sequence_dropped| // signals whether any data loss has been detected on the sequence // (e.g. because its chunk was overridden due to the ring buffer wrapping or // due to an ABI violation), and to |false| otherwise. // + // SMB v2 packets are reassembled and rewritten to length-delimited + // protobuf. Malformed packets and packets that length-delimited protobuf + // cannot encode are dropped, with loss reported on the next readable packet + // in the sequence. + // // This function returns only complete packets. Specifically: // When there is at least one complete packet in the buffer, this function // returns true and populates the TracePacket argument with the boundaries of @@ -63587,22 +72057,38 @@ class TraceBufferV2 : public TraceBuffer { PacketSequenceProperties* sequence_properties, uint32_t* previous_packet_on_sequence_dropped) override; + // Compacts the buffer by moving live chunks to the front in ring order. + // It clears the unused tail and retains pages for the old |used_size_| plus + // 1/|kSpareCapacityDivisor| of it, capped at the buffer size. + // It advises the OS to release the whole pages after that range. + // If live chunks are on both sides of the write cursor, it skips compaction. + // + // Compaction can invalidate packet slices from earlier reads, so the caller + // must not use those packets after MaybeCompact(). + // + // This is a no-op if the buffer is read-only or if it is a kDiscard buffer. + void MaybeCompact() override; + // Creates a read-only clone of the trace buffer. The read iterators of the - // new buffer will be reset, as if no Read() had been called. Calls to - // CopyChunkUntrusted() and TryPatchChunkContents() on the returned cloned - // TraceBuffer will CHECK(). + // new buffer will be reset. + // + // Calls to CopyChunkUntrusted(), CopyChunkV2Untrusted(), + // TryPatchChunkContents(), RecordChunkV2DataLoss() or RecordAbiViolation() + // on the returned clone will CHECK(). std::unique_ptr CloneReadOnly() const override; + TraceBufferProtoVms* protovms() override; + + void set_read_only() override { read_only_ = true; } + const TraceStats::BufferStats& stats() const override { return stats_; } + const WriterStats& writer_stats() const override { return writer_stats_; } size_t size() const override { return size_; } size_t used_size() const override { return used_size_; } size_t GetMemoryUsageBytes() const override; OverwritePolicy overwrite_policy() const override { return overwrite_policy_; } - const TraceStats::BufferStats& stats() const override { return stats_; } - const WriterStats& writer_stats() const override { return writer_stats_; } - bool has_data() const override { return used_size_ > 0; } - void set_read_only() override { read_only_ = true; } + bool has_data() const override { return has_data_; } BufType buf_type() const override { return kV2; } void DumpForTesting(); @@ -63627,14 +72113,29 @@ class TraceBufferV2 : public TraceBuffer { bool Initialize(size_t size); TBChunk* CreateTBChunk(size_t off, size_t payload_size); + + // Prepares contiguous storage at wr_. The caller checks that size <= size_. + // May evict chunks and wrap. Does not prune sequences or change stats for + // rejected writes. Returns false if the write reaches the end of a kDiscard + // buffer. The caller then seals the buffer with DiscardWrite(). + bool MakeSpaceToWrite(size_t size); void DeleteNextChunksFor(size_t bytes_to_clear); + // Makes a reassembled SMB v2 packet length-delimited protobuf. A packet + // without nested messages keeps its slices into the buffer, as an SMB + // packet does. Otherwise the packet gets one owned slice. Returns false, + // leaving the packet unchanged, for: + // - malformed input, counted in abi_violations. + // - a packet that length-delimited protobuf cannot encode, counted in + // oversized_packets_dropped. + bool RewriteProtoGroupPacket(TracePacket*); + void DcheckIsAlignedAndWithinBounds(size_t off) const { PERFETTO_DCHECK((off & (alignof(TBChunk) - 1)) == 0); PERFETTO_DCHECK(off <= size_ - sizeof(TBChunk)); } - // This should only be used when followed by a placement new. + // Used for placement new and to update the checksum after moving a chunk. TBChunk* GetTBChunkAtUnchecked(size_t off) { DcheckIsAlignedAndWithinBounds(off); return reinterpret_cast(begin() + off); @@ -63665,7 +72166,6 @@ class TraceBufferV2 : public TraceBuffer { void DiscardWrite(); void DeleteStaleEmptySequences(); - void MaybeProcessOverwrittenPacketWithProtoVm(const TracePacket&, ProducerID); uint8_t* begin() const { return reinterpret_cast(data_.Get()); } uint8_t* end() const { return begin() + size_; } @@ -63674,11 +72174,24 @@ class TraceBufferV2 : public TraceBuffer { base::PagedMemory data_; size_t size_ = 0; // Size in bytes of |data_|. - // High watermark. The number of bytes (<= |size_|) written into the buffer - // before the first wraparound. This increases as data is written into the - // buffer and then saturates at |size_|. + // High watermark of the written bytes (<= |size_|). + // Writes increase it until the write cursor wraps around, and MaybeCompact() + // sets it to the total size of the remaining chunks. + // Reads and overwrites stop here, and [used_size_, size_) is zero-filled. size_t used_size_ = 0; + // Where the last madvise in MaybeCompact() began. + // The whole pages from here to |size_| are released or were never written. + // Writes after that can go past it. If they do, the next MaybeCompact() first + // raises it to |used_size_|, to cover the pages they touched. + // MaybeCompact() then uses it to skip a madvise that would release nothing. + size_t prev_madvise_begin_ = 0; + + // Set when the first chunk is written, and never cleared. + // Unlike |used_size_|, this stays set when compaction empties the buffer. + // As in TraceBufferV1, clear_before_clone uses it to skip unused buffers. + bool has_data_ = false; + size_t wr_ = 0; // Write cursor (offset since start()). size_t rd_ = 0; // Read cursor. Reset to wr_ on every BeginRead(). std::optional chunk_seq_reader_; @@ -63706,8 +72219,8 @@ class TraceBufferV2 : public TraceBuffer { // This is used to sort SequenceState by least-recently cleared. uint64_t seq_age_ = 0; - // This buffer is a read-only snapshot obtained via Clone(). If this is true - // calls to CopyChunkUntrusted() and TryPatchChunkContents() will CHECK(). + // This buffer is a read-only snapshot obtained via Clone(). If this is true, + // appending chunks, patching or recording loss will CHECK(). bool read_only_ = false; // Only used when |overwrite_policy_ == kDiscard|. This is set the first time @@ -63720,7 +72233,7 @@ class TraceBufferV2 : public TraceBuffer { bool suppress_client_dchecks_for_testing_ = false; // ProtoVMs used to process overwritten packets (go/perfetto-proto-vm) - std::vector protovms_; + TraceBufferProtoVms protovms_; // Used to collect slices of the overwritten packet. Note that this is a // member variable (instead of local) so that the memory (internal @@ -63729,12 +72242,8 @@ class TraceBufferV2 : public TraceBuffer { // few times during the initial iterations). TracePacket overwritten_packet_; - // Storage used to re-write overwritten packets (from TBv2) into contiguous - // memory to be used as ProtoVM patches (must be continguous to be decoded - // with protozero). Note that this is a member variable (instead of local) so - // that the memory is re-used across overwritten packets, thus involving - // allocations only when the storage needs to be expanded. - std::string protovm_patch_; + // Rewrites SMB v2 packets at readback. + tracing_v2::ProtoGroupRewriter rewriter_; }; } // namespace perfetto @@ -63760,16 +72269,15 @@ class TraceBufferV2 : public TraceBuffer { #include #include +#include // gen_amalgamated expanded: #include "perfetto/base/logging.h" -// gen_amalgamated expanded: #include "perfetto/ext/base/murmur_hash.h" // gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h" // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h" // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" -// gen_amalgamated expanded: #include "src/protovm/vm.h" // gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h" @@ -63809,6 +72317,11 @@ constexpr uint8_t kChunkIncomplete = 0x80; // Mask out the flags that don't come from the ABI like kChunkIncomplete. constexpr uint8_t kFlagsMask = SharedMemoryABI::ChunkHeader::kFlagsMask; +// SMB v2 sequences have no ChunkID. A gap is recorded on the first chunk +// appended after the loss, so earlier packets do not inherit the loss marker. +constexpr uint8_t kChunkLossBefore = 0x40; +static_assert((kChunkLossBefore & (kFlagsMask | kChunkIncomplete)) == 0); + // Compares two ChunkID(s) in a wrapping 32-bit ID space. // Returns: // -1 if a comes before b in modular (wrapping) order. @@ -63830,6 +72343,11 @@ constexpr size_t kKeepLastEmptySeq = 1024; // The threshold when we start scanning and deleting the oldest sequences. constexpr size_t kEmptySequencesGcTreshold = kKeepLastEmptySeq + 128; + +// Controls how much spare capacity compaction retains so later writes can +// reuse pages and avoid page faults. +constexpr size_t kSpareCapacityDivisor = 4; + } // namespace. namespace internal { @@ -63978,7 +72496,8 @@ TBChunk* ChunkSeqIterator::NextChunkInSequence() { size_t next_chunk_off = chunk_list.at(next_list_idx); // O(1) TBChunk* next_chunk = buf_->GetTBChunkAt(next_chunk_off); // O(1) - if (last_chunk_id.has_value() && next_chunk->chunk_id != *last_chunk_id + 1) + if (!seq_->is_smb_v2 && last_chunk_id.has_value() && + next_chunk->chunk_id != *last_chunk_id + 1) sequence_gap_detected_ = true; chunk_ = next_chunk; @@ -64043,6 +72562,9 @@ ChunkSeqReader::ChunkSeqReader(TraceBufferV2* buf, : 0, iter_->chunk_id, end_->chunk_id); + if (seq_->is_smb_v2) + return; + if (seq_->last_chunk_consumed.has_value()) { const auto& last = *seq_->last_chunk_consumed; // Re-admit: an incomplete chunk that was evicted has been re-committed @@ -64075,6 +72597,12 @@ bool ChunkSeqReader::ReadNextPacketInSeqOrder(TracePacket* out_packet) { // This is because this class is used both while doing readbacks and, // importantly, in DeleteNextChunksFor() when overwriting. for (;;) { + // Report an SMB v2 gap when we reach the chunk after it. Clear the + // flag so later packets in this chunk do not report the same gap again. + if (PERFETTO_UNLIKELY(iter_->flags & kChunkLossBefore)) { + AddSeqDataLoss(seq_, DataLossReason::DATA_LOSS_READ_GAP); + iter_->flags &= static_cast(~kChunkLossBefore); + } std::optional maybe_frag = frag_iter_.NextFragmentInChunk(); if (!maybe_frag.has_value()) { // Once we exhaust all fragments, move to the next chunk in the sequence. @@ -64255,8 +72783,10 @@ ChunkSeqReader::ReassembleFragmentedPacket(TracePacket* out_packet, outcome.result = FragReassemblyResult::kNotEnoughData; break; } - if (chunk_iter.sequence_gap_detected()) { - // There is a gap in the sequence ID. + if (PERFETTO_UNLIKELY(chunk_iter.sequence_gap_detected() || + (next_chunk->flags & kChunkLossBefore))) { + // SMB sequences detect gaps via chunk_id discontinuity. + // SMB v2 sequences use the kChunkLossBefore flag instead. outcome.result = FragReassemblyResult::kDataLoss; outcome.reason = DataLossReason::DATA_LOSS_REASSEMBLY_GAP; break; @@ -64334,6 +72864,8 @@ std::unique_ptr TraceBufferV2::Create(size_t size_in_bytes, // efficiency. static_assert(sizeof(TBChunk) == 16); static_assert(alignof(TBChunk) == 4); + // CloneReadOnly() and MaybeCompact() copy chunks as raw bytes. + static_assert(std::is_trivially_copyable_v); std::unique_ptr trace_buffer(new TraceBufferV2(pol)); if (!trace_buffer->Initialize(size_in_bytes)) return nullptr; @@ -64413,6 +72945,17 @@ bool TraceBufferV2::ReadNextTracePacket( // If it returns false, we should continue in buffer order. if (chunk_seq_reader_->ReadNextPacketInSeqOrder(out_packet)) { SequenceState& s = *chunk_seq_reader_->seq(); + if (s.is_smb_v2) { + if (out_packet->size() == 0) + continue; // Skip empty fragments. + + if (PERFETTO_UNLIKELY(!RewriteProtoGroupPacket(out_packet))) { + out_packet->Clear(); + internal::AddSeqDataLoss(&s, + DataLossReason::DATA_LOSS_CHUNK_CORRUPTED); + continue; + } + } *sequence_properties = {s.producer_id, s.client_identity, s.writer_id}; *previous_packet_on_sequence_dropped = s.data_loss_reasons; s.data_loss_reasons = 0; @@ -64437,6 +72980,151 @@ bool TraceBufferV2::ReadNextTracePacket( } // for(;;) } +void TraceBufferV2::MaybeCompact() { + TRACE_BUFFER_V2_DLOG("MaybeCompact(), wr_=%zu", wr_); + chunk_seq_reader_.reset(); + if (overwrite_policy_ != kOverwrite || read_only_) { + return; + } + + // The read cycle is complete, so usually only a few chunks remain. + size_t num_chunks = 0; + for (const auto& seq_entry : sequences_) + num_chunks += seq_entry.second.chunks.size(); + + // Store pointers to the chunk offsets in each SequenceState::chunks queue + // so we can update those offsets without another lookup. + // TODO(sashwinbalaji): Using these queues avoids scanning the buffer but + // leaves removed padding unaccounted for in padding_bytes_cleared. + std::vector chunk_offset_ptrs; + chunk_offset_ptrs.reserve(num_chunks); + for (auto& seq_entry : sequences_) { + for (size_t& chunk_offset : seq_entry.second.chunks) + chunk_offset_ptrs.emplace_back(&chunk_offset); + } + + // Sort the pointer vector by chunk offset, from lowest to highest. + // This reorders only the vector, so the queue entries stay in sequence order. + // The loop below updates each chunk's offset in its original queue entry. + std::sort(chunk_offset_ptrs.begin(), chunk_offset_ptrs.end(), + [](const size_t* lhs, const size_t* rhs) { return *lhs < *rhs; }); + + // If live chunks are on both sides of wr_, skip compaction. + // The chunks at or after wr_ are older, so address order is not ring order. + // + // In this diagram and the ones below: + // - [C0], [D0], [C1], ... are live chunks of two sequences, C and D. + // The number is the order of the chunk within its sequence. + // - "." is padding (read chunks). + // - "~" is unused space, past the new used_size_. + // + // 0 wr_ used_size_ + // |..[C1]..[D1]..[C2]......|..[C0]....[D0]..........| + const bool chunks_on_both_sides = !chunk_offset_ptrs.empty() && + *chunk_offset_ptrs.front() < wr_ && + *chunk_offset_ptrs.back() >= wr_; + if (PERFETTO_UNLIKELY(chunks_on_both_sides)) { + stats_.set_compactions_skipped(stats_.compactions_skipped() + 1); + return; + } + + // All live chunks are on one side of wr_, so address order is ring order. + // Move each chunk to the lowest available offset, in address order. + // Each destination starts at or before its source, so a move cannot + // overwrite a chunk that comes later in address order. + // + // All live chunks are before wr_: + // + // 0 wr_ used_size_ + // |.[C0].[D0]..[C1]..[C2]..|........................| + // + // All live chunks are at or after wr_ because reads consumed every chunk + // before wr_ after the write cursor wrapped. + // + // 0 wr_ used_size_ + // |........................|.[C0].[D0]..[C1]..[C2]..| + // + // After compaction: + // + // 0 dst used_size_ + // |[C0][D0][C1][C2]|~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~| + size_t dst = 0; + size_t prev_chunk_end = 0; + for (size_t* offset_ptr : chunk_offset_ptrs) { + const size_t src = *offset_ptr; + TBChunk* chunk = GetTBChunkAt(src); + PERFETTO_DCHECK(!chunk->is_padding()); + const size_t outer_size = chunk->outer_size(); + PERFETTO_CHECK(src >= prev_chunk_end); + prev_chunk_end = src + outer_size; + if (dst != src) { + memmove(begin() + dst, chunk, outer_size); + *offset_ptr = dst; + TBChunk* moved_chunk = GetTBChunkAtUnchecked(dst); + moved_chunk->checksum = TBChunk::Checksum(dst, moved_chunk->size); + } + dst += outer_size; + } + + TRACE_BUFFER_V2_DLOG("Compacted %zu -> %zu bytes", used_size_, dst); + const size_t old_used_size = used_size_; + PERFETTO_CHECK(dst <= old_used_size && old_used_size <= size_); + wr_ = dst; + used_size_ = dst; + + // Bytes beyond |old_used_size| are zero from allocation or earlier + // compactions. + // Clear [dst, old_used_size) on each compaction so the unused tail stays zero + // even when used_size_ shrinks. + // ReadNextTracePacket() visits offset 0 even when the buffer is empty and so + // if dst == 0, this also leaves the empty padding chunk that it needs. + memset(begin() + dst, 0, old_used_size - dst); + + const size_t spare_size = + std::min(old_used_size / kSpareCapacityDivisor, size_ - old_used_size); + const size_t cur_madvise_begin = old_used_size + spare_size; + + // Writes since the last compaction touched pages up to |old_used_size|. + prev_madvise_begin_ = std::max(prev_madvise_begin_, old_used_size); + + // Skip the madvise if it starts at or past |prev_madvise_begin_|, because + // the pages from there on are already released. + if (cur_madvise_begin < prev_madvise_begin_) { + data_.AdviseDontNeedAfter(cur_madvise_begin); + prev_madvise_begin_ = cur_madvise_begin; + } + stats_.set_compactions(stats_.compactions() + 1); +} + +bool TraceBufferV2::RewriteProtoGroupPacket(TracePacket* packet) { + PERFETTO_DCHECK(packet->size() > 0); + + // The packet's slices point into TBChunks. The rewriter reads them in + // place, and writes the output into one slice that the packet owns. + // + // TODO(sashwinbalaji): Allocate the rewritten packets from an arena owned by + // the read batch. Today each rewritten packet is one heap allocation. + // Readers use packets in batches (an IPC reply or a file write) and drop + // them together, so one arena per batch fits their lifetime. + std::optional rewritten; + switch (rewriter_.Rewrite(packet->slices(), &rewritten)) { + case tracing_v2::RewriteResult::kRewritten: + break; + case tracing_v2::RewriteResult::kUnchanged: + return true; + case tracing_v2::RewriteResult::kMalformedInput: + stats_.set_abi_violations(stats_.abi_violations() + 1); + return false; + case tracing_v2::RewriteResult::kGroupTooLarge: + stats_.set_oversized_packets_dropped(stats_.oversized_packets_dropped() + + 1); + return false; + } + packet->Clear(); + packet->AddSlice(std::move(*rewritten)); + return true; +} + void TraceBufferV2::CopyChunkUntrusted( ProducerID producer_id_trusted, const ClientIdentity& client_identity_trusted, @@ -64457,6 +73145,10 @@ void TraceBufferV2::CopyChunkUntrusted( if (PERFETTO_UNLIKELY(discard_writes_)) return DiscardWrite(); + // Only ABI flags may come from the producer. In particular, loss markers + // and the incomplete-chunk flag are set by the service. + chunk_flags &= kFlagsMask; + // chunk_complete is true in the majority of cases, and is false only when // the service performs SMB scraping (upon flush). // If the chunk hasn't been completed, we should only consider the first @@ -64528,6 +73220,13 @@ void TraceBufferV2::CopyChunkUntrusted( } SequenceState& seq = seq_it->second; + // A sequence uses one input format. SMB v1 and SMB v2 writers share one + // WriterID space per producer, so an SMB v2 sequence with this key + // belongs to another writer. Leave that writer's sequence unchanged. + if (seq.is_smb_v2) { + stats_.set_abi_violations(stats_.abi_violations() + 1); + return; + } if (trace_writer_data_drop) { stats_.set_trace_writer_packet_loss(stats_.trace_writer_packet_loss() + 1); internal::AddSeqDataLoss(&seq, DataLossReason::DATA_LOSS_WRITER_ABORT); @@ -64619,9 +73318,10 @@ void TraceBufferV2::CopyChunkUntrusted( // Nothing for the erase to lose, nothing for the relocation to duplicate. const bool copy_fully_consumed = recommit_chunk->payload_avail == 0; - // The producer's final commit (not another scrape), with new fragments. + // Any re-commit with new fragments, whether the producer's final commit or + // a later scrape of the same still-open chunk. const bool commit_adds_new_data = - chunk_complete && all_frags_size > recommit_chunk->payload_size; + all_frags_size > recommit_chunk->payload_size; // EraseCurrentChunk() only supports the first chunk of a sequence. Later // chunks may stay physically ahead of the relocated one, which is fine: @@ -64668,30 +73368,11 @@ void TraceBufferV2::CopyChunkUntrusted( internal::ChunkSeqIterator(this, &seq).EraseCurrentChunk(); } // if (recommit_chunk) - // If there isn't enough room from the given write position: write a padding - // record to clear the end of the buffer, wrap and start at offset 0. - const size_t cached_size_to_end = size_to_end(); - if (PERFETTO_UNLIKELY(tbchunk_outer_size > cached_size_to_end)) { - // If we reached the end of the buffer and we are using discard policy, - // this is where we stop. This buffer will no longer accept data. - if (overwrite_policy_ == kDiscard) - return DiscardWrite(); - - // Skip the tail cleanup if the previous write landed exactly at the end - // of the buffer (|wr_| == |size_|): there is no leftover tail to clear. - if (cached_size_to_end > 0) - DeleteNextChunksFor(cached_size_to_end); - - wr_ = 0; - stats_.set_write_wrap_count(stats_.write_wrap_count() + 1); - PERFETTO_DCHECK(size_to_end() >= tbchunk_outer_size); - } - - // Deletes all chunks from |wptr_| to |wptr_| + |record_size|. - DeleteNextChunksFor(tbchunk_outer_size); + if (!MakeSpaceToWrite(tbchunk_outer_size)) + return DiscardWrite(); // |insert_pos| is invalid if any chunk was removed from this sequence since - // it was computed: either by the DeleteNextChunksFor above, or by the + // it was computed: either by MakeSpaceToWrite() above, or by the // relocation erase. // Why don't we compute the insert_pos here? Because we also need to check // for re-commits (which are rare, but possible) and don't want to iterate @@ -64722,6 +73403,7 @@ void TraceBufferV2::CopyChunkUntrusted( stats_.chunks_committed_out_of_order() + 1); } chunk_list.InsertAfter(insert_pos, wr_); + has_data_ = true; if (chunk_list.size() == 1 && !seq_is_new) { PERFETTO_DCHECK(empty_sequences_ > 0); --empty_sequences_; @@ -64743,6 +73425,166 @@ void TraceBufferV2::CopyChunkUntrusted( DeleteStaleEmptySequences(); } +bool TraceBufferV2::supports_tracing_v2() const { + return true; +} + +bool TraceBufferV2::CopyChunkV2Untrusted( + const PacketSequenceProperties& sequence, + const protozero::ConstBytes* fragments, + size_t num_fragments, + bool first_continues_from_prev, + bool last_continues_on_next) { + PERFETTO_CHECK(!read_only_); + + if (PERFETTO_UNLIKELY(num_fragments == 0)) + return false; + + // Each rejection site updates its own stats. This only records the gap. + auto reject = [&] { + RecordChunkV2DataLoss(sequence.producer_id_trusted, sequence.writer_id); + return false; + }; + auto reject_abi_violation = [&] { + stats_.set_abi_violations(stats_.abi_violations() + 1); + return reject(); + }; + + if (PERFETTO_UNLIKELY(discard_writes_)) { + DiscardWrite(); + return reject(); + } + + if (!fragments) + return reject_abi_violation(); + + // ProtoVM expects length-delimited protobuf on the overwrite path. + if (protovms_.HasProducer(sequence.producer_id_trusted)) { + stats_.set_chunks_discarded(stats_.chunks_discarded() + 1); + return reject(); + } + + // The batch becomes one TBChunk with the same payload layout as an SMB chunk, + // so readback uses FragIterator for both: + // + // +---------+-----------+--------+-----------+--------+-----+---------+ + // | TBChunk | varint s0 | frag 0 | varint s1 | frag 1 | ... | padding | + // +---------+-----------+--------+-----------+--------+-----+---------+ + // |<----------- total_payload <= kMaxSize ------->| + // + // Validate the entire batch before making space: a rejected batch must not + // evict any buffered packets. A batch larger than one TBChunk breaks the + // writer's chunk contract. Each addend is at most kMaxSize + 3, so + // |total_payload| cannot overflow. + size_t total_payload = 0; + for (size_t i = 0; i < num_fragments; i++) { + const size_t frag_size = fragments[i].size; + if ((frag_size && !fragments[i].data) || frag_size > TBChunk::kMaxSize) + return reject_abi_violation(); + uint8_t varint[3]; // A varint up to TBChunk::kMaxSize takes 3 bytes. + const size_t varint_size = static_cast( + proto_utils::WriteVarInt(frag_size, varint) - varint); + total_payload += varint_size + frag_size; + if (total_payload > TBChunk::kMaxSize) + return reject_abi_violation(); + } + + // As in CopyChunkUntrusted(): a chunk larger than the whole buffer. Rare, + // e.g. a 16 KB buffer and a 32 KB ring chunk. + const size_t tbchunk_outer_size = TBChunk::OuterSize(total_payload); + if (PERFETTO_UNLIKELY(tbchunk_outer_size > size_)) + return reject_abi_violation(); + + auto seq_key = + MkProducerAndWriterID(sequence.producer_id_trusted, sequence.writer_id); + writer_stats_.Insert(seq_key, static_cast(total_payload)); + + auto [seq_it, seq_is_new] = sequences_.try_emplace( + seq_key, SequenceState(sequence.producer_id_trusted, sequence.writer_id, + sequence.client_identity_trusted)); + SequenceState& seq = seq_it->second; + if (seq_is_new) { + seq.is_smb_v2 = true; + seq.age_for_gc = ++seq_age_; + ++empty_sequences_; + } else if (!seq.is_smb_v2) { + // As in CopyChunkUntrusted(), a sequence uses one input format. The SMB + // sequence belongs to another writer, so no loss is recorded on it. + return reject_abi_violation(); + } + + if (!MakeSpaceToWrite(tbchunk_outer_size)) { + DiscardWrite(); + return reject(); + } + + TBChunk* chunk = CreateTBChunk(wr_, total_payload); + chunk->pri_wri_id = seq_key; + chunk->payload_size = static_cast(total_payload); + chunk->payload_avail = static_cast(total_payload); + + uint8_t flags = 0; + if (PERFETTO_UNLIKELY(seq.pending_chunk_v2_data_loss)) { + flags |= kChunkLossBefore; + seq.pending_chunk_v2_data_loss = false; + } + if (first_continues_from_prev) + flags |= kFirstPacketContFromPrevChunk; + if (last_continues_on_next) + flags |= kLastPacketContOnNextChunk; + chunk->flags = flags; + + // Copy fragment data into the chunk payload with varint length prefixes. + uint8_t* dst = chunk->fragments_begin(); + for (size_t i = 0; i < num_fragments; i++) { + const size_t frag_size = fragments[i].size; + dst = protozero::proto_utils::WriteVarInt(frag_size, dst); + if (frag_size > 0) { + memcpy(dst, fragments[i].data, frag_size); + dst += frag_size; + } + } + PERFETTO_DCHECK(static_cast(dst - chunk->fragments_begin()) == + total_payload); + + // Append after eviction, which can remove earlier chunks from this sequence. + auto& chunk_list = seq.chunks; + bool was_empty = chunk_list.empty(); + chunk_list.emplace_back(wr_); + has_data_ = true; + if (was_empty) { + PERFETTO_DCHECK(empty_sequences_ > 0); + --empty_sequences_; + } + + wr_ += tbchunk_outer_size; + PERFETTO_DCHECK(wr_ <= size_ && wr_ <= used_size_); + + stats_.set_chunks_written(stats_.chunks_written() + 1); + stats_.set_bytes_written(stats_.bytes_written() + tbchunk_outer_size); + + if (empty_sequences_ > kEmptySequencesGcTreshold) + DeleteStaleEmptySequences(); + + return true; +} + +void TraceBufferV2::RecordChunkV2DataLoss(ProducerID producer_id, + WriterID writer_id) { + PERFETTO_CHECK(!read_only_); + + // SMB v1 and SMB v2 writers share one WriterID space per producer. An SMB v1 + // sequence with this key therefore belongs to another writer. + auto seq_it = sequences_.find(MkProducerAndWriterID(producer_id, writer_id)); + if (seq_it != sequences_.end() && seq_it->second.is_smb_v2) + seq_it->second.pending_chunk_v2_data_loss = true; +} + +void TraceBufferV2::RecordAbiViolation() { + PERFETTO_CHECK(!read_only_); + stats_.set_abi_violations(stats_.abi_violations() + 1); +} + TraceBufferV2::TBChunk* TraceBufferV2::CreateTBChunk(size_t off, size_t size) { DcheckIsAlignedAndWithinBounds(off); size_t end = off + TBChunk::OuterSize(size); @@ -64754,6 +73596,26 @@ TraceBufferV2::TBChunk* TraceBufferV2::CreateTBChunk(size_t off, size_t size) { return new (chunk) TBChunk(off, size); } +bool TraceBufferV2::MakeSpaceToWrite(size_t size) { + PERFETTO_DCHECK(size <= size_); + + // If the chunk does not fit at the end, clear the remaining tail and wrap. + // In discard mode, reaching the end stops all further writes. + const size_t tail_size = size_to_end(); + if (PERFETTO_UNLIKELY(size > tail_size)) { + if (overwrite_policy_ == kDiscard) + return false; + // A previous write can land exactly at the end, leaving no tail to clear. + if (tail_size > 0) + DeleteNextChunksFor(tail_size); + wr_ = 0; + stats_.set_write_wrap_count(stats_.write_wrap_count() + 1); + PERFETTO_DCHECK(size_to_end() >= size); + } + DeleteNextChunksFor(size); + return true; +} + // Deletes (by marking the record invalid and removing form the index) all // chunks from wr_ to (wr_ + bytes_to_clear). // Graphically, assume the initial situation is the following (|wptr_| = 10). @@ -64782,8 +73644,9 @@ void TraceBufferV2::DeleteNextChunksFor(size_t bytes_to_clear) { // This loop erases all the existing chunks in the clear range. for (size_t off = wr_, next_off = 0; off < clear_end; off = next_off) { if (PERFETTO_UNLIKELY(off >= used_size_)) { - // This happens only on the first round of writing, when there are no - // chunks in the buffer yet. There is nothing to delete here, easy. + // This happens on the first round of writing, or after MaybeCompact() + // shrinks |used_size_|, when there are no chunks in this range. + // There is nothing to delete here, easy. break; } TBChunk* chunk = GetTBChunkAt(off); @@ -64805,7 +73668,7 @@ void TraceBufferV2::DeleteNextChunksFor(size_t bytes_to_clear) { // protovm. If not, we still need to do reads, but without having to // accumulated data in a packet. TracePacket* maybe_packet = nullptr; - if (!protovms_.empty()) { + if (!protovms_.empty() && !csr.seq()->is_smb_v2) { overwritten_packet_.Clear(); maybe_packet = &overwritten_packet_; } @@ -64813,8 +73676,8 @@ void TraceBufferV2::DeleteNextChunksFor(size_t bytes_to_clear) { break; } if (maybe_packet) { - MaybeProcessOverwrittenPacketWithProtoVm(*maybe_packet, - csr.seq()->producer_id); + protovms_.MaybeProcessOverwrittenPacket(*maybe_packet, + csr.seq()->producer_id); } has_cleared_unconsumed_fragments = true; } @@ -64858,7 +73721,7 @@ bool TraceBufferV2::TryPatchChunkContents(ProducerID producer_id, ProducerAndWriterID seq_key = MkProducerAndWriterID(producer_id, writer_id); auto seq_it = sequences_.find(seq_key); - if (seq_it == sequences_.end()) { + if (seq_it == sequences_.end() || seq_it->second.is_smb_v2) { stats_.set_patches_failed(stats_.patches_failed() + 1); return false; } @@ -64934,7 +73797,8 @@ void TraceBufferV2::DiscardWrite() { // This is to avoid thrashing with a sort every time one sequence becomes empty. // Also we have to defer the deletion of SequenceState outside of // ReadNextTracePacket() calls, as that caches SequenceState* pointers in -// seq_iter_. This is called only at the end of each CopyChunkUntrusted(). +// chunk_seq_reader_. This is called only at the end of CopyChunkUntrusted() +// and CopyChunkV2Untrusted(). void TraceBufferV2::DeleteStaleEmptySequences() { // Build a vector of iterators; sort it; delete the first size() - kThreshold. using SeqIterator = decltype(sequences_)::iterator; @@ -64953,6 +73817,11 @@ void TraceBufferV2::DeleteStaleEmptySequences() { return a->second.age_for_gc < b->second.age_for_gc; }); + // TODO(sashwinbalaji): Pruning an SMB v2 sequence discards its + // pending_chunk_v2_data_loss. If that writer appends again, the loss is not + // reported. SMB sequences have the same limit: pruning discards + // last_chunk_consumed. Revisit if field traces show missed loss for writers + // that write rarely while many others churn. size_t n_oldest = empty_seqs.size() - kKeepLastEmptySeq; for (size_t i = 0; i < n_oldest; ++i) { sequences_.erase(empty_seqs[i]); @@ -64961,9 +73830,9 @@ void TraceBufferV2::DeleteStaleEmptySequences() { // This is not really required in the current implementation and is here just // to spot bugs while refactoring the code in future. This function is - // only called by CopyChunkUntrusted(), but the chunk_seq_reader_ (which can + // called only by writes, but the chunk_seq_reader_ (which can // hold onto a SequenceState* pointer) is reset by every BeginRead() call. - // By design BeginRead()/ReadNextTracePacket() cannot overlap with CCU(). + // By design BeginRead()/ReadNextTracePacket() cannot overlap with writes. chunk_seq_reader_.reset(); } @@ -64974,12 +73843,12 @@ std::unique_ptr TraceBufferV2::CloneReadOnly() const { return buf; } +TraceBufferProtoVms* TraceBufferV2::protovms() { + return &protovms_; +} + size_t TraceBufferV2::GetMemoryUsageBytes() const { - size_t total_bytes = size(); - for (const Vm& vm : protovms_) { - total_bytes += vm.instance->GetMemoryUsageBytes(); - } - return total_bytes; + return size() + protovms_.GetMemoryUsageBytes(); } TraceBufferV2::TraceBufferV2(CloneCtor, const TraceBufferV2& src) @@ -64995,6 +73864,7 @@ TraceBufferV2::TraceBufferV2(CloneCtor, const TraceBufferV2& src) data_.EnsureCommitted(src.used_size_); memcpy(data_.Get(), src.data_.Get(), src.used_size_); used_size_ = src.used_size_; + has_data_ = src.has_data_; wr_ = src.wr_; stats_ = src.stats_; @@ -65003,28 +73873,13 @@ TraceBufferV2::TraceBufferV2(CloneCtor, const TraceBufferV2& src) stats_.set_readaheads_failed(0); stats_.set_readaheads_succeeded(0); - // Finally copy over the SequenceState map. + // Finally copy over the SequenceState map and WriterStats map. WriterStats + // must be copied because EmitTraceProvenance() derives the producer->sequence + // mapping from it, until b/568173038 is addressed. sequences_ = src.sequences_; + writer_stats_ = src.writer_stats_; - for (const auto& vm : src.protovms_) { - auto vm_cloned = vm.CloneReadOnly(); - if (!vm_cloned.instance) { - PERFETTO_ELOG("Failed to clone ProtoVMs"); - protovms_.clear(); - break; - } - protovms_.push_back(std::move(vm_cloned)); - } -} - -TraceBufferV2::Vm TraceBufferV2::Vm::CloneReadOnly() const { - Vm cloned_vm; - cloned_vm.data_source_name = data_source_name; - cloned_vm.program_hash = program_hash; - cloned_vm.memory_limit_kb = memory_limit_kb; - cloned_vm.producers = producers; - cloned_vm.instance = instance->CloneReadOnly(); - return cloned_vm; + protovms_.CloneReadOnlyFrom(src.protovms_); } void TraceBufferV2::DumpForTesting() { @@ -65044,8 +73899,8 @@ void TraceBufferV2::DumpForTesting() { PERFETTO_DLOG( "[%06zu-%06zu] size=%05u(%05u) id=%05u pr_wr=%08x flags=%08x", rd, rd + c->outer_size(), c->payload_size, - c->payload_size - c->payload_avail, c->chunk_id, c->pri_wri_id, - c->flags); + static_cast(c->payload_size - c->payload_avail), + c->chunk_id, c->pri_wri_id, c->flags); rd += c->outer_size(); continue; } @@ -65059,79 +73914,6 @@ void TraceBufferV2::DumpForTesting() { PERFETTO_DLOG("------------------------------------------------------------"); } -TraceBufferV2::Vm::Vm() = default; -TraceBufferV2::Vm::~Vm() = default; -TraceBufferV2::Vm::Vm(Vm&&) noexcept = default; - -void TraceBufferV2::MaybeSetUpProtoVm(const std::string& data_source_name, - const std::string& program_bytes, - uint32_t memory_limit_kb, - ProducerID producer_id) { - Vm* vm = nullptr; - // Re-use existing ProtoVM instance, if any. - uint64_t program_hash = base::MurmurHashValue(program_bytes); - auto vm_it = - std::find_if(protovms_.begin(), protovms_.end(), [&](const Vm& vm) { - return vm.data_source_name == data_source_name && - vm.program_hash == program_hash; - }); - if (vm_it != protovms_.end()) { - vm = &(*vm_it); - } else { - // Otherwise instantiate new ProtoVM - Vm new_vm; - new_vm.data_source_name = data_source_name; - new_vm.program_hash = program_hash; - new_vm.memory_limit_kb = memory_limit_kb; - - protozero::ConstBytes program_bytes_view{ - reinterpret_cast(program_bytes.data()), - program_bytes.size()}; - - new_vm.instance = std::make_unique( - program_bytes_view, new_vm.memory_limit_kb * 1024); - if (!new_vm.instance) { - PERFETTO_ELOG("Failed to allocate ProtoVM"); - return; - } - - protovms_.push_back(std::move(new_vm)); - vm = &protovms_.back(); - } - // Update ProtoVM's producer IDs - vm->producers.insert(producer_id); -} - -void TraceBufferV2::MaybeProcessOverwrittenPacketWithProtoVm( - const TracePacket& packet, - ProducerID producer) { - protovm_patch_.clear(); - - for (auto& vm : protovms_) { - if (vm.producers.find(producer) == vm.producers.end()) { - continue; - } - // TODO(keanmariotti): add an optimized path for the case - // "packet.slices().size() == 1" (zero copy) - if (protovm_patch_.empty()) { - packet.GetRawBytes(&protovm_patch_); - } - protozero::ConstBytes bytes{ - reinterpret_cast(protovm_patch_.data()), - protovm_patch_.size()}; - auto status = vm.instance->ApplyPatch(bytes); - if (status.IsOk()) { - break; - } - if (status.IsAbort()) { - // TODO(keanmariotti): consider doing something more here. Ideally - // triggering a field upload containing the stacktrace. - PERFETTO_ELOG("ProtoVM abort while applying patch. Stacktrace:\n%s", - base::Join(status.stacktrace(), "\n").c_str()); - } - } -} - } // namespace perfetto // gen_amalgamated begin source: src/tracing/service/tracing_service_endpoints_impl.cc // gen_amalgamated begin header: src/tracing/service/tracing_service_endpoints_impl.h @@ -65173,6 +73955,8 @@ void TraceBufferV2::MaybeProcessOverwrittenPacketWithProtoVm( // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h" // gen_amalgamated expanded: #include "perfetto/tracing/core/forward_decls.h" +// gen_amalgamated expanded: #include "src/tracing/service/service_ring_buffer_drainer.h" +// gen_amalgamated expanded: #include "src/tracing/v2/producer_ring_buffer_arbiter.h" // This header contains the declarations for the 3 abtract classes // (ProducerEndpointImpl, ConsumerEndpointImpl, RelayEndpointImpl). @@ -65192,7 +73976,9 @@ struct TracingSession; struct TriggerInfo; // The implementation behind the service endpoint exposed to each producer. -class ProducerEndpointImpl : public TracingService::ProducerEndpoint { +class ProducerEndpointImpl + : public TracingService::ProducerEndpoint, + public tracing_v2::ServiceRingBufferDrainer::Delegate { public: ProducerEndpointImpl(ProducerID, const ClientIdentity& client_identity, @@ -65203,7 +73989,8 @@ class ProducerEndpointImpl : public TracingService::ProducerEndpoint { const std::string& machine_name, const std::string& sdk_version, bool in_process, - bool smb_scraping_enabled); + bool smb_scraping_enabled, + uint32_t protocol_abi_versions); ~ProducerEndpointImpl() override; // TracingService::ProducerEndpoint implementation. @@ -65221,6 +74008,9 @@ class ProducerEndpointImpl : public TracingService::ProducerEndpoint { std::unique_ptr CreateTraceWriter( BufferID, BufferExhaustedPolicy) override; + std::unique_ptr CreateTraceWriterV2( + BufferID, + BufferExhaustedPolicy) override; SharedMemoryArbiter* MaybeSharedMemoryArbiter() override; bool IsShmemProvidedByProducer() const override; void NotifyFlushComplete(FlushRequestID) override; @@ -65252,6 +74042,24 @@ class ProducerEndpointImpl : public TracingService::ProducerEndpoint { return std::nullopt; } + // TracingService::ProducerEndpoint implementation for tracing v2. + void InitializeV2RingBuffer(const DataSourceConfig&) override; + void AttachV2RingBuffer(const std::shared_ptr&, + uint32_t chunk_size_bytes, + std::function) override; + void DrainV2RingBuffer() override; + + // tracing_v2::ServiceRingBufferDrainer::Delegate implementation. + TraceBuffer* GetV2RingBufferDestination(BufferID) override; + void ForEachV2RingBufferDestination( + const std::function& callback) override; + void OnRingBufferChunksDiscarded(uint64_t count) override; + + // Mapping size for the memory guardrail. Zero if no ring buffer is attached. + size_t ring_buffer_size_bytes() const { + return v2_ring_buffer_drainer_ ? v2_ring_buffer_drainer_->size_bytes() : 0; + } + bool IsShmemEmulated() { return shmem_abi_.use_shmem_emulation(); } bool IsAndroidProcessFrozen(); @@ -65299,6 +74107,32 @@ class ProducerEndpointImpl : public TracingService::ProducerEndpoint { // SharedMemoryArbiterImpl methods themselves are thread-safe. std::unique_ptr inproc_shmem_arbiter_; + // Bitmask of the common versions supplied to ConnectProducer(). Fixed for + // the connection. + const uint32_t protocol_abi_versions_; + + // Owns the ring buffer and creates v2 writers. + // + // States: + // - nullopt: initialization has not been attempted. + // - nullptr: sizing or allocation failed. + // Later InitializeV2RingBuffer() calls on the same connection do not retry + // initialization, to avoid changing the pointer while v2 writer threads + // read it without a lock. + // - Non-null pointer: the arbiter exists and tracks service attachment. + // + // Set by InitializeV2RingBuffer() when an instance selects v2, before the + // first in-process v2 writer. + // Writer threads then read it without a lock. + // For an IPC producer, the arbiter lives in the producer process. + std::optional> + v2_ring_buffer_arbiter_; + + // |v2_ring_buffer_drainer_| owns the reader and keeps the ring buffer mapped. + // The reader's destination checks use |allowed_target_buffers_|. + // DisconnectProducer() runs the final drain through |v2_ring_buffer_drainer_| + // before |allowed_target_buffers_| is destroyed. + std::unique_ptr v2_ring_buffer_drainer_; PERFETTO_THREAD_CHECKER(thread_checker_) base::WeakRunner weak_runner_; }; @@ -65984,6 +74818,7 @@ struct TracingSession { // gen_amalgamated expanded: #include "src/tracing/service/clock.h" // gen_amalgamated expanded: #include "src/tracing/service/dependencies.h" // gen_amalgamated expanded: #include "src/tracing/service/random.h" +// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer.h" // gen_amalgamated expanded: #include "src/tracing/service/tracing_service_endpoints_impl.h" // gen_amalgamated expanded: #include "src/tracing/service/tracing_service_session.h" // gen_amalgamated expanded: #include "src/tracing/service/tracing_service_structs.h" @@ -66007,14 +74842,12 @@ class Consumer; class Producer; class SharedMemory; class SharedMemoryArbiterImpl; -class TraceBuffer; class TracePacket; namespace tracing_service { // The tracing service business logic. class TracingServiceImpl : public TracingService { public: - static constexpr size_t kMaxShmSize = 32 * 1024 * 1024ul; static constexpr uint8_t kSyncMarker[] = {0x82, 0x47, 0x7a, 0x76, 0xb2, 0x8d, 0x42, 0xba, 0x81, 0xdc, 0x33, 0x32, 0x6d, 0x57, 0xa0, 0x79}; @@ -66118,7 +74951,12 @@ class TracingServiceImpl : public TracingService { size_t shared_memory_page_size_hint_bytes = 0, std::unique_ptr shm = nullptr, const std::string& sdk_version = {}, - const std::string& machine_name = {}) override; + const std::string& machine_name = {}, + uint32_t protocol_abi_versions = kProtocolAbiV1) override; + + // The endpoint reports discarded ring buffer chunks on the service + // sequence. Adds them to chunks_discarded. + void OnRingBufferChunksDiscarded(uint64_t count); std::unique_ptr ConnectConsumer( Consumer*, @@ -66239,6 +75077,7 @@ class TracingServiceImpl : public TracingService { bool success); void ScrapeSharedMemoryBuffers(TracingSession*, ProducerEndpointImpl*); void PeriodicClearIncrementalStateTask(TracingSessionID, bool post_next_only); + // Returns nullptr if there is no buffer with this ID. TraceBuffer* GetBufferByID(BufferID); void FlushDataSourceInstances( TracingSession*, @@ -66287,8 +75126,11 @@ class TracingServiceImpl : public TracingService { std::vector* packets); // If `*tracing_session` has compression enabled, compress `*packets`. + // `skip_compression_of_first_n_packets` is the number of packets to skip + // compression of (i.e. TraceConfig, UUID packets). void MaybeCompressPackets(TracingSession* tracing_session, - std::vector* packets); + std::vector* packets, + size_t skip_compression_of_first_n_packets); // If `*tracing_session` is configured to write into a file, writes `packets` // into the file. @@ -66297,6 +75139,12 @@ class TracingServiceImpl : public TracingService { // been an error), false otherwise. bool WriteIntoFile(TracingSession* tracing_session, std::vector packets); + + // Attempts to compact each buffer in `*tracing_session`. + // Call only after the ReadBuffers() packets are no longer in use, because + // compaction can move the data their slices reference. + void MaybeCompactBuffers(TracingSession* tracing_session); + void OnStartTriggersTimeout(TracingSessionID tsid); void MaybeLogUploadEvent(const TraceConfig&, const base::Uuid&, @@ -66378,20 +75226,30 @@ class TracingServiceImpl : public TracingService { */ // gen_amalgamated expanded: #include "src/tracing/service/tracing_service_endpoints_impl.h" + +#include + // gen_amalgamated expanded: #include "perfetto/base/task_runner.h" // gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h" // gen_amalgamated expanded: #include "perfetto/ext/base/metatrace.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/status_or.h" // gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h" // gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h" // gen_amalgamated expanded: #include "perfetto/ext/base/version.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/consumer.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/producer.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h" +// gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h" // gen_amalgamated expanded: #include "perfetto/tracing/core/tracing_service_capabilities.h" // gen_amalgamated expanded: #include "perfetto/tracing/core/tracing_service_state.h" +// gen_amalgamated expanded: #include "src/tracing/core/in_process_shared_memory.h" +// gen_amalgamated expanded: #include "src/tracing/core/null_trace_writer.h" // gen_amalgamated expanded: #include "src/tracing/core/shared_memory_arbiter_impl.h" +// gen_amalgamated expanded: #include "src/tracing/service/service_ring_buffer_drainer.h" +// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer.h" // gen_amalgamated expanded: #include "src/tracing/service/tracing_service_impl.h" // gen_amalgamated expanded: #include "src/tracing/service/tracing_service_structs.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_abi.h" // gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.pbzero.h" @@ -66790,7 +75648,8 @@ ProducerEndpointImpl::ProducerEndpointImpl( const std::string& machine_name, const std::string& sdk_version, bool in_process, - bool smb_scraping_enabled) + bool smb_scraping_enabled, + uint32_t protocol_abi_versions) : id_(id), client_identity_(client_identity), service_(service), @@ -66800,6 +75659,7 @@ ProducerEndpointImpl::ProducerEndpointImpl( sdk_version_(sdk_version), in_process_(in_process), smb_scraping_enabled_(smb_scraping_enabled), + protocol_abi_versions_(protocol_abi_versions), weak_runner_(task_runner) {} ProducerEndpointImpl::~ProducerEndpointImpl() { @@ -67000,11 +75860,30 @@ bool ProducerEndpointImpl::IsShmemProvidedByProducer() const { std::unique_ptr ProducerEndpointImpl::CreateTraceWriter( BufferID buf_id, BufferExhaustedPolicy buffer_exhausted_policy) { + if (!(protocol_abi_versions_ & kProtocolAbiV1)) { + PERFETTO_ELOG( + "Cannot create a v1 trace writer: v1 is not in the common protocol " + "mask (%x)", + protocol_abi_versions_); + return std::make_unique(); + } PERFETTO_DCHECK(MaybeSharedMemoryArbiter()); return MaybeSharedMemoryArbiter()->CreateTraceWriter(buf_id, buffer_exhausted_policy); } +// Can be called on any thread. +std::unique_ptr ProducerEndpointImpl::CreateTraceWriterV2( + BufferID buf_id, + BufferExhaustedPolicy buffer_exhausted_policy) { + auto* arbiter = v2_ring_buffer_arbiter_.has_value() + ? v2_ring_buffer_arbiter_->get() + : nullptr; + if (!arbiter) + return std::make_unique(); + return arbiter->CreateTraceWriter(buf_id, buffer_exhausted_policy); +} + void ProducerEndpointImpl::NotifyFlushComplete(FlushRequestID id) { PERFETTO_DCHECK_THREAD(thread_checker_); PERFETTO_DCHECK(MaybeSharedMemoryArbiter()); @@ -67116,6 +75995,100 @@ bool ProducerEndpointImpl::IsAndroidProcessFrozen() { return false; } +void ProducerEndpointImpl::InitializeV2RingBuffer( + const DataSourceConfig& config) { + PERFETTO_DCHECK_THREAD(thread_checker_); + if (v2_ring_buffer_arbiter_.has_value() || !in_process_ || + !(protocol_abi_versions_ & kProtocolAbiV2)) { + return; + } + + auto arbiter_or = tracing_v2::ProducerRingBufferArbiter::Create( + weak_runner_.task_runner(), this, config, shmem_size_hint_bytes_, + [](size_t size) -> base::StatusOr> { + return std::shared_ptr( + InProcessSharedMemory::Create(size)); + }); + if (!arbiter_or.ok()) { + PERFETTO_ELOG("tracing v2: cannot create ring buffer: %s", + arbiter_or.status().c_message()); + v2_ring_buffer_arbiter_ = nullptr; + return; + } + v2_ring_buffer_arbiter_ = std::move(*arbiter_or); + + auto* arbiter = v2_ring_buffer_arbiter_->get(); + AttachV2RingBuffer( + arbiter->memory(), arbiter->ring_buffer()->chunk_size(), + [weak_arbiter = arbiter->GetWeakPtr()](bool reader_attached) { + if (weak_arbiter) + weak_arbiter->OnReaderAttachReply(reader_attached); + }); +} + +void ProducerEndpointImpl::AttachV2RingBuffer( + const std::shared_ptr& memory, + uint32_t chunk_size_bytes, + std::function callback) { + PERFETTO_DCHECK_THREAD(thread_checker_); + + base::Status status; + if (!(protocol_abi_versions_ & kProtocolAbiV2)) { + status = base::ErrStatus("the connection has no tracing v2"); + } else if (v2_ring_buffer_drainer_) { + status = base::ErrStatus("a ring buffer is already attached"); + } else if (!memory || memory->size() > TracingService::kMaxShmSize) { + status = base::ErrStatus("no mapping, or the mapping is too large"); + } else { + status = tracing_v2::NumChunksForRingBufferLayout( + memory->start(), memory->size(), chunk_size_bytes) + .status(); + } + if (!status.ok()) { + PERFETTO_DLOG("Producer %" PRIu16 " \"%s\": ring buffer rejected: %s", id_, + name_.c_str(), status.c_message()); + callback(false); + return; + } + + v2_ring_buffer_drainer_ = + std::make_unique( + memory, chunk_size_bytes, id_, client_identity_, this, + weak_runner_.task_runner()); + service_->UpdateMemoryGuardrail(); + DrainV2RingBuffer(); + callback(true); +} + +void ProducerEndpointImpl::DrainV2RingBuffer() { + PERFETTO_DCHECK_THREAD(thread_checker_); + if (v2_ring_buffer_drainer_) + v2_ring_buffer_drainer_->Drain(); +} + +TraceBuffer* ProducerEndpointImpl::GetV2RingBufferDestination(BufferID id) { + if (!is_allowed_target_buffer(id)) + return nullptr; + + // The producer supplies |id| through shared memory. Check that the + // destination buffer supports tracing v2 otherwise return nullptr. + TraceBuffer* buffer = service_->GetBufferByID(id); + return buffer && buffer->supports_tracing_v2() ? buffer : nullptr; +} + +void ProducerEndpointImpl::ForEachV2RingBufferDestination( + const std::function& callback) { + for (BufferID id : allowed_target_buffers_) { + TraceBuffer* buffer = service_->GetBufferByID(id); + if (buffer && buffer->supports_tracing_v2()) + callback(*buffer); + } +} + +void ProducerEndpointImpl::OnRingBufferChunksDiscarded(uint64_t count) { + service_->OnRingBufferChunksDiscarded(count); +} + //////////////////////////////////////////////////////////////////////////////// // RelayEndpointImpl implementation //////////////////////////////////////////////////////////////////////////////// @@ -67308,11 +76281,13 @@ inline base::StatusOr CreateSchedPolicyFromConfig( // gen_amalgamated expanded: #include "src/tracing/service/packet_stream_validator.h" // gen_amalgamated expanded: #include "src/tracing/service/random.h" // gen_amalgamated expanded: #include "src/tracing/service/trace_buffer.h" +// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_protovms.h" // gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v1.h" // gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v2.h" // gen_amalgamated expanded: #include "src/tracing/service/tracing_service_endpoints_impl.h" // gen_amalgamated expanded: #include "src/tracing/service/tracing_service_session.h" // gen_amalgamated expanded: #include "src/tracing/service/tracing_service_structs.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_abi.h" #if PERFETTO_BUILDFLAG(PERFETTO_ZLIB) // gen_amalgamated expanded: #include "src/tracing/service/zlib_compressor.h" #endif @@ -67441,7 +76416,7 @@ std::tuple EnsureValidShmSizes( shm_size = TracingServiceImpl::kDefaultShmSize; page_size = std::min(page_size, kMaxPageSize); - shm_size = std::min(shm_size, TracingServiceImpl::kMaxShmSize); + shm_size = std::min(shm_size, TracingService::kMaxShmSize); // The tracing page size has to be multiple of 4K. On some systems (e.g. Mac // on Arm64) the system page size can be larger (e.g., 16K). That doesn't @@ -67545,6 +76520,21 @@ void AppendOwnedSlicesToPacket(std::unique_ptr data, } } +// Creates an empty trace buffer of the given implementation. +// Returns nullptr if the memory allocation fails. +std::unique_ptr CreateTraceBuffer( + TraceBuffer::BufType type, + size_t size_in_bytes, + TraceBuffer::OverwritePolicy policy) { + switch (type) { + case TraceBuffer::kV1: + return TraceBufferV1::Create(size_in_bytes, policy); + case TraceBuffer::kV2: + return TraceBufferV2::Create(size_in_bytes, policy); + } + return nullptr; +} + // Shmem emulation is only for relay (remote-host) producers whose SMB is copied // over IPC. An in-process producer always has a real shared SMB, so it must use // kDefault even when it carries a non-default machine id. @@ -67586,9 +76576,18 @@ TracingServiceImpl::ConnectProducer(Producer* producer, size_t shared_memory_page_size_hint_bytes, std::unique_ptr shm, const std::string& sdk_version, - const std::string& machine_name) { + const std::string& machine_name, + uint32_t protocol_abi_versions) { PERFETTO_DCHECK_THREAD(thread_checker_); + if (!protocol_abi_versions) { + PERFETTO_ELOG( + "Failed to negotiate a valid tracing protocol version with the tracing " + "service: producer=\"%s\"", + producer_name.c_str()); + return nullptr; + } + auto uid = client_identity.uid(); if (lockdown_mode_ && uid != base::GetCurrentUserId()) { PERFETTO_DLOG("Lockdown mode. Rejecting producer with UID %lu", @@ -67618,7 +76617,7 @@ TracingServiceImpl::ConnectProducer(Producer* producer, std::unique_ptr endpoint(new ProducerEndpointImpl( id, client_identity, this, weak_runner_.task_runner(), producer, producer_name, machine_name, sdk_version, in_process, - smb_scraping_enabled)); + smb_scraping_enabled, protocol_abi_versions)); auto it_and_inserted = producers_.emplace(id, endpoint.get()); PERFETTO_DCHECK(it_and_inserted.second); @@ -68003,11 +77002,35 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer, } } + // For each buffer: the name of a data source with a ProtoVM, and of one + // that can use tracing v2. + // Tracing v2 does not support ProtoVM on the same buffer yet. + std::vector protovm_source(num_buffers); + std::vector tracing_v2_source(num_buffers); + // Check that the config specifies all buffers for its data sources. This // is also checked in SetupDataSource, but it is simpler to return a proper // error to the consumer from here (and there will be less state to undo). for (const TraceConfig::DataSource& cfg_data_source : cfg.data_sources()) { const auto& ds_config = cfg_data_source.config(); + const auto& tracing_v2_config = ds_config.experimental_tracing_v2(); + if (tracing_v2_config.use_v2_probability_percent() > 100) { + return PERFETTO_SVC_ERR( + "experimental_tracing_v2.use_v2_probability_percent must be at most " + "100"); + } + if (tracing_v2_config.drain_occupancy_percent() < -1 || + tracing_v2_config.drain_occupancy_percent() > 100) { + return PERFETTO_SVC_ERR( + "experimental_tracing_v2.drain_occupancy_percent must be -1 to 100"); + } + for (const auto& option : tracing_v2_config.chunk_size_options()) { + if (!tracing_v2::IsValidChunkSize(option.size_bytes())) { + return PERFETTO_SVC_ERR( + "experimental_tracing_v2.chunk_size_options: invalid size %u", + option.size_bytes()); + } + } // Resolve target buffer: if target_buffer_name is set, look it up. size_t target_buffer = ds_config.target_buffer(); @@ -68050,6 +77073,19 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer, "%zu)", ds_config.name().c_str(), target_buffer, num_buffers); } + + if (ds_config.has_protovm_config()) + protovm_source[target_buffer] = &ds_config.name(); + if (tracing_v2_config.use_v2_probability_percent() > 0) + tracing_v2_source[target_buffer] = &ds_config.name(); + if (protovm_source[target_buffer] && tracing_v2_source[target_buffer]) { + return PERFETTO_SVC_ERR( + "Data source \"%s\" has a ProtoVM and data source \"%s\" has " + "experimental_tracing_v2 on the same buffer %zu. Tracing v2 does not " + "support ProtoVM", + protovm_source[target_buffer]->c_str(), + tracing_v2_source[target_buffer]->c_str(), target_buffer); + } } uint32_t current_exclusive_prio = 0; @@ -68427,10 +77463,10 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer, std::unique_ptr new_buffer; switch (buffer_cfg.experimental_mode()) { case TraceConfig::BufferConfig::TRACE_BUFFER_V2: - new_buffer = TraceBufferV2::Create(buf_size, policy); + new_buffer = CreateTraceBuffer(TraceBuffer::kV2, buf_size, policy); break; case TraceConfig::BufferConfig::MODE_UNSPECIFIED: - new_buffer = TraceBufferV1::Create(buf_size, policy); + new_buffer = CreateTraceBuffer(TraceBuffer::kV1, buf_size, policy); break; } auto it_and_inserted = buffers_.emplace(global_id, std::move(new_buffer)); @@ -69521,13 +78557,6 @@ void TracingServiceImpl::CompleteFlush(TracingSessionID tsid, void TracingServiceImpl::ScrapeSharedMemoryBuffers( TracingSession* tracing_session, ProducerEndpointImpl* producer) { - if (!producer->smb_scraping_enabled_ || producer->IsShmemEmulated()) - return; - - // Can't copy chunks if we don't know about any trace writers. - if (producer->writers_.empty()) - return; - // Performance optimization: On flush or session disconnect, this method is // called for each producer. If the producer doesn't participate in the // session, there's no need to scrape its chunks right now. We can tell if a @@ -69542,6 +78571,16 @@ void TracingServiceImpl::ScrapeSharedMemoryBuffers( if (!producer_in_session) return; + // Drain v2 data even when v1 SMB scraping is disabled. + producer->DrainV2RingBuffer(); + + if (!producer->smb_scraping_enabled_ || producer->IsShmemEmulated()) + return; + + // Can't copy chunks if we don't know about any trace writers. + if (producer->writers_.empty()) + return; + PERFETTO_DLOG("Scraping SMB for producer %" PRIu16, producer->id_); // Find and copy any uncommitted chunks from the SMB. @@ -69749,6 +78788,26 @@ bool TracingServiceImpl::ReadBuffersIntoConsumer( return; ReadBuffersIntoConsumer(tsid, weak_consumer.get()); }); + } else { + // Compact only once ReadBuffers() has nothing more to read + // (has_more == false). + // By then the read has consumed as much data as it can, so compaction has + // the fewest chunks to memmove. + // If we compacted after every batch, we would move the unread chunks again + // each time and end up with the same layout. + // + // The packets passed to OnTraceData() point into the buffer, so compaction + // has to wait until it returns. + // But we can't compact inline after it, because the consumer's + // OnTraceData() can call FreeBuffers() or destroy the service. + // So we post a task. + // The task looks up the session again in case FreeBuffers() removed it, + // and weak_runner_ drops the task if the service is destroyed. + weak_runner_.PostTask([this, tsid] { + TracingSession* tracing_session = GetTracingSession(tsid); + if (tracing_session) + MaybeCompactBuffers(tracing_session); + }); } // Keep this as tail call, just in case the consumer re-enters. @@ -69808,6 +78867,8 @@ bool TracingServiceImpl::ReadBuffersIntoFile( return; } + MaybeCompactBuffers(tracing_session); + if (tracing_session->fflush_post_write) { // Ensure all data was written to the file. base::FlushFile(tracing_session->write_into_file.get()); @@ -69890,6 +78951,19 @@ std::vector TracingServiceImpl::ReadBuffers( &packets); } + if (!tracing_session->config.builtin_data_sources().disable_trace_config()) { + MaybeEmitTraceConfig(tracing_session, &packets); + } + if (!tracing_session->did_emit_initial_packets) { + EmitUuid(tracing_session, &packets); + } + + // All packets emitted above (clock snapshot, trace config, uuid) will not be + // compressed, regardless of the config. This is to allow services that + // consume the trace on-device to take decisions based on the metadata of the + // trace, without having to uncompress. + const size_t skip_compression_of_first_n_packets = packets.size(); + for (auto& snapshot : tracing_session->clock_snapshot_ring_buffer) { PERFETTO_DCHECK(!snapshot.empty()); EmitClockSnapshot(tracing_session, std::move(snapshot), &packets); @@ -69902,12 +78976,10 @@ std::vector TracingServiceImpl::ReadBuffers( } if (!tracing_session->config.builtin_data_sources().disable_trace_config()) { - MaybeEmitTraceConfig(tracing_session, &packets); MaybeEmitCloneTrigger(tracing_session, &packets); MaybeEmitReceivedTriggers(tracing_session, &packets); } if (!tracing_session->did_emit_initial_packets) { - EmitUuid(tracing_session, &packets); if (!tracing_session->config.builtin_data_sources() .disable_extension_descriptors()) { EmitExtensionDescriptors(tracing_session, &packets); @@ -70061,7 +79133,8 @@ std::vector TracingServiceImpl::ReadBuffers( } } - MaybeCompressPackets(tracing_session, &packets); + MaybeCompressPackets(tracing_session, &packets, + skip_compression_of_first_n_packets); if (!*has_more) { // We've observed some extremely high memory usage by scudo after @@ -70136,7 +79209,28 @@ void TracingServiceImpl::MaybeFilterPackets(TracingSession* tracing_session, void TracingServiceImpl::MaybeCompressPackets( TracingSession* tracing_session, - [[maybe_unused]] std::vector* packets) { + [[maybe_unused]] std::vector* packets, + [[maybe_unused]] size_t skip_compression_of_first_n_packets) { + [[maybe_unused]] auto compress_with_fn = [&](auto compress_fn) { + if (skip_compression_of_first_n_packets == 0) { + compress_fn(packets); + return; + } + if (skip_compression_of_first_n_packets >= packets->size()) { + return; + } + const auto nskip = + static_cast(skip_compression_of_first_n_packets); + std::vector packets_to_compress( + std::make_move_iterator(packets->begin() + nskip), + std::make_move_iterator(packets->end())); + packets->erase(packets->begin() + nskip, packets->end()); + compress_fn(&packets_to_compress); + packets->insert(packets->end(), + std::make_move_iterator(packets_to_compress.begin()), + std::make_move_iterator(packets_to_compress.end())); + }; + // Compress with the codec the config selects, preferring the newest (highest // proto field number) this build supports. Leaves the packets uncompressed if // none is available. @@ -70147,7 +79241,9 @@ void TracingServiceImpl::MaybeCompressPackets( tracing_session->config.compression(); #if PERFETTO_BUILDFLAG(PERFETTO_ZSTD) if (compression.has_zstd()) { - ZstdCompressFn(packets, compression.zstd().level()); + compress_with_fn([&](std::vector* target) { + ZstdCompressFn(target, compression.zstd().level()); + }); return; } #endif @@ -70156,7 +79252,8 @@ void TracingServiceImpl::MaybeCompressPackets( // predating `compression` still get compressed. if (compression.has_deflate() || tracing_session->config.compression_type() == TraceConfig::COMPRESSION_TYPE_DEFLATE) { - ZlibCompressFn(packets); + compress_with_fn( + [](std::vector* target) { ZlibCompressFn(target); }); return; } #endif @@ -70233,6 +79330,18 @@ bool TracingServiceImpl::WriteIntoFile(TracingSession* tracing_session, return stop_writing_into_file; } +void TracingServiceImpl::MaybeCompactBuffers(TracingSession* tracing_session) { + PERFETTO_DCHECK_THREAD(thread_checker_); + if (!tracing_session->config.experimental_trace_buffer_v2_compaction()) + return; + + for (BufferID buf_id : tracing_session->buffers_index) { + auto tbuf_iter = buffers_.find(buf_id); + if (tbuf_iter != buffers_.end()) + tbuf_iter->second->MaybeCompact(); + } +} + void TracingServiceImpl::FreeBuffers(TracingSessionID tsid, const std::string& error) { PERFETTO_DCHECK_THREAD(thread_checker_); @@ -70307,12 +79416,12 @@ void TracingServiceImpl::MaybeSetUpProtoVm( const RegisteredDataSource& ds_instance, BufferID buffer_id) { if (!ds_config.has_protovm_config() && - !ds_instance.descriptor.has_protovm_program()) { + ds_instance.descriptor.protovm_program_raw().empty()) { return; // Data source has no ProtoVM } // TODO(keanmariotti): report the errors below in a trace packet as well, so // that we can surface them on the UI. - if (!ds_instance.descriptor.has_protovm_program()) { + if (ds_instance.descriptor.protovm_program_raw().empty()) { PERFETTO_ELOG( "ProtoVM config for data source %s specifies a ProtoVM, but the data " "source instance (ProducerID: %d) doesn't specify a ProtoVM program", @@ -70335,17 +79444,16 @@ void TracingServiceImpl::MaybeSetUpProtoVm( } auto it = buffers_.find(buffer_id); PERFETTO_CHECK(it != buffers_.cend()); - if (it->second->buf_type() != TraceBuffer::BufType::kV2) { + TraceBufferProtoVms* protovms = it->second->protovms(); + if (!protovms) { PERFETTO_ELOG( "Data source %s is configured to run a ProtoVM, but the corresponding " - "buffer is not of type V2", + "buffer is of type V1, which cannot run one.", ds_config.name().c_str()); return; } - auto* buffer = static_cast(it->second.get()); - buffer->MaybeSetUpProtoVm( - ds_config.name(), - ds_instance.descriptor.protovm_program().SerializeAsString(), + protovms->MaybeSetUp( + ds_config.name(), ds_instance.descriptor.protovm_program_raw(), ds_config.protovm_config().memory_limit_kb(), ds_instance.producer_id); } @@ -70628,6 +79736,22 @@ DataSourceInstance* TracingServiceImpl::SetupDataSource( return nullptr; } + const BufferID global_id = tracing_session->buffers_index[relative_buffer_id]; + PERFETTO_DCHECK(global_id); + + const TraceBuffer* target_buffer = GetBufferByID(global_id); + const bool supports_tracing_v2 = + (producer->protocol_abi_versions_ & kProtocolAbiV2) && target_buffer && + target_buffer->supports_tracing_v2(); + if (!(producer->protocol_abi_versions_ & kProtocolAbiV1) && + !supports_tracing_v2) { + PERFETTO_ELOG( + "Cannot set up data source \"%s\" on producer \"%s\": " + "target_buffer %u supports no common protocol version", + ds_cfg.name().c_str(), producer->name_.c_str(), relative_buffer_id); + return nullptr; + } + // Create a copy of the DataSourceConfig specified in the trace config. This // will be passed to the producer after translating the |target_buffer| id. // The |target_buffer| parameter passed by the consumer in the trace config is @@ -70656,6 +79780,14 @@ DataSourceInstance* TracingServiceImpl::SetupDataSource( } DataSourceConfig& ds_config = ds_instance->config; + // When v2 is unavailable, keep an absent field unset so startup configs + // still match in older SDKs. + // + // If the consumer supplied a value, overwrite it with the service's decision + // about whether this data source can use v2. + if (supports_tracing_v2 || ds_config.has_supports_tracing_v2()) + ds_config.set_supports_tracing_v2(supports_tracing_v2); + ds_config.set_trace_duration_ms(tracing_session->config.duration_ms()); // Rationale for `if (prefer) set_prefer(true)`, rather than `set(prefer)`: @@ -70680,8 +79812,6 @@ DataSourceInstance* TracingServiceImpl::SetupDataSource( DataSourceConfig::SESSION_INITIATOR_UNSPECIFIED); } ds_config.set_tracing_session_id(tracing_session->id); - BufferID global_id = tracing_session->buffers_index[relative_buffer_id]; - PERFETTO_DCHECK(global_id); ds_config.set_target_buffer(global_id); MaybeSetUpProtoVm(ds_config, data_source, global_id); @@ -70928,6 +80058,11 @@ ProducerID TracingServiceImpl::GetNextProducerID() { return last_producer_id_; } +void TracingServiceImpl::OnRingBufferChunksDiscarded(uint64_t count) { + PERFETTO_DCHECK_THREAD(thread_checker_); + chunks_discarded_ += count; +} + TraceBuffer* TracingServiceImpl::GetBufferByID(BufferID buffer_id) { auto buf_iter = buffers_.find(buffer_id); if (buf_iter == buffers_.end()) @@ -70967,6 +80102,7 @@ void TracingServiceImpl::UpdateMemoryGuardrail() { for (const auto& id_to_producer : producers_) { if (id_to_producer.second->shared_memory()) total_buffer_bytes += id_to_producer.second->shared_memory()->size(); + total_buffer_bytes += id_to_producer.second->ring_buffer_size_bytes(); } // Sum up all the trace buffers. @@ -70987,7 +80123,7 @@ void TracingServiceImpl::UpdateMemoryGuardrail() { } } - // Set the guard rail to 64MB + the sum of all the buffers over a 30 second + // Set the guard rail to 32MB + the sum of all the buffers over a 30 second // interval. uint64_t guardrail = base::kWatchdogDefaultMemorySlack + total_buffer_bytes; base::Watchdog::GetInstance()->SetMemoryLimit(guardrail, 30 * 1000); @@ -71148,6 +80284,12 @@ void TracingServiceImpl::SetServiceTracePacketHeader( protos::pbzero::TracePacket* tp) { tp->set_trusted_uid(static_cast(uid_)); tp->set_trusted_packet_sequence_id(kServicePacketSequenceID); + // Every timestamp the service stamps on its own packets comes from + // GetBootTimeNs(), so declare the clock domain explicitly. Without this, + // Trace Processor's "no clock id" fallback resolves to the trace's primary + // clock, which is not BOOTTIME in general + // (https://github.com/google/perfetto/discussions/7112). + tp->set_timestamp_clock_id(protos::pbzero::BUILTIN_CLOCK_BOOTTIME); // When a local machine was adopted (an in-process producer with a non-default // machine id; see ConnectProducer), attribute the service's own packets to it // so the trace has no separate host machine. Host and relay sessions leave @@ -71359,6 +80501,9 @@ void TracingServiceImpl::EmitSystemInfo(std::vector* packets) { info->set_android_storage_model(sys_info.android_storage_model); if (!sys_info.android_ram_model.empty()) info->set_android_ram_model(sys_info.android_ram_model); + for (const auto& compatible : sys_info.device_tree_compatibles) { + info->add_device_tree_compatibles(compatible); + } if (!sys_info.android_serial_console.empty()) info->set_android_serial_console(sys_info.android_serial_console); @@ -71377,6 +80522,8 @@ void TracingServiceImpl::EmitTraceProvenance( TraceBuffer* buf = GetBufferByID(buf_id); if (!buf) continue; + // TODO(b/568173038): derive sequences from the buffer's own sequence + // tracking instead of writer_stats() once TraceBufferV1 is gone. for (auto it = buf->writer_stats().GetIterator(); it; ++it) { ProducerID producer_id; WriterID writer_id; @@ -71646,11 +80793,10 @@ void TracingServiceImpl::MaybeEmitProtoVmInstances( for (auto buffer_id : tracing_session->buffers_index) { auto it = buffers_.find(buffer_id); PERFETTO_CHECK(it != buffers_.cend()); - if (it->second->buf_type() != TraceBuffer::BufType::kV2) { + const TraceBufferProtoVms* protovms = it->second->protovms(); + if (!protovms) continue; - } - auto* buffer = static_cast(it->second.get()); - for (const TraceBufferV2::Vm& vm : buffer->GetProtoVmInstances()) { + for (const TraceBufferProtoVms::Vm& vm : protovms->instances()) { auto* vm_instance = get_packet_protovms()->add_instance(); vm_instance->AppendString( protos::pbzero::TracePacket::ProtoVms::Instance::kProgramFieldNumber, @@ -71874,18 +81020,9 @@ base::Status TracingServiceImpl::FlushAndCloneSession( continue; // Some leftover data was left in the buffer. Recreate it to empty it. - const auto buf_policy = buf->overwrite_policy(); - const auto buf_size = buf->size(); - const auto buf_type = buf->buf_type(); std::unique_ptr old_buf = std::move(buf); - switch (buf_type) { - case TraceBuffer::kV1: - buf = TraceBufferV1::Create(buf_size, buf_policy); - break; - case TraceBuffer::kV2: - buf = TraceBufferV2::Create(buf_size, buf_policy); - break; - } + buf = CreateTraceBuffer(old_buf->buf_type(), old_buf->size(), + old_buf->overwrite_policy()); if (!buf) { // This is extremely rare but could happen on 32-bit. If the new buffer // allocation failed, put back the buffer where it was and fail the clone. @@ -72054,18 +81191,9 @@ bool TracingServiceImpl::DoCloneBuffers(const TracingSession& src, std::unique_ptr& src_buf = buf_iter->second; std::unique_ptr new_buf; if (src.config.buffers()[buf_idx].transfer_on_clone()) { - const auto buf_policy = src_buf->overwrite_policy(); - const auto buf_size = src_buf->size(); - const auto buf_type = src_buf->buf_type(); new_buf = std::move(src_buf); - switch (buf_type) { - case TraceBuffer::kV1: - src_buf = TraceBufferV1::Create(buf_size, buf_policy); - break; - case TraceBuffer::kV2: - src_buf = TraceBufferV2::Create(buf_size, buf_policy); - break; - } + src_buf = CreateTraceBuffer(new_buf->buf_type(), new_buf->size(), + new_buf->overwrite_policy()); if (!src_buf) { // If the allocation fails put the buffer back and let the code below // handle the failure gracefully. @@ -72395,7 +81523,9 @@ std::unique_ptr InProcessTracingBackend::ConnectProducer( args.producer_name, args.shmem_size_hint_bytes, /*in_process=*/true, TracingService::ProducerSMBScrapingMode::kEnabled, - args.shmem_page_size_hint_bytes); + args.shmem_page_size_hint_bytes, /*shm=*/nullptr, + /*sdk_version=*/{}, /*machine_name=*/{}, + kProtocolAbiV1 | kProtocolAbiV2); } std::unique_ptr InProcessTracingBackend::ConnectConsumer( @@ -72436,16 +81566,18 @@ TracingService* InProcessTracingBackend::GetOrCreateService( // gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/qnx/qnx_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/linux/journald_config.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/stack_sampling_profiler.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/sampling_heap_profiler.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/histogram_samples.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/track_event/track_event_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/sys_stats/sys_stats_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/sys_stats_counters.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/smaps_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/profiling/perf_event_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/perf_events.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/profiling/java_hprof_config.gen.h" -// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/smaps_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/profiling/heapprofd_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/process_stats/process_stats_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/statsd/statsd_tracing_config.gen.h" @@ -72479,6 +81611,7 @@ TracingService* InProcessTracingBackend::GetOrCreateService( // gen_amalgamated expanded: #include "protos/perfetto/config/android/app_wakelock_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_system_property_config.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_process_state_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_polled_state_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_log_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h" @@ -74287,16 +83420,18 @@ void EnableTracingRequest::Serialize(::protozero::Message* msg) const { // gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/qnx/qnx_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/linux/journald_config.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/stack_sampling_profiler.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/chrome/sampling_heap_profiler.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/histogram_samples.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/system_info/system_info_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/track_event/track_event_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/test_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/sys_stats/sys_stats_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/sys_stats_counters.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/smaps_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/profiling/perf_event_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/perf_events.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/profiling/java_hprof_config.gen.h" -// gen_amalgamated expanded: #include "protos/perfetto/config/profiling/smaps_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/profiling/heapprofd_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/process_stats/process_stats_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/priority_boost/priority_boost_config.gen.h" @@ -74331,6 +83466,7 @@ void EnableTracingRequest::Serialize(::protozero::Message* msg) const { // gen_amalgamated expanded: #include "protos/perfetto/config/android/app_wakelock_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_system_property_config.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/android/android_process_state_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_polled_state_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_log_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/android_log_constants.gen.h" @@ -75834,6 +84970,199 @@ void RegisterDataSourceRequest::Serialize(::protozero::Message* msg) const { } +DrainV2RingBufferResponse::DrainV2RingBufferResponse() = default; +DrainV2RingBufferResponse::~DrainV2RingBufferResponse() = default; +DrainV2RingBufferResponse::DrainV2RingBufferResponse(const DrainV2RingBufferResponse&) = default; +DrainV2RingBufferResponse& DrainV2RingBufferResponse::operator=(const DrainV2RingBufferResponse&) = default; +DrainV2RingBufferResponse::DrainV2RingBufferResponse(DrainV2RingBufferResponse&&) noexcept = default; +DrainV2RingBufferResponse& DrainV2RingBufferResponse::operator=(DrainV2RingBufferResponse&&) = default; + +bool DrainV2RingBufferResponse::operator==(const DrainV2RingBufferResponse& other) const { + return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_); +} + +bool DrainV2RingBufferResponse::ParseFromArray(const void* raw, size_t size) { + unknown_fields_.clear(); + bool packed_error = false; + + ::protozero::ProtoDecoder dec(raw, size); + for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) { + if (field.id() < _has_field_.size()) { + _has_field_.set(field.id()); + } + switch (field.id()) { + default: + field.SerializeAndAppendTo(&unknown_fields_); + break; + } + } + return !packed_error && !dec.bytes_left(); +} + +std::string DrainV2RingBufferResponse::SerializeAsString() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsString(); +} + +std::vector DrainV2RingBufferResponse::SerializeAsArray() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsArray(); +} + +void DrainV2RingBufferResponse::Serialize(::protozero::Message* msg) const { + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); +} + + +DrainV2RingBufferRequest::DrainV2RingBufferRequest() = default; +DrainV2RingBufferRequest::~DrainV2RingBufferRequest() = default; +DrainV2RingBufferRequest::DrainV2RingBufferRequest(const DrainV2RingBufferRequest&) = default; +DrainV2RingBufferRequest& DrainV2RingBufferRequest::operator=(const DrainV2RingBufferRequest&) = default; +DrainV2RingBufferRequest::DrainV2RingBufferRequest(DrainV2RingBufferRequest&&) noexcept = default; +DrainV2RingBufferRequest& DrainV2RingBufferRequest::operator=(DrainV2RingBufferRequest&&) = default; + +bool DrainV2RingBufferRequest::operator==(const DrainV2RingBufferRequest& other) const { + return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_); +} + +bool DrainV2RingBufferRequest::ParseFromArray(const void* raw, size_t size) { + unknown_fields_.clear(); + bool packed_error = false; + + ::protozero::ProtoDecoder dec(raw, size); + for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) { + if (field.id() < _has_field_.size()) { + _has_field_.set(field.id()); + } + switch (field.id()) { + default: + field.SerializeAndAppendTo(&unknown_fields_); + break; + } + } + return !packed_error && !dec.bytes_left(); +} + +std::string DrainV2RingBufferRequest::SerializeAsString() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsString(); +} + +std::vector DrainV2RingBufferRequest::SerializeAsArray() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsArray(); +} + +void DrainV2RingBufferRequest::Serialize(::protozero::Message* msg) const { + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); +} + + +AttachV2RingBufferResponse::AttachV2RingBufferResponse() = default; +AttachV2RingBufferResponse::~AttachV2RingBufferResponse() = default; +AttachV2RingBufferResponse::AttachV2RingBufferResponse(const AttachV2RingBufferResponse&) = default; +AttachV2RingBufferResponse& AttachV2RingBufferResponse::operator=(const AttachV2RingBufferResponse&) = default; +AttachV2RingBufferResponse::AttachV2RingBufferResponse(AttachV2RingBufferResponse&&) noexcept = default; +AttachV2RingBufferResponse& AttachV2RingBufferResponse::operator=(AttachV2RingBufferResponse&&) = default; + +bool AttachV2RingBufferResponse::operator==(const AttachV2RingBufferResponse& other) const { + return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_); +} + +bool AttachV2RingBufferResponse::ParseFromArray(const void* raw, size_t size) { + unknown_fields_.clear(); + bool packed_error = false; + + ::protozero::ProtoDecoder dec(raw, size); + for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) { + if (field.id() < _has_field_.size()) { + _has_field_.set(field.id()); + } + switch (field.id()) { + default: + field.SerializeAndAppendTo(&unknown_fields_); + break; + } + } + return !packed_error && !dec.bytes_left(); +} + +std::string AttachV2RingBufferResponse::SerializeAsString() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsString(); +} + +std::vector AttachV2RingBufferResponse::SerializeAsArray() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsArray(); +} + +void AttachV2RingBufferResponse::Serialize(::protozero::Message* msg) const { + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); +} + + +AttachV2RingBufferRequest::AttachV2RingBufferRequest() = default; +AttachV2RingBufferRequest::~AttachV2RingBufferRequest() = default; +AttachV2RingBufferRequest::AttachV2RingBufferRequest(const AttachV2RingBufferRequest&) = default; +AttachV2RingBufferRequest& AttachV2RingBufferRequest::operator=(const AttachV2RingBufferRequest&) = default; +AttachV2RingBufferRequest::AttachV2RingBufferRequest(AttachV2RingBufferRequest&&) noexcept = default; +AttachV2RingBufferRequest& AttachV2RingBufferRequest::operator=(AttachV2RingBufferRequest&&) = default; + +bool AttachV2RingBufferRequest::operator==(const AttachV2RingBufferRequest& other) const { + return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_) + && ::protozero::internal::gen_helpers::EqualsField(chunk_size_bytes_, other.chunk_size_bytes_); +} + +bool AttachV2RingBufferRequest::ParseFromArray(const void* raw, size_t size) { + unknown_fields_.clear(); + bool packed_error = false; + + ::protozero::ProtoDecoder dec(raw, size); + for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) { + if (field.id() < _has_field_.size()) { + _has_field_.set(field.id()); + } + switch (field.id()) { + case 1 /* chunk_size_bytes */: + field.get(&chunk_size_bytes_); + break; + default: + field.SerializeAndAppendTo(&unknown_fields_); + break; + } + } + return !packed_error && !dec.bytes_left(); +} + +std::string AttachV2RingBufferRequest::SerializeAsString() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsString(); +} + +std::vector AttachV2RingBufferRequest::SerializeAsArray() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsArray(); +} + +void AttachV2RingBufferRequest::Serialize(::protozero::Message* msg) const { + // Field 1: chunk_size_bytes + if (_has_field_[1]) { + ::protozero::internal::gen_helpers::SerializeVarInt(1, chunk_size_bytes_, msg); + } + + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); +} + + InitializeConnectionResponse::InitializeConnectionResponse() = default; InitializeConnectionResponse::~InitializeConnectionResponse() = default; InitializeConnectionResponse::InitializeConnectionResponse(const InitializeConnectionResponse&) = default; @@ -75845,7 +85174,8 @@ bool InitializeConnectionResponse::operator==(const InitializeConnectionResponse return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_) && ::protozero::internal::gen_helpers::EqualsField(using_shmem_provided_by_producer_, other.using_shmem_provided_by_producer_) && ::protozero::internal::gen_helpers::EqualsField(direct_smb_patching_supported_, other.direct_smb_patching_supported_) - && ::protozero::internal::gen_helpers::EqualsField(use_shmem_emulation_, other.use_shmem_emulation_); + && ::protozero::internal::gen_helpers::EqualsField(use_shmem_emulation_, other.use_shmem_emulation_) + && ::protozero::internal::gen_helpers::EqualsField(protocol_abi_versions_, other.protocol_abi_versions_); } bool InitializeConnectionResponse::ParseFromArray(const void* raw, size_t size) { @@ -75867,6 +85197,9 @@ bool InitializeConnectionResponse::ParseFromArray(const void* raw, size_t size) case 3 /* use_shmem_emulation */: field.get(&use_shmem_emulation_); break; + case 4 /* protocol_abi_versions */: + field.get(&protocol_abi_versions_); + break; default: field.SerializeAndAppendTo(&unknown_fields_); break; @@ -75903,6 +85236,11 @@ void InitializeConnectionResponse::Serialize(::protozero::Message* msg) const { ::protozero::internal::gen_helpers::SerializeTinyVarInt(3, use_shmem_emulation_, msg); } + // Field 4: protocol_abi_versions + if (_has_field_[4]) { + ::protozero::internal::gen_helpers::SerializeVarInt(4, protocol_abi_versions_, msg); + } + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); } @@ -75922,7 +85260,8 @@ bool InitializeConnectionRequest::operator==(const InitializeConnectionRequest& && ::protozero::internal::gen_helpers::EqualsField(smb_scraping_mode_, other.smb_scraping_mode_) && ::protozero::internal::gen_helpers::EqualsField(producer_provided_shmem_, other.producer_provided_shmem_) && ::protozero::internal::gen_helpers::EqualsField(sdk_version_, other.sdk_version_) - && ::protozero::internal::gen_helpers::EqualsField(shm_key_windows_, other.shm_key_windows_); + && ::protozero::internal::gen_helpers::EqualsField(shm_key_windows_, other.shm_key_windows_) + && ::protozero::internal::gen_helpers::EqualsField(supported_protocol_abi_versions_, other.supported_protocol_abi_versions_); } bool InitializeConnectionRequest::ParseFromArray(const void* raw, size_t size) { @@ -75956,6 +85295,9 @@ bool InitializeConnectionRequest::ParseFromArray(const void* raw, size_t size) { case 7 /* shm_key_windows */: ::protozero::internal::gen_helpers::DeserializeString(field, &shm_key_windows_); break; + case 9 /* supported_protocol_abi_versions */: + field.get(&supported_protocol_abi_versions_); + break; default: field.SerializeAndAppendTo(&unknown_fields_); break; @@ -76012,6 +85354,11 @@ void InitializeConnectionRequest::Serialize(::protozero::Message* msg) const { ::protozero::internal::gen_helpers::SerializeString(7, shm_key_windows_, msg); } + // Field 9: supported_protocol_abi_versions + if (_has_field_[9]) { + ::protozero::internal::gen_helpers::SerializeVarInt(9, supported_protocol_abi_versions_, msg); + } + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); } @@ -78869,62 +88216,6 @@ std::unique_ptr WatchUnixSocketCreation( } // namespace perfetto // gen_amalgamated begin source: src/ipc/buffered_frame_deserializer.cc // gen_amalgamated begin header: src/ipc/buffered_frame_deserializer.h -// gen_amalgamated begin header: include/perfetto/ext/ipc/basic_types.h -/* - * Copyright (C) 2017 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef INCLUDE_PERFETTO_EXT_IPC_BASIC_TYPES_H_ -#define INCLUDE_PERFETTO_EXT_IPC_BASIC_TYPES_H_ - -#include -#include -#include - -// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h" -// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h" - -namespace perfetto { -namespace ipc { - -using ProtoMessage = ::protozero::CppMessageObj; -using ServiceID = uint32_t; -using MethodID = uint32_t; -using ClientID = uint64_t; -using RequestID = uint64_t; - -#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) -// AF_UNIX on Windows is supported only on Windows 10 from build 17063. -// Also it doesn't bring major advantages compared to a TCP socket. -// See go/perfetto-win . -constexpr bool kUseTCPSocket = true; -#else -// Android, Linux, Mac, Fuchsia use local sockets. -constexpr bool kUseTCPSocket = false; -#endif - -// This determines the maximum size allowed for an IPC message. Trying to send -// or receive a larger message will hit DCHECK(s) and auto-disconnect. -constexpr size_t kIPCBufferSize = 128 * 1024; - -constexpr uid_t kInvalidUid = static_cast(-1); - -} // namespace ipc -} // namespace perfetto - -#endif // INCLUDE_PERFETTO_EXT_IPC_BASIC_TYPES_H_ /* * Copyright (C) 2017 The Android Open Source Project * @@ -79123,8 +88414,7 @@ BufferedFrameDeserializer::BeginReceive() { // Surely we are going to use at least the first page, but we may not need // the rest for a bit. - const auto page_size = base::GetSysPageSize(); - buf_.AdviseDontNeed(buf() + page_size, capacity_ - page_size); + buf_.AdviseDontNeedAfter(base::GetSysPageSize()); } PERFETTO_CHECK(capacity_ > size_); @@ -79211,11 +88501,8 @@ bool BufferedFrameDeserializer::EndReceive(size_t recv_size) { if (consumed_size > page_size) { size_t size_rounded_up = (size_ / page_size + 1) * page_size; if (size_rounded_up < capacity_) { - char* madvise_begin = buf() + size_rounded_up; - const size_t madvise_size = capacity_ - size_rounded_up; - PERFETTO_CHECK(madvise_begin > buf() + size_); - PERFETTO_CHECK(madvise_begin + madvise_size <= buf() + capacity_); - buf_.AdviseDontNeed(madvise_begin, madvise_size); + PERFETTO_CHECK(size_rounded_up > size_); + buf_.AdviseDontNeedAfter(size_rounded_up); } } } @@ -81680,1188 +90967,494 @@ void ConsumerPortProxy::Attach(const AttachRequest& request, DeferredAttachRespo fd); } -void ConsumerPortProxy::GetTraceStats(const GetTraceStatsRequest& request, DeferredGetTraceStatsResponse reply, int fd) { - BeginInvoke("GetTraceStats", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ConsumerPortProxy::ObserveEvents(const ObserveEventsRequest& request, DeferredObserveEventsResponse reply, int fd) { - BeginInvoke("ObserveEvents", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ConsumerPortProxy::QueryServiceState(const QueryServiceStateRequest& request, DeferredQueryServiceStateResponse reply, int fd) { - BeginInvoke("QueryServiceState", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ConsumerPortProxy::QueryCapabilities(const QueryCapabilitiesRequest& request, DeferredQueryCapabilitiesResponse reply, int fd) { - BeginInvoke("QueryCapabilities", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ConsumerPortProxy::SaveTraceForBugreport(const SaveTraceForBugreportRequest& request, DeferredSaveTraceForBugreportResponse reply, int fd) { - BeginInvoke("SaveTraceForBugreport", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ConsumerPortProxy::CloneSession(const CloneSessionRequest& request, DeferredCloneSessionResponse reply, int fd) { - BeginInvoke("CloneSession", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} -} // namespace perfetto -} // namespace protos -} // namespace gen -// gen_amalgamated begin source: gen/protos/perfetto/ipc/producer_port.ipc.cc -// gen_amalgamated begin header: gen/protos/perfetto/ipc/producer_port.ipc.h -// DO NOT EDIT. Autogenerated by Perfetto IPC -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_H_ - -// gen_amalgamated expanded: #include "perfetto/ext/ipc/deferred.h" -// gen_amalgamated expanded: #include "perfetto/ext/ipc/service.h" -// gen_amalgamated expanded: #include "perfetto/ext/ipc/service_descriptor.h" -// gen_amalgamated expanded: #include "perfetto/ext/ipc/service_proxy.h" - -// gen_amalgamated expanded: #include "protos/perfetto/ipc/producer_port.gen.h" -// gen_amalgamated expanded: #include "protos/perfetto/common/commit_data_request.gen.h" -// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h" -// gen_amalgamated expanded: #include "protos/perfetto/common/data_source_descriptor.gen.h" - -namespace perfetto { -namespace protos { -namespace gen { - -class ProducerPort : public ::perfetto::ipc::Service { - private: - static ::perfetto::ipc::ServiceDescriptor* NewDescriptor(); - - public: - ~ProducerPort() override; - - static const ::perfetto::ipc::ServiceDescriptor& GetDescriptorStatic(); - - // Service implementation. - const ::perfetto::ipc::ServiceDescriptor& GetDescriptor() override; - - // Methods from the .proto file - using DeferredInitializeConnectionResponse = ::perfetto::ipc::Deferred; - virtual void InitializeConnection(const InitializeConnectionRequest&, DeferredInitializeConnectionResponse) = 0; - - using DeferredRegisterDataSourceResponse = ::perfetto::ipc::Deferred; - virtual void RegisterDataSource(const RegisterDataSourceRequest&, DeferredRegisterDataSourceResponse) = 0; - - using DeferredUnregisterDataSourceResponse = ::perfetto::ipc::Deferred; - virtual void UnregisterDataSource(const UnregisterDataSourceRequest&, DeferredUnregisterDataSourceResponse) = 0; - - using DeferredCommitDataResponse = ::perfetto::ipc::Deferred; - virtual void CommitData(const CommitDataRequest&, DeferredCommitDataResponse) = 0; - - using DeferredGetAsyncCommandResponse = ::perfetto::ipc::Deferred; - virtual void GetAsyncCommand(const GetAsyncCommandRequest&, DeferredGetAsyncCommandResponse) = 0; - - using DeferredRegisterTraceWriterResponse = ::perfetto::ipc::Deferred; - virtual void RegisterTraceWriter(const RegisterTraceWriterRequest&, DeferredRegisterTraceWriterResponse) = 0; - - using DeferredUnregisterTraceWriterResponse = ::perfetto::ipc::Deferred; - virtual void UnregisterTraceWriter(const UnregisterTraceWriterRequest&, DeferredUnregisterTraceWriterResponse) = 0; - - using DeferredNotifyDataSourceStartedResponse = ::perfetto::ipc::Deferred; - virtual void NotifyDataSourceStarted(const NotifyDataSourceStartedRequest&, DeferredNotifyDataSourceStartedResponse) = 0; - - using DeferredNotifyDataSourceStoppedResponse = ::perfetto::ipc::Deferred; - virtual void NotifyDataSourceStopped(const NotifyDataSourceStoppedRequest&, DeferredNotifyDataSourceStoppedResponse) = 0; - - using DeferredActivateTriggersResponse = ::perfetto::ipc::Deferred; - virtual void ActivateTriggers(const ActivateTriggersRequest&, DeferredActivateTriggersResponse) = 0; - - using DeferredSyncResponse = ::perfetto::ipc::Deferred; - virtual void Sync(const SyncRequest&, DeferredSyncResponse) = 0; - - using DeferredUpdateDataSourceResponse = ::perfetto::ipc::Deferred; - virtual void UpdateDataSource(const UpdateDataSourceRequest&, DeferredUpdateDataSourceResponse) = 0; - -}; - - -class ProducerPortProxy : public ::perfetto::ipc::ServiceProxy { - public: - explicit ProducerPortProxy(::perfetto::ipc::ServiceProxy::EventListener*); - ~ProducerPortProxy() override; - - // ServiceProxy implementation. - const ::perfetto::ipc::ServiceDescriptor& GetDescriptor() override; - - // Methods from the .proto file - using DeferredInitializeConnectionResponse = ::perfetto::ipc::Deferred; - void InitializeConnection(const InitializeConnectionRequest&, DeferredInitializeConnectionResponse, int fd = -1); - - using DeferredRegisterDataSourceResponse = ::perfetto::ipc::Deferred; - void RegisterDataSource(const RegisterDataSourceRequest&, DeferredRegisterDataSourceResponse, int fd = -1); - - using DeferredUnregisterDataSourceResponse = ::perfetto::ipc::Deferred; - void UnregisterDataSource(const UnregisterDataSourceRequest&, DeferredUnregisterDataSourceResponse, int fd = -1); - - using DeferredCommitDataResponse = ::perfetto::ipc::Deferred; - void CommitData(const CommitDataRequest&, DeferredCommitDataResponse, int fd = -1); - - using DeferredGetAsyncCommandResponse = ::perfetto::ipc::Deferred; - void GetAsyncCommand(const GetAsyncCommandRequest&, DeferredGetAsyncCommandResponse, int fd = -1); - - using DeferredRegisterTraceWriterResponse = ::perfetto::ipc::Deferred; - void RegisterTraceWriter(const RegisterTraceWriterRequest&, DeferredRegisterTraceWriterResponse, int fd = -1); - - using DeferredUnregisterTraceWriterResponse = ::perfetto::ipc::Deferred; - void UnregisterTraceWriter(const UnregisterTraceWriterRequest&, DeferredUnregisterTraceWriterResponse, int fd = -1); - - using DeferredNotifyDataSourceStartedResponse = ::perfetto::ipc::Deferred; - void NotifyDataSourceStarted(const NotifyDataSourceStartedRequest&, DeferredNotifyDataSourceStartedResponse, int fd = -1); - - using DeferredNotifyDataSourceStoppedResponse = ::perfetto::ipc::Deferred; - void NotifyDataSourceStopped(const NotifyDataSourceStoppedRequest&, DeferredNotifyDataSourceStoppedResponse, int fd = -1); - - using DeferredActivateTriggersResponse = ::perfetto::ipc::Deferred; - void ActivateTriggers(const ActivateTriggersRequest&, DeferredActivateTriggersResponse, int fd = -1); - - using DeferredSyncResponse = ::perfetto::ipc::Deferred; - void Sync(const SyncRequest&, DeferredSyncResponse, int fd = -1); - - using DeferredUpdateDataSourceResponse = ::perfetto::ipc::Deferred; - void UpdateDataSource(const UpdateDataSourceRequest&, DeferredUpdateDataSourceResponse, int fd = -1); - -}; - -} // namespace perfetto -} // namespace protos -} // namespace gen - -#endif // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_H_ -// DO NOT EDIT. Autogenerated by Perfetto IPC -// gen_amalgamated expanded: #include "protos/perfetto/ipc/producer_port.ipc.h" -// gen_amalgamated expanded: #include "perfetto/ext/ipc/codegen_helpers.h" - -#include - -namespace perfetto { -namespace protos { -namespace gen { -::perfetto::ipc::ServiceDescriptor* ProducerPort::NewDescriptor() { - auto* desc = new ::perfetto::ipc::ServiceDescriptor(); - desc->service_name = "ProducerPort"; - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "InitializeConnection", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "RegisterDataSource", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "UnregisterDataSource", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "CommitData", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "GetAsyncCommand", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "RegisterTraceWriter", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "UnregisterTraceWriter", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "NotifyDataSourceStarted", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "NotifyDataSourceStopped", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "ActivateTriggers", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "Sync", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "UpdateDataSource", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - desc->methods.shrink_to_fit(); - return desc; -} - - -const ::perfetto::ipc::ServiceDescriptor& ProducerPort::GetDescriptorStatic() { - static auto* instance = NewDescriptor(); - return *instance; -} - -// Host-side definitions. -ProducerPort::~ProducerPort() = default; - -const ::perfetto::ipc::ServiceDescriptor& ProducerPort::GetDescriptor() { - return GetDescriptorStatic(); -} - -// Client-side definitions. -ProducerPortProxy::ProducerPortProxy(::perfetto::ipc::ServiceProxy::EventListener* event_listener) - : ::perfetto::ipc::ServiceProxy(event_listener) {} - -ProducerPortProxy::~ProducerPortProxy() = default; - -const ::perfetto::ipc::ServiceDescriptor& ProducerPortProxy::GetDescriptor() { - return ProducerPort::GetDescriptorStatic(); -} - -void ProducerPortProxy::InitializeConnection(const InitializeConnectionRequest& request, DeferredInitializeConnectionResponse reply, int fd) { - BeginInvoke("InitializeConnection", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ProducerPortProxy::RegisterDataSource(const RegisterDataSourceRequest& request, DeferredRegisterDataSourceResponse reply, int fd) { - BeginInvoke("RegisterDataSource", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ProducerPortProxy::UnregisterDataSource(const UnregisterDataSourceRequest& request, DeferredUnregisterDataSourceResponse reply, int fd) { - BeginInvoke("UnregisterDataSource", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ProducerPortProxy::CommitData(const CommitDataRequest& request, DeferredCommitDataResponse reply, int fd) { - BeginInvoke("CommitData", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ProducerPortProxy::GetAsyncCommand(const GetAsyncCommandRequest& request, DeferredGetAsyncCommandResponse reply, int fd) { - BeginInvoke("GetAsyncCommand", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ProducerPortProxy::RegisterTraceWriter(const RegisterTraceWriterRequest& request, DeferredRegisterTraceWriterResponse reply, int fd) { - BeginInvoke("RegisterTraceWriter", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ProducerPortProxy::UnregisterTraceWriter(const UnregisterTraceWriterRequest& request, DeferredUnregisterTraceWriterResponse reply, int fd) { - BeginInvoke("UnregisterTraceWriter", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ProducerPortProxy::NotifyDataSourceStarted(const NotifyDataSourceStartedRequest& request, DeferredNotifyDataSourceStartedResponse reply, int fd) { - BeginInvoke("NotifyDataSourceStarted", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ProducerPortProxy::NotifyDataSourceStopped(const NotifyDataSourceStoppedRequest& request, DeferredNotifyDataSourceStoppedResponse reply, int fd) { - BeginInvoke("NotifyDataSourceStopped", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ProducerPortProxy::ActivateTriggers(const ActivateTriggersRequest& request, DeferredActivateTriggersResponse reply, int fd) { - BeginInvoke("ActivateTriggers", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ProducerPortProxy::Sync(const SyncRequest& request, DeferredSyncResponse reply, int fd) { - BeginInvoke("Sync", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} - -void ProducerPortProxy::UpdateDataSource(const UpdateDataSourceRequest& request, DeferredUpdateDataSourceResponse reply, int fd) { - BeginInvoke("UpdateDataSource", request, ::perfetto::ipc::DeferredBase(std::move(reply)), - fd); -} -} // namespace perfetto -} // namespace protos -} // namespace gen -// gen_amalgamated begin source: gen/protos/perfetto/ipc/relay_port.ipc.cc -// gen_amalgamated begin header: gen/protos/perfetto/ipc/relay_port.ipc.h -// DO NOT EDIT. Autogenerated by Perfetto IPC -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_RELAY_PORT_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_RELAY_PORT_PROTO_H_ - -// gen_amalgamated expanded: #include "perfetto/ext/ipc/deferred.h" -// gen_amalgamated expanded: #include "perfetto/ext/ipc/service.h" -// gen_amalgamated expanded: #include "perfetto/ext/ipc/service_descriptor.h" -// gen_amalgamated expanded: #include "perfetto/ext/ipc/service_proxy.h" - -// gen_amalgamated expanded: #include "protos/perfetto/ipc/relay_port.gen.h" -// gen_amalgamated expanded: #include "protos/perfetto/common/system_info.gen.h" - -namespace perfetto { -namespace protos { -namespace gen { - -class RelayPort : public ::perfetto::ipc::Service { - private: - static ::perfetto::ipc::ServiceDescriptor* NewDescriptor(); - - public: - ~RelayPort() override; - - static const ::perfetto::ipc::ServiceDescriptor& GetDescriptorStatic(); - - // Service implementation. - const ::perfetto::ipc::ServiceDescriptor& GetDescriptor() override; - - // Methods from the .proto file - using DeferredInitRelayResponse = ::perfetto::ipc::Deferred; - virtual void InitRelay(const InitRelayRequest&, DeferredInitRelayResponse) = 0; - - using DeferredSyncClockResponse = ::perfetto::ipc::Deferred; - virtual void SyncClock(const SyncClockRequest&, DeferredSyncClockResponse) = 0; - -}; - - -class RelayPortProxy : public ::perfetto::ipc::ServiceProxy { - public: - explicit RelayPortProxy(::perfetto::ipc::ServiceProxy::EventListener*); - ~RelayPortProxy() override; - - // ServiceProxy implementation. - const ::perfetto::ipc::ServiceDescriptor& GetDescriptor() override; - - // Methods from the .proto file - using DeferredInitRelayResponse = ::perfetto::ipc::Deferred; - void InitRelay(const InitRelayRequest&, DeferredInitRelayResponse, int fd = -1); - - using DeferredSyncClockResponse = ::perfetto::ipc::Deferred; - void SyncClock(const SyncClockRequest&, DeferredSyncClockResponse, int fd = -1); - -}; - -} // namespace perfetto -} // namespace protos -} // namespace gen - -#endif // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_RELAY_PORT_PROTO_H_ -// DO NOT EDIT. Autogenerated by Perfetto IPC -// gen_amalgamated expanded: #include "protos/perfetto/ipc/relay_port.ipc.h" -// gen_amalgamated expanded: #include "perfetto/ext/ipc/codegen_helpers.h" - -#include - -namespace perfetto { -namespace protos { -namespace gen { -::perfetto::ipc::ServiceDescriptor* RelayPort::NewDescriptor() { - auto* desc = new ::perfetto::ipc::ServiceDescriptor(); - desc->service_name = "RelayPort"; - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "InitRelay", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - - desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ - "SyncClock", - &_IPC_Decoder, - &_IPC_Decoder, - &_IPC_Invoker}); - desc->methods.shrink_to_fit(); - return desc; -} - - -const ::perfetto::ipc::ServiceDescriptor& RelayPort::GetDescriptorStatic() { - static auto* instance = NewDescriptor(); - return *instance; -} - -// Host-side definitions. -RelayPort::~RelayPort() = default; - -const ::perfetto::ipc::ServiceDescriptor& RelayPort::GetDescriptor() { - return GetDescriptorStatic(); +void ConsumerPortProxy::GetTraceStats(const GetTraceStatsRequest& request, DeferredGetTraceStatsResponse reply, int fd) { + BeginInvoke("GetTraceStats", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); } -// Client-side definitions. -RelayPortProxy::RelayPortProxy(::perfetto::ipc::ServiceProxy::EventListener* event_listener) - : ::perfetto::ipc::ServiceProxy(event_listener) {} +void ConsumerPortProxy::ObserveEvents(const ObserveEventsRequest& request, DeferredObserveEventsResponse reply, int fd) { + BeginInvoke("ObserveEvents", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); +} -RelayPortProxy::~RelayPortProxy() = default; +void ConsumerPortProxy::QueryServiceState(const QueryServiceStateRequest& request, DeferredQueryServiceStateResponse reply, int fd) { + BeginInvoke("QueryServiceState", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); +} -const ::perfetto::ipc::ServiceDescriptor& RelayPortProxy::GetDescriptor() { - return RelayPort::GetDescriptorStatic(); +void ConsumerPortProxy::QueryCapabilities(const QueryCapabilitiesRequest& request, DeferredQueryCapabilitiesResponse reply, int fd) { + BeginInvoke("QueryCapabilities", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); } -void RelayPortProxy::InitRelay(const InitRelayRequest& request, DeferredInitRelayResponse reply, int fd) { - BeginInvoke("InitRelay", request, ::perfetto::ipc::DeferredBase(std::move(reply)), +void ConsumerPortProxy::SaveTraceForBugreport(const SaveTraceForBugreportRequest& request, DeferredSaveTraceForBugreportResponse reply, int fd) { + BeginInvoke("SaveTraceForBugreport", request, ::perfetto::ipc::DeferredBase(std::move(reply)), fd); } -void RelayPortProxy::SyncClock(const SyncClockRequest& request, DeferredSyncClockResponse reply, int fd) { - BeginInvoke("SyncClock", request, ::perfetto::ipc::DeferredBase(std::move(reply)), +void ConsumerPortProxy::CloneSession(const CloneSessionRequest& request, DeferredCloneSessionResponse reply, int fd) { + BeginInvoke("CloneSession", request, ::perfetto::ipc::DeferredBase(std::move(reply)), fd); } } // namespace perfetto } // namespace protos } // namespace gen -// gen_amalgamated begin source: src/tracing/ipc/default_socket.cc -/* - * Copyright (C) 2018 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// gen_amalgamated expanded: #include "perfetto/tracing/default_socket.h" - -// gen_amalgamated expanded: #include "perfetto/base/build_config.h" -// gen_amalgamated expanded: #include "perfetto/base/logging.h" -// gen_amalgamated expanded: #include "perfetto/ext/base/android_utils.h" -// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h" -// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h" -// gen_amalgamated expanded: #include "perfetto/ext/ipc/basic_types.h" -// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h" +// gen_amalgamated begin source: gen/protos/perfetto/ipc/producer_port.ipc.cc +// gen_amalgamated begin header: gen/protos/perfetto/ipc/producer_port.ipc.h +// DO NOT EDIT. Autogenerated by Perfetto IPC +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_H_ -#include +// gen_amalgamated expanded: #include "perfetto/ext/ipc/deferred.h" +// gen_amalgamated expanded: #include "perfetto/ext/ipc/service.h" +// gen_amalgamated expanded: #include "perfetto/ext/ipc/service_descriptor.h" +// gen_amalgamated expanded: #include "perfetto/ext/ipc/service_proxy.h" -#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) -#include -#endif +// gen_amalgamated expanded: #include "protos/perfetto/ipc/producer_port.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/common/commit_data_request.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/data_source_config.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/common/data_source_descriptor.gen.h" namespace perfetto { -namespace { +namespace protos { +namespace gen { -const char* kRunPerfettoBaseDir = "/run/perfetto/"; +class ProducerPort : public ::perfetto::ipc::Service { + private: + static ::perfetto::ipc::ServiceDescriptor* NewDescriptor(); -// On Linux and CrOS, check /run/perfetto/ before using /tmp/ as the socket -// base directory. -bool UseRunPerfettoBaseDir() { -#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) - // Note that the trailing / in |kRunPerfettoBaseDir| ensures we are checking - // against a directory, not a file. - int res = PERFETTO_EINTR(access(kRunPerfettoBaseDir, X_OK)); - if (!res) - return true; + public: + ~ProducerPort() override; - // If the path doesn't exist (ENOENT), fail silently to the caller. Otherwise, - // fail with an explicit error message. - if (errno != ENOENT -#if PERFETTO_BUILDFLAG(PERFETTO_CHROMIUM_BUILD) - // access(2) won't return EPERM, but Chromium sandbox returns EPERM if the - // sandbox doesn't allow the call (e.g. in the child processes). - && errno != EPERM -#endif - ) { - PERFETTO_PLOG("%s exists but cannot be accessed. Falling back on /tmp/ ", - kRunPerfettoBaseDir); - } - return false; -#else - base::ignore_result(kRunPerfettoBaseDir); - return false; -#endif -} + static const ::perfetto::ipc::ServiceDescriptor& GetDescriptorStatic(); -} // anonymous namespace + // Service implementation. + const ::perfetto::ipc::ServiceDescriptor& GetDescriptor() override; -const char* GetProducerSocket() { - const char* name = getenv("PERFETTO_PRODUCER_SOCK_NAME"); - if (name == nullptr) { -#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) - name = "127.0.0.1:32278"; -#elif PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) - name = "/dev/socket/traced_producer"; -#else - // Use /run/perfetto if it exists. Then fallback to /tmp. - static const char* producer_socket = - UseRunPerfettoBaseDir() ? "/run/perfetto/traced-producer.sock" - : "/tmp/perfetto-producer"; - name = producer_socket; -#endif - } - base::ignore_result(UseRunPerfettoBaseDir); // Silence unused func warnings. - return name; -} + // Methods from the .proto file + using DeferredInitializeConnectionResponse = ::perfetto::ipc::Deferred; + virtual void InitializeConnection(const InitializeConnectionRequest&, DeferredInitializeConnectionResponse) = 0; -std::string GetRelaySocket() { - // The relay socket is optional and is connected only when the env var is set. - // In Android, if the env var isn't set then we check the - // |traced_relay.relay_port| system property. - const char* name = getenv("PERFETTO_RELAY_SOCK_NAME"); - if (name != nullptr) - return std::string(name); -#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) - return base::GetAndroidProp("traced_relay.relay_port"); -#else - return std::string(); -#endif -} + using DeferredRegisterDataSourceResponse = ::perfetto::ipc::Deferred; + virtual void RegisterDataSource(const RegisterDataSourceRequest&, DeferredRegisterDataSourceResponse) = 0; -std::vector TokenizeProducerSockets( - const char* producer_socket_names) { - return base::SplitString(producer_socket_names, ","); -} + using DeferredUnregisterDataSourceResponse = ::perfetto::ipc::Deferred; + virtual void UnregisterDataSource(const UnregisterDataSourceRequest&, DeferredUnregisterDataSourceResponse) = 0; -const char* GetConsumerSocket() { - const char* name = getenv("PERFETTO_CONSUMER_SOCK_NAME"); - if (name == nullptr) { -#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) - name = "127.0.0.1:32279"; -#elif PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) - name = "/dev/socket/traced_consumer"; -#else - // Use /run/perfetto if it exists. Then fallback to /tmp. - static const char* consumer_socket = - UseRunPerfettoBaseDir() ? "/run/perfetto/traced-consumer.sock" - : "/tmp/perfetto-consumer"; - name = consumer_socket; -#endif - } - return name; -} + using DeferredCommitDataResponse = ::perfetto::ipc::Deferred; + virtual void CommitData(const CommitDataRequest&, DeferredCommitDataResponse) = 0; -} // namespace perfetto -// gen_amalgamated begin source: src/tracing/ipc/memfd.cc -// gen_amalgamated begin header: src/tracing/ipc/memfd.h -/* - * Copyright (C) 2020 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ + using DeferredGetAsyncCommandResponse = ::perfetto::ipc::Deferred; + virtual void GetAsyncCommand(const GetAsyncCommandRequest&, DeferredGetAsyncCommandResponse) = 0; -#ifndef SRC_TRACING_IPC_MEMFD_H_ -#define SRC_TRACING_IPC_MEMFD_H_ + using DeferredRegisterTraceWriterResponse = ::perfetto::ipc::Deferred; + virtual void RegisterTraceWriter(const RegisterTraceWriterRequest&, DeferredRegisterTraceWriterResponse) = 0; -// gen_amalgamated expanded: #include "perfetto/base/build_config.h" + using DeferredUnregisterTraceWriterResponse = ::perfetto::ipc::Deferred; + virtual void UnregisterTraceWriter(const UnregisterTraceWriterRequest&, DeferredUnregisterTraceWriterResponse) = 0; -// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h" + using DeferredNotifyDataSourceStartedResponse = ::perfetto::ipc::Deferred; + virtual void NotifyDataSourceStarted(const NotifyDataSourceStartedRequest&, DeferredNotifyDataSourceStartedResponse) = 0; -// Some android build bots use a sysroot that doesn't support memfd when -// compiling for the host, so we define the flags we need ourselves. + using DeferredNotifyDataSourceStoppedResponse = ::perfetto::ipc::Deferred; + virtual void NotifyDataSourceStopped(const NotifyDataSourceStoppedRequest&, DeferredNotifyDataSourceStoppedResponse) = 0; -// from memfd.h -#ifndef MFD_CLOEXEC -#define MFD_CLOEXEC 0x0001U -#define MFD_ALLOW_SEALING 0x0002U -#endif + using DeferredActivateTriggersResponse = ::perfetto::ipc::Deferred; + virtual void ActivateTriggers(const ActivateTriggersRequest&, DeferredActivateTriggersResponse) = 0; -// from fcntl.h -#ifndef F_ADD_SEALS -#define F_ADD_SEALS 1033 -#define F_GET_SEALS 1034 -#define F_SEAL_SEAL 0x0001 -#define F_SEAL_SHRINK 0x0002 -#define F_SEAL_GROW 0x0004 -#define F_SEAL_WRITE 0x0008 -#endif + using DeferredSyncResponse = ::perfetto::ipc::Deferred; + virtual void Sync(const SyncRequest&, DeferredSyncResponse) = 0; -namespace perfetto { + using DeferredUpdateDataSourceResponse = ::perfetto::ipc::Deferred; + virtual void UpdateDataSource(const UpdateDataSourceRequest&, DeferredUpdateDataSourceResponse) = 0; -// Whether the operating system supports memfd. -bool HasMemfdSupport(); + using DeferredAttachV2RingBufferResponse = ::perfetto::ipc::Deferred; + virtual void AttachV2RingBuffer(const AttachV2RingBufferRequest&, DeferredAttachV2RingBufferResponse) = 0; -// Call memfd(2) if available on platform and return the fd as result. This call -// also makes a kernel version check for safety on older kernels (b/116769556). -// Returns an invalid ScopedFile on failure. -base::ScopedFile CreateMemfd(const char* name, unsigned int flags); + using DeferredDrainV2RingBufferResponse = ::perfetto::ipc::Deferred; + virtual void DrainV2RingBuffer(const DrainV2RingBufferRequest&, DeferredDrainV2RingBufferResponse) = 0; -} // namespace perfetto +}; -#endif // SRC_TRACING_IPC_MEMFD_H_ -/* - * Copyright (C) 2020 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -// gen_amalgamated expanded: #include "src/tracing/ipc/memfd.h" +class ProducerPortProxy : public ::perfetto::ipc::ServiceProxy { + public: + explicit ProducerPortProxy(::perfetto::ipc::ServiceProxy::EventListener*); + ~ProducerPortProxy() override; -#include + // ServiceProxy implementation. + const ::perfetto::ipc::ServiceDescriptor& GetDescriptor() override; -#define PERFETTO_MEMFD_ENABLED() \ - PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) + // Methods from the .proto file + using DeferredInitializeConnectionResponse = ::perfetto::ipc::Deferred; + void InitializeConnection(const InitializeConnectionRequest&, DeferredInitializeConnectionResponse, int fd = -1); -#if PERFETTO_MEMFD_ENABLED() + using DeferredRegisterDataSourceResponse = ::perfetto::ipc::Deferred; + void RegisterDataSource(const RegisterDataSourceRequest&, DeferredRegisterDataSourceResponse, int fd = -1); -#include -#include -#include -#include -#include + using DeferredUnregisterDataSourceResponse = ::perfetto::ipc::Deferred; + void UnregisterDataSource(const UnregisterDataSourceRequest&, DeferredUnregisterDataSourceResponse, int fd = -1); -// Some android build bots use a sysroot that doesn't support memfd when -// compiling for the host, so we redefine it if necessary. -#if !defined(__NR_memfd_create) -#if defined(__x86_64__) -#define __NR_memfd_create 319 -#elif defined(__i386__) -#define __NR_memfd_create 356 -#elif defined(__aarch64__) -#define __NR_memfd_create 279 -#elif defined(__arm__) -#define __NR_memfd_create 385 -#else -#error "unsupported sysroot without memfd support" -#endif -#endif // !defined(__NR_memfd_create) + using DeferredCommitDataResponse = ::perfetto::ipc::Deferred; + void CommitData(const CommitDataRequest&, DeferredCommitDataResponse, int fd = -1); -namespace perfetto { -bool HasMemfdSupport() { - static bool kSupportsMemfd = [] { - // Check kernel version supports memfd_create(). Some older kernels segfault - // executing memfd_create() rather than returning ENOSYS (b/116769556). - static constexpr int kRequiredMajor = 3; - static constexpr int kRequiredMinor = 17; - struct utsname uts; - int major, minor; - if (uname(&uts) == 0 && strcmp(uts.sysname, "Linux") == 0 && - sscanf(uts.release, "%d.%d", &major, &minor) == 2 && - ((major < kRequiredMajor || - (major == kRequiredMajor && minor < kRequiredMinor)))) { - return false; - } + using DeferredGetAsyncCommandResponse = ::perfetto::ipc::Deferred; + void GetAsyncCommand(const GetAsyncCommandRequest&, DeferredGetAsyncCommandResponse, int fd = -1); - base::ScopedFile fd; - fd.reset(static_cast(syscall(__NR_memfd_create, "perfetto_shmem", - MFD_CLOEXEC | MFD_ALLOW_SEALING))); - return !!fd; - }(); - return kSupportsMemfd; -} + using DeferredRegisterTraceWriterResponse = ::perfetto::ipc::Deferred; + void RegisterTraceWriter(const RegisterTraceWriterRequest&, DeferredRegisterTraceWriterResponse, int fd = -1); -base::ScopedFile CreateMemfd(const char* name, unsigned int flags) { - if (!HasMemfdSupport()) { - errno = ENOSYS; - return base::ScopedFile(); - } - return base::ScopedFile( - static_cast(syscall(__NR_memfd_create, name, flags))); -} -} // namespace perfetto + using DeferredUnregisterTraceWriterResponse = ::perfetto::ipc::Deferred; + void UnregisterTraceWriter(const UnregisterTraceWriterRequest&, DeferredUnregisterTraceWriterResponse, int fd = -1); -#else // PERFETTO_MEMFD_ENABLED() + using DeferredNotifyDataSourceStartedResponse = ::perfetto::ipc::Deferred; + void NotifyDataSourceStarted(const NotifyDataSourceStartedRequest&, DeferredNotifyDataSourceStartedResponse, int fd = -1); -namespace perfetto { -bool HasMemfdSupport() { - return false; -} -base::ScopedFile CreateMemfd(const char*, unsigned int) { - errno = ENOSYS; - return base::ScopedFile(); -} -} // namespace perfetto + using DeferredNotifyDataSourceStoppedResponse = ::perfetto::ipc::Deferred; + void NotifyDataSourceStopped(const NotifyDataSourceStoppedRequest&, DeferredNotifyDataSourceStoppedResponse, int fd = -1); -#endif // PERFETTO_MEMFD_ENABLED() -// gen_amalgamated begin source: src/tracing/ipc/posix_shared_memory.cc -// gen_amalgamated begin header: src/tracing/ipc/posix_shared_memory.h -/* - * Copyright (C) 2017 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ + using DeferredActivateTriggersResponse = ::perfetto::ipc::Deferred; + void ActivateTriggers(const ActivateTriggersRequest&, DeferredActivateTriggersResponse, int fd = -1); -#ifndef SRC_TRACING_IPC_POSIX_SHARED_MEMORY_H_ -#define SRC_TRACING_IPC_POSIX_SHARED_MEMORY_H_ + using DeferredSyncResponse = ::perfetto::ipc::Deferred; + void Sync(const SyncRequest&, DeferredSyncResponse, int fd = -1); -// gen_amalgamated expanded: #include "perfetto/base/build_config.h" + using DeferredUpdateDataSourceResponse = ::perfetto::ipc::Deferred; + void UpdateDataSource(const UpdateDataSourceRequest&, DeferredUpdateDataSourceResponse, int fd = -1); -#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_WASM) + using DeferredAttachV2RingBufferResponse = ::perfetto::ipc::Deferred; + void AttachV2RingBuffer(const AttachV2RingBufferRequest&, DeferredAttachV2RingBufferResponse, int fd = -1); -#include + using DeferredDrainV2RingBufferResponse = ::perfetto::ipc::Deferred; + void DrainV2RingBuffer(const DrainV2RingBufferRequest&, DeferredDrainV2RingBufferResponse, int fd = -1); -#include +}; -// gen_amalgamated expanded: #include "perfetto/base/build_config.h" -// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h" -// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h" +} // namespace perfetto +} // namespace protos +} // namespace gen -namespace perfetto { +#endif // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_PRODUCER_PORT_PROTO_H_ +// DO NOT EDIT. Autogenerated by Perfetto IPC +// gen_amalgamated expanded: #include "protos/perfetto/ipc/producer_port.ipc.h" +// gen_amalgamated expanded: #include "perfetto/ext/ipc/codegen_helpers.h" -// Implements the SharedMemory and its factory for the posix-based transport. -class PosixSharedMemory : public SharedMemory { - public: - class Factory : public SharedMemory::Factory { - public: - ~Factory() override; - std::unique_ptr CreateSharedMemory(size_t) override; - }; +#include - // Create a brand new SHM region. - static std::unique_ptr Create(size_t size); +namespace perfetto { +namespace protos { +namespace gen { +::perfetto::ipc::ServiceDescriptor* ProducerPort::NewDescriptor() { + auto* desc = new ::perfetto::ipc::ServiceDescriptor(); + desc->service_name = "ProducerPort"; - // Mmaps a file descriptor to an existing SHM region. If - // |require_seals_if_supported| is true and the system supports - // memfd_create(), the FD is required to be a sealed memfd with F_SEAL_SEAL, - // F_SEAL_GROW, and F_SEAL_SHRINK seals set (otherwise, nullptr is returned). - // May also return nullptr if mapping fails for another reason (e.g. OOM). - static std::unique_ptr AttachToFd( - base::ScopedFile, - bool require_seals_if_supported = true); + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "InitializeConnection", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); - ~PosixSharedMemory() override; + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "RegisterDataSource", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); - int fd() const { return fd_.get(); } + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "UnregisterDataSource", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); - // SharedMemory implementation. - using SharedMemory::start; // Equal priority to const and non-const versions - const void* start() const override { return start_; } - size_t size() const override { return size_; } + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "CommitData", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); - private: - static std::unique_ptr MapFD(base::ScopedFile, size_t); + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "GetAsyncCommand", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); - PosixSharedMemory(void* start, size_t size, base::ScopedFile); - PosixSharedMemory(const PosixSharedMemory&) = delete; - PosixSharedMemory& operator=(const PosixSharedMemory&) = delete; + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "RegisterTraceWriter", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); - void* const start_; - const size_t size_; - base::ScopedFile fd_; -}; + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "UnregisterTraceWriter", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); -} // namespace perfetto + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "NotifyDataSourceStarted", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); -#endif // OS_LINUX || OS_ANDROID || OS_APPLE -#endif // SRC_TRACING_IPC_POSIX_SHARED_MEMORY_H_ -/* - * Copyright (C) 2017 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "NotifyDataSourceStopped", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); -// gen_amalgamated expanded: #include "src/tracing/ipc/posix_shared_memory.h" + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "ActivateTriggers", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); -#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \ - PERFETTO_BUILDFLAG(PERFETTO_OS_WASM) + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "Sync", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); -#include -#include -#include -#include -#include -#include -#include + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "UpdateDataSource", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); -#include -#include + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "AttachV2RingBuffer", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); -// gen_amalgamated expanded: #include "perfetto/base/compiler.h" -// gen_amalgamated expanded: #include "perfetto/base/logging.h" -// gen_amalgamated expanded: #include "perfetto/ext/base/temp_file.h" -// gen_amalgamated expanded: #include "src/tracing/ipc/memfd.h" + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "DrainV2RingBuffer", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); + desc->methods.shrink_to_fit(); + return desc; +} -namespace perfetto { -namespace { -int kFileSeals = F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_SEAL; -} // namespace +const ::perfetto::ipc::ServiceDescriptor& ProducerPort::GetDescriptorStatic() { + static auto* instance = NewDescriptor(); + return *instance; +} -// static -std::unique_ptr PosixSharedMemory::Create(size_t size) { - base::ScopedFile fd = - CreateMemfd("perfetto_shmem", MFD_CLOEXEC | MFD_ALLOW_SEALING); - bool is_memfd = !!fd; +// Host-side definitions. +ProducerPort::~ProducerPort() = default; - // In-tree builds only allow mem_fd, so we can inspect the seals to verify the - // fd is appropriately sealed. We'll crash in the PERFETTO_CHECK(fd) below if - // memfd_create failed. -#if !PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD) - if (!fd) { - // TODO: if this fails on Android we should fall back on ashmem. - PERFETTO_DPLOG("memfd_create() failed"); - fd = base::TempFile::CreateUnlinked().ReleaseFD(); - } -#endif +const ::perfetto::ipc::ServiceDescriptor& ProducerPort::GetDescriptor() { + return GetDescriptorStatic(); +} - PERFETTO_CHECK(fd); - int res = ftruncate(fd.get(), static_cast(size)); - PERFETTO_CHECK(res == 0); +// Client-side definitions. +ProducerPortProxy::ProducerPortProxy(::perfetto::ipc::ServiceProxy::EventListener* event_listener) + : ::perfetto::ipc::ServiceProxy(event_listener) {} - if (is_memfd) { - // When memfd is supported, file seals should be, too. - res = fcntl(*fd, F_ADD_SEALS, kFileSeals); - PERFETTO_DCHECK(res == 0); - } +ProducerPortProxy::~ProducerPortProxy() = default; - return MapFD(std::move(fd), size); +const ::perfetto::ipc::ServiceDescriptor& ProducerPortProxy::GetDescriptor() { + return ProducerPort::GetDescriptorStatic(); } -// static -std::unique_ptr PosixSharedMemory::AttachToFd( - base::ScopedFile fd, - bool require_seals_if_supported) { - bool requires_seals = require_seals_if_supported; +void ProducerPortProxy::InitializeConnection(const InitializeConnectionRequest& request, DeferredInitializeConnectionResponse reply, int fd) { + BeginInvoke("InitializeConnection", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); +} -#if PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD) - // In-tree kernels all support memfd. - PERFETTO_CHECK(HasMemfdSupport()); -#else - // In out-of-tree builds, we only require seals if the kernel supports memfd. - if (requires_seals) - requires_seals = HasMemfdSupport(); -#endif +void ProducerPortProxy::RegisterDataSource(const RegisterDataSourceRequest& request, DeferredRegisterDataSourceResponse reply, int fd) { + BeginInvoke("RegisterDataSource", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); +} - if (requires_seals) { - // If the system supports memfd, we require a sealed memfd. - int res = fcntl(*fd, F_GET_SEALS); - if (res == -1 || (res & kFileSeals) != kFileSeals) { - PERFETTO_PLOG("Couldn't verify file seals on shmem FD"); - return nullptr; - } - } +void ProducerPortProxy::UnregisterDataSource(const UnregisterDataSourceRequest& request, DeferredUnregisterDataSourceResponse reply, int fd) { + BeginInvoke("UnregisterDataSource", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); +} - struct stat stat_buf = {}; - int res = fstat(fd.get(), &stat_buf); - PERFETTO_CHECK(res == 0 && stat_buf.st_size > 0); - return MapFD(std::move(fd), static_cast(stat_buf.st_size)); +void ProducerPortProxy::CommitData(const CommitDataRequest& request, DeferredCommitDataResponse reply, int fd) { + BeginInvoke("CommitData", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); } -// static -std::unique_ptr PosixSharedMemory::MapFD(base::ScopedFile fd, - size_t size) { - PERFETTO_DCHECK(fd); - PERFETTO_DCHECK(size > 0); - void* start = - mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd.get(), 0); - PERFETTO_CHECK(start != MAP_FAILED); - return std::unique_ptr( - new PosixSharedMemory(start, size, std::move(fd))); +void ProducerPortProxy::GetAsyncCommand(const GetAsyncCommandRequest& request, DeferredGetAsyncCommandResponse reply, int fd) { + BeginInvoke("GetAsyncCommand", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); } -PosixSharedMemory::PosixSharedMemory(void* start, - size_t size, - base::ScopedFile fd) - : start_(start), size_(size), fd_(std::move(fd)) {} +void ProducerPortProxy::RegisterTraceWriter(const RegisterTraceWriterRequest& request, DeferredRegisterTraceWriterResponse reply, int fd) { + BeginInvoke("RegisterTraceWriter", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); +} -PosixSharedMemory::~PosixSharedMemory() { - munmap(start(), size()); +void ProducerPortProxy::UnregisterTraceWriter(const UnregisterTraceWriterRequest& request, DeferredUnregisterTraceWriterResponse reply, int fd) { + BeginInvoke("UnregisterTraceWriter", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); } -PosixSharedMemory::Factory::~Factory() {} +void ProducerPortProxy::NotifyDataSourceStarted(const NotifyDataSourceStartedRequest& request, DeferredNotifyDataSourceStartedResponse reply, int fd) { + BeginInvoke("NotifyDataSourceStarted", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); +} -std::unique_ptr PosixSharedMemory::Factory::CreateSharedMemory( - size_t size) { - return PosixSharedMemory::Create(size); +void ProducerPortProxy::NotifyDataSourceStopped(const NotifyDataSourceStoppedRequest& request, DeferredNotifyDataSourceStoppedResponse reply, int fd) { + BeginInvoke("NotifyDataSourceStopped", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); } -} // namespace perfetto +void ProducerPortProxy::ActivateTriggers(const ActivateTriggersRequest& request, DeferredActivateTriggersResponse reply, int fd) { + BeginInvoke("ActivateTriggers", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); +} -#endif // OS_LINUX || OS_ANDROID || OS_APPLE -// gen_amalgamated begin source: src/tracing/ipc/shared_memory_windows.cc -// gen_amalgamated begin header: src/tracing/ipc/shared_memory_windows.h -/* - * Copyright (C) 2021 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ +void ProducerPortProxy::Sync(const SyncRequest& request, DeferredSyncResponse reply, int fd) { + BeginInvoke("Sync", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); +} -#ifndef SRC_TRACING_IPC_SHARED_MEMORY_WINDOWS_H_ -#define SRC_TRACING_IPC_SHARED_MEMORY_WINDOWS_H_ +void ProducerPortProxy::UpdateDataSource(const UpdateDataSourceRequest& request, DeferredUpdateDataSourceResponse reply, int fd) { + BeginInvoke("UpdateDataSource", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); +} -// gen_amalgamated expanded: #include "perfetto/base/build_config.h" +void ProducerPortProxy::AttachV2RingBuffer(const AttachV2RingBufferRequest& request, DeferredAttachV2RingBufferResponse reply, int fd) { + BeginInvoke("AttachV2RingBuffer", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); +} -#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +void ProducerPortProxy::DrainV2RingBuffer(const DrainV2RingBufferRequest& request, DeferredDrainV2RingBufferResponse reply, int fd) { + BeginInvoke("DrainV2RingBuffer", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); +} +} // namespace perfetto +} // namespace protos +} // namespace gen +// gen_amalgamated begin source: gen/protos/perfetto/ipc/relay_port.ipc.cc +// gen_amalgamated begin header: gen/protos/perfetto/ipc/relay_port.ipc.h +// DO NOT EDIT. Autogenerated by Perfetto IPC +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_RELAY_PORT_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_RELAY_PORT_PROTO_H_ -#include +// gen_amalgamated expanded: #include "perfetto/ext/ipc/deferred.h" +// gen_amalgamated expanded: #include "perfetto/ext/ipc/service.h" +// gen_amalgamated expanded: #include "perfetto/ext/ipc/service_descriptor.h" +// gen_amalgamated expanded: #include "perfetto/ext/ipc/service_proxy.h" -// gen_amalgamated expanded: #include "perfetto/base/build_config.h" -// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h" -// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h" +// gen_amalgamated expanded: #include "protos/perfetto/ipc/relay_port.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/common/system_info.gen.h" namespace perfetto { +namespace protos { +namespace gen { + +class RelayPort : public ::perfetto::ipc::Service { + private: + static ::perfetto::ipc::ServiceDescriptor* NewDescriptor(); -// Implements the SharedMemory and its factory for the Windows IPC transport. -// This used only for standalone builds and NOT in chromium, which instead uses -// a custom Mojo wrapper (MojoSharedMemory in chromium's //services/tracing/). -class SharedMemoryWindows : public SharedMemory { public: - class Factory : public SharedMemory::Factory { - public: - ~Factory() override; - std::unique_ptr CreateSharedMemory(size_t) override; - }; + ~RelayPort() override; - // Create a brand new SHM region. - enum Flags { kNone = 0, kInheritableHandles }; - static std::unique_ptr Create( - size_t size, - Flags flags = Flags::kNone); - static std::unique_ptr Attach(const std::string& key); - static std::unique_ptr AttachToHandleWithKey( - base::ScopedPlatformHandle fd, - const std::string& key); - ~SharedMemoryWindows() override; - const std::string& key() const { return key_; } - const base::ScopedPlatformHandle& handle() const { return handle_; } + static const ::perfetto::ipc::ServiceDescriptor& GetDescriptorStatic(); - // SharedMemory implementation. - using SharedMemory::start; // Equal priority to const and non-const versions - const void* start() const override { return start_; } - size_t size() const override { return size_; } + // Service implementation. + const ::perfetto::ipc::ServiceDescriptor& GetDescriptor() override; - private: - SharedMemoryWindows(void* start, - size_t size, - std::string, - base::ScopedPlatformHandle); - SharedMemoryWindows(const SharedMemoryWindows&) = delete; - SharedMemoryWindows& operator=(const SharedMemoryWindows&) = delete; + // Methods from the .proto file + using DeferredInitRelayResponse = ::perfetto::ipc::Deferred; + virtual void InitRelay(const InitRelayRequest&, DeferredInitRelayResponse) = 0; + + using DeferredSyncClockResponse = ::perfetto::ipc::Deferred; + virtual void SyncClock(const SyncClockRequest&, DeferredSyncClockResponse) = 0; - void* const start_; - const size_t size_; - std::string key_; - base::ScopedPlatformHandle handle_; }; -} // namespace perfetto -#endif // OS_WIN +class RelayPortProxy : public ::perfetto::ipc::ServiceProxy { + public: + explicit RelayPortProxy(::perfetto::ipc::ServiceProxy::EventListener*); + ~RelayPortProxy() override; -#endif // SRC_TRACING_IPC_SHARED_MEMORY_WINDOWS_H_ -/* - * Copyright (C) 2021 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ + // ServiceProxy implementation. + const ::perfetto::ipc::ServiceDescriptor& GetDescriptor() override; -// gen_amalgamated expanded: #include "src/tracing/ipc/shared_memory_windows.h" + // Methods from the .proto file + using DeferredInitRelayResponse = ::perfetto::ipc::Deferred; + void InitRelay(const InitRelayRequest&, DeferredInitRelayResponse, int fd = -1); -#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + using DeferredSyncClockResponse = ::perfetto::ipc::Deferred; + void SyncClock(const SyncClockRequest&, DeferredSyncClockResponse, int fd = -1); -#include -#include +}; -#include +} // namespace perfetto +} // namespace protos +} // namespace gen -// gen_amalgamated expanded: #include "perfetto/base/logging.h" -// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h" +#endif // PERFETTO_PROTOS_PROTOS_PERFETTO_IPC_RELAY_PORT_PROTO_H_ +// DO NOT EDIT. Autogenerated by Perfetto IPC +// gen_amalgamated expanded: #include "protos/perfetto/ipc/relay_port.ipc.h" +// gen_amalgamated expanded: #include "perfetto/ext/ipc/codegen_helpers.h" -namespace perfetto { +#include -// static -std::unique_ptr SharedMemoryWindows::Create(size_t size, - Flags flags) { - base::ScopedPlatformHandle shmem_handle; - std::random_device rnd_dev; - uint64_t rnd_key = (static_cast(rnd_dev()) << 32) | rnd_dev(); - std::string key = "perfetto_shm_" + base::Uint64ToHexStringNoPrefix(rnd_key); +namespace perfetto { +namespace protos { +namespace gen { +::perfetto::ipc::ServiceDescriptor* RelayPort::NewDescriptor() { + auto* desc = new ::perfetto::ipc::ServiceDescriptor(); + desc->service_name = "RelayPort"; - SECURITY_ATTRIBUTES security_attributes = {}; - security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES); - if (flags & Flags::kInheritableHandles) - security_attributes.bInheritHandle = TRUE; + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "InitRelay", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); - shmem_handle.reset(CreateFileMappingA( - INVALID_HANDLE_VALUE, // Use paging file. - &security_attributes, PAGE_READWRITE, - static_cast(size >> 32), // maximum object size (high-order DWORD) - static_cast(size), // maximum object size (low-order DWORD) - key.c_str())); + desc->methods.emplace_back(::perfetto::ipc::ServiceDescriptor::Method{ + "SyncClock", + &_IPC_Decoder, + &_IPC_Decoder, + &_IPC_Invoker}); + desc->methods.shrink_to_fit(); + return desc; +} - if (!shmem_handle) { - PERFETTO_PLOG("CreateFileMapping() call failed"); - return nullptr; - } - void* start = - MapViewOfFile(*shmem_handle, FILE_MAP_ALL_ACCESS, /*offsetHigh=*/0, - /*offsetLow=*/0, size); - if (!start) { - PERFETTO_PLOG("MapViewOfFile() failed"); - return nullptr; - } - return std::unique_ptr(new SharedMemoryWindows( - start, size, std::move(key), std::move(shmem_handle))); +const ::perfetto::ipc::ServiceDescriptor& RelayPort::GetDescriptorStatic() { + static auto* instance = NewDescriptor(); + return *instance; } -// static -std::unique_ptr SharedMemoryWindows::Attach( - const std::string& key) { - base::ScopedPlatformHandle shmem_handle; - shmem_handle.reset( - OpenFileMappingA(FILE_MAP_ALL_ACCESS, /*inherit=*/false, key.c_str())); - if (!shmem_handle) { - PERFETTO_PLOG("Failed to OpenFileMapping()"); - return nullptr; - } - - void* start = - MapViewOfFile(*shmem_handle, FILE_MAP_ALL_ACCESS, /*offsetHigh=*/0, - /*offsetLow=*/0, /*dwNumberOfBytesToMap=*/0); - if (!start) { - PERFETTO_PLOG("MapViewOfFile() failed"); - return nullptr; - } +// Host-side definitions. +RelayPort::~RelayPort() = default; - MEMORY_BASIC_INFORMATION info{}; - if (!VirtualQuery(start, &info, sizeof(info))) { - PERFETTO_PLOG("VirtualQuery() failed"); - return nullptr; - } - size_t size = info.RegionSize; - return std::unique_ptr( - new SharedMemoryWindows(start, size, key, std::move(shmem_handle))); +const ::perfetto::ipc::ServiceDescriptor& RelayPort::GetDescriptor() { + return GetDescriptorStatic(); } -// static -std::unique_ptr SharedMemoryWindows::AttachToHandleWithKey( - base::ScopedPlatformHandle shmem_handle, - const std::string& key) { - void* start = - MapViewOfFile(*shmem_handle, FILE_MAP_ALL_ACCESS, /*offsetHigh=*/0, - /*offsetLow=*/0, /*dwNumberOfBytesToMap=*/0); - if (!start) { - PERFETTO_PLOG("MapViewOfFile() failed"); - return nullptr; - } +// Client-side definitions. +RelayPortProxy::RelayPortProxy(::perfetto::ipc::ServiceProxy::EventListener* event_listener) + : ::perfetto::ipc::ServiceProxy(event_listener) {} - MEMORY_BASIC_INFORMATION info{}; - if (!VirtualQuery(start, &info, sizeof(info))) { - PERFETTO_PLOG("VirtualQuery() failed"); - return nullptr; - } - size_t size = info.RegionSize; +RelayPortProxy::~RelayPortProxy() = default; - return std::unique_ptr( - new SharedMemoryWindows(start, size, key, std::move(shmem_handle))); +const ::perfetto::ipc::ServiceDescriptor& RelayPortProxy::GetDescriptor() { + return RelayPort::GetDescriptorStatic(); } -SharedMemoryWindows::SharedMemoryWindows(void* start, - size_t size, - std::string key, - base::ScopedPlatformHandle handle) - : start_(start), - size_(size), - key_(std::move(key)), - handle_(std::move(handle)) {} - -SharedMemoryWindows::~SharedMemoryWindows() { - if (start_) - UnmapViewOfFile(start_); +void RelayPortProxy::InitRelay(const InitRelayRequest& request, DeferredInitRelayResponse reply, int fd) { + BeginInvoke("InitRelay", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); } -SharedMemoryWindows::Factory::~Factory() = default; - -std::unique_ptr SharedMemoryWindows::Factory::CreateSharedMemory( - size_t size) { - return SharedMemoryWindows::Create(size); +void RelayPortProxy::SyncClock(const SyncClockRequest& request, DeferredSyncClockResponse reply, int fd) { + BeginInvoke("SyncClock", request, ::perfetto::ipc::DeferredBase(std::move(reply)), + fd); } - } // namespace perfetto - -#endif // !OS_WIN +} // namespace protos +} // namespace gen // gen_amalgamated begin source: src/tracing/ipc/consumer/consumer_ipc_client_impl.cc // gen_amalgamated begin header: src/tracing/ipc/consumer/consumer_ipc_client_impl.h // gen_amalgamated begin header: include/perfetto/ext/tracing/ipc/consumer_ipc_client.h @@ -83711,6 +92304,8 @@ class PERFETTO_EXPORT_COMPONENT ProducerIPCClient { #include +#include +#include #include #include @@ -83722,6 +92317,7 @@ class PERFETTO_EXPORT_COMPONENT ProducerIPCClient { // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/ipc/producer_ipc_client.h" +// gen_amalgamated expanded: #include "src/tracing/v2/producer_ring_buffer_arbiter.h" // gen_amalgamated expanded: #include "protos/perfetto/ipc/producer_port.ipc.h" @@ -83731,6 +92327,10 @@ namespace base { class TaskRunner; } // namespace base +namespace test { +class ProducerIPCClientTestPeer; +} // namespace test + class Producer; class SharedMemoryArbiter; @@ -83740,6 +92340,10 @@ class SharedMemoryArbiter; // actual IPC transport. // If create_socket_async is set, it will be called to create and connect to a // socket to the service. If unset, the producer will create and connect itself. +// +// TODO(sashwinbalaji): Check all paths through Disconnect(), OnDisconnect(), +// and ScheduleDisconnect() again. Check for unnecessary steps, incorrect +// cleanup or callback order, and object lifetime errors. class ProducerIPCClientImpl : public TracingService::ProducerEndpoint, public ipc::ServiceProxy::EventListener { public: @@ -83769,10 +92373,18 @@ class ProducerIPCClientImpl : public TracingService::ProducerEndpoint, void NotifyDataSourceStopped(DataSourceInstanceID) override; void ActivateTriggers(const std::vector&) override; void Sync(std::function callback) override; + void InitializeV2RingBuffer(const DataSourceConfig&) override; + void AttachV2RingBuffer(const std::shared_ptr&, + uint32_t chunk_size_bytes, + std::function callback) override; + void DrainV2RingBuffer() override; std::unique_ptr CreateTraceWriter( BufferID target_buffer, BufferExhaustedPolicy) override; + std::unique_ptr CreateTraceWriterV2( + BufferID, + BufferExhaustedPolicy) override; SharedMemoryArbiter* MaybeSharedMemoryArbiter() override; bool IsShmemProvidedByProducer() const override; void NotifyFlushComplete(FlushRequestID) override; @@ -83788,15 +92400,22 @@ class ProducerIPCClientImpl : public TracingService::ProducerEndpoint, ipc::Client* GetClientForTesting() { return ipc_channel_.get(); } private: + // Defined in tracing_integration_test.cc. + friend class test::ProducerIPCClientTestPeer; + // Drops the provider connection if a protocol error was detected while // processing an IPC command. void ScheduleDisconnect(); // Invoked soon after having established the connection with the service. - void OnConnectionInitialized(bool connection_succeeded, - bool using_shmem_provided_by_producer, - bool direct_smb_patching_supported, - bool use_shmem_emulation); + // |offered_versions| is the bitmask sent in the request. + void OnConnectionInitialized( + uint32_t offered_versions, + ipc::AsyncResult response); + + bool HasNegotiatedV2Abi() const { + return !!(protocol_abi_versions_ & kProtocolAbiV2); + } // Invoked when the remote Service sends an IPC to tell us to do something // (e.g. start/stop a data source). @@ -83824,6 +92443,8 @@ class ProducerIPCClientImpl : public TracingService::ProducerEndpoint, std::map writers_for_scraping_; std::unique_ptr shared_memory_; + // Bitmask of the versions agreed in InitializeConnection, zero until then. + uint32_t protocol_abi_versions_ = 0; std::unique_ptr shared_memory_arbiter_; size_t shared_buffer_page_size_kb_ = 0; std::set data_sources_setup_; @@ -83836,6 +92457,23 @@ class ProducerIPCClientImpl : public TracingService::ProducerEndpoint, bool direct_smb_patching_supported_ = false; bool use_shmem_emulation_ = false; std::vector> pending_sync_reqs_; + // Owns the ring buffer and creates v2 writers. + // + // States: + // - nullopt: initialization has not been attempted. + // - nullptr: sizing or allocation failed. + // Later InitializeV2RingBuffer() calls on the same connection do not retry + // initialization, to avoid changing the pointer while v2 writer threads + // read it without a lock. + // - Non-null pointer: the arbiter exists and tracks service attachment. + // + // Set by InitializeV2RingBuffer() when an instance selects v2, before the + // first v2 writer. + // Writer threads then read it without a lock. + // OnDisconnect() does not reset this member because v2 writer threads can + // still read it or use the arbiter. + std::optional> + v2_ring_buffer_arbiter_; base::WeakPtrFactory weak_factory_{this}; PERFETTO_THREAD_CHECKER(thread_checker_) }; @@ -83865,8 +92503,11 @@ class ProducerIPCClientImpl : public TracingService::ProducerEndpoint, #include +// gen_amalgamated expanded: #include "perfetto/base/compiler.h" // gen_amalgamated expanded: #include "perfetto/base/logging.h" // gen_amalgamated expanded: #include "perfetto/base/task_runner.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/status_macros.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/status_or.h" // gen_amalgamated expanded: #include "perfetto/ext/base/unix_socket.h" // gen_amalgamated expanded: #include "perfetto/ext/base/version.h" // gen_amalgamated expanded: #include "perfetto/ext/ipc/client.h" @@ -83875,10 +92516,13 @@ class ProducerIPCClientImpl : public TracingService::ProducerEndpoint, // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_abi.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/shared_memory_arbiter.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_writer.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h" // gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h" // gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_descriptor.h" // gen_amalgamated expanded: #include "perfetto/tracing/core/trace_config.h" // gen_amalgamated expanded: #include "src/tracing/core/in_process_shared_memory.h" +// gen_amalgamated expanded: #include "src/tracing/core/null_trace_writer.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_abi.h" #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) // gen_amalgamated expanded: #include "src/tracing/ipc/shared_memory_windows.h" @@ -84000,14 +92644,19 @@ ProducerIPCClientImpl::~ProducerIPCClientImpl() { void ProducerIPCClientImpl::Disconnect() { PERFETTO_DCHECK_THREAD(thread_checker_); - if (!producer_port_) + // Disconnect() is complete when both the port and channel are gone. + // ScheduleDisconnect() drops only the port and leaves the channel open. + if (!producer_port_ && !ipc_channel_) return; - // Reset the producer port so that no further IPCs are received and IPC - // callbacks are no longer executed. Also reset the IPC channel so that the - // service is notified of the disconnection. + + // Clear |connected_| so callbacks invoked during port destruction see a + // disconnected endpoint. + connected_ = false; + // Reset |producer_port_| to stop further IPC replies, then close + // |ipc_channel_| so the service sees the disconnection. producer_port_.reset(); ipc_channel_.reset(); - // Perform disconnect synchronously. + // Perform disconnect synchronously. This may delete |this|. OnDisconnect(); } @@ -84016,19 +92665,22 @@ void ProducerIPCClientImpl::OnConnect() { PERFETTO_DCHECK_THREAD(thread_checker_); connected_ = true; - // The IPC layer guarantees that any outstanding callback will be dropped on - // the floor if producer_port_ is destroyed between the request and the reply. - // Binding |this| is hence safe. + uint32_t offered_versions = kProtocolAbiV1; + offered_versions |= tracing_v2::IpcSupportsTracingV2() ? kProtocolAbiV2 : 0u; + protos::gen::InitializeConnectionRequest req; + req.set_supported_protocol_abi_versions(offered_versions); + + // When this client is destroyed, the port calls pending callbacks with a + // failure result. By then, members used by OnConnectionInitialized() have + // already been destroyed. Use a weak pointer to skip the handler in that + // case. ipc::Deferred on_init; on_init.Bind( - [this](ipc::AsyncResult resp) { - OnConnectionInitialized( - resp.success(), - resp.success() ? resp->using_shmem_provided_by_producer() : false, - resp.success() ? resp->direct_smb_patching_supported() : false, - resp.success() ? resp->use_shmem_emulation() : false); + [weak_this = weak_factory_.GetWeakPtr(), offered_versions]( + ipc::AsyncResult resp) { + if (weak_this) + weak_this->OnConnectionInitialized(offered_versions, std::move(resp)); }); - protos::gen::InitializeConnectionRequest req; req.set_producer_name(name_); req.set_shared_memory_size_hint_bytes( static_cast(shared_memory_size_hint_bytes_)); @@ -84085,6 +92737,11 @@ void ProducerIPCClientImpl::OnDisconnect() { PERFETTO_DLOG("Tracing service connection failure"); connected_ = false; data_sources_setup_.clear(); + auto* arbiter = v2_ring_buffer_arbiter_.has_value() + ? v2_ring_buffer_arbiter_->get() + : nullptr; + if (arbiter) + arbiter->Disconnect(); producer_->OnDisconnect(); // Note: may delete |this|. } @@ -84092,8 +92749,10 @@ void ProducerIPCClientImpl::ScheduleDisconnect() { // |ipc_channel| doesn't allow disconnection in the middle of handling // an IPC call, so the connection drop must take place over two phases. - // First, synchronously drop the |producer_port_| so that no more IPC - // messages are handled. + // First, clear |connected_| so pending Sync() callbacks see a disconnected + // endpoint when the port is destroyed. Then synchronously drop + // |producer_port_| so that no more IPC messages are handled. + connected_ = false; producer_port_.reset(); // Then schedule an async task for performing the remainder of the @@ -84107,22 +92766,44 @@ void ProducerIPCClientImpl::ScheduleDisconnect() { } void ProducerIPCClientImpl::OnConnectionInitialized( - bool connection_succeeded, - bool using_shmem_provided_by_producer, - bool direct_smb_patching_supported, - bool use_shmem_emulation) { + uint32_t offered_versions, + ipc::AsyncResult response) { PERFETTO_DCHECK_THREAD(thread_checker_); - // If connection_succeeded == false, the OnDisconnect() call will follow next - // and there we'll notify the |producer_|. TODO: add a test for this. - if (!connection_succeeded) + // The IPC proxy accesses this callback after it returns, so keep the port + // alive until the next task. + auto reject_connection = [this] { + task_runner_->PostTask([weak_this = weak_factory_.GetWeakPtr()] { + if (weak_this && weak_this->connected_) + weak_this->Disconnect(); + }); + }; + + if (!response.success()) { + reject_connection(); + return; + } + + // An old service sends no versions. This means v1 only. + uint32_t versions = response->protocol_abi_versions(); + if (!versions) + versions = kProtocolAbiV1; + + // The service returns only versions that the producer offered. Log both + // masks if it does not. + if (versions & ~offered_versions) { + PERFETTO_ELOG("Unexpected protocol versions (advertised: %x, service: %x)", + offered_versions, versions); + reject_connection(); return; - is_shmem_provided_by_producer_ = using_shmem_provided_by_producer; - direct_smb_patching_supported_ = direct_smb_patching_supported; + } + protocol_abi_versions_ = versions; + is_shmem_provided_by_producer_ = response->using_shmem_provided_by_producer(); + direct_smb_patching_supported_ = response->direct_smb_patching_supported(); // The tracing service may reject using shared memory and tell the client to // commit data over the socket. This can happen when the client connects to // the service via a relay service: // client <-Unix socket-> relay service <- vsock -> tracing service. - use_shmem_emulation_ = use_shmem_emulation; + use_shmem_emulation_ = response->use_shmem_emulation(); producer_->OnConnect(); // Bail out if the service failed to adopt our producer-allocated SMB. @@ -84179,27 +92860,17 @@ void ProducerIPCClientImpl::OnServiceRequest( // FD, which is provided to this code via a blocking callback. PERFETTO_CHECK(receive_shmem_fd_cb_fuchsia_); - base::ScopedFile shmem_fd(receive_shmem_fd_cb_fuchsia_()); - if (!shmem_fd) { - // Failure to get a shared memory buffer is a protocol violation and - // therefore we should drop the Protocol connection. - PERFETTO_ELOG("Could not get shared memory FD from embedder."); - ScheduleDisconnect(); - return; - } - - ipc_shared_memory = - PosixSharedMemory::AttachToFd(std::move(shmem_fd), - /*require_seals_if_supported=*/false); + ipc_shared_memory = PosixSharedMemory::AttachToFd( + base::ScopedFile(receive_shmem_fd_cb_fuchsia_()), + /*require_seals_if_supported=*/false, TracingService::kMaxShmSize); #else - base::ScopedFile shmem_fd = ipc_channel_->TakeReceivedFD(); - if (shmem_fd) { - // TODO(primiano): handle mmap failure in case of OOM. - ipc_shared_memory = - PosixSharedMemory::AttachToFd(std::move(shmem_fd), - /*require_seals_if_supported=*/false); - } + // The FD can be invalid, for example with a producer-provided SMB. + // |ipc_shared_memory| is then null. The checks below handle it. + ipc_shared_memory = PosixSharedMemory::AttachToFd( + ipc_channel_->TakeReceivedFD(), + /*require_seals_if_supported=*/false, TracingService::kMaxShmSize); #endif + if (use_shmem_emulation_) { PERFETTO_CHECK(!ipc_shared_memory); // Need to create an emulated shmem buffer when the transport doesn't @@ -84207,6 +92878,16 @@ void ProducerIPCClientImpl::OnServiceRequest( ipc_shared_memory = InProcessSharedMemory::Create( /*size=*/InProcessSharedMemory::kShmemEmulationSize); } + + // No SMB from the service (none sent, or it failed to map), and none + // provided by the producer. The producer cannot trace without one. + // Drop the connection: the producer gets OnDisconnect() and can reconnect. + if (!ipc_shared_memory && !is_shmem_provided_by_producer_) { + PERFETTO_ELOG("No usable shared memory from the service, disconnecting."); + ScheduleDisconnect(); + return; + } + if (ipc_shared_memory) { auto shmem_mode = use_shmem_emulation_ ? SharedMemoryABI::ShmemMode::kShmemEmulation @@ -84268,6 +92949,7 @@ void ProducerIPCClientImpl::RegisterDataSource( if (!connected_) { PERFETTO_DLOG( "Cannot RegisterDataSource(), not connected to tracing service"); + return; } protos::gen::RegisterDataSourceRequest req; *req.mutable_data_source_descriptor() = descriptor; @@ -84286,6 +92968,7 @@ void ProducerIPCClientImpl::UpdateDataSource( if (!connected_) { PERFETTO_DLOG( "Cannot UpdateDataSource(), not connected to tracing service"); + return; } protos::gen::UpdateDataSourceRequest req; *req.mutable_data_source_descriptor() = descriptor; @@ -84371,6 +93054,87 @@ void ProducerIPCClientImpl::CommitData(const CommitDataRequest& req, producer_port_->CommitData(req, std::move(async_response)); } +void ProducerIPCClientImpl::InitializeV2RingBuffer( + const DataSourceConfig& config) { + PERFETTO_DCHECK_THREAD(thread_checker_); + // V2 IPC requires a sealed memfd. + // TODO(sashwinbalaji): Decide how tracing v2 shares the ring buffer over IPC + // on Windows and macOS, which have no memfd. +#if PERFETTO_MEMFD_ENABLED() + if (v2_ring_buffer_arbiter_.has_value() || !connected_ || + !HasNegotiatedV2Abi()) { + return; + } + + auto arbiter_or = tracing_v2::ProducerRingBufferArbiter::Create( + task_runner_, this, config, shared_memory_size_hint_bytes_, + [](size_t size) -> base::StatusOr> { + ASSIGN_OR_RETURN(auto memory, PosixSharedMemory::Create(size)); + return std::shared_ptr(std::move(memory)); + }); + if (!arbiter_or.ok()) { + PERFETTO_ELOG("tracing v2: cannot create ring buffer: %s", + arbiter_or.status().c_message()); + v2_ring_buffer_arbiter_ = nullptr; + return; + } + v2_ring_buffer_arbiter_ = std::move(*arbiter_or); + + auto* arbiter = v2_ring_buffer_arbiter_->get(); + AttachV2RingBuffer( + arbiter->memory(), arbiter->ring_buffer()->chunk_size(), + [weak_arbiter = arbiter->GetWeakPtr()](bool reader_attached) { + if (weak_arbiter) + weak_arbiter->OnReaderAttachReply(reader_attached); + }); +#else + base::ignore_result(config); +#endif // PERFETTO_MEMFD_ENABLED() +} + +void ProducerIPCClientImpl::AttachV2RingBuffer( + const std::shared_ptr& memory, + uint32_t chunk_size_bytes, + std::function callback) { + PERFETTO_DCHECK_THREAD(thread_checker_); + + // OnConnect() offers v2 only if tracing_v2::IpcSupportsTracingV2(). + if (!connected_ || !HasNegotiatedV2Abi() || !memory) { + callback(false); + return; + } + +#if PERFETTO_TRACING_V2_IPC() + protos::gen::AttachV2RingBufferRequest req; + req.set_chunk_size_bytes(chunk_size_bytes); + ipc::Deferred reply; + reply.Bind( + [callback = std::move(callback)]( + ipc::AsyncResult result) { + callback(result.success()); + }); + // The IPC layer sends the descriptor before this call returns. The service + // maps it on its side. + // + // The producer that called this method owns |memory| and keeps it mapped for + // its writers. + const int fd = static_cast(memory.get())->fd(); + producer_port_->AttachV2RingBuffer(req, std::move(reply), fd); +#else + base::ignore_result(chunk_size_bytes); + callback(false); +#endif +} + +void ProducerIPCClientImpl::DrainV2RingBuffer() { + PERFETTO_DCHECK_THREAD(thread_checker_); + if (!connected_ || !HasNegotiatedV2Abi()) + return; + producer_port_->DrainV2RingBuffer( + protos::gen::DrainV2RingBufferRequest(), + ipc::Deferred()); +} + void ProducerIPCClientImpl::NotifyDataSourceStarted(DataSourceInstanceID id) { PERFETTO_DCHECK_THREAD(thread_checker_); if (!connected_) { @@ -84435,10 +93199,29 @@ std::unique_ptr ProducerIPCClientImpl::CreateTraceWriter( BufferExhaustedPolicy buffer_exhausted_policy) { // This method can be called by different threads. |shared_memory_arbiter_| is // thread-safe but be aware of accessing any other state in this function. + // |protocol_abi_versions_| does not change after setup. + if (!(protocol_abi_versions_ & kProtocolAbiV1)) { + PERFETTO_ELOG( + "Cannot create a v1 trace writer: v1 is not in the common protocol " + "mask (%x)", + protocol_abi_versions_); + return std::make_unique(); + } return shared_memory_arbiter_->CreateTraceWriter(target_buffer, buffer_exhausted_policy); } +std::unique_ptr ProducerIPCClientImpl::CreateTraceWriterV2( + BufferID target_buffer, + BufferExhaustedPolicy policy) { + auto* arbiter = v2_ring_buffer_arbiter_.has_value() + ? v2_ring_buffer_arbiter_->get() + : nullptr; + if (!arbiter) + return std::make_unique(); + return arbiter->CreateTraceWriter(target_buffer, policy); +} + SharedMemoryArbiter* ProducerIPCClientImpl::MaybeSharedMemoryArbiter() { return shared_memory_arbiter_.get(); } @@ -85253,6 +94036,10 @@ class ProducerIPCService : public protos::gen::ProducerPort { void GetAsyncCommand(const protos::gen::GetAsyncCommandRequest&, DeferredGetAsyncCommandResponse) override; void Sync(const protos::gen::SyncRequest&, DeferredSyncResponse) override; + void AttachV2RingBuffer(const protos::gen::AttachV2RingBufferRequest&, + DeferredAttachV2RingBufferResponse) override; + void DrainV2RingBuffer(const protos::gen::DrainV2RingBufferRequest&, + DeferredDrainV2RingBufferResponse) override; void OnClientDisconnected() override; private: @@ -85351,6 +94138,7 @@ class ProducerIPCService : public protos::gen::ProducerPort { // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/tracing_service.h" // gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_config.h" // gen_amalgamated expanded: #include "perfetto/tracing/core/data_source_descriptor.h" +// gen_amalgamated expanded: #include "src/tracing/v2/shared_ring_buffer_abi.h" #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) // gen_amalgamated expanded: #include "src/tracing/ipc/shared_memory_windows.h" @@ -85364,6 +94152,32 @@ class ProducerIPCService : public protos::gen::ProducerPort { namespace perfetto { +namespace { + +// The proto and C++ enums use the same bits. +static_assert(static_cast(protos::gen::PROTOCOL_ABI_VERSION_V1) == + kProtocolAbiV1); +static_assert(static_cast(protos::gen::PROTOCOL_ABI_VERSION_V2) == + kProtocolAbiV2); + +// Returns the bitmask of common protocol versions, or 0 if none match. +uint32_t GetCommonProtocolAbiVersions(uint32_t producer_versions, + bool use_shmem_emulation) { + // Old producers send no versions and support only v1. + if (!producer_versions) + return kProtocolAbiV1; + + // v2 needs memfd support and cannot use shared memory emulation. + uint32_t supported = kProtocolAbiV1; + if (tracing_v2::IpcSupportsTracingV2() && !use_shmem_emulation) + supported |= kProtocolAbiV2; + + // Unknown bits from a newer producer drop out here. + return producer_versions & supported; +} + +} // namespace + ProducerIPCService::ProducerIPCService(TracingService* core_service) : core_service_(core_service), weak_ptr_factory_(this) {} @@ -85425,8 +94239,9 @@ void ProducerIPCService::InitializeConnection( base::ScopedFile shmem_fd = ipc::Service::TakeReceivedFD(); if (shmem_fd) { - shmem = PosixSharedMemory::AttachToFd( - std::move(shmem_fd), /*require_seals_if_supported=*/true); + shmem = PosixSharedMemory::AttachToFd(std::move(shmem_fd), + /*require_seals_if_supported=*/true, + TracingService::kMaxShmSize); if (!shmem) { PERFETTO_ELOG( "Couldn't map producer-provided SMB, falling back to " @@ -85443,13 +94258,23 @@ void ProducerIPCService::InitializeConnection( // Copy the data fields to be emitted to trace packets into ClientIdentity. ClientIdentity client_identity(client_info.uid(), client_info.pid(), client_info.machine_id()); + const uint32_t protocol_abi_versions = + GetCommonProtocolAbiVersions(req.supported_protocol_abi_versions(), + ipc::Service::use_shmem_emulation()); + if (!protocol_abi_versions) { + PERFETTO_ELOG( + "Producer \"%s\" supports no protocol version of this service", + req.producer_name().c_str()); + return response.Reject(); + } + // ConnectProducer will call OnConnect() on the next task. producer->service_endpoint = core_service_->ConnectProducer( producer.get(), client_identity, req.producer_name(), req.shared_memory_size_hint_bytes(), /*in_process=*/false, smb_scraping_mode, req.shared_memory_page_size_hint_bytes(), std::move(shmem), - req.sdk_version(), client_info.machine_name()); + req.sdk_version(), client_info.machine_name(), protocol_abi_versions); // Could happen if the service has too many producers connected. if (!producer->service_endpoint) { @@ -85470,6 +94295,7 @@ void ProducerIPCService::InitializeConnection( async_res->set_using_shmem_provided_by_producer(using_producer_shmem); async_res->set_direct_smb_patching_supported(true); async_res->set_use_shmem_emulation(use_shmem_emulation); + async_res->set_protocol_abi_versions(protocol_abi_versions); response.Resolve(std::move(async_res)); } @@ -85712,6 +94538,52 @@ void ProducerIPCService::GetAsyncCommand( producer->SendSetupTracing(); } +void ProducerIPCService::AttachV2RingBuffer( + const protos::gen::AttachV2RingBufferRequest& req, + DeferredAttachV2RingBufferResponse resp) { + // Take the descriptor first. It is closed on every rejection path. + auto fd = ipc::Service::TakeReceivedFD(); + auto* producer = GetProducerForCurrentRequest(); + if (!producer) { + resp.Reject(); + return; + } + + std::shared_ptr memory; +#if PERFETTO_TRACING_V2_IPC() + memory = PosixSharedMemory::AttachToFd(std::move(fd), + /*require_seals_if_supported=*/true, + TracingService::kMaxShmSize); +#endif + if (!memory) { + PERFETTO_DLOG("AttachV2RingBuffer() rejected: could not map the memfd"); + resp.Reject(); + return; + } + + // |resp| cannot be copied, but std::function requires a copyable callback. + // Capture a shared_ptr so callback copies refer to the same response. + auto pending = + std::make_shared(std::move(resp)); + producer->service_endpoint->AttachV2RingBuffer( + memory, req.chunk_size_bytes(), [pending](bool accepted) { + if (!accepted) { + pending->Reject(); + return; + } + pending->Resolve(ipc::AsyncResult< + protos::gen::AttachV2RingBufferResponse>::Create()); + }); +} + +void ProducerIPCService::DrainV2RingBuffer( + const protos::gen::DrainV2RingBufferRequest&, + DeferredDrainV2RingBufferResponse) { + auto* producer = GetProducerForCurrentRequest(); + if (producer) + producer->service_endpoint->DrainV2RingBuffer(); +} + void ProducerIPCService::Sync(const protos::gen::SyncRequest&, DeferredSyncResponse resp) { RemoteProducer* producer = GetProducerForCurrentRequest(); @@ -86499,7 +95371,7 @@ std::unique_ptr SystemProducerTracingBackend::ConnectProducer( #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) shm = SharedMemoryWindows::Create(shmem_size_hint); #else - shm = PosixSharedMemory::Create(shmem_size_hint); + shm = PosixSharedMemory::Create(shmem_size_hint).ValueOrDie(); #endif arbiter = SharedMemoryArbiter::CreateUnboundInstance( shm.get(), shmem_page_size_hint, SharedMemoryABI::ShmemMode::kDefault); diff --git a/deps/perfetto/sdk/perfetto.h b/deps/perfetto/sdk/perfetto.h index 5bf6732f9b7..29ce162dd55 100644 --- a/deps/perfetto/sdk/perfetto.h +++ b/deps/perfetto/sdk/perfetto.h @@ -543,6 +543,17 @@ static const int kPerfettoBuildFlagsCount = sizeof(kPerfettoBuildFlags) / sizeof #define PERFETTO_NORETURN __declspec(noreturn) #endif +// Promises that what a pointer reaches is reached through nothing else in its +// scope, so writes through it cannot change what other pointers read. Not +// `__restrict`: the macOS SDK defines that away to nothing in C++. +#if defined(__GNUC__) || defined(__clang__) +#define PERFETTO_RESTRICT __restrict__ +#elif defined(_MSC_VER) +#define PERFETTO_RESTRICT __restrict +#else +#define PERFETTO_RESTRICT +#endif + #if defined(__GNUC__) || defined(__clang__) #define PERFETTO_DEBUG_FUNCTION_IDENTIFIER() __PRETTY_FUNCTION__ #elif defined(_MSC_VER) @@ -595,7 +606,7 @@ extern "C" void __msan_unpoison(void const volatile*, size_t); #endif // __clang__ #if defined(__GNUC__) || defined(__clang__) -#define PERFETTO_IS_LITTLE_ENDIAN() __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +#define PERFETTO_IS_LITTLE_ENDIAN() (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) #else // Assume all MSVC targets are little endian. #define PERFETTO_IS_LITTLE_ENDIAN() 1 @@ -1036,6 +1047,7 @@ inline void MaybeSerializeLastLogsForCrashReporting() {} #include #include #include +#include #include #endif @@ -1534,6 +1546,38 @@ static inline uint32_t PerfettoPbMakeTag(int32_t field_id, PERFETTO_STATIC_CAST(uint32_t, wire_type); } +// Constants for tracing v2's append-only proto group format: +// +// open nested field f: varint((f << 3) | 3) +// close current nested: 0x04 +// root: no wrapper and no close byte +// +// Unlike standard protobuf groups, the closing byte does not repeat the field +// number. It encodes field zero (invalid in standard protobuf) with wire +// type 4. At a field boundary, it closes the innermost message. The packet +// boundary ends the root. +// +// The parent writes both the start tag and the closing byte of a nested +// message. A root has no parent, so nothing writes a closing byte for it. +// +// The packet must be rewritten to length-delimited protobuf before standard +// decoders can read it. See RFC 0014 for the design: +// https://github.com/google/perfetto/discussions/4508. +// +// The wire types stay outside PerfettoPbWireType because the decoders do not +// support groups. Keep in sync with kWireTypeStartGroup and kProtoGroupEndByte +// in perfetto/protozero/proto_utils.h. +enum { + PERFETTO_PB_WIRE_TYPE_START_GROUP = 3, + PERFETTO_PB_PROTO_GROUP_END_BYTE = 0x04, +}; + +// Creates the tag that opens a nested message in proto group mode. +static inline uint32_t PerfettoPbMakeTagStartGroup(int32_t field_id) { + return ((PERFETTO_STATIC_CAST(uint32_t, field_id)) << 3) | + PERFETTO_STATIC_CAST(uint32_t, PERFETTO_PB_WIRE_TYPE_START_GROUP); +} + enum { // Maximum bytes size of a 64-bit integer encoded as a VarInt. PERFETTO_PB_VARINT_MAX_SIZE_64 = 10, @@ -1695,6 +1739,7 @@ static inline uint32_t PerfettoPbFloatToFixed32(float value) { #include #include +// gen_amalgamated expanded: #include "perfetto/base/compiler.h" // gen_amalgamated expanded: #include "perfetto/base/logging.h" // gen_amalgamated expanded: #include "perfetto/public/compiler.h" // gen_amalgamated expanded: #include "perfetto/public/pb_utils.h" @@ -1721,6 +1766,41 @@ enum class ProtoWireType : uint32_t { kFixed32 = 5, }; +// Wire types for proto group boundaries. These stay outside ProtoWireType +// because protozero decoders do not support groups. See kProtoGroupEndByte. +// Keep in sync with PERFETTO_PB_WIRE_TYPE_START_GROUP in public/pb_utils.h. +constexpr uint32_t kWireTypeStartGroup = 3; +constexpr uint32_t kWireTypeEndGroup = 4; + +// Closing byte for tracing v2's append-only proto group format: +// +// open nested field f: varint((f << 3) | 3) +// close current nested: 0x04 +// root: no wrapper and no close byte +// +// Unlike standard protobuf groups, the closing byte does not repeat the field +// number. It encodes field zero (invalid in standard protobuf) with wire +// type 4. At a field boundary, it closes the innermost message. The packet +// boundary ends the root. +// +// The parent writes both the start tag and the closing byte of a nested +// message, as it writes the tag and the length field of a length-delimited +// one. A root has no parent, so nothing writes a closing byte for it. +// +// The packet must be rewritten to length-delimited protobuf before standard +// decoders can read it. See RFC 0014 for the design: +// https://github.com/google/perfetto/discussions/4508. +// Keep in sync with PERFETTO_PB_PROTO_GROUP_END_BYTE in pb_utils.h. +constexpr uint8_t kProtoGroupEndByte = static_cast(kWireTypeEndGroup); + +// Enforces the "Keep in sync" rules above. +static_assert(kWireTypeStartGroup == + static_cast(PERFETTO_PB_WIRE_TYPE_START_GROUP), + "C and C++ start group wire types differ"); +static_assert(kProtoGroupEndByte == + static_cast(PERFETTO_PB_PROTO_GROUP_END_BYTE), + "C and C++ proto group closing bytes differ"); + // This is the type defined in the proto for each field. This information // is used to decide the translation strategy when writing the trace. enum class ProtoSchemaType { @@ -1873,6 +1953,11 @@ constexpr uint32_t MakeTagLengthDelimited(uint32_t field_id) { static_cast(ProtoWireType::kLengthDelimited); } +// Opens a nested message in the proto group encoding described above. +constexpr uint32_t MakeTagStartGroup(uint32_t field_id) { + return (field_id << kFieldTypeNumBits) | kWireTypeStartGroup; +} + // Proto types: sint64, sint32. template inline typename std::make_unsigned::type ZigZagEncode(T value) { @@ -2587,6 +2672,8 @@ class InterceptorConfig; class ConsoleConfig; class ChromeConfig; class SystemInfoConfig; +class DataSourceConfig_ExperimentalTracingV2Config; +class DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption; class ProtoVmConfig; class PriorityBoostConfig; enum DataSourceConfig_SessionInitiator : int; @@ -2618,6 +2705,7 @@ enum DataSourceConfig_BufferExhaustedPolicy : int { class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessageObj { public: + using ExperimentalTracingV2Config = DataSourceConfig_ExperimentalTracingV2Config; using SessionInitiator = DataSourceConfig_SessionInitiator; static constexpr auto SESSION_INITIATOR_UNSPECIFIED = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_UNSPECIFIED; static constexpr auto SESSION_INITIATOR_TRUSTED_SYSTEM = DataSourceConfig_SessionInitiator_SESSION_INITIATOR_TRUSTED_SYSTEM; @@ -2643,6 +2731,8 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag kBufferExhaustedPolicyFieldNumber = 9, kPriorityBoostFieldNumber = 10, kProtovmConfigFieldNumber = 12, + kSupportsTracingV2FieldNumber = 147, + kExperimentalTracingV2FieldNumber = 148, kFtraceConfigFieldNumber = 100, kInodeFileConfigFieldNumber = 102, kProcessStatsConfigFieldNumber = 103, @@ -2685,6 +2775,10 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag kAndroidAflagsConfigFieldNumber = 140, kJournaldConfigFieldNumber = 141, kDisplayVideoConfigFieldNumber = 142, + kChromiumStackSamplingProfilerFieldNumber = 143, + kChromiumSamplingHeapProfilerFieldNumber = 144, + kAndroidProcessStateConfigFieldNumber = 145, + kProcessSmapsConfigFieldNumber = 146, kQnxConfigFieldNumber = 150, kLegacyConfigFieldNumber = 1000, kForTestingFieldNumber = 1001, @@ -2752,6 +2846,14 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag const ProtoVmConfig& protovm_config() const { return *protovm_config_; } ProtoVmConfig* mutable_protovm_config() { _has_field_.set(12); return protovm_config_.get(); } + bool has_supports_tracing_v2() const { return _has_field_[147]; } + bool supports_tracing_v2() const { return supports_tracing_v2_; } + void set_supports_tracing_v2(bool value) { supports_tracing_v2_ = value; _has_field_.set(147); } + + bool has_experimental_tracing_v2() const { return _has_field_[148]; } + const DataSourceConfig_ExperimentalTracingV2Config& experimental_tracing_v2() const { return *experimental_tracing_v2_; } + DataSourceConfig_ExperimentalTracingV2Config* mutable_experimental_tracing_v2() { _has_field_.set(148); return experimental_tracing_v2_.get(); } + const std::string& ftrace_config_raw() const { return ftrace_config_; } void set_ftrace_config_raw(const std::string& raw) { ftrace_config_ = raw; _has_field_.set(100); } @@ -2881,6 +2983,18 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag const std::string& display_video_config_raw() const { return display_video_config_; } void set_display_video_config_raw(const std::string& raw) { display_video_config_ = raw; _has_field_.set(142); } + const std::string& chromium_stack_sampling_profiler_raw() const { return chromium_stack_sampling_profiler_; } + void set_chromium_stack_sampling_profiler_raw(const std::string& raw) { chromium_stack_sampling_profiler_ = raw; _has_field_.set(143); } + + const std::string& chromium_sampling_heap_profiler_raw() const { return chromium_sampling_heap_profiler_; } + void set_chromium_sampling_heap_profiler_raw(const std::string& raw) { chromium_sampling_heap_profiler_ = raw; _has_field_.set(144); } + + const std::string& android_process_state_config_raw() const { return android_process_state_config_; } + void set_android_process_state_config_raw(const std::string& raw) { android_process_state_config_ = raw; _has_field_.set(145); } + + const std::string& process_smaps_config_raw() const { return process_smaps_config_; } + void set_process_smaps_config_raw(const std::string& raw) { process_smaps_config_ = raw; _has_field_.set(146); } + const std::string& qnx_config_raw() const { return qnx_config_; } void set_qnx_config_raw(const std::string& raw) { qnx_config_ = raw; _has_field_.set(150); } @@ -2905,6 +3019,8 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag DataSourceConfig_BufferExhaustedPolicy buffer_exhausted_policy_{}; ::protozero::CopyablePtr priority_boost_; ::protozero::CopyablePtr protovm_config_; + bool supports_tracing_v2_{}; + ::protozero::CopyablePtr experimental_tracing_v2_; std::string ftrace_config_; // [lazy=true] std::string inode_file_config_; // [lazy=true] std::string process_stats_config_; // [lazy=true] @@ -2947,6 +3063,10 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag std::string android_aflags_config_; // [lazy=true] std::string journald_config_; // [lazy=true] std::string display_video_config_; // [lazy=true] + std::string chromium_stack_sampling_profiler_; // [lazy=true] + std::string chromium_sampling_heap_profiler_; // [lazy=true] + std::string android_process_state_config_; // [lazy=true] + std::string process_smaps_config_; // [lazy=true] std::string qnx_config_; // [lazy=true] std::string legacy_config_{}; ::protozero::CopyablePtr for_testing_; @@ -2958,6 +3078,97 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag std::bitset<1002> _has_field_{}; }; + +class PERFETTO_EXPORT_COMPONENT DataSourceConfig_ExperimentalTracingV2Config : public ::protozero::CppMessageObj { + public: + using ChunkSizeOption = DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption; + enum FieldNumbers { + kUseV2ProbabilityPercentFieldNumber = 1, + kChunkSizeOptionsFieldNumber = 2, + kDrainOccupancyPercentFieldNumber = 3, + }; + + DataSourceConfig_ExperimentalTracingV2Config(); + ~DataSourceConfig_ExperimentalTracingV2Config() override; + DataSourceConfig_ExperimentalTracingV2Config(DataSourceConfig_ExperimentalTracingV2Config&&) noexcept; + DataSourceConfig_ExperimentalTracingV2Config& operator=(DataSourceConfig_ExperimentalTracingV2Config&&); + DataSourceConfig_ExperimentalTracingV2Config(const DataSourceConfig_ExperimentalTracingV2Config&); + DataSourceConfig_ExperimentalTracingV2Config& operator=(const DataSourceConfig_ExperimentalTracingV2Config&); + bool operator==(const DataSourceConfig_ExperimentalTracingV2Config&) const; + bool operator!=(const DataSourceConfig_ExperimentalTracingV2Config& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_use_v2_probability_percent() const { return _has_field_[1]; } + uint32_t use_v2_probability_percent() const { return use_v2_probability_percent_; } + void set_use_v2_probability_percent(uint32_t value) { use_v2_probability_percent_ = value; _has_field_.set(1); } + + const std::vector& chunk_size_options() const { return chunk_size_options_; } + std::vector* mutable_chunk_size_options() { return &chunk_size_options_; } + int chunk_size_options_size() const; + void clear_chunk_size_options(); + DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption* add_chunk_size_options(); + + bool has_drain_occupancy_percent() const { return _has_field_[3]; } + int32_t drain_occupancy_percent() const { return drain_occupancy_percent_; } + void set_drain_occupancy_percent(int32_t value) { drain_occupancy_percent_ = value; _has_field_.set(3); } + + private: + uint32_t use_v2_probability_percent_{}; + std::vector chunk_size_options_; + int32_t drain_occupancy_percent_{}; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<4> _has_field_{}; +}; + + +class PERFETTO_EXPORT_COMPONENT DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + kSizeBytesFieldNumber = 1, + kWeightFieldNumber = 2, + }; + + DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption(); + ~DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption() override; + DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption(DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption&&) noexcept; + DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption& operator=(DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption&&); + DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption(const DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption&); + DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption& operator=(const DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption&); + bool operator==(const DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption&) const; + bool operator!=(const DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_size_bytes() const { return _has_field_[1]; } + uint32_t size_bytes() const { return size_bytes_; } + void set_size_bytes(uint32_t value) { size_bytes_ = value; _has_field_.set(1); } + + bool has_weight() const { return _has_field_[2]; } + uint32_t weight() const { return weight_; } + void set_weight(uint32_t value) { weight_ = value; _has_field_.set(2); } + + private: + uint32_t size_bytes_{}; + uint32_t weight_{}; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<3> _has_field_{}; +}; + } // namespace perfetto } // namespace protos } // namespace gen @@ -2994,6 +3205,256 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag // gen_amalgamated begin header: include/perfetto/tracing/trace_writer_base.h // gen_amalgamated begin header: include/perfetto/protozero/message_handle.h // gen_amalgamated begin header: include/perfetto/protozero/message.h +// gen_amalgamated begin header: include/perfetto/base/endian.h +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_BASE_ENDIAN_H_ +#define INCLUDE_PERFETTO_BASE_ENDIAN_H_ + +#include +#include // For MSVC +#include + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" +// gen_amalgamated expanded: #include "perfetto/base/compiler.h" + +namespace perfetto { +namespace base { + +#if PERFETTO_BUILDFLAG(PERFETTO_COMPILER_MSVC) +inline uint16_t ByteSwap16(uint16_t x) { + return _byteswap_ushort(x); +} +inline uint32_t ByteSwap32(uint32_t x) { + return _byteswap_ulong(x); +} +inline uint64_t ByteSwap64(uint64_t x) { + return _byteswap_uint64(x); +} +#else +inline uint16_t ByteSwap16(uint16_t x) { + return __builtin_bswap16(x); +} +inline uint32_t ByteSwap32(uint32_t x) { + return __builtin_bswap32(x); +} +inline uint64_t ByteSwap64(uint64_t x) { + return __builtin_bswap64(x); +} +#endif + +#if PERFETTO_IS_LITTLE_ENDIAN() +inline uint16_t HostToLE16(uint16_t x) { + return x; +} +inline uint32_t HostToLE32(uint32_t x) { + return x; +} +inline uint64_t HostToLE64(uint64_t x) { + return x; +} +inline uint16_t LE16ToHost(uint16_t x) { + return x; +} +inline uint32_t LE32ToHost(uint32_t x) { + return x; +} +inline uint64_t LE64ToHost(uint64_t x) { + return x; +} +inline uint16_t HostToBE16(uint16_t x) { + return ByteSwap16(x); +} +inline uint32_t HostToBE32(uint32_t x) { + return ByteSwap32(x); +} +inline uint64_t HostToBE64(uint64_t x) { + return ByteSwap64(x); +} +inline uint16_t BE16ToHost(uint16_t x) { + return ByteSwap16(x); +} +inline uint32_t BE32ToHost(uint32_t x) { + return ByteSwap32(x); +} +inline uint64_t BE64ToHost(uint64_t x) { + return ByteSwap64(x); +} +inline float HostToLEFloat(float x) { + return x; +} +inline double HostToLEDouble(double x) { + return x; +} +inline float LEFloatToHost(float x) { + return x; +} +inline double LEDoubleToHost(double x) { + return x; +} +inline float HostToBEFloat(float x) { + uint32_t u; + memcpy(&u, &x, sizeof(u)); + u = ByteSwap32(u); + memcpy(&x, &u, sizeof(u)); + return x; +} +inline double HostToBEDouble(double x) { + uint64_t u; + memcpy(&u, &x, sizeof(u)); + u = ByteSwap64(u); + memcpy(&x, &u, sizeof(u)); + return x; +} +inline float BEFloatToHost(float x) { + uint32_t u; + memcpy(&u, &x, sizeof(u)); + u = ByteSwap32(u); + memcpy(&x, &u, sizeof(u)); + return x; +} +inline double BEDoubleToHost(double x) { + uint64_t u; + memcpy(&u, &x, sizeof(u)); + u = ByteSwap64(u); + memcpy(&x, &u, sizeof(u)); + return x; +} +#else +inline uint16_t HostToLE16(uint16_t x) { + return ByteSwap16(x); +} +inline uint32_t HostToLE32(uint32_t x) { + return ByteSwap32(x); +} +inline uint64_t HostToLE64(uint64_t x) { + return ByteSwap64(x); +} +inline uint16_t LE16ToHost(uint16_t x) { + return ByteSwap16(x); +} +inline uint32_t LE32ToHost(uint32_t x) { + return ByteSwap32(x); +} +inline uint64_t LE64ToHost(uint64_t x) { + return ByteSwap64(x); +} +inline uint16_t HostToBE16(uint16_t x) { + return x; +} +inline uint32_t HostToBE32(uint32_t x) { + return x; +} +inline uint64_t HostToBE64(uint64_t x) { + return x; +} +inline uint16_t BE16ToHost(uint16_t x) { + return x; +} +inline uint32_t BE32ToHost(uint32_t x) { + return x; +} +inline uint64_t BE64ToHost(uint64_t x) { + return x; +} +inline float HostToLEFloat(float x) { + uint32_t u; + memcpy(&u, &x, sizeof(u)); + u = ByteSwap32(u); + memcpy(&x, &u, sizeof(u)); + return x; +} +inline double HostToLEDouble(double x) { + uint64_t u; + memcpy(&u, &x, sizeof(u)); + u = ByteSwap64(u); + memcpy(&x, &u, sizeof(u)); + return x; +} +inline float LEFloatToHost(float x) { + uint32_t u; + memcpy(&u, &x, sizeof(u)); + u = ByteSwap32(u); + memcpy(&x, &u, sizeof(u)); + return x; +} +inline double LEDoubleToHost(double x) { + uint64_t u; + memcpy(&u, &x, sizeof(u)); + u = ByteSwap64(u); + memcpy(&x, &u, sizeof(u)); + return x; +} +inline float HostToBEFloat(float x) { + return x; +} +inline double HostToBEDouble(double x) { + return x; +} +inline float BEFloatToHost(float x) { + return x; +} +inline double BEDoubleToHost(double x) { + return x; +} +#endif + +inline uint32_t HostToLE(uint32_t x) { + return HostToLE32(x); +} +inline int32_t HostToLE(int32_t x) { + return static_cast(HostToLE32(static_cast(x))); +} +inline uint64_t HostToLE(uint64_t x) { + return HostToLE64(x); +} +inline int64_t HostToLE(int64_t x) { + return static_cast(HostToLE64(static_cast(x))); +} +inline float HostToLE(float x) { + return HostToLEFloat(x); +} +inline double HostToLE(double x) { + return HostToLEDouble(x); +} + +inline uint32_t LEToHost(uint32_t x) { + return LE32ToHost(x); +} +inline int32_t LEToHost(int32_t x) { + return static_cast(LE32ToHost(static_cast(x))); +} +inline uint64_t LEToHost(uint64_t x) { + return LE64ToHost(x); +} +inline int64_t LEToHost(int64_t x) { + return static_cast(LE64ToHost(static_cast(x))); +} +inline float LEToHost(float x) { + return LEFloatToHost(x); +} +inline double LEToHost(double x) { + return LEDoubleToHost(x); +} + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_BASE_ENDIAN_H_ // gen_amalgamated begin header: include/perfetto/protozero/scattered_stream_writer.h /* * Copyright (C) 2017 The Android Open Source Project @@ -3200,6 +3661,7 @@ class PERFETTO_EXPORT_COMPONENT ScatteredStreamWriter { #include #include +// gen_amalgamated expanded: #include "perfetto/base/endian.h" // gen_amalgamated expanded: #include "perfetto/base/export.h" // gen_amalgamated expanded: #include "perfetto/base/logging.h" // gen_amalgamated expanded: #include "perfetto/protozero/contiguous_memory_range.h" @@ -3234,16 +3696,46 @@ class PERFETTO_EXPORT_COMPONENT Message { // static_assert()s in the Reset() method. Message() = default; - // Clears up the state, allowing the message to be reused as a fresh one. - void Reset(ScatteredStreamWriter*, MessageArena*); - - // Commits all the changes to the buffer (backfills the size field of this and - // all nested messages) and seals the message. Returns the size of the message - // (and all nested sub-messages), without taking into account any chunking. + // Encoding for nested messages. The root selects it in Reset(). Each child + // inherits its parent's encoding. + // Keep in sync with PerfettoPbMsgEncoding in perfetto/public/pb_msg.h. + enum class Encoding : uint8_t { + // Standard protobuf. Finalize() writes each child's length into a reserved + // field before the child's contents. + kLengthDelimited = 0, + + // Append-only format for tracing v2. It needs no patches: + // - A nested message starts with a group start tag and ends with a + // closing byte, instead of a fixed-size length field. + // - Use it only inside the SMB, for the tracing v2 protocol. The final + // trace output stays canonical protobuf. + // See proto_utils::kProtoGroupEndByte for the wire format. + kProtoGroup = 1, + }; + + // Returns the encoding each new child inherits. + Encoding encoding() const { return encoding_; } + + // Clears up the state, allowing the message to be reused as a fresh one + // with the specified encoding. + void Reset(ScatteredStreamWriter*, MessageArena*, Encoding); + + // Convenience wrapper for the default length-delimited encoding. + // See the TODO on RootMessage::Reset(). + void Reset(ScatteredStreamWriter* stream_writer, MessageArena* arena) { + Reset(stream_writer, arena, Encoding::kLengthDelimited); + } + + // Finalizes all open children, then seals this message: + // - Length-delimited: writes the encoded size into the reserved length field, + // if present. For short messages within the current chunk, compaction can + // reduce the field from proto_utils::kMessageLengthFieldSize bytes to one. + // - kProtoGroup: writes nothing. The parent writes the closing byte. + // + // Returns the encoded size of this message's fields, including nested + // messages. It excludes this message's own tag, length field and closing + // byte. // Finalize is idempotent and can be called several times w/o side effects. - // Short messages may be compacted in memory into the size field, since their - // size can be represented with fewer than - // proto_utils::kMessageLengthFieldSize bytes. uint32_t Finalize(); // Optional. If is_valid() == true, the corresponding memory region (its @@ -3252,6 +3744,8 @@ class PERFETTO_EXPORT_COMPONENT Message { // corresponding size field in the parent message. In most cases this is only // used for nested messages and the ScatteredStreamWriter::Delegate (e.g. // TraceWriterImpl), takes case of the outer message. + // + // In kProtoGroup mode, this pointer must always be null. uint8_t* size_field() const { return size_field_; } void set_size_field(uint8_t* size_field) { size_field_ = size_field; } @@ -3311,7 +3805,8 @@ class PERFETTO_EXPORT_COMPONENT Message { uint8_t* pos = buffer; pos = proto_utils::WriteVarInt(proto_utils::MakeTagFixed(field_id), pos); - memcpy(pos, &value, sizeof(T)); + T le_value = perfetto::base::HostToLE(value); + memcpy(pos, &le_value, sizeof(T)); pos += sizeof(T); // TODO: Optimize memcpy performance, see http://crbug.com/624311 . WriteToStream(buffer, pos); @@ -3357,6 +3852,12 @@ class PERFETTO_EXPORT_COMPONENT Message { // generated by the cppgen_plugin.cc. // The caller needs to guarantee that the appended data is properly // proto-encoded and each field has a proto preamble. + // + // In kProtoGroup mode: + // - |data| must not contain protobuf group fields. This mode reserves wire + // types 3 and 4 for nested message boundaries. + // - A nested message must contain only proto fields. For a raw string or + // bytes payload, use AppendBytes() on the parent. void AppendRawProtoBytes(const void* data, size_t size) { if (nested_message_) EndNestedMessage(); @@ -3371,6 +3872,8 @@ class PERFETTO_EXPORT_COMPONENT Message { Message* BeginNestedMessageInternal(uint32_t field_id); // Called by Finalize and Append* methods. + // Ends the open child: finalizes it, adds its encoded size to this message + // and, in kProtoGroup mode, appends its closing byte. void EndNestedMessage(); void WriteToStream(const uint8_t* src_begin, const uint8_t* src_end) { @@ -3403,6 +3906,8 @@ class PERFETTO_EXPORT_COMPONENT Message { // [optional] Pointer to a non-aligned pre-reserved var-int slot of // kMessageLengthFieldSize bytes. When set, the Finalize() method will write // the size of proto-encoded message in the pointed memory region. + // + // In kProtoGroup mode, this pointer is unused and always null. uint8_t* size_field_; // Keeps track of the size of the current message. @@ -3422,6 +3927,9 @@ class PERFETTO_EXPORT_COMPONENT Message { MessageState message_state_; + // Selected by the root and inherited by every nested message. + Encoding encoding_; + #if PERFETTO_DCHECK_IS_ON() // Current generation of message. Incremented on Reset. // Used to detect stale handles. @@ -3838,6 +4346,14 @@ struct DataSourceState { // this data source. std::atomic incremental_state_generation{0}; + // True if the writers of this instance use tracing v2. + // The muxer sets it once during setup, before writer threads see the + // instance. + // It stays true if v2 initialization fails, so the writers discard their + // data and do not fall back to v1. + // A startup instance keeps v1, also after adoption. + bool use_tracing_v2 = false; + // This lock is not held to implement Trace() and it's used only if the trace // code wants to access its own data source state. // This is to prevent that accessing the data source on an arbitrary embedder @@ -4563,6 +5079,7 @@ struct FieldWriter { #include #include +// gen_amalgamated expanded: #include "perfetto/base/endian.h" // gen_amalgamated expanded: #include "perfetto/base/logging.h" // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" @@ -4645,7 +5162,8 @@ class PackedFixedSizeInt : public PackedBufferBase { "kMaxElementSize needs to be updated"); GrowIfNeeded(); PERFETTO_DCHECK(reinterpret_cast(write_ptr_) % alignof(T) == 0); - memcpy(reinterpret_cast(write_ptr_), &value, sizeof(T)); + T le_value = perfetto::base::HostToLE(value); + memcpy(reinterpret_cast(write_ptr_), &le_value, sizeof(T)); write_ptr_ += sizeof(T); } }; @@ -4683,6 +5201,7 @@ class PackedFixedSizeInt : public PackedBufferBase { #include #include +// gen_amalgamated expanded: #include "perfetto/base/endian.h" // gen_amalgamated expanded: #include "perfetto/base/export.h" // gen_amalgamated expanded: #include "perfetto/base/logging.h" // gen_amalgamated expanded: #include "perfetto/protozero/field.h" @@ -4880,7 +5399,7 @@ class PackedRepeatedFieldIterator { return *this; } - if (wire_type == ProtoWireType::kVarInt) { + if constexpr (wire_type == ProtoWireType::kVarInt) { uint64_t new_value = 0; const uint8_t* new_pos = proto_utils::ParseVarInt(read_ptr_, data_end_, &new_value); @@ -4899,6 +5418,7 @@ class PackedRepeatedFieldIterator { // NB: the raw buffer is not guaranteed to be aligned, so neither are // these copies. memcpy(&curr_value_, read_ptr_, sizeof(CppType)); + curr_value_ = perfetto::base::LEToHost(curr_value_); read_ptr_ += kStep; } @@ -4983,7 +5503,8 @@ class UnifiedRepeatedFieldIterator { // static constexpr SelectiveDecodeMask // kMask{}; -// SelectiveTypedProtoDecoder decoder(data, size, kMask); +// SelectiveTypedProtoDecoder> decoder( +// data, size, kMask); // for (const Field& f : decoder.unknown_fields()) { ... } template class SelectiveDecodeMask { @@ -5042,6 +5563,24 @@ class PERFETTO_EXPORT_COMPONENT TypedProtoDecoderBase : public ProtoDecoder { return kInvalidField; } + // True if the message contained at least one field with an id beyond the + // highest id known in-tree (typically an out-of-tree extension). Such + // fields are not stored here; this lets callers skip a selective re-decode + // via unknown_fields() when there is nothing to find. + bool has_out_of_range_fields() const { return has_out_of_range_fields_; } + + // True if any field whose bit is set in |mask| is present. |mask| is laid + // out like the presence bitmap (bit i of word i / 64 for field id i) and + // holds |words| words; bits beyond the known field range are ignored. + bool HasAnyField(const uint64_t* mask, size_t words) const { + size_t presence_words = (num_fields_ + 63) / 64; + for (size_t i = 0; i < words && i < presence_words; ++i) { + if (presence_[i] & mask[i]) + return true; + } + return false; + } + // True if the field with the given id was seen while decoding: tests bit // |id| of the presence bitmap. The caller must check that |id| is within // the bitmap, i.e. <= the decoder's MAX_FIELD_ID. Note that |id| may @@ -5221,6 +5760,9 @@ class PERFETTO_EXPORT_COMPONENT TypedProtoDecoderBase : public ProtoDecoder { // |size_| is always <= |capacity_|. But |num_fields_| can be > |size_|. uint32_t size_; + // See has_out_of_range_fields(). + bool has_out_of_range_fields_ = false; + // Initially equal to kFieldsCapacity of the TypedProtoDecoder // specialization. Can grow when falling back on heap-based storage, in which // case it represents the size (#fields with each entry of a repeated field @@ -5254,11 +5796,16 @@ class PERFETTO_EXPORT_COMPONENT TypedProtoDecoderBase : public ProtoDecoder { template class TypedProtoDecoder : public TypedProtoDecoderBase { public: + // The highest field id known to this decoder; see has_out_of_range_fields(). + static constexpr uint32_t kMaxFieldId = static_cast(MAX_FIELD_ID); + TypedProtoDecoder(const uint8_t* buffer, size_t length) - : TypedProtoDecoder(SkipParseTag{}, - buffer, - length, - /*num_fields=*/MAX_FIELD_ID + 1) { + : TypedProtoDecoderBase(on_stack_storage_, + presence_storage_, + /*num_fields=*/MAX_FIELD_ID + 1, + PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, + buffer, + length) { TypedProtoDecoderBase::ParseAllFields(); } @@ -5290,21 +5837,6 @@ class TypedProtoDecoder : public TypedProtoDecoderBase { return *this; } - protected: - // Sets up the storage but does not parse: for subclasses that drive - // ParseAllFields() themselves (see SelectiveTypedProtoDecoder). - struct SkipParseTag {}; - TypedProtoDecoder(SkipParseTag, - const uint8_t* buffer, - size_t length, - uint32_t num_fields) - : TypedProtoDecoderBase(on_stack_storage_, - presence_storage_, - num_fields, - PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, - buffer, - length) {} - private: void MaybeCopyOnStackStorage(const TypedProtoDecoder& other) { // If the moved-from decoder was using on-stack storage, we need to update @@ -5344,37 +5876,34 @@ class TypedProtoDecoder : public TypedProtoDecoderBase { // static constexpr SelectiveDecodeMask // kMask{}; -// SelectiveTypedProtoDecoder decoder(data, size, kMask); +// SelectiveTypedProtoDecoder> decoder( +// data, size, kMask); // for (const Field& f : decoder.unknown_fields()) { ... } -template -class SelectiveTypedProtoDecoder : public TypedProtoDecoder { - using Base = TypedProtoDecoder; - - public: - // The dense window is capped at the mask's extent: |num_fields_| is the - // only id bound the decode loop checks, so capping it both bounds the mask - // read and makes every id above the mask spill, letting the mask be sized - // to the allowlisted ids only rather than to MAX_FIELD_ID. - // |mask| is only read during this call. +template +class SelectiveTypedProtoDecoder : public Decoder { + public: + // |Decoder| is a TypedProtoDecoder or a generated message decoder, whose + // typed accessors this class inherits. The dense window is capped at the + // mask's extent: |num_fields_| is the only id bound the decode loop checks, + // so capping it both bounds the mask read and makes every id above the + // mask spill, letting the mask be sized to the allowlisted ids only rather + // than to the decoder's max field id. |mask| is only read during this call. template SelectiveTypedProtoDecoder(const uint8_t* buffer, size_t length, const SelectiveDecodeMask& mask) - : Base(typename Base::SkipParseTag{}, - buffer, - length, - /*num_fields=*/ - std::min(static_cast(MAX_FIELD_ID), - SelectiveDecodeMask::kMaxFieldId) + - 1) { - // The base constructor cleared the presence bitmap only up to the capped - // |num_fields_|. at<>() skips the range check for ids below the on-stack - // capacity and tests the presence bit directly, so the rest of the bitmap - // must be cleared too. - constexpr uint32_t kPresenceWords = (MAX_FIELD_ID + 1 + 63) / 64; - const uint32_t cleared_words = (this->num_fields_ + 63) / 64; - memset(this->presence_ + cleared_words, 0, - (kPresenceWords - cleared_words) * sizeof(uint64_t)); + : Decoder(nullptr, 0) { + // The empty decode above set up the storage and cleared the whole + // presence bitmap without parsing anything; point it at the real buffer + // and parse selectively. + this->begin_ = buffer; + this->end_ = buffer + length; + this->read_ptr_ = buffer; + this->num_fields_ = + std::min(Decoder::kMaxFieldId, + SelectiveDecodeMask::kMaxFieldId) + + 1; + this->size_ = std::min(this->num_fields_, this->capacity_ - 1); spill_ = spill_storage_; uint32_t spill_capacity = kSpillStackCapacity; this->ParseAllFieldsSelective(mask.data(), &spill_, &spill_capacity, @@ -5388,7 +5917,7 @@ class SelectiveTypedProtoDecoder : public TypedProtoDecoder { } SelectiveTypedProtoDecoder(SelectiveTypedProtoDecoder&& other) noexcept - : Base(std::move(other)), + : Decoder(std::move(other)), spill_(other.spill_), spill_size_(other.spill_size_), heap_spill_(std::move(other.heap_spill_)) { @@ -7599,16 +8128,6 @@ namespace perfetto { namespace protos { namespace gen { class DataSourceDescriptor; -class VmProgram; -class VmInstruction; -class VmOpDel; -class VmOpSet; -class VmOpMerge; -class VmOpRegLoad; -class VmOpSelect; -class VmOpSelect_PathComponent; -enum VmInstruction_AbortLevel : int; -enum VmCursorEnum : int; } // namespace perfetto } // namespace protos } // namespace gen @@ -7674,9 +8193,8 @@ class PERFETTO_EXPORT_COMPONENT DataSourceDescriptor : public ::protozero::CppMe bool no_flush() const { return no_flush_; } void set_no_flush(bool value) { no_flush_ = value; _has_field_.set(9); } - bool has_protovm_program() const { return _has_field_[10]; } - const VmProgram& protovm_program() const { return *protovm_program_; } - VmProgram* mutable_protovm_program() { _has_field_.set(10); return protovm_program_.get(); } + const std::string& protovm_program_raw() const { return protovm_program_; } + void set_protovm_program_raw(const std::string& raw) { protovm_program_ = raw; _has_field_.set(10); } const std::string& gpu_counter_descriptor_raw() const { return gpu_counter_descriptor_; } void set_gpu_counter_descriptor_raw(const std::string& raw) { gpu_counter_descriptor_ = raw; _has_field_.set(5); } @@ -7694,7 +8212,7 @@ class PERFETTO_EXPORT_COMPONENT DataSourceDescriptor : public ::protozero::CppMe bool will_notify_on_start_{}; bool handles_incremental_state_clear_{}; bool no_flush_{}; - ::protozero::CopyablePtr protovm_program_; + std::string protovm_program_; // [lazy=true] std::string gpu_counter_descriptor_; // [lazy=true] std::string track_event_descriptor_; // [lazy=true] std::string ftrace_descriptor_; // [lazy=true] @@ -7787,6 +8305,8 @@ class InterceptorConfig; class ConsoleConfig; class ChromeConfig; class SystemInfoConfig; +class DataSourceConfig_ExperimentalTracingV2Config; +class DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption; class ProtoVmConfig; class TraceConfig_BufferConfig; enum TraceConfig_LockdownModeOperation : int; @@ -7913,6 +8433,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj static constexpr auto FFlushMode_MAX = TraceConfig_FFlushMode_FFLUSH_ENABLED; enum FieldNumbers { kBuffersFieldNumber = 1, + kExperimentalTraceBufferV2CompactionFieldNumber = 50, kDataSourcesFieldNumber = 2, kBuiltinDataSourcesFieldNumber = 20, kDurationMsFieldNumber = 3, @@ -7954,6 +8475,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj kFflushPostWriteFieldNumber = 45, kTraceAllMachinesFieldNumber = 43, kTraceAttributesFieldNumber = 48, + kPersistTraceAcrossRebootsFieldNumber = 49, }; TraceConfig(); @@ -7976,6 +8498,10 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj void clear_buffers(); TraceConfig_BufferConfig* add_buffers(); + bool has_experimental_trace_buffer_v2_compaction() const { return _has_field_[50]; } + bool experimental_trace_buffer_v2_compaction() const { return experimental_trace_buffer_v2_compaction_; } + void set_experimental_trace_buffer_v2_compaction(bool value) { experimental_trace_buffer_v2_compaction_ = value; _has_field_.set(50); } + const std::vector& data_sources() const { return data_sources_; } std::vector* mutable_data_sources() { return &data_sources_; } int data_sources_size() const; @@ -8149,8 +8675,13 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj const TraceAttributes& trace_attributes() const { return *trace_attributes_; } TraceAttributes* mutable_trace_attributes() { _has_field_.set(48); return trace_attributes_.get(); } + bool has_persist_trace_across_reboots() const { return _has_field_[49]; } + bool persist_trace_across_reboots() const { return persist_trace_across_reboots_; } + void set_persist_trace_across_reboots(bool value) { persist_trace_across_reboots_ = value; _has_field_.set(49); } + private: std::vector buffers_; + bool experimental_trace_buffer_v2_compaction_{}; std::vector data_sources_; ::protozero::CopyablePtr builtin_data_sources_; uint32_t duration_ms_{}; @@ -8192,12 +8723,13 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj TraceConfig_FFlushMode fflush_post_write_{}; bool trace_all_machines_{}; ::protozero::CopyablePtr trace_attributes_; + bool persist_trace_across_reboots_{}; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<49> _has_field_{}; + std::bitset<51> _has_field_{}; }; @@ -10851,6 +11383,11 @@ struct DataSourceParams { bool buffer_exhausted_policy_configurable = false; bool supports_multiple_instances = true; bool requires_callbacks_under_lock = true; + // Advertises that the data source supports tracing v2. + // This does NOT mean v2 will be used which is decided after the negotiation + // with the service, which might not support v2 or might decide not to use it. + // See DataSourceState.use_tracing_v2 for the active state. + bool supports_tracing_v2 = false; }; struct DataSourceStaticState; @@ -11334,6 +11871,7 @@ class ProcessDescriptor; class ProcessStats; class ProcessTree; class ProfilePacket; +class RecoveredTraceInfo; class RemoteClockSync; class SmapsPacket; class StackSample; @@ -11641,6 +12179,8 @@ class TracePacket_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_journald_event() const { return at<132>().valid(); } ::protozero::ConstBytes journald_event() const { return at<132>().as_bytes(); } + bool has_recovered_trace_info() const { return at<138>().valid(); } + ::protozero::ConstBytes recovered_trace_info() const { return at<138>().as_bytes(); } bool has_for_testing() const { return at<900>().valid(); } ::protozero::ConstBytes for_testing() const { return at<900>().as_bytes(); } bool has_trusted_uid() const { return at<3>().valid(); } @@ -11755,6 +12295,7 @@ class TracePacket : public ::protozero::Message { kCpuPerUidDataFieldNumber = 119, kUserListFieldNumber = 123, kJournaldEventFieldNumber = 132, + kRecoveredTraceInfoFieldNumber = 138, kForTestingFieldNumber = 900, kTrustedUidFieldNumber = 3, kTrustedPacketSequenceIdFieldNumber = 10, @@ -13036,6 +13577,20 @@ class TracePacket : public ::protozero::Message { } + using FieldMetadata_RecoveredTraceInfo = + ::protozero::proto_utils::FieldMetadata< + 138, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RecoveredTraceInfo, + TracePacket>; + + static constexpr FieldMetadata_RecoveredTraceInfo kRecoveredTraceInfo{}; + template T* set_recovered_trace_info() { + return BeginNestedMessage(138); + } + + using FieldMetadata_ForTesting = ::protozero::proto_utils::FieldMetadata< 900, @@ -13714,6 +14269,15 @@ class DataSource : public DataSourceBase { // This can be useful for splitting protos that might grow very large. uint64_t written() { return tls_inst_->trace_writer->written(); } + // Returns the number of times the trace writer for the current thread and + // data source instance entered a mode in which it started dropping data + // (e.g. because the shared memory buffer was exhausted and the buffer + // exhausted policy is kDrop). Note that this does *not* necessarily + // correspond to the number of dropped packets, as multiple packets can be + // dropped on each entry into the drop mode. A non-zero (or increased) + // value indicates that some data written on this thread was lost. + uint64_t drop_count() { return tls_inst_->trace_writer->drop_count(); } + // Returns a RAII handle to access the data source instance, guaranteeing // that it won't be deleted on another thread (because of trace stopping) // while accessing it from within the Trace() lambda. @@ -13870,6 +14434,7 @@ class DataSource : public DataSourceBase { DerivedDataSource::GetDefaultBufferExhaustedPolicy(); params.buffer_exhausted_policy_configurable = DerivedDataSource::kBufferExhaustedPolicyConfigurable; + params.supports_tracing_v2 = true; return Helper::type().Register( descriptor, factory, params, no_flush, GetCreateTlsFn( @@ -14675,9 +15240,20 @@ class RootMessage : public T { RootMessage(RootMessage&&) = delete; RootMessage& operator=(RootMessage&&) = delete; - void Reset(ScatteredStreamWriter* writer) { + // Resets the root and its arena for output to |writer| with |encoding|. + // See Message::Encoding. + void Reset(ScatteredStreamWriter* writer, Message::Encoding encoding) { root_arena_.Reset(); - Message::Reset(writer, &root_arena_); + Message::Reset(writer, &root_arena_, encoding); + } + + // Convenience wrapper for the default length-delimited encoding. + // + // TODO(sashwinbalaji): Remove this overload once Chromium calls the one + // above, for example in: + // https://crsrc.org/c/services/tracing/public/cpp/perfetto/traced_value_proto_writer.cc + void Reset(ScatteredStreamWriter* writer) { + Reset(writer, Message::Encoding::kLengthDelimited); } private: @@ -14765,6 +15341,10 @@ class PERFETTO_EXPORT_COMPONENT ScatteredHeapBuffer // writer has written. const std::vector& GetSlices(); + // Like GetSlices() but hands them over, leaving this empty. The writer is + // reset so it no longer points into the handed-over memory. + std::vector TakeSlices(); + // Stitch all the slices into a single contiguous buffer. std::vector StitchSlices(); @@ -14864,6 +15444,16 @@ class HeapBuffered { return shb_.GetSlices(); } + // Finalizes the message and hands over its slices, leaving this empty and + // reusable. + std::vector TakeSlices() { + msg_.Finalize(); + std::vector slices = shb_.TakeSlices(); + msg_.Reset(&writer_); + PERFETTO_DCHECK(empty()); + return slices; + } + void Reset() { shb_.Reset(); writer_.Reset(protozero::ContiguousMemoryRange{}); @@ -21791,7 +22381,7 @@ class FlowImpl { static PERFETTO_ALWAYS_INLINE inline FlowImpl ProcessScoped( uint64_t flow_id, const char* named_scope) { - return Global(flow_id, named_scope); + return Global(flow_id ^ Track::process_uuid, named_scope); } // Same as above, but construct an id from a pointer. @@ -29094,6 +29684,7 @@ class PERFETTO_EXPORT_COMPONENT SystemInfo : public ::protozero::CppMessageObj { kAndroidBuildFingerprintFieldNumber = 2, kAndroidDeviceManufacturerFieldNumber = 14, kAndroidSocModelFieldNumber = 9, + kDeviceTreeCompatiblesFieldNumber = 18, kAndroidGuestSocModelFieldNumber = 13, kAndroidHardwareRevisionFieldNumber = 10, kAndroidStorageModelFieldNumber = 11, @@ -29139,6 +29730,13 @@ class PERFETTO_EXPORT_COMPONENT SystemInfo : public ::protozero::CppMessageObj { const std::string& android_soc_model() const { return android_soc_model_; } void set_android_soc_model(const std::string& value) { android_soc_model_ = value; _has_field_.set(9); } + const std::vector& device_tree_compatibles() const { return device_tree_compatibles_; } + std::vector* mutable_device_tree_compatibles() { return &device_tree_compatibles_; } + int device_tree_compatibles_size() const { return static_cast(device_tree_compatibles_.size()); } + void clear_device_tree_compatibles() { device_tree_compatibles_.clear(); } + void add_device_tree_compatibles(std::string value) { device_tree_compatibles_.emplace_back(value); } + std::string* add_device_tree_compatibles() { device_tree_compatibles_.emplace_back(); return &device_tree_compatibles_.back(); } + bool has_android_guest_soc_model() const { return _has_field_[13]; } const std::string& android_guest_soc_model() const { return android_guest_soc_model_; } void set_android_guest_soc_model(const std::string& value) { android_guest_soc_model_ = value; _has_field_.set(13); } @@ -29196,6 +29794,7 @@ class PERFETTO_EXPORT_COMPONENT SystemInfo : public ::protozero::CppMessageObj { std::string android_build_fingerprint_{}; std::string android_device_manufacturer_{}; std::string android_soc_model_{}; + std::vector device_tree_compatibles_; std::string android_guest_soc_model_{}; std::string android_hardware_revision_{}; std::string android_storage_model_{}; @@ -29214,7 +29813,7 @@ class PERFETTO_EXPORT_COMPONENT SystemInfo : public ::protozero::CppMessageObj { // with future versions of .proto files. std::string unknown_fields_; - std::bitset<18> _has_field_{}; + std::bitset<19> _has_field_{}; }; @@ -29727,12 +30326,15 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp kChunksReadFieldNumber = 17, kChunksCommittedOutOfOrderFieldNumber = 11, kWriteWrapCountFieldNumber = 4, + kCompactionsFieldNumber = 23, + kCompactionsSkippedFieldNumber = 24, kPatchesSucceededFieldNumber = 5, kPatchesFailedFieldNumber = 6, kReadaheadsSucceededFieldNumber = 7, kReadaheadsFailedFieldNumber = 8, kAbiViolationsFieldNumber = 9, kTraceWriterPacketLossFieldNumber = 19, + kOversizedPacketsDroppedFieldNumber = 22, }; TraceStats_BufferStats(); @@ -29805,6 +30407,14 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp uint64_t write_wrap_count() const { return write_wrap_count_; } void set_write_wrap_count(uint64_t value) { write_wrap_count_ = value; _has_field_.set(4); } + bool has_compactions() const { return _has_field_[23]; } + uint64_t compactions() const { return compactions_; } + void set_compactions(uint64_t value) { compactions_ = value; _has_field_.set(23); } + + bool has_compactions_skipped() const { return _has_field_[24]; } + uint64_t compactions_skipped() const { return compactions_skipped_; } + void set_compactions_skipped(uint64_t value) { compactions_skipped_ = value; _has_field_.set(24); } + bool has_patches_succeeded() const { return _has_field_[5]; } uint64_t patches_succeeded() const { return patches_succeeded_; } void set_patches_succeeded(uint64_t value) { patches_succeeded_ = value; _has_field_.set(5); } @@ -29829,6 +30439,10 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp uint64_t trace_writer_packet_loss() const { return trace_writer_packet_loss_; } void set_trace_writer_packet_loss(uint64_t value) { trace_writer_packet_loss_ = value; _has_field_.set(19); } + bool has_oversized_packets_dropped() const { return _has_field_[22]; } + uint64_t oversized_packets_dropped() const { return oversized_packets_dropped_; } + void set_oversized_packets_dropped(uint64_t value) { oversized_packets_dropped_ = value; _has_field_.set(22); } + private: uint64_t buffer_size_{}; uint64_t bytes_written_{}; @@ -29844,18 +30458,21 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp uint64_t chunks_read_{}; uint64_t chunks_committed_out_of_order_{}; uint64_t write_wrap_count_{}; + uint64_t compactions_{}; + uint64_t compactions_skipped_{}; uint64_t patches_succeeded_{}; uint64_t patches_failed_{}; uint64_t readaheads_succeeded_{}; uint64_t readaheads_failed_{}; uint64_t abi_violations_{}; uint64_t trace_writer_packet_loss_{}; + uint64_t oversized_packets_dropped_{}; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<21> _has_field_{}; + std::bitset<25> _has_field_{}; }; } // namespace perfetto @@ -29977,17 +30594,7 @@ class TracingServiceState; class TracingServiceState_TracingSession; class TracingServiceState_DataSource; class DataSourceDescriptor; -class VmProgram; -class VmInstruction; -class VmOpDel; -class VmOpSet; -class VmOpMerge; -class VmOpRegLoad; -class VmOpSelect; -class VmOpSelect_PathComponent; class TracingServiceState_Producer; -enum VmInstruction_AbortLevel : int; -enum VmCursorEnum : int; } // namespace perfetto } // namespace protos } // namespace gen @@ -31993,6 +32600,10 @@ class DataSourceDescriptor : public ::protozero::Message { return BeginNestedMessage(10); } + void set_protovm_program_raw(const std::string& raw) { + return AppendBytes(10, raw.data(), raw.size()); + } + using FieldMetadata_GpuCounterDescriptor = ::protozero::proto_utils::FieldMetadata< @@ -36896,7 +37507,7 @@ namespace perfetto { namespace protos { namespace pbzero { -class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder { +class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder { public: SystemInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit SystemInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -36909,6 +37520,8 @@ class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder().as_string(); } bool has_android_soc_model() const { return at<9>().valid(); } ::protozero::ConstChars android_soc_model() const { return at<9>().as_string(); } + bool has_device_tree_compatibles() const { return at<18>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> device_tree_compatibles() const { return GetRepeated<::protozero::ConstChars>(18); } bool has_android_guest_soc_model() const { return at<13>().valid(); } ::protozero::ConstChars android_guest_soc_model() const { return at<13>().as_string(); } bool has_android_hardware_revision() const { return at<10>().valid(); } @@ -36945,6 +37558,7 @@ class SystemInfo : public ::protozero::Message { kAndroidBuildFingerprintFieldNumber = 2, kAndroidDeviceManufacturerFieldNumber = 14, kAndroidSocModelFieldNumber = 9, + kDeviceTreeCompatiblesFieldNumber = 18, kAndroidGuestSocModelFieldNumber = 13, kAndroidHardwareRevisionFieldNumber = 10, kAndroidStorageModelFieldNumber = 11, @@ -37048,6 +37662,30 @@ class SystemInfo : public ::protozero::Message { ::Append(*this, field_id, value); } + using FieldMetadata_DeviceTreeCompatibles = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SystemInfo>; + + static constexpr FieldMetadata_DeviceTreeCompatibles kDeviceTreeCompatibles{}; + void add_device_tree_compatibles(const char* data, size_t size) { + AppendBytes(FieldMetadata_DeviceTreeCompatibles::kFieldId, data, size); + } + void add_device_tree_compatibles(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DeviceTreeCompatibles::kFieldId, chars.data, chars.size); + } + void add_device_tree_compatibles(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DeviceTreeCompatibles::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + using FieldMetadata_AndroidGuestSocModel = ::protozero::proto_utils::FieldMetadata< 13, @@ -38277,7 +38915,7 @@ class TraceStats_WriterStats : public ::protozero::Message { } }; -class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder { +class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder { public: TraceStats_BufferStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit TraceStats_BufferStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -38310,6 +38948,10 @@ class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder().as_uint64(); } bool has_write_wrap_count() const { return at<4>().valid(); } uint64_t write_wrap_count() const { return at<4>().as_uint64(); } + bool has_compactions() const { return at<23>().valid(); } + uint64_t compactions() const { return at<23>().as_uint64(); } + bool has_compactions_skipped() const { return at<24>().valid(); } + uint64_t compactions_skipped() const { return at<24>().as_uint64(); } bool has_patches_succeeded() const { return at<5>().valid(); } uint64_t patches_succeeded() const { return at<5>().as_uint64(); } bool has_patches_failed() const { return at<6>().valid(); } @@ -38322,6 +38964,8 @@ class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder().as_uint64(); } bool has_trace_writer_packet_loss() const { return at<19>().valid(); } uint64_t trace_writer_packet_loss() const { return at<19>().as_uint64(); } + bool has_oversized_packets_dropped() const { return at<22>().valid(); } + uint64_t oversized_packets_dropped() const { return at<22>().as_uint64(); } }; class TraceStats_BufferStats : public ::protozero::Message { @@ -38342,12 +38986,15 @@ class TraceStats_BufferStats : public ::protozero::Message { kChunksReadFieldNumber = 17, kChunksCommittedOutOfOrderFieldNumber = 11, kWriteWrapCountFieldNumber = 4, + kCompactionsFieldNumber = 23, + kCompactionsSkippedFieldNumber = 24, kPatchesSucceededFieldNumber = 5, kPatchesFailedFieldNumber = 6, kReadaheadsSucceededFieldNumber = 7, kReadaheadsFailedFieldNumber = 8, kAbiViolationsFieldNumber = 9, kTraceWriterPacketLossFieldNumber = 19, + kOversizedPacketsDroppedFieldNumber = 22, }; static constexpr const char* GetName() { return ".perfetto.protos.TraceStats.BufferStats"; } @@ -38604,6 +39251,42 @@ class TraceStats_BufferStats : public ::protozero::Message { ::Append(*this, field_id, value); } + using FieldMetadata_Compactions = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_Compactions kCompactions{}; + void set_compactions(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Compactions::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CompactionsSkipped = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_CompactionsSkipped kCompactionsSkipped{}; + void set_compactions_skipped(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CompactionsSkipped::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + using FieldMetadata_PatchesSucceeded = ::protozero::proto_utils::FieldMetadata< 5, @@ -38711,6 +39394,24 @@ class TraceStats_BufferStats : public ::protozero::Message { ::protozero::proto_utils::ProtoSchemaType::kUint64> ::Append(*this, field_id, value); } + + using FieldMetadata_OversizedPacketsDropped = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_OversizedPacketsDropped kOversizedPacketsDropped{}; + void set_oversized_packets_dropped(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OversizedPacketsDropped::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } }; } // Namespace. @@ -40262,6 +40963,76 @@ class PERFETTO_EXPORT_COMPONENT AndroidPolledStateConfig : public ::protozero::C } // namespace gen #endif // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_POLLED_STATE_CONFIG_PROTO_CPP_H_ +// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_process_state_config.gen.h +// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_PROCESS_STATE_CONFIG_PROTO_CPP_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_PROCESS_STATE_CONFIG_PROTO_CPP_H_ + +#include +#include +#include +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h" +// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h" +// gen_amalgamated expanded: #include "perfetto/base/export.h" + +namespace perfetto { +namespace protos { +namespace gen { +class AndroidProcessStateConfig; +} // namespace perfetto +} // namespace protos +} // namespace gen + +namespace protozero { +class Message; +} // namespace protozero + +namespace perfetto { +namespace protos { +namespace gen { + +class PERFETTO_EXPORT_COMPONENT AndroidProcessStateConfig : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + kDumpProcessMetadataFieldNumber = 1, + }; + + AndroidProcessStateConfig(); + ~AndroidProcessStateConfig() override; + AndroidProcessStateConfig(AndroidProcessStateConfig&&) noexcept; + AndroidProcessStateConfig& operator=(AndroidProcessStateConfig&&); + AndroidProcessStateConfig(const AndroidProcessStateConfig&); + AndroidProcessStateConfig& operator=(const AndroidProcessStateConfig&); + bool operator==(const AndroidProcessStateConfig&) const; + bool operator!=(const AndroidProcessStateConfig& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_dump_process_metadata() const { return _has_field_[1]; } + bool dump_process_metadata() const { return dump_process_metadata_; } + void set_dump_process_metadata(bool value) { dump_process_metadata_ = value; _has_field_.set(1); } + + private: + bool dump_process_metadata_{}; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<2> _has_field_{}; +}; + +} // namespace perfetto +} // namespace protos +} // namespace gen + +#endif // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_PROCESS_STATE_CONFIG_PROTO_CPP_H_ // gen_amalgamated begin header: gen/protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin #ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_SDK_SYSPROP_GUARD_CONFIG_PROTO_CPP_H_ @@ -42612,6 +43383,7 @@ class PERFETTO_EXPORT_COMPONENT GpuRenderStagesConfig : public ::protozero::CppM kFullLoadstoreFieldNumber = 1, kLowOverheadFieldNumber = 2, kTraceMetricsFieldNumber = 3, + kDrawcallStagesFieldNumber = 4, }; GpuRenderStagesConfig(); @@ -42643,16 +43415,21 @@ class PERFETTO_EXPORT_COMPONENT GpuRenderStagesConfig : public ::protozero::CppM void add_trace_metrics(std::string value) { trace_metrics_.emplace_back(value); } std::string* add_trace_metrics() { trace_metrics_.emplace_back(); return &trace_metrics_.back(); } + bool has_drawcall_stages() const { return _has_field_[4]; } + bool drawcall_stages() const { return drawcall_stages_; } + void set_drawcall_stages(bool value) { drawcall_stages_ = value; _has_field_.set(4); } + private: bool full_loadstore_{}; bool low_overhead_{}; std::vector trace_metrics_; + bool drawcall_stages_{}; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<4> _has_field_{}; + std::bitset<5> _has_field_{}; }; } // namespace perfetto @@ -44262,6 +45039,9 @@ namespace protos { namespace gen { class RedactionRule; class SmapsConfig; +class ProcessSmapsConfig; +class ProcessSmapsConfig_Scope; +class ProcessSmapsConfig_Scope_UidRange; enum RedactionRule_MatchMode : int; enum SmapsConfig_VmaField : int; } // namespace perfetto @@ -44436,6 +45216,154 @@ class PERFETTO_EXPORT_COMPONENT SmapsConfig : public ::protozero::CppMessageObj std::bitset<4> _has_field_{}; }; + +class PERFETTO_EXPORT_COMPONENT ProcessSmapsConfig : public ::protozero::CppMessageObj { + public: + using Scope = ProcessSmapsConfig_Scope; + enum FieldNumbers { + kSmapsConfigFieldNumber = 1, + kScopeFieldNumber = 2, + kReadPeriodMsFieldNumber = 3, + kMaxProcessesPerPeriodFieldNumber = 4, + }; + + ProcessSmapsConfig(); + ~ProcessSmapsConfig() override; + ProcessSmapsConfig(ProcessSmapsConfig&&) noexcept; + ProcessSmapsConfig& operator=(ProcessSmapsConfig&&); + ProcessSmapsConfig(const ProcessSmapsConfig&); + ProcessSmapsConfig& operator=(const ProcessSmapsConfig&); + bool operator==(const ProcessSmapsConfig&) const; + bool operator!=(const ProcessSmapsConfig& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_smaps_config() const { return _has_field_[1]; } + const SmapsConfig& smaps_config() const { return *smaps_config_; } + SmapsConfig* mutable_smaps_config() { _has_field_.set(1); return smaps_config_.get(); } + + bool has_scope() const { return _has_field_[2]; } + const ProcessSmapsConfig_Scope& scope() const { return *scope_; } + ProcessSmapsConfig_Scope* mutable_scope() { _has_field_.set(2); return scope_.get(); } + + bool has_read_period_ms() const { return _has_field_[3]; } + uint32_t read_period_ms() const { return read_period_ms_; } + void set_read_period_ms(uint32_t value) { read_period_ms_ = value; _has_field_.set(3); } + + bool has_max_processes_per_period() const { return _has_field_[4]; } + uint32_t max_processes_per_period() const { return max_processes_per_period_; } + void set_max_processes_per_period(uint32_t value) { max_processes_per_period_ = value; _has_field_.set(4); } + + private: + ::protozero::CopyablePtr smaps_config_; + ::protozero::CopyablePtr scope_; + uint32_t read_period_ms_{}; + uint32_t max_processes_per_period_{}; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<5> _has_field_{}; +}; + + +class PERFETTO_EXPORT_COMPONENT ProcessSmapsConfig_Scope : public ::protozero::CppMessageObj { + public: + using UidRange = ProcessSmapsConfig_Scope_UidRange; + enum FieldNumbers { + kTargetCmdlineFieldNumber = 1, + kTargetUidFieldNumber = 2, + }; + + ProcessSmapsConfig_Scope(); + ~ProcessSmapsConfig_Scope() override; + ProcessSmapsConfig_Scope(ProcessSmapsConfig_Scope&&) noexcept; + ProcessSmapsConfig_Scope& operator=(ProcessSmapsConfig_Scope&&); + ProcessSmapsConfig_Scope(const ProcessSmapsConfig_Scope&); + ProcessSmapsConfig_Scope& operator=(const ProcessSmapsConfig_Scope&); + bool operator==(const ProcessSmapsConfig_Scope&) const; + bool operator!=(const ProcessSmapsConfig_Scope& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + const std::vector& target_cmdline() const { return target_cmdline_; } + std::vector* mutable_target_cmdline() { return &target_cmdline_; } + int target_cmdline_size() const { return static_cast(target_cmdline_.size()); } + void clear_target_cmdline() { target_cmdline_.clear(); } + void add_target_cmdline(std::string value) { target_cmdline_.emplace_back(value); } + std::string* add_target_cmdline() { target_cmdline_.emplace_back(); return &target_cmdline_.back(); } + + const std::vector& target_uid() const { return target_uid_; } + std::vector* mutable_target_uid() { return &target_uid_; } + int target_uid_size() const; + void clear_target_uid(); + ProcessSmapsConfig_Scope_UidRange* add_target_uid(); + + private: + std::vector target_cmdline_; + std::vector target_uid_; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<3> _has_field_{}; +}; + + +class PERFETTO_EXPORT_COMPONENT ProcessSmapsConfig_Scope_UidRange : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + kMinUidFieldNumber = 1, + kMaxUidFieldNumber = 2, + kAndroidMatchAcrossProfilesFieldNumber = 3, + }; + + ProcessSmapsConfig_Scope_UidRange(); + ~ProcessSmapsConfig_Scope_UidRange() override; + ProcessSmapsConfig_Scope_UidRange(ProcessSmapsConfig_Scope_UidRange&&) noexcept; + ProcessSmapsConfig_Scope_UidRange& operator=(ProcessSmapsConfig_Scope_UidRange&&); + ProcessSmapsConfig_Scope_UidRange(const ProcessSmapsConfig_Scope_UidRange&); + ProcessSmapsConfig_Scope_UidRange& operator=(const ProcessSmapsConfig_Scope_UidRange&); + bool operator==(const ProcessSmapsConfig_Scope_UidRange&) const; + bool operator!=(const ProcessSmapsConfig_Scope_UidRange& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_min_uid() const { return _has_field_[1]; } + uint32_t min_uid() const { return min_uid_; } + void set_min_uid(uint32_t value) { min_uid_ = value; _has_field_.set(1); } + + bool has_max_uid() const { return _has_field_[2]; } + uint32_t max_uid() const { return max_uid_; } + void set_max_uid(uint32_t value) { max_uid_ = value; _has_field_.set(2); } + + bool has_android_match_across_profiles() const { return _has_field_[3]; } + bool android_match_across_profiles() const { return android_match_across_profiles_; } + void set_android_match_across_profiles(bool value) { android_match_across_profiles_ = value; _has_field_.set(3); } + + private: + uint32_t min_uid_{}; + uint32_t max_uid_{}; + bool android_match_across_profiles_{}; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<4> _has_field_{}; +}; + } // namespace perfetto } // namespace protos } // namespace gen @@ -46499,6 +47427,82 @@ class PERFETTO_EXPORT_COMPONENT ChromiumHistogramSamplesConfig_HistogramSample : } // namespace gen #endif // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_HISTOGRAM_SAMPLES_PROTO_CPP_H_ +// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/sampling_heap_profiler.gen.h +// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SAMPLING_HEAP_PROFILER_PROTO_CPP_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SAMPLING_HEAP_PROFILER_PROTO_CPP_H_ + +#include +#include +#include +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h" +// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h" +// gen_amalgamated expanded: #include "perfetto/base/export.h" + +namespace perfetto { +namespace protos { +namespace gen { +class ChromiumSamplingHeapProfilerConfig; +} // namespace perfetto +} // namespace protos +} // namespace gen + +namespace protozero { +class Message; +} // namespace protozero + +namespace perfetto { +namespace protos { +namespace gen { + +class PERFETTO_EXPORT_COMPONENT ChromiumSamplingHeapProfilerConfig : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + kSamplingIntervalBytesFieldNumber = 1, + kSamplingIntervalMsFieldNumber = 2, + }; + + ChromiumSamplingHeapProfilerConfig(); + ~ChromiumSamplingHeapProfilerConfig() override; + ChromiumSamplingHeapProfilerConfig(ChromiumSamplingHeapProfilerConfig&&) noexcept; + ChromiumSamplingHeapProfilerConfig& operator=(ChromiumSamplingHeapProfilerConfig&&); + ChromiumSamplingHeapProfilerConfig(const ChromiumSamplingHeapProfilerConfig&); + ChromiumSamplingHeapProfilerConfig& operator=(const ChromiumSamplingHeapProfilerConfig&); + bool operator==(const ChromiumSamplingHeapProfilerConfig&) const; + bool operator!=(const ChromiumSamplingHeapProfilerConfig& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_sampling_interval_bytes() const { return _has_field_[1]; } + uint64_t sampling_interval_bytes() const { return sampling_interval_bytes_; } + void set_sampling_interval_bytes(uint64_t value) { sampling_interval_bytes_ = value; _has_field_.set(1); } + + bool has_sampling_interval_ms() const { return _has_field_[2]; } + uint32_t sampling_interval_ms() const { return sampling_interval_ms_; } + void set_sampling_interval_ms(uint32_t value) { sampling_interval_ms_ = value; _has_field_.set(2); } + + private: + uint64_t sampling_interval_bytes_{}; + uint32_t sampling_interval_ms_{}; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<3> _has_field_{}; +}; + +} // namespace perfetto +} // namespace protos +} // namespace gen + +#endif // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SAMPLING_HEAP_PROFILER_PROTO_CPP_H_ // gen_amalgamated begin header: gen/protos/perfetto/config/chrome/scenario_config.gen.h // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin #ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SCENARIO_CONFIG_PROTO_CPP_H_ @@ -46553,6 +47557,8 @@ class InterceptorConfig; class ConsoleConfig; class ChromeConfig; class SystemInfoConfig; +class DataSourceConfig_ExperimentalTracingV2Config; +class DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption; class ProtoVmConfig; class TraceConfig_BufferConfig; enum TraceConfig_LockdownModeOperation : int; @@ -46974,6 +47980,76 @@ class PERFETTO_EXPORT_COMPONENT NestedScenarioConfig : public ::protozero::CppMe } // namespace gen #endif // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SCENARIO_CONFIG_PROTO_CPP_H_ +// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/stack_sampling_profiler.gen.h +// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_STACK_SAMPLING_PROFILER_PROTO_CPP_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_STACK_SAMPLING_PROFILER_PROTO_CPP_H_ + +#include +#include +#include +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h" +// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h" +// gen_amalgamated expanded: #include "perfetto/base/export.h" + +namespace perfetto { +namespace protos { +namespace gen { +class ChromiumStackSamplingProfilerConfig; +} // namespace perfetto +} // namespace protos +} // namespace gen + +namespace protozero { +class Message; +} // namespace protozero + +namespace perfetto { +namespace protos { +namespace gen { + +class PERFETTO_EXPORT_COMPONENT ChromiumStackSamplingProfilerConfig : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + kSamplingIntervalMsFieldNumber = 1, + }; + + ChromiumStackSamplingProfilerConfig(); + ~ChromiumStackSamplingProfilerConfig() override; + ChromiumStackSamplingProfilerConfig(ChromiumStackSamplingProfilerConfig&&) noexcept; + ChromiumStackSamplingProfilerConfig& operator=(ChromiumStackSamplingProfilerConfig&&); + ChromiumStackSamplingProfilerConfig(const ChromiumStackSamplingProfilerConfig&); + ChromiumStackSamplingProfilerConfig& operator=(const ChromiumStackSamplingProfilerConfig&); + bool operator==(const ChromiumStackSamplingProfilerConfig&) const; + bool operator!=(const ChromiumStackSamplingProfilerConfig& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_sampling_interval_ms() const { return _has_field_[1]; } + uint32_t sampling_interval_ms() const { return sampling_interval_ms_; } + void set_sampling_interval_ms(uint32_t value) { sampling_interval_ms_ = value; _has_field_.set(1); } + + private: + uint32_t sampling_interval_ms_{}; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<2> _has_field_{}; +}; + +} // namespace perfetto +} // namespace protos +} // namespace gen + +#endif // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_STACK_SAMPLING_PROFILER_PROTO_CPP_H_ // gen_amalgamated begin header: gen/protos/perfetto/config/chrome/system_metrics.gen.h // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin #ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SYSTEM_METRICS_PROTO_CPP_H_ @@ -47139,6 +48215,7 @@ namespace perfetto { namespace protos { namespace gen { class EtwConfig; +class EtwConfig_DebugId; enum EtwConfig_KernelFlag : int; } // namespace perfetto } // namespace protos @@ -47158,6 +48235,7 @@ enum EtwConfig_KernelFlag : int { class PERFETTO_EXPORT_COMPONENT EtwConfig : public ::protozero::CppMessageObj { public: + using DebugId = EtwConfig_DebugId; using KernelFlag = EtwConfig_KernelFlag; static constexpr auto CSWITCH = EtwConfig_KernelFlag_CSWITCH; static constexpr auto DISPATCHER = EtwConfig_KernelFlag_DISPATCHER; @@ -47171,6 +48249,7 @@ class PERFETTO_EXPORT_COMPONENT EtwConfig : public ::protozero::CppMessageObj { kStackSamplingEventsFieldNumber = 5, kDiskProviderEventsFieldNumber = 6, kSystemIoProviderEventsFieldNumber = 7, + kStackSamplingDebugIdsFieldNumber = 8, }; EtwConfig(); @@ -47236,6 +48315,12 @@ class PERFETTO_EXPORT_COMPONENT EtwConfig : public ::protozero::CppMessageObj { void add_system_io_provider_events(std::string value) { system_io_provider_events_.emplace_back(value); } std::string* add_system_io_provider_events() { system_io_provider_events_.emplace_back(); return &system_io_provider_events_.back(); } + const std::vector& stack_sampling_debug_ids() const { return stack_sampling_debug_ids_; } + std::vector* mutable_stack_sampling_debug_ids() { return &stack_sampling_debug_ids_; } + int stack_sampling_debug_ids_size() const; + void clear_stack_sampling_debug_ids(); + EtwConfig_DebugId* add_stack_sampling_debug_ids(); + private: std::vector kernel_flags_; std::vector scheduler_provider_events_; @@ -47244,12 +48329,54 @@ class PERFETTO_EXPORT_COMPONENT EtwConfig : public ::protozero::CppMessageObj { std::vector stack_sampling_events_; std::vector disk_provider_events_; std::vector system_io_provider_events_; + std::vector stack_sampling_debug_ids_; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<8> _has_field_{}; + std::bitset<9> _has_field_{}; +}; + + +class PERFETTO_EXPORT_COMPONENT EtwConfig_DebugId : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + kPathFieldNumber = 1, + kDebugIdFieldNumber = 2, + }; + + EtwConfig_DebugId(); + ~EtwConfig_DebugId() override; + EtwConfig_DebugId(EtwConfig_DebugId&&) noexcept; + EtwConfig_DebugId& operator=(EtwConfig_DebugId&&); + EtwConfig_DebugId(const EtwConfig_DebugId&); + EtwConfig_DebugId& operator=(const EtwConfig_DebugId&); + bool operator==(const EtwConfig_DebugId&) const; + bool operator!=(const EtwConfig_DebugId& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_path() const { return _has_field_[1]; } + const std::string& path() const { return path_; } + void set_path(const std::string& value) { path_ = value; _has_field_.set(1); } + + bool has_debug_id() const { return _has_field_[2]; } + const std::string& debug_id() const { return debug_id_; } + void set_debug_id(const std::string& value) { debug_id_ = value; _has_field_.set(2); } + + private: + std::string path_{}; + std::string debug_id_{}; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<3> _has_field_{}; }; } // namespace perfetto @@ -47384,6 +48511,8 @@ class InterceptorConfig; class ConsoleConfig; class ChromeConfig; class SystemInfoConfig; +class DataSourceConfig_ExperimentalTracingV2Config; +class DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption; class ProtoVmConfig; class TraceConfig_BufferConfig; enum TraceConfig_LockdownModeOperation : int; @@ -48524,6 +49653,67 @@ class AndroidPolledStateConfig : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/config/android/android_process_state_config.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_PROCESS_STATE_CONFIG_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_ANDROID_PROCESS_STATE_CONFIG_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class AndroidProcessStateConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidProcessStateConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidProcessStateConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidProcessStateConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dump_process_metadata() const { return at<1>().valid(); } + bool dump_process_metadata() const { return at<1>().as_bool(); } +}; + +class AndroidProcessStateConfig : public ::protozero::Message { + public: + using Decoder = AndroidProcessStateConfig_Decoder; + enum : int32_t { + kDumpProcessMetadataFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidProcessStateConfig"; } + + + using FieldMetadata_DumpProcessMetadata = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidProcessStateConfig>; + + static constexpr FieldMetadata_DumpProcessMetadata kDumpProcessMetadata{}; + void set_dump_process_metadata(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DumpProcessMetadata::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -52309,7 +53499,7 @@ namespace perfetto { namespace protos { namespace pbzero { -class GpuRenderStagesConfig_Decoder : public ::protozero::TypedProtoDecoder { +class GpuRenderStagesConfig_Decoder : public ::protozero::TypedProtoDecoder { public: GpuRenderStagesConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit GpuRenderStagesConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -52320,6 +53510,8 @@ class GpuRenderStagesConfig_Decoder : public ::protozero::TypedProtoDecoder().as_bool(); } bool has_trace_metrics() const { return at<3>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstChars> trace_metrics() const { return GetRepeated<::protozero::ConstChars>(3); } + bool has_drawcall_stages() const { return at<4>().valid(); } + bool drawcall_stages() const { return at<4>().as_bool(); } }; class GpuRenderStagesConfig : public ::protozero::Message { @@ -52329,6 +53521,7 @@ class GpuRenderStagesConfig : public ::protozero::Message { kFullLoadstoreFieldNumber = 1, kLowOverheadFieldNumber = 2, kTraceMetricsFieldNumber = 3, + kDrawcallStagesFieldNumber = 4, }; static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStagesConfig"; } @@ -52392,6 +53585,24 @@ class GpuRenderStagesConfig : public ::protozero::Message { ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } + + using FieldMetadata_DrawcallStages = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + GpuRenderStagesConfig>; + + static constexpr FieldMetadata_DrawcallStages kDrawcallStages{}; + void set_drawcall_stages(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DrawcallStages::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } }; } // Namespace. @@ -55432,7 +56643,10 @@ class PerfEventConfig_CallstackSampling : public ::protozero::Message { namespace perfetto { namespace protos { namespace pbzero { +class ProcessSmapsConfig_Scope; +class ProcessSmapsConfig_Scope_UidRange; class RedactionRule; +class SmapsConfig; namespace perfetto_pbzero_enum_RedactionRule { enum MatchMode : int32_t; } // namespace perfetto_pbzero_enum_RedactionRule @@ -55807,6 +57021,239 @@ class SmapsConfig : public ::protozero::Message { }; +class ProcessSmapsConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessSmapsConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessSmapsConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessSmapsConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_smaps_config() const { return at<1>().valid(); } + ::protozero::ConstBytes smaps_config() const { return at<1>().as_bytes(); } + bool has_scope() const { return at<2>().valid(); } + ::protozero::ConstBytes scope() const { return at<2>().as_bytes(); } + bool has_read_period_ms() const { return at<3>().valid(); } + uint32_t read_period_ms() const { return at<3>().as_uint32(); } + bool has_max_processes_per_period() const { return at<4>().valid(); } + uint32_t max_processes_per_period() const { return at<4>().as_uint32(); } +}; + +class ProcessSmapsConfig : public ::protozero::Message { + public: + using Decoder = ProcessSmapsConfig_Decoder; + enum : int32_t { + kSmapsConfigFieldNumber = 1, + kScopeFieldNumber = 2, + kReadPeriodMsFieldNumber = 3, + kMaxProcessesPerPeriodFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessSmapsConfig"; } + + using Scope = ::perfetto::protos::pbzero::ProcessSmapsConfig_Scope; + + using FieldMetadata_SmapsConfig = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SmapsConfig, + ProcessSmapsConfig>; + + static constexpr FieldMetadata_SmapsConfig kSmapsConfig{}; + template T* set_smaps_config() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_Scope = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessSmapsConfig_Scope, + ProcessSmapsConfig>; + + static constexpr FieldMetadata_Scope kScope{}; + template T* set_scope() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_ReadPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProcessSmapsConfig>; + + static constexpr FieldMetadata_ReadPeriodMs kReadPeriodMs{}; + void set_read_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReadPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxProcessesPerPeriod = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProcessSmapsConfig>; + + static constexpr FieldMetadata_MaxProcessesPerPeriod kMaxProcessesPerPeriod{}; + void set_max_processes_per_period(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxProcessesPerPeriod::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ProcessSmapsConfig_Scope_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessSmapsConfig_Scope_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessSmapsConfig_Scope_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessSmapsConfig_Scope_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_target_cmdline() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_cmdline() const { return GetRepeated<::protozero::ConstChars>(1); } + bool has_target_uid() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> target_uid() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class ProcessSmapsConfig_Scope : public ::protozero::Message { + public: + using Decoder = ProcessSmapsConfig_Scope_Decoder; + enum : int32_t { + kTargetCmdlineFieldNumber = 1, + kTargetUidFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessSmapsConfig.Scope"; } + + using UidRange = ::perfetto::protos::pbzero::ProcessSmapsConfig_Scope_UidRange; + + using FieldMetadata_TargetCmdline = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProcessSmapsConfig_Scope>; + + static constexpr FieldMetadata_TargetCmdline kTargetCmdline{}; + void add_target_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_TargetCmdline::kFieldId, data, size); + } + void add_target_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TargetCmdline::kFieldId, chars.data, chars.size); + } + void add_target_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TargetCmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetUid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessSmapsConfig_Scope_UidRange, + ProcessSmapsConfig_Scope>; + + static constexpr FieldMetadata_TargetUid kTargetUid{}; + template T* add_target_uid() { + return BeginNestedMessage(2); + } + +}; + +class ProcessSmapsConfig_Scope_UidRange_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessSmapsConfig_Scope_UidRange_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessSmapsConfig_Scope_UidRange_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessSmapsConfig_Scope_UidRange_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_min_uid() const { return at<1>().valid(); } + uint32_t min_uid() const { return at<1>().as_uint32(); } + bool has_max_uid() const { return at<2>().valid(); } + uint32_t max_uid() const { return at<2>().as_uint32(); } + bool has_android_match_across_profiles() const { return at<3>().valid(); } + bool android_match_across_profiles() const { return at<3>().as_bool(); } +}; + +class ProcessSmapsConfig_Scope_UidRange : public ::protozero::Message { + public: + using Decoder = ProcessSmapsConfig_Scope_UidRange_Decoder; + enum : int32_t { + kMinUidFieldNumber = 1, + kMaxUidFieldNumber = 2, + kAndroidMatchAcrossProfilesFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessSmapsConfig.Scope.UidRange"; } + + + using FieldMetadata_MinUid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProcessSmapsConfig_Scope_UidRange>; + + static constexpr FieldMetadata_MinUid kMinUid{}; + void set_min_uid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MinUid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxUid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProcessSmapsConfig_Scope_UidRange>; + + static constexpr FieldMetadata_MaxUid kMaxUid{}; + void set_max_uid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxUid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AndroidMatchAcrossProfiles = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProcessSmapsConfig_Scope_UidRange>; + + static constexpr FieldMetadata_AndroidMatchAcrossProfiles kAndroidMatchAcrossProfiles{}; + void set_android_match_across_profiles(bool value) { + static constexpr uint32_t field_id = FieldMetadata_AndroidMatchAcrossProfiles::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -62257,6 +63704,88 @@ class ChromiumHistogramSamplesConfig_HistogramSample : public ::protozero::Messa } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/sampling_heap_profiler.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SAMPLING_HEAP_PROFILER_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_SAMPLING_HEAP_PROFILER_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class ChromiumSamplingHeapProfilerConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromiumSamplingHeapProfilerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromiumSamplingHeapProfilerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromiumSamplingHeapProfilerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_sampling_interval_bytes() const { return at<1>().valid(); } + uint64_t sampling_interval_bytes() const { return at<1>().as_uint64(); } + bool has_sampling_interval_ms() const { return at<2>().valid(); } + uint32_t sampling_interval_ms() const { return at<2>().as_uint32(); } +}; + +class ChromiumSamplingHeapProfilerConfig : public ::protozero::Message { + public: + using Decoder = ChromiumSamplingHeapProfilerConfig_Decoder; + enum : int32_t { + kSamplingIntervalBytesFieldNumber = 1, + kSamplingIntervalMsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromiumSamplingHeapProfilerConfig"; } + + + using FieldMetadata_SamplingIntervalBytes = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromiumSamplingHeapProfilerConfig>; + + static constexpr FieldMetadata_SamplingIntervalBytes kSamplingIntervalBytes{}; + void set_sampling_interval_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SamplingIntervalBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SamplingIntervalMs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromiumSamplingHeapProfilerConfig>; + + static constexpr FieldMetadata_SamplingIntervalMs kSamplingIntervalMs{}; + void set_sampling_interval_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SamplingIntervalMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -62958,6 +64487,67 @@ class TriggerRule_HistogramTrigger : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/config/chrome/stack_sampling_profiler.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_STACK_SAMPLING_PROFILER_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_CHROME_STACK_SAMPLING_PROFILER_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class ChromiumStackSamplingProfilerConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromiumStackSamplingProfilerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromiumStackSamplingProfilerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromiumStackSamplingProfilerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_sampling_interval_ms() const { return at<1>().valid(); } + uint32_t sampling_interval_ms() const { return at<1>().as_uint32(); } +}; + +class ChromiumStackSamplingProfilerConfig : public ::protozero::Message { + public: + using Decoder = ChromiumStackSamplingProfilerConfig_Decoder; + enum : int32_t { + kSamplingIntervalMsFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromiumStackSamplingProfilerConfig"; } + + + using FieldMetadata_SamplingIntervalMs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromiumStackSamplingProfilerConfig>; + + static constexpr FieldMetadata_SamplingIntervalMs kSamplingIntervalMs{}; + void set_sampling_interval_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SamplingIntervalMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -63129,14 +64719,19 @@ class AndroidInputEventConfig; class AndroidLogConfig; class AndroidPolledStateConfig; class AndroidPowerConfig; +class AndroidProcessStateConfig; class AndroidSdkSyspropGuardConfig; class AndroidSystemPropertyConfig; class AndroidUserListConfig; class AppWakelocksConfig; class ChromeConfig; class ChromiumHistogramSamplesConfig; +class ChromiumSamplingHeapProfilerConfig; +class ChromiumStackSamplingProfilerConfig; class ChromiumSystemMetricsConfig; class CpuPerUidConfig; +class DataSourceConfig_ExperimentalTracingV2Config; +class DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption; class DisplayVideoConfig; class EtwConfig; class FrozenFtraceConfig; @@ -63154,6 +64749,7 @@ class PackagesListConfig; class PerfEventConfig; class PixelModemConfig; class PriorityBoostConfig; +class ProcessSmapsConfig; class ProcessStatsConfig; class ProtoLogConfig; class ProtoVmConfig; @@ -63272,6 +64868,10 @@ class DataSourceConfig_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_protovm_config() const { return at<12>().valid(); } ::protozero::ConstBytes protovm_config() const { return at<12>().as_bytes(); } + bool has_supports_tracing_v2() const { return at<147>().valid(); } + bool supports_tracing_v2() const { return at<147>().as_bool(); } + bool has_experimental_tracing_v2() const { return at<148>().valid(); } + ::protozero::ConstBytes experimental_tracing_v2() const { return at<148>().as_bytes(); } bool has_ftrace_config() const { return at<100>().valid(); } ::protozero::ConstBytes ftrace_config() const { return at<100>().as_bytes(); } bool has_inode_file_config() const { return at<102>().valid(); } @@ -63356,6 +64956,14 @@ class DataSourceConfig_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_display_video_config() const { return at<142>().valid(); } ::protozero::ConstBytes display_video_config() const { return at<142>().as_bytes(); } + bool has_chromium_stack_sampling_profiler() const { return at<143>().valid(); } + ::protozero::ConstBytes chromium_stack_sampling_profiler() const { return at<143>().as_bytes(); } + bool has_chromium_sampling_heap_profiler() const { return at<144>().valid(); } + ::protozero::ConstBytes chromium_sampling_heap_profiler() const { return at<144>().as_bytes(); } + bool has_android_process_state_config() const { return at<145>().valid(); } + ::protozero::ConstBytes android_process_state_config() const { return at<145>().as_bytes(); } + bool has_process_smaps_config() const { return at<146>().valid(); } + ::protozero::ConstBytes process_smaps_config() const { return at<146>().as_bytes(); } bool has_qnx_config() const { return at<150>().valid(); } ::protozero::ConstBytes qnx_config() const { return at<150>().as_bytes(); } // field legacy_config omitted because its id is too high @@ -63378,6 +64986,8 @@ class DataSourceConfig : public ::protozero::Message { kBufferExhaustedPolicyFieldNumber = 9, kPriorityBoostFieldNumber = 10, kProtovmConfigFieldNumber = 12, + kSupportsTracingV2FieldNumber = 147, + kExperimentalTracingV2FieldNumber = 148, kFtraceConfigFieldNumber = 100, kInodeFileConfigFieldNumber = 102, kProcessStatsConfigFieldNumber = 103, @@ -63420,12 +65030,17 @@ class DataSourceConfig : public ::protozero::Message { kAndroidAflagsConfigFieldNumber = 140, kJournaldConfigFieldNumber = 141, kDisplayVideoConfigFieldNumber = 142, + kChromiumStackSamplingProfilerFieldNumber = 143, + kChromiumSamplingHeapProfilerFieldNumber = 144, + kAndroidProcessStateConfigFieldNumber = 145, + kProcessSmapsConfigFieldNumber = 146, kQnxConfigFieldNumber = 150, kLegacyConfigFieldNumber = 1000, kForTestingFieldNumber = 1001, }; static constexpr const char* GetName() { return ".perfetto.protos.DataSourceConfig"; } + using ExperimentalTracingV2Config = ::perfetto::protos::pbzero::DataSourceConfig_ExperimentalTracingV2Config; using SessionInitiator = ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator; static inline const char* SessionInitiator_Name(SessionInitiator value) { @@ -63663,6 +65278,38 @@ class DataSourceConfig : public ::protozero::Message { } + using FieldMetadata_SupportsTracingV2 = + ::protozero::proto_utils::FieldMetadata< + 147, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DataSourceConfig>; + + static constexpr FieldMetadata_SupportsTracingV2 kSupportsTracingV2{}; + void set_supports_tracing_v2(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SupportsTracingV2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExperimentalTracingV2 = + ::protozero::proto_utils::FieldMetadata< + 148, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DataSourceConfig_ExperimentalTracingV2Config, + DataSourceConfig>; + + static constexpr FieldMetadata_ExperimentalTracingV2 kExperimentalTracingV2{}; + template T* set_experimental_tracing_v2() { + return BeginNestedMessage(148); + } + + using FieldMetadata_FtraceConfig = ::protozero::proto_utils::FieldMetadata< 100, @@ -64407,6 +66054,78 @@ class DataSourceConfig : public ::protozero::Message { } + using FieldMetadata_ChromiumStackSamplingProfiler = + ::protozero::proto_utils::FieldMetadata< + 143, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromiumStackSamplingProfilerConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_ChromiumStackSamplingProfiler kChromiumStackSamplingProfiler{}; + template T* set_chromium_stack_sampling_profiler() { + return BeginNestedMessage(143); + } + + void set_chromium_stack_sampling_profiler_raw(const std::string& raw) { + return AppendBytes(143, raw.data(), raw.size()); + } + + + using FieldMetadata_ChromiumSamplingHeapProfiler = + ::protozero::proto_utils::FieldMetadata< + 144, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromiumSamplingHeapProfilerConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_ChromiumSamplingHeapProfiler kChromiumSamplingHeapProfiler{}; + template T* set_chromium_sampling_heap_profiler() { + return BeginNestedMessage(144); + } + + void set_chromium_sampling_heap_profiler_raw(const std::string& raw) { + return AppendBytes(144, raw.data(), raw.size()); + } + + + using FieldMetadata_AndroidProcessStateConfig = + ::protozero::proto_utils::FieldMetadata< + 145, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidProcessStateConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_AndroidProcessStateConfig kAndroidProcessStateConfig{}; + template T* set_android_process_state_config() { + return BeginNestedMessage(145); + } + + void set_android_process_state_config_raw(const std::string& raw) { + return AppendBytes(145, raw.data(), raw.size()); + } + + + using FieldMetadata_ProcessSmapsConfig = + ::protozero::proto_utils::FieldMetadata< + 146, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessSmapsConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_ProcessSmapsConfig kProcessSmapsConfig{}; + template T* set_process_smaps_config() { + return BeginNestedMessage(146); + } + + void set_process_smaps_config_raw(const std::string& raw) { + return AppendBytes(146, raw.data(), raw.size()); + } + + using FieldMetadata_QnxConfig = ::protozero::proto_utils::FieldMetadata< 150, @@ -64464,6 +66183,140 @@ class DataSourceConfig : public ::protozero::Message { }; +class DataSourceConfig_ExperimentalTracingV2Config_Decoder : public ::protozero::TypedProtoDecoder { + public: + DataSourceConfig_ExperimentalTracingV2Config_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DataSourceConfig_ExperimentalTracingV2Config_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DataSourceConfig_ExperimentalTracingV2Config_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_use_v2_probability_percent() const { return at<1>().valid(); } + uint32_t use_v2_probability_percent() const { return at<1>().as_uint32(); } + bool has_chunk_size_options() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> chunk_size_options() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_drain_occupancy_percent() const { return at<3>().valid(); } + int32_t drain_occupancy_percent() const { return at<3>().as_int32(); } +}; + +class DataSourceConfig_ExperimentalTracingV2Config : public ::protozero::Message { + public: + using Decoder = DataSourceConfig_ExperimentalTracingV2Config_Decoder; + enum : int32_t { + kUseV2ProbabilityPercentFieldNumber = 1, + kChunkSizeOptionsFieldNumber = 2, + kDrainOccupancyPercentFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DataSourceConfig.ExperimentalTracingV2Config"; } + + using ChunkSizeOption = ::perfetto::protos::pbzero::DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption; + + using FieldMetadata_UseV2ProbabilityPercent = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DataSourceConfig_ExperimentalTracingV2Config>; + + static constexpr FieldMetadata_UseV2ProbabilityPercent kUseV2ProbabilityPercent{}; + void set_use_v2_probability_percent(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_UseV2ProbabilityPercent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChunkSizeOptions = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption, + DataSourceConfig_ExperimentalTracingV2Config>; + + static constexpr FieldMetadata_ChunkSizeOptions kChunkSizeOptions{}; + template T* add_chunk_size_options() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_DrainOccupancyPercent = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DataSourceConfig_ExperimentalTracingV2Config>; + + static constexpr FieldMetadata_DrainOccupancyPercent kDrainOccupancyPercent{}; + void set_drain_occupancy_percent(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DrainOccupancyPercent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption_Decoder : public ::protozero::TypedProtoDecoder { + public: + DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_size_bytes() const { return at<1>().valid(); } + uint32_t size_bytes() const { return at<1>().as_uint32(); } + bool has_weight() const { return at<2>().valid(); } + uint32_t weight() const { return at<2>().as_uint32(); } +}; + +class DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption : public ::protozero::Message { + public: + using Decoder = DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption_Decoder; + enum : int32_t { + kSizeBytesFieldNumber = 1, + kWeightFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DataSourceConfig.ExperimentalTracingV2Config.ChunkSizeOption"; } + + + using FieldMetadata_SizeBytes = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption>; + + static constexpr FieldMetadata_SizeBytes kSizeBytes{}; + void set_size_bytes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SizeBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Weight = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption>; + + static constexpr FieldMetadata_Weight kWeight{}; + void set_weight(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Weight::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -64486,6 +66339,7 @@ class DataSourceConfig : public ::protozero::Message { namespace perfetto { namespace protos { namespace pbzero { +class EtwConfig_DebugId; namespace perfetto_pbzero_enum_EtwConfig { enum KernelFlag : int32_t; } // namespace perfetto_pbzero_enum_EtwConfig @@ -64523,7 +66377,7 @@ const char* EtwConfig_KernelFlag_Name(::perfetto::protos::pbzero::EtwConfig_Kern return "PBZERO_UNKNOWN_ENUM_VALUE"; } -class EtwConfig_Decoder : public ::protozero::TypedProtoDecoder { +class EtwConfig_Decoder : public ::protozero::TypedProtoDecoder { public: EtwConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit EtwConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -64542,6 +66396,8 @@ class EtwConfig_Decoder : public ::protozero::TypedProtoDecoder disk_provider_events() const { return GetRepeated<::protozero::ConstChars>(6); } bool has_system_io_provider_events() const { return at<7>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstChars> system_io_provider_events() const { return GetRepeated<::protozero::ConstChars>(7); } + bool has_stack_sampling_debug_ids() const { return at<8>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> stack_sampling_debug_ids() const { return GetRepeated<::protozero::ConstBytes>(8); } }; class EtwConfig : public ::protozero::Message { @@ -64555,9 +66411,11 @@ class EtwConfig : public ::protozero::Message { kStackSamplingEventsFieldNumber = 5, kDiskProviderEventsFieldNumber = 6, kSystemIoProviderEventsFieldNumber = 7, + kStackSamplingDebugIdsFieldNumber = 8, }; static constexpr const char* GetName() { return ".perfetto.protos.EtwConfig"; } + using DebugId = ::perfetto::protos::pbzero::EtwConfig_DebugId; using KernelFlag = ::perfetto::protos::pbzero::EtwConfig_KernelFlag; static inline const char* KernelFlag_Name(KernelFlag value) { @@ -64727,6 +66585,90 @@ class EtwConfig : public ::protozero::Message { ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } + + using FieldMetadata_StackSamplingDebugIds = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + EtwConfig_DebugId, + EtwConfig>; + + static constexpr FieldMetadata_StackSamplingDebugIds kStackSamplingDebugIds{}; + template T* add_stack_sampling_debug_ids() { + return BeginNestedMessage(8); + } + +}; + +class EtwConfig_DebugId_Decoder : public ::protozero::TypedProtoDecoder { + public: + EtwConfig_DebugId_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit EtwConfig_DebugId_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit EtwConfig_DebugId_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_path() const { return at<1>().valid(); } + ::protozero::ConstChars path() const { return at<1>().as_string(); } + bool has_debug_id() const { return at<2>().valid(); } + ::protozero::ConstChars debug_id() const { return at<2>().as_string(); } +}; + +class EtwConfig_DebugId : public ::protozero::Message { + public: + using Decoder = EtwConfig_DebugId_Decoder; + enum : int32_t { + kPathFieldNumber = 1, + kDebugIdFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.EtwConfig.DebugId"; } + + + using FieldMetadata_Path = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + EtwConfig_DebugId>; + + static constexpr FieldMetadata_Path kPath{}; + void set_path(const char* data, size_t size) { + AppendBytes(FieldMetadata_Path::kFieldId, data, size); + } + void set_path(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size); + } + void set_path(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DebugId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + EtwConfig_DebugId>; + + static constexpr FieldMetadata_DebugId kDebugId{}; + void set_debug_id(const char* data, size_t size) { + AppendBytes(FieldMetadata_DebugId::kFieldId, data, size); + } + void set_debug_id(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DebugId::kFieldId, chars.data, chars.size); + } + void set_debug_id(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DebugId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } }; } // Namespace. @@ -66064,13 +68006,15 @@ const char* TraceConfig_BufferConfig_ExperimentalMode_Name(::perfetto::protos::p return "PBZERO_UNKNOWN_ENUM_VALUE"; } -class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder { +class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder { public: TraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit TraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} explicit TraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} bool has_buffers() const { return at<1>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buffers() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_experimental_trace_buffer_v2_compaction() const { return at<50>().valid(); } + bool experimental_trace_buffer_v2_compaction() const { return at<50>().as_bool(); } bool has_data_sources() const { return at<2>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> data_sources() const { return GetRepeated<::protozero::ConstBytes>(2); } bool has_builtin_data_sources() const { return at<20>().valid(); } @@ -66153,6 +68097,8 @@ class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder().as_bool(); } bool has_trace_attributes() const { return at<48>().valid(); } ::protozero::ConstBytes trace_attributes() const { return at<48>().as_bytes(); } + bool has_persist_trace_across_reboots() const { return at<49>().valid(); } + bool persist_trace_across_reboots() const { return at<49>().as_bool(); } }; class TraceConfig : public ::protozero::Message { @@ -66160,6 +68106,7 @@ class TraceConfig : public ::protozero::Message { using Decoder = TraceConfig_Decoder; enum : int32_t { kBuffersFieldNumber = 1, + kExperimentalTraceBufferV2CompactionFieldNumber = 50, kDataSourcesFieldNumber = 2, kBuiltinDataSourcesFieldNumber = 20, kDurationMsFieldNumber = 3, @@ -66201,6 +68148,7 @@ class TraceConfig : public ::protozero::Message { kFflushPostWriteFieldNumber = 45, kTraceAllMachinesFieldNumber = 43, kTraceAttributesFieldNumber = 48, + kPersistTraceAcrossRebootsFieldNumber = 49, }; static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig"; } @@ -66273,6 +68221,24 @@ class TraceConfig : public ::protozero::Message { } + using FieldMetadata_ExperimentalTraceBufferV2Compaction = + ::protozero::proto_utils::FieldMetadata< + 50, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig>; + + static constexpr FieldMetadata_ExperimentalTraceBufferV2Compaction kExperimentalTraceBufferV2Compaction{}; + void set_experimental_trace_buffer_v2_compaction(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ExperimentalTraceBufferV2Compaction::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + using FieldMetadata_DataSources = ::protozero::proto_utils::FieldMetadata< 2, @@ -66974,6 +68940,24 @@ class TraceConfig : public ::protozero::Message { return BeginNestedMessage(48); } + + using FieldMetadata_PersistTraceAcrossReboots = + ::protozero::proto_utils::FieldMetadata< + 49, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig>; + + static constexpr FieldMetadata_PersistTraceAcrossReboots kPersistTraceAcrossReboots{}; + void set_persist_trace_across_reboots(bool value) { + static constexpr uint32_t field_id = FieldMetadata_PersistTraceAcrossReboots::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } }; class TraceConfig_SessionSemaphore_Decoder : public ::protozero::TypedProtoDecoder { @@ -71535,7 +73519,7 @@ class PackagesList : public ::protozero::Message { } }; -class PackagesList_PackageInfo_Decoder : public ::protozero::TypedProtoDecoder { +class PackagesList_PackageInfo_Decoder : public ::protozero::TypedProtoDecoder { public: PackagesList_PackageInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit PackagesList_PackageInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -71550,6 +73534,8 @@ class PackagesList_PackageInfo_Decoder : public ::protozero::TypedProtoDecoder().as_bool(); } bool has_version_code() const { return at<5>().valid(); } int64_t version_code() const { return at<5>().as_int64(); } + bool has_profileable() const { return at<6>().valid(); } + bool profileable() const { return at<6>().as_bool(); } }; class PackagesList_PackageInfo : public ::protozero::Message { @@ -71561,6 +73547,7 @@ class PackagesList_PackageInfo : public ::protozero::Message { kDebuggableFieldNumber = 3, kProfileableFromShellFieldNumber = 4, kVersionCodeFieldNumber = 5, + kProfileableFieldNumber = 6, }; static constexpr const char* GetName() { return ".perfetto.protos.PackagesList.PackageInfo"; } @@ -71660,6 +73647,24 @@ class PackagesList_PackageInfo : public ::protozero::Message { ::protozero::proto_utils::ProtoSchemaType::kInt64> ::Append(*this, field_id, value); } + + using FieldMetadata_Profileable = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + PackagesList_PackageInfo>; + + static constexpr FieldMetadata_Profileable kProfileable{}; + void set_profileable(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Profileable::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } }; } // Namespace. @@ -71793,6 +73798,151 @@ class PixelModemEvents : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/recovered_trace_info.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_RECOVERED_TRACE_INFO_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_RECOVERED_TRACE_INFO_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +namespace perfetto_pbzero_enum_RecoveredTraceInfo { +enum Reason : int32_t; +} // namespace perfetto_pbzero_enum_RecoveredTraceInfo +using RecoveredTraceInfo_Reason = perfetto_pbzero_enum_RecoveredTraceInfo::Reason; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +namespace perfetto_pbzero_enum_RecoveredTraceInfo { +enum Reason : int32_t { + REASON_UNSPECIFIED = 0, + REASON_UNEXPECTED_REBOOT = 1, +}; +} // namespace perfetto_pbzero_enum_RecoveredTraceInfo +using RecoveredTraceInfo_Reason = perfetto_pbzero_enum_RecoveredTraceInfo::Reason; + + +constexpr RecoveredTraceInfo_Reason RecoveredTraceInfo_Reason_MIN = RecoveredTraceInfo_Reason::REASON_UNSPECIFIED; +constexpr RecoveredTraceInfo_Reason RecoveredTraceInfo_Reason_MAX = RecoveredTraceInfo_Reason::REASON_UNEXPECTED_REBOOT; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* RecoveredTraceInfo_Reason_Name(::perfetto::protos::pbzero::RecoveredTraceInfo_Reason value) { + switch (value) { + case ::perfetto::protos::pbzero::RecoveredTraceInfo_Reason::REASON_UNSPECIFIED: + return "REASON_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::RecoveredTraceInfo_Reason::REASON_UNEXPECTED_REBOOT: + return "REASON_UNEXPECTED_REBOOT"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +class RecoveredTraceInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + RecoveredTraceInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RecoveredTraceInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RecoveredTraceInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_reason() const { return at<1>().valid(); } + int32_t reason() const { return at<1>().as_int32(); } + bool has_original_file_size_bytes() const { return at<2>().valid(); } + uint64_t original_file_size_bytes() const { return at<2>().as_uint64(); } + bool has_bytes_truncated() const { return at<3>().valid(); } + uint64_t bytes_truncated() const { return at<3>().as_uint64(); } +}; + +class RecoveredTraceInfo : public ::protozero::Message { + public: + using Decoder = RecoveredTraceInfo_Decoder; + enum : int32_t { + kReasonFieldNumber = 1, + kOriginalFileSizeBytesFieldNumber = 2, + kBytesTruncatedFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RecoveredTraceInfo"; } + + + using Reason = ::perfetto::protos::pbzero::RecoveredTraceInfo_Reason; + static inline const char* Reason_Name(Reason value) { + return ::perfetto::protos::pbzero::RecoveredTraceInfo_Reason_Name(value); + } + static inline const Reason REASON_UNSPECIFIED = Reason::REASON_UNSPECIFIED; + static inline const Reason REASON_UNEXPECTED_REBOOT = Reason::REASON_UNEXPECTED_REBOOT; + + using FieldMetadata_Reason = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + RecoveredTraceInfo_Reason, + RecoveredTraceInfo>; + + static constexpr FieldMetadata_Reason kReason{}; + void set_reason(RecoveredTraceInfo_Reason value) { + static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OriginalFileSizeBytes = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + RecoveredTraceInfo>; + + static constexpr FieldMetadata_OriginalFileSizeBytes kOriginalFileSizeBytes{}; + void set_original_file_size_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OriginalFileSizeBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BytesTruncated = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + RecoveredTraceInfo>; + + static constexpr FieldMetadata_BytesTruncated kBytesTruncated{}; + void set_bytes_truncated(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesTruncated::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -80223,6 +82373,8 @@ class KvmVcpuWakeupFtraceEvent; class KvmWfxArm64FtraceEvent; class LocalTimerEntryFtraceEvent; class LocalTimerExitFtraceEvent; +class LongIrqFtraceEvent; +class LongSoftirqFtraceEvent; class LowmemoryKillFtraceEvent; class LwisTracingMarkWriteFtraceEvent; class MaliGpuPowerStateFtraceEvent; @@ -80446,7 +82598,7 @@ namespace perfetto { namespace protos { namespace pbzero { -class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { +class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { public: FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -81645,6 +83797,10 @@ class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_psci_domain_idle_enter() const { return at<615>().valid(); } ::protozero::ConstBytes psci_domain_idle_enter() const { return at<615>().as_bytes(); } + bool has_long_irq() const { return at<616>().valid(); } + ::protozero::ConstBytes long_irq() const { return at<616>().as_bytes(); } + bool has_long_softirq() const { return at<617>().valid(); } + ::protozero::ConstBytes long_softirq() const { return at<617>().as_bytes(); } }; class FtraceEvent : public ::protozero::Message { @@ -82248,6 +84404,8 @@ class FtraceEvent : public ::protozero::Message { kDpuDispDpuLineUnderrunFieldNumber = 613, kPsciDomainIdleExitFieldNumber = 614, kPsciDomainIdleEnterFieldNumber = 615, + kLongIrqFieldNumber = 616, + kLongSoftirqFieldNumber = 617, }; static constexpr const char* GetName() { return ".perfetto.protos.FtraceEvent"; } @@ -90621,6 +92779,34 @@ class FtraceEvent : public ::protozero::Message { return BeginNestedMessage(615); } + + using FieldMetadata_LongIrq = + ::protozero::proto_utils::FieldMetadata< + 616, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LongIrqFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_LongIrq kLongIrq{}; + template T* set_long_irq() { + return BeginNestedMessage(616); + } + + + using FieldMetadata_LongSoftirq = + ::protozero::proto_utils::FieldMetadata< + 617, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LongSoftirqFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_LongSoftirq kLongSoftirq{}; + template T* set_long_softirq() { + return BeginNestedMessage(617); + } + }; } // Namespace. @@ -145757,6 +147943,188 @@ class SchedSwitchWithCtrsFtraceEvent : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/pixel_metrics.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PIXEL_METRICS_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_PIXEL_METRICS_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class LongSoftirqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + LongSoftirqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LongSoftirqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LongSoftirqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_vec_nr() const { return at<1>().valid(); } + int32_t vec_nr() const { return at<1>().as_int32(); } + bool has_latency() const { return at<2>().valid(); } + uint32_t latency() const { return at<2>().as_uint32(); } + bool has_count() const { return at<3>().valid(); } + uint32_t count() const { return at<3>().as_uint32(); } +}; + +class LongSoftirqFtraceEvent : public ::protozero::Message { + public: + using Decoder = LongSoftirqFtraceEvent_Decoder; + enum : int32_t { + kVecNrFieldNumber = 1, + kLatencyFieldNumber = 2, + kCountFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LongSoftirqFtraceEvent"; } + + + using FieldMetadata_VecNr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LongSoftirqFtraceEvent>; + + static constexpr FieldMetadata_VecNr kVecNr{}; + void set_vec_nr(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_VecNr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Latency = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LongSoftirqFtraceEvent>; + + static constexpr FieldMetadata_Latency kLatency{}; + void set_latency(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Latency::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Count = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LongSoftirqFtraceEvent>; + + static constexpr FieldMetadata_Count kCount{}; + void set_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class LongIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + LongIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LongIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LongIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_irq() const { return at<1>().valid(); } + int32_t irq() const { return at<1>().as_int32(); } + bool has_latency() const { return at<2>().valid(); } + uint32_t latency() const { return at<2>().as_uint32(); } + bool has_count() const { return at<3>().valid(); } + uint32_t count() const { return at<3>().as_uint32(); } +}; + +class LongIrqFtraceEvent : public ::protozero::Message { + public: + using Decoder = LongIrqFtraceEvent_Decoder; + enum : int32_t { + kIrqFieldNumber = 1, + kLatencyFieldNumber = 2, + kCountFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LongIrqFtraceEvent"; } + + + using FieldMetadata_Irq = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LongIrqFtraceEvent>; + + static constexpr FieldMetadata_Irq kIrq{}; + void set_irq(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Latency = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LongIrqFtraceEvent>; + + static constexpr FieldMetadata_Latency kLatency{}; + void set_latency(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Latency::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Count = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LongIrqFtraceEvent>; + + static constexpr FieldMetadata_Count kCount{}; + void set_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -148206,7 +150574,7 @@ class SchedGroupTrackerFtraceEvent : public ::protozero::Message { } }; -class SchedWakeupTaskAttrFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { +class SchedWakeupTaskAttrFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { public: SchedWakeupTaskAttrFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit SchedWakeupTaskAttrFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -148221,6 +150589,14 @@ class SchedWakeupTaskAttrFtraceEvent_Decoder : public ::protozero::TypedProtoDec uint64_t uclamp_min() const { return at<4>().as_uint64(); } bool has_vruntime() const { return at<5>().valid(); } uint64_t vruntime() const { return at<5>().as_uint64(); } + bool has_sched_qos_user_defined_flag() const { return at<6>().valid(); } + uint64_t sched_qos_user_defined_flag() const { return at<6>().as_uint64(); } + bool has_rampup_multiplier() const { return at<7>().valid(); } + uint32_t rampup_multiplier() const { return at<7>().as_uint32(); } + bool has_effect_rampup_multiplier() const { return at<8>().valid(); } + uint32_t effect_rampup_multiplier() const { return at<8>().as_uint32(); } + bool has_tag_nice() const { return at<9>().valid(); } + int32_t tag_nice() const { return at<9>().as_int32(); } }; class SchedWakeupTaskAttrFtraceEvent : public ::protozero::Message { @@ -148232,6 +150608,10 @@ class SchedWakeupTaskAttrFtraceEvent : public ::protozero::Message { kTaskUtilFieldNumber = 3, kUclampMinFieldNumber = 4, kVruntimeFieldNumber = 5, + kSchedQosUserDefinedFlagFieldNumber = 6, + kRampupMultiplierFieldNumber = 7, + kEffectRampupMultiplierFieldNumber = 8, + kTagNiceFieldNumber = 9, }; static constexpr const char* GetName() { return ".perfetto.protos.SchedWakeupTaskAttrFtraceEvent"; } @@ -148325,6 +150705,78 @@ class SchedWakeupTaskAttrFtraceEvent : public ::protozero::Message { ::protozero::proto_utils::ProtoSchemaType::kUint64> ::Append(*this, field_id, value); } + + using FieldMetadata_SchedQosUserDefinedFlag = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SchedWakeupTaskAttrFtraceEvent>; + + static constexpr FieldMetadata_SchedQosUserDefinedFlag kSchedQosUserDefinedFlag{}; + void set_sched_qos_user_defined_flag(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SchedQosUserDefinedFlag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RampupMultiplier = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedWakeupTaskAttrFtraceEvent>; + + static constexpr FieldMetadata_RampupMultiplier kRampupMultiplier{}; + void set_rampup_multiplier(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RampupMultiplier::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EffectRampupMultiplier = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedWakeupTaskAttrFtraceEvent>; + + static constexpr FieldMetadata_EffectRampupMultiplier kEffectRampupMultiplier{}; + void set_effect_rampup_multiplier(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EffectRampupMultiplier::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TagNice = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakeupTaskAttrFtraceEvent>; + + static constexpr FieldMetadata_TagNice kTagNice{}; + void set_tag_nice(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TagNice::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } }; class SchedMigrateTaskFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { @@ -165426,6 +167878,8 @@ namespace perfetto { namespace protos { namespace pbzero { class ObfuscatedClass; +class ObfuscatedClass_MergedClass; +class ObfuscatedClass_MergedClasses; class ObfuscatedMember; } // Namespace pbzero. } // Namespace protos. @@ -165516,7 +167970,7 @@ class DeobfuscationMapping : public ::protozero::Message { }; -class ObfuscatedClass_Decoder : public ::protozero::TypedProtoDecoder { +class ObfuscatedClass_Decoder : public ::protozero::TypedProtoDecoder { public: ObfuscatedClass_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit ObfuscatedClass_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -165529,6 +167983,8 @@ class ObfuscatedClass_Decoder : public ::protozero::TypedProtoDecoder obfuscated_members() const { return GetRepeated<::protozero::ConstBytes>(3); } bool has_obfuscated_methods() const { return at<4>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_methods() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_merged_classes() const { return at<5>().valid(); } + ::protozero::ConstBytes merged_classes() const { return at<5>().as_bytes(); } }; class ObfuscatedClass : public ::protozero::Message { @@ -165539,9 +167995,12 @@ class ObfuscatedClass : public ::protozero::Message { kDeobfuscatedNameFieldNumber = 2, kObfuscatedMembersFieldNumber = 3, kObfuscatedMethodsFieldNumber = 4, + kMergedClassesFieldNumber = 5, }; static constexpr const char* GetName() { return ".perfetto.protos.ObfuscatedClass"; } + using MergedClass = ::perfetto::protos::pbzero::ObfuscatedClass_MergedClass; + using MergedClasses = ::perfetto::protos::pbzero::ObfuscatedClass_MergedClasses; using FieldMetadata_ObfuscatedName = ::protozero::proto_utils::FieldMetadata< @@ -165618,6 +168077,182 @@ class ObfuscatedClass : public ::protozero::Message { return BeginNestedMessage(4); } + + using FieldMetadata_MergedClasses = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ObfuscatedClass_MergedClasses, + ObfuscatedClass>; + + static constexpr FieldMetadata_MergedClasses kMergedClasses{}; + template T* set_merged_classes() { + return BeginNestedMessage(5); + } + +}; + +class ObfuscatedClass_MergedClasses_Decoder : public ::protozero::TypedProtoDecoder { + public: + ObfuscatedClass_MergedClasses_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ObfuscatedClass_MergedClasses_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ObfuscatedClass_MergedClasses_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_class_id_field_name() const { return at<1>().valid(); } + ::protozero::ConstChars class_id_field_name() const { return at<1>().as_string(); } + bool has_merged_classes() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> merged_classes() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_unknown_merged_classes() const { return at<3>().valid(); } + bool unknown_merged_classes() const { return at<3>().as_bool(); } +}; + +class ObfuscatedClass_MergedClasses : public ::protozero::Message { + public: + using Decoder = ObfuscatedClass_MergedClasses_Decoder; + enum : int32_t { + kClassIdFieldNameFieldNumber = 1, + kMergedClassesFieldNumber = 2, + kUnknownMergedClassesFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ObfuscatedClass.MergedClasses"; } + + + using FieldMetadata_ClassIdFieldName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ObfuscatedClass_MergedClasses>; + + static constexpr FieldMetadata_ClassIdFieldName kClassIdFieldName{}; + void set_class_id_field_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ClassIdFieldName::kFieldId, data, size); + } + void set_class_id_field_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ClassIdFieldName::kFieldId, chars.data, chars.size); + } + void set_class_id_field_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ClassIdFieldName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MergedClasses = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ObfuscatedClass_MergedClass, + ObfuscatedClass_MergedClasses>; + + static constexpr FieldMetadata_MergedClasses kMergedClasses{}; + template T* add_merged_classes() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_UnknownMergedClasses = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ObfuscatedClass_MergedClasses>; + + static constexpr FieldMetadata_UnknownMergedClasses kUnknownMergedClasses{}; + void set_unknown_merged_classes(bool value) { + static constexpr uint32_t field_id = FieldMetadata_UnknownMergedClasses::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class ObfuscatedClass_MergedClass_Decoder : public ::protozero::TypedProtoDecoder { + public: + ObfuscatedClass_MergedClass_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ObfuscatedClass_MergedClass_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ObfuscatedClass_MergedClass_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_class_id() const { return at<2>().valid(); } + int32_t class_id() const { return at<2>().as_int32(); } + bool has_merged_classes() const { return at<3>().valid(); } + ::protozero::ConstBytes merged_classes() const { return at<3>().as_bytes(); } +}; + +class ObfuscatedClass_MergedClass : public ::protozero::Message { + public: + using Decoder = ObfuscatedClass_MergedClass_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kClassIdFieldNumber = 2, + kMergedClassesFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ObfuscatedClass.MergedClass"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ObfuscatedClass_MergedClass>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ClassId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ObfuscatedClass_MergedClass>; + + static constexpr FieldMetadata_ClassId kClassId{}; + void set_class_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ClassId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MergedClasses = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ObfuscatedClass_MergedClasses, + ObfuscatedClass_MergedClass>; + + static constexpr FieldMetadata_MergedClasses kMergedClasses{}; + template T* set_merged_classes() { + return BeginNestedMessage(3); + } + }; class ObfuscatedMember_Decoder : public ::protozero::TypedProtoDecoder { @@ -190398,14 +193033,6 @@ class TracingServiceState; class TracingServiceState_TracingSession; class TracingServiceState_DataSource; class DataSourceDescriptor; -class VmProgram; -class VmInstruction; -class VmOpDel; -class VmOpSet; -class VmOpMerge; -class VmOpRegLoad; -class VmOpSelect; -class VmOpSelect_PathComponent; class TracingServiceState_Producer; class QueryServiceStateRequest; class ObserveEventsResponse; @@ -190449,6 +193076,8 @@ class InterceptorConfig; class ConsoleConfig; class ChromeConfig; class SystemInfoConfig; +class DataSourceConfig_ExperimentalTracingV2Config; +class DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption; class ProtoVmConfig; class TraceConfig_BufferConfig; class AttachRequest; @@ -190470,8 +193099,6 @@ class StartTracingRequest; class EnableTracingResponse; class EnableTracingRequest; enum ObservableEvents_Type : int; -enum VmInstruction_AbortLevel : int; -enum VmCursorEnum : int; enum ObservableEvents_DataSourceInstanceState : int; enum TraceStats_FinalFlushOutcome : int; enum TraceConfig_LockdownModeOperation : int; @@ -191663,6 +194290,8 @@ class InterceptorConfig; class ConsoleConfig; class ChromeConfig; class SystemInfoConfig; +class DataSourceConfig_ExperimentalTracingV2Config; +class DataSourceConfig_ExperimentalTracingV2Config_ChunkSizeOption; class ProtoVmConfig; class PriorityBoostConfig; class GetAsyncCommandResponse_SetupDataSource; @@ -191684,25 +194313,20 @@ class UnregisterDataSourceRequest; class UpdateDataSourceResponse; class UpdateDataSourceRequest; class DataSourceDescriptor; -class VmProgram; -class VmInstruction; -class VmOpDel; -class VmOpSet; -class VmOpMerge; -class VmOpRegLoad; -class VmOpSelect; -class VmOpSelect_PathComponent; class RegisterDataSourceResponse; class RegisterDataSourceRequest; +class DrainV2RingBufferResponse; +class DrainV2RingBufferRequest; +class AttachV2RingBufferResponse; +class AttachV2RingBufferRequest; class InitializeConnectionResponse; class InitializeConnectionRequest; +enum ProtocolAbiVersion : int; enum DataSourceConfig_SessionInitiator : int; enum DataSourceConfig_BufferExhaustedPolicy : int; enum ConsoleConfig_Output : int; enum ChromeConfig_ClientPriority : int; enum PriorityBoostConfig_BoostPolicy : int; -enum VmInstruction_AbortLevel : int; -enum VmCursorEnum : int; enum InitializeConnectionRequest_ProducerSMBScrapingMode : int; } // namespace perfetto } // namespace protos @@ -191715,6 +194339,11 @@ class Message; namespace perfetto { namespace protos { namespace gen { +enum ProtocolAbiVersion : int { + PROTOCOL_ABI_VERSION_UNSPECIFIED = 0, + PROTOCOL_ABI_VERSION_V1 = 1, + PROTOCOL_ABI_VERSION_V2 = 2, +}; enum InitializeConnectionRequest_ProducerSMBScrapingMode : int { InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_UNSPECIFIED = 0, InitializeConnectionRequest_ProducerSMBScrapingMode_SMB_SCRAPING_ENABLED = 1, @@ -192681,12 +195310,135 @@ class PERFETTO_EXPORT_COMPONENT RegisterDataSourceRequest : public ::protozero:: }; +class PERFETTO_EXPORT_COMPONENT DrainV2RingBufferResponse : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + }; + + DrainV2RingBufferResponse(); + ~DrainV2RingBufferResponse() override; + DrainV2RingBufferResponse(DrainV2RingBufferResponse&&) noexcept; + DrainV2RingBufferResponse& operator=(DrainV2RingBufferResponse&&); + DrainV2RingBufferResponse(const DrainV2RingBufferResponse&); + DrainV2RingBufferResponse& operator=(const DrainV2RingBufferResponse&); + bool operator==(const DrainV2RingBufferResponse&) const; + bool operator!=(const DrainV2RingBufferResponse& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + private: + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<2> _has_field_{}; +}; + + +class PERFETTO_EXPORT_COMPONENT DrainV2RingBufferRequest : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + }; + + DrainV2RingBufferRequest(); + ~DrainV2RingBufferRequest() override; + DrainV2RingBufferRequest(DrainV2RingBufferRequest&&) noexcept; + DrainV2RingBufferRequest& operator=(DrainV2RingBufferRequest&&); + DrainV2RingBufferRequest(const DrainV2RingBufferRequest&); + DrainV2RingBufferRequest& operator=(const DrainV2RingBufferRequest&); + bool operator==(const DrainV2RingBufferRequest&) const; + bool operator!=(const DrainV2RingBufferRequest& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + private: + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<2> _has_field_{}; +}; + + +class PERFETTO_EXPORT_COMPONENT AttachV2RingBufferResponse : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + }; + + AttachV2RingBufferResponse(); + ~AttachV2RingBufferResponse() override; + AttachV2RingBufferResponse(AttachV2RingBufferResponse&&) noexcept; + AttachV2RingBufferResponse& operator=(AttachV2RingBufferResponse&&); + AttachV2RingBufferResponse(const AttachV2RingBufferResponse&); + AttachV2RingBufferResponse& operator=(const AttachV2RingBufferResponse&); + bool operator==(const AttachV2RingBufferResponse&) const; + bool operator!=(const AttachV2RingBufferResponse& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + private: + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<2> _has_field_{}; +}; + + +class PERFETTO_EXPORT_COMPONENT AttachV2RingBufferRequest : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + kChunkSizeBytesFieldNumber = 1, + }; + + AttachV2RingBufferRequest(); + ~AttachV2RingBufferRequest() override; + AttachV2RingBufferRequest(AttachV2RingBufferRequest&&) noexcept; + AttachV2RingBufferRequest& operator=(AttachV2RingBufferRequest&&); + AttachV2RingBufferRequest(const AttachV2RingBufferRequest&); + AttachV2RingBufferRequest& operator=(const AttachV2RingBufferRequest&); + bool operator==(const AttachV2RingBufferRequest&) const; + bool operator!=(const AttachV2RingBufferRequest& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_chunk_size_bytes() const { return _has_field_[1]; } + uint32_t chunk_size_bytes() const { return chunk_size_bytes_; } + void set_chunk_size_bytes(uint32_t value) { chunk_size_bytes_ = value; _has_field_.set(1); } + + private: + uint32_t chunk_size_bytes_{}; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<2> _has_field_{}; +}; + + class PERFETTO_EXPORT_COMPONENT InitializeConnectionResponse : public ::protozero::CppMessageObj { public: enum FieldNumbers { kUsingShmemProvidedByProducerFieldNumber = 1, kDirectSmbPatchingSupportedFieldNumber = 2, kUseShmemEmulationFieldNumber = 3, + kProtocolAbiVersionsFieldNumber = 4, }; InitializeConnectionResponse(); @@ -192715,16 +195467,21 @@ class PERFETTO_EXPORT_COMPONENT InitializeConnectionResponse : public ::protozer bool use_shmem_emulation() const { return use_shmem_emulation_; } void set_use_shmem_emulation(bool value) { use_shmem_emulation_ = value; _has_field_.set(3); } + bool has_protocol_abi_versions() const { return _has_field_[4]; } + uint32_t protocol_abi_versions() const { return protocol_abi_versions_; } + void set_protocol_abi_versions(uint32_t value) { protocol_abi_versions_ = value; _has_field_.set(4); } + private: bool using_shmem_provided_by_producer_{}; bool direct_smb_patching_supported_{}; bool use_shmem_emulation_{}; + uint32_t protocol_abi_versions_{}; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<4> _has_field_{}; + std::bitset<5> _has_field_{}; }; @@ -192744,6 +195501,7 @@ class PERFETTO_EXPORT_COMPONENT InitializeConnectionRequest : public ::protozero kProducerProvidedShmemFieldNumber = 6, kSdkVersionFieldNumber = 8, kShmKeyWindowsFieldNumber = 7, + kSupportedProtocolAbiVersionsFieldNumber = 9, }; InitializeConnectionRequest(); @@ -192788,6 +195546,10 @@ class PERFETTO_EXPORT_COMPONENT InitializeConnectionRequest : public ::protozero const std::string& shm_key_windows() const { return shm_key_windows_; } void set_shm_key_windows(const std::string& value) { shm_key_windows_ = value; _has_field_.set(7); } + bool has_supported_protocol_abi_versions() const { return _has_field_[9]; } + uint32_t supported_protocol_abi_versions() const { return supported_protocol_abi_versions_; } + void set_supported_protocol_abi_versions(uint32_t value) { supported_protocol_abi_versions_ = value; _has_field_.set(9); } + private: uint32_t shared_memory_page_size_hint_bytes_{}; uint32_t shared_memory_size_hint_bytes_{}; @@ -192796,12 +195558,13 @@ class PERFETTO_EXPORT_COMPONENT InitializeConnectionRequest : public ::protozero bool producer_provided_shmem_{}; std::string sdk_version_{}; std::string shm_key_windows_{}; + uint32_t supported_protocol_abi_versions_{}; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<9> _has_field_{}; + std::bitset<10> _has_field_{}; }; } // namespace perfetto From 237fd0d169f6cc0cbf09cd9a26a02f9893338fb1 Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Mon, 2 Nov 2026 21:14:37 -0800 Subject: [PATCH 199/331] ffi: make Fast API functions collectable V8 strongly caches instantiations of low-serial FunctionTemplates, which pinned Fast API functions and, through them, their DynamicLibrary and trampoline. FunctionTemplate::New() has no opt-out, so add an ObjectTemplate property to make these templates uncacheable, then delete it from the new function. Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com> Assisted-by: claude:opus-5.5 PR-URL: https://github.com/nodejs/node/pull/67177 Fixes: https://github.com/nodejs/node/issues/67176 Reviewed-By: Paolo Insogna Reviewed-By: Matteo Collina --- src/env_properties.h | 1 + src/node_ffi.cc | 31 +++++++++++++++-- test/ffi/test-ffi-dynamic-library.js | 50 ++++++++++++++++++++++++++++ 3 files changed, 80 insertions(+), 2 deletions(-) diff --git a/src/env_properties.h b/src/env_properties.h index 22876f8f971..798db159b9f 100644 --- a/src/env_properties.h +++ b/src/env_properties.h @@ -415,6 +415,7 @@ V(fdclose_constructor_template, v8::ObjectTemplate) \ V(ffi_dynamic_library_constructor_template, v8::FunctionTemplate) \ V(ffi_function_constructor_template, v8::FunctionTemplate) \ + V(ffi_uncacheable_placeholder_template, v8::ObjectTemplate) \ V(filehandlereadwrap_template, v8::ObjectTemplate) \ V(fips_indicator_event_template, v8::DictionaryTemplate) \ V(free_list_statistics_template, v8::DictionaryTemplate) \ diff --git a/src/node_ffi.cc b/src/node_ffi.cc index 5c5d6b8a436..50fc8815cf9 100644 --- a/src/node_ffi.cc +++ b/src/node_ffi.cc @@ -37,6 +37,7 @@ using v8::LocalVector; using v8::Maybe; using v8::MaybeLocal; using v8::Object; +using v8::ObjectTemplate; using v8::PropertyAttribute; using v8::ReadOnly; using v8::Signature; @@ -277,6 +278,32 @@ BaseObjectPtr FFIFunctionInfo::Create( return MakeWeakBaseObject(env, obj, std::move(fn), library); } +// V8 strongly caches instantiations of low-serial FunctionTemplates, which +// would root the function and, through FFIFunctionInfo, its library and +// trampoline. An ObjectTemplate property is the only public way to make a +// FunctionTemplate uncacheable (see v8::Template::Set()), so add one and delete +// it from the instance. It is shared because its own instantiation is cached. +static MaybeLocal GetUncachedFunction(Environment* env, + Local tmpl) { + Local context = env->context(); + IsolateData* isolate_data = env->isolate_data(); + + Local placeholder = + isolate_data->ffi_uncacheable_placeholder_template(); + if (placeholder.IsEmpty()) { + placeholder = ObjectTemplate::New(env->isolate()); + isolate_data->set_ffi_uncacheable_placeholder_template(placeholder); + } + tmpl->Set(env->pointer_string(), placeholder); + + Local ret; + if (!tmpl->GetFunction(context).ToLocal(&ret) || + !ret->Delete(context, env->pointer_string()).FromMaybe(false)) { + return MaybeLocal(); + } + return ret; +} + MaybeLocal DynamicLibrary::CreateFunction( Environment* env, const std::string& name, @@ -340,7 +367,7 @@ MaybeLocal DynamicLibrary::CreateFunction( v8::ConstructorBehavior::kThrow, v8::SideEffectType::kHasSideEffect, &info->fast_metadata->c_function); - maybe_ret = tmpl->GetFunction(context); + maybe_ret = GetUncachedFunction(env, tmpl); } else { // Non-Fast signatures either use the SharedBuffer invoker, where JS writes // argument slots before calling with no arguments, or the generic invoker @@ -492,7 +519,7 @@ MaybeLocal DynamicLibrary::CreateFunction( v8::SideEffectType::kHasSideEffect, &info->fast_buffer_metadata->c_function); Local fast_buffer_invoke; - if (!tmpl->GetFunction(context).ToLocal(&fast_buffer_invoke)) { + if (!GetUncachedFunction(env, tmpl).ToLocal(&fast_buffer_invoke)) { return MaybeLocal(); } if (!ret->DefineOwnProperty(context, diff --git a/test/ffi/test-ffi-dynamic-library.js b/test/ffi/test-ffi-dynamic-library.js index 7dcbf175a86..138e1ccb410 100644 --- a/test/ffi/test-ffi-dynamic-library.js +++ b/test/ffi/test-ffi-dynamic-library.js @@ -260,6 +260,56 @@ test('a dropped function wrapper is collectable', async () => { } }); +for (const symbol of [ + 'multiply_f64', // Fast API, no JS wrapper + 'add_i32', // Fast API, JS wrapper + 'get_counter', // Fast API, no arguments + 'pointer_to_usize', // Fast API, JS wrapper and Buffer invoker +]) { + test(`dropping ${symbol} releases the function and its library`, async () => { + let lib = new ffi.DynamicLibrary(libraryPath); + let fn = lib.getFunction(symbol, fixtureSymbols[symbol]); + const fnRef = new WeakRef(fn); + const libRef = new WeakRef(lib); + lib = null; + fn = null; + + await gcUntil(`dropping ${symbol} releases the function and its library`, () => { + return fnRef.deref() === undefined && libRef.deref() === undefined; + }); + }); +} + +test('an optimized Fast API call target can be collected', async () => { + const lib = new ffi.DynamicLibrary(libraryPath); + + try { + function callMultiply(fn) { + return fn(20, 22); + } + eval('%PrepareFunctionForOptimization(callMultiply)'); + + // Collect a function that optimized code has called, then make sure a new + // function for the same symbol works through a fresh trampoline. + let fn = lib.getFunction('multiply_f64', fixtureSymbols.multiply_f64); + assert.strictEqual(callMultiply(fn), 440); + assert.strictEqual(callMultiply(fn), 440); + eval('%OptimizeFunctionOnNextCall(callMultiply)'); + assert.strictEqual(callMultiply(fn), 440); + + const ref = new WeakRef(fn); + fn = null; + await gcUntil('an optimized Fast API call target can be collected', () => { + return ref.deref() === undefined; + }); + + fn = lib.getFunction('multiply_f64', fixtureSymbols.multiply_f64); + assert.strictEqual(callMultiply(fn), 440); + } finally { + lib.close(); + } +}); + test('FFI functions keep their owning library alive', async () => { let lib = new ffi.DynamicLibrary(libraryPath); const addI32 = lib.getFunction('add_i32', fixtureSymbols.add_i32); From 273d0fabbe4b3dc2ece50a4580fb1259b3641757 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Sun, 1 Nov 2026 00:39:53 +0000 Subject: [PATCH 200/331] deps: update amaro to 1.3.0 PR-URL: https://github.com/nodejs/node/pull/66144 Reviewed-By: Aviv Keller Reviewed-By: Geoffrey Booth Reviewed-By: Marco Ippolito --- deps/amaro/README.md | 24 +- deps/amaro/dist/LICENSE | 2 +- deps/amaro/dist/errors.js | 32 +- deps/amaro/dist/index.d.ts | 2 +- deps/amaro/dist/index.js | 562 +----------------- deps/amaro/dist/internal.d.ts | 9 + deps/amaro/dist/internal.js | 706 +++++++++++++++++++++++ deps/amaro/dist/package.json | 13 +- deps/amaro/dist/register-strip.mjs | 10 +- deps/amaro/dist/register-transform.mjs | 10 +- deps/amaro/dist/strip-loader.d.ts | 11 +- deps/amaro/dist/strip-loader.js | 90 ++- deps/amaro/dist/transform-loader.d.ts | 11 +- deps/amaro/dist/transform-loader.js | 96 +++- deps/amaro/dist/transform.d.ts | 2 - deps/amaro/lib/wasm.d.ts | 28 + deps/amaro/lib/wasm.js | 755 +++++++++++++++++++++++++ deps/amaro/lib/wasm_bg.wasm.d.ts | 9 +- deps/amaro/package.json | 3 +- src/amaro_version.h | 2 +- 20 files changed, 1731 insertions(+), 646 deletions(-) create mode 100644 deps/amaro/dist/internal.d.ts create mode 100644 deps/amaro/dist/internal.js delete mode 100644 deps/amaro/dist/transform.d.ts create mode 100644 deps/amaro/lib/wasm.js diff --git a/deps/amaro/README.md b/deps/amaro/README.md index 44c44c4dc6a..7009652564b 100644 --- a/deps/amaro/README.md +++ b/deps/amaro/README.md @@ -1,12 +1,26 @@ # Amaro -Amaro is a wrapper around `@swc/wasm-typescript`, a WebAssembly port of the SWC TypeScript parser. +Amaro is a Node.js wrapper around the [SWC](https://swc.rs) TypeScript parser and type stripper. Its Rust core in `crates/amaro` depends on the published SWC crates and is compiled to WebAssembly. It's used as an internal in Node.js for [Type Stripping](https://nodejs.org/api/typescript.html#type-stripping) but can also be used as a standalone package. > Amaro means "bitter" in Italian. It's a reference to [Mount Amaro](https://en.wikipedia.org/wiki/Monte_Amaro_(Abruzzo)) on whose slopes this package was conceived. This package provides a stable API for the TypeScript parser and allows users to upgrade to the latest version of TypeScript transpiler independently from the one used internally in Node.js. +## Building from source + +The WebAssembly module is not checked in. Building it requires Docker, which +runs the Rust build inside the [Node.js wasm-builder](https://github.com/nodejs/wasm-builder) +container: + +```bash +npm run build:wasm +npm run build +npm test +``` + +Releases build the module in CI before publishing. + ## How to Install To install Amaro, run: @@ -47,15 +61,13 @@ node --enable-source-maps --import="amaro/transform" file.ts > Note that the `amaro/transform` loader should be used with `--enable-source-maps` > to preserve accurate source-mapped stack traces. -#### Programmatic registration with `module.register()` +#### Programmatic registration with `module.registerHooks()` -If you want TypeScript to "just work" in an existing codebase without passing `--import` every time, create a small bootstrap file and register Amaro once before loading your TS entrypoint. +Amaro's `strip` and `transform` entry points use `module.registerHooks()` to register synchronous hooks on Node.js versions that provide it, and fall back to `module.register()` on older versions. If you want TypeScript to "just work" in an existing codebase without passing `--import` every time, create a small bootstrap file that imports Amaro before loading your TS entrypoint. ```mjs // bootstrap.mjs -import { register } from "node:module"; - -register("amaro/strip", import.meta.url); +import "amaro/strip"; await import("./src/index.ts"); ``` diff --git a/deps/amaro/dist/LICENSE b/deps/amaro/dist/LICENSE index 6a08504909f..8f3eaa8198d 100644 --- a/deps/amaro/dist/LICENSE +++ b/deps/amaro/dist/LICENSE @@ -198,4 +198,4 @@ Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and -limitations under the License. \ No newline at end of file +limitations under the License. diff --git a/deps/amaro/dist/errors.js b/deps/amaro/dist/errors.js index 0b860e4b541..c8a036f5c3e 100644 --- a/deps/amaro/dist/errors.js +++ b/deps/amaro/dist/errors.js @@ -1,8 +1,31 @@ "use strict"; -export function isSwcError(error) { +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); +var errors_exports = {}; +__export(errors_exports, { + isSwcError: () => isSwcError, + wrapAndReThrowSwcError: () => wrapAndReThrowSwcError +}); +module.exports = __toCommonJS(errors_exports); +function isSwcError(error) { return error.code !== void 0; } -export function wrapAndReThrowSwcError(error) { +function wrapAndReThrowSwcError(error) { const errorHints = `${error.filename}:${error.startLine} ${error.snippet} `; @@ -22,3 +45,8 @@ ${error.snippet} throw new Error(error.message); } } +// Annotate the CommonJS export names for ESM import in node: +0 && (module.exports = { + isSwcError, + wrapAndReThrowSwcError +}); diff --git a/deps/amaro/dist/index.d.ts b/deps/amaro/dist/index.d.ts index 5e35978f759..8b28c9599bd 100644 --- a/deps/amaro/dist/index.d.ts +++ b/deps/amaro/dist/index.d.ts @@ -1 +1 @@ -export { transformSync } from "./transform.ts"; +export { transformSync } from "./internal.js"; diff --git a/deps/amaro/dist/index.js b/deps/amaro/dist/index.js index 4ce1359bb25..f10c8ae5ce5 100644 --- a/deps/amaro/dist/index.js +++ b/deps/amaro/dist/index.js @@ -1,13 +1,8 @@ "use strict"; -var __create = Object.create; var __defProp = Object.defineProperty; var __getOwnPropDesc = Object.getOwnPropertyDescriptor; var __getOwnPropNames = Object.getOwnPropertyNames; -var __getProtoOf = Object.getPrototypeOf; var __hasOwnProp = Object.prototype.hasOwnProperty; -var __commonJS = (cb, mod) => function __require() { - return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; -}; var __export = (target, all) => { for (var name in all) __defProp(target, name, { get: all[name], enumerable: true }); @@ -20,566 +15,13 @@ var __copyProps = (to, from, except, desc) => { } return to; }; -var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( - // If the importer is in node compatibility mode or this is not an ESM - // file that has been converted to a CommonJS file using a Babel- - // compatible transform (i.e. "__esModule" has not been set), then set - // "default" to the CommonJS "module.exports" for node compatibility. - isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, - mod -)); var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); - -// lib/wasm.js -var require_wasm = __commonJS({ - "lib/wasm.js"(exports2, module2) { - "use strict"; - var imports = {}; - imports["__wbindgen_placeholder__"] = module2.exports; - var wasm; - var { TextDecoder, TextEncoder } = require("util"); - var heap = new Array(128).fill(void 0); - heap.push(void 0, null, true, false); - function getObject(idx) { - return heap[idx]; - } - var heap_next = heap.length; - function addHeapObject(obj) { - if (heap_next === heap.length) heap.push(heap.length + 1); - const idx = heap_next; - heap_next = heap[idx]; - heap[idx] = obj; - return idx; - } - function handleError(f, args) { - try { - return f.apply(this, args); - } catch (e) { - wasm.__wbindgen_export_0(addHeapObject(e)); - } - } - var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true }); - cachedTextDecoder.decode(); - var cachedUint8ArrayMemory0 = null; - function getUint8ArrayMemory0() { - if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) { - cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer); - } - return cachedUint8ArrayMemory0; - } - function getStringFromWasm0(ptr, len) { - ptr = ptr >>> 0; - return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); - } - function getCachedStringFromWasm0(ptr, len) { - if (ptr === 0) { - return getObject(len); - } else { - return getStringFromWasm0(ptr, len); - } - } - function dropObject(idx) { - if (idx < 132) return; - heap[idx] = heap_next; - heap_next = idx; - } - function takeObject(idx) { - const ret = getObject(idx); - dropObject(idx); - return ret; - } - function isLikeNone(x) { - return x === void 0 || x === null; - } - var cachedDataViewMemory0 = null; - function getDataViewMemory0() { - if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) { - cachedDataViewMemory0 = new DataView(wasm.memory.buffer); - } - return cachedDataViewMemory0; - } - var CLOSURE_DTORS = typeof FinalizationRegistry === "undefined" ? { register: () => { - }, unregister: () => { - } } : new FinalizationRegistry((state) => { - wasm.__wbindgen_export_1.get(state.dtor)(state.a, state.b); - }); - function makeMutClosure(arg0, arg1, dtor, f) { - const state = { a: arg0, b: arg1, cnt: 1, dtor }; - const real = (...args) => { - state.cnt++; - const a = state.a; - state.a = 0; - try { - return f(a, state.b, ...args); - } finally { - if (--state.cnt === 0) { - wasm.__wbindgen_export_1.get(state.dtor)(a, state.b); - CLOSURE_DTORS.unregister(state); - } else { - state.a = a; - } - } - }; - real.original = state; - CLOSURE_DTORS.register(real, state, state); - return real; - } - function debugString(val) { - const type = typeof val; - if (type == "number" || type == "boolean" || val == null) { - return `${val}`; - } - if (type == "string") { - return `"${val}"`; - } - if (type == "symbol") { - const description = val.description; - if (description == null) { - return "Symbol"; - } else { - return `Symbol(${description})`; - } - } - if (type == "function") { - const name = val.name; - if (typeof name == "string" && name.length > 0) { - return `Function(${name})`; - } else { - return "Function"; - } - } - if (Array.isArray(val)) { - const length = val.length; - let debug = "["; - if (length > 0) { - debug += debugString(val[0]); - } - for (let i = 1; i < length; i++) { - debug += ", " + debugString(val[i]); - } - debug += "]"; - return debug; - } - const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); - let className; - if (builtInMatches && builtInMatches.length > 1) { - className = builtInMatches[1]; - } else { - return toString.call(val); - } - if (className == "Object") { - try { - return "Object(" + JSON.stringify(val) + ")"; - } catch (_) { - return "Object"; - } - } - if (val instanceof Error) { - return `${val.name}: ${val.message} -${val.stack}`; - } - return className; - } - var WASM_VECTOR_LEN = 0; - var cachedTextEncoder = new TextEncoder("utf-8"); - var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) { - return cachedTextEncoder.encodeInto(arg, view); - } : function(arg, view) { - const buf = cachedTextEncoder.encode(arg); - view.set(buf); - return { - read: arg.length, - written: buf.length - }; - }; - function passStringToWasm0(arg, malloc, realloc) { - if (realloc === void 0) { - const buf = cachedTextEncoder.encode(arg); - const ptr2 = malloc(buf.length, 1) >>> 0; - getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf); - WASM_VECTOR_LEN = buf.length; - return ptr2; - } - let len = arg.length; - let ptr = malloc(len, 1) >>> 0; - const mem = getUint8ArrayMemory0(); - let offset = 0; - for (; offset < len; offset++) { - const code = arg.charCodeAt(offset); - if (code > 127) break; - mem[ptr + offset] = code; - } - if (offset !== len) { - if (offset !== 0) { - arg = arg.slice(offset); - } - ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; - const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len); - const ret = encodeString(arg, view); - offset += ret.written; - ptr = realloc(ptr, len, offset, 1) >>> 0; - } - WASM_VECTOR_LEN = offset; - return ptr; - } - module2.exports.transform = function(input, options) { - const ret = wasm.transform(addHeapObject(input), addHeapObject(options)); - return takeObject(ret); - }; - module2.exports.transformSync = function(input, options) { - try { - const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); - wasm.transformSync(retptr, addHeapObject(input), addHeapObject(options)); - var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); - var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); - var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); - if (r2) { - throw takeObject(r1); - } - return takeObject(r0); - } finally { - wasm.__wbindgen_add_to_stack_pointer(16); - } - }; - function __wbg_adapter_50(arg0, arg1, arg2) { - wasm.__wbindgen_export_4(arg0, arg1, addHeapObject(arg2)); - } - function __wbg_adapter_79(arg0, arg1, arg2, arg3) { - wasm.__wbindgen_export_5(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); - } - module2.exports.__wbg_buffer_609cc3eee51ed158 = function(arg0) { - const ret = getObject(arg0).buffer; - return addHeapObject(ret); - }; - module2.exports.__wbg_call_672a4d21634d4a24 = function() { - return handleError(function(arg0, arg1) { - const ret = getObject(arg0).call(getObject(arg1)); - return addHeapObject(ret); - }, arguments); - }; - module2.exports.__wbg_call_7cccdd69e0791ae2 = function() { - return handleError(function(arg0, arg1, arg2) { - const ret = getObject(arg0).call(getObject(arg1), getObject(arg2)); - return addHeapObject(ret); - }, arguments); - }; - module2.exports.__wbg_done_769e5ede4b31c67b = function(arg0) { - const ret = getObject(arg0).done; - return ret; - }; - module2.exports.__wbg_entries_3265d4158b33e5dc = function(arg0) { - const ret = Object.entries(getObject(arg0)); - return addHeapObject(ret); - }; - module2.exports.__wbg_get_67b2ba62fc30de12 = function() { - return handleError(function(arg0, arg1) { - const ret = Reflect.get(getObject(arg0), getObject(arg1)); - return addHeapObject(ret); - }, arguments); - }; - module2.exports.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) { - const ret = getObject(arg0)[arg1 >>> 0]; - return addHeapObject(ret); - }; - module2.exports.__wbg_getwithrefkey_1dc361bd10053bfe = function(arg0, arg1) { - const ret = getObject(arg0)[getObject(arg1)]; - return addHeapObject(ret); - }; - module2.exports.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) { - let result; - try { - result = getObject(arg0) instanceof ArrayBuffer; - } catch (_) { - result = false; - } - const ret = result; - return ret; - }; - module2.exports.__wbg_instanceof_Map_f3469ce2244d2430 = function(arg0) { - let result; - try { - result = getObject(arg0) instanceof Map; - } catch (_) { - result = false; - } - const ret = result; - return ret; - }; - module2.exports.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function(arg0) { - let result; - try { - result = getObject(arg0) instanceof Uint8Array; - } catch (_) { - result = false; - } - const ret = result; - return ret; - }; - module2.exports.__wbg_isArray_a1eab7e0d067391b = function(arg0) { - const ret = Array.isArray(getObject(arg0)); - return ret; - }; - module2.exports.__wbg_isSafeInteger_343e2beeeece1bb0 = function(arg0) { - const ret = Number.isSafeInteger(getObject(arg0)); - return ret; - }; - module2.exports.__wbg_iterator_9a24c88df860dc65 = function() { - const ret = Symbol.iterator; - return addHeapObject(ret); - }; - module2.exports.__wbg_length_a446193dc22c12f8 = function(arg0) { - const ret = getObject(arg0).length; - return ret; - }; - module2.exports.__wbg_length_e2d2a49132c1b256 = function(arg0) { - const ret = getObject(arg0).length; - return ret; - }; - module2.exports.__wbg_new_23a2665fac83c611 = function(arg0, arg1) { - try { - var state0 = { a: arg0, b: arg1 }; - var cb0 = (arg02, arg12) => { - const a = state0.a; - state0.a = 0; - try { - return __wbg_adapter_79(a, state0.b, arg02, arg12); - } finally { - state0.a = a; - } - }; - const ret = new Promise(cb0); - return addHeapObject(ret); - } finally { - state0.a = state0.b = 0; - } - }; - module2.exports.__wbg_new_405e22f390576ce2 = function() { - const ret = new Object(); - return addHeapObject(ret); - }; - module2.exports.__wbg_new_78feb108b6472713 = function() { - const ret = new Array(); - return addHeapObject(ret); - }; - module2.exports.__wbg_new_a12002a7f91c75be = function(arg0) { - const ret = new Uint8Array(getObject(arg0)); - return addHeapObject(ret); - }; - module2.exports.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) { - var v0 = getCachedStringFromWasm0(arg0, arg1); - const ret = new Function(v0); - return addHeapObject(ret); - }; - module2.exports.__wbg_next_25feadfc0913fea9 = function(arg0) { - const ret = getObject(arg0).next; - return addHeapObject(ret); - }; - module2.exports.__wbg_next_6574e1a8a62d1055 = function() { - return handleError(function(arg0) { - const ret = getObject(arg0).next(); - return addHeapObject(ret); - }, arguments); - }; - module2.exports.__wbg_queueMicrotask_97d92b4fcc8a61c5 = function(arg0) { - queueMicrotask(getObject(arg0)); - }; - module2.exports.__wbg_queueMicrotask_d3219def82552485 = function(arg0) { - const ret = getObject(arg0).queueMicrotask; - return addHeapObject(ret); - }; - module2.exports.__wbg_resolve_4851785c9c5f573d = function(arg0) { - const ret = Promise.resolve(getObject(arg0)); - return addHeapObject(ret); - }; - module2.exports.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) { - getObject(arg0)[arg1 >>> 0] = takeObject(arg2); - }; - module2.exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) { - getObject(arg0)[takeObject(arg1)] = takeObject(arg2); - }; - module2.exports.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) { - getObject(arg0).set(getObject(arg1), arg2 >>> 0); - }; - module2.exports.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() { - const ret = typeof global === "undefined" ? null : global; - return isLikeNone(ret) ? 0 : addHeapObject(ret); - }; - module2.exports.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() { - const ret = typeof globalThis === "undefined" ? null : globalThis; - return isLikeNone(ret) ? 0 : addHeapObject(ret); - }; - module2.exports.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() { - const ret = typeof self === "undefined" ? null : self; - return isLikeNone(ret) ? 0 : addHeapObject(ret); - }; - module2.exports.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() { - const ret = typeof window === "undefined" ? null : window; - return isLikeNone(ret) ? 0 : addHeapObject(ret); - }; - module2.exports.__wbg_then_44b73946d2fb3e7d = function(arg0, arg1) { - const ret = getObject(arg0).then(getObject(arg1)); - return addHeapObject(ret); - }; - module2.exports.__wbg_toString_5285597960676b7b = function(arg0) { - const ret = getObject(arg0).toString(); - return addHeapObject(ret); - }; - module2.exports.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) { - const ret = getObject(arg0).value; - return addHeapObject(ret); - }; - module2.exports.__wbindgen_bigint_from_i64 = function(arg0) { - const ret = arg0; - return addHeapObject(ret); - }; - module2.exports.__wbindgen_bigint_from_u64 = function(arg0) { - const ret = BigInt.asUintN(64, arg0); - return addHeapObject(ret); - }; - module2.exports.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) { - const v = getObject(arg1); - const ret = typeof v === "bigint" ? v : void 0; - getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true); - getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true); - }; - module2.exports.__wbindgen_boolean_get = function(arg0) { - const v = getObject(arg0); - const ret = typeof v === "boolean" ? v ? 1 : 0 : 2; - return ret; - }; - module2.exports.__wbindgen_cb_drop = function(arg0) { - const obj = takeObject(arg0).original; - if (obj.cnt-- == 1) { - obj.a = 0; - return true; - } - const ret = false; - return ret; - }; - module2.exports.__wbindgen_closure_wrapper5465 = function(arg0, arg1, arg2) { - const ret = makeMutClosure(arg0, arg1, 900, __wbg_adapter_50); - return addHeapObject(ret); - }; - module2.exports.__wbindgen_debug_string = function(arg0, arg1) { - const ret = debugString(getObject(arg1)); - const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3); - const len1 = WASM_VECTOR_LEN; - getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); - getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); - }; - module2.exports.__wbindgen_error_new = function(arg0, arg1) { - const ret = new Error(getStringFromWasm0(arg0, arg1)); - return addHeapObject(ret); - }; - module2.exports.__wbindgen_in = function(arg0, arg1) { - const ret = getObject(arg0) in getObject(arg1); - return ret; - }; - module2.exports.__wbindgen_is_bigint = function(arg0) { - const ret = typeof getObject(arg0) === "bigint"; - return ret; - }; - module2.exports.__wbindgen_is_falsy = function(arg0) { - const ret = !getObject(arg0); - return ret; - }; - module2.exports.__wbindgen_is_function = function(arg0) { - const ret = typeof getObject(arg0) === "function"; - return ret; - }; - module2.exports.__wbindgen_is_object = function(arg0) { - const val = getObject(arg0); - const ret = typeof val === "object" && val !== null; - return ret; - }; - module2.exports.__wbindgen_is_string = function(arg0) { - const ret = typeof getObject(arg0) === "string"; - return ret; - }; - module2.exports.__wbindgen_is_undefined = function(arg0) { - const ret = getObject(arg0) === void 0; - return ret; - }; - module2.exports.__wbindgen_jsval_eq = function(arg0, arg1) { - const ret = getObject(arg0) === getObject(arg1); - return ret; - }; - module2.exports.__wbindgen_jsval_loose_eq = function(arg0, arg1) { - const ret = getObject(arg0) == getObject(arg1); - return ret; - }; - module2.exports.__wbindgen_memory = function() { - const ret = wasm.memory; - return addHeapObject(ret); - }; - module2.exports.__wbindgen_number_get = function(arg0, arg1) { - const obj = getObject(arg1); - const ret = typeof obj === "number" ? obj : void 0; - getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true); - getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true); - }; - module2.exports.__wbindgen_number_new = function(arg0) { - const ret = arg0; - return addHeapObject(ret); - }; - module2.exports.__wbindgen_object_clone_ref = function(arg0) { - const ret = getObject(arg0); - return addHeapObject(ret); - }; - module2.exports.__wbindgen_object_drop_ref = function(arg0) { - takeObject(arg0); - }; - module2.exports.__wbindgen_string_get = function(arg0, arg1) { - const obj = getObject(arg1); - const ret = typeof obj === "string" ? obj : void 0; - var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3); - var len1 = WASM_VECTOR_LEN; - getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); - getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); - }; - module2.exports.__wbindgen_string_new = function(arg0, arg1) { - const ret = getStringFromWasm0(arg0, arg1); - return addHeapObject(ret); - }; - module2.exports.__wbindgen_throw = function(arg0, arg1) { - throw new Error(getStringFromWasm0(arg0, arg1)); - }; - var { Buffer: Buffer2 } = require("node:buffer"); - var bytes = Buffer2.from("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", "base64"); - var wasmModule = new WebAssembly.Module(bytes); - var wasmInstance = new WebAssembly.Instance(wasmModule, imports); - wasm = wasmInstance.exports; - module2.exports.__wasm = wasm; - } -}); - -// src/index.ts var src_exports = {}; __export(src_exports, { - transformSync: () => transformSync + transformSync: () => import_internal.transformSync }); module.exports = __toCommonJS(src_exports); - -// src/transform.ts -var import_wasm = __toESM(require_wasm()); -var DEFAULT_OPTIONS = { - mode: "strip-only", - deprecatedTsModuleAsError: true, - // default transform will only work when mode is "transform" - transform: { - verbatimModuleSyntax: true, - nativeClassProperties: true, - noEmptyExport: true, - importNotUsedAsValues: "preserve" - } -}; -function transformSync(source, options) { - const input = `${source ?? ""}`; - return import_wasm.default.transformSync(input, { - ...DEFAULT_OPTIONS, - ...options - }); -} +var import_internal = require("./internal.js"); // Annotate the CommonJS export names for ESM import in node: 0 && (module.exports = { transformSync diff --git a/deps/amaro/dist/internal.d.ts b/deps/amaro/dist/internal.d.ts new file mode 100644 index 00000000000..5efdff97856 --- /dev/null +++ b/deps/amaro/dist/internal.d.ts @@ -0,0 +1,9 @@ +import type { ModuleSyntaxTransformOutput, Options, Token, TokenKind, TopLevelAwaitLocation, TransformOutput } from "../lib/wasm"; +export type { Token, TokenKind, TopLevelAwaitLocation }; +export declare function transformSync(source: string, options?: Options): TransformOutput; +export declare function transformModuleSyntax(source: string): ModuleSyntaxTransformOutput; +export declare function getFirstExpression(source: string, startColumn: number): string; +export declare function isValidSyntax(source: string): boolean; +export declare function isRecoverableError(source: string): boolean; +export declare function tokenize(source: string): Token[]; +export declare function findTopLevelAwaits(source: string): TopLevelAwaitLocation[]; diff --git a/deps/amaro/dist/internal.js b/deps/amaro/dist/internal.js new file mode 100644 index 00000000000..8c58074bc38 --- /dev/null +++ b/deps/amaro/dist/internal.js @@ -0,0 +1,706 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// lib/wasm.js +var require_wasm = __commonJS({ + "lib/wasm.js"(exports2, module2) { + "use strict"; + var imports = {}; + imports["__wbindgen_placeholder__"] = module2.exports; + var wasm; + var { TextDecoder, TextEncoder } = require("util"); + var heap = new Array(128).fill(void 0); + heap.push(void 0, null, true, false); + function getObject(idx) { + return heap[idx]; + } + var heap_next = heap.length; + function addHeapObject(obj) { + if (heap_next === heap.length) heap.push(heap.length + 1); + const idx = heap_next; + heap_next = heap[idx]; + heap[idx] = obj; + return idx; + } + function handleError(f, args) { + try { + return f.apply(this, args); + } catch (e) { + wasm.__wbindgen_export_0(addHeapObject(e)); + } + } + var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true }); + cachedTextDecoder.decode(); + var cachedUint8ArrayMemory0 = null; + function getUint8ArrayMemory0() { + if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) { + cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8ArrayMemory0; + } + function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); + } + function getCachedStringFromWasm0(ptr, len) { + if (ptr === 0) { + return getObject(len); + } else { + return getStringFromWasm0(ptr, len); + } + } + function dropObject(idx) { + if (idx < 132) return; + heap[idx] = heap_next; + heap_next = idx; + } + function takeObject(idx) { + const ret = getObject(idx); + dropObject(idx); + return ret; + } + function isLikeNone(x) { + return x === void 0 || x === null; + } + var cachedDataViewMemory0 = null; + function getDataViewMemory0() { + if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) { + cachedDataViewMemory0 = new DataView(wasm.memory.buffer); + } + return cachedDataViewMemory0; + } + var CLOSURE_DTORS = typeof FinalizationRegistry === "undefined" ? { register: () => { + }, unregister: () => { + } } : new FinalizationRegistry((state) => { + wasm.__wbindgen_export_1.get(state.dtor)(state.a, state.b); + }); + function makeMutClosure(arg0, arg1, dtor, f) { + const state = { a: arg0, b: arg1, cnt: 1, dtor }; + const real = (...args) => { + state.cnt++; + const a = state.a; + state.a = 0; + try { + return f(a, state.b, ...args); + } finally { + if (--state.cnt === 0) { + wasm.__wbindgen_export_1.get(state.dtor)(a, state.b); + CLOSURE_DTORS.unregister(state); + } else { + state.a = a; + } + } + }; + real.original = state; + CLOSURE_DTORS.register(real, state, state); + return real; + } + function debugString(val) { + const type = typeof val; + if (type == "number" || type == "boolean" || val == null) { + return `${val}`; + } + if (type == "string") { + return `"${val}"`; + } + if (type == "symbol") { + const description = val.description; + if (description == null) { + return "Symbol"; + } else { + return `Symbol(${description})`; + } + } + if (type == "function") { + const name = val.name; + if (typeof name == "string" && name.length > 0) { + return `Function(${name})`; + } else { + return "Function"; + } + } + if (Array.isArray(val)) { + const length = val.length; + let debug = "["; + if (length > 0) { + debug += debugString(val[0]); + } + for (let i = 1; i < length; i++) { + debug += ", " + debugString(val[i]); + } + debug += "]"; + return debug; + } + const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); + let className; + if (builtInMatches && builtInMatches.length > 1) { + className = builtInMatches[1]; + } else { + return toString.call(val); + } + if (className == "Object") { + try { + return "Object(" + JSON.stringify(val) + ")"; + } catch (_) { + return "Object"; + } + } + if (val instanceof Error) { + return `${val.name}: ${val.message} +${val.stack}`; + } + return className; + } + var WASM_VECTOR_LEN = 0; + var cachedTextEncoder = new TextEncoder("utf-8"); + var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) { + return cachedTextEncoder.encodeInto(arg, view); + } : function(arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; + }; + function passStringToWasm0(arg, malloc, realloc) { + if (realloc === void 0) { + const buf = cachedTextEncoder.encode(arg); + const ptr2 = malloc(buf.length, 1) >>> 0; + getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr2; + } + let len = arg.length; + let ptr = malloc(len, 1) >>> 0; + const mem = getUint8ArrayMemory0(); + let offset = 0; + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 127) break; + mem[ptr + offset] = code; + } + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; + const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len); + const ret = encodeString(arg, view); + offset += ret.written; + ptr = realloc(ptr, len, offset, 1) >>> 0; + } + WASM_VECTOR_LEN = offset; + return ptr; + } + module2.exports.transform = function(input, options) { + const ret = wasm.transform(addHeapObject(input), addHeapObject(options)); + return takeObject(ret); + }; + module2.exports.transformSync = function(input, options) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.transformSync(retptr, addHeapObject(input), addHeapObject(options)); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return takeObject(r0); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } + }; + module2.exports.transformModuleSyntax = function(input) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.transformModuleSyntax(retptr, addHeapObject(input)); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return takeObject(r0); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } + }; + module2.exports.getFirstExpression = function(input, start_column) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.getFirstExpression(retptr, addHeapObject(input), start_column); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true); + if (r3) { + throw takeObject(r2); + } + var v1 = getCachedStringFromWasm0(r0, r1); + if (r0 !== 0) { + wasm.__wbindgen_export_4(r0, r1, 1); + } + return v1; + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } + }; + module2.exports.isValidSyntax = function(input) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.isValidSyntax(retptr, addHeapObject(input)); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return r0 !== 0; + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } + }; + module2.exports.isRecoverableError = function(input) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.isRecoverableError(retptr, addHeapObject(input)); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return r0 !== 0; + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } + }; + module2.exports.tokenize = function(input) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.tokenize(retptr, addHeapObject(input)); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return takeObject(r0); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } + }; + module2.exports.findTopLevelAwaits = function(input) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.findTopLevelAwaits(retptr, addHeapObject(input)); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return takeObject(r0); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } + }; + function __wbg_adapter_50(arg0, arg1, arg2) { + wasm.__wbindgen_export_5(arg0, arg1, addHeapObject(arg2)); + } + function __wbg_adapter_83(arg0, arg1, arg2, arg3) { + wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); + } + module2.exports.__wbg_buffer_609cc3eee51ed158 = function(arg0) { + const ret = getObject(arg0).buffer; + return addHeapObject(ret); + }; + module2.exports.__wbg_call_672a4d21634d4a24 = function() { + return handleError(function(arg0, arg1) { + const ret = getObject(arg0).call(getObject(arg1)); + return addHeapObject(ret); + }, arguments); + }; + module2.exports.__wbg_call_7cccdd69e0791ae2 = function() { + return handleError(function(arg0, arg1, arg2) { + const ret = getObject(arg0).call(getObject(arg1), getObject(arg2)); + return addHeapObject(ret); + }, arguments); + }; + module2.exports.__wbg_done_769e5ede4b31c67b = function(arg0) { + const ret = getObject(arg0).done; + return ret; + }; + module2.exports.__wbg_entries_3265d4158b33e5dc = function(arg0) { + const ret = Object.entries(getObject(arg0)); + return addHeapObject(ret); + }; + module2.exports.__wbg_get_67b2ba62fc30de12 = function() { + return handleError(function(arg0, arg1) { + const ret = Reflect.get(getObject(arg0), getObject(arg1)); + return addHeapObject(ret); + }, arguments); + }; + module2.exports.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) { + const ret = getObject(arg0)[arg1 >>> 0]; + return addHeapObject(ret); + }; + module2.exports.__wbg_getwithrefkey_1dc361bd10053bfe = function(arg0, arg1) { + const ret = getObject(arg0)[getObject(arg1)]; + return addHeapObject(ret); + }; + module2.exports.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof ArrayBuffer; + } catch (_) { + result = false; + } + const ret = result; + return ret; + }; + module2.exports.__wbg_instanceof_Map_f3469ce2244d2430 = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof Map; + } catch (_) { + result = false; + } + const ret = result; + return ret; + }; + module2.exports.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof Uint8Array; + } catch (_) { + result = false; + } + const ret = result; + return ret; + }; + module2.exports.__wbg_isArray_a1eab7e0d067391b = function(arg0) { + const ret = Array.isArray(getObject(arg0)); + return ret; + }; + module2.exports.__wbg_isSafeInteger_343e2beeeece1bb0 = function(arg0) { + const ret = Number.isSafeInteger(getObject(arg0)); + return ret; + }; + module2.exports.__wbg_iterator_9a24c88df860dc65 = function() { + const ret = Symbol.iterator; + return addHeapObject(ret); + }; + module2.exports.__wbg_length_a446193dc22c12f8 = function(arg0) { + const ret = getObject(arg0).length; + return ret; + }; + module2.exports.__wbg_length_e2d2a49132c1b256 = function(arg0) { + const ret = getObject(arg0).length; + return ret; + }; + module2.exports.__wbg_new_23a2665fac83c611 = function(arg0, arg1) { + try { + var state0 = { a: arg0, b: arg1 }; + var cb0 = (arg02, arg12) => { + const a = state0.a; + state0.a = 0; + try { + return __wbg_adapter_83(a, state0.b, arg02, arg12); + } finally { + state0.a = a; + } + }; + const ret = new Promise(cb0); + return addHeapObject(ret); + } finally { + state0.a = state0.b = 0; + } + }; + module2.exports.__wbg_new_405e22f390576ce2 = function() { + const ret = new Object(); + return addHeapObject(ret); + }; + module2.exports.__wbg_new_78feb108b6472713 = function() { + const ret = new Array(); + return addHeapObject(ret); + }; + module2.exports.__wbg_new_a12002a7f91c75be = function(arg0) { + const ret = new Uint8Array(getObject(arg0)); + return addHeapObject(ret); + }; + module2.exports.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) { + var v0 = getCachedStringFromWasm0(arg0, arg1); + const ret = new Function(v0); + return addHeapObject(ret); + }; + module2.exports.__wbg_next_25feadfc0913fea9 = function(arg0) { + const ret = getObject(arg0).next; + return addHeapObject(ret); + }; + module2.exports.__wbg_next_6574e1a8a62d1055 = function() { + return handleError(function(arg0) { + const ret = getObject(arg0).next(); + return addHeapObject(ret); + }, arguments); + }; + module2.exports.__wbg_queueMicrotask_97d92b4fcc8a61c5 = function(arg0) { + queueMicrotask(getObject(arg0)); + }; + module2.exports.__wbg_queueMicrotask_d3219def82552485 = function(arg0) { + const ret = getObject(arg0).queueMicrotask; + return addHeapObject(ret); + }; + module2.exports.__wbg_resolve_4851785c9c5f573d = function(arg0) { + const ret = Promise.resolve(getObject(arg0)); + return addHeapObject(ret); + }; + module2.exports.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) { + getObject(arg0)[arg1 >>> 0] = takeObject(arg2); + }; + module2.exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) { + getObject(arg0)[takeObject(arg1)] = takeObject(arg2); + }; + module2.exports.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) { + getObject(arg0).set(getObject(arg1), arg2 >>> 0); + }; + module2.exports.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() { + const ret = typeof global === "undefined" ? null : global; + return isLikeNone(ret) ? 0 : addHeapObject(ret); + }; + module2.exports.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() { + const ret = typeof globalThis === "undefined" ? null : globalThis; + return isLikeNone(ret) ? 0 : addHeapObject(ret); + }; + module2.exports.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() { + const ret = typeof self === "undefined" ? null : self; + return isLikeNone(ret) ? 0 : addHeapObject(ret); + }; + module2.exports.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() { + const ret = typeof window === "undefined" ? null : window; + return isLikeNone(ret) ? 0 : addHeapObject(ret); + }; + module2.exports.__wbg_then_44b73946d2fb3e7d = function(arg0, arg1) { + const ret = getObject(arg0).then(getObject(arg1)); + return addHeapObject(ret); + }; + module2.exports.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) { + const ret = getObject(arg0).value; + return addHeapObject(ret); + }; + module2.exports.__wbindgen_bigint_from_i64 = function(arg0) { + const ret = arg0; + return addHeapObject(ret); + }; + module2.exports.__wbindgen_bigint_from_u64 = function(arg0) { + const ret = BigInt.asUintN(64, arg0); + return addHeapObject(ret); + }; + module2.exports.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) { + const v = getObject(arg1); + const ret = typeof v === "bigint" ? v : void 0; + getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true); + }; + module2.exports.__wbindgen_boolean_get = function(arg0) { + const v = getObject(arg0); + const ret = typeof v === "boolean" ? v ? 1 : 0 : 2; + return ret; + }; + module2.exports.__wbindgen_cb_drop = function(arg0) { + const obj = takeObject(arg0).original; + if (obj.cnt-- == 1) { + obj.a = 0; + return true; + } + const ret = false; + return ret; + }; + module2.exports.__wbindgen_closure_wrapper6775 = function(arg0, arg1, arg2) { + const ret = makeMutClosure(arg0, arg1, 923, __wbg_adapter_50); + return addHeapObject(ret); + }; + module2.exports.__wbindgen_debug_string = function(arg0, arg1) { + const ret = debugString(getObject(arg1)); + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); + }; + module2.exports.__wbindgen_error_new = function(arg0, arg1) { + const ret = new Error(getStringFromWasm0(arg0, arg1)); + return addHeapObject(ret); + }; + module2.exports.__wbindgen_in = function(arg0, arg1) { + const ret = getObject(arg0) in getObject(arg1); + return ret; + }; + module2.exports.__wbindgen_is_bigint = function(arg0) { + const ret = typeof getObject(arg0) === "bigint"; + return ret; + }; + module2.exports.__wbindgen_is_falsy = function(arg0) { + const ret = !getObject(arg0); + return ret; + }; + module2.exports.__wbindgen_is_function = function(arg0) { + const ret = typeof getObject(arg0) === "function"; + return ret; + }; + module2.exports.__wbindgen_is_object = function(arg0) { + const val = getObject(arg0); + const ret = typeof val === "object" && val !== null; + return ret; + }; + module2.exports.__wbindgen_is_string = function(arg0) { + const ret = typeof getObject(arg0) === "string"; + return ret; + }; + module2.exports.__wbindgen_is_undefined = function(arg0) { + const ret = getObject(arg0) === void 0; + return ret; + }; + module2.exports.__wbindgen_jsval_eq = function(arg0, arg1) { + const ret = getObject(arg0) === getObject(arg1); + return ret; + }; + module2.exports.__wbindgen_jsval_loose_eq = function(arg0, arg1) { + const ret = getObject(arg0) == getObject(arg1); + return ret; + }; + module2.exports.__wbindgen_memory = function() { + const ret = wasm.memory; + return addHeapObject(ret); + }; + module2.exports.__wbindgen_number_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof obj === "number" ? obj : void 0; + getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true); + }; + module2.exports.__wbindgen_number_new = function(arg0) { + const ret = arg0; + return addHeapObject(ret); + }; + module2.exports.__wbindgen_object_clone_ref = function(arg0) { + const ret = getObject(arg0); + return addHeapObject(ret); + }; + module2.exports.__wbindgen_object_drop_ref = function(arg0) { + takeObject(arg0); + }; + module2.exports.__wbindgen_string_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof obj === "string" ? obj : void 0; + var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3); + var len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); + }; + module2.exports.__wbindgen_string_new = function(arg0, arg1) { + const ret = getStringFromWasm0(arg0, arg1); + return addHeapObject(ret); + }; + module2.exports.__wbindgen_throw = function(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); + }; + var { Buffer: Buffer2 } = require("node:buffer"); + var bytes = Buffer2.from("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", "base64"); + var wasmModule = new WebAssembly.Module(bytes); + var wasmInstance = new WebAssembly.Instance(wasmModule, imports); + wasm = wasmInstance.exports; + module2.exports.__wasm = wasm; + } +}); + +// src/internal.ts +var internal_exports = {}; +__export(internal_exports, { + findTopLevelAwaits: () => findTopLevelAwaits, + getFirstExpression: () => getFirstExpression, + isRecoverableError: () => isRecoverableError, + isValidSyntax: () => isValidSyntax, + tokenize: () => tokenize, + transformModuleSyntax: () => transformModuleSyntax, + transformSync: () => transformSync +}); +module.exports = __toCommonJS(internal_exports); +var import_wasm = __toESM(require_wasm()); +var DEFAULT_OPTIONS = { + mode: "strip-only", + deprecatedTsModuleAsError: true +}; +var DEFAULT_TRANSFORM_OPTIONS = { + mode: "transform", + deprecatedTsModuleAsError: true, + transform: { + verbatimModuleSyntax: true, + nativeClassProperties: true, + noEmptyExport: true, + importNotUsedAsValues: "preserve" + } +}; +function transformSync(source, options) { + const input = `${source ?? ""}`; + const defaults = options?.mode === "transform" ? DEFAULT_TRANSFORM_OPTIONS : DEFAULT_OPTIONS; + return import_wasm.default.transformSync(input, { ...defaults, ...options }); +} +function transformModuleSyntax(source) { + return import_wasm.default.transformModuleSyntax(`${source ?? ""}`); +} +function getFirstExpression(source, startColumn) { + return import_wasm.default.getFirstExpression(`${source ?? ""}`, startColumn); +} +function isValidSyntax(source) { + return import_wasm.default.isValidSyntax(`${source ?? ""}`); +} +function isRecoverableError(source) { + return import_wasm.default.isRecoverableError(`${source ?? ""}`); +} +function tokenize(source) { + return import_wasm.default.tokenize(`${source ?? ""}`); +} +function findTopLevelAwaits(source) { + return import_wasm.default.findTopLevelAwaits(`${source ?? ""}`); +} +// Annotate the CommonJS export names for ESM import in node: +0 && (module.exports = { + findTopLevelAwaits, + getFirstExpression, + isRecoverableError, + isValidSyntax, + tokenize, + transformModuleSyntax, + transformSync +}); diff --git a/deps/amaro/dist/package.json b/deps/amaro/dist/package.json index 7fa9644440d..59912ed5ce7 100644 --- a/deps/amaro/dist/package.json +++ b/deps/amaro/dist/package.json @@ -1,14 +1,11 @@ { - "name": "@swc/wasm-typescript", - "collaborators": [ - "강동윤 " - ], - "description": "wasm module for swc", - "version": "1.15.43", + "name": "amaro", + "description": "Node.js TypeScript and REPL helpers built on SWC, compiled to WebAssembly", + "version": "1.2.0", "license": "Apache-2.0", "repository": { "type": "git", - "url": "https://github.com/swc-project/swc.git" + "url": "https://github.com/nodejs/amaro.git" }, "files": [ "wasm.js", @@ -16,4 +13,4 @@ ], "main": "wasm.js", "types": "wasm.d.ts" -} \ No newline at end of file +} diff --git a/deps/amaro/dist/register-strip.mjs b/deps/amaro/dist/register-strip.mjs index 3a6134ba69a..7ffde8fba54 100644 --- a/deps/amaro/dist/register-strip.mjs +++ b/deps/amaro/dist/register-strip.mjs @@ -1,3 +1,9 @@ -import { register } from "node:module"; +import module from "node:module"; -register("./strip-loader.js", import.meta.url); +if (typeof module.registerHooks === "function") { + const { default: loader } = await import("./strip-loader.js"); + module.registerHooks({ load: loader.loadSync }); +} else { + // Node.js versions without `module.registerHooks()`. + module.register("./strip-loader.js", import.meta.url); +} diff --git a/deps/amaro/dist/register-transform.mjs b/deps/amaro/dist/register-transform.mjs index f244052b233..54f8b0bca63 100644 --- a/deps/amaro/dist/register-transform.mjs +++ b/deps/amaro/dist/register-transform.mjs @@ -1,4 +1,4 @@ -import { register } from "node:module"; +import module from "node:module"; import { emitWarning, env, execArgv } from "node:process"; const hasSourceMaps = @@ -9,4 +9,10 @@ if (!hasSourceMaps) { emitWarning("Source maps are disabled, stack traces will not be accurate"); } -register("./transform-loader.js", import.meta.url); +if (typeof module.registerHooks === "function") { + const { default: loader } = await import("./transform-loader.js"); + module.registerHooks({ load: loader.loadSync }); +} else { + // Node.js versions without `module.registerHooks()`. + module.register("./transform-loader.js", import.meta.url); +} diff --git a/deps/amaro/dist/strip-loader.d.ts b/deps/amaro/dist/strip-loader.d.ts index 7e2300c7472..2ed814838cb 100644 --- a/deps/amaro/dist/strip-loader.d.ts +++ b/deps/amaro/dist/strip-loader.d.ts @@ -1,2 +1,11 @@ import type { LoadFnOutput, LoadHookContext } from "node:module"; -export declare function load(url: string, context: LoadHookContext, nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput | Promise): Promise; +type NextLoad = (url: string, context?: Partial) => LoadFnOutput; +export declare function loadSync(url: string, context: LoadHookContext, nextLoad: NextLoad): LoadFnOutput | { + format: string; + source: string; +}; +export declare function load(url: string, context: LoadHookContext, nextLoad: (url: string, context?: Partial) => LoadFnOutput | Promise): Promise; +export {}; diff --git a/deps/amaro/dist/strip-loader.js b/deps/amaro/dist/strip-loader.js index e604e154f61..025988b2269 100644 --- a/deps/amaro/dist/strip-loader.js +++ b/deps/amaro/dist/strip-loader.js @@ -1,34 +1,70 @@ "use strict"; -import { fileURLToPath } from "node:url"; -import { isSwcError, wrapAndReThrowSwcError } from "./errors.js"; -import { transformSync } from "./index.js"; -export async function load(url, context, nextLoad) { - const { format } = context; - if (format?.endsWith("-typescript")) { - try { - const { source } = await nextLoad(url, { - ...context, - format - }); - const { code } = transformSync(source.toString(), { - mode: "strip-only", - filename: fileURLToPath(url) - }); - return { - format: format.replace("-typescript", ""), - // Source map is not necessary in strip-only mode. However, to map the source - // file in debuggers to the original TypeScript source, add a sourceURL magic - // comment to hint that it is a generated source. - source: `${code} +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); +var strip_loader_exports = {}; +__export(strip_loader_exports, { + load: () => load, + loadSync: () => loadSync +}); +module.exports = __toCommonJS(strip_loader_exports); +var import_node_url = require("node:url"); +var import_errors = require("./errors.js"); +var import_index = require("./index.js"); +function strip(url, format, source) { + try { + const { code } = (0, import_index.transformSync)(source.toString(), { + mode: "strip-only", + filename: (0, import_node_url.fileURLToPath)(url) + }); + return { + format: format.replace("-typescript", ""), + // Source map is not necessary in strip-only mode. However, to map the source + // file in debuggers to the original TypeScript source, add a sourceURL magic + // comment to hint that it is a generated source. + source: `${code} //# sourceURL=${url}` - }; - } catch (error) { - if (isSwcError(error)) { - wrapAndReThrowSwcError(error); - } - throw error; + }; + } catch (error) { + if ((0, import_errors.isSwcError)(error)) { + (0, import_errors.wrapAndReThrowSwcError)(error); } + throw error; + } +} +function loadSync(url, context, nextLoad) { + const { format } = context; + if (format?.endsWith("-typescript")) { + const { source } = nextLoad(url, { ...context, format }); + return strip(url, format, source); + } + return nextLoad(url, context); +} +async function load(url, context, nextLoad) { + const { format } = context; + if (format?.endsWith("-typescript")) { + const { source } = await nextLoad(url, { ...context, format }); + return strip(url, format, source); } return nextLoad(url, context); } +// Annotate the CommonJS export names for ESM import in node: +0 && (module.exports = { + load, + loadSync +}); diff --git a/deps/amaro/dist/transform-loader.d.ts b/deps/amaro/dist/transform-loader.d.ts index 7e2300c7472..2ed814838cb 100644 --- a/deps/amaro/dist/transform-loader.d.ts +++ b/deps/amaro/dist/transform-loader.d.ts @@ -1,2 +1,11 @@ import type { LoadFnOutput, LoadHookContext } from "node:module"; -export declare function load(url: string, context: LoadHookContext, nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput | Promise): Promise; +type NextLoad = (url: string, context?: Partial) => LoadFnOutput; +export declare function loadSync(url: string, context: LoadHookContext, nextLoad: NextLoad): LoadFnOutput | { + format: string; + source: string; +}; +export declare function load(url: string, context: LoadHookContext, nextLoad: (url: string, context?: Partial) => LoadFnOutput | Promise): Promise; +export {}; diff --git a/deps/amaro/dist/transform-loader.js b/deps/amaro/dist/transform-loader.js index 7b971068256..e44a6d962b3 100644 --- a/deps/amaro/dist/transform-loader.js +++ b/deps/amaro/dist/transform-loader.js @@ -1,39 +1,75 @@ "use strict"; -import { fileURLToPath } from "node:url"; -import { isSwcError, wrapAndReThrowSwcError } from "./errors.js"; -import { transformSync } from "./index.js"; -export async function load(url, context, nextLoad) { - const { format } = context; - if (format?.endsWith("-typescript")) { - try { - const { source } = await nextLoad(url, { - ...context, - format - }); - const { code, map } = transformSync(source.toString(), { - mode: "transform", - sourceMap: true, - filename: fileURLToPath(url) - }); - let output = code; - if (map) { - const base64SourceMap = Buffer.from(map).toString("base64"); - output = `${code} +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); +var transform_loader_exports = {}; +__export(transform_loader_exports, { + load: () => load, + loadSync: () => loadSync +}); +module.exports = __toCommonJS(transform_loader_exports); +var import_node_url = require("node:url"); +var import_errors = require("./errors.js"); +var import_index = require("./index.js"); +function transform(url, format, source) { + try { + const { code, map } = (0, import_index.transformSync)(source.toString(), { + mode: "transform", + sourceMap: true, + filename: (0, import_node_url.fileURLToPath)(url) + }); + let output = code; + if (map) { + const base64SourceMap = Buffer.from(map).toString("base64"); + output = `${code} //# sourceMappingURL=data:application/json;base64,${base64SourceMap}`; - } - return { - format: format.replace("-typescript", ""), - source: `${output} + } + return { + format: format.replace("-typescript", ""), + source: `${output} //# sourceURL=${url}` - }; - } catch (error) { - if (isSwcError(error)) { - wrapAndReThrowSwcError(error); - } - throw error; + }; + } catch (error) { + if ((0, import_errors.isSwcError)(error)) { + (0, import_errors.wrapAndReThrowSwcError)(error); } + throw error; + } +} +function loadSync(url, context, nextLoad) { + const { format } = context; + if (format?.endsWith("-typescript")) { + const { source } = nextLoad(url, { ...context, format }); + return transform(url, format, source); + } + return nextLoad(url, context); +} +async function load(url, context, nextLoad) { + const { format } = context; + if (format?.endsWith("-typescript")) { + const { source } = await nextLoad(url, { ...context, format }); + return transform(url, format, source); } return nextLoad(url, context); } +// Annotate the CommonJS export names for ESM import in node: +0 && (module.exports = { + load, + loadSync +}); diff --git a/deps/amaro/dist/transform.d.ts b/deps/amaro/dist/transform.d.ts deleted file mode 100644 index 2d10478abe5..00000000000 --- a/deps/amaro/dist/transform.d.ts +++ /dev/null @@ -1,2 +0,0 @@ -import type { Options, TransformOutput } from "../lib/wasm"; -export declare function transformSync(source: string, options?: Options): TransformOutput; diff --git a/deps/amaro/lib/wasm.d.ts b/deps/amaro/lib/wasm.d.ts index 0fb4e65fd58..32f54ce66c2 100644 --- a/deps/amaro/lib/wasm.d.ts +++ b/deps/amaro/lib/wasm.d.ts @@ -3,8 +3,36 @@ export declare function transform(src: string | Uint8Array, opts?: Options): Promise; export declare function transformSync(src: string | Uint8Array, opts?: Options): TransformOutput; +export declare function transformModuleSyntax(src: string | Uint8Array): ModuleSyntaxTransformOutput; +export declare function getFirstExpression(src: string | Uint8Array, startColumn: number): string; +export declare function isValidSyntax(src: string | Uint8Array): boolean; +export declare function isRecoverableError(src: string | Uint8Array): boolean; +export declare function tokenize(src: string | Uint8Array): Token[]; +export declare function findTopLevelAwaits(src: string | Uint8Array): TopLevelAwaitLocation[]; export type { Options, TransformOutput }; +export type TokenKind = "keyword" | "identifier" | "number" | "bigint" | "string" | "template" | "regexp" | "comment" | "punctuator"; + +export interface Token { + kind: TokenKind; + /** Zero-based UTF-16 offset, inclusive. */ + start: number; + /** Zero-based UTF-16 offset, exclusive. */ + end: number; +} + +export interface TopLevelAwaitLocation { + /** One-based line number. */ + line: number; + /** Zero-based UTF-16 column. */ + column: number; +} + +export interface ModuleSyntaxTransformOutput { + code: string; + hadModuleSyntax: boolean; +} + interface Options { diff --git a/deps/amaro/lib/wasm.js b/deps/amaro/lib/wasm.js new file mode 100644 index 00000000000..1b8cd0e81df --- /dev/null +++ b/deps/amaro/lib/wasm.js @@ -0,0 +1,755 @@ + +let imports = {}; +imports['__wbindgen_placeholder__'] = module.exports; +let wasm; +const { TextDecoder, TextEncoder } = require(`util`); + +const heap = new Array(128).fill(undefined); + +heap.push(undefined, null, true, false); + +function getObject(idx) { return heap[idx]; } + +let heap_next = heap.length; + +function addHeapObject(obj) { + if (heap_next === heap.length) heap.push(heap.length + 1); + const idx = heap_next; + heap_next = heap[idx]; + + heap[idx] = obj; + return idx; +} + +function handleError(f, args) { + try { + return f.apply(this, args); + } catch (e) { + wasm.__wbindgen_export_0(addHeapObject(e)); + } +} + +let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true }); + +cachedTextDecoder.decode(); + +let cachedUint8ArrayMemory0 = null; + +function getUint8ArrayMemory0() { + if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) { + cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8ArrayMemory0; +} + +function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); +} + +function getCachedStringFromWasm0(ptr, len) { + if (ptr === 0) { + return getObject(len); + } else { + return getStringFromWasm0(ptr, len); + } +} + +function dropObject(idx) { + if (idx < 132) return; + heap[idx] = heap_next; + heap_next = idx; +} + +function takeObject(idx) { + const ret = getObject(idx); + dropObject(idx); + return ret; +} + +function isLikeNone(x) { + return x === undefined || x === null; +} + +let cachedDataViewMemory0 = null; + +function getDataViewMemory0() { + if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) { + cachedDataViewMemory0 = new DataView(wasm.memory.buffer); + } + return cachedDataViewMemory0; +} + +const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined') + ? { register: () => {}, unregister: () => {} } + : new FinalizationRegistry(state => { + wasm.__wbindgen_export_1.get(state.dtor)(state.a, state.b) +}); + +function makeMutClosure(arg0, arg1, dtor, f) { + const state = { a: arg0, b: arg1, cnt: 1, dtor }; + const real = (...args) => { + // First up with a closure we increment the internal reference + // count. This ensures that the Rust closure environment won't + // be deallocated while we're invoking it. + state.cnt++; + const a = state.a; + state.a = 0; + try { + return f(a, state.b, ...args); + } finally { + if (--state.cnt === 0) { + wasm.__wbindgen_export_1.get(state.dtor)(a, state.b); + CLOSURE_DTORS.unregister(state); + } else { + state.a = a; + } + } + }; + real.original = state; + CLOSURE_DTORS.register(real, state, state); + return real; +} + +function debugString(val) { + // primitive types + const type = typeof val; + if (type == 'number' || type == 'boolean' || val == null) { + return `${val}`; + } + if (type == 'string') { + return `"${val}"`; + } + if (type == 'symbol') { + const description = val.description; + if (description == null) { + return 'Symbol'; + } else { + return `Symbol(${description})`; + } + } + if (type == 'function') { + const name = val.name; + if (typeof name == 'string' && name.length > 0) { + return `Function(${name})`; + } else { + return 'Function'; + } + } + // objects + if (Array.isArray(val)) { + const length = val.length; + let debug = '['; + if (length > 0) { + debug += debugString(val[0]); + } + for(let i = 1; i < length; i++) { + debug += ', ' + debugString(val[i]); + } + debug += ']'; + return debug; + } + // Test for built-in + const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); + let className; + if (builtInMatches && builtInMatches.length > 1) { + className = builtInMatches[1]; + } else { + // Failed to match the standard '[object ClassName]' + return toString.call(val); + } + if (className == 'Object') { + // we're a user defined class or Object + // JSON.stringify avoids problems with cycles, and is generally much + // easier than looping through ownProperties of `val`. + try { + return 'Object(' + JSON.stringify(val) + ')'; + } catch (_) { + return 'Object'; + } + } + // errors + if (val instanceof Error) { + return `${val.name}: ${val.message}\n${val.stack}`; + } + // TODO we could test for more things here, like `Set`s and `Map`s. + return className; +} + +let WASM_VECTOR_LEN = 0; + +let cachedTextEncoder = new TextEncoder('utf-8'); + +const encodeString = (typeof cachedTextEncoder.encodeInto === 'function' + ? function (arg, view) { + return cachedTextEncoder.encodeInto(arg, view); +} + : function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; +}); + +function passStringToWasm0(arg, malloc, realloc) { + + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length, 1) >>> 0; + getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len, 1) >>> 0; + + const mem = getUint8ArrayMemory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; + const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len); + const ret = encodeString(arg, view); + + offset += ret.written; + ptr = realloc(ptr, len, offset, 1) >>> 0; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} +/** + * @param {any} input + * @param {any} options + * @returns {Promise} + */ +module.exports.transform = function(input, options) { + const ret = wasm.transform(addHeapObject(input), addHeapObject(options)); + return takeObject(ret); +}; + +/** + * @param {any} input + * @param {any} options + * @returns {any} + */ +module.exports.transformSync = function(input, options) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.transformSync(retptr, addHeapObject(input), addHeapObject(options)); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return takeObject(r0); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } +}; + +/** + * @param {any} input + * @returns {any} + */ +module.exports.transformModuleSyntax = function(input) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.transformModuleSyntax(retptr, addHeapObject(input)); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return takeObject(r0); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } +}; + +/** + * @param {any} input + * @param {number} start_column + * @returns {string} + */ +module.exports.getFirstExpression = function(input, start_column) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.getFirstExpression(retptr, addHeapObject(input), start_column); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true); + if (r3) { + throw takeObject(r2); + } + var v1 = getCachedStringFromWasm0(r0, r1); + if (r0 !== 0) { wasm.__wbindgen_export_4(r0, r1, 1); } + return v1; + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } +}; + +/** + * @param {any} input + * @returns {boolean} + */ +module.exports.isValidSyntax = function(input) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.isValidSyntax(retptr, addHeapObject(input)); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return r0 !== 0; + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } +}; + +/** + * @param {any} input + * @returns {boolean} + */ +module.exports.isRecoverableError = function(input) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.isRecoverableError(retptr, addHeapObject(input)); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return r0 !== 0; + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } +}; + +/** + * Returns compact tokens for syntax highlighting, including a partial prefix + * when the input is incomplete or invalid. + * @param {any} input + * @returns {any} + */ +module.exports.tokenize = function(input) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.tokenize(retptr, addHeapObject(input)); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return takeObject(r0); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } +}; + +/** + * Returns module-scope await locations in source order using Acorn + * coordinates. + * @param {any} input + * @returns {any} + */ +module.exports.findTopLevelAwaits = function(input) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.findTopLevelAwaits(retptr, addHeapObject(input)); + var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); + var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); + var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return takeObject(r0); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } +}; + +function __wbg_adapter_50(arg0, arg1, arg2) { + wasm.__wbindgen_export_5(arg0, arg1, addHeapObject(arg2)); +} + +function __wbg_adapter_83(arg0, arg1, arg2, arg3) { + wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); +} + +module.exports.__wbg_buffer_609cc3eee51ed158 = function(arg0) { + const ret = getObject(arg0).buffer; + return addHeapObject(ret); +}; + +module.exports.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) { + const ret = getObject(arg0).call(getObject(arg1)); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_call_7cccdd69e0791ae2 = function() { return handleError(function (arg0, arg1, arg2) { + const ret = getObject(arg0).call(getObject(arg1), getObject(arg2)); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_done_769e5ede4b31c67b = function(arg0) { + const ret = getObject(arg0).done; + return ret; +}; + +module.exports.__wbg_entries_3265d4158b33e5dc = function(arg0) { + const ret = Object.entries(getObject(arg0)); + return addHeapObject(ret); +}; + +module.exports.__wbg_get_67b2ba62fc30de12 = function() { return handleError(function (arg0, arg1) { + const ret = Reflect.get(getObject(arg0), getObject(arg1)); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) { + const ret = getObject(arg0)[arg1 >>> 0]; + return addHeapObject(ret); +}; + +module.exports.__wbg_getwithrefkey_1dc361bd10053bfe = function(arg0, arg1) { + const ret = getObject(arg0)[getObject(arg1)]; + return addHeapObject(ret); +}; + +module.exports.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof ArrayBuffer; + } catch (_) { + result = false; + } + const ret = result; + return ret; +}; + +module.exports.__wbg_instanceof_Map_f3469ce2244d2430 = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof Map; + } catch (_) { + result = false; + } + const ret = result; + return ret; +}; + +module.exports.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof Uint8Array; + } catch (_) { + result = false; + } + const ret = result; + return ret; +}; + +module.exports.__wbg_isArray_a1eab7e0d067391b = function(arg0) { + const ret = Array.isArray(getObject(arg0)); + return ret; +}; + +module.exports.__wbg_isSafeInteger_343e2beeeece1bb0 = function(arg0) { + const ret = Number.isSafeInteger(getObject(arg0)); + return ret; +}; + +module.exports.__wbg_iterator_9a24c88df860dc65 = function() { + const ret = Symbol.iterator; + return addHeapObject(ret); +}; + +module.exports.__wbg_length_a446193dc22c12f8 = function(arg0) { + const ret = getObject(arg0).length; + return ret; +}; + +module.exports.__wbg_length_e2d2a49132c1b256 = function(arg0) { + const ret = getObject(arg0).length; + return ret; +}; + +module.exports.__wbg_new_23a2665fac83c611 = function(arg0, arg1) { + try { + var state0 = {a: arg0, b: arg1}; + var cb0 = (arg0, arg1) => { + const a = state0.a; + state0.a = 0; + try { + return __wbg_adapter_83(a, state0.b, arg0, arg1); + } finally { + state0.a = a; + } + }; + const ret = new Promise(cb0); + return addHeapObject(ret); + } finally { + state0.a = state0.b = 0; + } +}; + +module.exports.__wbg_new_405e22f390576ce2 = function() { + const ret = new Object(); + return addHeapObject(ret); +}; + +module.exports.__wbg_new_78feb108b6472713 = function() { + const ret = new Array(); + return addHeapObject(ret); +}; + +module.exports.__wbg_new_a12002a7f91c75be = function(arg0) { + const ret = new Uint8Array(getObject(arg0)); + return addHeapObject(ret); +}; + +module.exports.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) { + var v0 = getCachedStringFromWasm0(arg0, arg1); + const ret = new Function(v0); + return addHeapObject(ret); +}; + +module.exports.__wbg_next_25feadfc0913fea9 = function(arg0) { + const ret = getObject(arg0).next; + return addHeapObject(ret); +}; + +module.exports.__wbg_next_6574e1a8a62d1055 = function() { return handleError(function (arg0) { + const ret = getObject(arg0).next(); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_queueMicrotask_97d92b4fcc8a61c5 = function(arg0) { + queueMicrotask(getObject(arg0)); +}; + +module.exports.__wbg_queueMicrotask_d3219def82552485 = function(arg0) { + const ret = getObject(arg0).queueMicrotask; + return addHeapObject(ret); +}; + +module.exports.__wbg_resolve_4851785c9c5f573d = function(arg0) { + const ret = Promise.resolve(getObject(arg0)); + return addHeapObject(ret); +}; + +module.exports.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) { + getObject(arg0)[arg1 >>> 0] = takeObject(arg2); +}; + +module.exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) { + getObject(arg0)[takeObject(arg1)] = takeObject(arg2); +}; + +module.exports.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) { + getObject(arg0).set(getObject(arg1), arg2 >>> 0); +}; + +module.exports.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() { + const ret = typeof global === 'undefined' ? null : global; + return isLikeNone(ret) ? 0 : addHeapObject(ret); +}; + +module.exports.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() { + const ret = typeof globalThis === 'undefined' ? null : globalThis; + return isLikeNone(ret) ? 0 : addHeapObject(ret); +}; + +module.exports.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() { + const ret = typeof self === 'undefined' ? null : self; + return isLikeNone(ret) ? 0 : addHeapObject(ret); +}; + +module.exports.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() { + const ret = typeof window === 'undefined' ? null : window; + return isLikeNone(ret) ? 0 : addHeapObject(ret); +}; + +module.exports.__wbg_then_44b73946d2fb3e7d = function(arg0, arg1) { + const ret = getObject(arg0).then(getObject(arg1)); + return addHeapObject(ret); +}; + +module.exports.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) { + const ret = getObject(arg0).value; + return addHeapObject(ret); +}; + +module.exports.__wbindgen_bigint_from_i64 = function(arg0) { + const ret = arg0; + return addHeapObject(ret); +}; + +module.exports.__wbindgen_bigint_from_u64 = function(arg0) { + const ret = BigInt.asUintN(64, arg0); + return addHeapObject(ret); +}; + +module.exports.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) { + const v = getObject(arg1); + const ret = typeof(v) === 'bigint' ? v : undefined; + getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true); +}; + +module.exports.__wbindgen_boolean_get = function(arg0) { + const v = getObject(arg0); + const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2; + return ret; +}; + +module.exports.__wbindgen_cb_drop = function(arg0) { + const obj = takeObject(arg0).original; + if (obj.cnt-- == 1) { + obj.a = 0; + return true; + } + const ret = false; + return ret; +}; + +module.exports.__wbindgen_closure_wrapper6775 = function(arg0, arg1, arg2) { + const ret = makeMutClosure(arg0, arg1, 923, __wbg_adapter_50); + return addHeapObject(ret); +}; + +module.exports.__wbindgen_debug_string = function(arg0, arg1) { + const ret = debugString(getObject(arg1)); + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); +}; + +module.exports.__wbindgen_error_new = function(arg0, arg1) { + const ret = new Error(getStringFromWasm0(arg0, arg1)); + return addHeapObject(ret); +}; + +module.exports.__wbindgen_in = function(arg0, arg1) { + const ret = getObject(arg0) in getObject(arg1); + return ret; +}; + +module.exports.__wbindgen_is_bigint = function(arg0) { + const ret = typeof(getObject(arg0)) === 'bigint'; + return ret; +}; + +module.exports.__wbindgen_is_falsy = function(arg0) { + const ret = !getObject(arg0); + return ret; +}; + +module.exports.__wbindgen_is_function = function(arg0) { + const ret = typeof(getObject(arg0)) === 'function'; + return ret; +}; + +module.exports.__wbindgen_is_object = function(arg0) { + const val = getObject(arg0); + const ret = typeof(val) === 'object' && val !== null; + return ret; +}; + +module.exports.__wbindgen_is_string = function(arg0) { + const ret = typeof(getObject(arg0)) === 'string'; + return ret; +}; + +module.exports.__wbindgen_is_undefined = function(arg0) { + const ret = getObject(arg0) === undefined; + return ret; +}; + +module.exports.__wbindgen_jsval_eq = function(arg0, arg1) { + const ret = getObject(arg0) === getObject(arg1); + return ret; +}; + +module.exports.__wbindgen_jsval_loose_eq = function(arg0, arg1) { + const ret = getObject(arg0) == getObject(arg1); + return ret; +}; + +module.exports.__wbindgen_memory = function() { + const ret = wasm.memory; + return addHeapObject(ret); +}; + +module.exports.__wbindgen_number_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof(obj) === 'number' ? obj : undefined; + getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true); +}; + +module.exports.__wbindgen_number_new = function(arg0) { + const ret = arg0; + return addHeapObject(ret); +}; + +module.exports.__wbindgen_object_clone_ref = function(arg0) { + const ret = getObject(arg0); + return addHeapObject(ret); +}; + +module.exports.__wbindgen_object_drop_ref = function(arg0) { + takeObject(arg0); +}; + +module.exports.__wbindgen_string_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof(obj) === 'string' ? obj : undefined; + var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3); + var len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); +}; + +module.exports.__wbindgen_string_new = function(arg0, arg1) { + const ret = getStringFromWasm0(arg0, arg1); + return addHeapObject(ret); +}; + +module.exports.__wbindgen_throw = function(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); +}; + + + +const { Buffer } = require('node:buffer'); +const bytes = Buffer.from('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', 'base64'); + +const wasmModule = new WebAssembly.Module(bytes); +const wasmInstance = new WebAssembly.Instance(wasmModule, imports); +wasm = wasmInstance.exports; +module.exports.__wasm = wasm; + diff --git a/deps/amaro/lib/wasm_bg.wasm.d.ts b/deps/amaro/lib/wasm_bg.wasm.d.ts index 550d0edb341..16dbd9540b6 100644 --- a/deps/amaro/lib/wasm_bg.wasm.d.ts +++ b/deps/amaro/lib/wasm_bg.wasm.d.ts @@ -1,7 +1,13 @@ /* tslint:disable */ /* eslint-disable */ export const memory: WebAssembly.Memory; +export const findTopLevelAwaits: (a: number, b: number) => void; +export const getFirstExpression: (a: number, b: number, c: number) => void; +export const isRecoverableError: (a: number, b: number) => void; +export const isValidSyntax: (a: number, b: number) => void; +export const tokenize: (a: number, b: number) => void; export const transform: (a: number, b: number) => number; +export const transformModuleSyntax: (a: number, b: number) => void; export const transformSync: (a: number, b: number, c: number) => void; export const __wbindgen_export_0: (a: number) => void; export const __wbindgen_export_1: WebAssembly.Table; @@ -9,4 +15,5 @@ export const __wbindgen_export_2: (a: number, b: number) => number; export const __wbindgen_export_3: (a: number, b: number, c: number, d: number) => number; export const __wbindgen_add_to_stack_pointer: (a: number) => number; export const __wbindgen_export_4: (a: number, b: number, c: number) => void; -export const __wbindgen_export_5: (a: number, b: number, c: number, d: number) => void; +export const __wbindgen_export_5: (a: number, b: number, c: number) => void; +export const __wbindgen_export_6: (a: number, b: number, c: number, d: number) => void; diff --git a/deps/amaro/package.json b/deps/amaro/package.json index 4bf579a0f0c..dd9df54e6c6 100644 --- a/deps/amaro/package.json +++ b/deps/amaro/package.json @@ -1,6 +1,6 @@ { "name": "amaro", - "version": "1.1.11", + "version": "1.3.0", "description": "Node.js TypeScript wrapper", "license": "MIT", "type": "commonjs", @@ -49,6 +49,7 @@ }, "files": [ "dist", + "lib/wasm.js", "lib/**/*.d.ts", "LICENSE.md" ], diff --git a/src/amaro_version.h b/src/amaro_version.h index b3b51a9a28f..e6f88e9854c 100644 --- a/src/amaro_version.h +++ b/src/amaro_version.h @@ -2,5 +2,5 @@ // Refer to tools/dep_updaters/update-amaro.sh #ifndef SRC_AMARO_VERSION_H_ #define SRC_AMARO_VERSION_H_ -#define AMARO_VERSION "1.1.11" +#define AMARO_VERSION "1.3.0" #endif // SRC_AMARO_VERSION_H_ From 65670b858da34e39811547102d4cb01b1a8066ab Mon Sep 17 00:00:00 2001 From: Geoffrey Booth Date: Mon, 2 Nov 2026 09:25:30 -0800 Subject: [PATCH 201/331] deps: load amaro from dist/internal.js amaro 1.3.0 turned dist/index.js into a thin wrapper that requires ./internal.js, where the implementation now lives. Register and require internal.js as the built-in instead of index.js, which would otherwise fail to resolve its sibling. Co-Authored-By: Claude Sonnet 5.5 PR-URL: https://github.com/nodejs/node/pull/66144 Reviewed-By: Aviv Keller Reviewed-By: Geoffrey Booth Reviewed-By: Marco Ippolito --- configure.py | 4 ++-- lib/internal/modules/typescript.js | 2 +- node.gni | 2 +- test/parallel/test-process-versions.js | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/configure.py b/configure.py index d0e6663bc2c..78a2e11ac35 100755 --- a/configure.py +++ b/configure.py @@ -59,7 +59,7 @@ # builtins may be removed later if they have been disabled by options shareable_builtins = {'undici/undici': 'deps/undici/undici.js', - 'amaro/dist/index': 'deps/amaro/dist/index.js' + 'amaro/dist/internal': 'deps/amaro/dist/internal.js' } # create option groups @@ -3008,7 +3008,7 @@ def make_bin_override(): # remove builtins that have been disabled if options.without_amaro: - del shareable_builtins['amaro/dist/index'] + del shareable_builtins['amaro/dist/internal'] # configure shareable builtins output['variables']['node_builtin_shareable_builtins'] = [] diff --git a/lib/internal/modules/typescript.js b/lib/internal/modules/typescript.js index ebe41e308bc..3c33a7befcd 100644 --- a/lib/internal/modules/typescript.js +++ b/lib/internal/modules/typescript.js @@ -34,7 +34,7 @@ const { */ const loadTypeScriptParser = getLazy(() => { assertTypeScript(); - const amaro = require('internal/deps/amaro/dist/index'); + const amaro = require('internal/deps/amaro/dist/internal'); return amaro.transformSync; }); diff --git a/node.gni b/node.gni index af0b066d80e..721fa81a039 100644 --- a/node.gni +++ b/node.gni @@ -18,7 +18,7 @@ declare_args() { # the list between configure.py and GN configurations. node_builtin_shareable_builtins = [ "deps/undici/undici.js", - "deps/amaro/dist/index.js", + "deps/amaro/dist/internal.js", ] } diff --git a/test/parallel/test-process-versions.js b/test/parallel/test-process-versions.js index 420625b01f5..98b20b072dd 100644 --- a/test/parallel/test-process-versions.js +++ b/test/parallel/test-process-versions.js @@ -29,7 +29,7 @@ const expected_keys = [ const hasUndici = process.config.variables.node_builtin_shareable_builtins.includes('deps/undici/undici.js'); -const hasAmaro = process.config.variables.node_builtin_shareable_builtins.includes('deps/amaro/dist/index.js'); +const hasAmaro = process.config.variables.node_builtin_shareable_builtins.includes('deps/amaro/dist/internal.js'); const hasLief = process.config.variables.node_use_lief; if (process.config.variables.node_use_amaro) { From afc241814011a66e01f78bfa4855f04ac67d06df Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 3 Nov 2026 18:48:27 +0000 Subject: [PATCH 202/331] meta: bump step-security/harden-runner from 2.21.1 to 2.22.3 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [step-security/harden-runner](https://github.com/step-security/harden-runner) from 2.21.1 to 2.22.3. - [Release notes](https://github.com/step-security/harden-runner/releases) - [Commits](https://github.com/step-security/harden-runner/compare/e14015d583714f6e62063499dc959a02595150a1...46b06cea07f9e64621fdf066ba77ac6915163d43) --- updated-dependencies: - dependency-name: step-security/harden-runner dependency-version: 2.22.3 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/67191 Reviewed-By: Ulises Gascón Reviewed-By: Antoine du Hamel Reviewed-By: Colin Ihrig Reviewed-By: Luigi Pinca --- .github/workflows/scorecard.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml index 16f1846a81a..f2f2415f524 100644 --- a/.github/workflows/scorecard.yml +++ b/.github/workflows/scorecard.yml @@ -36,7 +36,7 @@ jobs: steps: - name: Harden Runner - uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1 + uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3 with: egress-policy: audit # TODO: change to 'egress-policy: block' after couple of runs From 487cfb3f3759e91f0022dfe606e3e26c8ccc86bb Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 3 Nov 2026 18:48:57 +0000 Subject: [PATCH 203/331] meta: bump rtCamp/action-slack-notify from 2.4.0 to 2.4.1 Bumps [rtCamp/action-slack-notify](https://github.com/rtcamp/action-slack-notify) from 2.4.0 to 2.4.1. - [Release notes](https://github.com/rtcamp/action-slack-notify/releases) - [Commits](https://github.com/rtcamp/action-slack-notify/compare/33ca3be66c6f378fe1610fd1d5258632dbed5e58...06cc13f74fa8d4d2296c09455d91e9453e4025f4) --- updated-dependencies: - dependency-name: rtCamp/action-slack-notify dependency-version: 2.4.1 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/67190 Reviewed-By: Antoine du Hamel Reviewed-By: Colin Ihrig --- .github/workflows/notify-on-push.yml | 4 ++-- .github/workflows/notify-on-review-wanted.yml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/notify-on-push.yml b/.github/workflows/notify-on-push.yml index dfded4d76af..e2a49775320 100644 --- a/.github/workflows/notify-on-push.yml +++ b/.github/workflows/notify-on-push.yml @@ -18,7 +18,7 @@ jobs: runs-on: ubuntu-24.04-arm steps: - name: Slack Notification - uses: rtCamp/action-slack-notify@33ca3be66c6f378fe1610fd1d5258632dbed5e58 # v2.4.0 + uses: rtCamp/action-slack-notify@06cc13f74fa8d4d2296c09455d91e9453e4025f4 # v2.4.1 env: SLACK_COLOR: '#DE512A' SLACK_ICON: https://github.com/nodejs.png?size=48 @@ -50,7 +50,7 @@ jobs: COMMITS: ${{ toJSON(github.event.commits) }} - name: Slack Notification if: ${{ failure() && steps.commit-check.conclusion == 'failure' && github.repository == 'nodejs/node' }} - uses: rtCamp/action-slack-notify@33ca3be66c6f378fe1610fd1d5258632dbed5e58 # v2.4.0 + uses: rtCamp/action-slack-notify@06cc13f74fa8d4d2296c09455d91e9453e4025f4 # v2.4.1 env: SLACK_COLOR: '#DE512A' SLACK_ICON: https://github.com/nodejs.png?size=48 diff --git a/.github/workflows/notify-on-review-wanted.yml b/.github/workflows/notify-on-review-wanted.yml index effc6c209eb..5d5b2a9e5c7 100644 --- a/.github/workflows/notify-on-review-wanted.yml +++ b/.github/workflows/notify-on-review-wanted.yml @@ -34,7 +34,7 @@ jobs: fi - name: Slack Notification - uses: rtCamp/action-slack-notify@33ca3be66c6f378fe1610fd1d5258632dbed5e58 # v2.4.0 + uses: rtCamp/action-slack-notify@06cc13f74fa8d4d2296c09455d91e9453e4025f4 # v2.4.1 env: MSG_MINIMAL: actions url SLACK_COLOR: '#3d85c6' From 73b47ca18c8b47f5a545d9c6ec7e009723600a67 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 3 Nov 2026 18:49:24 +0000 Subject: [PATCH 204/331] tools: bump the eslint group in /tools/eslint with 2 updates Bumps the eslint group in /tools/eslint with 2 updates: [@babel/core](https://github.com/babel/babel/tree/HEAD/packages/babel-core) and [eslint-plugin-jsdoc](https://github.com/gajus/eslint-plugin-jsdoc). Updates `@babel/core` from 8.0.7 to 8.0.9 - [Release notes](https://github.com/babel/babel/releases) - [Changelog](https://github.com/babel/babel/blob/main/CHANGELOG.md) - [Commits](https://github.com/babel/babel/commits/v8.0.9/packages/babel-core) Updates `eslint-plugin-jsdoc` from 65.4.0 to 65.4.2 - [Release notes](https://github.com/gajus/eslint-plugin-jsdoc/releases) - [Commits](https://github.com/gajus/eslint-plugin-jsdoc/compare/v65.4.0...v65.4.2) --- updated-dependencies: - dependency-name: "@babel/core" dependency-version: 8.0.9 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: eslint - dependency-name: eslint-plugin-jsdoc dependency-version: 65.4.2 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: eslint ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/67189 Reviewed-By: Antoine du Hamel Reviewed-By: Colin Ihrig Reviewed-By: Luigi Pinca --- tools/eslint/package-lock.json | 68 ++++++++++------------------------ tools/eslint/package.json | 4 +- 2 files changed, 22 insertions(+), 50 deletions(-) diff --git a/tools/eslint/package-lock.json b/tools/eslint/package-lock.json index dd6b553cfea..fa11a7f1388 100644 --- a/tools/eslint/package-lock.json +++ b/tools/eslint/package-lock.json @@ -8,7 +8,7 @@ "name": "eslint-tools", "version": "0.0.0", "dependencies": { - "@babel/core": "^8.0.7", + "@babel/core": "^8.0.9", "@babel/eslint-parser": "^8.0.7", "@babel/plugin-syntax-import-defer": "^8.0.1", "@babel/plugin-syntax-import-source": "^8.0.1", @@ -17,7 +17,7 @@ "@stylistic/eslint-plugin": "^5.10.0", "eslint": "^10.13.0", "eslint-formatter-tap": "^9.0.1", - "eslint-plugin-jsdoc": "^65.4.0", + "eslint-plugin-jsdoc": "^65.4.2", "eslint-plugin-regexp": "^3.3.1", "globals": "^17.13.0" } @@ -45,19 +45,19 @@ } }, "node_modules/@babel/core": { - "version": "8.0.7", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-8.0.7.tgz", - "integrity": "sha512-ZIsZWBG6Y1oa+8fkQVp0xeCdjCHBkXFCCIWrmg9SvejVvfcVQgKKRmGrBDWfM7rilhvnRoEuaqa5dkK7KB3pHA==", + "version": "8.0.9", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-8.0.9.tgz", + "integrity": "sha512-wXtyKlpR/pXf/u0vmib+OBakQaIzLglLcRoKpWxCHW/whqq7YfQYPD0IAAl9H/evi40MyLIjYYdvb6N+9DI2yA==", "license": "MIT", "dependencies": { "@babel/code-frame": "^8.0.6", "@babel/generator": "^8.0.6", "@babel/helper-compilation-targets": "^8.0.7", - "@babel/helpers": "^8.0.7", - "@babel/parser": "^8.0.7", + "@babel/helpers": "^8.0.8", + "@babel/parser": "^8.0.8", "@babel/template": "^8.0.0", "@babel/traverse": "^8.0.7", - "@babel/types": "^8.0.6", + "@babel/types": "^8.0.8", "@types/gensync": "^1.0.5", "convert-source-map": "^2.0.0", "empathic": "^2.0.1", @@ -366,28 +366,16 @@ } }, "node_modules/@es-joy/jsdoccomment": { - "version": "0.100.0", - "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.100.0.tgz", - "integrity": "sha512-QuIT5kMg3XWN22Wa1rcXmR/GkfSg6Ygs/ikMiHihdSpu+o3O59LygkFV9srKa5xHplBFwNd5ZCo3bywL4k7qMQ==", + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-1.0.0.tgz", + "integrity": "sha512-jiVfUnvMioo3upHpAoxE4XkqfrL6nc/XQx7Uw7tQL6QbQDJcALm+fhdj6tjiORDF7uADJbTlmnYWR9DvJE/eiw==", "license": "MIT", "dependencies": { "@types/estree": "^1.0.9", "@typescript-eslint/types": "^8.72.0", "comment-parser": "1.4.9", "esquery": "^1.7.0", - "jsdoc-type-pratt-parser": "~9.3.0" - }, - "engines": { - "node": "^22.22.2 || >=24.15.0" - } - }, - "node_modules/@es-joy/jsdoccomment/node_modules/jsdoc-type-pratt-parser": { - "version": "9.3.0", - "resolved": "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-9.3.0.tgz", - "integrity": "sha512-JZ8lKMCZXDlM1jAjAK5tTmtFJtgv6iFQQfjE3Fza6jBRACUueaEXLY17n1u05JO1lcPkNxgP+ddEDtiPsk5ktg==", - "license": "MIT", - "dependencies": { - "@types/estree": "^1.0.9" + "jsdoc-type-pratt-parser": "~9.4.0" }, "engines": { "node": "^22.22.2 || >=24.15.0" @@ -777,15 +765,6 @@ "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==", "license": "MIT" }, - "node_modules/@types/node": { - "version": "26.4.0", - "resolved": "https://registry.npmjs.org/@types/node/-/node-26.4.0.tgz", - "integrity": "sha512-faiGnoIrLH/V8cibOMEAZ8pMw6oXqSukl29ra4mN8GdaB2ZewzeaLj+INpV5N+Z1eKWzY+IzaIZH2EIR6YZRNQ==", - "license": "MIT", - "dependencies": { - "undici-types": "~8.3.0" - } - }, "node_modules/@types/unist": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", @@ -1300,13 +1279,13 @@ } }, "node_modules/eslint-plugin-jsdoc": { - "version": "65.4.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-65.4.0.tgz", - "integrity": "sha512-bRiU6LfCFmLL7GuePKvA6ZIcXLonhZGCg2TgQLmkcExeVdAirQp2Hsf3xeSUTmlKwAAsREVEOLbZYD8F7oA69g==", + "version": "65.4.2", + "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-65.4.2.tgz", + "integrity": "sha512-+1XHeMXZxHK0+uiHwKuZzwCIlZjw9SuZ/enuLMtZ8ZT7cxBLTZ4lCHd3kO6BhPcsUQ59fMg6DKWcCNxnRAhMjg==", "license": "BSD-3-Clause", "dependencies": { "@es-joy/escodegen": "^4.2.0", - "@es-joy/jsdoccomment": "~0.100.0", + "@es-joy/jsdoccomment": "~1.0.0", "@es-joy/resolve.exports": "1.2.0", "@typescript-eslint/utils": "^8.72.0", "are-docs-informative": "^0.1.1", @@ -1780,13 +1759,12 @@ } }, "node_modules/jsdoc-type-pratt-parser": { - "version": "9.2.2", - "resolved": "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-9.2.2.tgz", - "integrity": "sha512-eFY7Rlscvv/BpY6UsVsjKwMhu1tJO/F4U/vC9g3yeRy/JqszuO1UP6Vdq+85G+3FP6fEw/sWR8a5ftPFY86csw==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-9.4.0.tgz", + "integrity": "sha512-orXhi2Y06rag47r4SW4JPII6WlUJbp0xe9cIcqLaSbb/8tREcEZSq99Lu3AFfra6PAlMqTYIxV+ZHxl1dFUrWw==", "license": "MIT", "dependencies": { - "@types/estree": "^1.0.9", - "@types/node": "^26.4.0" + "@types/estree": "^1.0.9" }, "engines": { "node": "^22.22.2 || >=24.15.0" @@ -3124,12 +3102,6 @@ "node": ">=14.17" } }, - "node_modules/undici-types": { - "version": "8.3.0", - "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.3.0.tgz", - "integrity": "sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ==", - "license": "MIT" - }, "node_modules/unist-util-is": { "version": "6.0.1", "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz", diff --git a/tools/eslint/package.json b/tools/eslint/package.json index 47a99e4fec4..e35dced6f5e 100644 --- a/tools/eslint/package.json +++ b/tools/eslint/package.json @@ -3,7 +3,7 @@ "version": "0.0.0", "private": true, "dependencies": { - "@babel/core": "^8.0.7", + "@babel/core": "^8.0.9", "@babel/eslint-parser": "^8.0.7", "@babel/plugin-syntax-import-defer": "^8.0.1", "@babel/plugin-syntax-import-source": "^8.0.1", @@ -12,7 +12,7 @@ "@stylistic/eslint-plugin": "^5.10.0", "eslint": "^10.13.0", "eslint-formatter-tap": "^9.0.1", - "eslint-plugin-jsdoc": "^65.4.0", + "eslint-plugin-jsdoc": "^65.4.2", "eslint-plugin-regexp": "^3.3.1", "globals": "^17.13.0" } From b4afb79d69329d2f0d129b956b1efa8d5bf597a3 Mon Sep 17 00:00:00 2001 From: Kevin Gibbons Date: Tue, 3 Nov 2026 11:56:30 -0800 Subject: [PATCH 205/331] benchmark: add URLSearchParams iterator consumers benchmark Assisted-by: claude:opus-5.5 Signed-off-by: Kevin Gibbons PR-URL: https://github.com/nodejs/node/pull/66837 Reviewed-By: Jordan Harband Reviewed-By: LiviaMedeiros --- .../url-searchparams-iterator-consumers.js | 53 ++++++++++++++++ lib/eslint.config_partial.mjs | 2 +- lib/events.js | 2 +- lib/internal/fs/promises.js | 10 ++-- .../source_map/source_map_cache_map.js | 2 +- lib/internal/streams/readable.js | 18 +++--- lib/internal/url.js | 4 +- lib/internal/vfs/watcher.js | 12 ++-- lib/internal/webstreams/readablestream.js | 28 ++++----- .../test-eslint-iterator-result-done-first.js | 60 ------------------- ...test-eslint-iterator-result-value-first.js | 60 +++++++++++++++++++ ...irst.js => iterator-result-value-first.js} | 10 +++- 12 files changed, 159 insertions(+), 102 deletions(-) create mode 100644 benchmark/url/url-searchparams-iterator-consumers.js delete mode 100644 test/parallel/test-eslint-iterator-result-done-first.js create mode 100644 test/parallel/test-eslint-iterator-result-value-first.js rename tools/eslint-rules/{iterator-result-done-first.js => iterator-result-value-first.js} (68%) diff --git a/benchmark/url/url-searchparams-iterator-consumers.js b/benchmark/url/url-searchparams-iterator-consumers.js new file mode 100644 index 00000000000..62fff749959 --- /dev/null +++ b/benchmark/url/url-searchparams-iterator-consumers.js @@ -0,0 +1,53 @@ +'use strict'; +const common = require('../common.js'); +const assert = require('assert'); + +// Consumes a URLSearchParams iterator with builtins that have fast paths for +// iterator result objects (Array.from, Map constructor, Object.fromEntries), +// plus for-of for comparison. +const bench = common.createBenchmark(main, { + method: ['Array.from', 'Map', 'Object.fromEntries', 'for-of'], + n: [1e6], +}); + +const str = 'one=single&two=first&three=first&two=2nd&three=2nd&three=3rd'; + +function main({ method, n }) { + const params = new URLSearchParams(str); + let noDead; + + switch (method) { + case 'Array.from': + bench.start(); + for (let i = 0; i < n; i += 1) + noDead = Array.from(params); + bench.end(n); + assert.strictEqual(noDead.length, 6); + break; + case 'Map': + bench.start(); + for (let i = 0; i < n; i += 1) + noDead = new Map(params); + bench.end(n); + assert.strictEqual(noDead.size, 3); + break; + case 'Object.fromEntries': + bench.start(); + for (let i = 0; i < n; i += 1) + noDead = Object.fromEntries(params); + bench.end(n); + assert.strictEqual(noDead.three, '3rd'); + break; + case 'for-of': + bench.start(); + for (let i = 0; i < n; i += 1) { + for (const pair of params) + noDead = pair; + } + bench.end(n); + assert.strictEqual(noDead[1], '3rd'); + break; + default: + throw new Error(`Unknown method ${method}`); + } +} diff --git a/lib/eslint.config_partial.mjs b/lib/eslint.config_partial.mjs index 58a2cda0296..8370fb0041a 100644 --- a/lib/eslint.config_partial.mjs +++ b/lib/eslint.config_partial.mjs @@ -435,7 +435,7 @@ export default [ 'node-core/alphabetize-errors': 'error', 'node-core/alphabetize-primordials': 'error', 'node-core/avoid-prototype-pollution': 'error', - 'node-core/iterator-result-done-first': 'error', + 'node-core/iterator-result-value-first': 'error', 'node-core/lowercase-name-for-primitive': 'error', 'node-core/non-ascii-character': 'error', 'node-core/no-array-destructuring': 'error', diff --git a/lib/events.js b/lib/events.js index 4866073de81..3b6805d8998 100644 --- a/lib/events.js +++ b/lib/events.js @@ -1043,7 +1043,7 @@ async function once(emitter, name, options = kEmptyObject) { } function createIterResult(value, done) { - return { done, value }; + return { value, done }; } function eventTargetAgnosticRemoveListener(emitter, name, listener, flags) { diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js index ab20755e0a7..cfb4365d916 100644 --- a/lib/internal/fs/promises.js +++ b/lib/internal/fs/promises.js @@ -672,7 +672,7 @@ if (getOptionValue('--experimental-stream-iter')) { __proto__: null, next() { if (done) { - return { done: true, value: undefined }; + return { value: undefined, done: true }; } if (!started) { // Lock lazily, on the first read, so that an iterable that is @@ -684,7 +684,7 @@ if (getOptionValue('--experimental-stream-iter')) { if (remaining === 0) { done = true; cleanup(); - return { done: true, value: undefined }; + return { value: undefined, done: true }; } const toRead = remaining > 0 ? MathMin(readSize, remaining) : readSize; @@ -700,20 +700,20 @@ if (getOptionValue('--experimental-stream-iter')) { if (bytesRead === 0) { done = true; cleanup(); - return { done: true, value: undefined }; + return { value: undefined, done: true }; } if (pos >= 0) pos += bytesRead; if (remaining > 0) remaining -= bytesRead; const chunk = bytesRead < toRead ? buf.subarray(0, bytesRead) : buf; - return { done: false, value: [chunk] }; + return { value: [chunk], done: false }; }, return() { if (!done) { done = true; if (started) cleanup(); } - return { done: true, value: undefined }; + return { value: undefined, done: true }; }, }; }, diff --git a/lib/internal/source_map/source_map_cache_map.js b/lib/internal/source_map/source_map_cache_map.js index 10561acffc4..5c144818ca7 100644 --- a/lib/internal/source_map/source_map_cache_map.js +++ b/lib/internal/source_map/source_map_cache_map.js @@ -104,7 +104,7 @@ class SourceMapCacheMap { const moduleInstance = weakRef.deref(); if (moduleInstance == null) return next(); const value = moduleInstance[source_map_data_private_symbol]; - return { done: false, value: [key, value] }; + return { value: [key, value], done: false }; }; return { diff --git a/lib/internal/streams/readable.js b/lib/internal/streams/readable.js index e584757dd9a..9bd7ea63691 100644 --- a/lib/internal/streams/readable.js +++ b/lib/internal/streams/readable.js @@ -1656,7 +1656,7 @@ function createAsyncIterator(stream, options) { function onChunkFulfilled(value) { inFlight = false; if (queue !== null) drain(); - return { done: false, value }; + return { value, done: false }; } function onChunkRejected(err) { @@ -1679,7 +1679,7 @@ function createAsyncIterator(stream, options) { if (typeof then === 'function') { FunctionPrototypeCall(then, chunk, (value) => { inFlight = false; - resolve({ done: false, value }); + resolve({ value, done: false }); if (queue !== null) drain(); }, (err) => { inFlight = false; @@ -1689,7 +1689,7 @@ function createAsyncIterator(stream, options) { return; } inFlight = false; - resolve({ done: false, value: chunk }); + resolve({ value: chunk, done: false }); if (queue !== null) drain(); } else if (error) { inFlight = false; @@ -1698,7 +1698,7 @@ function createAsyncIterator(stream, options) { } else if (error === null) { inFlight = false; finalize(); - resolve({ done: true, value: undefined }); + resolve({ value: undefined, done: true }); if (queue !== null) drain(); } else { // No data buffered yet; wait for 'readable' or end-of-stream and @@ -1709,7 +1709,7 @@ function createAsyncIterator(stream, options) { function processNext(resolve, reject) { if (completed) { - resolve({ done: true, value: undefined }); + resolve({ value: undefined, done: true }); return; } if (!started) start(); @@ -1726,7 +1726,7 @@ function createAsyncIterator(stream, options) { completed = true; } } - resolve({ done: true, value }); + resolve({ value, done: true }); } function processThrow(err, reject) { @@ -1755,7 +1755,7 @@ function createAsyncIterator(stream, options) { return FunctionPrototypeCall( then, chunk, onChunkFulfilled, onChunkRejected); } - return PromiseResolve({ done: false, value: chunk }); + return PromiseResolve({ value: chunk, done: false }); } if (error) { finalize(); @@ -1763,7 +1763,7 @@ function createAsyncIterator(stream, options) { } if (error === null) { finalize(); - return PromiseResolve({ done: true, value: undefined }); + return PromiseResolve({ value: undefined, done: true }); } // No data buffered yet; wait for 'readable' or end-of-stream. inFlight = true; @@ -1776,7 +1776,7 @@ function createAsyncIterator(stream, options) { queue ??= new FixedQueue(); queue.push({ __proto__: null, type: 'next', value: undefined, resolve, reject }); } else { - resolve({ done: true, value: undefined }); + resolve({ value: undefined, done: true }); } }); }, diff --git a/lib/internal/url.js b/lib/internal/url.js index 8c04ac70c07..456afd2242d 100644 --- a/lib/internal/url.js +++ b/lib/internal/url.js @@ -278,8 +278,8 @@ class URLSearchParamsIterator { const len = values.length; if (index >= len) { return { - done: true, value: undefined, + done: true, }; } @@ -297,8 +297,8 @@ class URLSearchParamsIterator { } return { - done: false, value: result, + done: false, }; } diff --git a/lib/internal/vfs/watcher.js b/lib/internal/vfs/watcher.js index f6035abfd8b..ee7cd9e5b0c 100644 --- a/lib/internal/vfs/watcher.js +++ b/lib/internal/vfs/watcher.js @@ -602,7 +602,7 @@ class VFSWatchAsyncIterable { const event = { eventType, filename }; if (this.#pendingResolvers.length > 0) { const { resolve } = this.#pendingResolvers.shift(); - resolve({ done: false, value: event }); + resolve({ value: event, done: false }); } else if (this.#pendingEvents.length < kMaxPendingEvents) { ArrayPrototypePush(this.#pendingEvents, event); } @@ -614,7 +614,7 @@ class VFSWatchAsyncIterable { // Resolve any pending iterators while (this.#pendingResolvers.length > 0) { const { resolve } = this.#pendingResolvers.shift(); - resolve({ done: true, value: undefined }); + resolve({ value: undefined, done: true }); } }); @@ -664,12 +664,12 @@ class VFSWatchAsyncIterable { } if (this.#closed) { - return PromiseResolve({ done: true, value: undefined }); + return PromiseResolve({ value: undefined, done: true }); } if (this.#pendingEvents.length > 0) { const event = this.#pendingEvents.shift(); - return PromiseResolve({ done: false, value: event }); + return PromiseResolve({ value: event, done: false }); } return new Promise((resolve, reject) => { @@ -683,7 +683,7 @@ class VFSWatchAsyncIterable { */ return() { this.#watcher.close(); - return PromiseResolve({ done: true, value: undefined }); + return PromiseResolve({ value: undefined, done: true }); } /** @@ -693,7 +693,7 @@ class VFSWatchAsyncIterable { */ throw(error) { this.#watcher.close(); - return PromiseResolve({ done: true, value: undefined }); + return PromiseResolve({ value: undefined, done: true }); } } diff --git a/lib/internal/webstreams/readablestream.js b/lib/internal/webstreams/readablestream.js index 1ed0a95c524..9ff4670e93b 100644 --- a/lib/internal/webstreams/readablestream.js +++ b/lib/internal/webstreams/readablestream.js @@ -712,14 +712,14 @@ class ReadableStreamAsyncIteratorReadRequest { [kChunk](chunk) { this.current = undefined; - this.promise.resolve({ done: false, value: chunk }); + this.promise.resolve({ value: chunk, done: false }); } [kClose]() { this.current = undefined; this.done = true; readableStreamReaderGenericRelease(this.reader); - this.promise.resolve({ done: true, value: undefined }); + this.promise.resolve({ value: undefined, done: true }); } [kError](error) { @@ -735,7 +735,7 @@ class ReadableStreamAsyncIteratorReadRequest { // promise allocations. function readableStreamAsyncIteratorNextSteps(state) { if (state.done) - return PromiseResolve({ done: true, value: undefined }); + return PromiseResolve({ value: undefined, done: true }); const reader = state.reader; if (reader[kState].stream === undefined) { @@ -753,7 +753,7 @@ function readableStreamAsyncIteratorNextSteps(state) { // Not an async function either: the cancel path settles one microtask // after the cancel promise, exactly as `await` would. function readableStreamAsyncIteratorReturnSteps(state, value) { - const iterResult = { done: true, value }; + const iterResult = { value, done: true }; if (state.done) return PromiseResolve(iterResult); state.done = true; @@ -841,16 +841,16 @@ class ReadableStreamAsyncIterator { readableStreamDefaultControllerPull(controller); } - return PromiseResolve({ done: false, value: chunk }); + return PromiseResolve({ value: chunk, done: false }); } } else if (controller[kState].queueTotalSize > 0) { // Byte controller with buffered data: same shape as above via // the queue-filled arm of the byte controller's pull steps. stream[kState].disturbed = true; return PromiseResolve({ - done: false, - value: readableByteStreamControllerDequeueChunk(controller), + + done: false, }); } } @@ -891,11 +891,11 @@ class DefaultReadRequest { } [kChunk](value) { - this[kState].resolve({ done: false, value }); + this[kState].resolve({ value, done: false }); } [kClose]() { - this[kState].resolve({ done: true, value: undefined }); + this[kState].resolve({ value: undefined, done: true }); } [kError](error) { @@ -936,11 +936,11 @@ class ReadIntoRequest { } [kChunk](value) { - this[kState].resolve({ done: false, value }); + this[kState].resolve({ value, done: false }); } [kClose](value) { - this[kState].resolve({ done: true, value }); + this[kState].resolve({ value, done: true }); } [kError](error) { @@ -1009,7 +1009,7 @@ class ReadableStreamDefaultReader { readableStreamDefaultControllerPull(controller); } - return PromiseResolve({ done: false, value: chunk }); + return PromiseResolve({ value: chunk, done: false }); } } else if (controller[kState].queueTotalSize > 0) { // Byte controller with buffered data: mirror the queue-filled arm @@ -1017,9 +1017,9 @@ class ReadableStreamDefaultReader { // the read request. stream[kState].disturbed = true; return PromiseResolve({ - done: false, - value: readableByteStreamControllerDequeueChunk(controller), + + done: false, }); } } diff --git a/test/parallel/test-eslint-iterator-result-done-first.js b/test/parallel/test-eslint-iterator-result-done-first.js deleted file mode 100644 index f65f6bd72eb..00000000000 --- a/test/parallel/test-eslint-iterator-result-done-first.js +++ /dev/null @@ -1,60 +0,0 @@ -'use strict'; - -const common = require('../common'); -if ((!common.hasCrypto) || (!common.hasIntl)) { - common.skip('ESLint tests require crypto and Intl'); -} - -common.skipIfEslintMissing(); - -const { RuleTester } = require('../../tools/eslint/node_modules/eslint'); -const rule = require('../../tools/eslint-rules/iterator-result-done-first'); - -const message = 'Iterator result objects should place `done` before `value`.'; - -new RuleTester().run('iterator-result-done-first', rule, { - valid: [ - 'function next() { return { done: true, value: undefined }; }', - 'function next() { return { __proto__: null, done: false, value: chunk }; }', - 'function next() { return { done, value }; }', - 'function next() { return { value }; }', - 'function next() { return { done }; }', - 'function next() { return { value: 1, other: 2 }; }', - 'function next() { return { [value]: 1, done: true }; }', - 'function next() { return { value: 1, [done]: true }; }', - 'function next() { return { "done": true, "value": undefined }; }', - 'function next() { return { ["done"]: true, ["value"]: undefined }; }', - ], - invalid: [ - { - code: 'function next() { return { value: undefined, done: true }; }', - errors: [{ message }], - output: 'function next() { return { done: true, value: undefined }; }', - }, - { - code: 'function next() { return { __proto__: null, value: chunk, done: false }; }', - errors: [{ message }], - output: 'function next() { return { __proto__: null, done: false, value: chunk }; }', - }, - { - code: 'function next() { return { value, done }; }', - errors: [{ message }], - output: 'function next() { return { done, value }; }', - }, - { - code: 'function next() { return { "value": undefined, "done": true }; }', - errors: [{ message }], - output: 'function next() { return { "done": true, "value": undefined }; }', - }, - { - code: 'function next() { return { ["value"]: undefined, ["done"]: true }; }', - errors: [{ message }], - output: 'function next() { return { ["done"]: true, ["value"]: undefined }; }', - }, - { - code: 'function next() { return { value: result, extra: true, done: false }; }', - errors: [{ message }], - output: 'function next() { return { done: false, extra: true, value: result }; }', - }, - ], -}); diff --git a/test/parallel/test-eslint-iterator-result-value-first.js b/test/parallel/test-eslint-iterator-result-value-first.js new file mode 100644 index 00000000000..24dc56be143 --- /dev/null +++ b/test/parallel/test-eslint-iterator-result-value-first.js @@ -0,0 +1,60 @@ +'use strict'; + +const common = require('../common'); +if ((!common.hasCrypto) || (!common.hasIntl)) { + common.skip('ESLint tests require crypto and Intl'); +} + +common.skipIfEslintMissing(); + +const { RuleTester } = require('../../tools/eslint/node_modules/eslint'); +const rule = require('../../tools/eslint-rules/iterator-result-value-first'); + +const message = 'Iterator result objects should place `value` before `done`.'; + +new RuleTester().run('iterator-result-value-first', rule, { + valid: [ + 'function next() { return { value: undefined, done: true }; }', + 'function next() { return { __proto__: null, value: chunk, done: false }; }', + 'function next() { return { value, done }; }', + 'function next() { return { value }; }', + 'function next() { return { done }; }', + 'function next() { return { done: 1, other: 2 }; }', + 'function next() { return { [done]: 1, value: true }; }', + 'function next() { return { done: 1, [value]: true }; }', + 'function next() { return { "value": undefined, "done": true }; }', + 'function next() { return { ["value"]: undefined, ["done"]: true }; }', + ], + invalid: [ + { + code: 'function next() { return { done: true, value: undefined }; }', + errors: [{ message }], + output: 'function next() { return { value: undefined, done: true }; }', + }, + { + code: 'function next() { return { __proto__: null, done: false, value: chunk }; }', + errors: [{ message }], + output: 'function next() { return { __proto__: null, value: chunk, done: false }; }', + }, + { + code: 'function next() { return { done, value }; }', + errors: [{ message }], + output: 'function next() { return { value, done }; }', + }, + { + code: 'function next() { return { "done": true, "value": undefined }; }', + errors: [{ message }], + output: 'function next() { return { "value": undefined, "done": true }; }', + }, + { + code: 'function next() { return { ["done"]: true, ["value"]: undefined }; }', + errors: [{ message }], + output: 'function next() { return { ["value"]: undefined, ["done"]: true }; }', + }, + { + code: 'function next() { return { done: false, extra: true, value: result }; }', + errors: [{ message }], + output: 'function next() { return { value: result, extra: true, done: false }; }', + }, + ], +}); diff --git a/tools/eslint-rules/iterator-result-done-first.js b/tools/eslint-rules/iterator-result-value-first.js similarity index 68% rename from tools/eslint-rules/iterator-result-done-first.js rename to tools/eslint-rules/iterator-result-value-first.js index 1c3ee9035e9..09d6fbe3027 100644 --- a/tools/eslint-rules/iterator-result-done-first.js +++ b/tools/eslint-rules/iterator-result-value-first.js @@ -1,6 +1,10 @@ 'use strict'; -const MESSAGE = 'Iterator result objects should place `done` before `value`.'; +// V8 has a fast path for `{ value, done }` literals, but it must be that order. +// https://source.chromium.org/chromium/chromium/src/+/main:v8/src/init/bootstrapper.cc;l=746-754;drc=e8ac4914ee6b24442aed773d3a041451692b6a9c +// Also, the ES spec technically requires that order. +// https://tc39.es/ecma262/multipage/abstract-operations.html#sec-createiterresultobject +const MESSAGE = 'Iterator result objects should place `value` before `done`.'; function getStaticPropertyName(property) { const { key } = property; @@ -48,9 +52,9 @@ module.exports = { } } - if (doneProperty && valueProperty && valueProperty.range[0] < doneProperty.range[0]) { + if (doneProperty && valueProperty && doneProperty.range[0] < valueProperty.range[0]) { context.report({ - node: valueProperty, + node: doneProperty, message: MESSAGE, fix(fixer) { return [ From 97dfaed0909db2085c2cacf7149dd0003d8d9eff Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Tue, 3 Nov 2026 17:26:19 -0300 Subject: [PATCH 206/331] doc: describe how the permission model grants the entrypoint MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: RafaelGSS PR-URL: https://github.com/nodejs/node/pull/67038 Reviewed-By: Luigi Pinca Reviewed-By: Ulises Gascón --- doc/api/cli.md | 6 ++++-- doc/api/permissions.md | 7 +++++++ doc/node.1 | 6 ++++-- 3 files changed, 15 insertions(+), 4 deletions(-) diff --git a/doc/api/cli.md b/doc/api/cli.md index 07dfa86bc2a..72b1e9ef2e4 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -252,8 +252,10 @@ The valid arguments for the `--allow-fs-read` flag are: Examples can be found in the [File System Permissions][] documentation. -The initializer module and custom `--require` modules has a implicit -read permission. +The initializer module and custom `--require` modules have an implicit +read permission. The entrypoint is granted as passed on the command line, +without the module loader's resolution; see the [File System Permissions][] +documentation for details. ```console $ node --permission -r custom-require.js -r custom-require-2.js index.js diff --git a/doc/api/permissions.md b/doc/api/permissions.md index 21fe47d80c9..65849c4ffc3 100644 --- a/doc/api/permissions.md +++ b/doc/api/permissions.md @@ -226,6 +226,13 @@ $ node -r /path/to/custom-require.js --permission index.js list. * `index.js` will be included in the allowed file system read list. +The entrypoint is granted as passed on the command line, without the module +loader's resolution. If it is a directory, such as in `node --permission .`, +read access is granted to everything inside that directory, recursively. If it +omits the file extension, such as in `node --permission index`, the resolved +`index.js` is not granted. Pass the full path of the file, or use +[`--allow-fs-read`][], to grant exactly what the application needs. + The valid arguments for both flags are: * `*` - To allow all `FileSystemRead` or `FileSystemWrite` operations, diff --git a/doc/node.1 b/doc/node.1 index a67a0709cb3..1ea3590eb7d 100644 --- a/doc/node.1 +++ b/doc/node.1 @@ -150,8 +150,10 @@ Multiple paths can be allowed using multiple \fB--allow-fs-read\fR flags. Example \fB--allow-fs-read=/folder1/ --allow-fs-read=/folder2/\fR .El Examples can be found in the File System Permissions documentation. -The initializer module and custom \fB--require\fR modules has a implicit -read permission. +The initializer module and custom \fB--require\fR modules have an implicit +read permission. The entrypoint is granted as passed on the command line, +without the module loader's resolution; see the File System Permissions +documentation for details. .Bd -literal $ node --permission -r custom-require.js -r custom-require-2.js index.js .Ed From 53828e73e68c62dad11408fd0f639ea37bdbabde Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Wed, 4 Nov 2026 00:07:30 +0100 Subject: [PATCH 207/331] Revert "benchmark: add URLSearchParams iterator consumers benchmark" This reverts commit b2913b4b7e3a11e899a1b5b248c02069f39d4029. PR-URL: https://github.com/nodejs/node/pull/66837 Reviewed-By: Jordan Harband Reviewed-By: LiviaMedeiros --- .../url-searchparams-iterator-consumers.js | 53 ---------------- lib/eslint.config_partial.mjs | 2 +- lib/events.js | 2 +- lib/internal/fs/promises.js | 10 ++-- .../source_map/source_map_cache_map.js | 2 +- lib/internal/streams/readable.js | 18 +++--- lib/internal/url.js | 4 +- lib/internal/vfs/watcher.js | 12 ++-- lib/internal/webstreams/readablestream.js | 28 ++++----- .../test-eslint-iterator-result-done-first.js | 60 +++++++++++++++++++ ...test-eslint-iterator-result-value-first.js | 60 ------------------- ...first.js => iterator-result-done-first.js} | 10 +--- 12 files changed, 102 insertions(+), 159 deletions(-) delete mode 100644 benchmark/url/url-searchparams-iterator-consumers.js create mode 100644 test/parallel/test-eslint-iterator-result-done-first.js delete mode 100644 test/parallel/test-eslint-iterator-result-value-first.js rename tools/eslint-rules/{iterator-result-value-first.js => iterator-result-done-first.js} (68%) diff --git a/benchmark/url/url-searchparams-iterator-consumers.js b/benchmark/url/url-searchparams-iterator-consumers.js deleted file mode 100644 index 62fff749959..00000000000 --- a/benchmark/url/url-searchparams-iterator-consumers.js +++ /dev/null @@ -1,53 +0,0 @@ -'use strict'; -const common = require('../common.js'); -const assert = require('assert'); - -// Consumes a URLSearchParams iterator with builtins that have fast paths for -// iterator result objects (Array.from, Map constructor, Object.fromEntries), -// plus for-of for comparison. -const bench = common.createBenchmark(main, { - method: ['Array.from', 'Map', 'Object.fromEntries', 'for-of'], - n: [1e6], -}); - -const str = 'one=single&two=first&three=first&two=2nd&three=2nd&three=3rd'; - -function main({ method, n }) { - const params = new URLSearchParams(str); - let noDead; - - switch (method) { - case 'Array.from': - bench.start(); - for (let i = 0; i < n; i += 1) - noDead = Array.from(params); - bench.end(n); - assert.strictEqual(noDead.length, 6); - break; - case 'Map': - bench.start(); - for (let i = 0; i < n; i += 1) - noDead = new Map(params); - bench.end(n); - assert.strictEqual(noDead.size, 3); - break; - case 'Object.fromEntries': - bench.start(); - for (let i = 0; i < n; i += 1) - noDead = Object.fromEntries(params); - bench.end(n); - assert.strictEqual(noDead.three, '3rd'); - break; - case 'for-of': - bench.start(); - for (let i = 0; i < n; i += 1) { - for (const pair of params) - noDead = pair; - } - bench.end(n); - assert.strictEqual(noDead[1], '3rd'); - break; - default: - throw new Error(`Unknown method ${method}`); - } -} diff --git a/lib/eslint.config_partial.mjs b/lib/eslint.config_partial.mjs index 8370fb0041a..58a2cda0296 100644 --- a/lib/eslint.config_partial.mjs +++ b/lib/eslint.config_partial.mjs @@ -435,7 +435,7 @@ export default [ 'node-core/alphabetize-errors': 'error', 'node-core/alphabetize-primordials': 'error', 'node-core/avoid-prototype-pollution': 'error', - 'node-core/iterator-result-value-first': 'error', + 'node-core/iterator-result-done-first': 'error', 'node-core/lowercase-name-for-primitive': 'error', 'node-core/non-ascii-character': 'error', 'node-core/no-array-destructuring': 'error', diff --git a/lib/events.js b/lib/events.js index 3b6805d8998..4866073de81 100644 --- a/lib/events.js +++ b/lib/events.js @@ -1043,7 +1043,7 @@ async function once(emitter, name, options = kEmptyObject) { } function createIterResult(value, done) { - return { value, done }; + return { done, value }; } function eventTargetAgnosticRemoveListener(emitter, name, listener, flags) { diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js index cfb4365d916..ab20755e0a7 100644 --- a/lib/internal/fs/promises.js +++ b/lib/internal/fs/promises.js @@ -672,7 +672,7 @@ if (getOptionValue('--experimental-stream-iter')) { __proto__: null, next() { if (done) { - return { value: undefined, done: true }; + return { done: true, value: undefined }; } if (!started) { // Lock lazily, on the first read, so that an iterable that is @@ -684,7 +684,7 @@ if (getOptionValue('--experimental-stream-iter')) { if (remaining === 0) { done = true; cleanup(); - return { value: undefined, done: true }; + return { done: true, value: undefined }; } const toRead = remaining > 0 ? MathMin(readSize, remaining) : readSize; @@ -700,20 +700,20 @@ if (getOptionValue('--experimental-stream-iter')) { if (bytesRead === 0) { done = true; cleanup(); - return { value: undefined, done: true }; + return { done: true, value: undefined }; } if (pos >= 0) pos += bytesRead; if (remaining > 0) remaining -= bytesRead; const chunk = bytesRead < toRead ? buf.subarray(0, bytesRead) : buf; - return { value: [chunk], done: false }; + return { done: false, value: [chunk] }; }, return() { if (!done) { done = true; if (started) cleanup(); } - return { value: undefined, done: true }; + return { done: true, value: undefined }; }, }; }, diff --git a/lib/internal/source_map/source_map_cache_map.js b/lib/internal/source_map/source_map_cache_map.js index 5c144818ca7..10561acffc4 100644 --- a/lib/internal/source_map/source_map_cache_map.js +++ b/lib/internal/source_map/source_map_cache_map.js @@ -104,7 +104,7 @@ class SourceMapCacheMap { const moduleInstance = weakRef.deref(); if (moduleInstance == null) return next(); const value = moduleInstance[source_map_data_private_symbol]; - return { value: [key, value], done: false }; + return { done: false, value: [key, value] }; }; return { diff --git a/lib/internal/streams/readable.js b/lib/internal/streams/readable.js index 9bd7ea63691..e584757dd9a 100644 --- a/lib/internal/streams/readable.js +++ b/lib/internal/streams/readable.js @@ -1656,7 +1656,7 @@ function createAsyncIterator(stream, options) { function onChunkFulfilled(value) { inFlight = false; if (queue !== null) drain(); - return { value, done: false }; + return { done: false, value }; } function onChunkRejected(err) { @@ -1679,7 +1679,7 @@ function createAsyncIterator(stream, options) { if (typeof then === 'function') { FunctionPrototypeCall(then, chunk, (value) => { inFlight = false; - resolve({ value, done: false }); + resolve({ done: false, value }); if (queue !== null) drain(); }, (err) => { inFlight = false; @@ -1689,7 +1689,7 @@ function createAsyncIterator(stream, options) { return; } inFlight = false; - resolve({ value: chunk, done: false }); + resolve({ done: false, value: chunk }); if (queue !== null) drain(); } else if (error) { inFlight = false; @@ -1698,7 +1698,7 @@ function createAsyncIterator(stream, options) { } else if (error === null) { inFlight = false; finalize(); - resolve({ value: undefined, done: true }); + resolve({ done: true, value: undefined }); if (queue !== null) drain(); } else { // No data buffered yet; wait for 'readable' or end-of-stream and @@ -1709,7 +1709,7 @@ function createAsyncIterator(stream, options) { function processNext(resolve, reject) { if (completed) { - resolve({ value: undefined, done: true }); + resolve({ done: true, value: undefined }); return; } if (!started) start(); @@ -1726,7 +1726,7 @@ function createAsyncIterator(stream, options) { completed = true; } } - resolve({ value, done: true }); + resolve({ done: true, value }); } function processThrow(err, reject) { @@ -1755,7 +1755,7 @@ function createAsyncIterator(stream, options) { return FunctionPrototypeCall( then, chunk, onChunkFulfilled, onChunkRejected); } - return PromiseResolve({ value: chunk, done: false }); + return PromiseResolve({ done: false, value: chunk }); } if (error) { finalize(); @@ -1763,7 +1763,7 @@ function createAsyncIterator(stream, options) { } if (error === null) { finalize(); - return PromiseResolve({ value: undefined, done: true }); + return PromiseResolve({ done: true, value: undefined }); } // No data buffered yet; wait for 'readable' or end-of-stream. inFlight = true; @@ -1776,7 +1776,7 @@ function createAsyncIterator(stream, options) { queue ??= new FixedQueue(); queue.push({ __proto__: null, type: 'next', value: undefined, resolve, reject }); } else { - resolve({ value: undefined, done: true }); + resolve({ done: true, value: undefined }); } }); }, diff --git a/lib/internal/url.js b/lib/internal/url.js index 456afd2242d..8c04ac70c07 100644 --- a/lib/internal/url.js +++ b/lib/internal/url.js @@ -278,8 +278,8 @@ class URLSearchParamsIterator { const len = values.length; if (index >= len) { return { - value: undefined, done: true, + value: undefined, }; } @@ -297,8 +297,8 @@ class URLSearchParamsIterator { } return { - value: result, done: false, + value: result, }; } diff --git a/lib/internal/vfs/watcher.js b/lib/internal/vfs/watcher.js index ee7cd9e5b0c..f6035abfd8b 100644 --- a/lib/internal/vfs/watcher.js +++ b/lib/internal/vfs/watcher.js @@ -602,7 +602,7 @@ class VFSWatchAsyncIterable { const event = { eventType, filename }; if (this.#pendingResolvers.length > 0) { const { resolve } = this.#pendingResolvers.shift(); - resolve({ value: event, done: false }); + resolve({ done: false, value: event }); } else if (this.#pendingEvents.length < kMaxPendingEvents) { ArrayPrototypePush(this.#pendingEvents, event); } @@ -614,7 +614,7 @@ class VFSWatchAsyncIterable { // Resolve any pending iterators while (this.#pendingResolvers.length > 0) { const { resolve } = this.#pendingResolvers.shift(); - resolve({ value: undefined, done: true }); + resolve({ done: true, value: undefined }); } }); @@ -664,12 +664,12 @@ class VFSWatchAsyncIterable { } if (this.#closed) { - return PromiseResolve({ value: undefined, done: true }); + return PromiseResolve({ done: true, value: undefined }); } if (this.#pendingEvents.length > 0) { const event = this.#pendingEvents.shift(); - return PromiseResolve({ value: event, done: false }); + return PromiseResolve({ done: false, value: event }); } return new Promise((resolve, reject) => { @@ -683,7 +683,7 @@ class VFSWatchAsyncIterable { */ return() { this.#watcher.close(); - return PromiseResolve({ value: undefined, done: true }); + return PromiseResolve({ done: true, value: undefined }); } /** @@ -693,7 +693,7 @@ class VFSWatchAsyncIterable { */ throw(error) { this.#watcher.close(); - return PromiseResolve({ value: undefined, done: true }); + return PromiseResolve({ done: true, value: undefined }); } } diff --git a/lib/internal/webstreams/readablestream.js b/lib/internal/webstreams/readablestream.js index 9ff4670e93b..1ed0a95c524 100644 --- a/lib/internal/webstreams/readablestream.js +++ b/lib/internal/webstreams/readablestream.js @@ -712,14 +712,14 @@ class ReadableStreamAsyncIteratorReadRequest { [kChunk](chunk) { this.current = undefined; - this.promise.resolve({ value: chunk, done: false }); + this.promise.resolve({ done: false, value: chunk }); } [kClose]() { this.current = undefined; this.done = true; readableStreamReaderGenericRelease(this.reader); - this.promise.resolve({ value: undefined, done: true }); + this.promise.resolve({ done: true, value: undefined }); } [kError](error) { @@ -735,7 +735,7 @@ class ReadableStreamAsyncIteratorReadRequest { // promise allocations. function readableStreamAsyncIteratorNextSteps(state) { if (state.done) - return PromiseResolve({ value: undefined, done: true }); + return PromiseResolve({ done: true, value: undefined }); const reader = state.reader; if (reader[kState].stream === undefined) { @@ -753,7 +753,7 @@ function readableStreamAsyncIteratorNextSteps(state) { // Not an async function either: the cancel path settles one microtask // after the cancel promise, exactly as `await` would. function readableStreamAsyncIteratorReturnSteps(state, value) { - const iterResult = { value, done: true }; + const iterResult = { done: true, value }; if (state.done) return PromiseResolve(iterResult); state.done = true; @@ -841,16 +841,16 @@ class ReadableStreamAsyncIterator { readableStreamDefaultControllerPull(controller); } - return PromiseResolve({ value: chunk, done: false }); + return PromiseResolve({ done: false, value: chunk }); } } else if (controller[kState].queueTotalSize > 0) { // Byte controller with buffered data: same shape as above via // the queue-filled arm of the byte controller's pull steps. stream[kState].disturbed = true; return PromiseResolve({ - value: readableByteStreamControllerDequeueChunk(controller), - done: false, + + value: readableByteStreamControllerDequeueChunk(controller), }); } } @@ -891,11 +891,11 @@ class DefaultReadRequest { } [kChunk](value) { - this[kState].resolve({ value, done: false }); + this[kState].resolve({ done: false, value }); } [kClose]() { - this[kState].resolve({ value: undefined, done: true }); + this[kState].resolve({ done: true, value: undefined }); } [kError](error) { @@ -936,11 +936,11 @@ class ReadIntoRequest { } [kChunk](value) { - this[kState].resolve({ value, done: false }); + this[kState].resolve({ done: false, value }); } [kClose](value) { - this[kState].resolve({ value, done: true }); + this[kState].resolve({ done: true, value }); } [kError](error) { @@ -1009,7 +1009,7 @@ class ReadableStreamDefaultReader { readableStreamDefaultControllerPull(controller); } - return PromiseResolve({ value: chunk, done: false }); + return PromiseResolve({ done: false, value: chunk }); } } else if (controller[kState].queueTotalSize > 0) { // Byte controller with buffered data: mirror the queue-filled arm @@ -1017,9 +1017,9 @@ class ReadableStreamDefaultReader { // the read request. stream[kState].disturbed = true; return PromiseResolve({ - value: readableByteStreamControllerDequeueChunk(controller), - done: false, + + value: readableByteStreamControllerDequeueChunk(controller), }); } } diff --git a/test/parallel/test-eslint-iterator-result-done-first.js b/test/parallel/test-eslint-iterator-result-done-first.js new file mode 100644 index 00000000000..f65f6bd72eb --- /dev/null +++ b/test/parallel/test-eslint-iterator-result-done-first.js @@ -0,0 +1,60 @@ +'use strict'; + +const common = require('../common'); +if ((!common.hasCrypto) || (!common.hasIntl)) { + common.skip('ESLint tests require crypto and Intl'); +} + +common.skipIfEslintMissing(); + +const { RuleTester } = require('../../tools/eslint/node_modules/eslint'); +const rule = require('../../tools/eslint-rules/iterator-result-done-first'); + +const message = 'Iterator result objects should place `done` before `value`.'; + +new RuleTester().run('iterator-result-done-first', rule, { + valid: [ + 'function next() { return { done: true, value: undefined }; }', + 'function next() { return { __proto__: null, done: false, value: chunk }; }', + 'function next() { return { done, value }; }', + 'function next() { return { value }; }', + 'function next() { return { done }; }', + 'function next() { return { value: 1, other: 2 }; }', + 'function next() { return { [value]: 1, done: true }; }', + 'function next() { return { value: 1, [done]: true }; }', + 'function next() { return { "done": true, "value": undefined }; }', + 'function next() { return { ["done"]: true, ["value"]: undefined }; }', + ], + invalid: [ + { + code: 'function next() { return { value: undefined, done: true }; }', + errors: [{ message }], + output: 'function next() { return { done: true, value: undefined }; }', + }, + { + code: 'function next() { return { __proto__: null, value: chunk, done: false }; }', + errors: [{ message }], + output: 'function next() { return { __proto__: null, done: false, value: chunk }; }', + }, + { + code: 'function next() { return { value, done }; }', + errors: [{ message }], + output: 'function next() { return { done, value }; }', + }, + { + code: 'function next() { return { "value": undefined, "done": true }; }', + errors: [{ message }], + output: 'function next() { return { "done": true, "value": undefined }; }', + }, + { + code: 'function next() { return { ["value"]: undefined, ["done"]: true }; }', + errors: [{ message }], + output: 'function next() { return { ["done"]: true, ["value"]: undefined }; }', + }, + { + code: 'function next() { return { value: result, extra: true, done: false }; }', + errors: [{ message }], + output: 'function next() { return { done: false, extra: true, value: result }; }', + }, + ], +}); diff --git a/test/parallel/test-eslint-iterator-result-value-first.js b/test/parallel/test-eslint-iterator-result-value-first.js deleted file mode 100644 index 24dc56be143..00000000000 --- a/test/parallel/test-eslint-iterator-result-value-first.js +++ /dev/null @@ -1,60 +0,0 @@ -'use strict'; - -const common = require('../common'); -if ((!common.hasCrypto) || (!common.hasIntl)) { - common.skip('ESLint tests require crypto and Intl'); -} - -common.skipIfEslintMissing(); - -const { RuleTester } = require('../../tools/eslint/node_modules/eslint'); -const rule = require('../../tools/eslint-rules/iterator-result-value-first'); - -const message = 'Iterator result objects should place `value` before `done`.'; - -new RuleTester().run('iterator-result-value-first', rule, { - valid: [ - 'function next() { return { value: undefined, done: true }; }', - 'function next() { return { __proto__: null, value: chunk, done: false }; }', - 'function next() { return { value, done }; }', - 'function next() { return { value }; }', - 'function next() { return { done }; }', - 'function next() { return { done: 1, other: 2 }; }', - 'function next() { return { [done]: 1, value: true }; }', - 'function next() { return { done: 1, [value]: true }; }', - 'function next() { return { "value": undefined, "done": true }; }', - 'function next() { return { ["value"]: undefined, ["done"]: true }; }', - ], - invalid: [ - { - code: 'function next() { return { done: true, value: undefined }; }', - errors: [{ message }], - output: 'function next() { return { value: undefined, done: true }; }', - }, - { - code: 'function next() { return { __proto__: null, done: false, value: chunk }; }', - errors: [{ message }], - output: 'function next() { return { __proto__: null, value: chunk, done: false }; }', - }, - { - code: 'function next() { return { done, value }; }', - errors: [{ message }], - output: 'function next() { return { value, done }; }', - }, - { - code: 'function next() { return { "done": true, "value": undefined }; }', - errors: [{ message }], - output: 'function next() { return { "value": undefined, "done": true }; }', - }, - { - code: 'function next() { return { ["done"]: true, ["value"]: undefined }; }', - errors: [{ message }], - output: 'function next() { return { ["value"]: undefined, ["done"]: true }; }', - }, - { - code: 'function next() { return { done: false, extra: true, value: result }; }', - errors: [{ message }], - output: 'function next() { return { value: result, extra: true, done: false }; }', - }, - ], -}); diff --git a/tools/eslint-rules/iterator-result-value-first.js b/tools/eslint-rules/iterator-result-done-first.js similarity index 68% rename from tools/eslint-rules/iterator-result-value-first.js rename to tools/eslint-rules/iterator-result-done-first.js index 09d6fbe3027..1c3ee9035e9 100644 --- a/tools/eslint-rules/iterator-result-value-first.js +++ b/tools/eslint-rules/iterator-result-done-first.js @@ -1,10 +1,6 @@ 'use strict'; -// V8 has a fast path for `{ value, done }` literals, but it must be that order. -// https://source.chromium.org/chromium/chromium/src/+/main:v8/src/init/bootstrapper.cc;l=746-754;drc=e8ac4914ee6b24442aed773d3a041451692b6a9c -// Also, the ES spec technically requires that order. -// https://tc39.es/ecma262/multipage/abstract-operations.html#sec-createiterresultobject -const MESSAGE = 'Iterator result objects should place `value` before `done`.'; +const MESSAGE = 'Iterator result objects should place `done` before `value`.'; function getStaticPropertyName(property) { const { key } = property; @@ -52,9 +48,9 @@ module.exports = { } } - if (doneProperty && valueProperty && doneProperty.range[0] < valueProperty.range[0]) { + if (doneProperty && valueProperty && valueProperty.range[0] < doneProperty.range[0]) { context.report({ - node: doneProperty, + node: valueProperty, message: MESSAGE, fix(fixer) { return [ From de4fc5400dc6981294d1ca44a04315f108e823d6 Mon Sep 17 00:00:00 2001 From: LiviaMedeiros Date: Wed, 4 Nov 2026 06:36:37 +0800 Subject: [PATCH 208/331] vfs: place `value` before `done` in iterator result Signed-off-by: LiviaMedeiros PR-URL: https://github.com/nodejs/node/pull/67231 Refs: https://github.com/nodejs/node/pull/66837 Reviewed-By: Antoine du Hamel Reviewed-By: Richard Lau --- lib/internal/vfs/watcher.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/internal/vfs/watcher.js b/lib/internal/vfs/watcher.js index f6035abfd8b..c6bc83a77cd 100644 --- a/lib/internal/vfs/watcher.js +++ b/lib/internal/vfs/watcher.js @@ -629,7 +629,7 @@ class VFSWatchAsyncIterable { reject(err); while (this.#pendingResolvers.length > 0) { const { resolve } = this.#pendingResolvers.shift(); - resolve({ done: true, value: undefined }); + resolve({ value: undefined, done: true }); } } else { this.#abortError = err; From 1ab60fd1dfadb4ec2df31375ba390469d4af4a8b Mon Sep 17 00:00:00 2001 From: Kevin Gibbons Date: Sun, 18 Oct 2026 13:45:08 -0700 Subject: [PATCH 209/331] benchmark: add URLSearchParams iterator consumers benchmark Assisted-by: claude:opus-5.5 Signed-off-by: Kevin Gibbons PR-URL: https://github.com/nodejs/node/pull/66837 Reviewed-By: Jordan Harband Reviewed-By: LiviaMedeiros --- .../url-searchparams-iterator-consumers.js | 53 +++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 benchmark/url/url-searchparams-iterator-consumers.js diff --git a/benchmark/url/url-searchparams-iterator-consumers.js b/benchmark/url/url-searchparams-iterator-consumers.js new file mode 100644 index 00000000000..62fff749959 --- /dev/null +++ b/benchmark/url/url-searchparams-iterator-consumers.js @@ -0,0 +1,53 @@ +'use strict'; +const common = require('../common.js'); +const assert = require('assert'); + +// Consumes a URLSearchParams iterator with builtins that have fast paths for +// iterator result objects (Array.from, Map constructor, Object.fromEntries), +// plus for-of for comparison. +const bench = common.createBenchmark(main, { + method: ['Array.from', 'Map', 'Object.fromEntries', 'for-of'], + n: [1e6], +}); + +const str = 'one=single&two=first&three=first&two=2nd&three=2nd&three=3rd'; + +function main({ method, n }) { + const params = new URLSearchParams(str); + let noDead; + + switch (method) { + case 'Array.from': + bench.start(); + for (let i = 0; i < n; i += 1) + noDead = Array.from(params); + bench.end(n); + assert.strictEqual(noDead.length, 6); + break; + case 'Map': + bench.start(); + for (let i = 0; i < n; i += 1) + noDead = new Map(params); + bench.end(n); + assert.strictEqual(noDead.size, 3); + break; + case 'Object.fromEntries': + bench.start(); + for (let i = 0; i < n; i += 1) + noDead = Object.fromEntries(params); + bench.end(n); + assert.strictEqual(noDead.three, '3rd'); + break; + case 'for-of': + bench.start(); + for (let i = 0; i < n; i += 1) { + for (const pair of params) + noDead = pair; + } + bench.end(n); + assert.strictEqual(noDead[1], '3rd'); + break; + default: + throw new Error(`Unknown method ${method}`); + } +} From f94f25db87a37491907489233ee8d4aeb7737b2d Mon Sep 17 00:00:00 2001 From: Kevin Gibbons Date: Sun, 18 Oct 2026 13:46:06 -0700 Subject: [PATCH 210/331] tools: require `value` before `done` in iterator results V8 has a fast path for `{ value, done }` literals, but it must be that order. Also, the ES spec technically requires that order. Assisted-by: claude:opus-5.5 Signed-off-by: Kevin Gibbons PR-URL: https://github.com/nodejs/node/pull/66837 Reviewed-By: Jordan Harband Reviewed-By: LiviaMedeiros --- lib/eslint.config_partial.mjs | 2 +- .../test-eslint-iterator-result-done-first.js | 60 ------------------- ...test-eslint-iterator-result-value-first.js | 60 +++++++++++++++++++ ...irst.js => iterator-result-value-first.js} | 10 +++- 4 files changed, 68 insertions(+), 64 deletions(-) delete mode 100644 test/parallel/test-eslint-iterator-result-done-first.js create mode 100644 test/parallel/test-eslint-iterator-result-value-first.js rename tools/eslint-rules/{iterator-result-done-first.js => iterator-result-value-first.js} (68%) diff --git a/lib/eslint.config_partial.mjs b/lib/eslint.config_partial.mjs index 58a2cda0296..8370fb0041a 100644 --- a/lib/eslint.config_partial.mjs +++ b/lib/eslint.config_partial.mjs @@ -435,7 +435,7 @@ export default [ 'node-core/alphabetize-errors': 'error', 'node-core/alphabetize-primordials': 'error', 'node-core/avoid-prototype-pollution': 'error', - 'node-core/iterator-result-done-first': 'error', + 'node-core/iterator-result-value-first': 'error', 'node-core/lowercase-name-for-primitive': 'error', 'node-core/non-ascii-character': 'error', 'node-core/no-array-destructuring': 'error', diff --git a/test/parallel/test-eslint-iterator-result-done-first.js b/test/parallel/test-eslint-iterator-result-done-first.js deleted file mode 100644 index f65f6bd72eb..00000000000 --- a/test/parallel/test-eslint-iterator-result-done-first.js +++ /dev/null @@ -1,60 +0,0 @@ -'use strict'; - -const common = require('../common'); -if ((!common.hasCrypto) || (!common.hasIntl)) { - common.skip('ESLint tests require crypto and Intl'); -} - -common.skipIfEslintMissing(); - -const { RuleTester } = require('../../tools/eslint/node_modules/eslint'); -const rule = require('../../tools/eslint-rules/iterator-result-done-first'); - -const message = 'Iterator result objects should place `done` before `value`.'; - -new RuleTester().run('iterator-result-done-first', rule, { - valid: [ - 'function next() { return { done: true, value: undefined }; }', - 'function next() { return { __proto__: null, done: false, value: chunk }; }', - 'function next() { return { done, value }; }', - 'function next() { return { value }; }', - 'function next() { return { done }; }', - 'function next() { return { value: 1, other: 2 }; }', - 'function next() { return { [value]: 1, done: true }; }', - 'function next() { return { value: 1, [done]: true }; }', - 'function next() { return { "done": true, "value": undefined }; }', - 'function next() { return { ["done"]: true, ["value"]: undefined }; }', - ], - invalid: [ - { - code: 'function next() { return { value: undefined, done: true }; }', - errors: [{ message }], - output: 'function next() { return { done: true, value: undefined }; }', - }, - { - code: 'function next() { return { __proto__: null, value: chunk, done: false }; }', - errors: [{ message }], - output: 'function next() { return { __proto__: null, done: false, value: chunk }; }', - }, - { - code: 'function next() { return { value, done }; }', - errors: [{ message }], - output: 'function next() { return { done, value }; }', - }, - { - code: 'function next() { return { "value": undefined, "done": true }; }', - errors: [{ message }], - output: 'function next() { return { "done": true, "value": undefined }; }', - }, - { - code: 'function next() { return { ["value"]: undefined, ["done"]: true }; }', - errors: [{ message }], - output: 'function next() { return { ["done"]: true, ["value"]: undefined }; }', - }, - { - code: 'function next() { return { value: result, extra: true, done: false }; }', - errors: [{ message }], - output: 'function next() { return { done: false, extra: true, value: result }; }', - }, - ], -}); diff --git a/test/parallel/test-eslint-iterator-result-value-first.js b/test/parallel/test-eslint-iterator-result-value-first.js new file mode 100644 index 00000000000..24dc56be143 --- /dev/null +++ b/test/parallel/test-eslint-iterator-result-value-first.js @@ -0,0 +1,60 @@ +'use strict'; + +const common = require('../common'); +if ((!common.hasCrypto) || (!common.hasIntl)) { + common.skip('ESLint tests require crypto and Intl'); +} + +common.skipIfEslintMissing(); + +const { RuleTester } = require('../../tools/eslint/node_modules/eslint'); +const rule = require('../../tools/eslint-rules/iterator-result-value-first'); + +const message = 'Iterator result objects should place `value` before `done`.'; + +new RuleTester().run('iterator-result-value-first', rule, { + valid: [ + 'function next() { return { value: undefined, done: true }; }', + 'function next() { return { __proto__: null, value: chunk, done: false }; }', + 'function next() { return { value, done }; }', + 'function next() { return { value }; }', + 'function next() { return { done }; }', + 'function next() { return { done: 1, other: 2 }; }', + 'function next() { return { [done]: 1, value: true }; }', + 'function next() { return { done: 1, [value]: true }; }', + 'function next() { return { "value": undefined, "done": true }; }', + 'function next() { return { ["value"]: undefined, ["done"]: true }; }', + ], + invalid: [ + { + code: 'function next() { return { done: true, value: undefined }; }', + errors: [{ message }], + output: 'function next() { return { value: undefined, done: true }; }', + }, + { + code: 'function next() { return { __proto__: null, done: false, value: chunk }; }', + errors: [{ message }], + output: 'function next() { return { __proto__: null, value: chunk, done: false }; }', + }, + { + code: 'function next() { return { done, value }; }', + errors: [{ message }], + output: 'function next() { return { value, done }; }', + }, + { + code: 'function next() { return { "done": true, "value": undefined }; }', + errors: [{ message }], + output: 'function next() { return { "value": undefined, "done": true }; }', + }, + { + code: 'function next() { return { ["done"]: true, ["value"]: undefined }; }', + errors: [{ message }], + output: 'function next() { return { ["value"]: undefined, ["done"]: true }; }', + }, + { + code: 'function next() { return { done: false, extra: true, value: result }; }', + errors: [{ message }], + output: 'function next() { return { value: result, extra: true, done: false }; }', + }, + ], +}); diff --git a/tools/eslint-rules/iterator-result-done-first.js b/tools/eslint-rules/iterator-result-value-first.js similarity index 68% rename from tools/eslint-rules/iterator-result-done-first.js rename to tools/eslint-rules/iterator-result-value-first.js index 1c3ee9035e9..09d6fbe3027 100644 --- a/tools/eslint-rules/iterator-result-done-first.js +++ b/tools/eslint-rules/iterator-result-value-first.js @@ -1,6 +1,10 @@ 'use strict'; -const MESSAGE = 'Iterator result objects should place `done` before `value`.'; +// V8 has a fast path for `{ value, done }` literals, but it must be that order. +// https://source.chromium.org/chromium/chromium/src/+/main:v8/src/init/bootstrapper.cc;l=746-754;drc=e8ac4914ee6b24442aed773d3a041451692b6a9c +// Also, the ES spec technically requires that order. +// https://tc39.es/ecma262/multipage/abstract-operations.html#sec-createiterresultobject +const MESSAGE = 'Iterator result objects should place `value` before `done`.'; function getStaticPropertyName(property) { const { key } = property; @@ -48,9 +52,9 @@ module.exports = { } } - if (doneProperty && valueProperty && valueProperty.range[0] < doneProperty.range[0]) { + if (doneProperty && valueProperty && doneProperty.range[0] < valueProperty.range[0]) { context.report({ - node: valueProperty, + node: doneProperty, message: MESSAGE, fix(fixer) { return [ From b2347deb85df42a73652ff09f5d1386b2b30b65a Mon Sep 17 00:00:00 2001 From: Kevin Gibbons Date: Sun, 18 Oct 2026 13:49:14 -0700 Subject: [PATCH 211/331] lib: place `value` before `done` in iterator results Apply the iterator-result-value-first lint fixer. Assisted-by: claude:opus-5.5 Signed-off-by: Kevin Gibbons PR-URL: https://github.com/nodejs/node/pull/66837 Reviewed-By: Jordan Harband Reviewed-By: LiviaMedeiros --- lib/events.js | 2 +- lib/internal/fs/promises.js | 10 +++---- .../source_map/source_map_cache_map.js | 2 +- lib/internal/streams/readable.js | 18 ++++++------ lib/internal/url.js | 4 +-- lib/internal/vfs/watcher.js | 12 ++++---- lib/internal/webstreams/readablestream.js | 28 +++++++++---------- 7 files changed, 38 insertions(+), 38 deletions(-) diff --git a/lib/events.js b/lib/events.js index 4866073de81..3b6805d8998 100644 --- a/lib/events.js +++ b/lib/events.js @@ -1043,7 +1043,7 @@ async function once(emitter, name, options = kEmptyObject) { } function createIterResult(value, done) { - return { done, value }; + return { value, done }; } function eventTargetAgnosticRemoveListener(emitter, name, listener, flags) { diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js index ab20755e0a7..cfb4365d916 100644 --- a/lib/internal/fs/promises.js +++ b/lib/internal/fs/promises.js @@ -672,7 +672,7 @@ if (getOptionValue('--experimental-stream-iter')) { __proto__: null, next() { if (done) { - return { done: true, value: undefined }; + return { value: undefined, done: true }; } if (!started) { // Lock lazily, on the first read, so that an iterable that is @@ -684,7 +684,7 @@ if (getOptionValue('--experimental-stream-iter')) { if (remaining === 0) { done = true; cleanup(); - return { done: true, value: undefined }; + return { value: undefined, done: true }; } const toRead = remaining > 0 ? MathMin(readSize, remaining) : readSize; @@ -700,20 +700,20 @@ if (getOptionValue('--experimental-stream-iter')) { if (bytesRead === 0) { done = true; cleanup(); - return { done: true, value: undefined }; + return { value: undefined, done: true }; } if (pos >= 0) pos += bytesRead; if (remaining > 0) remaining -= bytesRead; const chunk = bytesRead < toRead ? buf.subarray(0, bytesRead) : buf; - return { done: false, value: [chunk] }; + return { value: [chunk], done: false }; }, return() { if (!done) { done = true; if (started) cleanup(); } - return { done: true, value: undefined }; + return { value: undefined, done: true }; }, }; }, diff --git a/lib/internal/source_map/source_map_cache_map.js b/lib/internal/source_map/source_map_cache_map.js index 10561acffc4..5c144818ca7 100644 --- a/lib/internal/source_map/source_map_cache_map.js +++ b/lib/internal/source_map/source_map_cache_map.js @@ -104,7 +104,7 @@ class SourceMapCacheMap { const moduleInstance = weakRef.deref(); if (moduleInstance == null) return next(); const value = moduleInstance[source_map_data_private_symbol]; - return { done: false, value: [key, value] }; + return { value: [key, value], done: false }; }; return { diff --git a/lib/internal/streams/readable.js b/lib/internal/streams/readable.js index e584757dd9a..9bd7ea63691 100644 --- a/lib/internal/streams/readable.js +++ b/lib/internal/streams/readable.js @@ -1656,7 +1656,7 @@ function createAsyncIterator(stream, options) { function onChunkFulfilled(value) { inFlight = false; if (queue !== null) drain(); - return { done: false, value }; + return { value, done: false }; } function onChunkRejected(err) { @@ -1679,7 +1679,7 @@ function createAsyncIterator(stream, options) { if (typeof then === 'function') { FunctionPrototypeCall(then, chunk, (value) => { inFlight = false; - resolve({ done: false, value }); + resolve({ value, done: false }); if (queue !== null) drain(); }, (err) => { inFlight = false; @@ -1689,7 +1689,7 @@ function createAsyncIterator(stream, options) { return; } inFlight = false; - resolve({ done: false, value: chunk }); + resolve({ value: chunk, done: false }); if (queue !== null) drain(); } else if (error) { inFlight = false; @@ -1698,7 +1698,7 @@ function createAsyncIterator(stream, options) { } else if (error === null) { inFlight = false; finalize(); - resolve({ done: true, value: undefined }); + resolve({ value: undefined, done: true }); if (queue !== null) drain(); } else { // No data buffered yet; wait for 'readable' or end-of-stream and @@ -1709,7 +1709,7 @@ function createAsyncIterator(stream, options) { function processNext(resolve, reject) { if (completed) { - resolve({ done: true, value: undefined }); + resolve({ value: undefined, done: true }); return; } if (!started) start(); @@ -1726,7 +1726,7 @@ function createAsyncIterator(stream, options) { completed = true; } } - resolve({ done: true, value }); + resolve({ value, done: true }); } function processThrow(err, reject) { @@ -1755,7 +1755,7 @@ function createAsyncIterator(stream, options) { return FunctionPrototypeCall( then, chunk, onChunkFulfilled, onChunkRejected); } - return PromiseResolve({ done: false, value: chunk }); + return PromiseResolve({ value: chunk, done: false }); } if (error) { finalize(); @@ -1763,7 +1763,7 @@ function createAsyncIterator(stream, options) { } if (error === null) { finalize(); - return PromiseResolve({ done: true, value: undefined }); + return PromiseResolve({ value: undefined, done: true }); } // No data buffered yet; wait for 'readable' or end-of-stream. inFlight = true; @@ -1776,7 +1776,7 @@ function createAsyncIterator(stream, options) { queue ??= new FixedQueue(); queue.push({ __proto__: null, type: 'next', value: undefined, resolve, reject }); } else { - resolve({ done: true, value: undefined }); + resolve({ value: undefined, done: true }); } }); }, diff --git a/lib/internal/url.js b/lib/internal/url.js index 8c04ac70c07..456afd2242d 100644 --- a/lib/internal/url.js +++ b/lib/internal/url.js @@ -278,8 +278,8 @@ class URLSearchParamsIterator { const len = values.length; if (index >= len) { return { - done: true, value: undefined, + done: true, }; } @@ -297,8 +297,8 @@ class URLSearchParamsIterator { } return { - done: false, value: result, + done: false, }; } diff --git a/lib/internal/vfs/watcher.js b/lib/internal/vfs/watcher.js index c6bc83a77cd..799b537ab95 100644 --- a/lib/internal/vfs/watcher.js +++ b/lib/internal/vfs/watcher.js @@ -602,7 +602,7 @@ class VFSWatchAsyncIterable { const event = { eventType, filename }; if (this.#pendingResolvers.length > 0) { const { resolve } = this.#pendingResolvers.shift(); - resolve({ done: false, value: event }); + resolve({ value: event, done: false }); } else if (this.#pendingEvents.length < kMaxPendingEvents) { ArrayPrototypePush(this.#pendingEvents, event); } @@ -614,7 +614,7 @@ class VFSWatchAsyncIterable { // Resolve any pending iterators while (this.#pendingResolvers.length > 0) { const { resolve } = this.#pendingResolvers.shift(); - resolve({ done: true, value: undefined }); + resolve({ value: undefined, done: true }); } }); @@ -664,12 +664,12 @@ class VFSWatchAsyncIterable { } if (this.#closed) { - return PromiseResolve({ done: true, value: undefined }); + return PromiseResolve({ value: undefined, done: true }); } if (this.#pendingEvents.length > 0) { const event = this.#pendingEvents.shift(); - return PromiseResolve({ done: false, value: event }); + return PromiseResolve({ value: event, done: false }); } return new Promise((resolve, reject) => { @@ -683,7 +683,7 @@ class VFSWatchAsyncIterable { */ return() { this.#watcher.close(); - return PromiseResolve({ done: true, value: undefined }); + return PromiseResolve({ value: undefined, done: true }); } /** @@ -693,7 +693,7 @@ class VFSWatchAsyncIterable { */ throw(error) { this.#watcher.close(); - return PromiseResolve({ done: true, value: undefined }); + return PromiseResolve({ value: undefined, done: true }); } } diff --git a/lib/internal/webstreams/readablestream.js b/lib/internal/webstreams/readablestream.js index 1ed0a95c524..9ff4670e93b 100644 --- a/lib/internal/webstreams/readablestream.js +++ b/lib/internal/webstreams/readablestream.js @@ -712,14 +712,14 @@ class ReadableStreamAsyncIteratorReadRequest { [kChunk](chunk) { this.current = undefined; - this.promise.resolve({ done: false, value: chunk }); + this.promise.resolve({ value: chunk, done: false }); } [kClose]() { this.current = undefined; this.done = true; readableStreamReaderGenericRelease(this.reader); - this.promise.resolve({ done: true, value: undefined }); + this.promise.resolve({ value: undefined, done: true }); } [kError](error) { @@ -735,7 +735,7 @@ class ReadableStreamAsyncIteratorReadRequest { // promise allocations. function readableStreamAsyncIteratorNextSteps(state) { if (state.done) - return PromiseResolve({ done: true, value: undefined }); + return PromiseResolve({ value: undefined, done: true }); const reader = state.reader; if (reader[kState].stream === undefined) { @@ -753,7 +753,7 @@ function readableStreamAsyncIteratorNextSteps(state) { // Not an async function either: the cancel path settles one microtask // after the cancel promise, exactly as `await` would. function readableStreamAsyncIteratorReturnSteps(state, value) { - const iterResult = { done: true, value }; + const iterResult = { value, done: true }; if (state.done) return PromiseResolve(iterResult); state.done = true; @@ -841,16 +841,16 @@ class ReadableStreamAsyncIterator { readableStreamDefaultControllerPull(controller); } - return PromiseResolve({ done: false, value: chunk }); + return PromiseResolve({ value: chunk, done: false }); } } else if (controller[kState].queueTotalSize > 0) { // Byte controller with buffered data: same shape as above via // the queue-filled arm of the byte controller's pull steps. stream[kState].disturbed = true; return PromiseResolve({ - done: false, - value: readableByteStreamControllerDequeueChunk(controller), + + done: false, }); } } @@ -891,11 +891,11 @@ class DefaultReadRequest { } [kChunk](value) { - this[kState].resolve({ done: false, value }); + this[kState].resolve({ value, done: false }); } [kClose]() { - this[kState].resolve({ done: true, value: undefined }); + this[kState].resolve({ value: undefined, done: true }); } [kError](error) { @@ -936,11 +936,11 @@ class ReadIntoRequest { } [kChunk](value) { - this[kState].resolve({ done: false, value }); + this[kState].resolve({ value, done: false }); } [kClose](value) { - this[kState].resolve({ done: true, value }); + this[kState].resolve({ value, done: true }); } [kError](error) { @@ -1009,7 +1009,7 @@ class ReadableStreamDefaultReader { readableStreamDefaultControllerPull(controller); } - return PromiseResolve({ done: false, value: chunk }); + return PromiseResolve({ value: chunk, done: false }); } } else if (controller[kState].queueTotalSize > 0) { // Byte controller with buffered data: mirror the queue-filled arm @@ -1017,9 +1017,9 @@ class ReadableStreamDefaultReader { // the read request. stream[kState].disturbed = true; return PromiseResolve({ - done: false, - value: readableByteStreamControllerDequeueChunk(controller), + + done: false, }); } } From 43b8f56a5736a878578b1f78cb07e3fc0c5539bf Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 4 Nov 2026 06:57:21 +0100 Subject: [PATCH 212/331] v8: support X509Certificate serialization v8.serialize() currently rejects X509Certificate objects. Add a host object encoding containing the certificate's DER snapshot, including its issuerCertificate chain, and reconstruct fresh X509Certificate objects in v8.deserialize(). Read the stored snapshot rather than the cached raw Buffer, which can be modified by callers. Decode each certificate independently without imposing issuer relationships on the serialized sequence. Assisted-by: Codex Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/67083 Reviewed-By: Yagiz Nizipli Reviewed-By: Tim Perry --- lib/internal/crypto/x509.js | 16 ++++ lib/v8.js | 58 +++++++++++- src/crypto/crypto_x509.cc | 92 +++++++++++++++++++ src/crypto/crypto_x509.h | 4 + .../test-crypto-x509-chain-key-usage.js | 87 ++++++++++++++++++ .../test-crypto-x509-chain-snapshot.js | 2 + test/parallel/test-crypto-x509-peer-chain.js | 2 + test/parallel/test-v8-serdes.js | 11 +++ typings/internalBinding/crypto.d.ts | 6 ++ 9 files changed, 277 insertions(+), 1 deletion(-) create mode 100644 test/parallel/test-crypto-x509-chain-key-usage.js diff --git a/lib/internal/crypto/x509.js b/lib/internal/crypto/x509.js index cf1de447475..0a0da0296a8 100644 --- a/lib/internal/crypto/x509.js +++ b/lib/internal/crypto/x509.js @@ -9,7 +9,9 @@ const { const { createX509CertificateClass, + getX509CertificateSnapshot: getNativeX509CertificateSnapshot, isX509Certificate: isNativeX509Certificate, + parseX509Snapshot, X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT, X509_CHECK_FLAG_NEVER_CHECK_SUBJECT, X509_CHECK_FLAG_NO_WILDCARDS, @@ -427,8 +429,22 @@ const { // Keep the binding-returned constructor and the closure reference aligned. InternalX509Certificate = InternalX509CertificateConstructor; +function getX509CertificateSnapshot(certificate) { + if (!isX509Certificate(certificate)) { + throw new ERR_INVALID_ARG_TYPE( + 'certificate', 'X509Certificate', certificate); + } + return getNativeX509CertificateSnapshot(certificate); +} + +function createX509CertificateFromSnapshot(snapshot) { + return new InternalX509Certificate(parseX509Snapshot(snapshot)); +} + module.exports = { X509Certificate, InternalX509Certificate, + createX509CertificateFromSnapshot, + getX509CertificateSnapshot, isX509Certificate, }; diff --git a/lib/v8.js b/lib/v8.js index ea3366bb961..6ae1d2c8ee6 100644 --- a/lib/v8.js +++ b/lib/v8.js @@ -16,6 +16,7 @@ const { Array, + ArrayBufferIsView, BigInt64Array, BigUint64Array, DataView, @@ -27,6 +28,7 @@ const { Int32Array, Int8Array, JSONParse, + ObjectDefineProperty, ObjectPrototypeToString, SymbolDispose, Uint16Array, @@ -55,12 +57,22 @@ const { normalizeCpuProfileOptions, } = require('internal/v8/cpu_profiler'); +const { + hasInspector, + hasOpenSSL, +} = internalBinding('config'); + let profiler = {}; -if (internalBinding('config').hasInspector) { +if (hasInspector) { profiler = internalBinding('profiler'); } const assert = require('internal/assert'); +const { + codes: { + ERR_INVALID_STATE, + }, +} = require('internal/errors'); const { inspect } = require('internal/util/inspect'); const { FastBuffer } = require('internal/buffer'); const { getValidatedPath } = require('internal/fs/utils'); @@ -438,6 +450,14 @@ function arrayBufferViewIndexToType(index) { return undefined; } +const kX509CertificateHostObject = 14; +let x509Serialization; + +function getX509Serialization() { + x509Serialization ??= require('internal/crypto/x509'); + return x509Serialization; +} + class DefaultSerializer extends Serializer { constructor() { super(); @@ -459,6 +479,23 @@ class DefaultSerializer extends Serializer { // serialization. Because a) those may contain sensitive data and the user // may not be aware of that and b) they are often much larger than the // `Buffer` itself, custom serialization is applied. + if (!ArrayBufferIsView(abView) && hasOpenSSL) { + const { + getX509CertificateSnapshot, + isX509Certificate, + } = getX509Serialization(); + if (isX509Certificate(abView)) { + const snapshot = getX509CertificateSnapshot(abView); + this.writeUint32(kX509CertificateHostObject); + this.writeUint32(snapshot.length); + for (let j = 0; j < snapshot.length; j++) { + this.writeUint32(snapshot[j].byteLength); + this.writeRawBytes(snapshot[j]); + } + return; + } + } + let i = 10; // FastBuffer if (abView.constructor !== Buffer) { i = arrayBufferViewTypeToIndex(abView); @@ -483,6 +520,25 @@ class DefaultDeserializer extends Deserializer { */ _readHostObject() { const typeIndex = this.readUint32(); + if (typeIndex === kX509CertificateHostObject) { + const count = this.readUint32(); + if (!hasOpenSSL || count === 0) { + throw new ERR_INVALID_STATE('Invalid serialized X509Certificate'); + } + const snapshot = new Array(count); + for (let i = 0; i < count; i++) { + const byteLength = this.readUint32(); + ObjectDefineProperty(snapshot, i, { + __proto__: null, + configurable: true, + enumerable: true, + value: this.readRawBytes(byteLength), + writable: true, + }); + } + const { createX509CertificateFromSnapshot } = getX509Serialization(); + return createX509CertificateFromSnapshot(snapshot); + } const ctor = arrayBufferViewIndexToType(typeIndex); const byteLength = this.readUint32(); const byteOffset = this._readRawBytes(byteLength); diff --git a/src/crypto/crypto_x509.cc b/src/crypto/crypto_x509.cc index 3c208082f94..3a9c296970a 100644 --- a/src/crypto/crypto_x509.cc +++ b/src/crypto/crypto_x509.cc @@ -128,6 +128,23 @@ std::shared_ptr X509CertificateSnapshot::Create( new X509CertificateSnapshot(std::move(certificates))); } +std::shared_ptr X509CertificateSnapshot::Create( + std::vector certificates) { + if (certificates.empty()) return {}; + + for (auto& certificate : certificates) { + auto cert = ParseCertificate(certificate); + if (!cert) return {}; + + auto der = EncodeCertificate(cert.view()); + if (!der.has_value()) return {}; + certificate = std::move(der.value()); + } + + return std::shared_ptr( + new X509CertificateSnapshot(std::move(certificates))); +} + X509Pointer X509CertificateSnapshot::Parse(size_t index) const { if (index >= certificates_.size()) return {}; return ParseCertificate(certificates_[index]); @@ -1065,6 +1082,76 @@ void X509Certificate::NewFromHandle(const FunctionCallbackInfo& args) { issuer); } +void X509Certificate::ParseSnapshot(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + Local context = env->context(); + if (args.Length() != 1 || !args[0]->IsArray()) { + THROW_ERR_INVALID_ARG_TYPE(env, + "The \"snapshot\" argument must be an Array"); + return; + } + + Local input = args[0].As(); + std::vector certificates; + certificates.reserve(input->Length()); + for (uint32_t i = 0; i < input->Length(); i++) { + Local value; + if (!input->Get(context, i).ToLocal(&value)) return; + if (!value->IsArrayBufferView()) { + THROW_ERR_INVALID_ARG_TYPE( + env, "The \"snapshot\" entries must be ArrayBufferViews"); + return; + } + + ArrayBufferViewContents contents( + value.As()); + certificates.emplace_back(contents.data(), + contents.data() + contents.length()); + } + + auto snapshot = X509CertificateSnapshot::Create(std::move(certificates)); + if (!snapshot) [[unlikely]] { + THROW_ERR_CRYPTO_OPERATION_FAILED( + env, "Failed to create X.509 certificate snapshot"); + return; + } + + Local cert; + if (New(env, std::move(snapshot)).ToLocal(&cert)) { + args.GetReturnValue().Set(cert); + } +} + +void X509Certificate::GetSnapshot(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + Local context = env->context(); + if (args.Length() != 1 || !HasInstance(env, args[0])) { + THROW_ERR_INVALID_ARG_TYPE(env, + "The \"certificate\" argument must be an " + "X509CertificateHandle"); + return; + } + + X509Certificate* cert = Unwrap(args[0].As()); + CHECK_NOT_NULL(cert); + CHECK_LT(cert->snapshot_index_, cert->snapshot_->size()); + const size_t count = cert->snapshot_->size() - cert->snapshot_index_; + CHECK_LE(count, static_cast(std::numeric_limits::max())); + Local output = Array::New(env->isolate(), static_cast(count)); + for (size_t i = 0; i < count; i++) { + const auto& der = cert->snapshot_->at(cert->snapshot_index_ + i); + Local buffer; + if (!Buffer::Copy( + env, reinterpret_cast(der.data()), der.size()) + .ToLocal(&buffer) || + !output->CreateDataProperty(context, static_cast(i), buffer) + .FromMaybe(false)) { + return; + } + } + args.GetReturnValue().Set(output); +} + void X509Certificate::CreateX509CertificateClass( const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); @@ -1324,6 +1411,9 @@ void X509Certificate::Initialize(Environment* env, Local target) { SetMethodNoSideEffect( env->context(), target, "isX509Certificate", IsX509Certificate); SetMethod(env->context(), target, "parseX509", Parse); + SetMethod(env->context(), target, "parseX509Snapshot", ParseSnapshot); + SetMethodNoSideEffect( + env->context(), target, "getX509CertificateSnapshot", GetSnapshot); NODE_DEFINE_CONSTANT(target, X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT); NODE_DEFINE_CONSTANT(target, X509_CHECK_FLAG_NEVER_CHECK_SUBJECT); @@ -1339,6 +1429,8 @@ void X509Certificate::RegisterExternalReferences( registry->Register(IsX509Certificate); registry->Register(NewFromHandle); registry->Register(Parse); + registry->Register(ParseSnapshot); + registry->Register(GetSnapshot); registry->Register(Subject); registry->Register(SubjectAltName); registry->Register(InfoAccess); diff --git a/src/crypto/crypto_x509.h b/src/crypto/crypto_x509.h index 44714d1bcca..e618edd8e5a 100644 --- a/src/crypto/crypto_x509.h +++ b/src/crypto/crypto_x509.h @@ -54,6 +54,8 @@ class X509CertificateSnapshot final : public MemoryRetainer { ncrypto::X509View leaf, const STACK_OF(X509) * issuer_chain = nullptr, OPENSSL_SIZE_T issuers_start = 0); + static std::shared_ptr Create( + std::vector certificates); ncrypto::X509Pointer Parse(size_t index) const; @@ -89,6 +91,8 @@ class X509Certificate final : public BaseObject { static void IsX509Certificate( const v8::FunctionCallbackInfo& args); static void NewFromHandle(const v8::FunctionCallbackInfo& args); + static void ParseSnapshot(const v8::FunctionCallbackInfo& args); + static void GetSnapshot(const v8::FunctionCallbackInfo& args); static v8::MaybeLocal New( Environment* env, diff --git a/test/parallel/test-crypto-x509-chain-key-usage.js b/test/parallel/test-crypto-x509-chain-key-usage.js new file mode 100644 index 00000000000..100e2dbb9e5 --- /dev/null +++ b/test/parallel/test-crypto-x509-chain-key-usage.js @@ -0,0 +1,87 @@ +// Flags: --expose-internals --no-warnings +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { X509Certificate } = require('node:crypto'); +const { deserialize, serialize } = require('node:v8'); +const { + createX509CertificateFromSnapshot, +} = require('internal/crypto/x509'); +const fixtures = require('../common/fixtures'); + +const leaf = new X509Certificate(`-----BEGIN CERTIFICATE----- +MIIBHTCBxaADAgECAgECMAoGCCqGSM49BAMCMBoxGDAWBgNVBAMMD3NuYXBzaG90 +IGlzc3VlcjAeFw0yNTAxMDEwMDAwMDBaFw0zNTAxMDEwMDAwMDBaMBgxFjAUBgNV +BAMMDXNuYXBzaG90IGxlYWYwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQYBC5j +NN5rAvdjqeCKGhuSxH7DSi35DDi7dArQbeGw5FzdtQmOpglNYbi+TfmcRwkPouuR +i1cCQjEtL+3TW51PMAoGCCqGSM49BAMCA0cAMEQCIE/FmO4pJThTdhYs3kHamBe9 +Qo9qR4urR0ZVNoS320q2AiBxs3QJcbhz18plOnwj2n6TTcevxtJauggAca+AVUg+ +HQ== +-----END CERTIFICATE-----`); + +const issuer = new X509Certificate(`-----BEGIN CERTIFICATE----- +MIIBQjCB6aADAgECAgEBMAoGCCqGSM49BAMCMBoxGDAWBgNVBAMMD3NuYXBzaG90 +IGlzc3VlcjAeFw0yNTAxMDEwMDAwMDBaFw0zNTAxMDEwMDAwMDBaMBoxGDAWBgNV +BAMMD3NuYXBzaG90IGlzc3VlcjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABG4H +eatluz8bc/iTzQN0Ada94gDZpq5E1g+xP/6WAKXILrnvRBZhRBi2xIJExYu1QZq2 ++mvnupnjSy7kJUdBz2WjIDAeMAwGA1UdEwQFMAMBAf8wDgYDVR0PAQH/BAQDAgeA +MAoGCCqGSM49BAMCA0gAMEUCIQDqKmAVHvhW0i87KWzp8sjUWId5IVWSgi7iqJx+ +los0qwIgOALGVcPyyV56QNJGOIYCcXNLPQ9Adbs2arUVYcWGNEU= +-----END CERTIFICATE-----`); + +// The issuer's Key Usage omits keyCertSign. Inspecting or copying the chain +// does not verify its certificates. +assert.strictEqual(leaf.verify(issuer.publicKey), true); +assert.strictEqual(leaf.checkIssued(issuer), false); + +function assertChain(certificate, expected) { + const seen = new Set(); + for (const raw of expected) { + assert(certificate instanceof X509Certificate); + assert(!seen.has(certificate)); + seen.add(certificate); + assert.deepStrictEqual(certificate.raw, raw); + certificate = certificate.issuerCertificate; + } + assert.strictEqual(certificate, undefined); +} + +const unrelated = new X509Certificate(fixtures.readKey('agent1-cert.pem')); + +// A recognized extension can be malformed without making the enclosing +// certificate invalid DER. Snapshotting does not interpret extensions. +const malformedIssuer = Buffer.from(issuer.raw); +const basicConstraints = Buffer.from('30030101ff', 'hex'); +const basicConstraintsOffset = malformedIssuer.indexOf(basicConstraints); +assert.notStrictEqual(basicConstraintsOffset, -1); +malformedIssuer[basicConstraintsOffset] = 0x31; +assert.deepStrictEqual(new X509Certificate(malformedIssuer).raw, malformedIssuer); + +for (const expected of [ + [leaf.raw, issuer.raw], + [leaf.raw, leaf.raw, issuer.raw], + [leaf.raw, issuer.raw, leaf.raw], + [issuer.raw, leaf.raw], + [leaf.raw, unrelated.raw, issuer.raw], + [leaf.raw, malformedIssuer], +]) { + const certificate = createX509CertificateFromSnapshot(expected); + assertChain(certificate, expected); + assertChain(structuredClone(certificate), expected); + assertChain(deserialize(serialize(certificate)), expected); +} + +for (const snapshot of [ + [], + [Buffer.alloc(0)], + [leaf.raw, Buffer.from('not a certificate')], + [leaf.raw, Buffer.concat([issuer.raw, Buffer.from([0])])], +]) { + assert.throws(() => createX509CertificateFromSnapshot(snapshot), { + code: 'ERR_CRYPTO_OPERATION_FAILED', + }); +} diff --git a/test/parallel/test-crypto-x509-chain-snapshot.js b/test/parallel/test-crypto-x509-chain-snapshot.js index 5a0f696da0f..433abd9fcca 100644 --- a/test/parallel/test-crypto-x509-chain-snapshot.js +++ b/test/parallel/test-crypto-x509-chain-snapshot.js @@ -8,6 +8,7 @@ const assert = require('node:assert'); const { X509Certificate } = require('node:crypto'); const { once } = require('node:events'); const tls = require('node:tls'); +const { deserialize, serialize } = require('node:v8'); const { MessageChannel, Worker, @@ -88,6 +89,7 @@ const server = tls.createServer({ assertChain(structuredClone(first)); assertChain(await cloneViaMessagePort(first)); assertChain(await cloneViaWorker(first)); + assertChain(deserialize(serialize(first))); socket.destroy(); server.close(); diff --git a/test/parallel/test-crypto-x509-peer-chain.js b/test/parallel/test-crypto-x509-peer-chain.js index b60f3d00acc..d14df8eda92 100644 --- a/test/parallel/test-crypto-x509-peer-chain.js +++ b/test/parallel/test-crypto-x509-peer-chain.js @@ -8,6 +8,7 @@ const assert = require('node:assert'); const { X509Certificate } = require('node:crypto'); const { once } = require('node:events'); const tls = require('node:tls'); +const { deserialize, serialize } = require('node:v8'); const { MessageChannel, Worker } = require('node:worker_threads'); const fixtures = require('../common/fixtures'); @@ -38,6 +39,7 @@ function assertChain(actual, expected) { async function assertClones(certificate, chain) { assertChain(structuredClone(certificate), chain); + assertChain(deserialize(serialize(certificate)), chain); const { port1, port2 } = new MessageChannel(); port1.postMessage(certificate); diff --git a/test/parallel/test-v8-serdes.js b/test/parallel/test-v8-serdes.js index 223c0fd550c..ac1640a8ef2 100644 --- a/test/parallel/test-v8-serdes.js +++ b/test/parallel/test-v8-serdes.js @@ -56,6 +56,17 @@ const hostObject = new (internalBinding('js_stream').JSStream)(); } } +{ + const buffer = Buffer.from([1, 2, 3, 4]); + Object.defineProperty(buffer, Symbol.toStringTag, { + value: 'CustomBuffer', + }); + + const deserialized = v8.deserialize(v8.serialize(buffer)); + assert(Buffer.isBuffer(deserialized)); + assert.deepStrictEqual(deserialized, Buffer.from(buffer)); +} + { const ser = new v8.DefaultSerializer(); ser._getDataCloneError = common.mustCall((message) => { diff --git a/typings/internalBinding/crypto.d.ts b/typings/internalBinding/crypto.d.ts index 14da4e83fb4..f136f76322f 100644 --- a/typings/internalBinding/crypto.d.ts +++ b/typings/internalBinding/crypto.d.ts @@ -974,6 +974,9 @@ export interface CryptoBinding { getFipsCryptoGeneration(): bigint; getHashes(): string[]; getMacs(): string[]; + getX509CertificateSnapshot( + certificate: InternalCryptoBinding.X509CertificateHandle, + ): InternalCryptoBinding.Buffer[]; isCryptoKey(key: unknown): boolean; isKeyAlgorithmAvailable(name: string): boolean; isKeyObject(key: unknown): boolean; @@ -999,6 +1002,9 @@ export interface CryptoBinding { passphrase?: InternalCryptoBinding.ByteSource, ): InternalCryptoBinding.PKCS12ParseResult; parseX509(data: InternalCryptoBinding.ByteSource): InternalCryptoBinding.X509CertificateHandle; + parseX509Snapshot( + snapshot: ArrayBufferView[], + ): InternalCryptoBinding.X509CertificateHandle; privateDecrypt: InternalCryptoBinding.PublicKeyCipher; privateEncrypt: InternalCryptoBinding.PublicKeyCipher; publicDecrypt: InternalCryptoBinding.PublicKeyCipher; From 139507aaf0ce9dfe56b835113d54fe2fdb6d4ec6 Mon Sep 17 00:00:00 2001 From: Yuya Inoue <65857152+inoway46@users.noreply.github.com> Date: Thu, 5 Nov 2026 03:42:51 +0900 Subject: [PATCH 213/331] doc: document C++ formatting in the pull request guide Document formatter setup and usage separately from make lint so contributors can catch C/C++ formatting issues before CI runs. Refs: https://github.com/nodejs/node/pull/66834#issuecomment-6583209249 Assisted-by: Codex Signed-off-by: inoway46 PR-URL: https://github.com/nodejs/node/pull/67205 Reviewed-By: Luigi Pinca Reviewed-By: Darshan Sen --- doc/contributing/pull-requests.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/doc/contributing/pull-requests.md b/doc/contributing/pull-requests.md index 77b9148213b..2e03ad2a3c2 100644 --- a/doc/contributing/pull-requests.md +++ b/doc/contributing/pull-requests.md @@ -121,6 +121,16 @@ If you are modifying code, please be sure to run `make lint` (or `vcbuild.bat lint` on Windows) to ensure that the changes follow the Node.js code style guide. +For C/C++ changes, also run the formatter, which is not included in `make lint`. +Install the formatter tooling with `make format-cpp-build`, then format the +changes in your branch: + +```bash +CLANG_FORMAT_START=$(git merge-base HEAD main) make format-cpp +``` + +Review and commit any formatting changes before submitting the pull request. + Any documentation you write (including code comments and API documentation) should follow the [Style Guide](../../doc/README.md). Code samples included in the API docs will also be checked when running `make lint` (or From d69c446bd6edc75b2ad44422bc652503fba56d3e Mon Sep 17 00:00:00 2001 From: Damiano Mazzella Date: Wed, 4 Nov 2026 20:25:06 +0100 Subject: [PATCH 214/331] ffi: support function calls from pointers Add getFunctionFromPointer() to create callables from native addresses with explicit signatures. Reuse function preparation without populating named symbol caches. Keep the associated library alive and invalidate pointer callables when it is closed. Add coverage for conversions, vtables, permissions and garbage collection, and document pointer lifetime requirements. Assisted-by: GitHub Copilot Signed-off-by: Damiano Mazzella PR-URL: https://github.com/nodejs/node/pull/66458 Fixes: https://github.com/nodejs/node/issues/66272 Reviewed-By: Paolo Insogna Reviewed-By: Trivikram Kamat --- doc/api/ffi.md | 58 +++++++ lib/ffi.js | 6 + src/node_ffi.cc | 131 ++++++++++++--- src/node_ffi.h | 17 +- test/ffi/fixture_library/ffi_test_library.c | 37 +++++ test/ffi/test-ffi-calls.js | 174 ++++++++++++++++++++ test/ffi/test-ffi-permission-drop.js | 14 ++ test/ffi/test-ffi-weakref-calls.js | 121 ++++++++++++++ typings/internalBinding/ffi.d.ts | 1 + 9 files changed, 535 insertions(+), 24 deletions(-) diff --git a/doc/api/ffi.md b/doc/api/ffi.md index d505ca745df..3a8adb9378f 100644 --- a/doc/api/ffi.md +++ b/doc/api/ffi.md @@ -440,6 +440,64 @@ console.log(add(20, 22)); console.log(add.pointer); ``` +### `library.toFunction(pointer, signature)` + +* `pointer` {bigint} +* `signature` {Object} +* Returns: {Function} + +Creates a callable JavaScript wrapper for a native function address. The pointer +must be a nonzero, non-negative `bigint` that fits the platform's pointer width. +It can come from a resolved symbol, a native function's return value, or a +function pointer stored in native memory, such as a vtable slot. + +```cjs +const { DynamicLibrary, suffix } = require('node:ffi'); + +const lib = new DynamicLibrary(`./mylib.${suffix}`); +try { + const address = lib.getSymbol('add_i32'); + const add = lib.toFunction(address, { + arguments: ['int32', 'int32'], + return: 'int32', + }); + console.log(add(20, 22)); + console.log(add.pointer === address); +} finally { + lib.close(); +} +``` + +Argument and return conversions follow the same rules as `getFunction()`. +This method supports fixed signatures using the platform's default calling +convention. Explicit calling convention selection and structures passed or +returned by value are not supported. + +Each call creates a distinct wrapper. Multiple signatures can be associated +with the same address, but the caller is responsible for their correctness. +These wrappers do not appear in `library.functions`, `library.getFunctions()`, +`library.symbols`, or `library.getSymbols()` unless a symbol was separately +resolved by name. They use the generic libffi call path rather than Fast API +or SharedBuffer invokers. + +The wrapper keeps the associated library alive. Calling it after +`library.close()` throws `ERR_FFI_LIBRARY_CLOSED`. FFI permission is required +when creating the wrapper, including after permission has been revoked on an +already-open library. + +**The associated library does not establish ownership or validity of the +address.** Node.js cannot determine whether the pointer refers to executable +code, matches the signature, or is still valid. Passing a data pointer, using +an incorrect signature, or calling code that has been unloaded can crash the +process or corrupt memory. + +The caller must keep the actual code and any native object used by the call +alive. For example, associating a COM vtable method with `ole32.dll` does not +retain the COM object or the module implementing that method. The caller must +manage its native references and lifetime. A wrapper for a callback pointer +also becomes unsafe if that callback is unregistered, even if the associated +library remains open. + ### `library.getFunctions([definitions])` * `definitions` {Object} diff --git a/lib/ffi.js b/lib/ffi.js index 82663a9710d..f3295ad0ee7 100644 --- a/lib/ffi.js +++ b/lib/ffi.js @@ -152,6 +152,7 @@ ObjectDefineProperty(DynamicLibrary.prototype, 'constructor', { }); const rawGetFunction = DynamicLibrary.prototype.getFunction; +const rawToFunction = DynamicLibrary.prototype.toFunction; const rawGetFunctions = DynamicLibrary.prototype.getFunctions; const rawClose = DynamicLibrary.prototype.close; @@ -180,6 +181,11 @@ DynamicLibrary.prototype.getFunction = function getFunction(name, signature) { return wrapFFIFunction(raw, this); }; +DynamicLibrary.prototype.toFunction = function toFunction(pointer, signature) { + const raw = FunctionPrototypeCall(rawToFunction, this, pointer, signature); + return wrapFFIFunction(raw, this); +}; + DynamicLibrary.prototype.getFunctions = function getFunctions(definitions) { const raw = definitions === undefined ? FunctionPrototypeCall(rawGetFunctions, this) : diff --git a/src/node_ffi.cc b/src/node_ffi.cc index 50fc8815cf9..287bbb7f8db 100644 --- a/src/node_ffi.cc +++ b/src/node_ffi.cc @@ -106,6 +106,14 @@ void DynamicLibrary::MemoryInfo(MemoryTracker* tracker) const { sizeof(decltype(function_wrappers_)::value_type), "std::unordered_map>"); + tracker->TrackFieldWithSize( + "pointer_functions", + pointer_functions_ == nullptr + ? 0 + : sizeof(std::unordered_set) + + pointer_functions_->size() * sizeof(FFIFunction*), + "std::unordered_set"); + // FFIFunctionInfo instances and their sb_backing ArrayBuffers are // owned by V8 function wrappers and reachable only via weak references, // so they are deliberately not counted here. @@ -117,6 +125,14 @@ void DynamicLibrary::Close() { fn->ptr = nullptr; } + if (pointer_functions_ != nullptr) { + for (FFIFunction* fn : *pointer_functions_) { + fn->closed = true; + fn->ptr = nullptr; + } + pointer_functions_->clear(); + } + // Closing the library invalidates all registered callbacks. Node.js does not // track or revoke callback pointers that have already been handed to native // code. If native code calls a callback pointer after `close()` or @@ -158,7 +174,10 @@ Maybe DynamicLibrary::ResolveSymbol(Environment* env, } Maybe DynamicLibrary::PrepareFunction( - Environment* env, const std::string& name, Local signature) { + Environment* env, + const std::string& name, + Local signature, + void* ptr) { std::shared_ptr fn; FunctionSignature parsed; @@ -167,7 +186,8 @@ Maybe DynamicLibrary::PrepareFunction( } // Look up the cache only after parsing: the signature's getters run user // code that may close the library, which clears `functions_`. - auto existing = functions_.find(name); + const bool from_pointer = ptr != nullptr; + auto existing = from_pointer ? functions_.end() : functions_.find(name); auto [return_type, args, return_type_name, arg_type_names] = std::move(parsed); @@ -175,14 +195,13 @@ Maybe DynamicLibrary::PrepareFunction( bool should_cache_function = false; if (existing == functions_.end()) { - void* ptr; - - if (!ResolveSymbol(env, name).To(&ptr)) { - return {}; + if (!from_pointer) { + if (!ResolveSymbol(env, name).To(&ptr)) { + return {}; + } + should_cache_symbol = symbols_.find(name) == symbols_.end(); } - should_cache_symbol = symbols_.find(name) == symbols_.end(); - fn = std::make_shared(); fn->ptr = ptr; fn->args = std::move(args); @@ -221,7 +240,7 @@ Maybe DynamicLibrary::PrepareFunction( } #endif - should_cache_function = true; + should_cache_function = !from_pointer; } else { fn = existing->second; @@ -309,7 +328,6 @@ MaybeLocal DynamicLibrary::CreateFunction( const std::string& name, const std::shared_ptr& fn) { Isolate* isolate = env->isolate(); - Local context = env->context(); // Creating a callable emits a trampoline, allocates an FFIFunctionInfo, and // on the SharedBuffer path allocates an ArrayBuffer, so reuse the one already @@ -324,20 +342,41 @@ MaybeLocal DynamicLibrary::CreateFunction( function_wrappers_.erase(cached); } + Local ret; + if (!BuildFunction(env, name, fn, true).ToLocal(&ret)) { + return {}; + } + function_wrappers_.emplace(name, Global(isolate, ret)) + .first->second.SetWeak(); + return ret; +} + +MaybeLocal DynamicLibrary::BuildFunction( + Environment* env, + const std::string& name, + const std::shared_ptr& fn, + bool optimize) { + Isolate* isolate = env->isolate(); + Local context = env->context(); auto info = FFIFunctionInfo::Create(env, fn, this); + if (!info) { + return {}; + } DCHECK_EQ(fn->args.size(), fn->arg_type_names.size()); // Try the generated Fast API path first. If metadata creation rejects the // signature, fall back to SharedBuffer for supported scalar shapes, then to // the generic libffi invoker. - std::shared_ptr fast_fn = CloneWithRawPointerArgNames(fn); - if (!CreateFastFFIMetadata(*fast_fn, &fn->closed, isolate) - .MoveTo(&info->fast_metadata)) { - return {}; + if (optimize) { + std::shared_ptr fast_fn = CloneWithRawPointerArgNames(fn); + if (!CreateFastFFIMetadata(*fast_fn, &fn->closed, isolate) + .MoveTo(&info->fast_metadata)) { + return {}; + } } bool use_fast_api = info->fast_metadata != nullptr; - bool use_sb = !use_fast_api && IsSBEligibleSignature(*fn); + bool use_sb = optimize && !use_fast_api && IsSBEligibleSignature(*fn); bool has_ptr_args = use_sb && SignatureHasPointerArgs(*fn); // Signatures that need JS-side conversion or validation use a wrapper, as // do all fast signatures on platforms without a native library guard. @@ -532,14 +571,6 @@ MaybeLocal DynamicLibrary::CreateFunction( } } - // A strong handle would root the callable, which holds the library object - // through FFIFunctionInfo, so neither could ever be collected. Weaken the - // stored handle instead, so the cache lasts exactly as long as user code - // keeps a reference. SetWeak() runs after the move into the map because - // moving a handle relocates the underlying slot. - function_wrappers_.emplace(name, Global(isolate, ret)) - .first->second.SetWeak(); - return ret; } @@ -921,6 +952,59 @@ void DynamicLibrary::GetFunction(const FunctionCallbackInfo& args) { args.GetReturnValue().Set(ret); } +void DynamicLibrary::ToFunction(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + THROW_IF_INSUFFICIENT_PERMISSIONS(env, permission::PermissionScope::kFFI, ""); + + if (args.Length() < 1 || !args[0]->IsBigInt()) { + THROW_ERR_INVALID_ARG_TYPE(env, "Function pointer must be a bigint"); + return; + } + bool lossless; + uint64_t address = args[0].As()->Uint64Value(&lossless); + if (!lossless || address == 0 || + address > static_cast(std::numeric_limits::max())) { + THROW_ERR_INVALID_ARG_VALUE(env, "Invalid function pointer"); + return; + } + if (args.Length() < 2 || !args[1]->IsObject() || args[1]->IsArray()) { + THROW_ERR_INVALID_ARG_TYPE(env, "Function signature must be an object"); + return; + } + + DynamicLibrary* lib = Unwrap(args.This()); + if (lib->is_closed()) { + THROW_ERR_FFI_LIBRARY_CLOSED(env); + return; + } + Local signature = args[1].As(); + PreparedFunction prepared; + void* ptr = reinterpret_cast(static_cast(address)); + if (!lib->PrepareFunction(env, "", signature, ptr).To(&prepared)) { + return; + } + THROW_IF_INSUFFICIENT_PERMISSIONS(env, permission::PermissionScope::kFFI, ""); + if (lib->is_closed()) { + THROW_ERR_FFI_LIBRARY_CLOSED(env); + return; + } + + auto fn = std::move(prepared.fn); + if (lib->pointer_functions_ == nullptr) { + lib->pointer_functions_ = + std::make_shared>(); + } + fn->pointer_registry = lib->pointer_functions_; + lib->pointer_functions_->insert(fn.get()); + Local ret; + if (!lib->BuildFunction(env, "", fn, false).ToLocal(&ret)) { + lib->pointer_functions_->erase(fn.get()); + fn->ptr = nullptr; + return; + } + args.GetReturnValue().Set(ret); +} + void DynamicLibrary::GetFunctions(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); Isolate* isolate = env->isolate(); @@ -1397,6 +1481,7 @@ Local DynamicLibrary::GetConstructorTemplate( SetProtoMethod(isolate, tmpl, "close", DynamicLibrary::Close); SetProtoDispose(isolate, tmpl, DynamicLibrary::Close); SetProtoMethod(isolate, tmpl, "getFunction", DynamicLibrary::GetFunction); + SetProtoMethod(isolate, tmpl, "toFunction", DynamicLibrary::ToFunction); SetProtoMethod(isolate, tmpl, "getFunctions", DynamicLibrary::GetFunctions); SetProtoMethod(isolate, tmpl, "getSymbol", DynamicLibrary::GetSymbol); SetProtoMethod(isolate, tmpl, "getSymbols", DynamicLibrary::GetSymbols); diff --git a/src/node_ffi.h b/src/node_ffi.h index 4b5df70124d..86737273e28 100644 --- a/src/node_ffi.h +++ b/src/node_ffi.h @@ -12,6 +12,7 @@ #include #include #include +#include #include // libffi only accelerates reusable call plans on x86-64 System V. Other @@ -29,12 +30,18 @@ struct FFIFunction; struct FFIFunction { FFIFunction() = default; + ~FFIFunction() { + if (auto registry = pointer_registry.lock()) { + registry->erase(this); + } + } FFIFunction(const FFIFunction&) = delete; FFIFunction& operator=(const FFIFunction&) = delete; FFIFunction(FFIFunction&&) = delete; FFIFunction& operator=(FFIFunction&&) = delete; bool closed = false; + std::weak_ptr> pointer_registry; void* ptr = nullptr; ffi_cif cif = {}; @@ -136,6 +143,7 @@ class DynamicLibrary : public BaseObject { static void GetPath(const v8::FunctionCallbackInfo& args); static void GetFunction(const v8::FunctionCallbackInfo& args); + static void ToFunction(const v8::FunctionCallbackInfo& args); static void GetFunctions(const v8::FunctionCallbackInfo& args); static void GetSymbol(const v8::FunctionCallbackInfo& args); static void GetSymbols(const v8::FunctionCallbackInfo& args); @@ -159,11 +167,17 @@ class DynamicLibrary : public BaseObject { }; v8::Maybe PrepareFunction(Environment* env, const std::string& name, - v8::Local signature); + v8::Local signature, + void* ptr = nullptr); v8::MaybeLocal CreateFunction( Environment* env, const std::string& name, const std::shared_ptr& fn); + v8::MaybeLocal BuildFunction( + Environment* env, + const std::string& name, + const std::shared_ptr& fn, + bool optimize); static void CleanupHook(void* arg); static void CleanupFunctionInfo( const v8::WeakCallbackInfo& data); @@ -179,6 +193,7 @@ class DynamicLibrary : public BaseObject { // which keeps the map from rooting the library through the wrapper's // FFIFunctionInfo. std::unordered_map> function_wrappers_; + std::shared_ptr> pointer_functions_; std::unordered_map> callbacks_; }; diff --git a/test/ffi/fixture_library/ffi_test_library.c b/test/ffi/fixture_library/ffi_test_library.c index 3e24b7cd3d3..d04b55a2078 100644 --- a/test/ffi/fixture_library/ffi_test_library.c +++ b/test/ffi/fixture_library/ffi_test_library.c @@ -11,6 +11,43 @@ // Integer operations. +typedef int32_t (*PointerUnaryFunction)(int32_t); + +FFI_EXPORT uint32_t get_pointer_size(void) { + return sizeof(uintptr_t); +} + +static int32_t pointer_increment(int32_t value) { + return value + 1; +} + +FFI_EXPORT PointerUnaryFunction get_function_pointer(void) { + return pointer_increment; +} + +typedef struct PointerTestObject PointerTestObject; +typedef int32_t (*PointerTestMethod)(PointerTestObject*, int32_t); + +struct PointerTestObject { + const PointerTestMethod* vtable; + int32_t base; +}; + +static int32_t pointer_object_add(PointerTestObject* self, int32_t value) { + return self->base + value; +} + +FFI_EXPORT PointerTestObject* get_pointer_test_object(void) { + static const PointerTestMethod vtable[] = {pointer_object_add}; + static PointerTestObject object = {vtable, 40}; + return &object; +} + +FFI_EXPORT uint64_t pointer_string_lengths(const char* first, + const char* second) { + return strlen(first) + strlen(second); +} + FFI_EXPORT void noop_void(void) {} FFI_EXPORT int8_t add_i8(int8_t a, int8_t b) { diff --git a/test/ffi/test-ffi-calls.js b/test/ffi/test-ffi-calls.js index 338a728bd22..3dbd1a905d1 100644 --- a/test/ffi/test-ffi-calls.js +++ b/test/ffi/test-ffi-calls.js @@ -11,6 +11,180 @@ function getLibrary() { return ffi.dlopen(libraryPath, fixtureSymbols); } +test('ffi function pointers are independent callables with library guards', () => { + const { lib } = ffi.dlopen(libraryPath); + try { + const signature = { arguments: ['i32', 'i32'], return: 'i32' }; + const address = lib.getSymbol('add_i32'); + const first = lib.toFunction(address, signature); + const second = lib.toFunction(address, signature); + assert.notStrictEqual(first, second); + assert.strictEqual(first.pointer, address); + assert.strictEqual(first(20, 22), 42); + assert.strictEqual(second(-10, 52), 42); + assert.deepStrictEqual(Object.keys(lib.functions), []); + assert.deepStrictEqual(Object.keys(lib.getFunctions()), []); + const named = lib.getFunction('add_i32', signature); + assert.notStrictEqual(named, first); + assert.strictEqual(lib.toFunction(named.pointer, signature)(1, 2), 3); + assert.throws(() => first(1), { code: 'ERR_INVALID_ARG_VALUE' }); + assert.throws(() => first(1, 2, 3), { code: 'ERR_INVALID_ARG_VALUE' }); + assert.throws(() => first(1, 2n), { code: 'ERR_INVALID_ARG_VALUE' }); + const different = lib.toFunction(address, { + arguments: ['f64'], return: 'f64', + }); + assert.notStrictEqual(different, first); + lib.close(); + for (const fn of [first, second, different]) { + assert.throws(() => fn(), { code: 'ERR_FFI_LIBRARY_CLOSED' }); + } + assert.throws(() => lib.toFunction(address, signature), { + code: 'ERR_FFI_LIBRARY_CLOSED', + }); + } finally { + lib.close(); + } +}); + +test('ffi calls function pointers returned by C and stored in vtables', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + get_function_pointer: { arguments: [], return: 'pointer' }, + get_pointer_test_object: { arguments: [], return: 'pointer' }, + get_pointer_size: { arguments: [], return: 'u32' }, + }); + try { + const increment = lib.toFunction(functions.get_function_pointer(), { + arguments: ['i32'], return: 'i32', + }); + assert.strictEqual(increment(41), 42); + const readPointer = functions.get_pointer_size() === 8 ? + (address) => ffi.getUint64(address) : (address) => BigInt(ffi.getUint32(address)); + const object = functions.get_pointer_test_object(); + const vtable = readPointer(object); + const method = lib.toFunction(readPointer(vtable), { + arguments: ['pointer', 'i32'], return: 'i32', + }); + assert.strictEqual(method(object, 2), 42); + lib.close(); + assert.throws(() => method(object, 2), { code: 'ERR_FFI_LIBRARY_CLOSED' }); + } finally { + lib.close(); + } +}); + +test('ffi function pointers reuse scalar, buffer and string conversions', () => { + const { lib } = ffi.dlopen(libraryPath); + try { + for (const [name, signature, values, expected] of [ + ['add_i8', { arguments: ['i8', 'i8'], return: 'i8' }, [120, 10], -126], + ['add_u64', { arguments: ['u64', 'u64'], return: 'u64' }, [20n, 22n], 42n], + ['add_f32', { arguments: ['f32', 'f32'], return: 'f32' }, [1.25, 2.75], 4], + ['multiply_f64', { arguments: ['f64', 'f64'], return: 'f64' }, [6, 7], 42], + ['noop_void', { arguments: [], return: 'void' }, [], undefined], + ['pointer_string_lengths', { arguments: ['string', 'string'], return: 'u64' }, + ['first', 'second'], 11n], + ]) { + const fn = lib.toFunction(lib.getSymbol(name), signature); + assert.strictEqual(fn(...values), expected); + } + const identity = lib.toFunction(lib.getSymbol('identity_pointer'), { + arguments: ['pointer'], return: 'pointer', + }); + const buffer = Buffer.from([1, 2, 3]); + assert.strictEqual(identity(buffer), ffi.getRawPointer(buffer)); + const view = new Uint8Array(buffer.buffer, buffer.byteOffset + 1, 1); + assert.strictEqual(identity(view), ffi.getRawPointer(view)); + assert.strictEqual(identity(null), 0n); + assert.strictEqual(identity(undefined), 0n); + const lengths = lib.toFunction(lib.getSymbol('pointer_string_lengths'), { + arguments: ['string', 'string'], return: 'u64', + }); + assert.throws(() => lengths('first\0', 'second'), { code: 'ERR_INVALID_ARG_VALUE' }); + assert.strictEqual(lengths('first', 'second'), 11n); + } finally { + lib.close(); + } +}); + +test('ffi function pointers reject invalid addresses and signatures', () => { + const { lib } = ffi.dlopen(libraryPath); + try { + const signature = { arguments: ['i32', 'i32'], return: 'i32' }; + const address = lib.getSymbol('add_i32'); + for (const value of [undefined, null, 1, '1', {}, + { valueOf: common.mustNotCall() }]) { + assert.throws(() => lib.toFunction(value, signature), { + code: 'ERR_INVALID_ARG_TYPE', + }); + } + const pointerSize = lib.getFunction('get_pointer_size', { + arguments: [], return: 'u32', + })(); + for (const value of [0n, -1n, 2n ** BigInt(pointerSize * 8), 2n ** 64n]) { + assert.throws(() => lib.toFunction(value, signature), { + code: 'ERR_INVALID_ARG_VALUE', + }); + } + for (const value of [undefined, null, 1, 'signature', []]) { + assert.throws(() => lib.toFunction(address, value), { + code: 'ERR_INVALID_ARG_TYPE', + }); + } + assert.throws(() => lib.toFunction(address, { return: 'unknown' }), { + code: 'ERR_INVALID_ARG_VALUE', + }); + assert.strictEqual(lib.toFunction(address, signature)(20, 22), 42); + } finally { + lib.close(); + } +}); + +test('ffi function pointer signature getters preserve errors and closure', () => { + for (const property of ['return', 'arguments']) { + const { lib } = ffi.dlopen(libraryPath); + try { + const address = lib.getSymbol('add_i32'); + const failure = new Error('pointer signature getter failed'); + const signature = { arguments: ['i32', 'i32'], return: 'i32' }; + Object.defineProperty(signature, property, { get() { throw failure; } }); + assert.throws(() => lib.toFunction(address, signature), + (error) => error === failure); + Object.defineProperty(signature, property, { + get() { + lib.close(); + return property === 'arguments' ? ['i32', 'i32'] : 'i32'; + }, + }); + assert.throws(() => lib.toFunction(address, signature), { + code: 'ERR_FFI_LIBRARY_CLOSED', + }); + } finally { + lib.close(); + } + } +}); + +test('ffi function pointer guards survive optimized JavaScript call sites', () => { + const { lib } = ffi.dlopen(libraryPath); + const fn = lib.toFunction(lib.getSymbol('add_i32'), { + arguments: ['i32', 'i32'], return: 'i32', + }); + function call(first, second) { + return fn(first, second); + } + try { + eval('%PrepareFunctionForOptimization(call)'); + assert.strictEqual(call(20, 22), 42); + eval('%OptimizeFunctionOnNextCall(call)'); + assert.strictEqual(call(20, 22), 42); + assert.throws(() => call(1, {}), { code: 'ERR_INVALID_ARG_VALUE' }); + lib.close(); + assert.throws(() => call(20, 22), { code: 'ERR_FFI_LIBRARY_CLOSED' }); + } finally { + lib.close(); + } +}); + test('ffi calls support integer arithmetic and char semantics', () => { const { lib, functions: symbols } = getLibrary(); try { diff --git a/test/ffi/test-ffi-permission-drop.js b/test/ffi/test-ffi-permission-drop.js index 275499503e6..a20ff8e6705 100644 --- a/test/ffi/test-ffi-permission-drop.js +++ b/test/ffi/test-ffi-permission-drop.js @@ -29,6 +29,20 @@ function openLibrary() { } { + const { lib } = ffi.dlopen(libraryPath); + const address = lib.getSymbol('add_i32'); + const signature = { arguments: ['i32', 'i32'], return: 'i32' }; + assert.strictEqual(lib.toFunction(address, signature)(20, 22), 42); + assert.throws(() => lib.toFunction(address, { + get arguments() { + process.permission.drop('ffi'); + return ['i32', 'i32']; + }, + return: 'i32', + }), common.expectsError({ code: 'ERR_ACCESS_DENIED', permission: 'FFI' })); + assert.throws(() => lib.toFunction(address, signature), + common.expectsError({ code: 'ERR_ACCESS_DENIED', permission: 'FFI' })); + lib.close(); process.permission.drop('ffi'); assert.ok(!process.permission.has('ffi')); assert.throws(() => { diff --git a/test/ffi/test-ffi-weakref-calls.js b/test/ffi/test-ffi-weakref-calls.js index 4daa26a9e35..37758ea61af 100644 --- a/test/ffi/test-ffi-weakref-calls.js +++ b/test/ffi/test-ffi-weakref-calls.js @@ -8,6 +8,127 @@ const test = require('node:test'); const ffi = require('node:ffi'); const { fixtureSymbols, libraryPath } = require('./ffi-test-common'); +test('ffi function pointer callables retain their library through GC', async (t) => { + let library = ffi.dlopen(libraryPath); + const ref = new WeakRef(library.lib); + const fn = library.lib.toFunction(library.lib.getSymbol('add_i32'), { + arguments: ['i32', 'i32'], return: 'i32', + }); + library = null; + try { + for (let index = 0; index < 5; index++) { + await gcUntil('ffi function pointer retains library', () => true, 1); + t.assert.notStrictEqual(ref.deref(), undefined); + t.assert.strictEqual(fn(20, 22), 42); + } + } finally { + ref.deref()?.close(); + } + t.assert.throws(() => fn(20, 22), { code: 'ERR_FFI_LIBRARY_CLOSED' }); +}); + +test('ffi function pointer registry does not retain callables', async (t) => { + const { lib } = ffi.dlopen(libraryPath); + try { + const address = lib.getSymbol('add_i32'); + const refs = []; + for (let index = 0; index < 100; index++) { + let fn = lib.toFunction(address, { + arguments: ['i32', 'i32'], return: 'i32', + }); + refs.push(new WeakRef(fn)); + fn = null; + } + await gcUntil('ffi function pointer callables are collected', + () => refs.every((ref) => ref.deref() === undefined)); + const fn = lib.toFunction(address, { + arguments: ['i32', 'i32'], return: 'i32', + }); + t.assert.strictEqual(fn(20, 22), 42); + lib.close(); + t.assert.throws(() => fn(20, 22), { code: 'ERR_FFI_LIBRARY_CLOSED' }); + } finally { + lib.close(); + } +}); + +test('ffi pointer callable construction ignores throwing inherited setters', async (t) => { + const { lib } = ffi.dlopen(libraryPath); + t.after(() => lib.close()); + const address = lib.getSymbol('add_i32'); + const original = Object.getOwnPropertyDescriptor(Function.prototype, 'pointer'); + let fn; + let setterCalls = 0; + const failure = new Error('pointer setter failed'); + try { + Object.defineProperty(Function.prototype, 'pointer', { + configurable: true, + get() { return undefined; }, + set() { + setterCalls++; + throw failure; + }, + }); + fn = lib.toFunction(address, { + arguments: ['i32', 'i32'], return: 'i32', + }); + t.assert.strictEqual(setterCalls, 0); + t.assert.strictEqual(Object.getOwnPropertyDescriptor(fn, 'pointer').value, address); + t.assert.strictEqual(fn(20, 22), 42); + } finally { + if (original === undefined) { + delete Function.prototype.pointer; + } else { + Object.defineProperty(Function.prototype, 'pointer', original); + } + } + try { + const ref = new WeakRef(fn); + fn = null; + await gcUntil('ffi pointer callable with inherited setter is collected', + () => ref.deref() === undefined); + } finally { + lib.close(); + } +}); + +test('ffi pointer callable construction ignores inherited setters that close the library', async (t) => { + const { lib } = ffi.dlopen(libraryPath); + t.after(() => lib.close()); + const address = lib.getSymbol('add_i32'); + const original = Object.getOwnPropertyDescriptor(Function.prototype, 'pointer'); + let fn; + let setterCalls = 0; + try { + Object.defineProperty(Function.prototype, 'pointer', { + configurable: true, + get() { return undefined; }, + set() { + setterCalls++; + lib.close(); + }, + }); + fn = lib.toFunction(address, { + arguments: ['i32', 'i32'], return: 'i32', + }); + t.assert.strictEqual(setterCalls, 0); + t.assert.strictEqual(Object.getOwnPropertyDescriptor(fn, 'pointer').value, address); + t.assert.strictEqual(fn(20, 22), 42); + } finally { + if (original === undefined) { + delete Function.prototype.pointer; + } else { + Object.defineProperty(Function.prototype, 'pointer', original); + } + } + lib.close(); + t.assert.throws(() => fn(20, 22), { code: 'ERR_FFI_LIBRARY_CLOSED' }); + const ref = new WeakRef(fn); + fn = null; + await gcUntil('ffi pointer callable from closed library is collected', + () => ref.deref() === undefined); +}); + test('ffi unrefCallback releases callback function', async (t) => { const { lib, functions: symbols } = ffi.dlopen(libraryPath, fixtureSymbols); t.after(() => lib.close()); diff --git a/typings/internalBinding/ffi.d.ts b/typings/internalBinding/ffi.d.ts index bebf2afa24d..8ecadbeeb53 100644 --- a/typings/internalBinding/ffi.d.ts +++ b/typings/internalBinding/ffi.d.ts @@ -40,6 +40,7 @@ declare namespace InternalFFIBinding { close(): void; getFunction(name: string, signature: FunctionSignature): FFIFunction; + toFunction(pointer: bigint, signature: FunctionSignature): FFIFunction; getFunctions(): Record; getFunctions( definitions: Record, From 4c8cece9478be03f4810a1720c0915ab4e3b973b Mon Sep 17 00:00:00 2001 From: Shelley Vohr Date: Wed, 4 Nov 2026 13:04:54 -0800 Subject: [PATCH 215/331] build: sort the ICU source lists MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit configure.py lists the ICU source files in the order os.walk() returns them, which depends on the file system. That order ends up in icu_config.gypi and in the generated build files, so it differs between machines. Signed-off-by: Shelley Vohr PR-URL: https://github.com/nodejs/node/pull/67206 Reviewed-By: Richard Lau Reviewed-By: Beth Griggs Reviewed-By: Gürgün Dayıoğlu --- configure.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/configure.py b/configure.py index 78a2e11ac35..270b801c185 100755 --- a/configure.py +++ b/configure.py @@ -2511,7 +2511,7 @@ def glob_to_var(dir_base, dir_sub, patch_dir): info(f'Using floating patch "{patchfile}" from "{dir_base}"') file_list.append(srcfile) break - return file_list + return sorted(file_list) def configure_intl(o): def icu_download(path): From 92bfe9ae4f95b0d43cd5d7a0e0ffb56a4b166fe8 Mon Sep 17 00:00:00 2001 From: Roberto Bianchi Date: Thu, 5 Nov 2026 10:50:20 +0100 Subject: [PATCH 216/331] url: use indexed appends in search params getAll MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Use indexed writes when collecting matching parameter values. This improves getAll throughput without changing result order. Signed-off-by: Roberto Bianchi PR-URL: https://github.com/nodejs/node/pull/66872 Reviewed-By: Gürgün Dayıoğlu --- lib/internal/url.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/internal/url.js b/lib/internal/url.js index 456afd2242d..0fe819fe129 100644 --- a/lib/internal/url.js +++ b/lib/internal/url.js @@ -624,7 +624,7 @@ class URLSearchParams { const { length } = list; for (let i = 0; i < length; i += 2) { if (list[i] === name) { - ArrayPrototypePush(values, list[i + 1]); + values[values.length] = list[i + 1]; } } return values; From 621b99d2e4695712ee10150f6a0e25ae625e2a51 Mon Sep 17 00:00:00 2001 From: Stefan Stojanovic Date: Thu, 5 Nov 2026 14:17:47 +0100 Subject: [PATCH 217/331] build,win: minify pgo training build Signed-off-by: StefanStojanovic PR-URL: https://github.com/nodejs/node/pull/67214 Reviewed-By: Antoine du Hamel Reviewed-By: Luigi Pinca --- vcbuild.bat | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/vcbuild.bat b/vcbuild.bat index f94cc1d1bbe..45e61e979dd 100644 --- a/vcbuild.bat +++ b/vcbuild.bat @@ -224,6 +224,15 @@ if defined pgo_generate if defined pgo_use ( exit /b 1 ) +:: PGO generation build release flag cleaning +if defined build_release if defined pgo_generate ( + set package= + set msi= + set licensertf= + set cctest= + set sign= +) + if defined msi set stage_package=1 if defined package set stage_package=1 From 00839e2d848df4b368b82d49cef08b8167206f22 Mon Sep 17 00:00:00 2001 From: Joyee Cheung Date: Thu, 5 Nov 2026 16:21:41 +0100 Subject: [PATCH 218/331] src: do not enable the inspector during snapshot building V8 no longer allows attaching a debuger or setting a debug context ID during snapshot building. Avoid enabling the inspector in this case, and reject the inspector options when the user-land --build-snapshot is used. Refs: https://chromium-review.googlesource.com/c/v8/v8/+/8679045 Signed-off-by: Joyee Cheung PR-URL: https://github.com/nodejs/node/pull/67154 Reviewed-By: Chengzhong Wu Reviewed-By: Richard Lau --- doc/api/cli.md | 4 +++ doc/node.1 | 3 ++ src/inspector_agent.cc | 12 ++++++- src/node_options.cc | 37 +++++++++++--------- src/node_options.h | 8 +++++ test/parallel/test-inspect-address-in-use.js | 11 ++++-- test/parallel/test-snapshot-console.js | 5 ++- 7 files changed, 58 insertions(+), 22 deletions(-) diff --git a/doc/api/cli.md b/doc/api/cli.md index 72b1e9ef2e4..24925d718fb 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -669,6 +669,10 @@ an additional module during the snapshot building process is needed, please file a request in the [Node.js issue tracker][] and link to it in the [tracking issue for user-land snapshots][]. +During snapshot building, a debugger cannot be attached to the process. +`--build-snapshot` cannot be used together with `--inspect`, `--inspect-brk` or +`--inspect-wait`. + ### `--build-snapshot-config` * `size` {number} Optional argument to specify how much data to read. @@ -1573,8 +1579,12 @@ The optional `size` argument specifies a specific number of bytes to read. If the stream has ended, in which case all of the data remaining in the internal buffer will be returned. -If the `size` argument is not specified, all of the data contained in the -internal buffer will be returned. +If the `size` argument is not specified, `readable.read()` returns the next +buffered chunk, or the next object in object mode. If the entire internal +buffer is needed in a single call, `readable.read(readable.readableLength)` +returns all currently buffered data; because data can be buffered internally +without an explicit `push()`, some cases may additionally require calling +`readable.read(0)` first to ensure all buffered data is available. The `size` argument must be less than or equal to 1 GiB. From c9221de87d22fc392021e331f8f1f8d3f6c0efdd Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Wed, 11 Nov 2026 11:18:43 -0500 Subject: [PATCH 258/331] deps: update ngtcp2 to 1.26.0 PR-URL: https://github.com/nodejs/node/pull/67257 Reviewed-By: Antoine du Hamel --- deps/ngtcp2/ngtcp2/crypto/ossl/ossl.c | 17 +- deps/ngtcp2/ngtcp2/crypto/picotls/picotls.c | 6 +- deps/ngtcp2/ngtcp2/crypto/shared.c | 35 +- deps/ngtcp2/ngtcp2/examples/client.cc | 3 +- .../ngtcp2/examples/hq_client_proto_codec.cc | 4 + .../ngtcp2/examples/hq_client_proto_codec.h | 2 +- deps/ngtcp2/ngtcp2/examples/server.cc | 50 +- deps/ngtcp2/ngtcp2/examples/server.h | 2 +- deps/ngtcp2/ngtcp2/examples/server_base.h | 3 + deps/ngtcp2/ngtcp2/examples/sim_test.cc | 4 +- deps/ngtcp2/ngtcp2/examples/siphash_test.cc | 4 +- deps/ngtcp2/ngtcp2/examples/siphash_test.h | 2 +- .../examples/tests/ngtcp2test/client.py | 2 +- .../ngtcp2/examples/tests/ngtcp2test/tls.py | 27 +- .../examples/tests/test_04_clientcert.py | 10 +- .../examples/tls_client_context_picotls.cc | 3 +- deps/ngtcp2/ngtcp2/examples/util_test.cc | 493 ++---- .../ngtcp2/lib/includes/ngtcp2/ngtcp2.h | 123 +- .../ngtcp2/lib/includes/ngtcp2/version.h | 4 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_balloc.c | 4 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_callbacks.c | 3 + deps/ngtcp2/ngtcp2/lib/ngtcp2_cc.c | 39 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_cc.h | 23 + deps/ngtcp2/ngtcp2/lib/ngtcp2_cid.c | 16 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_cid.h | 12 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_conn.c | 1439 ++++++++++------- deps/ngtcp2/ngtcp2/lib/ngtcp2_conn.h | 128 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_crypto.h | 4 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_dcidtr.c | 21 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_dcidtr.h | 23 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_log.c | 5 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_map.c | 93 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_map.h | 4 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_pkt.c | 33 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_pkt.h | 4 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_ppe.c | 7 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_ppe.h | 3 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_pv.c | 19 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_pv.h | 19 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_qlog.c | 4 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_ratelim.c | 19 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_ratelim.h | 7 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_rob.c | 40 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_rob.h | 23 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_rtb.c | 183 ++- deps/ngtcp2/ngtcp2/lib/ngtcp2_rtb.h | 13 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_settings.c | 3 + deps/ngtcp2/ngtcp2/lib/ngtcp2_strm.c | 47 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_strm.h | 34 +- .../ngtcp2/lib/ngtcp2_transport_params.c | 9 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_unreachable.h | 6 +- deps/ngtcp2/ngtcp2/lib/ngtcp2_vec.c | 3 +- src/quic/session.cc | 11 +- ...est-quic-callback-error-stream-onerror.mjs | 9 +- 54 files changed, 1753 insertions(+), 1351 deletions(-) diff --git a/deps/ngtcp2/ngtcp2/crypto/ossl/ossl.c b/deps/ngtcp2/ngtcp2/crypto/ossl/ossl.c index 06712907754..8dd5cd126b3 100644 --- a/deps/ngtcp2/ngtcp2/crypto/ossl/ossl.c +++ b/deps/ngtcp2/ngtcp2/crypto/ossl/ossl.c @@ -411,6 +411,7 @@ static void crypto_buf_write(crypto_buf *cbuf, const uint8_t *data, struct ngtcp2_crypto_ossl_ctx { SSL *ssl; + ngtcp2_encryption_level rx_level; ngtcp2_encryption_level tx_level; crypto_buf *crypto_head, *crypto_read, *crypto_write; size_t crypto_head_released; @@ -425,6 +426,7 @@ int ngtcp2_crypto_ossl_ctx_new(ngtcp2_crypto_ossl_ctx **possl_ctx, SSL *ssl) { } ossl_ctx->ssl = ssl; + ossl_ctx->rx_level = NGTCP2_ENCRYPTION_LEVEL_INITIAL; ossl_ctx->tx_level = NGTCP2_ENCRYPTION_LEVEL_INITIAL; ossl_ctx->crypto_head = ossl_ctx->crypto_read = ossl_ctx->crypto_write = NULL; ossl_ctx->crypto_head_released = 0; @@ -962,7 +964,10 @@ int ngtcp2_crypto_read_write_crypto_data( SSL *ssl = ossl_ctx->ssl; int rv; int err; - (void)encryption_level; + + if (encryption_level != ossl_ctx->rx_level) { + return -1; + } if (crypto_ossl_ctx_write_crypto_data(ossl_ctx, data, datalen) != 0) { return -1; @@ -1128,7 +1133,10 @@ static int ossl_yield_secret(SSL *ssl, uint32_t ossl_level, int direction, return 0; } - ossl_ctx->tx_level = level; + /* CRYPTO data is never sent in 0-RTT packet. */ + if (level != NGTCP2_ENCRYPTION_LEVEL_0RTT) { + ossl_ctx->tx_level = level; + } return 1; } @@ -1138,6 +1146,11 @@ static int ossl_yield_secret(SSL *ssl, uint32_t ossl_level, int direction, return 0; } + /* This check is probably not needed, but just in case */ + if (level != NGTCP2_ENCRYPTION_LEVEL_0RTT) { + ossl_ctx->rx_level = level; + } + return 1; } diff --git a/deps/ngtcp2/ngtcp2/crypto/picotls/picotls.c b/deps/ngtcp2/ngtcp2/crypto/picotls/picotls.c index af934bf1046..e21c302f939 100644 --- a/deps/ngtcp2/ngtcp2/crypto/picotls/picotls.c +++ b/deps/ngtcp2/ngtcp2/crypto/picotls/picotls.c @@ -387,9 +387,11 @@ int ngtcp2_crypto_read_write_crypto_data( size_t i; int rv; - ptls_buffer_init(&sendbuf, (void *)"", 0); + if (epoch != ptls_get_read_epoch(cptls->ptls)) { + return -1; + } - assert(datalen == 0 || epoch == ptls_get_read_epoch(cptls->ptls)); + ptls_buffer_init(&sendbuf, (void *)"", 0); rv = ptls_handle_message(cptls->ptls, &sendbuf, epoch_offsets, epoch, data, datalen, &cptls->handshake_properties); diff --git a/deps/ngtcp2/ngtcp2/crypto/shared.c b/deps/ngtcp2/ngtcp2/crypto/shared.c index 925461e2397..2ee561a8689 100644 --- a/deps/ngtcp2/ngtcp2/crypto/shared.c +++ b/deps/ngtcp2/ngtcp2/crypto/shared.c @@ -236,6 +236,35 @@ int ngtcp2_crypto_update_traffic_secret(uint8_t *dest, uint32_t version, return 0; } +/* + * crypto_set_remote_transport_params retrieves remote QUIC transport + * parameters from |tls| and sets it to |conn|. Some TLS backends set + * them to |conn| from their own TLS extension callback instead, which + * is never called if a remote endpoint omits the extension. This + * function fails if they have not been set to |conn| after all. + * + * This function returns 0 if it succeeds, or -1. + */ +static int crypto_set_remote_transport_params(ngtcp2_conn *conn, void *tls) { + const ngtcp2_transport_params *params; + + if (ngtcp2_crypto_set_remote_transport_params(conn, tls) != 0) { + return -1; + } + + params = ngtcp2_conn_get_remote_transport_params2(conn); + + /* Client might have the remembered 0-RTT transport parameters, but + they never include initial_scid which is mandatory in the ones + received from a remote endpoint. */ + if (!params || !params->initial_scid_present) { + ngtcp2_conn_set_tls_error(conn, NGTCP2_ERR_REQUIRED_TRANSPORT_PARAM); + return -1; + } + + return 0; +} + int ngtcp2_crypto_derive_and_install_rx_key(ngtcp2_conn *conn, uint8_t *key, uint8_t *iv, uint8_t *hp_key, ngtcp2_encryption_level level, @@ -282,7 +311,7 @@ int ngtcp2_crypto_derive_and_install_rx_key(ngtcp2_conn *conn, uint8_t *key, case NGTCP2_ENCRYPTION_LEVEL_HANDSHAKE: if (ngtcp2_conn_is_server2(conn) && !ngtcp2_conn_get_negotiated_version2(conn)) { - rv = ngtcp2_crypto_set_remote_transport_params(conn, tls); + rv = crypto_set_remote_transport_params(conn, tls); if (rv != 0) { return -1; } @@ -340,7 +369,7 @@ int ngtcp2_crypto_derive_and_install_rx_key(ngtcp2_conn *conn, uint8_t *key, break; case NGTCP2_ENCRYPTION_LEVEL_1RTT: if (!ngtcp2_conn_is_server2(conn)) { - rv = ngtcp2_crypto_set_remote_transport_params(conn, tls); + rv = crypto_set_remote_transport_params(conn, tls); if (rv != 0) { goto fail; } @@ -443,7 +472,7 @@ int ngtcp2_crypto_derive_and_install_tx_key(ngtcp2_conn *conn, uint8_t *key, case NGTCP2_ENCRYPTION_LEVEL_HANDSHAKE: if (ngtcp2_conn_is_server2(conn) && !ngtcp2_conn_get_negotiated_version2(conn)) { - rv = ngtcp2_crypto_set_remote_transport_params(conn, tls); + rv = crypto_set_remote_transport_params(conn, tls); if (rv != 0) { return -1; } diff --git a/deps/ngtcp2/ngtcp2/examples/client.cc b/deps/ngtcp2/ngtcp2/examples/client.cc index 0950ebf3a4f..ec93de159cd 100644 --- a/deps/ngtcp2/ngtcp2/examples/client.cc +++ b/deps/ngtcp2/ngtcp2/examples/client.cc @@ -1721,7 +1721,8 @@ std::expected Client::make_stream_early() { void Client::on_extend_max_streams() { int64_t stream_id; - if ((config.delay_stream && !handshake_confirmed_) || + if (config.requests.empty() || + (config.delay_stream && !handshake_confirmed_) || ev_is_active(&delay_stream_timer_)) { return; } diff --git a/deps/ngtcp2/ngtcp2/examples/hq_client_proto_codec.cc b/deps/ngtcp2/ngtcp2/examples/hq_client_proto_codec.cc index ed072c8058f..bbfa33bfa6e 100644 --- a/deps/ngtcp2/ngtcp2/examples/hq_client_proto_codec.cc +++ b/deps/ngtcp2/ngtcp2/examples/hq_client_proto_codec.cc @@ -82,6 +82,10 @@ ProtoCodec::on_stream_close(int64_t stream_id, return {}; } + if (auto stream = client_->find_stream(stream_id); stream) { + sendq_.erase(stream); + } + if (!config.quiet) { std::println(stderr, "HTTP stream {:#x} closed with error codes (RX:{}, TX:{})", diff --git a/deps/ngtcp2/ngtcp2/examples/hq_client_proto_codec.h b/deps/ngtcp2/ngtcp2/examples/hq_client_proto_codec.h index 9e8e30b49af..a4a92350cc1 100644 --- a/deps/ngtcp2/ngtcp2/examples/hq_client_proto_codec.h +++ b/deps/ngtcp2/ngtcp2/examples/hq_client_proto_codec.h @@ -63,7 +63,7 @@ class ProtoCodec { std::expected extend_max_stream_data(int64_t stream_id, uint64_t max_data); - void early_data_rejected() {} + void early_data_rejected() { sendq_.clear(); } std::expected on_stream_close(int64_t stream_id, std::optional rx_app_error_code, diff --git a/deps/ngtcp2/ngtcp2/examples/server.cc b/deps/ngtcp2/ngtcp2/examples/server.cc index 79896b539a8..1f4bfd19e76 100644 --- a/deps/ngtcp2/ngtcp2/examples/server.cc +++ b/deps/ngtcp2/ngtcp2/examples/server.cc @@ -31,6 +31,8 @@ #include #include #include +#include +#include #include #include @@ -216,6 +218,11 @@ Stream::open_file(const std::filesystem::path &path) { close(fd); } else { fe.fd = fd; + // A file larger than the address space cannot be mapped. + if (std::cmp_greater(st.st_size, std::numeric_limits::max())) { + close(fd); + return std::unexpected{Error::INTEGER_OVERFLOW}; + } fe.len = static_cast(st.st_size); if (fe.len) { fe.map = mmap(nullptr, fe.len, PROT_READ, MAP_SHARED, fd, 0); @@ -321,9 +328,7 @@ void timeoutcb(struct ev_loop *loop, ev_timer *w, int revents) { } if (auto rv = h->handle_expiry(); !rv) { - if (rv.error() == Error::CLOSE_WAIT) { - ev_timer_stop(loop, w); - } else { + if (rv.error() != Error::CLOSE_WAIT) { s->remove(h); } @@ -773,6 +778,7 @@ Handler::init(const Endpoint &ep, const Address &local_addr, settings.handshake_timeout = config.handshake_timeout; settings.no_pmtud = config.no_pmtud; settings.ack_thresh = config.ack_thresh; + settings.write_stream_data_thresh = config.write_stream_data_thresh; if (config.max_udp_payload_size) { settings.max_tx_udp_payload_size = config.max_udp_payload_size; settings.no_tx_udp_payload_size_shaping = 1; @@ -1705,7 +1711,9 @@ void Server::on_read(const Endpoint &ep) { stderr, "Received packet: local={} remote={} if={} ecn={:#x} {} bytes", util::straddr(*local_addr), util::straddr(remote_addr), - if_indextoname(local_addr->ifindex, ifname.data()), pi.ecn, datalen); + if_indextoname(local_addr->ifindex, ifname.data()) ? ifname.data() + : "(unknown)", + pi.ecn, datalen); } // Packets less than 21 bytes never be a valid QUIC packet. @@ -1735,6 +1743,11 @@ void Server::read_pkt(const Endpoint &ep, const Address &local_addr, NGTCP2_SV_SCIDLEN); rv) { case 0: + if ((data[0] & 0x80U) && vc.version == 0) { + // Version Negotiation packet was received. + return; + } + break; case NGTCP2_ERR_VERSION_NEGOTIATION: (void)send_version_negotiation(vc.version, {vc.scid, vc.scidlen}, @@ -2658,6 +2671,15 @@ void print_help() { to send per an event loop in a single connection. It defaults to 0, which means it is not limited by the configuration. + --write-stream-data-thresh= + The threshold for the length of STREAM frame payload + that the local endpoint sends. If there is data more + than this value to send, and the flow control does not + allow sending more than this length, the data is not + sent, waiting for the window update from the remote + endpoint. + Default: )" + << config.write_stream_data_thresh << R"( -h, --help Display this help and exit. --- @@ -2732,6 +2754,7 @@ int main(int argc, char **argv) { {"no-gso", no_argument, &flag, 35}, {"show-stat", no_argument, &flag, 36}, {"gso-burst", required_argument, &flag, 37}, + {"write-stream-data-thresh", required_argument, &flag, 38}, {}, }; @@ -3163,6 +3186,25 @@ int main(int argc, char **argv) { break; } + case 38: { + // --write-stream-data-thresh + auto n = util::parse_uint_iec(optarg); + if (!n) { + std::println(stderr, "write-stream-data-thresh: invalid argument"); + exit(EXIT_FAILURE); + } + + if (auto max = std::numeric_limits::max(); *n > max) { + std::println( + stderr, + "write-stream-data-thresh: must be less than or equal to {}", max); + exit(EXIT_FAILURE); + } + + config.write_stream_data_thresh = static_cast(*n); + + break; + } } break; default: diff --git a/deps/ngtcp2/ngtcp2/examples/server.h b/deps/ngtcp2/ngtcp2/examples/server.h index 8a71a12a2e7..3d7a47fc420 100644 --- a/deps/ngtcp2/ngtcp2/examples/server.h +++ b/deps/ngtcp2/ngtcp2/examples/server.h @@ -68,7 +68,7 @@ enum FileEntryFlag { }; struct FileEntry { - uint64_t len{}; + size_t len{}; void *map{}; int fd{}; uint8_t flags{}; diff --git a/deps/ngtcp2/ngtcp2/examples/server_base.h b/deps/ngtcp2/ngtcp2/examples/server_base.h index 9438d11f8bd..af0660fe7ae 100644 --- a/deps/ngtcp2/ngtcp2/examples/server_base.h +++ b/deps/ngtcp2/ngtcp2/examples/server_base.h @@ -169,6 +169,9 @@ struct Config { // gso_burst is the number of packets to aggregate in GSO. 0 means // it is not limited by the configuration. size_t gso_burst{}; + // write_stream_data_thresh is the threshold for the length of + // STREAM frame payload that the local endpoint sends. + size_t write_stream_data_thresh{255}; }; struct HTTPHeader { diff --git a/deps/ngtcp2/ngtcp2/examples/sim_test.cc b/deps/ngtcp2/ngtcp2/examples/sim_test.cc index b7e6d69e36d..23c3282fa14 100644 --- a/deps/ngtcp2/ngtcp2/examples/sim_test.cc +++ b/deps/ngtcp2/ngtcp2/examples/sim_test.cc @@ -130,8 +130,8 @@ void test_sim_unistream(void) { assert_true(rv.has_value()); assert_true(svapp.is_all_bytes_sent()); - assert_uint64(link.compute_expected_goodput(link.delay * 2), <=, - svapp.compute_goodput()); + assert_lte(link.compute_expected_goodput(link.delay * 2), + svapp.compute_goodput()); } } diff --git a/deps/ngtcp2/ngtcp2/examples/siphash_test.cc b/deps/ngtcp2/ngtcp2/examples/siphash_test.cc index 54f300444ef..77ac585ee4e 100644 --- a/deps/ngtcp2/ngtcp2/examples/siphash_test.cc +++ b/deps/ngtcp2/ngtcp2/examples/siphash_test.cc @@ -62,7 +62,7 @@ void test_siphash(void) { std::array input; std::iota(std::ranges::begin(input), std::ranges::end(input), 0); - assert_uint64(0xA129CA6149BE45E5ULL, ==, siphash24(key, input)); + assert_eq(0xA129CA6149BE45E5ULL, siphash24(key, input)); } void test_siphash_vector(void) { @@ -91,7 +91,7 @@ void test_siphash_vector(void) { expect = byteswap(expect); } - assert_uint64(expect, ==, h); + assert_eq(expect, h); } } diff --git a/deps/ngtcp2/ngtcp2/examples/siphash_test.h b/deps/ngtcp2/ngtcp2/examples/siphash_test.h index c356d2e6b00..11a867f9450 100644 --- a/deps/ngtcp2/ngtcp2/examples/siphash_test.h +++ b/deps/ngtcp2/ngtcp2/examples/siphash_test.h @@ -32,7 +32,7 @@ #define MUNIT_ENABLE_ASSERT_ALIASES -#include "munit.h" +#include "munitxx.h" namespace ngtcp2 { diff --git a/deps/ngtcp2/ngtcp2/examples/tests/ngtcp2test/client.py b/deps/ngtcp2/ngtcp2/examples/tests/ngtcp2test/client.py index c22f661a782..4a631627099 100644 --- a/deps/ngtcp2/ngtcp2/examples/tests/ngtcp2test/client.py +++ b/deps/ngtcp2/ngtcp2/examples/tests/ngtcp2test/client.py @@ -107,7 +107,7 @@ def assert_verify_null_handshake(self): def assert_verify_cert_handshake(self): c_hs, s_hs = self.norm_exp( "ServerHello:EncryptedExtensions:CertificateRequest:(Compressed)?Certificate:CertificateVerify:Finished", - "ClientHello:Certificate:CertificateVerify:Finished") + "ClientHello:(Compressed)?Certificate:CertificateVerify:Finished") self._assert_hs(c_hs, s_hs) diff --git a/deps/ngtcp2/ngtcp2/examples/tests/ngtcp2test/tls.py b/deps/ngtcp2/ngtcp2/examples/tests/ngtcp2test/tls.py index 414b94d38e5..ded059416b6 100644 --- a/deps/ngtcp2/ngtcp2/examples/tests/ngtcp2test/tls.py +++ b/deps/ngtcp2/ngtcp2/examples/tests/ngtcp2test/tls.py @@ -842,6 +842,31 @@ def to_text(self, indent: int = 0): f'{ind} certificate_list: \n' + '\n'.join( [self._enxtry_text(e, indent+4) for e in self._cert_entries]) +class CompressedCertificate(HSRecord): + + def __init__(self, hsid: int, name: str, data): + super().__init__(hsid=hsid, name=name, data=data) + d = data + d, algorithm = _get_field(d, 2) + self._algorithm = int.from_bytes(bytearray(algorithm), byteorder='big') + d, uncompressed_length = _get_field(d, 3) + self._uncompressed_length = int.from_bytes(bytearray(uncompressed_length), byteorder='big') + d, self._compressed_certificate_message = _get_len_field(d, 3) + assert len(d) == 0 + + def to_json(self): + jdata = super().to_json() + jdata['algorithm'] = self._algorithm + jdata['uncompressed_length'] = self._uncompressed_length + jdata['compressed_certificate_message'] = binascii.hexlify(self._compressed_certificate_message).decode() + return jdata + + def to_text(self, indent: int = 0): + ind = ' ' * (indent + 2) + return super().to_text(indent=indent) + '\n'\ + f'{ind} algorithm: {self._algorithm}\n'\ + f'{ind} uncompressed_length: {self._uncompressed_length}\n'\ + f'{ind} compressed_certificate_message: {binascii.hexlify(self._compressed_certificate_message).decode()}' class SessionTicket(HSRecord): @@ -901,7 +926,7 @@ class HandShake: (20, 'Finished', HSRecord), (22, 'CertificateStatus', HSRecord), (24, 'KeyUpdate', HSRecord), - (25, 'CompressedCertificate', HSRecord), + (25, 'CompressedCertificate', CompressedCertificate), ] RT_NAME_BY_ID = {} RT_CLS_BY_ID = {} diff --git a/deps/ngtcp2/ngtcp2/examples/tests/test_04_clientcert.py b/deps/ngtcp2/ngtcp2/examples/tests/test_04_clientcert.py index bde1b187fda..25b4029f13d 100644 --- a/deps/ngtcp2/ngtcp2/examples/tests/test_04_clientcert.py +++ b/deps/ngtcp2/ngtcp2/examples/tests/test_04_clientcert.py @@ -49,9 +49,13 @@ def test_04_02(self, env: Env, server, client): creqs = [r for r in cr.handshake if r.hsid == 13] # CertificateRequest assert len(creqs) == 1 creq = creqs[0].to_json() - certs = [r for r in cr.server.handshake if r.hsid == 11] # Certificate + certs = [r for r in cr.server.handshake if r.hsid == 11 or r.hsid == 25] # Certificate or CompressedCertificate assert len(certs) == 1 crec = certs[0].to_json() - assert len(crec['certificate_list']) == 1 - assert creq['context'] == crec['context'] + if 'certificate_list' in crec: + cert_list = crec['certificate_list'] + assert len(cert_list) == 1 + assert creq['context'] == crec['context'] + else: + assert 'compressed_certificate_message' in crec # TODO: check that GET indeed gave a response diff --git a/deps/ngtcp2/ngtcp2/examples/tls_client_context_picotls.cc b/deps/ngtcp2/ngtcp2/examples/tls_client_context_picotls.cc index d5ee705be0a..6cc632f0196 100644 --- a/deps/ngtcp2/ngtcp2/examples/tls_client_context_picotls.cc +++ b/deps/ngtcp2/ngtcp2/examples/tls_client_context_picotls.cc @@ -36,7 +36,8 @@ extern Config config; namespace { -int save_ticket_cb(ptls_save_ticket_t *self, ptls_t *ptls, ptls_iovec_t input) { +int save_ticket_cb(ptls_save_ticket_t *self, ptls_t *ptls, ptls_iovec_t input, + const ptls_save_ticket_properties_t *ticket_prop) { auto conn_ref = static_cast(*ptls_get_data_ptr(ptls)); auto c = static_cast(conn_ref->user_data); diff --git a/deps/ngtcp2/ngtcp2/examples/util_test.cc b/deps/ngtcp2/ngtcp2/examples/util_test.cc index 14a7bd05d92..ab2ce1266d1 100644 --- a/deps/ngtcp2/ngtcp2/examples/util_test.cc +++ b/deps/ngtcp2/ngtcp2/examples/util_test.cc @@ -92,323 +92,112 @@ std::expected generate_secure_random(std::span data) { } // namespace util void test_util_format_durationf() { - assert_stdstring_equal("0ns", util::format_durationf(0)); - assert_stdstring_equal("999ns", util::format_durationf(999)); - assert_stdstring_equal("1.00us", util::format_durationf(1000)); - assert_stdstring_equal("1.00us", util::format_durationf(1004)); - assert_stdstring_equal("1.00us", util::format_durationf(1005)); - assert_stdstring_equal("1.02us", util::format_durationf(1015)); - assert_stdstring_equal("2.00us", util::format_durationf(1999)); - assert_stdstring_equal("1.00ms", util::format_durationf(999999)); - assert_stdstring_equal("3.50ms", util::format_durationf(3500111)); - assert_stdstring_equal("9999.99s", util::format_durationf(9999990000000ULL)); + assert_eq("0ns", util::format_durationf(0)); + assert_eq("999ns", util::format_durationf(999)); + assert_eq("1.00us", util::format_durationf(1000)); + assert_eq("1.00us", util::format_durationf(1004)); + assert_eq("1.00us", util::format_durationf(1005)); + assert_eq("1.02us", util::format_durationf(1015)); + assert_eq("2.00us", util::format_durationf(1999)); + assert_eq("1.00ms", util::format_durationf(999999)); + assert_eq("3.50ms", util::format_durationf(3500111)); + assert_eq("9999.99s", util::format_durationf(9999990000000ULL)); } void test_util_format_uint() { - assert_stdstring_equal("0"s, util::format_uint(0U)); - assert_stdstring_equal("18446744073709551615"s, - util::format_uint(18446744073709551615ULL)); + assert_eq("0", util::format_uint(0U)); + assert_eq("18446744073709551615", util::format_uint(18446744073709551615ULL)); } void test_util_format_uint_iec() { - assert_stdstring_equal("0"s, util::format_uint_iec(0U)); - assert_stdstring_equal("1023"s, util::format_uint_iec((1U << 10) - 1)); - assert_stdstring_equal("1K"s, util::format_uint_iec(1U << 10)); - assert_stdstring_equal("1M"s, util::format_uint_iec(1U << 20)); - assert_stdstring_equal("1G"s, util::format_uint_iec(1U << 30)); - assert_stdstring_equal( - "18446744073709551615"s, - util::format_uint_iec(std::numeric_limits::max())); - assert_stdstring_equal("1025K"s, - util::format_uint_iec((1U << 20) + (1U << 10))); + assert_eq("0", util::format_uint_iec(0U)); + assert_eq("1023", util::format_uint_iec((1U << 10) - 1)); + assert_eq("1K", util::format_uint_iec(1U << 10)); + assert_eq("1M", util::format_uint_iec(1U << 20)); + assert_eq("1G", util::format_uint_iec(1U << 30)); + assert_eq("18446744073709551615"s, + util::format_uint_iec(std::numeric_limits::max())); + assert_eq("1025K", util::format_uint_iec((1U << 20) + (1U << 10))); } void test_util_format_duration() { - assert_stdstring_equal("0ns", util::format_duration(0)); - assert_stdstring_equal("999ns", util::format_duration(999)); - assert_stdstring_equal("1us", util::format_duration(1000)); - assert_stdstring_equal("1ms", util::format_duration(1000000)); - assert_stdstring_equal("1s", util::format_duration(1000000000)); - assert_stdstring_equal("1m", util::format_duration(60000000000ULL)); - assert_stdstring_equal("1h", util::format_duration(3600000000000ULL)); - assert_stdstring_equal( - "18446744073709551615ns", - util::format_duration(std::numeric_limits::max())); - assert_stdstring_equal("61s", util::format_duration(61000000000ULL)); + assert_eq("0ns", util::format_duration(0)); + assert_eq("999ns", util::format_duration(999)); + assert_eq("1us", util::format_duration(1000)); + assert_eq("1ms", util::format_duration(1000000)); + assert_eq("1s", util::format_duration(1000000000)); + assert_eq("1m", util::format_duration(60000000000ULL)); + assert_eq("1h", util::format_duration(3600000000000ULL)); + assert_eq("18446744073709551615ns", + util::format_duration(std::numeric_limits::max())); + assert_eq("61s", util::format_duration(61000000000ULL)); } void test_util_parse_uint() { - { - auto res = util::parse_uint("0"); - assert_true(res.has_value()); - assert_uint64(0, ==, *res); - } - { - auto res = util::parse_uint("1"); - assert_true(res.has_value()); - assert_uint64(1, ==, *res); - } - { - auto res = util::parse_uint("18446744073709551615"); - assert_true(res.has_value()); - assert_uint64(18446744073709551615ULL, ==, *res); - } - { - auto res = util::parse_uint("18446744073709551616"); - assert_false(res.has_value()); - } - { - auto res = util::parse_uint("a"); - assert_false(res.has_value()); - } - { - auto res = util::parse_uint("1a"); - assert_false(res.has_value()); - } - { - auto res = util::parse_uint(""); - assert_false(res.has_value()); - } + assert_ok_eq(0, util::parse_uint("0")); + assert_ok_eq(1, util::parse_uint("1")); + assert_ok_eq(18446744073709551615ULL, + util::parse_uint("18446744073709551615")); + assert_err(Error::INTEGER_OVERFLOW, util::parse_uint("18446744073709551616")); + assert_err(Error::INVALID_ARGUMENT, util::parse_uint("a")); + assert_err(Error::INVALID_ARGUMENT, util::parse_uint("1a")); + assert_err(Error::INVALID_ARGUMENT, util::parse_uint("")); } void test_util_parse_uint_iec() { - { - auto res = util::parse_uint_iec("0"); - assert_true(res.has_value()); - assert_uint64(0, ==, *res); - } - { - auto res = util::parse_uint_iec("1023"); - assert_true(res.has_value()); - assert_uint64(1023, ==, *res); - } - { - auto res = util::parse_uint_iec("1K"); - assert_true(res.has_value()); - assert_uint64(1 << 10, ==, *res); - } - { - auto res = util::parse_uint_iec("1M"); - assert_true(res.has_value()); - assert_uint64(1 << 20, ==, *res); - } - { - auto res = util::parse_uint_iec("1G"); - assert_true(res.has_value()); - assert_uint64(1 << 30, ==, *res); - } - { - auto res = util::parse_uint_iec("11G"); - assert_true(res.has_value()); - assert_uint64((1ULL << 30) * 11, ==, *res); - } - { - auto res = util::parse_uint_iec("18446744073709551616"); - assert_false(res.has_value()); - } - { - auto res = util::parse_uint_iec("1x"); - assert_false(res.has_value()); - } - { - auto res = util::parse_uint_iec("1Gx"); - assert_false(res.has_value()); - } - { - auto res = util::parse_uint_iec("G"); - assert_false(res.has_value()); - } - { - auto res = util::parse_uint_iec(""); - assert_false(res.has_value()); - } + assert_ok_eq(0, util::parse_uint_iec("0")); + assert_ok_eq(1023, util::parse_uint_iec("1023")); + assert_ok_eq(1 << 10, util::parse_uint_iec("1K")); + assert_ok_eq(1 << 20, util::parse_uint_iec("1M")); + assert_ok_eq(1 << 30, util::parse_uint_iec("1G")); + assert_ok_eq((1ULL << 30) * 11, util::parse_uint_iec("11G")); + assert_err(Error::INTEGER_OVERFLOW, + util::parse_uint_iec("18446744073709551616")); + assert_err(Error::INVALID_ARGUMENT, util::parse_uint_iec("1x")); + assert_err(Error::INVALID_ARGUMENT, util::parse_uint_iec("1Gx")); + assert_err(Error::INVALID_ARGUMENT, util::parse_uint_iec("G")); + assert_err(Error::INVALID_ARGUMENT, util::parse_uint_iec("")); } void test_util_parse_duration() { - { - auto res = util::parse_duration("0"); - assert_true(res.has_value()); - assert_uint64(0, ==, *res); - } - { - auto res = util::parse_duration("1"); - assert_true(res.has_value()); - assert_uint64(NGTCP2_SECONDS, ==, *res); - } - { - auto res = util::parse_duration("0ns"); - assert_true(res.has_value()); - assert_uint64(0, ==, *res); - } - { - auto res = util::parse_duration("1ns"); - assert_true(res.has_value()); - assert_uint64(1, ==, *res); - } - { - auto res = util::parse_duration("1us"); - assert_true(res.has_value()); - assert_uint64(NGTCP2_MICROSECONDS, ==, *res); - } - { - auto res = util::parse_duration("1ms"); - assert_true(res.has_value()); - assert_uint64(NGTCP2_MILLISECONDS, ==, *res); - } - { - auto res = util::parse_duration("1s"); - assert_true(res.has_value()); - assert_uint64(NGTCP2_SECONDS, ==, *res); - } - { - auto res = util::parse_duration("1m"); - assert_true(res.has_value()); - assert_uint64(60 * NGTCP2_SECONDS, ==, *res); - } - { - auto res = util::parse_duration("1h"); - assert_true(res.has_value()); - assert_uint64(3600 * NGTCP2_SECONDS, ==, *res); - } - { - auto res = util::parse_duration("2h"); - assert_true(res.has_value()); - assert_uint64(2 * 3600 * NGTCP2_SECONDS, ==, *res); - } - { - auto res = util::parse_duration("18446744073709551616"); - assert_false(res.has_value()); - } - { - auto res = util::parse_duration("1x"); - assert_false(res.has_value()); - } - { - auto res = util::parse_duration("1mx"); - assert_false(res.has_value()); - } - { - auto res = util::parse_duration("1mxy"); - assert_false(res.has_value()); - } - { - auto res = util::parse_duration("s"); - assert_false(res.has_value()); - } - { - auto res = util::parse_duration("ms"); - assert_false(res.has_value()); - } - { - auto res = util::parse_duration(""); - assert_false(res.has_value()); - } + assert_ok_eq(0, util::parse_duration("0")); + assert_ok_eq(NGTCP2_SECONDS, util::parse_duration("1")); + assert_ok_eq(0, util::parse_duration("0ns")); + assert_ok_eq(1, util::parse_duration("1ns")); + assert_ok_eq(NGTCP2_MICROSECONDS, util::parse_duration("1us")); + assert_ok_eq(NGTCP2_MILLISECONDS, util::parse_duration("1ms")); + assert_ok_eq(NGTCP2_SECONDS, util::parse_duration("1s")); + assert_ok_eq(60 * NGTCP2_SECONDS, util::parse_duration("1m")); + assert_ok_eq(3600 * NGTCP2_SECONDS, util::parse_duration("1h")); + assert_ok_eq(2 * 3600 * NGTCP2_SECONDS, util::parse_duration("2h")); + assert_err(Error::INTEGER_OVERFLOW, + util::parse_duration("18446744073709551616")); + assert_err(Error::INVALID_ARGUMENT, util::parse_duration("1x")); + assert_err(Error::INVALID_ARGUMENT, util::parse_duration("1mx")); + assert_err(Error::INVALID_ARGUMENT, util::parse_duration("1mxy")); + assert_err(Error::INVALID_ARGUMENT, util::parse_duration("s")); + assert_err(Error::INVALID_ARGUMENT, util::parse_duration("ms")); + assert_err(Error::INVALID_ARGUMENT, util::parse_duration("")); } void test_util_normalize_path() { - { - auto rv = util::normalize_path("/"); - - assert_true(rv.has_value()); - assert_stdstring_equal("/", rv.value()); - } - - { - auto rv = util::normalize_path("//"); - - assert_true(rv.has_value()); - assert_stdstring_equal("/", rv.value()); - } - - { - auto rv = util::normalize_path("/foo"); - - assert_true(rv.has_value()); - assert_stdstring_equal("/foo", rv.value()); - } - - { - auto rv = util::normalize_path("/foo/bar/"); - - assert_true(rv.has_value()); - assert_stdstring_equal("/foo/bar/", rv.value()); - } - - { - auto rv = util::normalize_path("/foo/abc/../bar/"); - - assert_true(rv.has_value()); - assert_stdstring_equal("/foo/bar/", rv.value()); - } - - { - auto rv = util::normalize_path("/../foo/abc/../bar/"); - - assert_true(rv.has_value()); - assert_stdstring_equal("/foo/bar/", rv.value()); - } - - { - auto rv = util::normalize_path("/./foo/././abc///.././bar/./"); - - assert_true(rv.has_value()); - assert_stdstring_equal("/foo/bar/", rv.value()); - } - - { - auto rv = util::normalize_path("/foo/."); - - assert_true(rv.has_value()); - assert_stdstring_equal("/foo/", rv.value()); - } - - { - auto rv = util::normalize_path("/foo/./bar"); - - assert_true(rv.has_value()); - assert_stdstring_equal("/foo/bar", rv.value()); - } - - { - auto rv = util::normalize_path("/foo/./../bar"); - - assert_true(rv.has_value()); - assert_stdstring_equal("/bar", rv.value()); - } - - { - auto rv = util::normalize_path("/../../bar"); - - assert_true(rv.has_value()); - assert_stdstring_equal("/bar", rv.value()); - } - - { - auto rv = util::normalize_path(std::string(1024, '/')); - - assert_true(rv.has_value()); - assert_stdstring_equal("/", rv.value()); - } - - { - auto rv = util::normalize_path(std::string(1025, '/')); - - assert_false(rv); - } - - { - auto rv = util::normalize_path("/.."); - - assert_true(rv.has_value()); - assert_stdstring_equal("/", rv.value()); - } - - { - auto rv = util::normalize_path("/../../index.html"); - - assert_true(rv.has_value()); - assert_stdstring_equal("/index.html", rv.value()); - } + assert_ok_eq("/", util::normalize_path("/")); + assert_ok_eq("/", util::normalize_path("//")); + assert_ok_eq("/foo", util::normalize_path("/foo")); + assert_ok_eq("/foo/bar/", util::normalize_path("/foo/bar/")); + assert_ok_eq("/foo/bar/", util::normalize_path("/foo/abc/../bar/")); + assert_ok_eq("/foo/bar/", util::normalize_path("/../foo/abc/../bar/")); + assert_ok_eq("/foo/bar/", + util::normalize_path("/./foo/././abc///.././bar/./")); + assert_ok_eq("/foo/", util::normalize_path("/foo/.")); + assert_ok_eq("/foo/bar", util::normalize_path("/foo/./bar")); + assert_ok_eq("/bar", util::normalize_path("/foo/./../bar")); + assert_ok_eq("/bar", util::normalize_path("/../../bar")); + assert_ok_eq("/", util::normalize_path(std::string(1024, '/'))); + assert_err(Error::INVALID_ARGUMENT, + util::normalize_path(std::string(1025, '/'))); + assert_ok_eq("/", util::normalize_path("/..")); + assert_ok_eq("/index.html", util::normalize_path("/../../index.html")); } void test_util_hexdump() { @@ -522,15 +311,14 @@ void test_util_hexdump() { munit_log(MUNIT_LOG_INFO, t.title); auto f = tmpfile(); - auto rv = util::hexdump(f, std::span{t.data}); - assert_true(rv.has_value()); + assert_ok(util::hexdump(f, std::span{t.data})); fseek(f, 0, SEEK_SET); auto nread = fread(buf, 1, sizeof(buf), f); buf[nread] = '\0'; - assert_stdsv_equal(t.dump, buf); + assert_eq(t.dump, buf); fclose(f); } @@ -539,58 +327,39 @@ void test_util_hexdump() { void test_util_format_hex() { auto a = std::to_array({0xDE, 0xAD, 0xBE, 0xEF}); - assert_stdstring_equal("deadbeef"s, util::format_hex(a)); - assert_stdstring_equal("deadbeef"s, util::format_hex(0xDEADBEEF)); - assert_stdstring_equal("beef"s, util::format_hex(a.data() + 2, 2)); + assert_eq("deadbeef", util::format_hex(a)); + assert_eq("deadbeef", util::format_hex(0xDEADBEEF)); + assert_eq("beef", util::format_hex(a.data() + 2, 2)); std::array buf; - - assert_stdsv_equal( - "00"sv, (std::string_view{std::ranges::begin(buf), - util::format_hex(static_cast(0U), - std::ranges::begin(buf))})); - assert_stdsv_equal( - "ec"sv, (std::string_view{std::ranges::begin(buf), - util::format_hex(static_cast(0xECU), - std::ranges::begin(buf))})); - assert_stdsv_equal( - "00000000"sv, - (std::string_view{std::ranges::begin(buf), - util::format_hex(0U, std::ranges::begin(buf))})); - assert_stdsv_equal( - "0000ab01"sv, - (std::string_view{std::ranges::begin(buf), - util::format_hex(0xAB01U, std::ranges::begin(buf))})); - assert_stdsv_equal( - "deadbeefbaadf00d"sv, - (std::string_view{ - std::ranges::begin(buf), - util::format_hex(0xDEADBEEFBAADF00DU, std::ranges::begin(buf))})); - assert_stdsv_equal( - "ffffffffffffffff"sv, - (std::string_view{std::ranges::begin(buf), - util::format_hex(std::numeric_limits::max(), - std::ranges::begin(buf))})); + auto b = std::ranges::begin(buf); + + assert_eq("00", + std::string_view(b, util::format_hex(static_cast(0U), b))); + assert_eq("ec", std::string_view( + b, util::format_hex(static_cast(0xECU), b))); + assert_eq("00000000", std::string_view(b, util::format_hex(0U, b))); + assert_eq("0000ab01", std::string_view(b, util::format_hex(0xAB01U, b))); + assert_eq("deadbeefbaadf00d", + std::string_view(b, util::format_hex(0xDEADBEEFBAADF00DU, b))); + assert_eq("ffffffffffffffff", + std::string_view( + b, util::format_hex(std::numeric_limits::max(), b))); std::vector char_vec; util::format_hex(a, std::back_inserter(char_vec)); - assert_stdsv_equal("deadbeef"sv, - (std::string_view{std::ranges::begin(char_vec), - std::ranges::end(char_vec)})); + assert_eq("deadbeef", as_string_view(char_vec)); std::vector uint8_vec; util::format_hex(a, std::back_inserter(uint8_vec)); - assert_stdsv_equal( - "deadbeef"sv, - (std::string_view{reinterpret_cast(uint8_vec.data()), - uint8_vec.size()})); + assert_eq("deadbeef", as_string_view(uint8_vec)); } void test_util_decode_hex() { - assert_stdstring_equal("\xDE\xAD\xBE\xEF"s, util::decode_hex("deadbeef"sv)); - assert_stdstring_equal(""s, util::decode_hex(""sv)); + assert_eq("\xDE\xAD\xBE\xEF", util::decode_hex("deadbeef"sv)); + assert_eq("", util::decode_hex(""sv)); } void test_util_is_hex_string() { @@ -607,25 +376,41 @@ void test_util_is_hex_string() { } void test_util_split_str() { - assert_true((std::vector{"alpha"sv, "bravo"sv, "charlie"sv} == - (util::split_str("alpha,bravo,charlie"sv) | - std::ranges::to()))); - assert_true((std::vector{"alpha"sv, "bravo"sv, "charlie"sv} == - (util::split_str("alpha bravo charlie"sv, ' ') | - std::ranges::to()))); - assert_true((std::vector{} == - (util::split_str(""sv, ' ') | std::ranges::to()))); - assert_true((std::vector{""sv, ""sv} == - (util::split_str(","sv) | std::ranges::to()))); - assert_true( - (std::vector{""sv, "alpha"sv, ""sv, ""sv, "bravo"sv, "charlie"sv, ""sv, - ""sv} == (util::split_str(" alpha bravo charlie "sv, ' ') | - std::ranges::to()))); + assert_eq((std::vector{ + "alpha"sv, + "bravo"sv, + "charlie"sv, + }), + util::split_str("alpha,bravo,charlie"sv) | + std::ranges::to()); + assert_eq((std::vector{ + "alpha"sv, + "bravo"sv, + "charlie"sv, + }), + util::split_str("alpha bravo charlie"sv, ' ') | + std::ranges::to()); + assert_eq((std::vector{}), + util::split_str(""sv, ' ') | std::ranges::to()); + assert_eq((std::vector{""sv, ""sv}), + util::split_str(","sv) | std::ranges::to()); + assert_eq((std::vector{ + ""sv, + "alpha"sv, + ""sv, + ""sv, + "bravo"sv, + "charlie"sv, + ""sv, + ""sv, + }), + util::split_str(" alpha bravo charlie "sv, ' ') | + std::ranges::to()); } void test_util_format_app_error_code() { - assert_stdstring_equal("(no error)", util::format_app_error_code({})); - assert_stdstring_equal("0xfe01", util::format_app_error_code(0xfe01)); + assert_eq("(no error)", util::format_app_error_code({})); + assert_eq("0xfe01", util::format_app_error_code(0xfe01)); } } // namespace ngtcp2 diff --git a/deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/ngtcp2.h b/deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/ngtcp2.h index 9bc9a7b512e..51e62c29eec 100644 --- a/deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/ngtcp2.h +++ b/deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/ngtcp2.h @@ -1861,7 +1861,8 @@ typedef enum ngtcp2_token_type { #define NGTCP2_SETTINGS_V2 2 #define NGTCP2_SETTINGS_V3 3 #define NGTCP2_SETTINGS_V4 4 -#define NGTCP2_SETTINGS_VERSION NGTCP2_SETTINGS_V4 +#define NGTCP2_SETTINGS_V5 5 +#define NGTCP2_SETTINGS_VERSION NGTCP2_SETTINGS_V5 /** * @struct @@ -1913,7 +1914,7 @@ typedef struct ngtcp2_settings { * :member:`token_type` field. * * Client sets this field if it intends to send token in its Initial - * packet. + * packet. A token longer than 512 bytes is ignored. * * `ngtcp2_conn_server_new` and `ngtcp2_conn_client_new` make a copy * of token. @@ -2087,11 +2088,12 @@ typedef struct ngtcp2_settings { /* The following fields have been added since NGTCP2_SETTINGS_V3. */ /** * :member:`glitch_ratelim_burst` is the maximum number of tokens - * available to "glitch" rate limiter. "glitch" is a suspicious - * activity from a remote endpoint. If detected, certain amount of - * tokens are consumed. If no tokens are available to consume, the - * connection is closed. The rate of token generation is specified - * by :member:`glitch_ratelim_rate`. + * available to "glitch" rate limiter. It is clamped to UINT64_MAX + * / NGTCP2_SECONDS. "glitch" is a suspicious activity from a + * remote endpoint. If detected, certain amount of tokens are + * consumed. If no tokens are available to consume, the connection + * is closed. The rate of token generation is specified by + * :member:`glitch_ratelim_rate`. * * .. version-added:: 1.15.0 */ @@ -2116,6 +2118,29 @@ typedef struct ngtcp2_settings { * .. version-added:: 1.23.0 */ ngtcp2_log_write log_write; + /* The following fields have been added since NGTCP2_SETTINGS_V5. */ + /** + * :member:`write_stream_data_thresh` is the threshold for the + * length of STREAM frame payload that the local endpoint sends. If + * there is data more than this value to send, and the flow control + * does not allow sending more than this length, the data is not + * sent, waiting for the window update from the remote endpoint. + * This effectively means that flow control credit less than or + * equal to :member:`write_stream_data_thresh` is considered 0. It + * implies that the connection to the remote endpoint that only + * grants less than or equal to :member:`write_stream_data_thresh` + * stalls. But normally the endpoint offers far more flow control + * credits. Those that only gives small credit are most likely + * badly configured or manipulated by an attacker, and no need to be + * supported. If nonzero value is set to this field, the + * application should use + * `ngtcp2_conn_get_max_data_left_write_thresh` instead of + * `ngtcp2_conn_get_max_data_left`, so that the streams are not + * blocked by the connection-level flow control. + * + * .. version-added:: 1.26.0 + */ + size_t write_stream_data_thresh; } ngtcp2_settings; /** @@ -3324,6 +3349,10 @@ typedef enum ngtcp2_connection_id_status_type { * :type:`ngtcp2_connection_id_status` is a callback function which is * called when the status of Destination Connection ID changes. * + * This callback function is not called before handshake completes. + * When handshake completes, it is called for Destination Connection + * ID in use at that time. + * * |token| is the associated stateless reset token, and it is ``NULL`` * if no token is present. * @@ -3500,6 +3529,8 @@ typedef int (*ngtcp2_stream_stop_sending)(ngtcp2_conn *conn, int64_t stream_id, * The callback function must return 0 if it succeeds. Returning * :macro:`NGTCP2_ERR_CALLBACK_FAILURE` makes the library call return * immediately. + * + * .. version-added:: 1.24.0 */ typedef int (*ngtcp2_recv_stop_sending)(ngtcp2_conn *conn, int64_t stream_id, uint64_t app_error_code, @@ -3596,6 +3627,10 @@ typedef int (*ngtcp2_get_new_connection_id2)( * :type:`ngtcp2_connection_id_status2` is a callback function which * is called when the status of Destination Connection ID changes. * + * This callback function is not called before handshake completes. + * When handshake completes, it is called for Destination Connection + * ID in use at that time. + * * |token| is the associated stateless reset token, and it is ``NULL`` * if no token is present. * @@ -3719,12 +3754,29 @@ typedef int (*ngtcp2_stream_close2)(ngtcp2_conn *conn, uint32_t flags, uint64_t tx_app_error_code, void *user_data, void *stream_user_data); +/** + * @functypedef + * + * :type:`ngtcp2_extend_max_data` is a callback function which is + * invoked when max session data is extended. |max_data| is a + * cumulative number of bytes an endpoint can send on this session. + * + * The callback function must return 0 if it succeeds. Returning + * :macro:`NGTCP2_ERR_CALLBACK_FAILURE` makes the library call return + * immediately. + * + * .. version-added:: 1.26.0 + */ +typedef int (*ngtcp2_extend_max_data)(ngtcp2_conn *conn, uint64_t max_data, + void *user_data); + #define NGTCP2_CALLBACKS_V1 1 #define NGTCP2_CALLBACKS_V2 2 #define NGTCP2_CALLBACKS_V3 3 #define NGTCP2_CALLBACKS_V4 4 #define NGTCP2_CALLBACKS_V5 5 -#define NGTCP2_CALLBACKS_VERSION NGTCP2_CALLBACKS_V5 +#define NGTCP2_CALLBACKS_V6 6 +#define NGTCP2_CALLBACKS_VERSION NGTCP2_CALLBACKS_V6 /** * @struct @@ -4086,6 +4138,16 @@ typedef struct ngtcp2_callbacks { * .. version-added:: 1.25.0 */ ngtcp2_stream_close2 stream_close2; + /* The following fields have been added since + NGTCP2_CALLBACKS_V6. */ + /** + * :member:`extend_max_data` is callback function which is invoked + * when the maximum offset of session data that a local endpoint can + * send is increased. This callback function is optional. + * + * .. version-added:: 1.26.0 + */ + ngtcp2_extend_max_data extend_max_data; } ngtcp2_callbacks; /** @@ -4532,6 +4594,8 @@ NGTCP2_EXTERN int ngtcp2_conn_install_0rtt_key( * * :macro:`NGTCP2_ERR_NOMEM` * Out of memory. + * :macro:`NGTCP2_ERR_INVALID_STATE` + * `ngtcp2_conn_install_rx_key` has already been called. */ NGTCP2_EXTERN int ngtcp2_conn_install_rx_key( ngtcp2_conn *conn, const uint8_t *secret, size_t secretlen, @@ -4563,6 +4627,8 @@ NGTCP2_EXTERN int ngtcp2_conn_install_rx_key( * * :macro:`NGTCP2_ERR_NOMEM` * Out of memory. + * :macro:`NGTCP2_ERR_INVALID_STATE` + * `ngtcp2_conn_install_tx_key` has already been called. */ NGTCP2_EXTERN int ngtcp2_conn_install_tx_key( ngtcp2_conn *conn, const uint8_t *secret, size_t secretlen, @@ -4578,8 +4644,12 @@ NGTCP2_EXTERN int ngtcp2_conn_install_tx_key( * negative error codes: * * :macro:`NGTCP2_ERR_INVALID_STATE` - * The previous key update has not been confirmed yet; or key - * update is too frequent; or new keys are not available yet. + * The handshake has not been confirmed yet; or the connection is + * in the closing or draining period; or the previous key update + * has not been confirmed yet; or key update is too frequent; or + * new keys are not available yet; or no packet encrypted with the + * current key has been acknowledged since the previous key + * update. */ NGTCP2_EXTERN int ngtcp2_conn_initiate_key_update(ngtcp2_conn *conn, ngtcp2_tstamp ts); @@ -5894,8 +5964,8 @@ ngtcp2_conn_get_negotiated_version2(const ngtcp2_conn *conn); * * `ngtcp2_conn_tls_early_data_rejected` tells |conn| that early data * was rejected by a server during TLS handshake, or client decided - * not to attempt early data for some reason. |conn| discards the - * following connection states: + * not to attempt early data for some reason. Only client can call + * this function. |conn| discards the following connection states: * * - Any opened streams. * - Stream identifier allocations. @@ -6175,9 +6245,27 @@ NGTCP2_EXTERN uint64_t ngtcp2_conn_get_max_data_left(ngtcp2_conn *conn); * connection-level flow control. * * .. version-added:: 1.23.0 + * + * .. seealso:: + * `ngtcp2_conn_get_max_data_left_write_thresh` */ NGTCP2_EXTERN uint64_t ngtcp2_conn_get_max_data_left2(const ngtcp2_conn *conn); +/** + * @function + * + * `ngtcp2_conn_get_max_data_left_write_thresh` returns the number of + * bytes that this local endpoint can send in this connection without + * violating connection-level flow control. If the remaining credit + * is less than or equal to + * :member:`ngtcp2_settings.write_stream_data_thresh`, this function + * returns 0. + * + * .. version-added:: 1.26.0 + */ +NGTCP2_EXTERN uint64_t +ngtcp2_conn_get_max_data_left_write_thresh(const ngtcp2_conn *conn); + /** * @function * @@ -6879,7 +6967,8 @@ NGTCP2_EXTERN size_t ngtcp2_conn_get_send_quantum(ngtcp2_conn *conn); * @function * * `ngtcp2_conn_get_send_quantum2` returns the maximum number of bytes - * that can be sent in one go without packet spacing. + * that can be sent in one go without packet spacing. It is at least + * `ngtcp2_conn_get_path_max_tx_udp_payload_size2` bytes. * * .. version-added:: 1.23.0 */ @@ -7109,8 +7198,8 @@ NGTCP2_EXTERN void ngtcp2_path_storage_zero(ngtcp2_path_storage *ps); * @function * * `ngtcp2_settings_default` initializes |settings| with the default - * values. First this function fills |settings| with 0, and set the - * default value to the following fields: + * values. First this function fills |settings| with 0, and sets the + * default values to the following fields: * * * :member:`cc_algo ` = * :enum:`ngtcp2_cc_algo.NGTCP2_CC_ALGO_CUBIC` @@ -7133,8 +7222,8 @@ NGTCP2_EXTERN void ngtcp2_settings_default_versioned(int settings_version, * @function * * `ngtcp2_transport_params_default` initializes |params| with the - * default values. First this function fills |params| with 0, and set - * the default value to the following fields: + * default values. First this function fills |params| with 0, and + * sets the default values to the following fields: * * * :member:`max_udp_payload_size * ` = diff --git a/deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/version.h b/deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/version.h index 64e8d705fa1..7e3da1994cf 100644 --- a/deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/version.h +++ b/deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/version.h @@ -36,7 +36,7 @@ * * Version number of the ngtcp2 library release. */ -#define NGTCP2_VERSION "1.25.0" +#define NGTCP2_VERSION "1.26.0" /** * @macro @@ -46,6 +46,6 @@ * number, 8 bits for minor and 8 bits for patch. Version 1.2.3 * becomes 0x010203. */ -#define NGTCP2_VERSION_NUM 0x011900 +#define NGTCP2_VERSION_NUM 0x011a00 #endif /* !defined(NGTCP2_VERSION_H) */ diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_balloc.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_balloc.c index ea72eb83143..2cc1734fd43 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_balloc.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_balloc.c @@ -65,8 +65,10 @@ int ngtcp2_balloc_get(ngtcp2_balloc *balloc, void **pbuf, size_t n) { assert(n <= balloc->blklen); if (ngtcp2_buf_left(&balloc->buf) < n) { + // 0xF: the 16-byte alignment below needs up to 15 bytes when malloc + // returns only 4-byte aligned memory (for example on ESP-IDF heap)! p = ngtcp2_mem_malloc(balloc->mem, - sizeof(ngtcp2_memblock_hd) + 0x8U + balloc->blklen); + sizeof(ngtcp2_memblock_hd) + 0xFU + balloc->blklen); if (p == NULL) { return NGTCP2_ERR_NOMEM; } diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_callbacks.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_callbacks.c index 08c9876346f..ac63361236d 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_callbacks.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_callbacks.c @@ -63,6 +63,9 @@ size_t ngtcp2_callbackslen_version(int callbacks_version) { switch (callbacks_version) { case NGTCP2_CALLBACKS_VERSION: return sizeof(callbacks); + case NGTCP2_CALLBACKS_V5: + return offsetof(ngtcp2_callbacks, stream_close2) + + sizeof(callbacks.stream_close2); case NGTCP2_CALLBACKS_V4: return offsetof(ngtcp2_callbacks, recv_stop_sending) + sizeof(callbacks.recv_stop_sending); diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_cc.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_cc.c index 2d3c65dbf38..ca06edd2cb0 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_cc.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_cc.c @@ -40,6 +40,9 @@ uint64_t ngtcp2_cc_compute_initcwnd(size_t max_udp_payload_size) { return ngtcp2_min(10 * max_udp_payload_size, n); } +/* NGTCP2_CC_SLOW_START_PACING_GAIN_H is the pacing rate for slow + start phase. */ +#define NGTCP2_CC_SLOW_START_PACING_GAIN_H 200 /* 1.25 is the under-utilization avoidance factor described in https://datatracker.ietf.org/doc/html/rfc9002#section-7.7 */ #define NGTCP2_CC_PACING_GAIN_H 125 @@ -47,22 +50,30 @@ uint64_t ngtcp2_cc_compute_initcwnd(size_t max_udp_payload_size) { static void init_pacing_rate(ngtcp2_conn_stat *cstat) { assert(cstat->cwnd); - cstat->pacing_interval_m = ngtcp2_max((NGTCP2_MILLISECONDS << 10) * 100 / - NGTCP2_CC_PACING_GAIN_H / cstat->cwnd, - 1); + cstat->pacing_interval_m = + ngtcp2_max((NGTCP2_MILLISECONDS << 10) * 100 / + NGTCP2_CC_SLOW_START_PACING_GAIN_H / cstat->cwnd, + 1); cstat->send_quantum = 10 * cstat->max_tx_udp_payload_size; } static void set_pacing_rate(ngtcp2_conn_stat *cstat) { size_t send_quantum = 64 * 1024; + uint64_t pacing_gain_h; assert(cstat->cwnd); + if (cstat->cwnd < cstat->ssthresh) { + pacing_gain_h = NGTCP2_CC_SLOW_START_PACING_GAIN_H; + } else { + pacing_gain_h = NGTCP2_CC_PACING_GAIN_H; + } + cstat->pacing_interval_m = ((cstat->first_rtt_sample_ts == UINT64_MAX ? NGTCP2_MILLISECONDS : cstat->smoothed_rtt) << 10) * - 100 / NGTCP2_CC_PACING_GAIN_H / cstat->cwnd; + 100 / pacing_gain_h / cstat->cwnd; cstat->pacing_interval_m = ngtcp2_max(cstat->pacing_interval_m, 1); @@ -232,6 +243,7 @@ void ngtcp2_cc_cubic_init(ngtcp2_cc_cubic *cubic, ngtcp2_log *log, .congestion_event = ngtcp2_cc_cubic_cc_congestion_event, .on_spurious_congestion = ngtcp2_cc_cubic_cc_on_spurious_congestion, .on_persistent_congestion = ngtcp2_cc_cubic_cc_on_persistent_congestion, + .on_pkt_lost_confirmed = ngtcp2_cc_cubic_cc_on_pkt_lost_confirmed, .reset = ngtcp2_cc_cubic_cc_reset, }, .rst = rst, @@ -375,6 +387,8 @@ void ngtcp2_cc_cubic_cc_on_ack_recv(ngtcp2_cc *cc, ngtcp2_conn_stat *cstat, cstat->ssthresh = cstat->cwnd; cubic->current.cwnd_prior = cstat->cwnd; cubic->current.w_est = cstat->cwnd; + + set_pacing_rate(cstat); } return; @@ -444,7 +458,7 @@ void ngtcp2_cc_cubic_cc_on_ack_recv(ngtcp2_cc *cc, ngtcp2_conn_stat *cstat, if (cubic->current.w_est > w_cubic) { cstat->cwnd = cubic->current.w_est; } else { - bytes_acked = (target - cstat->cwnd) * cstat->max_tx_udp_payload_size; + bytes_acked = (target - cstat->cwnd) * ack->bytes_delivered; m = (bytes_acked + cubic->current.pending_bytes_acked) / cstat->cwnd; cubic->current.pending_bytes_acked += bytes_acked; @@ -567,6 +581,21 @@ void ngtcp2_cc_cubic_cc_on_persistent_congestion(ngtcp2_cc *cc, set_pacing_rate(cstat); } +void ngtcp2_cc_cubic_cc_on_pkt_lost_confirmed(ngtcp2_cc *cc, + ngtcp2_conn_stat *cstat, + ngtcp2_tstamp ts) { + ngtcp2_cc_cubic *cubic = ngtcp2_struct_of(cc, ngtcp2_cc_cubic, cc); + (void)cstat; + (void)ts; + + /* The loss is real. Discard the snapshot so that a spurious + congestion detected later does not restore the state from before + this loss. */ + cubic_vars_reset(&cubic->undo.v); + cubic->undo.cwnd = 0; + cubic->undo.ssthresh = 0; +} + void ngtcp2_cc_cubic_cc_reset(ngtcp2_cc *cc, ngtcp2_conn_stat *cstat, ngtcp2_tstamp ts) { ngtcp2_cc_cubic *cubic = ngtcp2_struct_of(cc, ngtcp2_cc_cubic, cc); diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_cc.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_cc.h index a19e90b1d0d..56c1e373fb9 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_cc.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_cc.h @@ -170,6 +170,19 @@ typedef void (*ngtcp2_cc_on_persistent_congestion)(ngtcp2_cc *cc, ngtcp2_conn_stat *cstat, ngtcp2_tstamp ts); +/** + * @functypedef + * + * :type:`ngtcp2_cc_on_pkt_lost_confirmed` is a callback function + * which is called when a packet which was declared lost is removed + * from the retransmission buffer without being acknowledged. The + * congestion event that the packet belongs to is no longer considered + * to be spurious. + */ +typedef void (*ngtcp2_cc_on_pkt_lost_confirmed)(ngtcp2_cc *cc, + ngtcp2_conn_stat *cstat, + ngtcp2_tstamp ts); + /** * @functypedef * @@ -235,6 +248,12 @@ typedef struct ngtcp2_cc { * is called when persistent congestion is established. */ ngtcp2_cc_on_persistent_congestion on_persistent_congestion; + /** + * :member:`on_pkt_lost_confirmed` is a callback function which is + * called when a lost packet is removed from the retransmission + * buffer without being acknowledged. + */ + ngtcp2_cc_on_pkt_lost_confirmed on_pkt_lost_confirmed; /** * :member:`on_ack_recv` is a callback function which is called when * an acknowledgement is received. @@ -349,6 +368,10 @@ void ngtcp2_cc_cubic_cc_on_persistent_congestion(ngtcp2_cc *cc, ngtcp2_conn_stat *cstat, ngtcp2_tstamp ts); +void ngtcp2_cc_cubic_cc_on_pkt_lost_confirmed(ngtcp2_cc *cc, + ngtcp2_conn_stat *cstat, + ngtcp2_tstamp ts); + void ngtcp2_cc_cubic_cc_reset(ngtcp2_cc *cc, ngtcp2_conn_stat *cstat, ngtcp2_tstamp ts); diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_cid.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_cid.c index 4eba2aaca5d..5b9a79215fe 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_cid.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_cid.c @@ -92,6 +92,7 @@ void ngtcp2_dcid_init(ngtcp2_dcid *dcid, uint64_t seq, const ngtcp2_cid *cid, dcid->bytes_sent = 0; dcid->bytes_recv = 0; dcid->max_udp_payload_size = NGTCP2_MAX_UDP_PAYLOAD_SIZE; + dcid->scid_seq = 0; } void ngtcp2_dcid_set_token(ngtcp2_dcid *dcid, @@ -117,6 +118,7 @@ void ngtcp2_dcid_copy(ngtcp2_dcid *dest, const ngtcp2_dcid *src) { dest->bytes_sent = src->bytes_sent; dest->bytes_recv = src->bytes_recv; dest->max_udp_payload_size = src->max_udp_payload_size; + dest->scid_seq = src->scid_seq; } void ngtcp2_dcid_copy_cid_token(ngtcp2_dcid *dest, const ngtcp2_dcid *src) { @@ -131,20 +133,6 @@ void ngtcp2_dcid_copy_cid_token(ngtcp2_dcid *dest, const ngtcp2_dcid *src) { } } -int ngtcp2_dcid_verify_uniqueness(const ngtcp2_dcid *dcid, uint64_t seq, - const ngtcp2_cid *cid, - const ngtcp2_stateless_reset_token *token) { - if (dcid->seq == seq) { - return ngtcp2_cid_eq(&dcid->cid, cid) && - (dcid->flags & NGTCP2_DCID_FLAG_TOKEN_PRESENT) && - ngtcp2_stateless_reset_token_eq(&dcid->token, token) - ? 0 - : NGTCP2_ERR_PROTO; - } - - return !ngtcp2_cid_eq(&dcid->cid, cid) ? 0 : NGTCP2_ERR_PROTO; -} - int ngtcp2_dcid_verify_stateless_reset_token( const ngtcp2_dcid *dcid, const ngtcp2_path *path, const ngtcp2_stateless_reset_token *token) { diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_cid.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_cid.h index f4956b0bac0..1cad017b179 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_cid.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_cid.h @@ -88,6 +88,10 @@ typedef struct ngtcp2_dcid { /* max_udp_payload_size is the maximum size of UDP datagram payload that is allowed to be sent to this path. */ size_t max_udp_payload_size; + /* scid_seq is the sequence number of the Source Connection ID that + a remote endpoint put in the Destination Connection ID field of + the latest packet received on an associated path. */ + uint64_t scid_seq; /* flags is bitwise OR of zero or more of NGTCP2_DCID_FLAG_*. */ uint8_t flags; /* token is a stateless reset token received along with this @@ -156,14 +160,6 @@ void ngtcp2_dcid_copy(ngtcp2_dcid *dest, const ngtcp2_dcid *src); */ void ngtcp2_dcid_copy_cid_token(ngtcp2_dcid *dest, const ngtcp2_dcid *src); -/* - * ngtcp2_dcid_verify_uniqueness verifies uniqueness of (|seq|, |cid|, - * |token|) tuple against |dcid|. - */ -int ngtcp2_dcid_verify_uniqueness(const ngtcp2_dcid *dcid, uint64_t seq, - const ngtcp2_cid *cid, - const ngtcp2_stateless_reset_token *token); - /* * ngtcp2_dcid_verify_stateless_reset_token verifies stateless reset * token |token| received on |path| against the one included in diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_conn.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_conn.c index 12cca44b07e..374274b567c 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_conn.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_conn.c @@ -485,11 +485,42 @@ static int conn_call_extend_max_stream_data(ngtcp2_conn *conn, return 0; } +static int conn_call_extend_max_data(ngtcp2_conn *conn, uint64_t datalen) { + int rv; + + if (!conn->callbacks.extend_max_data) { + return 0; + } + + rv = conn->callbacks.extend_max_data(conn, datalen, conn->user_data); + if (rv != 0) { + return NGTCP2_ERR_CALLBACK_FAILURE; + } + + return 0; +} + static int conn_call_dcid_status(ngtcp2_conn *conn, ngtcp2_connection_id_status_type type, const ngtcp2_dcid *dcid) { int rv; + switch (conn->state) { + case NGTCP2_CS_CLIENT_INITIAL: + case NGTCP2_CS_CLIENT_WAIT_HANDSHAKE: + case NGTCP2_CS_SERVER_INITIAL: + case NGTCP2_CS_SERVER_WAIT_HANDSHAKE: + /* The current Destination Connection ID is activated when + handshake completes. Until then, ngtcp2_conn_get_active_dcid3 + returns nothing, and an application which closes the connection + has no means to forget Destination Connection ID which + NEW_CONNECTION_ID frame in 0-RTT or 0.5-RTT packet made a local + endpoint use. */ + return 0; + default: + break; + } + if (conn->callbacks.dcid_status2) { rv = conn->callbacks.dcid_status2( conn, type, dcid->seq, &dcid->cid, @@ -1331,6 +1362,11 @@ static int conn_new(ngtcp2_conn **pconn, const ngtcp2_cid *dcid, buflen += NGTCP2_LOG_BUFLEN; } + // buflen_align() aligns lengths, buf_align() addresses: when malloc + // returns only 4-byte aligned memory (ESP-IDF heap), the sections + // start up to 7 bytes later than computed. + buflen += 0x7U; + buf = ngtcp2_mem_calloc(mem, 1, buflen); if (buf == NULL) { return NGTCP2_ERR_NOMEM; @@ -1362,9 +1398,9 @@ static int conn_new(ngtcp2_conn **pconn, const ngtcp2_cid *dcid, ngtcp2_pq_init(&(*pconn)->tx.strmq, cycle_less, mem); - ngtcp2_idtr_init(&(*pconn)->remote.bidi.idtr, mem); + ngtcp2_idtr_init(&(*pconn)->bidi.idtr, mem); - ngtcp2_idtr_init(&(*pconn)->remote.uni.idtr, mem); + ngtcp2_idtr_init(&(*pconn)->uni.idtr, mem); ngtcp2_static_ringbuf_path_challenge_init(&(*pconn)->rx.path_challenge); @@ -1391,13 +1427,18 @@ static int conn_new(ngtcp2_conn **pconn, const ngtcp2_cid *dcid, (*pconn)->local.settings = *settings; if (settings->tokenlen) { - tokenbuf = ngtcp2_mem_malloc(mem, settings->tokenlen); - if (tokenbuf == NULL) { - rv = NGTCP2_ERR_NOMEM; - goto fail_token; + if (settings->tokenlen > NGTCP2_MAX_TOKENLEN) { + (*pconn)->local.settings.token = NULL; + (*pconn)->local.settings.tokenlen = 0; + } else { + tokenbuf = ngtcp2_mem_malloc(mem, settings->tokenlen); + if (tokenbuf == NULL) { + rv = NGTCP2_ERR_NOMEM; + goto fail_token; + } + memcpy(tokenbuf, settings->token, settings->tokenlen); + (*pconn)->local.settings.token = tokenbuf; } - memcpy(tokenbuf, settings->token, settings->tokenlen); - (*pconn)->local.settings.token = tokenbuf; } else { (*pconn)->local.settings.token = NULL; } @@ -1596,7 +1637,6 @@ static int conn_new(ngtcp2_conn **pconn, const ngtcp2_cid *dcid, (*pconn)->tx.last_max_data_ts = UINT64_MAX; (*pconn)->tx.pacing.next_ts = UINT64_MAX; (*pconn)->tx.last_blocked_offset = UINT64_MAX; - (*pconn)->rx.preferred_addr.pkt_num = -1; (*pconn)->early.discard_started_ts = UINT64_MAX; conn_reset_ecn_validation_state(*pconn); @@ -1646,8 +1686,8 @@ int ngtcp2_conn_client_new_versioned( } (*pconn)->rcid = *dcid; (*pconn)->state = NGTCP2_CS_CLIENT_INITIAL; - (*pconn)->local.bidi.next_stream_id = 0; - (*pconn)->local.uni.next_stream_id = 2; + (*pconn)->tx.bidi.next_stream_id = 0; + (*pconn)->tx.uni.next_stream_id = 2; (*pconn)->flags |= NGTCP2_CONN_FLAG_CRUMBLE_INITIAL_CRYPTO; rv = ngtcp2_conn_commit_local_transport_params(*pconn); @@ -1678,8 +1718,8 @@ int ngtcp2_conn_server_new_versioned( } (*pconn)->state = NGTCP2_CS_SERVER_INITIAL; - (*pconn)->local.bidi.next_stream_id = 1; - (*pconn)->local.uni.next_stream_id = 3; + (*pconn)->tx.bidi.next_stream_id = 1; + (*pconn)->tx.uni.next_stream_id = 3; if ((*pconn)->local.settings.tokenlen) { /* Usage of token lifts amplification limit */ @@ -1826,8 +1866,8 @@ void ngtcp2_conn_del(ngtcp2_conn *conn) { ngtcp2_mem_free(conn->mem, (uint8_t *)conn->rx.ccerr.reason); - ngtcp2_idtr_free(&conn->remote.uni.idtr); - ngtcp2_idtr_free(&conn->remote.bidi.idtr); + ngtcp2_idtr_free(&conn->uni.idtr); + ngtcp2_idtr_free(&conn->bidi.idtr); ngtcp2_pq_free(&conn->tx.strmq); ngtcp2_map_each(&conn->strms, delete_strms_each, (void *)conn); ngtcp2_map_free(&conn->strms); @@ -1990,8 +2030,11 @@ static int conn_cwnd_is_zero(const ngtcp2_conn *conn) { /* * conn_retry_early_payloadlen returns the estimated wire length of - * the first STREAM frame of 0-RTT packet which should be - * retransmitted due to Retry packet. + * the first frame of 0-RTT packet which is generated from + * conn->tx.strmq. It is either STREAM frame which should be + * retransmitted due to Retry packet, or the other stream related + * frame (e.g., RESET_STREAM, STOP_SENDING, STREAM_DATA_BLOCKED, and + * MAX_STREAM_DATA). */ static uint64_t conn_retry_early_payloadlen(ngtcp2_conn *conn) { ngtcp2_frame_chain *frc; @@ -2002,32 +2045,35 @@ static uint64_t conn_retry_early_payloadlen(ngtcp2_conn *conn) { return 0; } - for (; !ngtcp2_pq_empty(&conn->tx.strmq);) { - strm = ngtcp2_conn_tx_strmq_top(conn); - if (ngtcp2_strm_streamfrq_empty(strm)) { - ngtcp2_conn_tx_strmq_pop(conn); - continue; - } + if (ngtcp2_pq_empty(&conn->tx.strmq)) { + return 0; + } - frc = ngtcp2_strm_streamfrq_top(strm); + strm = ngtcp2_conn_tx_strmq_top(conn); + if (ngtcp2_strm_streamfrq_empty(strm)) { + /* strm has no STREAM frame to send, but is queued to send the + other stream related frames (e.g., RESET_STREAM, STOP_SENDING, + or MAX_STREAM_DATA). Do not remove it from the queue here, + otherwise those frames are never sent. conn_write_pkt writes + them, and removes strm from the queue. */ + return NGTCP2_STREAM_OVERHEAD; + } - len = ngtcp2_vec_len(frc->fr.stream.data, frc->fr.stream.datacnt) + - NGTCP2_STREAM_OVERHEAD; + frc = ngtcp2_strm_streamfrq_top(strm); - /* Take the min because in conn_should_pad_pkt we take max in - order to deal with unbreakable DATAGRAM. */ - return ngtcp2_min(len, NGTCP2_MIN_COALESCED_PAYLOADLEN); - } + len = ngtcp2_vec_len(frc->fr.stream.data, frc->fr.stream.datacnt) + + NGTCP2_STREAM_OVERHEAD; - return 0; + /* Take the min because in conn_should_pad_pkt we take max in order + to deal with unbreakable DATAGRAM. */ + return ngtcp2_min(len, NGTCP2_MIN_COALESCED_PAYLOADLEN); } /* * conn_verify_dcid verifies that destination connection ID in |hd| is - * valid for the connection. If it is successfully verified and the - * remote endpoint uses new DCID in the packet, nonzero value is - * assigned to |*pnew_cid_used| if it is not NULL. Otherwise 0 is - * assigned to it. + * valid for the connection. If it is successfully verified, and + * |pseq| is not NULL, the sequence number of the connection ID is + * assigned to |*pseq|. * * This function returns 0 if it succeeds, or one of the following * negative error codes: @@ -2037,7 +2083,7 @@ static uint64_t conn_retry_early_payloadlen(ngtcp2_conn *conn) { * NGTCP2_ERR_INVALID_ARGUMENT * |dcid| is not known to the local endpoint. */ -static int conn_verify_dcid(ngtcp2_conn *conn, int *pnew_cid_used, +static int conn_verify_dcid(ngtcp2_conn *conn, uint64_t *pseq, const ngtcp2_pkt_hd *hd) { ngtcp2_ksl_it it; ngtcp2_scid *scid; @@ -2062,12 +2108,10 @@ static int conn_verify_dcid(ngtcp2_conn *conn, int *pnew_cid_used, return rv; } } + } - if (pnew_cid_used) { - *pnew_cid_used = 1; - } - } else if (pnew_cid_used) { - *pnew_cid_used = 0; + if (pseq) { + *pseq = scid->seq; } return 0; @@ -2728,18 +2772,9 @@ conn_write_handshake_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, uint8_t *dest, } /* We had pktns->rtb.num_retransmittable > 0 but the contents of those packets have been acknowledged (i.e., retransmission in - another packet). For server, in this case, we don't have to - send any probe packet. Client needs to send probe packets - until it knows that server has completed address - validation. */ - if (pktns->rtb.num_pto_eliciting == 0 && - (conn->server || - (conn->flags & NGTCP2_CONN_FLAG_SERVER_ADDR_VERIFIED))) { - pktns->rtb.probe_pkt_left = 0; - ngtcp2_conn_set_loss_detection_timer(conn, ts); - /* TODO If packet is empty, we should return now if cwnd is - zero. */ - } + another packet). Those packets are still in flight, and we + have to send PING as a probe packet to know whether they are + lost or not. */ } if (!(rtb_entry_flags & NGTCP2_RTB_ENTRY_FLAG_ACK_ELICITING) && @@ -2804,6 +2839,13 @@ conn_write_handshake_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, uint8_t *dest, (rtb_entry_flags & NGTCP2_RTB_ENTRY_FLAG_ACK_ELICITING)) { padded = 1; } + + if (!hd_logged) { + hd_logged = 1; + ngtcp2_log_tx_pkt_hd(&conn->log, &hd); + ngtcp2_qlog_pkt_sent_start(&conn->qlog); + } + ngtcp2_log_tx_fr(&conn->log, &hd, &lfr); ngtcp2_qlog_write_frame(&conn->qlog, &lfr); } @@ -3071,9 +3113,13 @@ static ngtcp2_ssize conn_write_client_initial(ngtcp2_conn *conn, ngtcp2_tstamp ts) { int rv; - rv = conn_call_client_initial(conn); - if (rv != 0) { - return rv; + if (!(conn->flags & NGTCP2_CONN_FLAG_CLIENT_INITIAL_CALLED)) { + rv = conn_call_client_initial(conn); + if (rv != 0) { + return rv; + } + + conn->flags |= NGTCP2_CONN_FLAG_CLIENT_INITIAL_CALLED; } return conn_write_handshake_pkt( @@ -3082,16 +3128,17 @@ static ngtcp2_ssize conn_write_client_initial(ngtcp2_conn *conn, } /* - * dcid_tx_left returns the maximum number of bytes that server is - * allowed to send to an unvalidated path associated to |dcid|. + * dcid_tx_left returns the maximum number of bytes that an endpoint + * is allowed to send to an unvalidated path associated to |dcid|. */ static uint64_t dcid_tx_left(const ngtcp2_dcid *dcid) { if (dcid->flags & NGTCP2_DCID_FLAG_PATH_VALIDATED) { return SIZE_MAX; } - /* From QUIC spec: Prior to validating the client address, servers - MUST NOT send more than three times as many bytes as the number - of bytes they have received. */ + /* From QUIC spec: After receiving packets from an address that is + not yet validated, an endpoint MUST limit the amount of data it + sends to the unvalidated address to three times the amount of + data received from that address. */ assert(dcid->bytes_recv * 3 >= dcid->bytes_sent); return dcid->bytes_recv * 3 - dcid->bytes_sent; @@ -3329,6 +3376,16 @@ static int conn_enqueue_new_connection_id(ngtcp2_conn *conn) { return rv; } + /* Allocate scid before calling get_new_connection_id callback. + An application associates a new Connection ID with conn inside + the callback, and relies on conn->scid.set to remove the + association later. */ + scid = ngtcp2_mem_malloc(conn->mem, sizeof(*scid)); + if (scid == NULL) { + rv = NGTCP2_ERR_NOMEM; + goto fail; + } + nfrc->fr.new_connection_id.type = NGTCP2_FRAME_NEW_CONNECTION_ID; nfrc->fr.new_connection_id.seq = ++conn->scid.last_seq; nfrc->fr.new_connection_id.retire_prior_to = 0; @@ -3355,18 +3412,14 @@ static int conn_enqueue_new_connection_id(ngtcp2_conn *conn) { goto fail; } - scid = ngtcp2_mem_malloc(conn->mem, sizeof(*scid)); - if (scid == NULL) { - rv = NGTCP2_ERR_NOMEM; - goto fail; - } - ngtcp2_scid_init(scid, nfrc->fr.new_connection_id.seq, &nfrc->fr.new_connection_id.cid); rv = ngtcp2_ksl_insert(&conn->scid.set, NULL, &scid->cid, scid); if (rv != 0) { - ngtcp2_mem_free(conn->mem, scid); + /* Let an application remove the association it has just + made. */ + conn_call_remove_connection_id(conn, &scid->cid); goto fail; } @@ -3381,6 +3434,7 @@ static int conn_enqueue_new_connection_id(ngtcp2_conn *conn) { return 0; fail: + ngtcp2_mem_free(conn->mem, scid); ngtcp2_frame_chain_objalloc_del(nfrc, &conn->frc_objalloc, conn->mem); return rv; @@ -3590,7 +3644,10 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, datalen = ngtcp2_vec_len(vmsg->stream.data, vmsg->stream.datacnt); ndatalen = conn_enforce_flow_control(conn, vmsg->stream.strm, datalen); /* 0 length STREAM frame is allowed */ - if (ndatalen || datalen == 0) { + if (datalen == 0 || + (ndatalen && + (datalen <= conn->local.settings.write_stream_data_thresh || + ndatalen > conn->local.settings.write_stream_data_thresh))) { send_stream = 1; } else { stream_blocked = 1; @@ -3729,7 +3786,8 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, ngtcp2_ringbuf_pop_front(&conn->rx.path_challenge.rb); pkt_empty = 0; - rtb_entry_flags |= NGTCP2_RTB_ENTRY_FLAG_ACK_ELICITING; + rtb_entry_flags |= NGTCP2_RTB_ENTRY_FLAG_ACK_ELICITING | + NGTCP2_RTB_ENTRY_FLAG_PTO_ELICITING; require_padding = require_padding || !conn->server || destlen >= NGTCP2_MAX_UDP_PAYLOAD_SIZE; /* We don't retransmit PATH_RESPONSE. */ @@ -3801,8 +3859,7 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, case NGTCP2_FRAME_STREAM: ngtcp2_unreachable(); case NGTCP2_FRAME_MAX_STREAMS_BIDI: - if ((*pfrc)->fr.max_streams.max_streams < - conn->remote.bidi.max_streams) { + if ((*pfrc)->fr.max_streams.max_streams < conn->rx.bidi.max_streams) { frc = *pfrc; *pfrc = (*pfrc)->next; ngtcp2_frame_chain_objalloc_del(frc, &conn->frc_objalloc, conn->mem); @@ -3810,8 +3867,7 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, } break; case NGTCP2_FRAME_MAX_STREAMS_UNI: - if ((*pfrc)->fr.max_streams.max_streams < - conn->remote.uni.max_streams) { + if ((*pfrc)->fr.max_streams.max_streams < conn->rx.uni.max_streams) { frc = *pfrc; *pfrc = (*pfrc)->next; ngtcp2_frame_chain_objalloc_del(frc, &conn->frc_objalloc, conn->mem); @@ -3849,7 +3905,7 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, } break; case NGTCP2_FRAME_DATA_BLOCKED: - if ((*pfrc)->fr.data_blocked.offset != conn->tx.max_offset) { + if ((*pfrc)->fr.data_blocked.max_data != conn->tx.max_offset) { frc = *pfrc; *pfrc = (*pfrc)->next; ngtcp2_frame_chain_objalloc_del(frc, &conn->frc_objalloc, conn->mem); @@ -3993,38 +4049,82 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, NGTCP2_RTB_ENTRY_FLAG_PTO_ELICITING | NGTCP2_RTB_ENTRY_FLAG_RETRANSMITTABLE; pfrc = &(*pfrc)->next; + + /* An application might have shut down or extended the + flow control window of any stream inside the callback + function. strm might not be the top of conn->tx.strmq + anymore, and its flags might have been changed. Start + over from the top of the queue. */ + if (ngtcp2_conn_tx_strmq_top(conn) != strm || + (strm->flags & NGTCP2_STRM_FLAG_SEND_RESET_STREAM)) { + continue; + } } } - if (!(strm->flags & NGTCP2_STRM_FLAG_SHUT_WR) && - strm_should_send_stream_data_blocked(strm)) { - rv = ngtcp2_frame_chain_objalloc_new(&nfrc, &conn->frc_objalloc); - if (rv != 0) { - return rv; - } + if (strm->flags & NGTCP2_STRM_FLAG_SEND_STREAM_DATA_BLOCKED) { + if (!(strm->flags & NGTCP2_STRM_FLAG_SHUT_WR)) { + if (conn_should_send_data_blocked(conn)) { + rv = ngtcp2_frame_chain_objalloc_new(&nfrc, &conn->frc_objalloc); + if (rv != 0) { + return rv; + } + + nfrc->fr.data_blocked = (ngtcp2_data_blocked){ + .type = NGTCP2_FRAME_DATA_BLOCKED, + .max_data = conn->tx.max_offset, + }; + *pfrc = nfrc; - nfrc->fr.stream_data_blocked = (ngtcp2_stream_data_blocked){ - .type = NGTCP2_FRAME_STREAM_DATA_BLOCKED, - .stream_id = strm->stream_id, - .offset = strm->tx.max_offset, - }; - *pfrc = nfrc; + conn->tx.last_blocked_offset = conn->tx.max_offset; - strm->tx.last_blocked_offset = strm->tx.max_offset; + rv = conn_ppe_write_frame_hd_log(conn, ppe, &hd_logged, hd, + &nfrc->fr); + if (rv != 0) { + assert(NGTCP2_ERR_NOBUF == rv); - rv = - conn_ppe_write_frame_hd_log(conn, ppe, &hd_logged, hd, &nfrc->fr); - if (rv != 0) { - assert(NGTCP2_ERR_NOBUF == rv); + break; + } - break; + pkt_empty = 0; + rtb_entry_flags |= NGTCP2_RTB_ENTRY_FLAG_ACK_ELICITING | + NGTCP2_RTB_ENTRY_FLAG_PTO_ELICITING | + NGTCP2_RTB_ENTRY_FLAG_RETRANSMITTABLE; + pfrc = &(*pfrc)->next; + } + + if (strm_should_send_stream_data_blocked(strm)) { + rv = ngtcp2_frame_chain_objalloc_new(&nfrc, &conn->frc_objalloc); + if (rv != 0) { + return rv; + } + + nfrc->fr.stream_data_blocked = (ngtcp2_stream_data_blocked){ + .type = NGTCP2_FRAME_STREAM_DATA_BLOCKED, + .stream_id = strm->stream_id, + .max_stream_data = strm->tx.max_offset, + }; + *pfrc = nfrc; + + strm->tx.last_blocked_offset = strm->tx.max_offset; + + rv = conn_ppe_write_frame_hd_log(conn, ppe, &hd_logged, hd, + &nfrc->fr); + if (rv != 0) { + assert(NGTCP2_ERR_NOBUF == rv); + + break; + } + + pkt_empty = 0; + rtb_entry_flags |= NGTCP2_RTB_ENTRY_FLAG_ACK_ELICITING | + NGTCP2_RTB_ENTRY_FLAG_PTO_ELICITING | + NGTCP2_RTB_ENTRY_FLAG_RETRANSMITTABLE; + pfrc = &(*pfrc)->next; + } } - pkt_empty = 0; - rtb_entry_flags |= NGTCP2_RTB_ENTRY_FLAG_ACK_ELICITING | - NGTCP2_RTB_ENTRY_FLAG_PTO_ELICITING | - NGTCP2_RTB_ENTRY_FLAG_RETRANSMITTABLE; - pfrc = &(*pfrc)->next; + strm->flags &= ~NGTCP2_STRM_FLAG_SEND_STREAM_DATA_BLOCKED; } if (!(strm->flags & @@ -4148,9 +4248,9 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, /* Write MAX_STREAMS after RESET_STREAM so that we can extend stream ID space in one packet. */ if (*pfrc == NULL && - conn->remote.bidi.unsent_max_streams > conn->remote.bidi.max_streams) { + conn->rx.bidi.unsent_max_streams > conn->rx.bidi.max_streams) { rv = conn_call_extend_max_remote_streams_bidi( - conn, conn->remote.bidi.unsent_max_streams); + conn, conn->rx.bidi.unsent_max_streams); if (rv != 0) { assert(ngtcp2_err_is_fatal(rv)); return rv; @@ -4163,11 +4263,11 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, } nfrc->fr.max_streams = (ngtcp2_max_streams){ .type = NGTCP2_FRAME_MAX_STREAMS_BIDI, - .max_streams = conn->remote.bidi.unsent_max_streams, + .max_streams = conn->rx.bidi.unsent_max_streams, }; *pfrc = nfrc; - conn->remote.bidi.max_streams = conn->remote.bidi.unsent_max_streams; + conn->rx.bidi.max_streams = conn->rx.bidi.unsent_max_streams; rv = conn_ppe_write_frame_hd_log(conn, ppe, &hd_logged, hd, &(*pfrc)->fr); if (rv != 0) { @@ -4182,9 +4282,9 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, } if (*pfrc == NULL && - conn->remote.uni.unsent_max_streams > conn->remote.uni.max_streams) { + conn->rx.uni.unsent_max_streams > conn->rx.uni.max_streams) { rv = conn_call_extend_max_remote_streams_uni( - conn, conn->remote.uni.unsent_max_streams); + conn, conn->rx.uni.unsent_max_streams); if (rv != 0) { assert(ngtcp2_err_is_fatal(rv)); return rv; @@ -4197,11 +4297,11 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, } nfrc->fr.max_streams = (ngtcp2_max_streams){ .type = NGTCP2_FRAME_MAX_STREAMS_UNI, - .max_streams = conn->remote.uni.unsent_max_streams, + .max_streams = conn->rx.uni.unsent_max_streams, }; *pfrc = nfrc; - conn->remote.uni.max_streams = conn->remote.uni.unsent_max_streams; + conn->rx.uni.max_streams = conn->rx.uni.unsent_max_streams; rv = conn_ppe_write_frame_hd_log(conn, ppe, &hd_logged, hd, &(*pfrc)->fr); if (rv != 0) { @@ -4227,16 +4327,9 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, } /* We had pktns->rtb.num_retransmittable > 0 but we were unable - to reclaim any frame. In this case, we do not have to send - any probe packet. */ - if (pktns->rtb.num_pto_eliciting == 0) { - pktns->rtb.probe_pkt_left = 0; - ngtcp2_conn_set_loss_detection_timer(conn, ts); - - if (pkt_empty && conn_cwnd_is_zero(conn) && !require_padding) { - return 0; - } - } + to reclaim any frame. Those packets are still in flight, and + we have to send PING as a probe packet to know whether they + are lost or not. */ } } else { pfrc = conn->pkt.pfrc; @@ -4248,17 +4341,19 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, left = ngtcp2_ppe_left(ppe); + /* An application might have shut down the stream inside + stream_stop_sending callback function called above. */ if (*pfrc == NULL && send_stream && ngtcp2_pq_empty(&conn->tx.strmq) && + !(vmsg->stream.strm->flags & NGTCP2_STRM_FLAG_SHUT_WR) && (wdatalen = ngtcp2_pkt_stream_max_datalen( vmsg->stream.strm->stream_id, vmsg->stream.strm->tx.offset, ndatalen, left)) != (size_t)-1 && (wdatalen == ndatalen || wdatalen >= NGTCP2_MIN_STREAM_DATALEN) && (wdatalen || datalen == 0)) { - ndatalen = wdatalen; datacnt = ngtcp2_vec_copy_at_most(data, NGTCP2_MAX_STREAM_DATACNT, vmsg->stream.data, vmsg->stream.datacnt, - (size_t)ndatalen); - ndatalen = ngtcp2_vec_len(data, datacnt); + (size_t)wdatalen); + wdatalen = ngtcp2_vec_len(data, datacnt); assert((datacnt == 0 && datalen == 0) || (datacnt && datalen)); @@ -4271,15 +4366,13 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, nfrc->fr.stream.type = NGTCP2_FRAME_STREAM; nfrc->fr.stream.flags = 0; - nfrc->fr.stream.fin = 0; + nfrc->fr.stream.fin = (vmsg->stream.flags & NGTCP2_WRITE_STREAM_FLAG_FIN) && + wdatalen == datalen; nfrc->fr.stream.stream_id = vmsg->stream.strm->stream_id; nfrc->fr.stream.offset = vmsg->stream.strm->tx.offset; nfrc->fr.stream.datacnt = datacnt; ngtcp2_vec_copy(nfrc->fr.stream.data, data, datacnt); - nfrc->fr.stream.fin = (vmsg->stream.flags & NGTCP2_WRITE_STREAM_FLAG_FIN) && - ndatalen == datalen; - rv = conn_ppe_write_frame_hd_log(conn, ppe, &hd_logged, hd, &nfrc->fr); if (rv != 0) { ngtcp2_unreachable(); @@ -4295,8 +4388,8 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, ++conn->frame_counts.stream; - vmsg->stream.strm->tx.offset += ndatalen; - conn->tx.offset += ndatalen; + vmsg->stream.strm->tx.offset += wdatalen; + conn->tx.offset += wdatalen; vmsg->stream.strm->flags |= NGTCP2_STRM_FLAG_ANY_SENT; if (nfrc->fr.stream.fin) { @@ -4304,7 +4397,7 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, } if (vmsg->stream.pdatalen) { - *vmsg->stream.pdatalen = (ngtcp2_ssize)ndatalen; + *vmsg->stream.pdatalen = (ngtcp2_ssize)wdatalen; } } else { send_stream = 0; @@ -4312,8 +4405,10 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, if (vmsg && vmsg->type == NGTCP2_VMSG_TYPE_STREAM && ((stream_blocked && *pfrc == NULL) || - (send_stream && - !(vmsg->stream.strm->flags & NGTCP2_STRM_FLAG_SHUT_WR)))) { + (send_stream && !(vmsg->stream.strm->flags & NGTCP2_STRM_FLAG_SHUT_WR) && + ndatalen < datalen && ndatalen == wdatalen))) { + strm = vmsg->stream.strm; + if (conn_should_send_data_blocked(conn)) { rv = ngtcp2_frame_chain_objalloc_new(&nfrc, &conn->frc_objalloc); if (rv != 0) { @@ -4324,7 +4419,7 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, nfrc->fr.data_blocked = (ngtcp2_data_blocked){ .type = NGTCP2_FRAME_DATA_BLOCKED, - .offset = conn->tx.offset, + .max_data = conn->tx.offset, }; rv = conn_ppe_write_frame_hd_log(conn, ppe, &hd_logged, hd, &nfrc->fr); @@ -4333,6 +4428,13 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, /* We cannot add nfrc to pktns->tx.frq here. */ ngtcp2_frame_chain_objalloc_del(nfrc, &conn->frc_objalloc, conn->mem); + + strm->flags |= NGTCP2_STRM_FLAG_SEND_STREAM_DATA_BLOCKED; + + rv = ngtcp2_conn_tx_strmq_push_if_not(conn, strm); + if (rv != 0) { + return rv; + } } else { *pfrc = nfrc; pfrc = &(*pfrc)->next; @@ -4346,8 +4448,6 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, } } - strm = vmsg->stream.strm; - if (strm_should_send_stream_data_blocked(strm)) { rv = ngtcp2_frame_chain_objalloc_new(&nfrc, &conn->frc_objalloc); if (rv != 0) { @@ -4359,7 +4459,7 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, nfrc->fr.stream_data_blocked = (ngtcp2_stream_data_blocked){ .type = NGTCP2_FRAME_STREAM_DATA_BLOCKED, .stream_id = strm->stream_id, - .offset = strm->tx.max_offset, + .max_stream_data = strm->tx.max_offset, }; rv = conn_ppe_write_frame_hd_log(conn, ppe, &hd_logged, hd, &nfrc->fr); @@ -4369,12 +4469,11 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, /* We cannot add nfrc to pktns->tx.frq here. */ ngtcp2_frame_chain_objalloc_del(nfrc, &conn->frc_objalloc, conn->mem); - if (!ngtcp2_strm_is_tx_queued(strm)) { - strm->cycle = ngtcp2_conn_tx_strmq_first_cycle(conn); - rv = ngtcp2_conn_tx_strmq_push(conn, strm); - if (rv != 0) { - return rv; - } + strm->flags |= NGTCP2_STRM_FLAG_SEND_STREAM_DATA_BLOCKED; + + rv = ngtcp2_conn_tx_strmq_push_if_not(conn, strm); + if (rv != 0) { + return rv; } } else { *pfrc = nfrc; @@ -4448,6 +4547,13 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, conn->pkt.hd_logged = hd_logged; conn->pkt.require_padding = require_padding; conn->flags |= NGTCP2_CONN_FLAG_PPE_PENDING; + } else { + /* The packet might have been left open by the previous call + with NGTCP2_WRITE_PKT_FLAG_MORE. It is still empty, and + nothing is going to be added to it, so discard it. + Otherwise, NGTCP2_CONN_FLAG_PPE_PENDING is left set after + returning to the application. */ + conn_reset_ppe_pending(conn); } return NGTCP2_ERR_STREAM_DATA_BLOCKED; @@ -4485,6 +4591,13 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, stream_blocked) { return NGTCP2_ERR_STREAM_DATA_BLOCKED; } + + /* In case when stream is shutted down inside stop_sending + callback */ + if (vmsg->stream.strm->flags & NGTCP2_STRM_FLAG_SHUT_WR) { + return NGTCP2_ERR_STREAM_SHUT_WR; + } + break; case NGTCP2_VMSG_TYPE_DATAGRAM: if (send_datagram && ngtcp2_ppe_left(ppe)) { @@ -4508,8 +4621,10 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, rv = conn_ppe_write_frame_hd_log(conn, ppe, &hd_logged, hd, &lfr); if (rv != 0) { assert(rv == NGTCP2_ERR_NOBUF); - /* TODO If buffer is too small, PING cannot be written if - packet is still empty. */ + /* ngtcp2_ppe_encode_hd ensures that an empty packet has the + space for PING. If we get here, the packet is not + empty. */ + assert(!pkt_empty); } else { rtb_entry_flags |= NGTCP2_RTB_ENTRY_FLAG_ACK_ELICITING; if (conn->pktns.rtb.probe_pkt_left) { @@ -4544,6 +4659,13 @@ static ngtcp2_ssize conn_write_pkt(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, padded = 1; } lfr.padding.type = NGTCP2_FRAME_PADDING; + + if (!hd_logged) { + hd_logged = 1; + ngtcp2_log_tx_pkt_hd(&conn->log, hd); + ngtcp2_qlog_pkt_sent_start(&conn->qlog); + } + ngtcp2_log_tx_fr(&conn->log, hd, &lfr); ngtcp2_qlog_write_frame(&conn->qlog, &lfr); } @@ -4915,6 +5037,8 @@ static int dcidtr_on_retire(const ngtcp2_dcid *dcid, void *user_data) { * * NGTCP2_ERR_NOMEM * Out of memory + * NGTCP2_ERR_CONNECTION_ID_LIMIT + * The number of unacknowledged retirement exceeds the limit. */ static int conn_retire_active_dcid(ngtcp2_conn *conn, const ngtcp2_dcid *dcid, ngtcp2_tstamp ts) { @@ -4942,6 +5066,8 @@ static int conn_retire_active_dcid(ngtcp2_conn *conn, const ngtcp2_dcid *dcid, * * NGTCP2_ERR_CONN_ID_BLOCKED * No unused DCID is available + * NGTCP2_ERR_CONNECTION_ID_LIMIT + * The number of unacknowledged retirement exceeds the limit. * NGTCP2_ERR_NOMEM * Out of memory */ @@ -5068,6 +5194,8 @@ static ngtcp2_ssize conn_write_pmtud_probe(ngtcp2_conn *conn, * * NGTCP2_ERR_NOMEM * Out of memory + * NGTCP2_ERR_CONNECTION_ID_LIMIT + * The number of unacknowledged retirement exceeds the limit. */ static int conn_stop_pv(ngtcp2_conn *conn, ngtcp2_tstamp ts) { int rv = 0; @@ -5077,7 +5205,10 @@ static int conn_stop_pv(ngtcp2_conn *conn, ngtcp2_tstamp ts) { return 0; } - if (pv->dcid.cid.datalen && pv->dcid.seq != conn->dcid.current.seq) { + if (pv->dcid.cid.datalen && pv->dcid.seq != conn->dcid.current.seq && + (!(pv->flags & NGTCP2_PV_FLAG_FALLBACK_PRESENT) || + !(pv->flags & NGTCP2_PV_FLAG_DONT_RETIRE_FALLBACK) || + pv->dcid.seq != pv->fallback_dcid.seq)) { rv = conn_retire_active_dcid(conn, &pv->dcid, ts); if (rv != 0) { goto fin; @@ -5085,6 +5216,7 @@ static int conn_stop_pv(ngtcp2_conn *conn, ngtcp2_tstamp ts) { } if ((pv->flags & NGTCP2_PV_FLAG_FALLBACK_PRESENT) && + !(pv->flags & NGTCP2_PV_FLAG_DONT_RETIRE_FALLBACK) && pv->fallback_dcid.cid.datalen && pv->fallback_dcid.seq != conn->dcid.current.seq && pv->fallback_dcid.seq != pv->dcid.seq) { @@ -5113,6 +5245,8 @@ static int conn_stop_pv(ngtcp2_conn *conn, ngtcp2_tstamp ts) { * Out of memory * NGTCP2_ERR_CALLBACK_FAILURE * User-defined callback function failed. + * NGTCP2_ERR_CONNECTION_ID_LIMIT + * The number of unacknowledged retirement exceeds the limit. */ static int conn_abort_pv(ngtcp2_conn *conn, ngtcp2_tstamp ts) { ngtcp2_pv *pv = conn->pv; @@ -5286,7 +5420,11 @@ static ngtcp2_ssize conn_write_path_challenge(ngtcp2_conn *conn, if (ngtcp2_path_eq(&pv->dcid.ps.path, &conn->dcid.current.ps.path)) { conn->dcid.current.bytes_sent += (uint64_t)nwrite; - } else { + } else if (conn->server) { + /* Client starts path validation before it receives anything from + the path. Its probes are not charged to the anti-amplification + limit, which only restricts what client sends in response to + the packets received from that path. */ pv->dcid.bytes_sent += (uint64_t)nwrite; } @@ -5304,6 +5442,8 @@ static ngtcp2_ssize conn_write_path_challenge(ngtcp2_conn *conn, * Out of memory * NGTCP2_ERR_CALLBACK_FAILURE * User-defined callback function failed. + * NGTCP2_ERR_CONNECTION_ID_LIMIT + * The number of unacknowledged retirement exceeds the limit. */ static ngtcp2_ssize conn_write_path_response(ngtcp2_conn *conn, ngtcp2_path *path, @@ -5314,7 +5454,6 @@ static ngtcp2_ssize conn_write_path_response(ngtcp2_conn *conn, ngtcp2_dcid *dcid = NULL; ngtcp2_frame lfr; ngtcp2_ssize nwrite; - int rv; uint64_t tx_left; for (; ngtcp2_ringbuf_len(&conn->rx.path_challenge.rb);) { @@ -5338,11 +5477,23 @@ static ngtcp2_ssize conn_write_path_response(ngtcp2_conn *conn, } if (conn->server) { - break; + /* conn_recv_pkt_from_new_path binds DCID to the path, and + credits the received bytes to it when PATH_CHALLENGE is + received. Do not bind new DCID here because it has no + credit, and nothing can be sent with it. */ + dcid = ngtcp2_dcidtr_find_bound_dcid(&conn->dcid.dtr, &pcent->ps.path); + if (dcid && dcid_tx_left(dcid)) { + break; + } } /* Client does not expect to respond to path validation against - unknown path */ + unknown path. Server has no DCID bound to the path, or is + blocked by the anti-amplification limit. Waiting does not help + because they are only resolved by receiving another packet from + the path, which carries new PATH_CHALLENGE if a remote endpoint + still needs the path. Drop this entry so that it does not + block the others. */ ngtcp2_ringbuf_pop_front(&conn->rx.path_challenge.rb); pcent = NULL; } @@ -5351,24 +5502,14 @@ static ngtcp2_ssize conn_write_path_response(ngtcp2_conn *conn, return 0; } - if (dcid == NULL) { - /* client is expected to have |path| in conn->dcid.current or - conn->pv. */ - assert(conn->server); - - rv = conn_bind_dcid(conn, &dcid, &pcent->ps.path, ts); - if (rv != 0) { - if (ngtcp2_err_is_fatal(rv)) { - return rv; - } - return 0; - } - } - destlen = ngtcp2_min(destlen, NGTCP2_MAX_UDP_PAYLOAD_SIZE); - if (conn->server && !(dcid->flags & NGTCP2_DCID_FLAG_PATH_VALIDATED)) { - tx_left = conn_server_tx_left(conn, dcid); + /* |dcid| is not bound to the current path here. Client is also + subject to the anti-amplification limit because the path it is + validating might lead to an address chosen by server (e.g., + preferred address). */ + if (!(dcid->flags & NGTCP2_DCID_FLAG_PATH_VALIDATED)) { + tx_left = dcid_tx_left(dcid); destlen = (size_t)ngtcp2_min((uint64_t)destlen, tx_left); if (destlen == 0) { return 0; @@ -5625,7 +5766,8 @@ int ngtcp2_conn_detect_lost_pkt(ngtcp2_conn *conn, ngtcp2_pktns *pktns, * NGTCP2_ERR_NOMEM * Out of memory * NGTCP2_ERR_PROTO - * |fr| acknowledges a packet this endpoint has not sent. + * |fr| acknowledges a packet this endpoint has not sent, or a + * packet which was sent after |pkt_ts|. * NGTCP2_ERR_CALLBACK_FAILURE * User callback failed. */ @@ -5706,21 +5848,21 @@ static int conn_recv_max_stream_data(ngtcp2_conn *conn, if (bidi) { if (local_stream) { - if (conn->local.bidi.next_stream_id <= fr->stream_id) { + if (conn->tx.bidi.next_stream_id <= fr->stream_id) { return NGTCP2_ERR_STREAM_STATE; } - } else if (conn->remote.bidi.max_streams < + } else if (conn->rx.bidi.max_streams < ngtcp2_ord_stream_id(fr->stream_id)) { return NGTCP2_ERR_STREAM_LIMIT; } - idtr = &conn->remote.bidi.idtr; + idtr = &conn->bidi.idtr; } else { - if (!local_stream || conn->local.uni.next_stream_id <= fr->stream_id) { + if (!local_stream || conn->tx.uni.next_stream_id <= fr->stream_id) { return NGTCP2_ERR_STREAM_STATE; } - idtr = &conn->remote.uni.idtr; + idtr = &conn->uni.idtr; } strm = ngtcp2_conn_find_stream(conn, fr->stream_id); @@ -5765,10 +5907,6 @@ static int conn_recv_max_stream_data(ngtcp2_conn *conn, } if (strm->tx.max_offset >= fr->max_stream_data) { - if (ngtcp2_ratelim_drain(&conn->glitch_rlim, 1, ts) != 0) { - return NGTCP2_ERR_INTERNAL; - } - return 0; } @@ -5776,27 +5914,34 @@ static int conn_recv_max_stream_data(ngtcp2_conn *conn, /* Don't call callback if stream is half-closed local */ if (strm->flags & NGTCP2_STRM_FLAG_SHUT_WR) { - if (ngtcp2_ratelim_drain(&conn->glitch_rlim, 1, ts) != 0) { - return NGTCP2_ERR_INTERNAL; - } - return 0; } - rv = conn_call_extend_max_stream_data(conn, strm, fr->stream_id, - fr->max_stream_data); - if (rv != 0) { - return rv; + if (strm->tx.max_offset <= + strm->tx.offset + conn->local.settings.write_stream_data_thresh) { + return 0; } - return 0; + return conn_call_extend_max_stream_data(conn, strm, fr->stream_id, + fr->max_stream_data); } /* * conn_recv_max_data processes received MAX_DATA frame |fr|. */ -static void conn_recv_max_data(ngtcp2_conn *conn, const ngtcp2_max_data *fr) { - conn->tx.max_offset = ngtcp2_max(conn->tx.max_offset, fr->max_data); +static int conn_recv_max_data(ngtcp2_conn *conn, const ngtcp2_max_data *fr) { + if (fr->max_data <= conn->tx.max_offset) { + return 0; + } + + conn->tx.max_offset = fr->max_data; + + if (conn->tx.max_offset <= + conn->tx.offset + conn->local.settings.write_stream_data_thresh) { + return 0; + } + + return conn_call_extend_max_data(conn, fr->max_data); } /* @@ -6028,7 +6173,7 @@ conn_emit_pending_crypto_data(ngtcp2_conn *conn, } for (;;) { - datalen = (size_t)ngtcp2_rob_data_at(strm->rx.rob, &data, rx_offset); + datalen = ngtcp2_rob_data_at(strm->rx.rob, &data, rx_offset); if (datalen == 0) { assert(rx_offset == ngtcp2_strm_rx_offset(strm)); return 0; @@ -6105,6 +6250,25 @@ static void conn_recv_path_challenge(ngtcp2_conn *conn, const ngtcp2_path *path, * conn_reset_congestion_state resets congestion state. */ static void conn_reset_congestion_state(ngtcp2_conn *conn, ngtcp2_tstamp ts) { + /* If no packet sent since the previous reset has been + acknowledged, congestion state is still in its initial state, + and the reset would only forget the in-flight packets, which + stay in rtb until they are acknowledged or declared lost. A + remote endpoint which keeps changing its address without sending + ACK would get a fresh initial congestion window per packet and + grow rtb without bound. Keep the congestion state as we do for + a port-only change. */ + if (conn->rst.delivered == 0 && conn->cstat.bytes_in_flight) { + conn->cstat.max_tx_udp_payload_size = + ngtcp2_conn_get_path_max_tx_udp_payload_size2(conn); + + /* The timer might have been canceled due to amplification limit + on the previous path. */ + ngtcp2_conn_set_loss_detection_timer(conn, ts); + + return; + } + conn_reset_conn_stat_cc(conn, &conn->cstat); if (conn->cc.reset) { @@ -6158,8 +6322,8 @@ static int conn_server_preferred_addr_migration(const ngtcp2_conn *conn, return 0; } -static int conn_recv_path_response(ngtcp2_conn *conn, const ngtcp2_pkt_hd *hd, - ngtcp2_path_response *fr, ngtcp2_tstamp ts) { +static int conn_recv_path_response(ngtcp2_conn *conn, ngtcp2_path_response *fr, + ngtcp2_tstamp ts) { int rv; ngtcp2_pv *pv = conn->pv, *npv = NULL; uint8_t ent_flags; @@ -6194,12 +6358,6 @@ static int conn_recv_path_response(ngtcp2_conn *conn, const ngtcp2_pkt_hd *hd, conn_reset_congestion_state(conn, ts); conn_reset_ecn_validation_state(conn); - - if (conn->server && conn->rx.preferred_addr.pkt_num == -1 && - conn_server_preferred_addr_migration( - conn, &conn->dcid.current.ps.path.local)) { - conn->rx.preferred_addr.pkt_num = hd->pkt_num; - } } assert(ngtcp2_path_eq(&pv->dcid.ps.path, &conn->dcid.current.ps.path)); @@ -6251,9 +6409,9 @@ static int conn_recv_path_response(ngtcp2_conn *conn, const ngtcp2_pkt_hd *hd, } if (pv->flags & NGTCP2_PV_FLAG_FALLBACK_PRESENT) { - /* Unset the flag bit so that conn_stop_pv does not retire + /* Set the flag bit so that conn_stop_pv does not retire DCID. */ - pv->flags &= (uint8_t)~NGTCP2_PV_FLAG_FALLBACK_PRESENT; + pv->flags |= NGTCP2_PV_FLAG_DONT_RETIRE_FALLBACK; } rv = conn_stop_pv(conn, ts); @@ -6463,6 +6621,9 @@ static int conn_process_buffered_protected_pkt(ngtcp2_conn *conn, * Generic QUIC protocol error. * NGTCP2_ERR_INTERNAL * Suspicious remote endpoint activity exceeded threshold. + * NGTCP2_ERR_AEAD_LIMIT_REACHED + * The number of packets that fail authentication reached the + * limit. * * In addition to the above error codes, error codes returned from * conn_recv_pkt are also returned. @@ -6713,7 +6874,7 @@ conn_recv_handshake_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, } if (hd.version != conn->client_chosen_version && - !conn->negotiated_version && conn->vneg.version != hd.version) { + !conn->negotiated_version) { if (!vneg_available_versions_includes(conn->vneg.available_versions, conn->vneg.available_versionslen, hd.version)) { @@ -6723,7 +6884,7 @@ conn_recv_handshake_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, /* Install new Initial keys using QUIC version = hd.version */ rv = conn_call_version_negotiation( conn, hd.version, - (conn->flags & NGTCP2_CONN_FLAG_RECV_RETRY) ? &conn->dcid.current.cid + (conn->flags & NGTCP2_CONN_FLAG_RECV_RETRY) ? &conn->retry_scid : &conn->rcid); if (rv != 0) { return rv; @@ -6850,6 +7011,14 @@ conn_recv_handshake_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, if (ngtcp2_err_is_fatal((int)nwrite)) { return nwrite; } + + /* Initial keys are not secret, and there is no limit for them. */ + if (hd.type == NGTCP2_PKT_HANDSHAKE && + ++conn->crypto.decryption_failure_count >= + pktns->crypto.ctx.max_decryption_failure) { + return NGTCP2_ERR_AEAD_LIMIT_REACHED; + } + ngtcp2_log_info(&conn->log, NGTCP2_LOG_EVENT_PKT, "could not decrypt packet payload"); return NGTCP2_ERR_DISCARD_PKT; @@ -6859,15 +7028,6 @@ conn_recv_handshake_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, return NGTCP2_ERR_PROTO; } - if (!conn->server && hd.version != conn->client_chosen_version && - !conn->negotiated_version) { - conn->negotiated_version = hd.version; - - ngtcp2_log_infof(&conn->log, NGTCP2_LOG_EVENT_CON, - "the negotiated version is 0x", - hexw(conn->negotiated_version, 8)); - } - payload = conn->crypto.decrypt_buf.base; payloadlen = (size_t)nwrite; @@ -6910,6 +7070,15 @@ conn_recv_handshake_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, return NGTCP2_ERR_PROTO; } + if (!conn->server && hd.version != conn->client_chosen_version && + !conn->negotiated_version) { + conn->negotiated_version = hd.version; + + ngtcp2_log_infof(&conn->log, NGTCP2_LOG_EVENT_CON, + "the negotiated version is 0x", + hexw(conn->negotiated_version, 8)); + } + if (hd.type == NGTCP2_PKT_INITIAL && !(conn->flags & NGTCP2_CONN_FLAG_INITIAL_PKT_PROCESSED)) { conn->flags |= NGTCP2_CONN_FLAG_INITIAL_PKT_PROCESSED; @@ -7212,7 +7381,7 @@ int ngtcp2_conn_init_stream(ngtcp2_conn *conn, ngtcp2_strm *strm, */ static int conn_emit_pending_stream_data(ngtcp2_conn *conn, ngtcp2_strm *strm, uint64_t rx_offset) { - uint64_t datalen; + size_t datalen; const uint8_t *data; int rv; uint64_t offset; @@ -7248,13 +7417,13 @@ static int conn_emit_pending_stream_data(ngtcp2_conn *conn, ngtcp2_strm *strm, if ((strm->flags & NGTCP2_STRM_FLAG_SHUT_RD) && rx_offset == strm->rx.last_offset) { sdflags |= NGTCP2_STREAM_DATA_FLAG_FIN; + strm->flags |= NGTCP2_STRM_FLAG_RX_FIN_DELIVERED; } if (!handshake_completed) { sdflags |= NGTCP2_STREAM_DATA_FLAG_0RTT; } - rv = conn_call_recv_stream_data(conn, strm, sdflags, offset, data, - (size_t)datalen); + rv = conn_call_recv_stream_data(conn, strm, sdflags, offset, data, datalen); if (rv != 0) { return rv; } @@ -7457,31 +7626,30 @@ static int conn_recv_stream(ngtcp2_conn *conn, const ngtcp2_stream *fr, uint64_t datalen = ngtcp2_vec_len(fr->data, fr->datacnt); uint32_t sdflags = NGTCP2_STREAM_DATA_FLAG_NONE; ngtcp2_ssize nwrite; - int new_strm = 0; local_stream = conn_local_stream(conn, fr->stream_id); bidi = bidi_stream(fr->stream_id); if (bidi) { if (local_stream) { - if (conn->local.bidi.next_stream_id <= fr->stream_id) { + if (conn->tx.bidi.next_stream_id <= fr->stream_id) { return NGTCP2_ERR_STREAM_STATE; } - } else if (conn->remote.bidi.max_streams < + } else if (conn->rx.bidi.max_streams < ngtcp2_ord_stream_id(fr->stream_id)) { return NGTCP2_ERR_STREAM_LIMIT; } - idtr = &conn->remote.bidi.idtr; + idtr = &conn->bidi.idtr; } else { if (local_stream) { return NGTCP2_ERR_STREAM_STATE; } - if (conn->remote.uni.max_streams < ngtcp2_ord_stream_id(fr->stream_id)) { + if (conn->rx.uni.max_streams < ngtcp2_ord_stream_id(fr->stream_id)) { return NGTCP2_ERR_STREAM_LIMIT; } - idtr = &conn->remote.uni.idtr; + idtr = &conn->uni.idtr; } if (NGTCP2_MAX_VARINT - datalen < fr->offset) { @@ -7524,8 +7692,6 @@ static int conn_recv_stream(ngtcp2_conn *conn, const ngtcp2_stream *fr, return rv; } - new_strm = 1; - rv = conn_call_stream_open(conn, strm); if (rv != 0) { return rv; @@ -7566,18 +7732,10 @@ static int conn_recv_stream(ngtcp2_conn *conn, const ngtcp2_stream *fr, if (fr->fin) { if (strm->flags & NGTCP2_STRM_FLAG_SHUT_RD) { if (strm->flags & NGTCP2_STRM_FLAG_RESET_STREAM_RECVED) { - if (ngtcp2_ratelim_drain(&conn->glitch_rlim, 1, ts) != 0) { - return NGTCP2_ERR_INTERNAL; - } - return 0; } if (rx_offset == fr_end_offset) { - if (!new_strm && ngtcp2_ratelim_drain(&conn->glitch_rlim, 1, ts) != 0) { - return NGTCP2_ERR_INTERNAL; - } - return 0; } } else { @@ -7588,19 +7746,8 @@ static int conn_recv_stream(ngtcp2_conn *conn, const ngtcp2_stream *fr, } else { strm->rx.last_offset = ngtcp2_max(strm->rx.last_offset, fr_end_offset); - if (fr_end_offset <= rx_offset) { - if (!new_strm && ngtcp2_ratelim_drain(&conn->glitch_rlim, 1, ts) != 0) { - return NGTCP2_ERR_INTERNAL; - } - - return 0; - } - - if (strm->flags & NGTCP2_STRM_FLAG_RESET_STREAM_RECVED) { - if (ngtcp2_ratelim_drain(&conn->glitch_rlim, 1, ts) != 0) { - return NGTCP2_ERR_INTERNAL; - } - + if (fr_end_offset <= rx_offset || + (strm->flags & NGTCP2_STRM_FLAG_RESET_STREAM_RECVED)) { return 0; } } @@ -7633,6 +7780,7 @@ static int conn_recv_stream(ngtcp2_conn *conn, const ngtcp2_stream *fr, if (fin) { sdflags |= NGTCP2_STREAM_DATA_FLAG_FIN; + strm->flags |= NGTCP2_STRM_FLAG_RX_FIN_DELIVERED; } if (!conn_is_tls_handshake_completed(conn)) { sdflags |= NGTCP2_STREAM_DATA_FLAG_0RTT; @@ -7654,10 +7802,6 @@ static int conn_recv_stream(ngtcp2_conn *conn, const ngtcp2_stream *fr, if (nwrite < 0) { return (int)nwrite; } - - if (nwrite == 0 && ngtcp2_ratelim_drain(&conn->glitch_rlim, 1, ts) != 0) { - return NGTCP2_ERR_INTERNAL; - } } return ngtcp2_conn_close_stream_if_shut_rdwr(conn, strm); } @@ -7678,13 +7822,7 @@ static int conn_reset_stream(ngtcp2_conn *conn, ngtcp2_strm *strm, NGTCP2_STRM_FLAG_TX_RESET_STREAM_APP_ERROR_CODE_SET; strm->tx.reset_stream_app_error_code = app_error_code; - if (ngtcp2_strm_is_tx_queued(strm)) { - return 0; - } - - strm->cycle = ngtcp2_conn_tx_strmq_first_cycle(conn); - - return ngtcp2_conn_tx_strmq_push(conn, strm); + return ngtcp2_conn_tx_strmq_push_if_not(conn, strm); } /* @@ -7703,13 +7841,7 @@ static int conn_stop_sending(ngtcp2_conn *conn, ngtcp2_strm *strm, NGTCP2_STRM_FLAG_TX_STOP_SENDING_APP_ERROR_CODE_SET; strm->tx.stop_sending_app_error_code = app_error_code; - if (ngtcp2_strm_is_tx_queued(strm)) { - return 0; - } - - strm->cycle = ngtcp2_conn_tx_strmq_first_cycle(conn); - - return ngtcp2_conn_tx_strmq_push(conn, strm); + return ngtcp2_conn_tx_strmq_push_if_not(conn, strm); } /* @@ -7739,13 +7871,11 @@ handle_max_remote_streams_extension(uint64_t *punsent_max_remote_streams, * * NGTCP2_ERR_STREAM_STATE * RESET_STREAM frame is received to the local stream which is not - * initiated. + * initiated; or RESET_STREAM frame is received to the local + * unidirectional stream * NGTCP2_ERR_STREAM_LIMIT * RESET_STREAM frame has remote stream ID which is strictly * greater than the allowed limit. - * NGTCP2_ERR_PROTO - * RESET_STREAM frame is received to the local unidirectional - * stream * NGTCP2_ERR_NOMEM * Out of memory. * NGTCP2_ERR_CALLBACK_FAILURE @@ -7771,24 +7901,24 @@ static int conn_recv_reset_stream(ngtcp2_conn *conn, /* TODO share this piece of code */ if (bidi) { if (local_stream) { - if (conn->local.bidi.next_stream_id <= fr->stream_id) { + if (conn->tx.bidi.next_stream_id <= fr->stream_id) { return NGTCP2_ERR_STREAM_STATE; } - } else if (conn->remote.bidi.max_streams < + } else if (conn->rx.bidi.max_streams < ngtcp2_ord_stream_id(fr->stream_id)) { return NGTCP2_ERR_STREAM_LIMIT; } - idtr = &conn->remote.bidi.idtr; + idtr = &conn->bidi.idtr; } else { if (local_stream) { - return NGTCP2_ERR_PROTO; + return NGTCP2_ERR_STREAM_STATE; } - if (conn->remote.uni.max_streams < ngtcp2_ord_stream_id(fr->stream_id)) { + if (conn->rx.uni.max_streams < ngtcp2_ord_stream_id(fr->stream_id)) { return NGTCP2_ERR_STREAM_LIMIT; } - idtr = &conn->remote.uni.idtr; + idtr = &conn->uni.idtr; } if (NGTCP2_MAX_VARINT < fr->final_size) { @@ -7841,7 +7971,7 @@ static int conn_recv_reset_stream(ngtcp2_conn *conn, } } - if ((strm->flags & NGTCP2_STRM_FLAG_SHUT_RD)) { + if (strm->flags & NGTCP2_STRM_FLAG_SHUT_RD) { if (strm->rx.last_offset != fr->final_size) { return NGTCP2_ERR_FINAL_SIZE; } @@ -7850,10 +7980,6 @@ static int conn_recv_reset_stream(ngtcp2_conn *conn, } if (strm->flags & NGTCP2_STRM_FLAG_RESET_STREAM_RECVED) { - if (ngtcp2_ratelim_drain(&conn->glitch_rlim, 1, ts) != 0) { - return NGTCP2_ERR_INTERNAL; - } - return 0; } @@ -7875,11 +8001,6 @@ static int conn_recv_reset_stream(ngtcp2_conn *conn, conn->rx.offset += datalen; - /* Extend connection flow control window for the amount of data - which are not passed to application. */ - ngtcp2_conn_extend_max_offset(conn, - fr->final_size - ngtcp2_strm_rx_offset(strm)); - strm->rx.last_offset = fr->final_size; strm->flags |= NGTCP2_STRM_FLAG_SHUT_RD | NGTCP2_STRM_FLAG_RESET_STREAM_RECVED | @@ -7922,21 +8043,21 @@ static int conn_recv_stop_sending(ngtcp2_conn *conn, if (bidi) { if (local_stream) { - if (conn->local.bidi.next_stream_id <= fr->stream_id) { + if (conn->tx.bidi.next_stream_id <= fr->stream_id) { return NGTCP2_ERR_STREAM_STATE; } - } else if (conn->remote.bidi.max_streams < + } else if (conn->rx.bidi.max_streams < ngtcp2_ord_stream_id(fr->stream_id)) { return NGTCP2_ERR_STREAM_LIMIT; } - idtr = &conn->remote.bidi.idtr; + idtr = &conn->bidi.idtr; } else { - if (!local_stream || conn->local.uni.next_stream_id <= fr->stream_id) { + if (!local_stream || conn->tx.uni.next_stream_id <= fr->stream_id) { return NGTCP2_ERR_STREAM_STATE; } - idtr = &conn->remote.uni.idtr; + idtr = &conn->uni.idtr; } strm = ngtcp2_conn_find_stream(conn, fr->stream_id); @@ -7981,10 +8102,6 @@ static int conn_recv_stop_sending(ngtcp2_conn *conn, } if (strm->flags & NGTCP2_STRM_FLAG_STOP_SENDING_RECVED) { - if (ngtcp2_ratelim_drain(&conn->glitch_rlim, 1, ts) != 0) { - return NGTCP2_ERR_INTERNAL; - } - return 0; } @@ -8013,7 +8130,7 @@ static int conn_recv_stop_sending(ngtcp2_conn *conn, ngtcp2_strm_streamfrq_clear(strm); - return ngtcp2_conn_close_stream_if_shut_rdwr(conn, strm); + return 0; } /* @@ -8087,25 +8204,21 @@ static int conn_on_stateless_reset(ngtcp2_conn *conn, const ngtcp2_path *path, */ static int conn_recv_max_streams(ngtcp2_conn *conn, const ngtcp2_max_streams *fr) { - uint64_t n; - if (fr->max_streams > NGTCP2_MAX_STREAMS) { return NGTCP2_ERR_FRAME_ENCODING; } - n = ngtcp2_min(fr->max_streams, NGTCP2_MAX_STREAMS); - if (fr->type == NGTCP2_FRAME_MAX_STREAMS_BIDI) { - if (conn->local.bidi.max_streams < n) { - conn->local.bidi.max_streams = n; - return conn_call_extend_max_local_streams_bidi(conn, n); + if (conn->tx.bidi.max_streams < fr->max_streams) { + conn->tx.bidi.max_streams = fr->max_streams; + return conn_call_extend_max_local_streams_bidi(conn, fr->max_streams); } return 0; } - if (conn->local.uni.max_streams < n) { - conn->local.uni.max_streams = n; - return conn_call_extend_max_local_streams_uni(conn, n); + if (conn->tx.uni.max_streams < fr->max_streams) { + conn->tx.uni.max_streams = fr->max_streams; + return conn_call_extend_max_local_streams_uni(conn, fr->max_streams); } return 0; } @@ -8118,52 +8231,55 @@ static int conn_recv_max_streams(ngtcp2_conn *conn, * negative error codes: * * NGTCP2_ERR_PROTO - * |fr| has the duplicated sequence number with different CID or - * token; or DCID is zero-length. + * |fr| contains the duplicated Connection ID when |fr|->seq is + * unique; or DCID is zero-length. */ static int conn_recv_new_connection_id(ngtcp2_conn *conn, const ngtcp2_new_connection_id *fr) { size_t len; ngtcp2_pv *pv = conn->pv; int rv; - int found = 0; size_t extra_dcid = 0; if (conn->dcid.current.cid.datalen == 0) { return NGTCP2_ERR_PROTO; } - if (fr->retire_prior_to > fr->seq) { - return NGTCP2_ERR_FRAME_ENCODING; + if (ngtcp2_gaptr_is_pushed(&conn->dcid.seqgap, fr->seq, 1)) { + return 0; } - rv = ngtcp2_dcid_verify_uniqueness(&conn->dcid.current, fr->seq, &fr->cid, - &fr->token); + rv = ngtcp2_gaptr_push(&conn->dcid.seqgap, fr->seq, 1); if (rv != 0) { return rv; } - if (ngtcp2_cid_eq(&conn->dcid.current.cid, &fr->cid)) { - found = 1; - } - if (pv) { - rv = - ngtcp2_dcid_verify_uniqueness(&pv->dcid, fr->seq, &fr->cid, &fr->token); - if (rv != 0) { - return rv; - } - if (ngtcp2_cid_eq(&pv->dcid.cid, &fr->cid)) { - found = 1; - } + if (ngtcp2_ksl_len(&conn->dcid.seqgap.gap) > 32) { + ngtcp2_gaptr_drop_first_gap(&conn->dcid.seqgap); } - rv = ngtcp2_dcidtr_verify_token_uniqueness(&conn->dcid.dtr, &found, fr->seq, - &fr->cid, &fr->token); - if (rv != 0) { - return rv; - } + /* We now assume that fr->seq is unique. */ - if (conn->dcid.retire_prior_to < fr->retire_prior_to) { + if (fr->retire_prior_to > fr->seq) { + return NGTCP2_ERR_FRAME_ENCODING; + } + + if (ngtcp2_cid_eq(&conn->dcid.current.cid, &fr->cid)) { + return NGTCP2_ERR_PROTO; + } + + if (pv && (ngtcp2_cid_eq(&pv->dcid.cid, &fr->cid) || + ((pv->flags & NGTCP2_PV_FLAG_FALLBACK_PRESENT) && + ngtcp2_cid_eq(&pv->fallback_dcid.cid, &fr->cid)))) { + return NGTCP2_ERR_PROTO; + } + + rv = ngtcp2_dcidtr_verify_cid_uniqueness(&conn->dcid.dtr, &fr->cid); + if (rv != 0) { + return rv; + } + + if (conn->dcid.retire_prior_to < fr->retire_prior_to) { conn->dcid.retire_prior_to = fr->retire_prior_to; rv = ngtcp2_dcidtr_retire_inactive_dcid_prior_to( @@ -8192,23 +8308,6 @@ static int conn_recv_new_connection_id(ngtcp2_conn *conn, return conn_enqueue_retire_connection_id(conn, fr->seq); } - if (found) { - return 0; - } - - if (ngtcp2_gaptr_is_pushed(&conn->dcid.seqgap, fr->seq, 1)) { - return 0; - } - - rv = ngtcp2_gaptr_push(&conn->dcid.seqgap, fr->seq, 1); - if (rv != 0) { - return rv; - } - - if (ngtcp2_ksl_len(&conn->dcid.seqgap.gap) > 32) { - ngtcp2_gaptr_drop_first_gap(&conn->dcid.seqgap); - } - len = ngtcp2_dcidtr_inactive_len(&conn->dcid.dtr); if (conn->dcid.current.seq >= conn->dcid.retire_prior_to) { @@ -8426,13 +8525,13 @@ static int conn_recv_new_token(ngtcp2_conn *conn, const ngtcp2_new_token *fr) { * This function returns 0 if it succeeds, or one of the following * negative error codes: * - * NGTCP2_ERR_FRAME_ENCODING + * NGTCP2_ERR_STREAM_LIMIT * Maximum Streams is larger than advertised value. */ static int conn_recv_streams_blocked_bidi(ngtcp2_conn *conn, ngtcp2_streams_blocked *fr) { - if (fr->max_streams > conn->remote.bidi.max_streams) { - return NGTCP2_ERR_FRAME_ENCODING; + if (fr->max_streams > conn->rx.bidi.max_streams) { + return NGTCP2_ERR_STREAM_LIMIT; } return 0; @@ -8445,13 +8544,13 @@ static int conn_recv_streams_blocked_bidi(ngtcp2_conn *conn, * This function returns 0 if it succeeds, or one of the following * negative error codes: * - * NGTCP2_ERR_FRAME_ENCODING + * NGTCP2_ERR_STREAM_LIMIT * Maximum Streams is larger than advertised value. */ static int conn_recv_streams_blocked_uni(ngtcp2_conn *conn, ngtcp2_streams_blocked *fr) { - if (fr->max_streams > conn->remote.uni.max_streams) { - return NGTCP2_ERR_FRAME_ENCODING; + if (fr->max_streams > conn->rx.uni.max_streams) { + return NGTCP2_ERR_STREAM_LIMIT; } return 0; @@ -8490,24 +8589,24 @@ static int conn_recv_stream_data_blocked(ngtcp2_conn *conn, if (bidi) { if (local_stream) { - if (conn->local.bidi.next_stream_id <= fr->stream_id) { + if (conn->tx.bidi.next_stream_id <= fr->stream_id) { return NGTCP2_ERR_STREAM_STATE; } - } else if (conn->remote.bidi.max_streams < + } else if (conn->rx.bidi.max_streams < ngtcp2_ord_stream_id(fr->stream_id)) { return NGTCP2_ERR_STREAM_LIMIT; } - idtr = &conn->remote.bidi.idtr; + idtr = &conn->bidi.idtr; } else { if (local_stream) { return NGTCP2_ERR_STREAM_STATE; } - if (conn->remote.uni.max_streams < ngtcp2_ord_stream_id(fr->stream_id)) { + if (conn->rx.uni.max_streams < ngtcp2_ord_stream_id(fr->stream_id)) { return NGTCP2_ERR_STREAM_LIMIT; } - idtr = &conn->remote.uni.idtr; + idtr = &conn->uni.idtr; } strm = ngtcp2_conn_find_stream(conn, fr->stream_id); @@ -8542,11 +8641,11 @@ static int conn_recv_stream_data_blocked(ngtcp2_conn *conn, } } - if (strm->rx.max_offset < fr->offset) { + if (strm->rx.max_offset < fr->max_stream_data) { return NGTCP2_ERR_FLOW_CONTROL; } - if (fr->offset <= strm->rx.last_offset) { + if (fr->max_stream_data <= strm->rx.last_offset) { return 0; } @@ -8554,7 +8653,7 @@ static int conn_recv_stream_data_blocked(ngtcp2_conn *conn, return NGTCP2_ERR_FINAL_SIZE; } - datalen = fr->offset - strm->rx.last_offset; + datalen = fr->max_stream_data - strm->rx.last_offset; if (datalen) { if (conn_max_data_violated(conn, datalen)) { return NGTCP2_ERR_FLOW_CONTROL; @@ -8563,7 +8662,7 @@ static int conn_recv_stream_data_blocked(ngtcp2_conn *conn, conn->rx.offset += datalen; } - strm->rx.last_offset = fr->offset; + strm->rx.last_offset = fr->max_stream_data; return 0; } @@ -8579,7 +8678,7 @@ static int conn_recv_stream_data_blocked(ngtcp2_conn *conn, * It violates connection-level flow control limit. */ static int conn_recv_data_blocked(ngtcp2_conn *conn, ngtcp2_data_blocked *fr) { - if (conn->rx.max_offset < fr->offset) { + if (conn->rx.max_offset < fr->max_data) { return NGTCP2_ERR_FLOW_CONTROL; } @@ -8651,7 +8750,8 @@ static int conn_select_preferred_addr(ngtcp2_conn *conn) { * negative error codes: * * NGTCP2_ERR_PROTO - * Server received HANDSHAKE_DONE frame. + * Server received HANDSHAKE_DONE frame; or client received it + * before it could send Finished. * NGTCP2_ERR_NOMEM * Out of memory. * NGTCP2_ERR_CALLBACK_FAILURE @@ -8668,6 +8768,17 @@ static int conn_recv_handshake_done(ngtcp2_conn *conn, ngtcp2_tstamp ts) { return 0; } + /* Server sends HANDSHAKE_DONE only after it has received client + Finished (RFC 9001 Section 4.1.2). Client moves to + post-handshake state and discards Initial packet number space no + later than it sends Finished. If either has not happened yet, + the remote endpoint is misbehaving, and Handshake packet number + space is still in use by conn_read_handshake and + conn_write_handshake, which must not see it discarded. */ + if (conn->state != NGTCP2_CS_POST_HANDSHAKE || conn->in_pktns) { + return NGTCP2_ERR_PROTO; + } + conn->flags |= NGTCP2_CONN_FLAG_HANDSHAKE_CONFIRMED | NGTCP2_CONN_FLAG_SERVER_ADDR_VERIFIED; @@ -8836,6 +8947,33 @@ static void conn_rotate_keys(ngtcp2_conn *conn, int64_t pkt_num, } } +/* + * conn_handle_unconfirmed_key_update_from_local deals with key update + * which has not been confirmed yet and initiated by the local + * endpoint. |ckm| is the key which decrypted an incoming packet. + * + * If key update was initiated by the local endpoint, receiving a + * packet encrypted with the new key tells that the remote endpoint + * has updated its keys. The remote endpoint may initiate the next + * key update as soon as that packet is acknowledged. Do not wait for + * an acknowledgement for a packet that the local endpoint sent, which + * might be lost. + */ +static void conn_handle_unconfirmed_key_update_from_local( + ngtcp2_conn *conn, const ngtcp2_crypto_km *ckm, ngtcp2_tstamp ts) { + if (!(conn->flags & NGTCP2_CONN_FLAG_KEY_UPDATE_NOT_CONFIRMED) || + !(conn->flags & NGTCP2_CONN_FLAG_KEY_UPDATE_INITIATOR) || + ckm != conn->pktns.crypto.rx.ckm) { + return; + } + + conn->flags &= (uint32_t)~(NGTCP2_CONN_FLAG_KEY_UPDATE_NOT_CONFIRMED | + NGTCP2_CONN_FLAG_KEY_UPDATE_INITIATOR); + conn->crypto.key_update.confirmed_ts = ts; + + ngtcp2_log_info(&conn->log, NGTCP2_LOG_EVENT_CRY, "key update confirmed"); +} + /* * conn_path_validation_in_progress returns nonzero if path validation * against |path| is underway. Ignore the path validation with @@ -8850,23 +8988,57 @@ static int conn_path_validation_in_progress(const ngtcp2_conn *conn, !(pv->flags & NGTCP2_PV_FLAG_DONT_CARE); } +/* + * conn_revert_client_migration handles the case that server observed + * that client is migrated back to the original path during the path + * validation or after that. + */ +static int conn_revert_client_migration(ngtcp2_conn *conn, + const ngtcp2_dcid *dcid, + size_t dgramlen, ngtcp2_tstamp ts) { + int rv; + + ngtcp2_log_info(&conn->log, NGTCP2_LOG_EVENT_PTV, + "path is migrated back to the original path"); + + ngtcp2_dcid_copy(&conn->dcid.current, dcid); + conn_reset_congestion_state(conn, ts); + conn->dcid.current.bytes_recv += dgramlen; + conn_reset_ecn_validation_state(conn); + + rv = conn_abort_pv(conn, ts); + if (rv != 0) { + return rv; + } + + /* Run PMTUD just in case if it is prematurely aborted */ + if (!conn->pmtud && !conn->local.settings.no_pmtud) { + return conn_start_pmtud(conn); + } + + return 0; +} + /* * conn_recv_non_probing_pkt_on_new_path is called when non-probing * packet is received via new path. It starts path validation against - * the new path. + * the new path. |scid_seq| is the sequence number of the connection + * ID in Destination Connection ID field of the packet. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * NGTCP2_ERR_CONN_ID_BLOCKED * No DCID is available + * NGTCP2_ERR_CONNECTION_ID_LIMIT + * The number of unacknowledged retirement exceeds the limit. * NGTCP2_ERR_NOMEM * Out of memory */ static int conn_recv_non_probing_pkt_on_new_path(ngtcp2_conn *conn, const ngtcp2_path *path, size_t dgramlen, - int new_cid_used, + uint64_t scid_seq, ngtcp2_tstamp ts) { ngtcp2_dcid dcid; ngtcp2_pv *pv = NULL; @@ -8879,31 +9051,22 @@ static int conn_recv_non_probing_pkt_on_new_path(ngtcp2_conn *conn, assert(conn->server); - if (conn->pv && (conn->pv->flags & NGTCP2_PV_FLAG_FALLBACK_PRESENT) && - ngtcp2_path_eq(&conn->pv->fallback_dcid.ps.path, path)) { - /* If new path equals fallback path, that means connection - migrated back to the original path. Fallback path is - considered to be validated. */ - ngtcp2_log_info(&conn->log, NGTCP2_LOG_EVENT_PTV, - "path is migrated back to the original path"); - ngtcp2_dcid_copy(&conn->dcid.current, &conn->pv->fallback_dcid); - conn_reset_congestion_state(conn, ts); - conn->dcid.current.bytes_recv += dgramlen; - conn_reset_ecn_validation_state(conn); - - rv = conn_abort_pv(conn, ts); - if (rv != 0) { - return rv; - } - - /* Run PMTUD just in case if it is prematurely aborted */ - assert(!conn->pmtud); - - if (!conn->local.settings.no_pmtud) { - return conn_start_pmtud(conn); + if (conn->pv) { + if ((conn->pv->flags & NGTCP2_PV_FLAG_FALLBACK_PRESENT) && + ngtcp2_path_eq(&conn->pv->fallback_dcid.ps.path, path)) { + /* If new path equals fallback path, that means connection + migrated back to the original path. Fallback path is + considered to be validated. */ + return conn_revert_client_migration(conn, &conn->pv->fallback_dcid, + dgramlen, ts); + } + + if ((conn->pv->flags & NGTCP2_PV_FLAG_DONT_CARE) && + ngtcp2_path_eq(&conn->pv->dcid.ps.path, path)) { + /* Client migrated back to the original path after successful + validation. */ + return conn_revert_client_migration(conn, &conn->pv->dcid, dgramlen, ts); } - - return 0; } remote_addr_cmp = @@ -8932,6 +9095,36 @@ static int conn_recv_non_probing_pkt_on_new_path(ngtcp2_conn *conn, ngtcp2_log_info(&conn->log, NGTCP2_LOG_EVENT_CON, "non-probing packet was received from new remote address"); + if (conn->pv) { + /* Stop the current path validation. If the current path is not + validated, and pv has fallback path, set the fallback path to + the current path. */ + if (!(conn->dcid.current.flags & NGTCP2_DCID_FLAG_PATH_VALIDATED) && + (conn->pv->flags & NGTCP2_PV_FLAG_FALLBACK_PRESENT)) { + if (conn->dcid.current.cid.datalen && + conn->dcid.current.seq != conn->pv->dcid.seq && + conn->dcid.current.seq != conn->pv->fallback_dcid.seq) { + rv = conn_retire_active_dcid(conn, &conn->dcid.current, ts); + if (rv != 0) { + return rv; + } + } + + ngtcp2_dcid_copy(&conn->dcid.current, &conn->pv->fallback_dcid); + conn_reset_congestion_state(conn, ts); + conn_reset_ecn_validation_state(conn); + } + + ngtcp2_log_info( + &conn->log, NGTCP2_LOG_EVENT_PTV, + "path migration is aborted because new migration has started"); + + rv = conn_abort_pv(conn, ts); + if (rv != 0) { + return rv; + } + } + if (ngtcp2_dcidtr_pop_bound_dcid(&conn->dcid.dtr, &dcid, path) == 0) { ngtcp2_log_info(&conn->log, NGTCP2_LOG_EVENT_CON, "Found DCID which has already been bound to the new path"); @@ -8944,7 +9137,8 @@ static int conn_recv_non_probing_pkt_on_new_path(ngtcp2_conn *conn, } } else { if (conn->dcid.current.cid.datalen && - ((new_cid_used && remote_addr_cmp) || !local_addr_eq)) { + ((scid_seq != conn->dcid.current.scid_seq && remote_addr_cmp) || + !local_addr_eq)) { /* New DCID is required. */ if (ngtcp2_dcidtr_unused_empty(&conn->dcid.dtr)) { return NGTCP2_ERR_CONN_ID_BLOCKED; @@ -8963,12 +9157,22 @@ static int conn_recv_non_probing_pkt_on_new_path(ngtcp2_conn *conn, dcid.bytes_sent = 0; dcid.bytes_recv = 0; dcid.flags &= (uint8_t)~NGTCP2_DCID_FLAG_PATH_VALIDATED; + + /* The copy carries the old path's max UDP payload size, which + may not hold for a new IP address; a port-only change + (e.g. NAT rebinding) keeps it, as it keeps congestion + state. */ + if (!local_addr_eq || (remote_addr_cmp & (NGTCP2_ADDR_CMP_FLAG_ADDR | + NGTCP2_ADDR_CMP_FLAG_FAMILY))) { + dcid.max_udp_payload_size = NGTCP2_MAX_UDP_PAYLOAD_SIZE; + } } ngtcp2_dcid_set_path(&dcid, path); } dcid.bytes_recv += dgramlen; + dcid.scid_seq = scid_seq; validated_path = ngtcp2_conn_find_path_history(conn, path, ts); if (!validated_path) { @@ -8980,20 +9184,34 @@ static int conn_recv_non_probing_pkt_on_new_path(ngtcp2_conn *conn, return rv; } - if (conn->pv && (conn->pv->flags & NGTCP2_PV_FLAG_FALLBACK_PRESENT)) { - ngtcp2_pv_set_fallback(pv, &conn->pv->fallback_dcid, - conn->pv->fallback_pto); - /* Unset the flag bit so that conn_stop_pv does not retire - DCID. */ - conn->pv->flags &= (uint8_t)~NGTCP2_PV_FLAG_FALLBACK_PRESENT; - } else if (!pref_addr_migration) { + if (!pref_addr_migration) { ngtcp2_pv_set_fallback(pv, &conn->dcid.current, pto); } + + conn->pv = pv; } if (!pref_addr_migration || validated_path) { + /* Restore the maximum UDP payload size of the validated path + before resetting congestion state because it derives its + parameters (e.g., send_quantum lower bound) from it. */ + if (validated_path) { + ngtcp2_dcid_apply_validated_path(&dcid, validated_path); + } + if (conn->dcid.current.flags & NGTCP2_DCID_FLAG_PATH_VALIDATED) { ngtcp2_conn_add_path_history(conn, &conn->dcid.current, ts); + /* Now validated_path may point to the different object. */ + } + + if (conn->dcid.current.cid.datalen && dcid.seq != conn->dcid.current.seq && + (!pv || (pv->dcid.seq != conn->dcid.current.seq && + (!(pv->flags & NGTCP2_PV_FLAG_FALLBACK_PRESENT) || + pv->fallback_dcid.seq != conn->dcid.current.seq)))) { + rv = conn_retire_active_dcid(conn, &conn->dcid.current, ts); + if (rv != 0) { + return rv; + } } ngtcp2_dcid_copy(&conn->dcid.current, &dcid); @@ -9001,37 +9219,30 @@ static int conn_recv_non_probing_pkt_on_new_path(ngtcp2_conn *conn, if (!local_addr_eq || (remote_addr_cmp & (NGTCP2_ADDR_CMP_FLAG_ADDR | NGTCP2_ADDR_CMP_FLAG_FAMILY))) { conn_reset_congestion_state(conn, ts); + } else { + /* Congestion state is kept, but the maximum UDP payload size of + the path may have changed. */ + conn->cstat.max_tx_udp_payload_size = + ngtcp2_conn_get_path_max_tx_udp_payload_size2(conn); } conn_reset_ecn_validation_state(conn); ngtcp2_conn_stop_pmtud(conn); - if (validated_path) { - ngtcp2_dcid_apply_validated_path(&conn->dcid.current, validated_path); - - if (!conn->local.settings.no_pmtud) { - rv = conn_start_pmtud(conn); - if (rv != 0) { - return rv; - } + if (validated_path && !conn->local.settings.no_pmtud) { + rv = conn_start_pmtud(conn); + if (rv != 0) { + return rv; } } } if (conn->pv) { - ngtcp2_log_info( - &conn->log, NGTCP2_LOG_EVENT_PTV, - "path migration is aborted because new migration has started"); - rv = conn_abort_pv(conn, ts); - if (rv != 0) { - return rv; - } + return conn_call_begin_path_validation(conn, conn->pv); } - conn->pv = pv; - - return conn_call_begin_path_validation(conn, conn->pv); + return 0; } /* @@ -9045,6 +9256,8 @@ static int conn_recv_non_probing_pkt_on_new_path(ngtcp2_conn *conn, * * NGTCP2_ERR_CONN_ID_BLOCKED * No unused DCID is available + * NGTCP2_ERR_CONNECTION_ID_LIMIT + * The number of unacknowledged retirement exceeds the limit. * NGTCP2_ERR_NOMEM * Out of memory */ @@ -9244,6 +9457,9 @@ conn_recv_delayed_handshake_pkt(ngtcp2_conn *conn, const ngtcp2_pkt_info *pi, * Frame has strictly larger end offset than it is permitted. * NGTCP2_ERR_INTERNAL * Suspicious remote endpoint activity exceeded threshold. + * NGTCP2_ERR_AEAD_LIMIT_REACHED + * The number of packets that fail authentication reached the + * limit. */ static ngtcp2_ssize conn_recv_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, const ngtcp2_pkt_info *pi, const uint8_t *pkt, @@ -9269,7 +9485,7 @@ static ngtcp2_ssize conn_recv_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, int key_phase_bit_changed = 0; int force_decrypt_failure = 0; int recv_ncid = 0; - int new_cid_used = 0; + uint64_t scid_seq = 0; int path_challenge_recved = 0; size_t num_ack_processed = 0; @@ -9336,7 +9552,13 @@ static ngtcp2_ssize conn_recv_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, return NGTCP2_ERR_DISCARD_PKT; } - if (!conn->early.ckm) { + /* TLS stack might install 0-RTT key before it decides to send + HelloRetryRequest. Local transport parameters are not + committed and remote transport parameters are not applied + until 1-RTT tx key is installed. Do not process 0-RTT packet + until then. Server which sends HelloRetryRequest must not + process 0-RTT packets anyway. */ + if (!conn->early.ckm || !conn->pktns.crypto.tx.ckm) { return (ngtcp2_ssize)pktlen; } @@ -9406,17 +9628,6 @@ static ngtcp2_ssize conn_recv_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, ngtcp2_log_rx_pkt_hd(&conn->log, &hd); if (hd.type == NGTCP2_PKT_1RTT) { - if (conn->server && conn->rx.preferred_addr.pkt_num != -1 && - conn->rx.preferred_addr.pkt_num < hd.pkt_num && - ngtcp2_sockaddr_eq((const ngtcp2_sockaddr *)&conn->hs_local_addr, - path->local.addr)) { - ngtcp2_log_infof( - &conn->log, NGTCP2_LOG_EVENT_PKT, "pkt=", hd.pkt_num, - " is discarded because it was received on handshake local " - "address after preferred address migration"); - return NGTCP2_ERR_DISCARD_PKT; - } - key_phase_bit_changed = conn_key_phase_changed(conn, &hd); } @@ -9469,9 +9680,12 @@ static ngtcp2_ssize conn_recv_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, assert(NGTCP2_ERR_DECRYPT == nwrite); - if (hd.type == NGTCP2_PKT_1RTT && - ++conn->crypto.decryption_failure_count >= - pktns->crypto.ctx.max_decryption_failure) { + /* Packets that fail authentication are counted across all keys, + including Handshake and 0-RTT keys. */ + if (++conn->crypto.decryption_failure_count >= + (hd.type == NGTCP2_PKT_0RTT + ? conn->early.ctx.max_decryption_failure + : pktns->crypto.ctx.max_decryption_failure)) { return NGTCP2_ERR_AEAD_LIMIT_REACHED; } @@ -9546,7 +9760,7 @@ static ngtcp2_ssize conn_recv_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, ngtcp2_unreachable(); } } else { - rv = conn_verify_dcid(conn, &new_cid_used, &hd); + rv = conn_verify_dcid(conn, &scid_seq, &hd); if (rv != 0) { if (ngtcp2_err_is_fatal(rv)) { return rv; @@ -9708,7 +9922,7 @@ static ngtcp2_ssize conn_recv_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, path_challenge_recved = 1; break; case NGTCP2_FRAME_PATH_RESPONSE: - rv = conn_recv_path_response(conn, &hd, &fr.path_response, ts); + rv = conn_recv_path_response(conn, &fr.path_response, ts); if (rv != 0) { return rv; } @@ -9800,28 +10014,27 @@ static ngtcp2_ssize conn_recv_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, !ngtcp2_path_eq(&conn->dcid.current.ps.path, path)) { if (non_probing_pkt && pktns->acktr.max_pkt_num < hd.pkt_num && !conn_path_validation_in_progress(conn, path)) { - rv = conn_recv_non_probing_pkt_on_new_path(conn, path, dgramlen, - new_cid_used, ts); - if (rv != 0) { - if (ngtcp2_err_is_fatal(rv)) { - return rv; - } - - /* DCID is not available. Just continue. */ - assert(NGTCP2_ERR_CONN_ID_BLOCKED == rv); + rv = conn_recv_non_probing_pkt_on_new_path(conn, path, dgramlen, scid_seq, + ts); + /* If DCID is not available, just continue. */ + if (rv != 0 && rv != NGTCP2_ERR_CONN_ID_BLOCKED) { + return rv; } } else { rv = conn_recv_pkt_from_new_path(conn, path, dgramlen, path_challenge_recved, ts); - if (rv != 0) { - if (ngtcp2_err_is_fatal(rv)) { - return rv; - } - - /* DCID is not available. Just continue. */ - assert(NGTCP2_ERR_CONN_ID_BLOCKED == rv); + /* If DCID is not available, just continue. */ + if (rv != 0 && rv != NGTCP2_ERR_CONN_ID_BLOCKED) { + return rv; } } + } else if (!conn->server && hd.type == NGTCP2_PKT_1RTT && conn->pv && + !ngtcp2_path_eq(&conn->dcid.current.ps.path, path) && + ngtcp2_path_eq(&conn->pv->dcid.ps.path, path)) { + /* Account for the bytes received from the path which client is + validating so that PATH_RESPONSE sent to that path is subject + to the anti-amplification limit. */ + conn->pv->dcid.bytes_recv += dgramlen; } if (hd.type == NGTCP2_PKT_1RTT) { @@ -9832,12 +10045,18 @@ static ngtcp2_ssize conn_recv_pkt(ngtcp2_conn *conn, const ngtcp2_path *path, ckm->pkt_num = hd.pkt_num; } + conn_handle_unconfirmed_key_update_from_local(conn, ckm, ts); + if (conn->server && conn->early.ckm && conn->early.discard_started_ts == UINT64_MAX) { conn->early.discard_started_ts = ts; } if (ngtcp2_path_eq(&conn->dcid.current.ps.path, path)) { + if (pktns->acktr.max_pkt_num < hd.pkt_num) { + conn->dcid.current.scid_seq = scid_seq; + } + conn_update_keep_alive_last_ts(conn, ts); } } @@ -9949,8 +10168,8 @@ static void conn_sync_stream_id_limit(ngtcp2_conn *conn) { assert(params); - conn->local.bidi.max_streams = params->initial_max_streams_bidi; - conn->local.uni.max_streams = params->initial_max_streams_uni; + conn->tx.bidi.max_streams = params->initial_max_streams_bidi; + conn->tx.uni.max_streams = params->initial_max_streams_uni; } static int strm_set_max_offset(void *data, void *ptr) { @@ -10014,16 +10233,22 @@ static int conn_handshake_completed(ngtcp2_conn *conn) { return rv; } - if (conn->local.bidi.max_streams > 0) { - rv = conn_call_extend_max_local_streams_bidi(conn, - conn->local.bidi.max_streams); + if (conn->tx.bidi.max_streams > 0) { + rv = + conn_call_extend_max_local_streams_bidi(conn, conn->tx.bidi.max_streams); if (rv != 0) { return rv; } } - if (conn->local.uni.max_streams > 0) { - rv = - conn_call_extend_max_local_streams_uni(conn, conn->local.uni.max_streams); + if (conn->tx.uni.max_streams > 0) { + rv = conn_call_extend_max_local_streams_uni(conn, conn->tx.uni.max_streams); + if (rv != 0) { + return rv; + } + } + + if (conn->tx.max_offset > 0) { + rv = conn_call_extend_max_data(conn, conn->tx.max_offset); if (rv != 0) { return rv; } @@ -10290,6 +10515,7 @@ static ngtcp2_ssize conn_read_handshake(ngtcp2_conn *conn, if (rv != 0) { return rv; } + conn->state = NGTCP2_CS_POST_HANDSHAKE; rv = conn_call_activate_dcid(conn, &conn->dcid.current); @@ -10342,8 +10568,6 @@ int ngtcp2_conn_read_pkt_versioned(ngtcp2_conn *conn, const ngtcp2_path *path, const ngtcp2_pkt_info zero_pi = {0}; (void)pkt_info_version; - assert(!(conn->flags & NGTCP2_CONN_FLAG_PPE_PENDING)); - conn_update_timestamp(conn, ts); ngtcp2_log_infof(&conn->log, NGTCP2_LOG_EVENT_CON, @@ -10431,7 +10655,24 @@ int ngtcp2_conn_read_pkt_versioned(ngtcp2_conn *conn, const ngtcp2_path *path, ngtcp2_unreachable(); } - return conn_recv_cpkt(conn, path, pi, pkt, pktlen, ts); + rv = conn_recv_cpkt(conn, path, pi, pkt, pktlen, ts); + if (rv != 0) { + return rv; + } + + /* If server hits amplification limit, it cancels loss detection + timer. The limit is lifted if server receives more bytes on the + current path, the path gets validated, or server migrates to + another path. Server does not necessarily send an ack-eliciting + packet after that (e.g., it is congestion limited). Re-arm the + timer here, otherwise in-flight packets are never declared + lost. */ + if (conn->server && conn->cstat.loss_detection_timer == UINT64_MAX && + conn_server_tx_left(conn, &conn->dcid.current)) { + ngtcp2_conn_set_loss_detection_timer(conn, ts); + } + + return 0; } int ngtcp2_conn_continue_handshake(ngtcp2_conn *conn, ngtcp2_tstamp ts) { @@ -10578,7 +10819,6 @@ static ngtcp2_ssize conn_write_handshake(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, ngtcp2_ssize res = 0, nwrite = 0, early_spktlen = 0; size_t origlen = destlen; uint64_t pending_early_datalen; - ngtcp2_preferred_addr *paddr; ngtcp2_stateless_reset_token token; switch (conn->state) { @@ -10703,19 +10943,6 @@ static ngtcp2_ssize conn_write_handshake(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, assert(conn->remote.transport_params); - if (conn->remote.transport_params->preferred_addr_present) { - assert(!ngtcp2_dcidtr_unused_full(&conn->dcid.dtr)); - - paddr = &conn->remote.transport_params->preferred_addr; - memcpy(token.data, paddr->stateless_reset_token, sizeof(token.data)); - ngtcp2_dcidtr_push_unused(&conn->dcid.dtr, 1, &paddr->cid, &token); - - rv = ngtcp2_gaptr_push(&conn->dcid.seqgap, 1, 1); - if (rv != 0) { - return (ngtcp2_ssize)rv; - } - } - if (conn->remote.transport_params->stateless_reset_token_present && conn->dcid.current.seq == 0) { assert(!(conn->dcid.current.flags & NGTCP2_DCID_FLAG_TOKEN_PRESENT)); @@ -10902,6 +11129,7 @@ conn_client_write_handshake(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, break; } /* fall through */ + case NGTCP2_ERR_STREAM_SHUT_WR: case NGTCP2_ERR_WRITE_MORE: conn->pkt.hs_spktlen = spktlen; break; @@ -11160,8 +11388,22 @@ int ngtcp2_conn_install_0rtt_key(ngtcp2_conn *conn, int rv; assert(ivlen >= 8); - assert(!conn->early.hp_ctx.native_handle); - assert(!conn->early.ckm); + + /* Some TLS stack (e.g., OpenSSL 3.6) attempts to install 0RTT key + twice when it receives HRR from server. After HRR, TLS client + cannot send 0RTT data, 0RTT key is useless.*/ + if (conn->early.ckm) { + conn_call_delete_crypto_aead_ctx(conn, &conn->early.ckm->aead_ctx); + ngtcp2_crypto_km_del(conn->early.ckm, conn->mem); + conn->early.ckm = NULL; + } + + if (conn->early.hp_ctx.native_handle) { + conn_call_delete_crypto_cipher_ctx(conn, &conn->early.hp_ctx); + conn->early.hp_ctx = (ngtcp2_crypto_cipher_ctx){0}; + } + + conn->flags &= ~NGTCP2_CONN_FLAG_EARLY_KEY_INSTALLED; rv = ngtcp2_crypto_km_new(&conn->early.ckm, NULL, 0, aead_ctx, iv, ivlen, conn->mem); @@ -11198,8 +11440,12 @@ int ngtcp2_conn_install_rx_key(ngtcp2_conn *conn, const uint8_t *secret, int rv; assert(ivlen >= 8); - assert(!pktns->crypto.rx.hp_ctx.native_handle); - assert(!pktns->crypto.rx.ckm); + + /* Graceful connection closure for TLS stack does not follow RFC + 9001, section 6. */ + if (pktns->crypto.rx.hp_ctx.native_handle || pktns->crypto.rx.ckm) { + return NGTCP2_ERR_INVALID_STATE; + } rv = ngtcp2_crypto_km_new(&pktns->crypto.rx.ckm, secret, secretlen, aead_ctx, iv, ivlen, conn->mem); @@ -11245,8 +11491,11 @@ int ngtcp2_conn_install_tx_key(ngtcp2_conn *conn, const uint8_t *secret, int rv; assert(ivlen >= 8); - assert(!pktns->crypto.tx.hp_ctx.native_handle); - assert(!pktns->crypto.tx.ckm); + + /* See the comment in ngtcp2_conn_install_rx_key. */ + if (pktns->crypto.tx.hp_ctx.native_handle || pktns->crypto.tx.ckm) { + return NGTCP2_ERR_INVALID_STATE; + } rv = ngtcp2_crypto_km_new(&pktns->crypto.tx.ckm, secret, secretlen, aead_ctx, iv, ivlen, conn->mem); @@ -11285,9 +11534,8 @@ static int conn_initiate_key_update(ngtcp2_conn *conn, ngtcp2_tstamp ts) { ngtcp2_tstamp confirmed_ts = conn->crypto.key_update.confirmed_ts; ngtcp2_duration pto = ngtcp2_conn_compute_pto(conn, &conn->pktns); - assert(conn->state == NGTCP2_CS_POST_HANDSHAKE); - - if (!(conn->flags & NGTCP2_CONN_FLAG_HANDSHAKE_CONFIRMED) || + if (conn->state != NGTCP2_CS_POST_HANDSHAKE || + !(conn->flags & NGTCP2_CONN_FLAG_HANDSHAKE_CONFIRMED) || (conn->flags & NGTCP2_CONN_FLAG_KEY_UPDATE_NOT_CONFIRMED) || !conn->crypto.key_update.new_tx_ckm || !conn->crypto.key_update.new_rx_ckm || @@ -11295,7 +11543,18 @@ static int conn_initiate_key_update(ngtcp2_conn *conn, ngtcp2_tstamp ts) { return NGTCP2_ERR_INVALID_STATE; } - conn_rotate_keys(conn, NGTCP2_MAX_PKT_NUM, /* initiator = */ 1); + /* A subsequent key update must not be initiated until a packet + encrypted with the current key is acknowledged. */ + if (confirmed_ts != UINT64_MAX && conn->pktns.rtb.largest_acked_tx_pkt_num < + conn->pktns.crypto.tx.ckm->pkt_num) { + return NGTCP2_ERR_INVALID_STATE; + } + + /* No packet protected by the new key has been received yet. Use + INT64_MAX instead of NGTCP2_MAX_PKT_NUM because the latter is a + valid packet number that the remote endpoint can send with the + old key. */ + conn_rotate_keys(conn, INT64_MAX, /* initiator = */ 1); return 0; } @@ -11395,8 +11654,6 @@ int ngtcp2_conn_handle_expiry(ngtcp2_conn *conn, ngtcp2_tstamp ts) { pto = ngtcp2_conn_compute_pto(conn, &conn->pktns); - assert(!(conn->flags & NGTCP2_CONN_FLAG_PPE_PENDING)); - if (ngtcp2_conn_get_idle_expiry(conn) <= ts) { return NGTCP2_ERR_IDLE_CLOSE; } @@ -11410,7 +11667,21 @@ int ngtcp2_conn_handle_expiry(ngtcp2_conn *conn, ngtcp2_tstamp ts) { ngtcp2_conn_remove_lost_pkt(conn, ts); if (conn->pv) { - ngtcp2_pv_cancel_expired_timer(conn->pv, ts); + /* conn_write_path_challenge also checks the timeout, but it might + not get a chance to send another PATH_CHALLENGE (e.g., server + is blocked by anti-amplification limit, or congestion window is + depleted). Path validation must time out regardless. */ + if (ngtcp2_pv_validation_timed_out(conn->pv, ts)) { + ngtcp2_log_info(&conn->log, NGTCP2_LOG_EVENT_PTV, + "path validation was timed out"); + + rv = conn_on_path_validation_failed(conn, conn->pv, ts); + if (rv != 0) { + return rv; + } + } else { + ngtcp2_pv_cancel_expired_timer(conn->pv, ts); + } } if (conn->pmtud) { @@ -11509,14 +11780,17 @@ void ngtcp2_conn_remove_lost_pkt(ngtcp2_conn *conn, ngtcp2_tstamp ts) { if (conn->in_pktns) { timeout = ngtcp2_conn_compute_pto(conn, conn->in_pktns) * 3; - ngtcp2_rtb_remove_expired_lost_pkt(&conn->in_pktns->rtb, timeout, ts); + ngtcp2_rtb_remove_expired_lost_pkt(&conn->in_pktns->rtb, timeout, + &conn->cstat, ts); } if (conn->hs_pktns) { timeout = ngtcp2_conn_compute_pto(conn, conn->hs_pktns) * 3; - ngtcp2_rtb_remove_expired_lost_pkt(&conn->hs_pktns->rtb, timeout, ts); + ngtcp2_rtb_remove_expired_lost_pkt(&conn->hs_pktns->rtb, timeout, + &conn->cstat, ts); } timeout = ngtcp2_conn_compute_pto(conn, &conn->pktns) * 3; - ngtcp2_rtb_remove_expired_lost_pkt(&conn->pktns.rtb, timeout, ts); + ngtcp2_rtb_remove_expired_lost_pkt(&conn->pktns.rtb, timeout, &conn->cstat, + ts); } /* @@ -11667,6 +11941,8 @@ ngtcp2_conn_server_negotiate_version(ngtcp2_conn *conn, int ngtcp2_conn_set_remote_transport_params( ngtcp2_conn *conn, const ngtcp2_transport_params *params) { + const ngtcp2_preferred_addr *paddr; + ngtcp2_stateless_reset_token token; int rv; /* We expect this function is called once per QUIC connection, but @@ -11743,6 +12019,22 @@ int ngtcp2_conn_set_remote_transport_params( if (rv != 0) { return rv; } + + /* Server can send NEW_CONNECTION_ID frames in 0.5 RTT packets. + Store the Connection ID in preferred_address now so that those + frames are verified against it. */ + if (params->preferred_addr_present) { + assert(!ngtcp2_dcidtr_unused_full(&conn->dcid.dtr)); + + rv = ngtcp2_gaptr_push(&conn->dcid.seqgap, 1, 1); + if (rv != 0) { + return rv; + } + + paddr = ¶ms->preferred_addr; + memcpy(token.data, paddr->stateless_reset_token, sizeof(token.data)); + ngtcp2_dcidtr_push_unused(&conn->dcid.dtr, 1, &paddr->cid, &token); + } } ngtcp2_log_remote_tp(&conn->log, params); @@ -11981,10 +12273,10 @@ int ngtcp2_conn_commit_local_transport_params(ngtcp2_conn *conn) { conn->rx.window = conn->rx.unsent_max_offset = conn->rx.max_offset = params->initial_max_data; - conn->remote.bidi.unsent_max_streams = params->initial_max_streams_bidi; - conn->remote.bidi.max_streams = params->initial_max_streams_bidi; - conn->remote.uni.unsent_max_streams = params->initial_max_streams_uni; - conn->remote.uni.max_streams = params->initial_max_streams_uni; + conn->rx.bidi.unsent_max_streams = params->initial_max_streams_bidi; + conn->rx.bidi.max_streams = params->initial_max_streams_bidi; + conn->rx.uni.unsent_max_streams = params->initial_max_streams_uni; + conn->rx.uni.max_streams = params->initial_max_streams_uni; conn->flags |= NGTCP2_CONN_FLAG_LOCAL_TRANSPORT_PARAMS_COMMITTED; @@ -12031,15 +12323,15 @@ int ngtcp2_conn_open_bidi_stream(ngtcp2_conn *conn, int64_t *pstream_id, return NGTCP2_ERR_NOMEM; } - rv = ngtcp2_conn_init_stream(conn, strm, conn->local.bidi.next_stream_id, + rv = ngtcp2_conn_init_stream(conn, strm, conn->tx.bidi.next_stream_id, stream_user_data); if (rv != 0) { ngtcp2_objalloc_strm_release(&conn->strm_objalloc, strm); return rv; } - *pstream_id = conn->local.bidi.next_stream_id; - conn->local.bidi.next_stream_id += 4; + *pstream_id = conn->tx.bidi.next_stream_id; + conn->tx.bidi.next_stream_id += 4; return 0; } @@ -12058,14 +12350,14 @@ int ngtcp2_conn_open_uni_stream(ngtcp2_conn *conn, int64_t *pstream_id, return NGTCP2_ERR_NOMEM; } - rv = ngtcp2_conn_init_stream(conn, strm, conn->local.uni.next_stream_id, + rv = ngtcp2_conn_init_stream(conn, strm, conn->tx.uni.next_stream_id, stream_user_data); if (rv != 0) { ngtcp2_objalloc_strm_release(&conn->strm_objalloc, strm); return rv; } - *pstream_id = conn->local.uni.next_stream_id; - conn->local.uni.next_stream_id += 4; + *pstream_id = conn->tx.uni.next_stream_id; + conn->tx.uni.next_stream_id += 4; return 0; } @@ -12080,22 +12372,13 @@ ngtcp2_ssize ngtcp2_conn_write_stream_versioned( ngtcp2_pkt_info *pi, uint8_t *dest, size_t destlen, ngtcp2_ssize *pdatalen, uint32_t flags, int64_t stream_id, const uint8_t *data, size_t datalen, ngtcp2_tstamp ts) { - ngtcp2_vec datav, *v; - size_t datacnt; - - if (datalen == 0) { - v = NULL; - datacnt = 0; - } else { - datav.len = datalen; - datav.base = (uint8_t *)data; - v = &datav; - datacnt = 1; - } - - return ngtcp2_conn_writev_stream_versioned(conn, path, pkt_info_version, pi, - dest, destlen, pdatalen, flags, - stream_id, v, datacnt, ts); + return ngtcp2_conn_writev_stream_versioned( + conn, path, pkt_info_version, pi, dest, destlen, pdatalen, flags, stream_id, + &(ngtcp2_vec){ + .base = (uint8_t *)data, + .len = datalen, + }, + datalen != 0, ts); } static int conn_no_app_data_written(const ngtcp2_conn *conn) { @@ -12610,6 +12893,7 @@ ngtcp2_ssize ngtcp2_conn_write_vmsg(ngtcp2_conn *conn, ngtcp2_path *path, break; } /* fall through */ + case NGTCP2_ERR_STREAM_SHUT_WR: case NGTCP2_ERR_WRITE_MORE: conn->pkt.hs_spktlen = res; break; @@ -12636,7 +12920,7 @@ conn_write_connection_close(ngtcp2_conn *conn, ngtcp2_pkt_info *pi, .reason = (uint8_t *)reason, }; - if (!(conn->flags & NGTCP2_CONN_FLAG_HANDSHAKE_CONFIRMED) && + if ((conn->server || !(conn->flags & NGTCP2_CONN_FLAG_HANDSHAKE_CONFIRMED)) && pkt_type != NGTCP2_PKT_INITIAL) { if (in_pktns && conn->server) { nwrite = ngtcp2_conn_write_single_frame_pkt( @@ -12759,6 +13043,7 @@ ngtcp2_ssize ngtcp2_conn_write_application_close_pkt( ngtcp2_ssize res = 0; ngtcp2_frame fr; uint64_t server_tx_left; + uint8_t pkt_type; if (conn_check_pkt_num_exhausted(conn)) { return NGTCP2_ERR_PKT_NUM_EXHAUSTED; @@ -12789,17 +13074,26 @@ ngtcp2_ssize ngtcp2_conn_write_application_close_pkt( destlen = (size_t)ngtcp2_min((uint64_t)destlen, server_tx_left); } - if (!(conn->flags & NGTCP2_CONN_FLAG_HANDSHAKE_CONFIRMED)) { - nwrite = conn_write_connection_close( - conn, pi, dest, destlen, - conn->hs_pktns->crypto.tx.ckm ? NGTCP2_PKT_HANDSHAKE : NGTCP2_PKT_INITIAL, - NGTCP2_APPLICATION_ERROR, NULL, 0, ts); - if (nwrite < 0) { - return nwrite; + if (conn->server || !(conn->flags & NGTCP2_CONN_FLAG_HANDSHAKE_CONFIRMED)) { + if (conn->hs_pktns && conn->hs_pktns->crypto.tx.ckm) { + pkt_type = NGTCP2_PKT_HANDSHAKE; + } else if (conn->in_pktns && conn->in_pktns->crypto.tx.ckm) { + pkt_type = NGTCP2_PKT_INITIAL; + } else { + pkt_type = NGTCP2_PKT_1RTT; + } + + if (pkt_type != NGTCP2_PKT_1RTT) { + nwrite = + conn_write_connection_close(conn, pi, dest, destlen, pkt_type, + NGTCP2_APPLICATION_ERROR, NULL, 0, ts); + if (nwrite < 0) { + return nwrite; + } + res = nwrite; + dest += nwrite; + destlen -= (size_t)nwrite; } - res = nwrite; - dest += nwrite; - destlen -= (size_t)nwrite; } if (conn->state != NGTCP2_CS_POST_HANDSHAKE && @@ -12952,6 +13246,11 @@ int ngtcp2_conn_close_stream(ngtcp2_conn *conn, ngtcp2_strm *strm) { return rv; } + /* Extend connection flow control window for the amount of data + which are not passed to application. */ + ngtcp2_conn_extend_max_offset(conn, strm->rx.last_offset - + ngtcp2_strm_rx_offset(strm)); + if (ngtcp2_strm_is_tx_queued(strm)) { ngtcp2_pq_remove(&conn->tx.strmq, &strm->pe); } @@ -13022,15 +13321,16 @@ static int conn_shutdown_stream_read(ngtcp2_conn *conn, ngtcp2_strm *strm, (NGTCP2_STRM_FLAG_STOP_SENDING | NGTCP2_STRM_FLAG_RESET_STREAM_RECVED)) { return 0; } - if ((strm->flags & NGTCP2_STRM_FLAG_SHUT_RD) && - ngtcp2_strm_rx_offset(strm) == strm->rx.last_offset) { + /* ngtcp2_strm_rx_offset() must not be used here. If this function + is called inside ngtcp2_callbacks.recv_stream_data, all stream + data might have been received, but some of them might still be + buffered, and have not been passed to an application yet. */ + if (strm->flags & NGTCP2_STRM_FLAG_RX_FIN_DELIVERED) { return 0; } strm->flags |= NGTCP2_STRM_FLAG_STOP_SENDING; - ngtcp2_strm_stop_buffering_reordered_data(strm); - return conn_stop_sending(conn, strm, app_error_code); } @@ -13110,8 +13410,6 @@ int ngtcp2_conn_shutdown_stream_read(ngtcp2_conn *conn, uint32_t flags, */ static int conn_extend_max_stream_offset(ngtcp2_conn *conn, ngtcp2_strm *strm, uint64_t datalen) { - ngtcp2_strm *top; - if (datalen > NGTCP2_MAX_VARINT || strm->rx.unsent_max_offset > NGTCP2_MAX_VARINT - datalen) { strm->rx.unsent_max_offset = NGTCP2_MAX_VARINT; @@ -13121,14 +13419,8 @@ static int conn_extend_max_stream_offset(ngtcp2_conn *conn, ngtcp2_strm *strm, if (!(strm->flags & (NGTCP2_STRM_FLAG_SHUT_RD | NGTCP2_STRM_FLAG_STOP_SENDING)) && - !ngtcp2_strm_is_tx_queued(strm) && conn_should_send_max_stream_data(conn, strm)) { - if (!ngtcp2_pq_empty(&conn->tx.strmq)) { - top = ngtcp2_conn_tx_strmq_top(conn); - strm->cycle = top->cycle; - } - strm->cycle = ngtcp2_conn_tx_strmq_first_cycle(conn); - return ngtcp2_conn_tx_strmq_push(conn, strm); + return ngtcp2_conn_tx_strmq_push_if_not(conn, strm); } return 0; @@ -13161,11 +13453,11 @@ void ngtcp2_conn_extend_max_offset(ngtcp2_conn *conn, uint64_t datalen) { } void ngtcp2_conn_extend_max_streams_bidi(ngtcp2_conn *conn, size_t n) { - handle_max_remote_streams_extension(&conn->remote.bidi.unsent_max_streams, n); + handle_max_remote_streams_extension(&conn->rx.bidi.unsent_max_streams, n); } void ngtcp2_conn_extend_max_streams_uni(ngtcp2_conn *conn, size_t n) { - handle_max_remote_streams_extension(&conn->remote.uni.unsent_max_streams, n); + handle_max_remote_streams_extension(&conn->rx.uni.unsent_max_streams, n); } const ngtcp2_cid *ngtcp2_conn_get_dcid(ngtcp2_conn *conn) { @@ -13217,11 +13509,14 @@ static int delete_strms_pq_each(void *data, void *ptr) { /* * conn_discard_early_data_state discards any connection states which - * are altered by any operations during early data transfer. + * are altered by any operations during early data transfer. This + * function assumes that |conn| is initialized as client. */ static void conn_discard_early_data_state(ngtcp2_conn *conn) { ngtcp2_frame_chain **pfrc, *frc; + assert(!conn->server); + ngtcp2_rtb_remove_early_data(&conn->pktns.rtb, &conn->cstat); ngtcp2_map_each(&conn->strms, delete_strms_pq_each, conn); @@ -13233,19 +13528,14 @@ static void conn_discard_early_data_state(ngtcp2_conn *conn) { conn->rx.unsent_max_offset = conn->rx.max_offset = conn->local.transport_params.initial_max_data; - conn->remote.bidi.unsent_max_streams = conn->remote.bidi.max_streams = + conn->rx.bidi.unsent_max_streams = conn->rx.bidi.max_streams = conn->local.transport_params.initial_max_streams_bidi; - conn->remote.uni.unsent_max_streams = conn->remote.uni.max_streams = + conn->rx.uni.unsent_max_streams = conn->rx.uni.max_streams = conn->local.transport_params.initial_max_streams_uni; - if (conn->server) { - conn->local.bidi.next_stream_id = 1; - conn->local.uni.next_stream_id = 3; - } else { - conn->local.bidi.next_stream_id = 0; - conn->local.uni.next_stream_id = 2; - } + conn->tx.bidi.next_stream_id = 0; + conn->tx.uni.next_stream_id = 2; for (pfrc = &conn->pktns.tx.frq; *pfrc;) { frc = *pfrc; @@ -13255,6 +13545,8 @@ static void conn_discard_early_data_state(ngtcp2_conn *conn) { } int ngtcp2_conn_tls_early_data_rejected(ngtcp2_conn *conn) { + assert(!conn->server); + if (conn->flags & NGTCP2_CONN_FLAG_EARLY_DATA_REJECTED) { return 0; } @@ -13263,14 +13555,14 @@ int ngtcp2_conn_tls_early_data_rejected(ngtcp2_conn *conn) { conn_discard_early_data_state(conn); - if (conn->callbacks.tls_early_data_rejected) { - return conn->callbacks.tls_early_data_rejected(conn, conn->user_data); - } - if (conn->early.ckm) { conn_discard_early_key(conn); } + if (conn->callbacks.tls_early_data_rejected) { + return conn->callbacks.tls_early_data_rejected(conn, conn->user_data); + } + return 0; } @@ -13662,6 +13954,16 @@ int ngtcp2_conn_tx_strmq_push(ngtcp2_conn *conn, ngtcp2_strm *strm) { return ngtcp2_pq_push(&conn->tx.strmq, &strm->pe); } +int ngtcp2_conn_tx_strmq_push_if_not(ngtcp2_conn *conn, ngtcp2_strm *strm) { + if (ngtcp2_strm_is_tx_queued(strm)) { + return 0; + } + + strm->cycle = ngtcp2_conn_tx_strmq_first_cycle(conn); + + return ngtcp2_conn_tx_strmq_push(conn, strm); +} + static int conn_has_uncommitted_preferred_addr_cid(const ngtcp2_conn *conn) { return conn->server && !(conn->flags & NGTCP2_CONN_FLAG_LOCAL_TRANSPORT_PARAMS_COMMITTED) && @@ -13906,13 +14208,18 @@ int ngtcp2_conn_initiate_immediate_migration(ngtcp2_conn *conn, ngtcp2_dcid_copy(&conn->dcid.current, &dcid); - conn_reset_congestion_state(conn, ts); - conn_reset_ecn_validation_state(conn); - + /* Restore the maximum UDP payload size of the validated path + before resetting congestion state because it derives its + parameters (e.g., send_quantum lower bound) from it. */ validated_path = ngtcp2_conn_find_path_history(conn, path, ts); if (validated_path) { ngtcp2_dcid_apply_validated_path(&conn->dcid.current, validated_path); + } + + conn_reset_congestion_state(conn, ts); + conn_reset_ecn_validation_state(conn); + if (validated_path) { if (!conn->local.settings.no_pmtud) { rv = conn_start_pmtud(conn); if (rv != 0) { @@ -13994,6 +14301,16 @@ uint64_t ngtcp2_conn_get_max_data_left2(const ngtcp2_conn *conn) { return conn->tx.max_offset - conn->tx.offset; } +uint64_t ngtcp2_conn_get_max_data_left_write_thresh(const ngtcp2_conn *conn) { + uint64_t n = conn->tx.max_offset - conn->tx.offset; + + if (n <= conn->local.settings.write_stream_data_thresh) { + return 0; + } + + return n; +} + uint64_t ngtcp2_conn_get_max_stream_data_left(ngtcp2_conn *conn, int64_t stream_id) { return ngtcp2_conn_get_max_stream_data_left2(conn, stream_id); @@ -14015,11 +14332,9 @@ uint64_t ngtcp2_conn_get_streams_bidi_left(ngtcp2_conn *conn) { } uint64_t ngtcp2_conn_get_streams_bidi_left2(const ngtcp2_conn *conn) { - uint64_t n = ngtcp2_ord_stream_id(conn->local.bidi.next_stream_id); + uint64_t n = ngtcp2_ord_stream_id(conn->tx.bidi.next_stream_id); - return n > conn->local.bidi.max_streams - ? 0 - : conn->local.bidi.max_streams - n + 1; + return n > conn->tx.bidi.max_streams ? 0 : conn->tx.bidi.max_streams - n + 1; } uint64_t ngtcp2_conn_get_streams_uni_left(ngtcp2_conn *conn) { @@ -14027,10 +14342,9 @@ uint64_t ngtcp2_conn_get_streams_uni_left(ngtcp2_conn *conn) { } uint64_t ngtcp2_conn_get_streams_uni_left2(const ngtcp2_conn *conn) { - uint64_t n = ngtcp2_ord_stream_id(conn->local.uni.next_stream_id); + uint64_t n = ngtcp2_ord_stream_id(conn->tx.uni.next_stream_id); - return n > conn->local.uni.max_streams ? 0 - : conn->local.uni.max_streams - n + 1; + return n > conn->tx.uni.max_streams ? 0 : conn->tx.uni.max_streams - n + 1; } uint64_t ngtcp2_conn_get_cwnd_left(ngtcp2_conn *conn) { @@ -14267,7 +14581,12 @@ size_t ngtcp2_conn_get_send_quantum(ngtcp2_conn *conn) { } size_t ngtcp2_conn_get_send_quantum2(const ngtcp2_conn *conn) { - return conn->cstat.send_quantum; + /* Congestion controller updates send_quantum only when it processes + ACK, but the maximum UDP payload size of the current path may + grow in between (e.g., migrating back to the validated path). + Ensure that at least one full-sized packet fits. */ + return ngtcp2_max(conn->cstat.send_quantum, + ngtcp2_conn_get_path_max_tx_udp_payload_size2(conn)); } size_t ngtcp2_conn_get_stream_loss_count(ngtcp2_conn *conn, int64_t stream_id) { @@ -14328,6 +14647,7 @@ ngtcp2_ssize ngtcp2_conn_write_aggregate_pkt2_versioned( int first_pkt; ngtcp2_pkt_info pi_discard; ngtcp2_path_storage path_discard; + ngtcp2_path_storage path_start; (void)pkt_info_version; assert(buflen >= path_max_udp_payloadlen); @@ -14336,6 +14656,8 @@ ngtcp2_ssize ngtcp2_conn_write_aggregate_pkt2_versioned( num_pkts = SIZE_MAX; } + ngtcp2_path_storage_init2(&path_start, &conn->dcid.current.ps.path); + for (;;) { ecn_state = conn->tx.ecn.state; @@ -14365,7 +14687,8 @@ ngtcp2_ssize ngtcp2_conn_write_aggregate_pkt2_versioned( if ((size_t)nwrite != path_max_udp_payloadlen || buflen < path_max_udp_payloadlen || ecn_state != conn->tx.ecn.state || - num_pkts == 0) { + num_pkts == 0 || (path && !ngtcp2_path_eq(path, &path_start.path)) || + !ngtcp2_path_eq(&conn->dcid.current.ps.path, &path_start.path)) { nwrite = wbuf - buf; break; } diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_conn.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_conn.h index 18af11727e0..5fd9bad9da3 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_conn.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_conn.h @@ -93,6 +93,10 @@ typedef enum { value, it is truncated. */ #define NGTCP2_CCERR_MAX_REASONLEN 1024 +/* NGTCP2_MAX_TOKENLEN is the maximum length of token given in + ngtcp2_settings.token that client sends in its Initial packet. */ +#define NGTCP2_MAX_TOKENLEN 512 + /* NGTCP2_WRITE_PKT_FLAG_NONE indicates that no flag is set. */ #define NGTCP2_WRITE_PKT_FLAG_NONE 0x00U /* NGTCP2_WRITE_PKT_FLAG_REQUIRE_PADDING indicates that packet other @@ -164,9 +168,9 @@ void ngtcp2_path_challenge_entry_init(ngtcp2_path_challenge_entry *pcent, supports Greasing QUIC Bit extension. */ #define NGTCP2_CONN_FLAG_CLEAR_FIXED_BIT 0x0400U /* NGTCP2_CONN_FLAG_KEY_UPDATE_NOT_CONFIRMED is set when key update is - not confirmed by the local endpoint. That is, it has not received - ACK frame which acknowledges packet which is encrypted with new - key. */ + not confirmed by the local endpoint. That is, it has received + neither ACK frame which acknowledges packet which is encrypted with + new key, nor packet which is encrypted with new key. */ #define NGTCP2_CONN_FLAG_KEY_UPDATE_NOT_CONFIRMED 0x0800U /* NGTCP2_CONN_FLAG_PPE_PENDING is set when NGTCP2_WRITE_STREAM_FLAG_MORE is used and the intermediate state of @@ -193,6 +197,9 @@ void ngtcp2_path_challenge_entry_init(ngtcp2_path_challenge_entry *pcent, Initial CRYPTO frame into pieces as a countermeasure against Deep Packet Inspection. */ #define NGTCP2_CONN_FLAG_CRUMBLE_INITIAL_CRYPTO 0x40000U +/* NGTCP2_CONN_FLAG_CLIENT_INITIAL_CALLED is set when + ngtcp2_callbacks.client_initial has been called successfully. */ +#define NGTCP2_CONN_FLAG_CLIENT_INITIAL_CALLED 0x80000U typedef struct ngtcp2_pktns { struct { @@ -391,6 +398,24 @@ struct ngtcp2_conn { sent. */ ngtcp2_tstamp last_max_data_ts; + struct { + /* max_streams is the maximum number of bidirectional streams which + the local endpoint can open. */ + uint64_t max_streams; + /* next_stream_id is the bidirectional stream ID which the local + endpoint opens next. */ + int64_t next_stream_id; + } bidi; + + struct { + /* max_streams is the maximum number of unidirectional streams + which the local endpoint can open. */ + uint64_t max_streams; + /* next_stream_id is the unidirectional stream ID which the + local endpoint opens next. */ + int64_t next_stream_id; + } uni; + struct { /* validation_start_ts is the timestamp when ECN validation is started. It is UINT64_MAX if it has not started yet. */ @@ -441,10 +466,28 @@ struct ngtcp2_conn { ngtcp2_ccerr ccerr; struct { - /* pkt_num is the lowest incoming packet number of the packet - that server verified preferred address usage of client. */ - int64_t pkt_num; - } preferred_addr; + /* unsent_max_streams is the maximum number of streams of peer + initiated bidirectional stream which the local endpoint can + accept. This limit is not yet notified to the remote + endpoint. */ + uint64_t unsent_max_streams; + /* max_streams is the maximum number of streams of peer + initiated bidirectional stream which the local endpoint can + accept. */ + uint64_t max_streams; + } bidi; + + struct { + /* unsent_max_streams is the maximum number of streams of peer + initiated unidirectional stream which the local endpoint can + accept. This limit is not yet notified to the remote + endpoint. */ + uint64_t unsent_max_streams; + /* max_streams is the maximum number of streams of peer + initiated unidirectional stream which the local endpoint can + accept. */ + uint64_t max_streams; + } uni; } rx; struct { @@ -467,23 +510,6 @@ struct ngtcp2_conn { /* transport_params is the local transport parameters. It is used for Short packet only. */ ngtcp2_transport_params transport_params; - struct { - /* max_streams is the maximum number of bidirectional streams which - the local endpoint can open. */ - uint64_t max_streams; - /* next_stream_id is the bidirectional stream ID which the local - endpoint opens next. */ - int64_t next_stream_id; - } bidi; - - struct { - /* max_streams is the maximum number of unidirectional streams - which the local endpoint can open. */ - uint64_t max_streams; - /* next_stream_id is the unidirectional stream ID which the - local endpoint opens next. */ - int64_t next_stream_id; - } uni; } local; struct { @@ -494,33 +520,18 @@ struct ngtcp2_conn { during handshake. It is copied to transport_params when 1RTT key is available. */ ngtcp2_transport_params *pending_transport_params; - struct { - ngtcp2_idtr idtr; - /* unsent_max_streams is the maximum number of streams of peer - initiated bidirectional stream which the local endpoint can - accept. This limit is not yet notified to the remote - endpoint. */ - uint64_t unsent_max_streams; - /* max_streams is the maximum number of streams of peer - initiated bidirectional stream which the local endpoint can - accept. */ - uint64_t max_streams; - } bidi; - - struct { - ngtcp2_idtr idtr; - /* unsent_max_streams is the maximum number of streams of peer - initiated unidirectional stream which the local endpoint can - accept. This limit is not yet notified to the remote - endpoint. */ - uint64_t unsent_max_streams; - /* max_streams is the maximum number of streams of peer - initiated unidirectional stream which the local endpoint can - accept. */ - uint64_t max_streams; - } uni; } remote; + struct { + /* idtr tracks the stream ID usage. */ + ngtcp2_idtr idtr; + } bidi; + + struct { + /* idtr tracks the stream ID usage. */ + ngtcp2_idtr idtr; + } uni; + struct { struct { /* new_tx_ckm is a new sender 1RTT key which has not been @@ -786,18 +797,19 @@ int ngtcp2_conn_detect_lost_pkt(ngtcp2_conn *conn, ngtcp2_pktns *pktns, /* * ngtcp2_conn_tx_strmq_top returns the ngtcp2_strm which sits on the - * top of queue. tx_strmq must not be empty. + * top of queue. |conn|->tx.strmq must not be empty. */ ngtcp2_strm *ngtcp2_conn_tx_strmq_top(ngtcp2_conn *conn); /* * ngtcp2_conn_tx_strmq_pop pops the ngtcp2_strm from the queue. - * tx_strmq must not be empty. + * |conn|->tx.strmq must not be empty. */ void ngtcp2_conn_tx_strmq_pop(ngtcp2_conn *conn); /* - * ngtcp2_conn_tx_strmq_push pushes |strm| into tx_strmq. + * ngtcp2_conn_tx_strmq_push pushes |strm| into |conn|->tx.strmq. + * |strm|->cycle must be set before calling this function. * * This function returns 0 if it succeeds, or one of the following * negative error codes: @@ -807,6 +819,18 @@ void ngtcp2_conn_tx_strmq_pop(ngtcp2_conn *conn); */ int ngtcp2_conn_tx_strmq_push(ngtcp2_conn *conn, ngtcp2_strm *strm); +/* + * ngtcp2_conn_tx_strmq_push_if_not pushes |strm| into + * |conn|->tx.strmq if |strm| is not pushed yet. + * + * This function returns 0 if it succeeds, or one of the following + * negative error codes: + * + * NGTCP2_ERR_NOMEM + * Out of memory. + */ +int ngtcp2_conn_tx_strmq_push_if_not(ngtcp2_conn *conn, ngtcp2_strm *strm); + /* * ngtcp2_conn_internal_expiry returns the minimum expiry time among * all timers in |conn|. diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_crypto.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_crypto.h index c1e786b5fc7..ae166ed7fb6 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_crypto.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_crypto.h @@ -54,7 +54,9 @@ typedef struct ngtcp2_crypto_km { /* pkt_num is a packet number of a packet which uses this keying material. For encryption key, it is the lowest packet number of a packet. For decryption key, it is the lowest packet number of - a packet which can be decrypted with this keying material. */ + a packet which can be decrypted with this keying material, or + INT64_MAX if the local endpoint initiated key update, and no + packet has been decrypted with this keying material yet. */ int64_t pkt_num; /* use_count is the number of encryption applied with this key. */ uint64_t use_count; diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_dcidtr.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_dcidtr.c index 0360ba82cbd..71fc7caf76e 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_dcidtr.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_dcidtr.c @@ -174,39 +174,32 @@ int ngtcp2_dcidtr_verify_stateless_reset( return NGTCP2_ERR_INVALID_ARGUMENT; } -static int verify_token_uniqueness(const ngtcp2_ringbuf *rb, int *pfound, - uint64_t seq, const ngtcp2_cid *cid, - const ngtcp2_stateless_reset_token *token) { +static int verify_cid_uniqueness(const ngtcp2_ringbuf *rb, + const ngtcp2_cid *cid) { const ngtcp2_dcid *dcid; size_t i, len = ngtcp2_ringbuf_len(rb); - int rv; for (i = 0; i < len; ++i) { dcid = ngtcp2_ringbuf_get(rb, i); - rv = ngtcp2_dcid_verify_uniqueness(dcid, seq, cid, token); - if (rv != 0) { - return NGTCP2_ERR_PROTO; - } if (ngtcp2_cid_eq(&dcid->cid, cid)) { - *pfound = 1; + return NGTCP2_ERR_PROTO; } } return 0; } -int ngtcp2_dcidtr_verify_token_uniqueness( - const ngtcp2_dcidtr *dtr, int *pfound, uint64_t seq, const ngtcp2_cid *cid, - const ngtcp2_stateless_reset_token *token) { +int ngtcp2_dcidtr_verify_cid_uniqueness(const ngtcp2_dcidtr *dtr, + const ngtcp2_cid *cid) { int rv; - rv = verify_token_uniqueness(&dtr->bound.rb, pfound, seq, cid, token); + rv = verify_cid_uniqueness(&dtr->bound.rb, cid); if (rv != 0) { return rv; } - return verify_token_uniqueness(&dtr->unused.rb, pfound, seq, cid, token); + return verify_cid_uniqueness(&dtr->unused.rb, cid); } static void remove_dcid_at(ngtcp2_ringbuf *rb, size_t at) { diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_dcidtr.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_dcidtr.h index 945ed12bae1..9dc97457df2 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_dcidtr.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_dcidtr.h @@ -159,30 +159,17 @@ int ngtcp2_dcidtr_verify_stateless_reset( const ngtcp2_stateless_reset_token *token); /* - * ngtcp2_dcidtr_verify_token_uniqueness verifies that the uniqueness - * of the combination of |seq|, |cid|, and |token| against the exiting - * Destination Connection IDs. That is: - * - * - If they do not share the same seq, then their Connection IDs must - * be different. - * - * - If they share the same seq, then their Connection IDs and tokens - * must be the same. - * - * If this function succeeds, and there is Destination Connection ID - * which shares |seq|, |cid|, and |token|, |*pfound| is set to - * nonzero. + * ngtcp2_dcidtr_verify_cid_uniqueness verifies that |dtr| does not + * contain |cid|. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * NGTCP2_ERR_PROTO - * The given combination of values does not satisfy the above - * conditions. + * |dtr| contains |cid|. */ -int ngtcp2_dcidtr_verify_token_uniqueness( - const ngtcp2_dcidtr *dtr, int *pfound, uint64_t seq, const ngtcp2_cid *cid, - const ngtcp2_stateless_reset_token *token); +int ngtcp2_dcidtr_verify_cid_uniqueness(const ngtcp2_dcidtr *dtr, + const ngtcp2_cid *cid); /* * ngtcp2_dcidtr_retire_inactive_dcid_prior_to retires inactive diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_log.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_log.c index 51a9d70d13c..cc81e3dd775 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_log.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_log.c @@ -284,7 +284,7 @@ static void log_fr_data_blocked(ngtcp2_log *log, const ngtcp2_pkt_hd *hd, const char *dir) { ngtcp2_log_infof_raw(log, NGTCP2_LOG_EVENT_FRM, NGTCP2_LOG_PKT(dir, hd), " DATA_BLOCKED(0x", hex(fr->type), - ") offset=", fr->offset); + ") max_data=", fr->max_data); } static void log_fr_stream_data_blocked(ngtcp2_log *log, const ngtcp2_pkt_hd *hd, @@ -292,7 +292,8 @@ static void log_fr_stream_data_blocked(ngtcp2_log *log, const ngtcp2_pkt_hd *hd, const char *dir) { ngtcp2_log_infof_raw(log, NGTCP2_LOG_EVENT_FRM, NGTCP2_LOG_PKT(dir, hd), " STREAM_DATA_BLOCKED(0x", hex(fr->type), ") id=0x", - hex(fr->stream_id), " offset=", fr->offset); + hex(fr->stream_id), + " max_stream_data=", fr->max_stream_data); } static void log_fr_streams_blocked(ngtcp2_log *log, const ngtcp2_pkt_hd *hd, diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_map.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_map.c index 3ad4b9f1ef0..ecc7cfa384c 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_map.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_map.c @@ -30,6 +30,7 @@ #include #include "ngtcp2_conv.h" +#include "ngtcp2_macro.h" #define NGTCP2_INITIAL_HASHBITS 4 @@ -74,18 +75,19 @@ int ngtcp2_map_each(const ngtcp2_map *map, int (*func)(void *data, void *ptr), return 0; } -/* Hasher from - https://github.com/rust-lang/rustc-hash/blob/dc5c33f1283de2da64d8d7a06401d91aded03ad4/src/lib.rs - to maximize the output's sensitivity to all input bits. */ -#define NGTCP2_MAP_HASHER 0xF1357AEA2E62A9C5ULL -/* 64-bit Fibonacci hashing constant, Golden Ratio constant, to get - the high bits with the good distribution. */ -#define NGTCP2_MAP_FIBO 0x9E3779B97F4A7C15ULL +/* 64-bit finalizer (fmix64) from MurmurHash3 to maximize the output's + sensitivity to all input bits. */ +#define NGTCP2_MAP_HASHER1 0xFF51AFD7ED558CCDULL +#define NGTCP2_MAP_HASHER2 0xC4CEB9FE1A85EC53ULL static size_t map_index(const ngtcp2_map *map, ngtcp2_map_key_type key) { - key += map->seed; - key *= NGTCP2_MAP_HASHER; - return (size_t)((key * NGTCP2_MAP_FIBO) >> (64 - map->hashbits)); + key ^= map->seed; + key ^= key >> 33; + key *= NGTCP2_MAP_HASHER1; + key ^= key >> 33; + key *= NGTCP2_MAP_HASHER2; + key ^= key >> 33; + return (size_t)(key >> (64 - map->hashbits)); } #ifndef WIN32 @@ -107,17 +109,17 @@ void ngtcp2_map_print_distance(const ngtcp2_map *map) { } idx = map_index(map, map->keys[i]); - fprintf(stderr, "@%zu key=%" PRIu64 " base=%zu distance=%u\n", i, + fprintf(stderr, "@%zu key=%" PRIu64 " base=%zu distance=%zu\n", i, map->keys[i], idx, map->psl[i] - 1); } } #endif /* !defined(WIN32) */ static void map_set_entry(ngtcp2_map *map, size_t idx, ngtcp2_map_key_type key, - void *data, size_t psl) { + size_t psl, void *data) { map->keys[idx] = key; + map->psl[idx] = psl; map->data[idx] = data; - map->psl[idx] = (uint8_t)psl; } #define NGTCP2_SWAP(TYPE, A, B) \ @@ -129,15 +131,15 @@ static void map_set_entry(ngtcp2_map *map, size_t idx, ngtcp2_map_key_type key, } while (0) /* - * map_insert inserts |key| and |data| to |map|, and returns the index - * where the pair is stored if it succeeds. Otherwise, it returns one - * of the following negative error codes: + * map_insert inserts |key| and |data| to |map|. + * + * It returns 0 if it succeeds, or one of the following negative error + * codes: * * NGTCP2_ERR_INVALID_ARGUMENT * The another data associated to |key| is already present. */ -static ngtcp2_ssize map_insert(ngtcp2_map *map, ngtcp2_map_key_type key, - void *data) { +static int map_insert(ngtcp2_map *map, ngtcp2_map_key_type key, void *data) { size_t idx = map_index(map, key); size_t mask = ((size_t)1 << map->hashbits) - 1; size_t psl = 1; @@ -147,16 +149,16 @@ static ngtcp2_ssize map_insert(ngtcp2_map *map, ngtcp2_map_key_type key, kpsl = map->psl[idx]; if (kpsl == 0) { - map_set_entry(map, idx, key, data, psl); + map_set_entry(map, idx, key, psl, data); ++map->size; - return (ngtcp2_ssize)idx; + return 0; } if (psl > kpsl) { NGTCP2_SWAP(ngtcp2_map_key_type, &key, &map->keys[idx]); + NGTCP2_SWAP(size_t, &psl, &map->psl[idx]); NGTCP2_SWAP(void *, &data, &map->data[idx]); - NGTCP2_SWAP(uint8_t, &psl, &map->psl[idx]); } else if (map->keys[idx] == key) { /* This check ensures that no duplicate keys are inserted. But it is just a waste after first swap or if this function is @@ -178,14 +180,14 @@ static ngtcp2_ssize map_insert(ngtcp2_map *map, ngtcp2_map_key_type key, static int map_resize(ngtcp2_map *map, size_t new_hashbits) { size_t i; size_t tablelen; - ngtcp2_ssize idx; ngtcp2_map new_map = { .mem = map->mem, .seed = map->seed, .hashbits = new_hashbits, }; void *buf; - (void)idx; + int rv; + (void)rv; if (new_hashbits > NGTCP2_MAP_MAX_HASHBITS) { return NGTCP2_ERR_NOMEM; @@ -194,16 +196,16 @@ static int map_resize(ngtcp2_map *map, size_t new_hashbits) { tablelen = (size_t)1 << new_hashbits; buf = ngtcp2_mem_calloc(map->mem, tablelen, - sizeof(ngtcp2_map_key_type) + sizeof(void *) + - sizeof(uint8_t)); - if (buf == NULL) { + sizeof(ngtcp2_map_key_type) + sizeof(size_t) + + sizeof(void *)); + if (!buf) { return NGTCP2_ERR_NOMEM; } new_map.keys = buf; - new_map.data = - (void *)((uint8_t *)new_map.keys + tablelen * sizeof(ngtcp2_map_key_type)); - new_map.psl = (uint8_t *)new_map.data + tablelen * sizeof(void *); + new_map.psl = (size_t *)(void *)((uint8_t *)new_map.keys + + tablelen * sizeof(ngtcp2_map_key_type)); + new_map.data = (void *)((uint8_t *)new_map.psl + tablelen * sizeof(size_t)); if (map->size) { tablelen = (size_t)1 << map->hashbits; @@ -213,31 +215,26 @@ static int map_resize(ngtcp2_map *map, size_t new_hashbits) { continue; } - idx = map_insert(&new_map, map->keys[i], map->data[i]); + rv = map_insert(&new_map, map->keys[i], map->data[i]); /* map_insert must not fail because all keys are unique during resize. */ - assert(idx >= 0); + assert(0 == rv); } } ngtcp2_mem_free(map->mem, map->keys); map->keys = new_map.keys; - map->data = new_map.data; map->psl = new_map.psl; + map->data = new_map.data; map->hashbits = new_hashbits; return 0; } -/* NGTCP2_MAX_PSL_RESIZE_THRESH is the maximum psl threshold. If - reached, resize the table. */ -#define NGTCP2_MAX_PSL_RESIZE_THRESH 128 - int ngtcp2_map_insert(ngtcp2_map *map, ngtcp2_map_key_type key, void *data) { int rv; size_t tablelen; - ngtcp2_ssize idx; assert(data); @@ -254,27 +251,9 @@ int ngtcp2_map_insert(ngtcp2_map *map, ngtcp2_map_key_type key, void *data) { if (rv != 0) { return rv; } - - idx = map_insert(map, key, data); - if (idx < 0) { - return (int)idx; - } - - return 0; - } - - idx = map_insert(map, key, data); - if (idx < 0) { - return (int)idx; - } - - /* Resize if psl reaches really large value which is almost - improbable, but just in case. */ - if (map->psl[idx] - 1 < NGTCP2_MAX_PSL_RESIZE_THRESH) { - return 0; } - return map_resize(map, map->hashbits + 1); + return map_insert(map, key, data); } void *ngtcp2_map_find(const ngtcp2_map *map, ngtcp2_map_key_type key) { @@ -332,7 +311,7 @@ int ngtcp2_map_remove(ngtcp2_map *map, ngtcp2_map_key_type key) { break; } - map_set_entry(map, dest, map->keys[idx], map->data[idx], kpsl - 1); + map_set_entry(map, dest, map->keys[idx], kpsl - 1, map->data[idx]); dest = idx; diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_map.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_map.h index 1afe3167e65..524e02e3930 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_map.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_map.h @@ -40,11 +40,11 @@ typedef uint64_t ngtcp2_map_key_type; typedef struct ngtcp2_map { ngtcp2_map_key_type *keys; - void **data; /* psl is the Probe Sequence Length. 0 has special meaning that the element is not stored at i-th position if psl[i] == 0. Because of this, the actual psl value is psl[i] - 1 if psl[i] > 0. */ - uint8_t *psl; + size_t *psl; + void **data; const ngtcp2_mem *mem; uint64_t seed; size_t size; diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_pkt.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_pkt.c index d146145843b..06595fe6be8 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_pkt.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_pkt.c @@ -70,7 +70,9 @@ int ngtcp2_pkt_decode_version_cid(ngtcp2_version_cid *dest, const uint8_t *data, size_t dcidlen, scidlen; int supported_version; - assert(datalen); + if (datalen == 0) { + return NGTCP2_ERR_INVALID_ARGUMENT; + } if (data[0] & NGTCP2_HEADER_FORM_BIT) { /* 1 byte (Header Form, Fixed Bit, Long Packet Type, Type-Specific bits) @@ -307,7 +309,7 @@ ngtcp2_ssize ngtcp2_pkt_decode_hd_long(ngtcp2_pkt_hd *dest, const uint8_t *pkt, ngtcp2_get_uvarint(&vi, p); #if SIZE_MAX < UINT64_MAX - if (vi > SIZE_MAX) { + if (vi > SIZE_MAX / 2) { return NGTCP2_ERR_INVALID_ARGUMENT; } #endif /* SIZE_MAX < UINT64_MAX */ @@ -1087,7 +1089,7 @@ ngtcp2_ssize ngtcp2_pkt_decode_data_blocked_frame(ngtcp2_data_blocked *dest, } dest->type = NGTCP2_FRAME_DATA_BLOCKED; - p = ngtcp2_get_uvarint(&dest->offset, p); + p = ngtcp2_get_uvarint(&dest->max_data, p); assert((size_t)(p - payload) == len); @@ -1126,7 +1128,7 @@ ngtcp2_ssize ngtcp2_pkt_decode_stream_data_blocked_frame( dest->type = NGTCP2_FRAME_STREAM_DATA_BLOCKED; p = ngtcp2_get_varint(&dest->stream_id, p); - p = ngtcp2_get_uvarint(&dest->offset, p); + p = ngtcp2_get_uvarint(&dest->max_stream_data, p); assert((size_t)(p - payload) == len); @@ -1820,7 +1822,7 @@ ngtcp2_ssize ngtcp2_pkt_encode_ping_frame(uint8_t *out, size_t outlen, ngtcp2_ssize ngtcp2_pkt_encode_data_blocked_frame(uint8_t *out, size_t outlen, const ngtcp2_data_blocked *fr) { - size_t len = 1 + ngtcp2_put_uvarintlen(fr->offset); + size_t len = 1 + ngtcp2_put_uvarintlen(fr->max_data); uint8_t *p; if (outlen < len) { @@ -1830,7 +1832,7 @@ ngtcp2_pkt_encode_data_blocked_frame(uint8_t *out, size_t outlen, p = out; *p++ = NGTCP2_FRAME_DATA_BLOCKED; - p = ngtcp2_put_uvarint(p, fr->offset); + p = ngtcp2_put_uvarint(p, fr->max_data); assert((size_t)(p - out) == len); @@ -1840,7 +1842,7 @@ ngtcp2_pkt_encode_data_blocked_frame(uint8_t *out, size_t outlen, ngtcp2_ssize ngtcp2_pkt_encode_stream_data_blocked_frame( uint8_t *out, size_t outlen, const ngtcp2_stream_data_blocked *fr) { size_t len = 1 + ngtcp2_put_uvarintlen((uint64_t)fr->stream_id) + - ngtcp2_put_uvarintlen(fr->offset); + ngtcp2_put_uvarintlen(fr->max_stream_data); uint8_t *p; if (outlen < len) { @@ -1851,7 +1853,7 @@ ngtcp2_ssize ngtcp2_pkt_encode_stream_data_blocked_frame( *p++ = NGTCP2_FRAME_STREAM_DATA_BLOCKED; p = ngtcp2_put_uvarint(p, (uint64_t)fr->stream_id); - p = ngtcp2_put_uvarint(p, fr->offset); + p = ngtcp2_put_uvarint(p, fr->max_stream_data); assert((size_t)(p - out) == len); @@ -2193,8 +2195,7 @@ int64_t ngtcp2_pkt_adjust_pkt_num(int64_t max_pkt_num, int64_t pkt_num, uint64_t mask = win - 1; uint64_t cand = (expected & ~mask) | (uint64_t)pkt_num; - if (cand + hwin <= expected) { - assert(cand <= NGTCP2_MAX_VARINT - win); + if (cand + hwin <= expected && cand <= NGTCP2_MAX_VARINT - win) { return (int64_t)(cand + win); } @@ -2439,11 +2440,6 @@ size_t ngtcp2_pkt_stream_max_datalen(int64_t stream_id, uint64_t offset, left -= n; - if (left > 8 + 1073741823 && len > 1073741823) { - len = ngtcp2_min(len, 4611686018427387903UL); - return (size_t)ngtcp2_min(len, (uint64_t)(left - 8)); - } - if (left > 4 + 16383 && len > 16383) { len = ngtcp2_min(len, 1073741823); return (size_t)ngtcp2_min(len, (uint64_t)(left - 4)); @@ -2469,13 +2465,6 @@ size_t ngtcp2_pkt_crypto_max_datalen(uint64_t offset, size_t len, size_t left) { left -= n; - if (left > 8 + 1073741823 && len > 1073741823) { -#if SIZE_MAX == UINT64_MAX - len = ngtcp2_min(len, 4611686018427387903UL); -#endif /* SIZE_MAX == UINT64_MAX */ - return ngtcp2_min(len, left - 8); - } - if (left > 4 + 16383 && len > 16383) { len = ngtcp2_min(len, 1073741823); return ngtcp2_min(len, left - 4); diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_pkt.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_pkt.h index b6c818d491a..68f81d75521 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_pkt.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_pkt.h @@ -281,13 +281,13 @@ typedef struct ngtcp2_ping { typedef struct ngtcp2_data_blocked { uint64_t type; - uint64_t offset; + uint64_t max_data; } ngtcp2_data_blocked; typedef struct ngtcp2_stream_data_blocked { uint64_t type; int64_t stream_id; - uint64_t offset; + uint64_t max_stream_data; } ngtcp2_stream_data_blocked; typedef struct ngtcp2_streams_blocked { diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_ppe.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_ppe.c index 81bc3296de8..0fb723d8ceb 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_ppe.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_ppe.c @@ -86,7 +86,12 @@ int ngtcp2_ppe_encode_hd(ngtcp2_ppe *ppe, const ngtcp2_pkt_hd *hd) { buf->last += rv; - if (ngtcp2_buf_cap(buf) < ppe_sample_offset(ppe) + NGTCP2_HP_SAMPLELEN) { + /* The space for header protection sample only guarantees 4 - + hd->pkt_numlen bytes of payload, which is 0 if packet number is + encoded in 4 bytes. A packet must contain at least one frame, so + make sure that at least 1 byte of payload can be written. */ + if (ngtcp2_buf_cap(buf) < ppe_sample_offset(ppe) + NGTCP2_HP_SAMPLELEN || + ngtcp2_ppe_left(ppe) == 0) { return NGTCP2_ERR_NOBUF; } diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_ppe.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_ppe.h index ba9edc698ad..5ba61fffb6f 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_ppe.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_ppe.h @@ -70,7 +70,8 @@ void ngtcp2_ppe_init(ngtcp2_ppe *ppe, uint8_t *out, size_t outlen, size_t dgram_offset, ngtcp2_crypto_cc *cc); /* - * ngtcp2_ppe_encode_hd encodes |hd|. + * ngtcp2_ppe_encode_hd encodes |hd|. If it succeeds, it is + * guaranteed that at least 1 byte of payload can be written. * * This function returns 0 if it succeeds, or one of the following * negative error codes: diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_pv.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_pv.c index f9abba46daf..eae6018bb85 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_pv.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_pv.c @@ -117,7 +117,12 @@ int ngtcp2_pv_validate(ngtcp2_pv *pv, uint8_t *pflags, void ngtcp2_pv_handle_entry_expiry(ngtcp2_pv *pv, ngtcp2_tstamp ts) { ngtcp2_pv_entry *ent; - if (ngtcp2_ringbuf_len(&pv->ents.rb) == 0) { + /* Do not start new round until at least one PATH_CHALLENGE is sent + in the current round. It might not be sent (e.g., server is + blocked by anti-amplification limit), and the last entry remains + expired. */ + if (ngtcp2_ringbuf_len(&pv->ents.rb) == 0 || + pv->probe_pkt_left == NGTCP2_PV_NUM_PROBE_PKT) { return; } @@ -158,13 +163,21 @@ int ngtcp2_pv_validation_timed_out(ngtcp2_pv *pv, ngtcp2_tstamp ts) { ngtcp2_tstamp ngtcp2_pv_next_expiry(ngtcp2_pv *pv) { ngtcp2_pv_entry *ent; - if ((pv->flags & NGTCP2_PV_FLAG_CANCEL_TIMER) || - ngtcp2_ringbuf_len(&pv->ents.rb) == 0) { + if (ngtcp2_ringbuf_len(&pv->ents.rb) == 0) { return UINT64_MAX; } ent = ngtcp2_ringbuf_get(&pv->ents.rb, ngtcp2_ringbuf_len(&pv->ents.rb) - 1); + if (pv->flags & NGTCP2_PV_FLAG_CANCEL_TIMER) { + /* The timer of the last entry has expired, but a new + PATH_CHALLENGE might never be sent (e.g., server is blocked by + anti-amplification limit), which leaves no timer armed. Keep + the timer for the timeout of path validation armed, which is + the value ngtcp2_pv_validation_timed_out compares with. */ + return ngtcp2_max(pv->started_ts + pv->timeout, ent->expiry); + } + return ent->expiry; } diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_pv.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_pv.h index 28bdf722b20..2d3c16a93b6 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_pv.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_pv.h @@ -69,19 +69,24 @@ void ngtcp2_pv_entry_init(ngtcp2_pv_entry *pvent, /* NGTCP2_PV_FLAG_DONT_CARE indicates that the outcome of path validation should be ignored entirely. */ #define NGTCP2_PV_FLAG_DONT_CARE 0x01U -/* NGTCP2_PV_FLAG_CANCEL_TIMER indicates that the expiry timer is - cancelled. */ +/* NGTCP2_PV_FLAG_CANCEL_TIMER indicates that the expiry timer of the + last ngtcp2_pv_entry is cancelled. The timer for the timeout of + path validation itself is still armed. */ #define NGTCP2_PV_FLAG_CANCEL_TIMER 0x02U /* NGTCP2_PV_FLAG_FALLBACK_PRESENT indicates that a fallback Destination Connection ID and PTO are available in ngtcp2_pv. If path validation fails, then fallback to them. If path validation succeeds, the fallback Destination Connection ID is retired if it is not zero length, and does not equal to the current Destination - Connection ID. */ + Connection ID, and NGTCP2_PV_FLAG_DONT_RETIRE_FALLBACK is not + set. */ #define NGTCP2_PV_FLAG_FALLBACK_PRESENT 0x04U /* NGTCP2_PV_FLAG_PREFERRED_ADDR indicates that client is migrating to server's preferred address. This flag is only used by client. */ #define NGTCP2_PV_FLAG_PREFERRED_ADDR 0x10U +/* NGTCP2_PV_FLAG_DONT_RETIRE_FALLBACK prevents the fallback + Destination Connection ID from being retired. */ +#define NGTCP2_PV_FLAG_DONT_RETIRE_FALLBACK 0x20U typedef struct ngtcp2_pv ngtcp2_pv; @@ -170,6 +175,9 @@ int ngtcp2_pv_validate(ngtcp2_pv *pv, uint8_t *pflags, /* * ngtcp2_pv_handle_entry_expiry checks expiry of existing entries. + * If the last entry has expired, it starts new round. Calling this + * function again has no effect until new entry is added by + * ngtcp2_pv_add_entry. */ void ngtcp2_pv_handle_entry_expiry(ngtcp2_pv *pv, ngtcp2_tstamp ts); @@ -191,7 +199,10 @@ int ngtcp2_pv_validation_timed_out(ngtcp2_pv *pv, ngtcp2_tstamp ts); ngtcp2_tstamp ngtcp2_pv_next_expiry(ngtcp2_pv *pv); /* - * ngtcp2_pv_cancel_expired_timer cancels the expired timer. + * ngtcp2_pv_cancel_expired_timer cancels the expired timer. It does + * not cancel the timer for the timeout of path validation. The + * caller must check it with ngtcp2_pv_validation_timed_out before + * calling this function. */ void ngtcp2_pv_cancel_expired_timer(ngtcp2_pv *pv, ngtcp2_tstamp ts); diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_qlog.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_qlog.c index 9f233b6cd83..6e85793f3bb 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_qlog.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_qlog.c @@ -488,7 +488,7 @@ static uint8_t *write_data_blocked_frame(uint8_t *p, #define NGTCP2_QLOG_DATA_BLOCKED_FRAME_OVERHEAD 57 p = write_verbatim(p, "{\"frame_type\":\"data_blocked\","); - p = write_pair_number(p, "limit", fr->offset); + p = write_pair_number(p, "limit", fr->max_data); *p++ = '}'; return p; @@ -505,7 +505,7 @@ write_stream_data_blocked_frame(uint8_t *p, p = write_verbatim(p, "{\"frame_type\":\"stream_data_blocked\","); p = write_pair_number(p, "stream_id", (uint64_t)fr->stream_id); *p++ = ','; - p = write_pair_number(p, "limit", fr->offset); + p = write_pair_number(p, "limit", fr->max_stream_data); *p++ = '}'; return p; diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_ratelim.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_ratelim.c index d13ed9a14aa..46a1b8f6902 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_ratelim.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_ratelim.c @@ -31,6 +31,8 @@ void ngtcp2_ratelim_init(ngtcp2_ratelim *rlim, uint64_t burst, uint64_t rate, ngtcp2_tstamp ts) { + burst = ngtcp2_min(burst, NGTCP2_RATELIM_MAX_BURST); + *rlim = (ngtcp2_ratelim){ .burst = burst, .rate = rate, @@ -52,19 +54,16 @@ static void ratelim_update(ngtcp2_ratelim *rlim, ngtcp2_tstamp ts) { d = ts - rlim->ts; rlim->ts = ts; - if (rlim->rate > (UINT64_MAX - rlim->carry) / d) { - gain = UINT64_MAX; - } else { + if (rlim->rate <= (UINT64_MAX - rlim->carry) / d) { gain = rlim->rate * d + rlim->carry; - } + gps = gain / NGTCP2_SECONDS; - gps = gain / NGTCP2_SECONDS; + if (gps < rlim->burst && rlim->tokens < rlim->burst - gps) { + rlim->tokens += gps; + rlim->carry = gain % NGTCP2_SECONDS; - if (gps < rlim->burst && rlim->tokens < rlim->burst - gps) { - rlim->tokens += gps; - rlim->carry = gain % NGTCP2_SECONDS; - - return; + return; + } } rlim->tokens = rlim->burst; diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_ratelim.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_ratelim.h index 231f5d1b018..f85cd6df845 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_ratelim.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_ratelim.h @@ -32,6 +32,9 @@ #include +/* NGTCP2_RATELIM_MAX_BURST is the maximum value of the burst. */ +#define NGTCP2_RATELIM_MAX_BURST (UINT64_MAX / NGTCP2_SECONDS) + typedef struct ngtcp2_ratelim { /* burst is the maximum number of tokens. */ uint64_t burst; @@ -47,8 +50,8 @@ typedef struct ngtcp2_ratelim { ngtcp2_tstamp ts; } ngtcp2_ratelim; -/* ngtcp2_ratelim_init initializes |rlim| with the given - parameters. */ +/* ngtcp2_ratelim_init initializes |rlim| with the given parameters. + |burst| is clamped to NGTCP2_RATELIM_MAX_BURST. */ void ngtcp2_ratelim_init(ngtcp2_ratelim *rlim, uint64_t burst, uint64_t rate, ngtcp2_tstamp ts); diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_rob.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_rob.c index 56b0d81fc13..f0a9aa4f5f0 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_rob.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_rob.c @@ -62,7 +62,6 @@ int ngtcp2_rob_init(ngtcp2_rob *rob, size_t chunk, const ngtcp2_mem *mem) { rob->chunk = chunk; rob->mem = mem; - rob->discard_data = 0; return 0; } @@ -96,10 +95,6 @@ static int rob_write_data(ngtcp2_rob *rob, uint64_t offset, const uint8_t *data, const ngtcp2_range *r; uint64_t chunk_offset; - if (rob->discard_data) { - return 0; - } - for (it = ngtcp2_ksl_lower_bound_search(&rob->dataksl, &range, ngtcp2_ksl_range_exclusive_search); len; ngtcp2_ksl_it_next(&it)) { @@ -235,10 +230,6 @@ void ngtcp2_rob_remove_prefix(ngtcp2_rob *rob, uint64_t offset) { ngtcp2_ksl_remove_hint(&rob->gapksl, &it, &it, &g); } - if (rob->discard_data) { - return; - } - it = ngtcp2_ksl_begin(&rob->dataksl); for (; !ngtcp2_ksl_it_end(&it);) { @@ -254,8 +245,8 @@ void ngtcp2_rob_remove_prefix(ngtcp2_rob *rob, uint64_t offset) { } } -uint64_t ngtcp2_rob_data_at(const ngtcp2_rob *rob, const uint8_t **pdest, - uint64_t offset) { +size_t ngtcp2_rob_data_at(const ngtcp2_rob *rob, const uint8_t **pdest, + uint64_t offset) { const ngtcp2_range *g; const ngtcp2_range *r; uint8_t *d; @@ -272,12 +263,6 @@ uint64_t ngtcp2_rob_data_at(const ngtcp2_rob *rob, const uint8_t **pdest, return 0; } - if (rob->discard_data) { - *pdest = NULL; - - return g->begin - offset; - } - it = ngtcp2_ksl_begin(&rob->dataksl); r = ngtcp2_ksl_it_key(&it); d = ngtcp2_ksl_it_get(&it); @@ -288,18 +273,14 @@ uint64_t ngtcp2_rob_data_at(const ngtcp2_rob *rob, const uint8_t **pdest, *pdest = d + (offset - r->begin); - return ngtcp2_min(g->begin, r->end) - offset; + return (size_t)(ngtcp2_min(g->begin, r->end) - offset); } -void ngtcp2_rob_pop(ngtcp2_rob *rob, uint64_t offset, uint64_t len) { +void ngtcp2_rob_pop(ngtcp2_rob *rob, uint64_t offset, size_t len) { ngtcp2_ksl_it it; ngtcp2_range r; uint8_t *d; - if (rob->discard_data) { - return; - } - it = ngtcp2_ksl_begin(&rob->dataksl); r = *(const ngtcp2_range *)ngtcp2_ksl_it_key(&it); d = ngtcp2_ksl_it_get(&it); @@ -330,16 +311,3 @@ uint64_t ngtcp2_rob_first_gap_offset(const ngtcp2_rob *rob) { int ngtcp2_rob_data_buffered(const ngtcp2_rob *rob) { return ngtcp2_ksl_len(&rob->dataksl) != 0; } - -void ngtcp2_rob_discard_data(ngtcp2_rob *rob) { - ngtcp2_ksl_it it; - - rob->discard_data = 1; - - for (it = ngtcp2_ksl_begin(&rob->dataksl); !ngtcp2_ksl_it_end(&it); - ngtcp2_ksl_it_next(&it)) { - rob_data_del(ngtcp2_ksl_it_get(&it), rob->mem); - } - - ngtcp2_ksl_clear(&rob->dataksl); -} diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_rob.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_rob.h index 6b616ea9b81..84194cae986 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_rob.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_rob.h @@ -50,9 +50,6 @@ typedef struct ngtcp2_rob { const ngtcp2_mem *mem; /* chunk is the size of each buffer in data field */ size_t chunk; - /* discard_data, if nonzero, stops buffering data. If it is - nonzero, ngtcp2_ksl_empty(&dataksl) always returns nonzero. */ - int discard_data; } ngtcp2_rob; /* @@ -76,10 +73,6 @@ void ngtcp2_rob_free(ngtcp2_rob *rob); * ngtcp2_rob_push adds new data pointed by |data| of length |datalen| * at the stream offset |offset|. * - * If ngtcp2_rob_discard_data is called, this function does not buffer - * data. The return value is the number of bytes that would be - * buffered if ngtcp2_rob_discard_data has not been called. - * * This function returns the number of data newly buffered if it * succeeds, or one of the following negative error codes: * @@ -102,11 +95,9 @@ void ngtcp2_rob_remove_prefix(ngtcp2_rob *rob, uint64_t offset); * valid length of available data. If no data is available, it * returns 0. This function only returns the data before the first * gap. It returns 0 even if data is available after the first gap. - * If ngtcp2_rob_discard_data has been called, NULL is assigned to - * |*pdest| if this function returns nonzero. */ -uint64_t ngtcp2_rob_data_at(const ngtcp2_rob *rob, const uint8_t **pdest, - uint64_t offset); +size_t ngtcp2_rob_data_at(const ngtcp2_rob *rob, const uint8_t **pdest, + uint64_t offset); /* * ngtcp2_rob_pop clears data at stream offset |offset| of length @@ -118,10 +109,8 @@ uint64_t ngtcp2_rob_data_at(const ngtcp2_rob *rob, const uint8_t **pdest, * * Caller should call this function from offset 0 in non-decreasing * order. - * - * ngtcp2_rob_pop is noop if ngtcp2_rob_discard_data has been called. */ -void ngtcp2_rob_pop(ngtcp2_rob *rob, uint64_t offset, uint64_t len); +void ngtcp2_rob_pop(ngtcp2_rob *rob, uint64_t offset, size_t len); /* * ngtcp2_rob_first_gap_offset returns the offset to the first gap. @@ -134,10 +123,4 @@ uint64_t ngtcp2_rob_first_gap_offset(const ngtcp2_rob *rob); */ int ngtcp2_rob_data_buffered(const ngtcp2_rob *rob); -/* - * ngtcp2_rob_discard_data discards the buffered data, and stops - * buffering data any further. - */ -void ngtcp2_rob_discard_data(ngtcp2_rob *rob); - #endif /* !defined(NGTCP2_ROB_H) */ diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_rtb.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_rtb.c index e8d05a3fead..11336ce370b 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_rtb.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_rtb.c @@ -106,6 +106,7 @@ void ngtcp2_rtb_init(ngtcp2_rtb *rtb, ngtcp2_rst *rst, ngtcp2_cc *cc, rtb->cc_bytes_in_flight = 0; rtb->num_lost_pkts = 0; rtb->num_lost_ignore_pkts = 0; + rtb->pto_reclaim_pkt_num = -1; } void ngtcp2_rtb_free(ngtcp2_rtb *rtb) { @@ -247,7 +248,8 @@ static ngtcp2_ssize rtb_reclaim_frame(ngtcp2_rtb *rtb, uint8_t flags, fr->stream.offset + ngtcp2_vec_len(fr->stream.data, fr->stream.datacnt); range = ngtcp2_range_intersect(&range, &gap); - if (ngtcp2_range_len(&range) == 0 && !fr->stream.fin && + if (ngtcp2_range_len(&range) == 0 && + (!fr->stream.fin || (strm->flags & NGTCP2_STRM_FLAG_FIN_ACKED)) && /* 0 length STREAM frame with offset == 0 must be retransmitted if no non-empty data are sent to this stream, fin flag is not set, and no data in this stream @@ -286,13 +288,9 @@ static ngtcp2_ssize rtb_reclaim_frame(ngtcp2_rtb *rtb, uint8_t flags, return rv; } - if (!ngtcp2_strm_is_tx_queued(strm)) { - strm->cycle = ngtcp2_conn_tx_strmq_first_cycle(conn); - - rv = ngtcp2_conn_tx_strmq_push(conn, strm); - if (rv != 0) { - return rv; - } + rv = ngtcp2_conn_tx_strmq_push_if_not(conn, strm); + if (rv != 0) { + return rv; } ++num_reclaimed; @@ -348,6 +346,7 @@ static ngtcp2_ssize rtb_reclaim_frame(ngtcp2_rtb *rtb, uint8_t flags, rv = ngtcp2_bind_frame_chains(frc, nfrc, rtb->mem); if (rv != 0) { + ngtcp2_frame_chain_objalloc_del(nfrc, rtb->frc_objalloc, rtb->mem); return rv; } @@ -374,6 +373,18 @@ static ngtcp2_ssize rtb_reclaim_frame(ngtcp2_rtb *rtb, uint8_t flags, continue; } + break; + case NGTCP2_FRAME_MAX_STREAMS_BIDI: + if (fr->max_streams.max_streams < conn->rx.bidi.max_streams) { + continue; + } + + break; + case NGTCP2_FRAME_MAX_STREAMS_UNI: + if (fr->max_streams.max_streams < conn->rx.uni.max_streams) { + continue; + } + break; case NGTCP2_FRAME_MAX_STREAM_DATA: strm = ngtcp2_conn_find_stream(conn, fr->max_stream_data.stream_id); @@ -382,6 +393,12 @@ static ngtcp2_ssize rtb_reclaim_frame(ngtcp2_rtb *rtb, uint8_t flags, continue; } + break; + case NGTCP2_FRAME_MAX_DATA: + if (fr->max_data.max_data < conn->rx.max_offset) { + continue; + } + break; case NGTCP2_FRAME_STREAM_DATA_BLOCKED: strm = ngtcp2_conn_find_stream(conn, fr->stream_data_blocked.stream_id); @@ -390,6 +407,12 @@ static ngtcp2_ssize rtb_reclaim_frame(ngtcp2_rtb *rtb, uint8_t flags, continue; } + break; + case NGTCP2_FRAME_DATA_BLOCKED: + if (fr->data_blocked.max_data != conn->tx.max_offset) { + continue; + } + break; } @@ -402,6 +425,7 @@ static ngtcp2_ssize rtb_reclaim_frame(ngtcp2_rtb *rtb, uint8_t flags, rv = ngtcp2_bind_frame_chains(frc, nfrc, rtb->mem); if (rv != 0) { + ngtcp2_frame_chain_objalloc_del(nfrc, rtb->frc_objalloc, rtb->mem); return rv; } @@ -481,30 +505,31 @@ static int rtb_on_pkt_lost(ngtcp2_rtb *rtb, ngtcp2_rtb_entry *ent, } } + /* DATAGRAM frame is not reclaimed on PTO, so its loss must be + notified even if the packet has already been reclaimed on + PTO. */ + if (conn->callbacks.lost_datagram && + (ent->flags & NGTCP2_RTB_ENTRY_FLAG_DATAGRAM)) { + rv = conn_process_lost_datagram(conn, ent); + if (rv != 0) { + return rv; + } + } + if (ent->flags & NGTCP2_RTB_ENTRY_FLAG_PTO_RECLAIMED) { ngtcp2_log_infof(rtb->log, NGTCP2_LOG_EVENT_LDC, "pkn=", ent->hd.pkt_num, " has already been reclaimed on PTO"); assert(!(ent->flags & NGTCP2_RTB_ENTRY_FLAG_LOST_RETRANSMITTED)); assert(UINT64_MAX == ent->lost_ts); - } else { - if (conn->callbacks.lost_datagram && - (ent->flags & NGTCP2_RTB_ENTRY_FLAG_DATAGRAM)) { - rv = conn_process_lost_datagram(conn, ent); - if (rv != 0) { - return rv; - } - } - - if (ent->flags & NGTCP2_RTB_ENTRY_FLAG_RETRANSMITTABLE) { - assert(ent->frc); - assert(!(ent->flags & NGTCP2_RTB_ENTRY_FLAG_LOST_RETRANSMITTED)); - assert(UINT64_MAX == ent->lost_ts); + } else if (ent->flags & NGTCP2_RTB_ENTRY_FLAG_RETRANSMITTABLE) { + assert(ent->frc); + assert(!(ent->flags & NGTCP2_RTB_ENTRY_FLAG_LOST_RETRANSMITTED)); + assert(UINT64_MAX == ent->lost_ts); - reclaimed = - rtb_reclaim_frame(rtb, NGTCP2_RECLAIM_FLAG_ON_LOSS, conn, pktns, ent); - if (reclaimed < 0) { - return (int)reclaimed; - } + reclaimed = + rtb_reclaim_frame(rtb, NGTCP2_RECLAIM_FLAG_ON_LOSS, conn, pktns, ent); + if (reclaimed < 0) { + return (int)reclaimed; } } @@ -798,7 +823,7 @@ ngtcp2_ssize ngtcp2_rtb_recv_ack(ngtcp2_rtb *rtb, const ngtcp2_ack *fr, size_t i; int rv; ngtcp2_ksl_it it; - size_t num_acked = 0; + size_t num_acked = 0, num_cc_acked = 0; int64_t pkt_num; ngtcp2_cc *cc = rtb->cc; ngtcp2_rtb_entry *acked_ent = NULL; @@ -855,7 +880,10 @@ ngtcp2_ssize ngtcp2_rtb_recv_ack(ngtcp2_rtb *rtb, const ngtcp2_ack *fr, ent = ngtcp2_ksl_it_get(&it); - if (ent->flags & NGTCP2_RTB_ENTRY_FLAG_SKIP) { + /* A packet cannot acknowledge a packet which was sent after it + had been received. This could happen with a buffered + packet. */ + if ((ent->flags & NGTCP2_RTB_ENTRY_FLAG_SKIP) || pkt_ts < ent->ts) { rv = NGTCP2_ERR_PROTO; goto fail; } @@ -888,7 +916,7 @@ ngtcp2_ssize ngtcp2_rtb_recv_ack(ngtcp2_rtb *rtb, const ngtcp2_ack *fr, ent = ngtcp2_ksl_it_get(&it); - if (ent->flags & NGTCP2_RTB_ENTRY_FLAG_SKIP) { + if ((ent->flags & NGTCP2_RTB_ENTRY_FLAG_SKIP) || pkt_ts < ent->ts) { rv = NGTCP2_ERR_PROTO; goto fail; } @@ -928,9 +956,11 @@ ngtcp2_ssize ngtcp2_rtb_recv_ack(ngtcp2_rtb *rtb, const ngtcp2_ack *fr, rtb_on_pkt_acked(rtb, ent, cstat, pktns, ts); - ++num_acked; + ++num_cc_acked; } + ++num_acked; + acked_ent = ent->next; ngtcp2_rtb_entry_objalloc_del(ent, rtb->rtb_entry_objalloc, rtb->frc_objalloc, rtb->mem); @@ -940,6 +970,7 @@ ngtcp2_ssize ngtcp2_rtb_recv_ack(ngtcp2_rtb *rtb, const ngtcp2_ack *fr, for (ent = acked_ent; ent; ent = acked_ent) { rtb_on_pkt_acked(rtb, ent, cstat, pktns, ts); acked_ent = ent->next; + ++num_cc_acked; ++num_acked; ngtcp2_rtb_entry_objalloc_del(ent, rtb->rtb_entry_objalloc, rtb->frc_objalloc, rtb->mem); @@ -951,9 +982,11 @@ ngtcp2_ssize ngtcp2_rtb_recv_ack(ngtcp2_rtb *rtb, const ngtcp2_ack *fr, rtb->cc->on_spurious_congestion(cc, cstat, ts); } - if (num_acked) { + if (num_cc_acked) { ngtcp2_rst_on_ack_recv(rtb->rst, cstat); + } + if (num_acked) { if (conn) { rv = rtb_detect_lost_pkt(rtb, &cc_ack, conn, pktns, cstat, ts); if (rv != 0) { @@ -1189,7 +1222,7 @@ static int rtb_detect_lost_pkt(ngtcp2_rtb *rtb, ngtcp2_cc_ack *cc_ack, } } - ngtcp2_rtb_remove_excessive_lost_pkt(rtb, (size_t)pkt_thres); + ngtcp2_rtb_remove_excessive_lost_pkt(rtb, (size_t)pkt_thres, cstat, ts); return 0; } @@ -1205,7 +1238,34 @@ int ngtcp2_rtb_detect_lost_pkt(ngtcp2_rtb *rtb, ngtcp2_conn *conn, conn, pktns, cstat, ts); } -void ngtcp2_rtb_remove_excessive_lost_pkt(ngtcp2_rtb *rtb, size_t n) { +/* + * rtb_on_lost_pkt_removed is called when a lost packet |ent| is + * removed from |rtb| without being acknowledged. It tells the + * congestion controller that the loss is not spurious. + */ +static void rtb_on_lost_pkt_removed(ngtcp2_rtb *rtb, ngtcp2_rtb_entry *ent, + ngtcp2_conn_stat *cstat, ngtcp2_tstamp ts) { + ngtcp2_cc *cc = rtb->cc; + + assert(ent->flags & NGTCP2_RTB_ENTRY_FLAG_LOST_RETRANSMITTED); + + --rtb->num_lost_pkts; + + if (ent->flags & + (NGTCP2_RTB_ENTRY_FLAG_PMTUD_PROBE | NGTCP2_RTB_ENTRY_FLAG_SKIP)) { + --rtb->num_lost_ignore_pkts; + + return; + } + + if (cc->on_pkt_lost_confirmed) { + cc->on_pkt_lost_confirmed(cc, cstat, ts); + } +} + +void ngtcp2_rtb_remove_excessive_lost_pkt(ngtcp2_rtb *rtb, size_t n, + ngtcp2_conn_stat *cstat, + ngtcp2_tstamp ts) { ngtcp2_ksl_it it = ngtcp2_ksl_end(&rtb->ents); ngtcp2_rtb_entry *ent; int rv; @@ -1221,12 +1281,7 @@ void ngtcp2_rtb_remove_excessive_lost_pkt(ngtcp2_rtb *rtb, size_t n) { ngtcp2_log_infof(rtb->log, NGTCP2_LOG_EVENT_LDC, "removing stale lost pkn=", ent->hd.pkt_num); - --rtb->num_lost_pkts; - - if (ent->flags & - (NGTCP2_RTB_ENTRY_FLAG_PMTUD_PROBE | NGTCP2_RTB_ENTRY_FLAG_SKIP)) { - --rtb->num_lost_ignore_pkts; - } + rtb_on_lost_pkt_removed(rtb, ent, cstat, ts); rv = ngtcp2_ksl_remove_hint(&rtb->ents, &it, &it, &ent->hd.pkt_num); assert(0 == rv); @@ -1237,6 +1292,7 @@ void ngtcp2_rtb_remove_excessive_lost_pkt(ngtcp2_rtb *rtb, size_t n) { void ngtcp2_rtb_remove_expired_lost_pkt(ngtcp2_rtb *rtb, ngtcp2_duration timeout, + ngtcp2_conn_stat *cstat, ngtcp2_tstamp ts) { ngtcp2_ksl_it it; ngtcp2_rtb_entry *ent; @@ -1264,12 +1320,7 @@ void ngtcp2_rtb_remove_expired_lost_pkt(ngtcp2_rtb *rtb, ngtcp2_log_infof(rtb->log, NGTCP2_LOG_EVENT_LDC, "removing stale lost pkn=", ent->hd.pkt_num); - --rtb->num_lost_pkts; - - if (ent->flags & - (NGTCP2_RTB_ENTRY_FLAG_PMTUD_PROBE | NGTCP2_RTB_ENTRY_FLAG_SKIP)) { - --rtb->num_lost_ignore_pkts; - } + rtb_on_lost_pkt_removed(rtb, ent, cstat, ts); rv = ngtcp2_ksl_remove_hint(&rtb->ents, &it, &it, &ent->hd.pkt_num); assert(0 == rv); @@ -1320,18 +1371,26 @@ static int rtb_reclaim_frame_on_retry(ngtcp2_rtb *rtb, ngtcp2_conn *conn, break; } + /* 0 length STREAM frame with offset == 0 must be retransmitted + only if no non-empty data are sent to this stream, and fin + flag is not set. Otherwise, it shares the offset with the + first non-empty (or fin ) STREAM frame, and + ngtcp2_strm_streamfrq_push fails. */ + if (sfr->offset == 0 && sfr->datacnt == 0 && !sfr->fin && + (strm->tx.offset || (strm->flags & NGTCP2_STRM_FLAG_SHUT_WR))) { + ngtcp2_frame_chain_objalloc_del(frc, rtb->frc_objalloc, rtb->mem); + break; + } + rv = ngtcp2_strm_streamfrq_push(strm, frc); if (rv != 0) { ngtcp2_frame_chain_objalloc_del(frc, rtb->frc_objalloc, rtb->mem); return rv; } - if (!ngtcp2_strm_is_tx_queued(strm)) { - strm->cycle = ngtcp2_conn_tx_strmq_first_cycle(conn); - rv = ngtcp2_conn_tx_strmq_push(conn, strm); - if (rv != 0) { - return rv; - } + rv = ngtcp2_conn_tx_strmq_push_if_not(conn, strm); + if (rv != 0) { + return rv; } break; @@ -1400,11 +1459,6 @@ int ngtcp2_rtb_reclaim_on_retry(ngtcp2_rtb *rtb, ngtcp2_conn *conn, } } - /* We never send PING only probe packet because we should have - CRYPTO data or just nothing. If we have nothing, then we do - not send probe packet. */ - assert(!(ent->flags & NGTCP2_RTB_ENTRY_FLAG_PROBE)); - /* We never get ACK before Retry packet. */ assert(!(ent->flags & NGTCP2_RTB_ENTRY_FLAG_LOST_RETRANSMITTED)); assert(0 == rtb->num_lost_pkts); @@ -1486,11 +1540,13 @@ ngtcp2_ssize ngtcp2_rtb_reclaim_on_pto(ngtcp2_rtb *rtb, ngtcp2_conn *conn, ngtcp2_ssize reclaimed; size_t atmost = num_pkts; - it = ngtcp2_ksl_end(&rtb->ents); + it = ngtcp2_ksl_lower_bound(&rtb->ents, &rtb->pto_reclaim_pkt_num); for (; !ngtcp2_ksl_it_begin(&it) && num_pkts;) { ngtcp2_ksl_it_prev(&it); ent = ngtcp2_ksl_it_get(&it); + rtb->pto_reclaim_pkt_num = ent->hd.pkt_num; + if ((ent->flags & (NGTCP2_RTB_ENTRY_FLAG_LOST_RETRANSMITTED | NGTCP2_RTB_ENTRY_FLAG_PTO_RECLAIMED)) || !(ent->flags & NGTCP2_RTB_ENTRY_FLAG_RETRANSMITTABLE)) { @@ -1512,15 +1568,22 @@ ngtcp2_ssize ngtcp2_rtb_reclaim_on_pto(ngtcp2_rtb *rtb, ngtcp2_conn *conn, assert(rtb->num_retransmittable); --rtb->num_retransmittable; + /* If nothing is reclaimed, no packet is sent on behalf of ent. + Keep ent PTO eliciting so that loss detection timer stays armed, + and PING is sent as a probe. Otherwise, if ent and the packets + reclaimed earlier are lost, nothing removes them from bytes in + flight. */ + if (reclaimed == 0) { + continue; + } + if (ent->flags & NGTCP2_RTB_ENTRY_FLAG_PTO_ELICITING) { ent->flags &= (uint16_t)~NGTCP2_RTB_ENTRY_FLAG_PTO_ELICITING; assert(rtb->num_pto_eliciting); --rtb->num_pto_eliciting; } - if (reclaimed) { - --num_pkts; - } + --num_pkts; } return (ngtcp2_ssize)(atmost - num_pkts); diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_rtb.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_rtb.h index 664498be962..8789b68c84d 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_rtb.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_rtb.h @@ -195,6 +195,11 @@ typedef struct ngtcp2_rtb { excluded from lost byte count. If only those packets are lost, congestion event is not triggered. */ size_t num_lost_ignore_pkts; + /* pto_reclaim_pkt_num is the largest packet number among the + entries that ngtcp2_rtb_reclaim_on_pto has visited, or -1 if it + has not visited any entry yet. The entries up to this packet + number have been reclaimed, or never will be. */ + int64_t pto_reclaim_pkt_num; } ngtcp2_rtb; /* @@ -243,6 +248,9 @@ ngtcp2_ksl_it ngtcp2_rtb_head(const ngtcp2_rtb *rtb); * User callback failed * NGTCP2_ERR_NOMEM * Out of memory + * NGTCP2_ERR_PROTO + * |fr| acknowledges a skipped packet number, or a packet that was + * sent after |pkt_ts|. */ ngtcp2_ssize ngtcp2_rtb_recv_ack(ngtcp2_rtb *rtb, const ngtcp2_ack *fr, ngtcp2_conn_stat *cstat, ngtcp2_conn *conn, @@ -264,6 +272,7 @@ int ngtcp2_rtb_detect_lost_pkt(ngtcp2_rtb *rtb, ngtcp2_conn *conn, */ void ngtcp2_rtb_remove_expired_lost_pkt(ngtcp2_rtb *rtb, ngtcp2_duration timeout, + ngtcp2_conn_stat *cstat, ngtcp2_tstamp ts); /* @@ -302,7 +311,9 @@ void ngtcp2_rtb_reset_cc_state(ngtcp2_rtb *rtb, int64_t cc_pkt_num); * ngtcp2_rtb_remove_excessive_lost_pkt ensures that the number of * lost packets is at most |n|. */ -void ngtcp2_rtb_remove_excessive_lost_pkt(ngtcp2_rtb *rtb, size_t n); +void ngtcp2_rtb_remove_excessive_lost_pkt(ngtcp2_rtb *rtb, size_t n, + ngtcp2_conn_stat *cstat, + ngtcp2_tstamp ts); /* * ngtcp2_rtb_reclaim_on_pto reclaims up to |num_pkts| packets which diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_settings.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_settings.c index 31c52b4d957..4062ddc0ab5 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_settings.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_settings.c @@ -37,6 +37,7 @@ void ngtcp2_settings_default_versioned(int settings_version, switch (settings_version) { case NGTCP2_SETTINGS_VERSION: + case NGTCP2_SETTINGS_V4: case NGTCP2_SETTINGS_V3: settings->glitch_ratelim_burst = NGTCP2_DEFAULT_GLITCH_RATELIM_BURST; settings->glitch_ratelim_rate = NGTCP2_DEFAULT_GLITCH_RATELIM_RATE; @@ -87,6 +88,8 @@ size_t ngtcp2_settingslen_version(int settings_version) { switch (settings_version) { case NGTCP2_SETTINGS_VERSION: return sizeof(settings); + case NGTCP2_SETTINGS_V4: + return offsetof(ngtcp2_settings, log_write) + sizeof(settings.log_write); case NGTCP2_SETTINGS_V3: return offsetof(ngtcp2_settings, glitch_ratelim_rate) + sizeof(settings.glitch_ratelim_rate); diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_strm.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_strm.c index aa01434bf16..b9e2cdfb199 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_strm.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_strm.c @@ -115,9 +115,21 @@ uint64_t ngtcp2_strm_rx_offset(const ngtcp2_strm *strm) { } /* strm_rob_heavily_fragmented returns nonzero if the number of gaps - in |rob| exceeds the limit. */ -static int strm_rob_heavily_fragmented(const ngtcp2_rob *rob) { - return ngtcp2_ksl_len(&rob->gapksl) >= 4000; + in strm->rx.rob exceeds the limit. A gap costs memory no matter + how small it is, while flow control only charges the remote + endpoint for the offset range that the reorder buffer covers. + Therefore, beyond a fixed allowance, each gap must be backed by + NGTCP2_MIN_STREAM_DATALEN bytes of that range. */ +static int strm_rob_heavily_fragmented(const ngtcp2_strm *strm) { + size_t ngap = ngtcp2_ksl_len(&strm->rx.rob->gapksl); + uint64_t rx_offset = ngtcp2_rob_first_gap_offset(strm->rx.rob); + uint64_t span; + + assert(strm->rx.last_offset >= rx_offset); + + span = strm->rx.last_offset - rx_offset; + + return ngap >= 4000 || ngap > 128 + span / NGTCP2_MIN_STREAM_DATALEN; } ngtcp2_ssize ngtcp2_strm_recv_reordering(ngtcp2_strm *strm, const uint8_t *data, @@ -134,10 +146,6 @@ ngtcp2_ssize ngtcp2_strm_recv_reordering(ngtcp2_strm *strm, const uint8_t *data, if (strm->rx.cont_offset) { ngtcp2_rob_remove_prefix(strm->rx.rob, strm->rx.cont_offset); } - - if (strm->flags & NGTCP2_STRM_FLAG_NO_REORDERED_DATA_BUFFERING) { - ngtcp2_rob_discard_data(strm->rx.rob); - } } nwrite = ngtcp2_rob_push(strm->rx.rob, offset, data, datalen); @@ -145,7 +153,7 @@ ngtcp2_ssize ngtcp2_strm_recv_reordering(ngtcp2_strm *strm, const uint8_t *data, return nwrite; } - if (strm_rob_heavily_fragmented(strm->rx.rob)) { + if (strm_rob_heavily_fragmented(strm)) { return NGTCP2_ERR_INTERNAL; } @@ -734,13 +742,12 @@ int ngtcp2_strm_require_retransmit_max_stream_data( int ngtcp2_strm_require_retransmit_stream_data_blocked( const ngtcp2_strm *strm, const ngtcp2_stream_data_blocked *fr) { - return fr->offset == strm->tx.max_offset && + return fr->max_stream_data == strm->tx.max_offset && !(strm->flags & NGTCP2_STRM_FLAG_SHUT_WR); } -uint64_t ngtcp2_strm_discard_ordered_data(ngtcp2_strm *strm, - uint64_t rx_offset) { - uint64_t datalen; +size_t ngtcp2_strm_discard_ordered_data(ngtcp2_strm *strm, uint64_t rx_offset) { + size_t datalen; const uint8_t *data; uint64_t orig_rx_offset = rx_offset; @@ -759,19 +766,5 @@ uint64_t ngtcp2_strm_discard_ordered_data(ngtcp2_strm *strm, rx_offset += datalen; } - return rx_offset - orig_rx_offset; -} - -void ngtcp2_strm_stop_buffering_reordered_data(ngtcp2_strm *strm) { - if (strm->flags & NGTCP2_STRM_FLAG_NO_REORDERED_DATA_BUFFERING) { - return; - } - - strm->flags |= NGTCP2_STRM_FLAG_NO_REORDERED_DATA_BUFFERING; - - if (!strm->rx.rob) { - return; - } - - ngtcp2_rob_discard_data(strm->rx.rob); + return (size_t)(rx_offset - orig_rx_offset); } diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_strm.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_strm.h index 0c47873c3db..6b1b7495d32 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_strm.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_strm.h @@ -89,9 +89,6 @@ typedef struct ngtcp2_frame_chain ngtcp2_frame_chain; /* NGTCP2_STRM_FLAG_ANY_SENT indicates that any STREAM frame, including empty one, has been sent. */ #define NGTCP2_STRM_FLAG_ANY_SENT 0x1000U -/* NGTCP2_STRM_FLAG_NO_REORDERED_DATA_BUFFERING is set when - ngtcp2_strm_stop_buffering_reordered_data is called. */ -#define NGTCP2_STRM_FLAG_NO_REORDERED_DATA_BUFFERING 0x2000U /* NGTCP2_STRM_FLAG_RX_APP_ERROR_CODE_SET is set when ngtcp2_strm.rx.app_error_code is set. */ #define NGTCP2_STRM_FLAG_RX_APP_ERROR_CODE_SET 0x4000U @@ -101,6 +98,14 @@ typedef struct ngtcp2_frame_chain ngtcp2_frame_chain; /* NGTCP2_STRM_FLAG_TX_STOP_SENDING_APP_ERROR_CODE_SET is set when ngtcp2_strm.tx.stop_sending_app_error_code is set. */ #define NGTCP2_STRM_FLAG_TX_STOP_SENDING_APP_ERROR_CODE_SET 0x10000U +/* NGTCP2_STRM_FLAG_SEND_STREAM_DATA_BLOCKED is set when + STREAM_DATA_BLOCKED and/or DATA_BLOCKED frame should be sent. */ +#define NGTCP2_STRM_FLAG_SEND_STREAM_DATA_BLOCKED 0x20000U +/* NGTCP2_STRM_FLAG_RX_FIN_DELIVERED is set when all stream data up to + the final offset have been passed to an application via + ngtcp2_callbacks.recv_stream_data with + NGTCP2_STREAM_DATA_FLAG_FIN. */ +#define NGTCP2_STRM_FLAG_RX_FIN_DELIVERED 0x40000U typedef struct ngtcp2_strm ngtcp2_strm; @@ -234,10 +239,6 @@ uint64_t ngtcp2_strm_rx_offset(const ngtcp2_strm *strm); /* * ngtcp2_strm_recv_reordering handles reordered data. * - * If ngtcp2_strm_stop_buffering_reordered_data has been called, this - * function only records the range of the reordered data. The actual - * data is not buffered. - * * It returns the number of bytes newly buffered if it succeeds, or * one of the following negative error codes: * @@ -382,19 +383,10 @@ int ngtcp2_strm_require_retransmit_max_stream_data( int ngtcp2_strm_require_retransmit_stream_data_blocked( const ngtcp2_strm *strm, const ngtcp2_stream_data_blocked *fr); -/* - * ngtcp2_strm_discard_ordered_data discards the ordered data starting - * at |rx_offset|. It stops when it finds a gap, which means that a - * portion of the data has not been received yet. It returns the size - * of the buffered bytes discarded. - */ -uint64_t ngtcp2_strm_discard_ordered_data(ngtcp2_strm *strm, - uint64_t rx_offset); - -/* - * ngtcp2_strm_stop_buffering_reordered_data discards the buffered - * reordered data, and stops buffering data any further. - */ -void ngtcp2_strm_stop_buffering_reordered_data(ngtcp2_strm *strm); +/* ngtcp2_strm_discard_ordered_data discards the ordered data starting + at |rx_offset|. It stops when it finds a gap, which means that a + portion of the data has not been received yet. It returns the size + of the buffered bytes discarded. */ +size_t ngtcp2_strm_discard_ordered_data(ngtcp2_strm *strm, uint64_t rx_offset); #endif /* !defined(NGTCP2_STRM_H) */ diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_transport_params.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_transport_params.c index f28c4f57b15..59765b1df2a 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_transport_params.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_transport_params.c @@ -586,10 +586,15 @@ int ngtcp2_transport_params_decode_versioned(int transport_params_version, if (decode_varint_param(¶ms->max_idle_timeout, &p, end) != 0) { return NGTCP2_ERR_MALFORMED_TRANSPORT_PARAM; } + /* Because we multiply the value by NGTCP2_MILLISECONDS, the + maximum max_idle_timeout is 18446744073709ms ~= 213504 days. + If it is larger than that, it is truncated. */ if (params->max_idle_timeout > UINT64_MAX / NGTCP2_MILLISECONDS) { - params->max_idle_timeout = UINT64_MAX; + params->max_idle_timeout = + UINT64_MAX / NGTCP2_MILLISECONDS * NGTCP2_MILLISECONDS; + } else { + params->max_idle_timeout *= NGTCP2_MILLISECONDS; } - params->max_idle_timeout *= NGTCP2_MILLISECONDS; break; case NGTCP2_TRANSPORT_PARAM_MAX_UDP_PAYLOAD_SIZE: if (decode_varint_param(¶ms->max_udp_payload_size, &p, end) != 0) { diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_unreachable.h b/deps/ngtcp2/ngtcp2/lib/ngtcp2_unreachable.h index ca712386527..5ef25ad6a3a 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_unreachable.h +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_unreachable.h @@ -43,10 +43,10 @@ #ifdef _MSC_VER __declspec(noreturn) #endif /* defined(_MSC_VER) */ - void ngtcp2_unreachable_fail(const char *file, int line, const char *func) +void ngtcp2_unreachable_fail(const char *file, int line, const char *func) #ifndef _MSC_VER - __attribute__((noreturn)) + __attribute__((noreturn)) #endif /* !defined(_MSC_VER) */ - ; + ; #endif /* !defined(NGTCP2_UNREACHABLE_H) */ diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_vec.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_vec.c index f94c6218d53..57b706685f6 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_vec.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_vec.c @@ -134,6 +134,8 @@ size_t ngtcp2_vec_merge(ngtcp2_vec *dst, size_t *pdstcnt, ngtcp2_vec *src, a = &dst[0]; b = &src[0]; + ++*pdstcnt; + if (left < b->len) { a->len = left; a->base = b->base; @@ -144,7 +146,6 @@ size_t ngtcp2_vec_merge(ngtcp2_vec *dst, size_t *pdstcnt, ngtcp2_vec *src, } *a = *b; - ++*pdstcnt; left -= b->len; i = 1; } diff --git a/src/quic/session.cc b/src/quic/session.cc index 1d06b1fdcc0..e0de45d13fd 100644 --- a/src/quic/session.cc +++ b/src/quic/session.cc @@ -1705,6 +1705,9 @@ struct Session::Impl final : public MemoryRetainer { on_receive_stream_stop_sending, #ifdef NGTCP2_CALLBACKS_V5 nullptr, // stream_close2 +#endif +#ifdef NGTCP2_CALLBACKS_V6 + nullptr, // extend_max_data #endif }; @@ -1757,6 +1760,9 @@ struct Session::Impl final : public MemoryRetainer { on_receive_stream_stop_sending, #ifdef NGTCP2_CALLBACKS_V5 nullptr, // stream_close2 +#endif +#ifdef NGTCP2_CALLBACKS_V6 + nullptr, // extend_max_data #endif }; }; @@ -3707,8 +3713,9 @@ void Session::OnTimeout() { // on a freed object. BaseObjectPtr ref(this); HandleScope scope(env()->isolate()); - int ret; - { + int ret = 0; + // Once we're draining, we don't want ngtcp to handle expired timeouts + if (!is_in_draining_period()) { NgTcp2CallbackScope callback_scope(this); ret = ngtcp2_conn_handle_expiry(*this, uv_hrtime()); } diff --git a/test/parallel/test-quic-callback-error-stream-onerror.mjs b/test/parallel/test-quic-callback-error-stream-onerror.mjs index 0e8505cdb0e..5cc0edc6fe1 100644 --- a/test/parallel/test-quic-callback-error-stream-onerror.mjs +++ b/test/parallel/test-quic-callback-error-stream-onerror.mjs @@ -21,11 +21,18 @@ const serverDone = Promise.withResolvers(); const serverEndpoint = await listen(mustCall((serverSession) => { serverSession.onstream = mustCall(async (stream) => { + // The client destroys its first stream with an error, which resets it. + if (stream.id === 0n) { + await assert.rejects(stream.closed, { + code: 'ERR_QUIC_APPLICATION_ERROR', + }); + return; + } stream.writer.endSync(); await stream.closed; serverSession.close(); serverDone.resolve(); - }); + }, 2); })); const clientSession = await connect(serverEndpoint.address); From b8bfb2a05bec6e294664c215ca88628010a6837d Mon Sep 17 00:00:00 2001 From: nashit hayat Date: Wed, 11 Nov 2026 21:48:57 +0530 Subject: [PATCH 259/331] inspector: fix out-of-bounds read in ws frame decoding Signed-off-by: nashit hayyat PR-URL: https://github.com/nodejs/node/pull/64618 Reviewed-By: Chengzhong Wu Reviewed-By: Kohei Ueno --- src/inspector_socket.cc | 5 ++++- test/cctest/test_inspector_socket.cc | 25 +++++++++++++++++++++++++ 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/src/inspector_socket.cc b/src/inspector_socket.cc index 52e53373c93..970df7cd8db 100644 --- a/src/inspector_socket.cc +++ b/src/inspector_socket.cc @@ -360,7 +360,10 @@ static ws_decode_result decode_frame_hybi17(const std::vector& buffer, } size_t payload_length = static_cast(payload_length64); - if (buffer.size() - kMaskingKeyWidthInBytes < payload_length) + // The masking key and the payload follow the header `it` already walked + // past, so they have to fit in what is left rather than in the whole buffer. + size_t remaining = static_cast(buffer.end() - it); + if (remaining < kMaskingKeyWidthInBytes + payload_length) return FRAME_INCOMPLETE; std::vector::const_iterator masking_key = it; diff --git a/test/cctest/test_inspector_socket.cc b/test/cctest/test_inspector_socket.cc index 2efa0d55d74..e8f5a57067d 100644 --- a/test/cctest/test_inspector_socket.cc +++ b/test/cctest/test_inspector_socket.cc @@ -409,6 +409,31 @@ TEST_F(InspectorSocketTest, ReadsAndWritesInspectorMessage) { reinterpret_cast(&client_socket))); } +TEST_F(InspectorSocketTest, WaitsForFrameBodyToArrive) { + do_write(const_cast(HANDSHAKE_REQ), sizeof(HANDSHAKE_REQ) - 1); + expect_handshake(); + + // A header announcing a masked five byte payload, with the masking key and + // the payload still on the wire. The frame has to be treated as incomplete + // until the remaining bytes show up. + const char FRAME_HEADER[] = {'\x81', '\x85'}; + do_write(FRAME_HEADER, sizeof(FRAME_HEADER)); + + // Round trip through the server so the header is guaranteed to have been + // read on its own, instead of arriving together with the body below. + const char SERVER_MESSAGE[] = "ping"; + const char SERVER_FRAME[] = {'\x81', '\x04', 'p', 'i', 'n', 'g'}; + delegate->Write(SERVER_MESSAGE, sizeof(SERVER_MESSAGE) - 1); + expect_on_client(SERVER_FRAME, sizeof(SERVER_FRAME)); + + const char FRAME_BODY[] = { + '\x01', '\x02', '\x03', '\x04', '\x69', '\x67', '\x6F', '\x68', '\x6E'}; + do_write(FRAME_BODY, sizeof(FRAME_BODY)); + + const char CLIENT_MESSAGE[] = "hello"; + delegate->ExpectData(CLIENT_MESSAGE, sizeof(CLIENT_MESSAGE) - 1); +} + TEST_F(InspectorSocketTest, BufferEdgeCases) { do_write(const_cast(HANDSHAKE_REQ), sizeof(HANDSHAKE_REQ) - 1); expect_handshake(); From 16fd46d775e370a9306ca72ce8261421c8e21628 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Wed, 11 Nov 2026 11:29:16 -0500 Subject: [PATCH 260/331] deps: update nghttp2 to 1.71.0 PR-URL: https://github.com/nodejs/node/pull/67331 Reviewed-By: Colin Ihrig Reviewed-By: Tim Perry --- deps/nghttp2/lib/Makefile.in | 43 +-- deps/nghttp2/lib/includes/Makefile.in | 27 +- deps/nghttp2/lib/includes/nghttp2/nghttp2.h | 41 ++- .../nghttp2/lib/includes/nghttp2/nghttp2ver.h | 4 +- deps/nghttp2/lib/nghttp2_frame.c | 22 +- deps/nghttp2/lib/nghttp2_frame.h | 2 + deps/nghttp2/lib/nghttp2_helper.c | 3 +- deps/nghttp2/lib/nghttp2_map.c | 100 +++---- deps/nghttp2/lib/nghttp2_map.h | 6 +- deps/nghttp2/lib/nghttp2_option.c | 6 + deps/nghttp2/lib/nghttp2_option.h | 5 + deps/nghttp2/lib/nghttp2_session.c | 259 +++++++++++++----- deps/nghttp2/lib/nghttp2_session.h | 5 + 13 files changed, 340 insertions(+), 183 deletions(-) diff --git a/deps/nghttp2/lib/Makefile.in b/deps/nghttp2/lib/Makefile.in index 128fb291258..aebda670702 100644 --- a/deps/nghttp2/lib/Makefile.in +++ b/deps/nghttp2/lib/Makefile.in @@ -1,7 +1,7 @@ -# Makefile.in generated by automake 1.16.5 from Makefile.am. +# Makefile.in generated by automake 1.18.1 from Makefile.am. # @configure_input@ -# Copyright (C) 1994-2021 Free Software Foundation, Inc. +# Copyright (C) 1994-2025 Free Software Foundation, Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, @@ -86,6 +86,8 @@ am__make_running_with_option = \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +am__rm_f = rm -f $(am__rm_f_notfound) +am__rm_rf = rm -rf $(am__rm_f_notfound) pkgdatadir = $(datadir)/@PACKAGE@ pkgincludedir = $(includedir)/@PACKAGE@ pkglibdir = $(libdir)/@PACKAGE@ @@ -141,10 +143,9 @@ am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' am__uninstall_files_from_dir = { \ - test -z "$$files" \ - || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ - || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ - $(am__cd) "$$dir" && rm -f $$files; }; \ + { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && echo $$files | $(am__xargs_n) 40 $(am__rm_f); }; \ } am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgconfigdir)" LTLIBRARIES = $(lib_LTLIBRARIES) @@ -436,8 +437,10 @@ ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ am__include = @am__include@ am__leading_dot = @am__leading_dot@ am__quote = @am__quote@ +am__rm_f_notfound = @am__rm_f_notfound@ am__tar = @am__tar@ am__untar = @am__untar@ +am__xargs_n = @am__xargs_n@ bindir = @bindir@ build = @build@ build_alias = @build_alias@ @@ -612,15 +615,13 @@ uninstall-libLTLIBRARIES: done clean-libLTLIBRARIES: - -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + -$(am__rm_f) $(lib_LTLIBRARIES) @list='$(lib_LTLIBRARIES)'; \ locs=`for p in $$list; do echo $$p; done | \ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ sort -u`; \ - test -z "$$locs" || { \ - echo rm -f $${locs}; \ - rm -f $${locs}; \ - } + echo rm -f $${locs}; \ + $(am__rm_f) $${locs} libnghttp2.la: $(libnghttp2_la_OBJECTS) $(libnghttp2_la_DEPENDENCIES) $(EXTRA_libnghttp2_la_DEPENDENCIES) $(AM_V_CCLD)$(libnghttp2_la_LINK) -rpath $(libdir) $(libnghttp2_la_OBJECTS) $(libnghttp2_la_LIBADD) $(LIBS) @@ -660,7 +661,7 @@ distclean-compile: $(am__depfiles_remade): @$(MKDIR_P) $(@D) - @echo '# dummy' >$@-t && $(am__mv) $@-t $@ + @: >>$@ am--depfiles: $(am__depfiles_remade) @@ -813,6 +814,7 @@ cscopelist-am: $(am__tagged_files) distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + distdir: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am @@ -903,9 +905,9 @@ mostlyclean-generic: clean-generic: distclean-generic: - -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) - -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) - -test -z "$(DISTCLEANFILES)" || rm -f $(DISTCLEANFILES) + -$(am__rm_f) $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || $(am__rm_f) $(CONFIG_CLEAN_VPATH_FILES) + -$(am__rm_f) $(DISTCLEANFILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @@ -916,7 +918,7 @@ clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \ mostlyclean-am distclean: distclean-recursive - -rm -f ./$(DEPDIR)/nghttp2_alpn.Plo + -rm -f ./$(DEPDIR)/nghttp2_alpn.Plo -rm -f ./$(DEPDIR)/nghttp2_buf.Plo -rm -f ./$(DEPDIR)/nghttp2_callbacks.Plo -rm -f ./$(DEPDIR)/nghttp2_debug.Plo @@ -987,7 +989,7 @@ install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-recursive - -rm -f ./$(DEPDIR)/nghttp2_alpn.Plo + -rm -f ./$(DEPDIR)/nghttp2_alpn.Plo -rm -f ./$(DEPDIR)/nghttp2_buf.Plo -rm -f ./$(DEPDIR)/nghttp2_callbacks.Plo -rm -f ./$(DEPDIR)/nghttp2_debug.Plo @@ -1055,3 +1057,10 @@ uninstall-am: uninstall-libLTLIBRARIES uninstall-pkgconfigDATA # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: + +# Tell GNU make to disable its built-in pattern rules. +%:: %,v +%:: RCS/%,v +%:: RCS/% +%:: s.% +%:: SCCS/s.% diff --git a/deps/nghttp2/lib/includes/Makefile.in b/deps/nghttp2/lib/includes/Makefile.in index 833a90fb339..1b115bde50e 100644 --- a/deps/nghttp2/lib/includes/Makefile.in +++ b/deps/nghttp2/lib/includes/Makefile.in @@ -1,7 +1,7 @@ -# Makefile.in generated by automake 1.16.5 from Makefile.am. +# Makefile.in generated by automake 1.18.1 from Makefile.am. # @configure_input@ -# Copyright (C) 1994-2021 Free Software Foundation, Inc. +# Copyright (C) 1994-2025 Free Software Foundation, Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, @@ -93,6 +93,8 @@ am__make_running_with_option = \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +am__rm_f = rm -f $(am__rm_f_notfound) +am__rm_rf = rm -rf $(am__rm_f_notfound) pkgdatadir = $(datadir)/@PACKAGE@ pkgincludedir = $(includedir)/@PACKAGE@ pkglibdir = $(libdir)/@PACKAGE@ @@ -168,10 +170,9 @@ am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' am__uninstall_files_from_dir = { \ - test -z "$$files" \ - || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ - || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ - $(am__cd) "$$dir" && rm -f $$files; }; \ + { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && echo $$files | $(am__xargs_n) 40 $(am__rm_f); }; \ } am__installdirs = "$(DESTDIR)$(includedir)" HEADERS = $(nobase_include_HEADERS) @@ -341,8 +342,10 @@ ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ am__include = @am__include@ am__leading_dot = @am__leading_dot@ am__quote = @am__quote@ +am__rm_f_notfound = @am__rm_f_notfound@ am__tar = @am__tar@ am__untar = @am__untar@ +am__xargs_n = @am__xargs_n@ bindir = @bindir@ build = @build@ build_alias = @build_alias@ @@ -508,6 +511,7 @@ cscopelist-am: $(am__tagged_files) distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + distdir: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am @@ -572,8 +576,8 @@ mostlyclean-generic: clean-generic: distclean-generic: - -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) - -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + -$(am__rm_f) $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || $(am__rm_f) $(CONFIG_CLEAN_VPATH_FILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @@ -666,3 +670,10 @@ uninstall-am: uninstall-nobase_includeHEADERS # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: + +# Tell GNU make to disable its built-in pattern rules. +%:: %,v +%:: RCS/%,v +%:: RCS/% +%:: s.% +%:: SCCS/s.% diff --git a/deps/nghttp2/lib/includes/nghttp2/nghttp2.h b/deps/nghttp2/lib/includes/nghttp2/nghttp2.h index 2a494894d2d..eac691280ba 100644 --- a/deps/nghttp2/lib/includes/nghttp2/nghttp2.h +++ b/deps/nghttp2/lib/includes/nghttp2/nghttp2.h @@ -465,10 +465,10 @@ typedef enum { /** * Possible flooding by peer was detected in this HTTP/2 session. * Flooding is measured by how many PING and SETTINGS frames with - * ACK flag set are queued for transmission. These frames are - * response for the peer initiated frames, and peer can cause memory - * exhaustion on server side to send these frames forever and does - * not read network. + * ACK flag set are queued for transmission, and the size of the + * outbound queue. These frames are response for the peer initiated + * frames, and peer can cause memory exhaustion on server side to + * send these frames forever and does not read network. */ NGHTTP2_ERR_FLOODED = -904, /** @@ -3258,6 +3258,21 @@ NGHTTP2_EXTERN void nghttp2_option_set_glitch_rate_limit(nghttp2_option *option, uint64_t burst, uint64_t rate); +/** + * @function + * + * This function sets the maximum number of frames allowed in the + * outbound queue. The limit is checked after + * `nghttp2_session_mem_recv2()` and `nghttp2_session_recv()`. The + * current queue size (excluding deferred DATA frames) can be obtained + * by `nghttp2_session_get_outbound_queue_size()`. If it exceeds + * |val|, `nghttp2_session_mem_recv2()` and `nghttp2_session_recv()` + * return :enum:`nghttp2_error.NGHTTP2_ERR_FLOODED`. The default + * value is 5000. + */ +NGHTTP2_EXTERN void +nghttp2_option_set_max_outbound_queue_size(nghttp2_option *option, size_t val); + /** * @function * @@ -4581,6 +4596,8 @@ NGHTTP2_EXTERN int32_t nghttp2_submit_request( * reached. * :enum:`nghttp2_error.NGHTTP2_ERR_PROTO` * The |session| is server session. + * :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT` + * The required memory for |nva| of length |nvlen| is too large. * * .. warning:: * @@ -4724,7 +4741,8 @@ nghttp2_submit_response(nghttp2_session *session, int32_t stream_id, * :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM` * Out of memory. * :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT` - * The |stream_id| is 0. + * The |stream_id| is 0; The required memory for |nva| of length + * |nvlen| is too large. * :enum:`nghttp2_error.NGHTTP2_ERR_DATA_EXIST` * DATA or HEADERS has been already submitted and not fully * processed yet. Normally, this does not happen, but when @@ -4794,7 +4812,8 @@ nghttp2_submit_response2(nghttp2_session *session, int32_t stream_id, * :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM` * Out of memory. * :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT` - * The |stream_id| is 0. + * The |stream_id| is 0; The required memory for |nva| of length + * |nvlen| is too large. */ NGHTTP2_EXTERN int nghttp2_submit_trailer(nghttp2_session *session, int32_t stream_id, @@ -4860,7 +4879,8 @@ NGHTTP2_EXTERN int nghttp2_submit_trailer(nghttp2_session *session, * No stream ID is available because maximum stream ID was * reached. * :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT` - * The |stream_id| is 0. + * The |stream_id| is 0; The required memory for |nva| of length + * |nvlen| is too large. * :enum:`nghttp2_error.NGHTTP2_ERR_DATA_EXIST` * DATA or HEADERS has been already submitted and not fully * processed yet. This happens if stream denoted by |stream_id| @@ -5087,8 +5107,8 @@ NGHTTP2_EXTERN int nghttp2_submit_rst_stream(nghttp2_session *session, * copies all the elements in the |iv|. * * While updating individual stream's local window size, if the window - * size becomes strictly larger than NGHTTP2_MAX_WINDOW_SIZE, - * RST_STREAM is issued against such a stream. + * size becomes strictly larger than NGHTTP2_MAX_WINDOW_SIZE, GOAWAY + * frame is submitted and the connection will be terminated. * * SETTINGS with :enum:`nghttp2_flag.NGHTTP2_FLAG_ACK` is * automatically submitted by the library and application could not @@ -5162,7 +5182,8 @@ NGHTTP2_EXTERN int nghttp2_submit_settings(nghttp2_session *session, * reached. * :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT` * The |stream_id| is 0; The |stream_id| does not designate stream - * that peer initiated. + * that peer initiated; The required memory for |nva| of length + * |nvlen| is too large. * :enum:`nghttp2_error.NGHTTP2_ERR_STREAM_CLOSED` * The stream was already closed; or the |stream_id| is invalid. * diff --git a/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h b/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h index 6c1a73206f3..c665394e051 100644 --- a/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h +++ b/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h @@ -29,7 +29,7 @@ * @macro * Version number of the nghttp2 library release */ -#define NGHTTP2_VERSION "1.70.0" +#define NGHTTP2_VERSION "1.71.0" /** * @macro @@ -37,6 +37,6 @@ * release. This is a 24 bit number with 8 bits for major number, 8 bits * for minor and 8 bits for patch. Version 1.2.3 becomes 0x010203. */ -#define NGHTTP2_VERSION_NUM 0x014600 +#define NGHTTP2_VERSION_NUM 0x014700 #endif /* NGHTTP2VER_H */ diff --git a/deps/nghttp2/lib/nghttp2_frame.c b/deps/nghttp2/lib/nghttp2_frame.c index 657607aed54..25fd025ab06 100644 --- a/deps/nghttp2/lib/nghttp2_frame.c +++ b/deps/nghttp2/lib/nghttp2_frame.c @@ -1048,8 +1048,8 @@ void nghttp2_nv_array_sort(nghttp2_nv *nva, size_t nvlen) { int nghttp2_nv_array_copy(nghttp2_nv **nva_ptr, const nghttp2_nv *nva, size_t nvlen, nghttp2_mem *mem) { size_t i; - uint8_t *data = NULL; - size_t buflen = 0; + uint8_t *data; + size_t buflen; nghttp2_nv *p; if (nvlen == 0) { @@ -1058,18 +1058,32 @@ int nghttp2_nv_array_copy(nghttp2_nv **nva_ptr, const nghttp2_nv *nva, return 0; } + if (sizeof(nghttp2_nv) > SIZE_MAX / nvlen) { + return NGHTTP2_ERR_INVALID_ARGUMENT; + } + + buflen = sizeof(nghttp2_nv) * nvlen; + for (i = 0; i < nvlen; ++i) { /* + 1 for null-termination */ if ((nva[i].flags & NGHTTP2_NV_FLAG_NO_COPY_NAME) == 0) { + if (nva[i].namelen == SIZE_MAX || + buflen > SIZE_MAX - nva[i].namelen - 1) { + return NGHTTP2_ERR_INVALID_ARGUMENT; + } + buflen += nva[i].namelen + 1; } if ((nva[i].flags & NGHTTP2_NV_FLAG_NO_COPY_VALUE) == 0) { + if (nva[i].valuelen == SIZE_MAX || + buflen > SIZE_MAX - nva[i].valuelen - 1) { + return NGHTTP2_ERR_INVALID_ARGUMENT; + } + buflen += nva[i].valuelen + 1; } } - buflen += sizeof(nghttp2_nv) * nvlen; - *nva_ptr = nghttp2_mem_malloc(mem, buflen); if (*nva_ptr == NULL) { diff --git a/deps/nghttp2/lib/nghttp2_frame.h b/deps/nghttp2/lib/nghttp2_frame.h index c0917c0df4c..32631de843f 100644 --- a/deps/nghttp2/lib/nghttp2_frame.h +++ b/deps/nghttp2/lib/nghttp2_frame.h @@ -597,6 +597,8 @@ void nghttp2_nv_array_sort(nghttp2_nv *nva, size_t nvlen); * * NGHTTP2_ERR_NOMEM * Out of memory. + * NGHTTP2_ERR_INVALID_ARGUMENT + * The required memory for |nva| of length |nvlen| is too large. */ int nghttp2_nv_array_copy(nghttp2_nv **nva_ptr, const nghttp2_nv *nva, size_t nvlen, nghttp2_mem *mem); diff --git a/deps/nghttp2/lib/nghttp2_helper.c b/deps/nghttp2/lib/nghttp2_helper.c index 70a80bc6faa..d4b04ff8d70 100644 --- a/deps/nghttp2/lib/nghttp2_helper.c +++ b/deps/nghttp2/lib/nghttp2_helper.c @@ -247,7 +247,8 @@ int nghttp2_increase_local_window_size(int32_t *local_window_size_ptr, int nghttp2_should_send_window_update(int32_t local_window_size, int32_t recv_window_size) { - return recv_window_size > 0 && recv_window_size >= local_window_size / 2; + return recv_window_size > 0 && local_window_size > 0 && + recv_window_size >= local_window_size / 2; } const char *nghttp2_strerror(int error_code) { diff --git a/deps/nghttp2/lib/nghttp2_map.c b/deps/nghttp2/lib/nghttp2_map.c index b1b1c93c03a..47a6e0a59e2 100644 --- a/deps/nghttp2/lib/nghttp2_map.c +++ b/deps/nghttp2/lib/nghttp2_map.c @@ -74,20 +74,19 @@ int nghttp2_map_each(const nghttp2_map *map, int (*func)(void *data, void *ptr), return 0; } -/* Hasher from - https://github.com/rust-lang/rustc-hash/blob/dc5c33f1283de2da64d8d7a06401d91aded03ad4/src/lib.rs - to maximize the output's sensitivity to all input bits. */ -#define NGHTTP2_MAP_HASHER 0xF1357AEA2E62A9C5ULL -/* 64-bit Fibonacci hashing constant, Golden Ratio constant, to get - the high bits with the good distribution. */ -#define NGHTTP2_MAP_FIBO 0x9E3779B97F4A7C15ULL - -static size_t map_index(const nghttp2_map *map, nghttp2_map_key_type key32) { - uint64_t key = (uint64_t)key32; - - key += map->seed; - key *= NGHTTP2_MAP_HASHER; - return (size_t)((key * NGHTTP2_MAP_FIBO) >> (64 - map->hashbits)); +/* 64-bit finalizer (fmix64) from MurmurHash3 to maximize the output's + sensitivity to all input bits. */ +#define NGHTTP2_MAP_HASHER1 0xFF51AFD7ED558CCDULL +#define NGHTTP2_MAP_HASHER2 0xC4CEB9FE1A85EC53ULL + +static size_t map_index(const nghttp2_map *map, nghttp2_map_key_type key) { + key ^= map->seed; + key ^= key >> 33; + key *= NGHTTP2_MAP_HASHER1; + key ^= key >> 33; + key *= NGHTTP2_MAP_HASHER2; + key ^= key >> 33; + return (size_t)(key >> (64 - map->hashbits)); } #ifndef WIN32 @@ -109,17 +108,17 @@ void nghttp2_map_print_distance(const nghttp2_map *map) { } idx = map_index(map, map->keys[i]); - fprintf(stderr, "@%zu key=%d base=%zu distance=%u\n", i, map->keys[i], idx, - map->psl[i] - 1); + fprintf(stderr, "@%zu key=%" PRIu64 " base=%zu distance=%zu\n", i, + map->keys[i], idx, map->psl[i] - 1); } } #endif /* !defined(WIN32) */ static void map_set_entry(nghttp2_map *map, size_t idx, - nghttp2_map_key_type key, void *data, size_t psl) { + nghttp2_map_key_type key, size_t psl, void *data) { map->keys[idx] = key; + map->psl[idx] = psl; map->data[idx] = data; - map->psl[idx] = (uint8_t)psl; } #define NGHTTP2_SWAP(TYPE, A, B) \ @@ -131,15 +130,15 @@ static void map_set_entry(nghttp2_map *map, size_t idx, } while (0) /* - * map_insert inserts |key| and |data| to |map|, and returns the index - * where the pair is stored if it succeeds. Otherwise, it returns one - * of the following negative error codes: + * map_insert inserts |key| and |data| to |map|. + * + * It returns 0 if it succeeds, or one of the following negative error + * codes: * * NGHTTP2_ERR_INVALID_ARGUMENT * The another data associated to |key| is already present. */ -static nghttp2_ssize map_insert(nghttp2_map *map, nghttp2_map_key_type key, - void *data) { +static int map_insert(nghttp2_map *map, nghttp2_map_key_type key, void *data) { size_t idx = map_index(map, key); size_t mask = ((size_t)1 << map->hashbits) - 1; size_t psl = 1; @@ -149,16 +148,16 @@ static nghttp2_ssize map_insert(nghttp2_map *map, nghttp2_map_key_type key, kpsl = map->psl[idx]; if (kpsl == 0) { - map_set_entry(map, idx, key, data, psl); + map_set_entry(map, idx, key, psl, data); ++map->size; - return (nghttp2_ssize)idx; + return 0; } if (psl > kpsl) { NGHTTP2_SWAP(nghttp2_map_key_type, &key, &map->keys[idx]); + NGHTTP2_SWAP(size_t, &psl, &map->psl[idx]); NGHTTP2_SWAP(void *, &data, &map->data[idx]); - NGHTTP2_SWAP(uint8_t, &psl, &map->psl[idx]); } else if (map->keys[idx] == key) { /* This check ensures that no duplicate keys are inserted. But it is just a waste after first swap or if this function is @@ -180,14 +179,14 @@ static nghttp2_ssize map_insert(nghttp2_map *map, nghttp2_map_key_type key, static int map_resize(nghttp2_map *map, size_t new_hashbits) { size_t i; size_t tablelen; - nghttp2_ssize idx; nghttp2_map new_map = { .mem = map->mem, .seed = map->seed, .hashbits = new_hashbits, }; void *buf; - (void)idx; + int rv; + (void)rv; if (new_hashbits > NGHTTP2_MAP_MAX_HASHBITS) { return NGHTTP2_ERR_NOMEM; @@ -196,16 +195,16 @@ static int map_resize(nghttp2_map *map, size_t new_hashbits) { tablelen = (size_t)1 << new_hashbits; buf = nghttp2_mem_calloc(map->mem, tablelen, - sizeof(nghttp2_map_key_type) + sizeof(void *) + - sizeof(uint8_t)); - if (buf == NULL) { + sizeof(nghttp2_map_key_type) + sizeof(size_t) + + sizeof(void *)); + if (!buf) { return NGHTTP2_ERR_NOMEM; } new_map.keys = buf; - new_map.data = - (void *)((uint8_t *)new_map.keys + tablelen * sizeof(nghttp2_map_key_type)); - new_map.psl = (uint8_t *)new_map.data + tablelen * sizeof(void *); + new_map.psl = (size_t *)(void *)((uint8_t *)new_map.keys + + tablelen * sizeof(nghttp2_map_key_type)); + new_map.data = (void *)((uint8_t *)new_map.psl + tablelen * sizeof(size_t)); if (map->size) { tablelen = (size_t)1 << map->hashbits; @@ -215,31 +214,26 @@ static int map_resize(nghttp2_map *map, size_t new_hashbits) { continue; } - idx = map_insert(&new_map, map->keys[i], map->data[i]); + rv = map_insert(&new_map, map->keys[i], map->data[i]); /* map_insert must not fail because all keys are unique during resize. */ - assert(idx >= 0); + assert(0 == rv); } } nghttp2_mem_free(map->mem, map->keys); map->keys = new_map.keys; - map->data = new_map.data; map->psl = new_map.psl; + map->data = new_map.data; map->hashbits = new_hashbits; return 0; } -/* NGHTTP2_MAX_PSL_RESIZE_THRESH is the maximum psl threshold. If - reached, resize the table. */ -#define NGHTTP2_MAX_PSL_RESIZE_THRESH 128 - int nghttp2_map_insert(nghttp2_map *map, nghttp2_map_key_type key, void *data) { int rv; size_t tablelen; - nghttp2_ssize idx; assert(data); @@ -256,27 +250,9 @@ int nghttp2_map_insert(nghttp2_map *map, nghttp2_map_key_type key, void *data) { if (rv != 0) { return rv; } - - idx = map_insert(map, key, data); - if (idx < 0) { - return (int)idx; - } - - return 0; - } - - idx = map_insert(map, key, data); - if (idx < 0) { - return (int)idx; - } - - /* Resize if psl reaches really large value which is almost - improbable, but just in case. */ - if (map->psl[idx] - 1 < NGHTTP2_MAX_PSL_RESIZE_THRESH) { - return 0; } - return map_resize(map, map->hashbits + 1); + return map_insert(map, key, data); } void *nghttp2_map_find(const nghttp2_map *map, nghttp2_map_key_type key) { @@ -334,7 +310,7 @@ int nghttp2_map_remove(nghttp2_map *map, nghttp2_map_key_type key) { break; } - map_set_entry(map, dest, map->keys[idx], map->data[idx], kpsl - 1); + map_set_entry(map, dest, map->keys[idx], kpsl - 1, map->data[idx]); dest = idx; diff --git a/deps/nghttp2/lib/nghttp2_map.h b/deps/nghttp2/lib/nghttp2_map.h index c47b279345d..864ecdbce81 100644 --- a/deps/nghttp2/lib/nghttp2_map.h +++ b/deps/nghttp2/lib/nghttp2_map.h @@ -36,15 +36,15 @@ /* Implementation of unordered map */ -typedef int32_t nghttp2_map_key_type; +typedef uint64_t nghttp2_map_key_type; typedef struct nghttp2_map { nghttp2_map_key_type *keys; - void **data; /* psl is the Probe Sequence Length. 0 has special meaning that the element is not stored at i-th position if psl[i] == 0. Because of this, the actual psl value is psl[i] - 1 if psl[i] > 0. */ - uint8_t *psl; + size_t *psl; + void **data; nghttp2_mem *mem; uint64_t seed; size_t size; diff --git a/deps/nghttp2/lib/nghttp2_option.c b/deps/nghttp2/lib/nghttp2_option.c index 7e44a241ba1..a1aa2738eb7 100644 --- a/deps/nghttp2/lib/nghttp2_option.c +++ b/deps/nghttp2/lib/nghttp2_option.c @@ -162,3 +162,9 @@ void nghttp2_option_set_glitch_rate_limit(nghttp2_option *option, option->glitch_burst = burst; option->glitch_rate = rate; } + +void nghttp2_option_set_max_outbound_queue_size(nghttp2_option *option, + size_t val) { + option->opt_set_mask |= NGHTTP2_OPT_MAX_OUTBOUND_QUEUE_SIZE; + option->max_outbound_queue_size = val; +} diff --git a/deps/nghttp2/lib/nghttp2_option.h b/deps/nghttp2/lib/nghttp2_option.h index db739b609ed..d53dd98f0be 100644 --- a/deps/nghttp2/lib/nghttp2_option.h +++ b/deps/nghttp2/lib/nghttp2_option.h @@ -73,6 +73,7 @@ #define NGHTTP2_OPT_STREAM_RESET_RATE_LIMIT 0x8000U #define NGHTTP2_OPT_MAX_CONTINUATIONS 0x010000U #define NGHTTP2_OPT_GLITCH_RATE_LIMIT 0x020000U +#define NGHTTP2_OPT_MAX_OUTBOUND_QUEUE_SIZE 0x040000U /** * Struct to store option values for nghttp2_session. @@ -108,6 +109,10 @@ struct nghttp2_option { * NGHTTP2_OPT_MAX_CONTINUATIONS */ size_t max_continuations; + /** + * NGHTTP2_OPT_MAX_OUTBOUND_QUEUE_SIZE + */ + size_t max_outbound_queue_size; /** * Bitwise OR of NGHTTP2_OPT_* values to determine which fields are * specified. diff --git a/deps/nghttp2/lib/nghttp2_session.c b/deps/nghttp2/lib/nghttp2_session.c index f4c2afc8009..bd4415f4933 100644 --- a/deps/nghttp2/lib/nghttp2_session.c +++ b/deps/nghttp2/lib/nghttp2_session.c @@ -285,7 +285,8 @@ nghttp2_stream *nghttp2_session_get_stream(nghttp2_session *session, int32_t stream_id) { nghttp2_stream *stream; - stream = (nghttp2_stream *)nghttp2_map_find(&session->streams, stream_id); + stream = (nghttp2_stream *)nghttp2_map_find(&session->streams, + (nghttp2_map_key_type)stream_id); if (stream == NULL || (stream->flags & NGHTTP2_STREAM_FLAG_CLOSED) || stream->state == NGHTTP2_STREAM_IDLE) { @@ -297,7 +298,8 @@ nghttp2_stream *nghttp2_session_get_stream(nghttp2_session *session, nghttp2_stream *nghttp2_session_get_stream_raw(nghttp2_session *session, int32_t stream_id) { - return (nghttp2_stream *)nghttp2_map_find(&session->streams, stream_id); + return (nghttp2_stream *)nghttp2_map_find(&session->streams, + (nghttp2_map_key_type)stream_id); } static void session_inbound_frame_reset(nghttp2_session *session) { @@ -498,6 +500,8 @@ static int session_new(nghttp2_session **session_ptr, (*session_ptr)->max_outbound_ack = NGHTTP2_DEFAULT_MAX_OBQ_FLOOD_ITEM; (*session_ptr)->max_settings = NGHTTP2_DEFAULT_MAX_SETTINGS; (*session_ptr)->max_continuations = NGHTTP2_DEFAULT_MAX_CONTINUATIONS; + (*session_ptr)->max_outbound_queue_size = + NGHTTP2_DEFAULT_MAX_OUTBOUND_QUEUE_SIZE; if (option) { if ((option->opt_set_mask & NGHTTP2_OPT_NO_AUTO_WINDOW_UPDATE) && @@ -578,6 +582,10 @@ static int session_new(nghttp2_session **session_ptr, nghttp2_ratelim_init(&(*session_ptr)->glitch_ratelim, option->glitch_burst, option->glitch_rate); } + + if (option->opt_set_mask & NGHTTP2_OPT_MAX_OUTBOUND_QUEUE_SIZE) { + (*session_ptr)->max_outbound_queue_size = option->max_outbound_queue_size; + } } rv = nghttp2_hd_deflate_init2(&(*session_ptr)->hd_deflater, @@ -1245,7 +1253,8 @@ nghttp2_stream *nghttp2_session_open_stream(nghttp2_session *session, stream_user_data); stream->seq = session->stream_seq++; - rv = nghttp2_map_insert(&session->streams, stream_id, stream); + rv = nghttp2_map_insert(&session->streams, (nghttp2_map_key_type)stream_id, + stream); if (rv != 0) { nghttp2_stream_free(stream); nghttp2_mem_free(mem, stream); @@ -1366,7 +1375,8 @@ void nghttp2_session_destroy_stream(nghttp2_session *session, session_ob_data_remove(session, stream); } - nghttp2_map_remove(&session->streams, stream->stream_id); + nghttp2_map_remove(&session->streams, + (nghttp2_map_key_type)stream->stream_id); nghttp2_stream_free(stream); nghttp2_mem_free(mem, stream); } @@ -2510,13 +2520,6 @@ static int session_after_frame_sent1(nghttp2_session *session) { aux_data = &item->aux_data.data; stream = nghttp2_session_get_stream(session, frame->hd.stream_id); - /* We update flow control window after a frame was completely - sent. This is possible because we choose payload length not to - exceed the window */ - session->remote_window_size -= (int32_t)frame->hd.length; - if (stream) { - stream->remote_window_size -= (int32_t)frame->hd.length; - } if (stream && aux_data->eof) { session_detach_stream_item(session, stream); @@ -2823,6 +2826,20 @@ static int session_call_send_data(nghttp2_session *session, } } +static void session_update_remote_window(nghttp2_session *session, + int32_t stream_id, size_t datalen) { + nghttp2_stream *stream; + + session->remote_window_size -= (int32_t)datalen; + + stream = nghttp2_session_get_stream(session, stream_id); + if (!stream) { + return; + } + + stream->remote_window_size -= (int32_t)datalen; +} + static nghttp2_ssize nghttp2_session_mem_send_internal(nghttp2_session *session, const uint8_t **data_ptr, int fast_cb) { @@ -3081,6 +3098,9 @@ static nghttp2_ssize nghttp2_session_mem_send_internal(nghttp2_session *session, return 0; } + session_update_remote_window(session, frame->hd.stream_id, + frame->hd.length); + pause = (rv == NGHTTP2_ERR_PAUSE); rv = session_after_frame_sent1(session); @@ -3130,6 +3150,7 @@ nghttp2_ssize nghttp2_session_mem_send2(nghttp2_session *session, const uint8_t **data_ptr) { int rv; nghttp2_ssize len; + const nghttp2_frame *frame; *data_ptr = NULL; @@ -3139,6 +3160,14 @@ nghttp2_ssize nghttp2_session_mem_send2(nghttp2_session *session, } if (session->aob.item) { + frame = &session->aob.item->frame; + + if (frame->hd.type == NGHTTP2_DATA && + (size_t)len == NGHTTP2_FRAME_HDLEN + frame->hd.length) { + session_update_remote_window(session, frame->hd.stream_id, + frame->hd.length); + } + /* We have to call session_after_frame_sent1 here to handle stream closure upon transmission of frames. Otherwise, END_STREAM may be reached to client before we call nghttp2_session_mem_send @@ -3158,6 +3187,7 @@ int nghttp2_session_send(nghttp2_session *session) { nghttp2_ssize datalen; nghttp2_ssize sentlen; nghttp2_bufs *framebufs; + const nghttp2_frame *frame; framebufs = &session->aob.framebufs; @@ -3182,6 +3212,17 @@ int nghttp2_session_send(nghttp2_session *session) { } return NGHTTP2_ERR_CALLBACK_FAILURE; } + + if (sentlen > 0 && session->aob.item) { + frame = &session->aob.item->frame; + + if (frame->hd.type == NGHTTP2_DATA && + (size_t)datalen == NGHTTP2_FRAME_HDLEN + frame->hd.length) { + session_update_remote_window(session, frame->hd.stream_id, + frame->hd.length); + } + } + /* Rewind the offset to the amount of unsent bytes */ framebufs->cur->buf.pos -= datalen - sentlen; } @@ -4022,6 +4063,22 @@ int nghttp2_session_on_headers_received(nghttp2_session *session, return session_inflate_handle_invalid_connection( session, frame, NGHTTP2_ERR_STREAM_CLOSED, "HEADERS: stream closed"); } + + if ((stream->http_flags & NGHTTP2_HTTP_FLAG_METH_CONNECT) && + (session->server || stream->status_code / 100 == 2)) { + rv = session_update_glitch_ratelim(session); + if (rv != 0) { + return rv; + } + + if (session->iframe.state == NGHTTP2_IB_IGN_ALL) { + return 0; + } + + return session_inflate_handle_invalid_stream(session, frame, + NGHTTP2_ERR_PROTO); + } + if (nghttp2_session_is_my_stream_id(session, frame->hd.stream_id)) { if (stream->state == NGHTTP2_STREAM_OPENED) { rv = session_call_on_begin_headers(session, frame); @@ -4199,6 +4256,11 @@ static int update_local_initial_window_size_func(void *entry, void *ptr) { return NGHTTP2_ERR_FLOW_CONTROL; } + if ((int64_t)stream->local_window_size - (int64_t)stream->recv_window_size > + NGHTTP2_MAX_WINDOW_SIZE) { + return NGHTTP2_ERR_FLOW_CONTROL; + } + if (stream->window_update_queued) { return 0; } @@ -4633,6 +4695,13 @@ int nghttp2_session_on_push_promise_received(nghttp2_session *session, session, frame, NGHTTP2_ERR_STREAM_CLOSED, "PUSH_PROMISE: stream closed"); } + if ((stream->http_flags & NGHTTP2_HTTP_FLAG_METH_CONNECT) && + stream->status_code / 100 == 2) { + return session_inflate_handle_invalid_connection( + session, frame, NGHTTP2_ERR_PROTO, + "PUSH_PROMISE: not allowed in CONNECT stream"); + } + promised_stream = nghttp2_session_open_stream( session, frame->push_promise.promised_stream_id, NGHTTP2_STREAM_FLAG_NONE, NGHTTP2_STREAM_RESERVED, NULL); @@ -4899,6 +4968,12 @@ int nghttp2_session_on_priority_update_received(nghttp2_session *session, "PRIORITY_UPDATE: max concurrent streams exceeded"); } + if (session->num_idle_streams + session->num_incoming_streams >= + session->pending_local_max_concurrent_stream) { + /* Ignore priority hints for excessive streams. */ + return session_call_on_frame_received(session, frame); + } + stream = nghttp2_session_open_stream(session, priority_update->stream_id, NGHTTP2_FLAG_NONE, NGHTTP2_STREAM_IDLE, NULL); @@ -5147,7 +5222,8 @@ static int session_update_consumed_size(nghttp2_session *session, int32_t recv_size; int rv; - if ((size_t)*consumed_size_ptr > NGHTTP2_MAX_WINDOW_SIZE - delta_size) { + if (delta_size > NGHTTP2_MAX_WINDOW_SIZE || + (size_t)*consumed_size_ptr > NGHTTP2_MAX_WINDOW_SIZE - delta_size) { return nghttp2_session_terminate_session(session, NGHTTP2_FLOW_CONTROL_ERROR); } @@ -5416,6 +5492,42 @@ inbound_frame_effective_readlen(nghttp2_inbound_frame *iframe, return (nghttp2_ssize)(readlen); } +static int session_update_recv_window_on_data_hd(nghttp2_session *session) { + const nghttp2_inbound_frame *iframe = &session->iframe; + int32_t stream_id = iframe->frame.hd.stream_id; + size_t datalen = iframe->frame.hd.length; + nghttp2_stream *stream; + int rv; + + if (datalen == 0) { + return 0; + } + + rv = nghttp2_session_update_recv_connection_window_size(session, datalen); + if (nghttp2_is_fatal(rv)) { + return rv; + } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return 0; + } + + stream = nghttp2_session_get_stream(session, stream_id); + if (!stream) { + return 0; + } + + rv = nghttp2_session_update_recv_stream_window_size( + session, stream, datalen, + !(iframe->frame.hd.flags & NGHTTP2_FLAG_END_STREAM) && + stream->state != NGHTTP2_STREAM_CLOSING); + if (nghttp2_is_fatal(rv)) { + return rv; + } + + return 0; +} + static const uint8_t static_in[] = {0}; ssize_t nghttp2_session_mem_recv(nghttp2_session *session, const uint8_t *in, @@ -5423,8 +5535,8 @@ ssize_t nghttp2_session_mem_recv(nghttp2_session *session, const uint8_t *in, return (ssize_t)nghttp2_session_mem_recv2(session, in, inlen); } -nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, - const uint8_t *in, size_t inlen) { +static nghttp2_ssize session_mem_recv(nghttp2_session *session, + const uint8_t *in, size_t inlen) { const uint8_t *first, *last; nghttp2_inbound_frame *iframe = &session->iframe; size_t readlen; @@ -5563,10 +5675,28 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, DEBUGF("recv: DATA not allowed stream_id=%d\n", iframe->frame.hd.stream_id); + rv = session_update_recv_window_on_data_hd(session); + if (nghttp2_is_fatal(rv)) { + return rv; + } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + iframe->state = NGHTTP2_IB_IGN_DATA; break; } + rv = session_update_recv_window_on_data_hd(session); + if (nghttp2_is_fatal(rv)) { + return rv; + } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + rv = inbound_frame_handle_pad(iframe, &iframe->frame.hd); if (rv < 0) { rv = nghttp2_session_terminate_session_with_reason( @@ -6671,6 +6801,19 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return NGHTTP2_ERR_TOO_MANY_CONTINUATIONS; } + if (cont_hd.length > session->local_settings.max_frame_size) { + DEBUGF("recv: length is too large %zu > %u\n", cont_hd.length, + session->local_settings.max_frame_size); + rv = nghttp2_session_terminate_session_with_reason( + session, NGHTTP2_FRAME_SIZE_ERROR, "too large frame size"); + + if (nghttp2_is_fatal(rv)) { + return rv; + } + + return (nghttp2_ssize)inlen; + } + /* CONTINUATION won't bear NGHTTP2_PADDED flag */ iframe->frame.hd.flags = @@ -6711,16 +6854,6 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return (nghttp2_ssize)(in - first); } - /* Pad Length field is subject to flow control */ - rv = nghttp2_session_update_recv_connection_window_size(session, readlen); - if (nghttp2_is_fatal(rv)) { - return rv; - } - - if (iframe->state == NGHTTP2_IB_IGN_ALL) { - return (nghttp2_ssize)inlen; - } - /* Pad Length field is consumed immediately */ rv = nghttp2_session_consume(session, iframe->frame.hd.stream_id, readlen); @@ -6733,21 +6866,6 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return (nghttp2_ssize)inlen; } - stream = nghttp2_session_get_stream(session, iframe->frame.hd.stream_id); - if (stream) { - rv = nghttp2_session_update_recv_stream_window_size( - session, stream, readlen, - iframe->payloadleft || - (iframe->frame.hd.flags & NGHTTP2_FLAG_END_STREAM) == 0); - if (nghttp2_is_fatal(rv)) { - return rv; - } - - if (iframe->state == NGHTTP2_IB_IGN_ALL) { - return (nghttp2_ssize)inlen; - } - } - busy = 1; padlen = inbound_frame_compute_pad(iframe); @@ -6800,28 +6918,6 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, if (readlen > 0) { nghttp2_ssize data_readlen; - rv = - nghttp2_session_update_recv_connection_window_size(session, readlen); - if (nghttp2_is_fatal(rv)) { - return rv; - } - - if (iframe->state == NGHTTP2_IB_IGN_ALL) { - return (nghttp2_ssize)inlen; - } - - rv = nghttp2_session_update_recv_stream_window_size( - session, stream, readlen, - iframe->payloadleft || - (iframe->frame.hd.flags & NGHTTP2_FLAG_END_STREAM) == 0); - if (nghttp2_is_fatal(rv)) { - return rv; - } - - if (iframe->state == NGHTTP2_IB_IGN_ALL) { - return (nghttp2_ssize)inlen; - } - data_readlen = inbound_frame_effective_readlen(iframe, iframe->payloadleft, readlen); @@ -6933,18 +7029,6 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, iframe->payloadleft); if (readlen > 0) { - /* Update connection-level flow control window for ignored - DATA frame too */ - rv = - nghttp2_session_update_recv_connection_window_size(session, readlen); - if (nghttp2_is_fatal(rv)) { - return rv; - } - - if (iframe->state == NGHTTP2_IB_IGN_ALL) { - return (nghttp2_ssize)inlen; - } - if (session->opt_flags & NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE) { /* Ignored DATA is considered as "consumed" immediately. */ rv = session_update_connection_consumed_size(session, readlen); @@ -7094,6 +7178,23 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return (nghttp2_ssize)(in - first); } +nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, + const uint8_t *in, size_t inlen) { + nghttp2_ssize nread; + + nread = session_mem_recv(session, in, inlen); + if (nread < 0 && nghttp2_is_fatal((int)nread)) { + return nread; + } + + if (nghttp2_session_get_outbound_queue_size(session) > + session->max_outbound_queue_size) { + return NGHTTP2_ERR_FLOODED; + } + + return nread; +} + int nghttp2_session_recv(nghttp2_session *session) { uint8_t buf[NGHTTP2_INBOUND_BUFFER_LENGTH]; while (1) { @@ -7696,13 +7797,13 @@ nghttp2_session_get_stream_effective_local_window_size(nghttp2_session *session, int32_t nghttp2_session_get_stream_local_window_size(nghttp2_session *session, int32_t stream_id) { nghttp2_stream *stream; - int32_t size; + int64_t size; stream = nghttp2_session_get_stream(session, stream_id); if (stream == NULL) { return -1; } - size = stream->local_window_size - stream->recv_window_size; + size = (int64_t)stream->local_window_size - (int64_t)stream->recv_window_size; /* size could be negative if local endpoint reduced SETTINGS_INITIAL_WINDOW_SIZE */ @@ -7710,7 +7811,13 @@ int32_t nghttp2_session_get_stream_local_window_size(nghttp2_session *session, return 0; } - return size; + /* In this case, GOAWAY with NGHTTP2_FLOW_CONTROL_ERROR has already + been queued or sent */ + if (size > NGHTTP2_MAX_WINDOW_SIZE) { + return NGHTTP2_MAX_WINDOW_SIZE; + } + + return (int32_t)size; } int32_t diff --git a/deps/nghttp2/lib/nghttp2_session.h b/deps/nghttp2/lib/nghttp2_session.h index 1b04464cda8..c385ddf20d5 100644 --- a/deps/nghttp2/lib/nghttp2_session.h +++ b/deps/nghttp2/lib/nghttp2_session.h @@ -110,6 +110,9 @@ typedef struct { HEADER frame. */ #define NGHTTP2_DEFAULT_MAX_CONTINUATIONS 8 +/* The default maximum size of the outbound queue. */ +#define NGHTTP2_DEFAULT_MAX_OUTBOUND_QUEUE_SIZE 5000 + /* Internal state when receiving incoming frame */ typedef enum { /* Receiving frame header */ @@ -280,6 +283,8 @@ struct nghttp2_session { /* The number of CONTINUATION frames following an incoming HEADER frame. This variable is reset when END_HEADERS flag is seen. */ size_t num_continuations; + /* The maximum size of the outbound queue. */ + size_t max_outbound_queue_size; /* Next Stream ID. Made unsigned int to detect >= (1 << 31). */ uint32_t next_stream_id; /* The last stream ID this session initiated. For client session, From 422149fd7b7897b8ca16158a8d1ba5015e597385 Mon Sep 17 00:00:00 2001 From: Philipp Dunkel Date: Wed, 11 Nov 2026 00:53:40 +0100 Subject: [PATCH 261/331] vfs: do not reuse the path of a loaded memfd image On Linux an addon or FFI library inside a VFS is loaded from an anonymous memfd through /proc/self/fd/N, and the memfd was closed right after a successful load. The next image then got the same fd number, hence the same path, and the dynamic loader, which knows a loaded object by the path it was opened with, returned the object already loaded under that path instead of loading the new file. So the second of any two addons or libraries loaded from a VFS resolved to the first: an addon after an FFI library failed with "Module did not self-register", an FFI library after an addon had none of its own symbols, and two addons silently became the same one. The fd is only needed until dlopen() returns, as the load's mapping keeps the memory alive from then on; what must not be shared is the path. Before the load, ask the loader with RTLD_NOLOAD whether the path is already taken, and if so move the fd to a higher number with F_DUPFD_CLOEXEC until it is free. Holding the fd from the check through the load keeps anyone else from taking the path in between, so this needs neither a counter nor a lock, and a library that has really been unloaded gives its number back. The fd is closed right after the load, whether or not it worked. Should no free number be left, the image goes to a temp file. The leak checks of test-vfs-addon and test-ffi-vfs compared the shared temporary directory before and after the load, so off Linux any other test loading from bytes at the same time could pass for a leak. Point TMPDIR at a directory each test owns instead. Signed-off-by: Philipp Dunkel PR-URL: https://github.com/nodejs/node/pull/67068 Reviewed-By: Anna Henningsen Reviewed-By: Filip Skokan --- src/node_binding.cc | 27 +++- src/node_binding.h | 4 +- test/ffi/test-ffi-vfs.js | 118 +++++++++++++++++- .../test-dlopen-binary-image-cleanup.js | 46 +++++-- test/parallel/test-vfs-addon-sequence.js | 60 +++++++++ test/parallel/test-vfs-addon.js | 12 +- 6 files changed, 245 insertions(+), 22 deletions(-) create mode 100644 test/parallel/test-vfs-addon-sequence.js diff --git a/src/node_binding.cc b/src/node_binding.cc index 13207268e2c..ee6bc6d6d36 100644 --- a/src/node_binding.cc +++ b/src/node_binding.cc @@ -475,6 +475,27 @@ bool WriteAllToFd(int fd, const char* data, size_t len) { int NodeMemfdCreate(const char* name, unsigned int flags) { return static_cast(syscall(SYS_memfd_create, name, flags)); } + +// The dynamic loader knows a loaded object by the path it was opened with, and +// hands back the object already loaded under a path instead of opening the +// file again. An image is loaded through /proc/self/fd/N and its fd is closed +// right after, so the kernel can hand N to the next image while the first is +// still loaded. So ask the loader, and move to a higher number while the path +// is taken. Holding the fd from here through the load keeps anyone else from +// taking the path in between, and an object that has really been unloaded gives +// its number back, so only images loaded at the same time compete for numbers. +int MoveFdToFreeImagePath(int fd) { + while (true) { + const std::string path = "/proc/self/fd/" + std::to_string(fd); + void* loaded = dlopen(path.c_str(), RTLD_LAZY | RTLD_NOLOAD); + if (loaded == nullptr) return fd; + dlclose(loaded); + const int moved = fcntl(fd, F_DUPFD_CLOEXEC, fd + 1); + close(fd); + if (moved == -1) return -1; + fd = moved; + } +} #endif // __linux__ #else // _WIN32 @@ -635,7 +656,8 @@ bool AddonImage::Materialize(const char* data, size_t len) { // reaches the filesystem, so there is no temp file to secure, unlink, or // leak, and no noexec-mount problem. Request an executable memfd (MFD_EXEC, // Linux 6.3+); retry without it on older kernels that reject the flag, then - // fall back to a temp file if memfd is unavailable entirely. + // fall back to a temp file if memfd is unavailable entirely, or if so many + // images are loaded that no fd number is left to load another through. #ifndef MFD_CLOEXEC #define MFD_CLOEXEC 0x0001U #endif @@ -653,6 +675,9 @@ bool AddonImage::Materialize(const char* data, size_t len) { fd_ = -1; return false; } + fd_ = MoveFdToFreeImagePath(fd_); + } + if (fd_ != -1) { path_ = "/proc/self/fd/" + std::to_string(fd_); return true; } diff --git a/src/node_binding.h b/src/node_binding.h index 0f19475ab48..5c2a58ca556 100644 --- a/src/node_binding.h +++ b/src/node_binding.h @@ -176,7 +176,9 @@ void DLOpenBinary(const v8::FunctionCallbackInfo& args); // dlopen()/LoadLibrary() can load, with the smallest, most private on-disk // footprint each platform allows: // Linux: an anonymous in-memory memfd, loaded via /proc/self/fd/N - -// the bytes never touch the filesystem. +// the bytes never touch the filesystem. The fd is closed right +// after the load, and a number whose path still names a loaded +// object is skipped (the loader would return that object). // other POSIX: a 0700 mkdtemp() directory plus an O_EXCL|O_NOFOLLOW file, // unlink()ed right after the load (the mapping keeps it alive). // Windows: a temp file, written and closed before the load because the diff --git a/test/ffi/test-ffi-vfs.js b/test/ffi/test-ffi-vfs.js index 884bd9f0d5d..28050cb8854 100644 --- a/test/ffi/test-ffi-vfs.js +++ b/test/ffi/test-ffi-vfs.js @@ -3,10 +3,12 @@ const common = require('../common'); common.skipIfFFIMissing(); const assert = require('node:assert'); +const { spawnSync } = require('node:child_process'); const fs = require('node:fs'); const os = require('node:os'); const path = require('node:path'); const { test } = require('node:test'); +const tmpdir = require('../common/tmpdir'); const ffi = require('node:ffi'); const vfs = require('node:vfs'); const { fixtureSymbols, libraryPath } = require('./ffi-test-common'); @@ -21,8 +23,12 @@ myVfs.writeFileSync(`/${libraryName}`, fs.readFileSync(libraryPath)); const mountPoint = myVfs.mount(); const virtualPath = path.join(mountPoint, libraryName); +// Images land in TMPDIR, which other tests loading libraries share. Point it at +// a directory this test owns, so their images cannot pass for a leak here. +tmpdir.refresh(); +process.env.TMPDIR = tmpdir.path; + test('ffi.dlopen() loads a library from a mounted VFS', () => { - const before = new Set(fs.readdirSync(os.tmpdir())); const { lib, functions } = ffi.dlopen(virtualPath, { add_i32: fixtureSymbols.add_i32, }); @@ -40,12 +46,64 @@ test('ffi.dlopen() loads a library from a mounted VFS', () => { // filesystem; on other POSIX it is unlinked right after loading. // (Windows keeps a delete-on-close file until exit, so skip there.) if (!common.isWindows) { - const leaked = fs.readdirSync(os.tmpdir()) - .filter((f) => f.startsWith('node-addon') && !before.has(f)); + const leaked = fs.readdirSync(tmpdir.path) + .filter((f) => f.startsWith('node-addon')); assert.deepStrictEqual(leaked, [], `image not cleaned up: ${leaked}`); } }); +test('library images leave no file descriptor behind', { skip: !common.isLinux }, () => { + const images = () => fs.readdirSync('/proc/self/fd').filter((fd) => { + try { + return fs.readlinkSync(`/proc/self/fd/${fd}`).startsWith('/memfd:node-addon'); + } catch { + return false; + } + }); + + const { lib, functions } = ffi.dlopen(virtualPath, { + add_i32: fixtureSymbols.add_i32, + }); + try { + assert.deepStrictEqual(images(), []); + assert.strictEqual(functions.add_i32(40, 2), 42); + } finally { + lib.close(); + } + assert.deepStrictEqual(images(), []); +}); + +test('closed library images give their fd numbers back', { skip: !common.isLinux }, () => { + // More loads than the limit allows fds, one at a time. There is no usable + // temporary directory, so this only works if each stays an in-memory image. + const limit = 128; + const child = ` + const assert = require('node:assert'); + const fs = require('node:fs'); + const path = require('node:path'); + const ffi = require('node:ffi'); + const vfs = require('node:vfs'); + const myVfs = vfs.create(); + myVfs.writeFileSync('/lib.so', fs.readFileSync(${JSON.stringify(libraryPath)})); + const libPath = path.join(myVfs.mount(), 'lib.so'); + for (let i = 0; i < ${limit * 4}; i++) { + const { lib, functions } = ffi.dlopen(libPath, { + add_i32: ${JSON.stringify(fixtureSymbols.add_i32)}, + }); + assert.strictEqual(functions.add_i32(40, 2), 42); + lib.close(); + } + `; + const { status, stderr } = spawnSync('/bin/sh', [ + '-c', `ulimit -n ${limit} && exec "$0" "$@"`, + process.execPath, '--experimental-vfs', '--disable-warning=ExperimentalWarning', '-e', child, + ], { + encoding: 'utf8', + env: { ...process.env, TMPDIR: path.join(os.tmpdir(), 'no-such-directory') }, + }); + assert.strictEqual(status, 0, stderr); +}); + test('new ffi.DynamicLibrary() loads from a mounted VFS', () => { const lib = new ffi.DynamicLibrary(virtualPath); @@ -92,3 +150,57 @@ test('a library loaded from a VFS outlives the mount', () => { lib.close(); } }); + +const addonPath = (name) => path.join( + __dirname, '..', 'addons', name, 'build', common.buildType, 'binding.node'); + +test('an addon loaded after a VFS library is its own module', (t) => { + const helloPath = addonPath('hello-world'); + if (!fs.existsSync(helloPath)) { + t.skip('the hello-world addon is not built'); + return; + } + const seqVfs = vfs.create(); + seqVfs.writeFileSync(`/${libraryName}`, fs.readFileSync(libraryPath)); + seqVfs.writeFileSync('/hello.node', fs.readFileSync(helloPath)); + const seqMount = seqVfs.mount(); + const { lib, functions } = ffi.dlopen(path.join(seqMount, libraryName), { + add_i32: fixtureSymbols.add_i32, + }); + + try { + // Resolved to the library, the addon would fail with "Module did not + // self-register". + const addon = require(path.join(seqMount, 'hello.node')); + assert.strictEqual(addon.hello(), 'world'); + assert.strictEqual(functions.add_i32(20, 22), 42); + } finally { + lib.close(); + seqVfs.unmount(); + } +}); + +test('a VFS library loaded after an addon is its own library', (t) => { + const functionPath = addonPath('hello-world-function-export'); + if (!fs.existsSync(functionPath)) { + t.skip('the hello-world-function-export addon is not built'); + return; + } + const seqVfs = vfs.create(); + seqVfs.writeFileSync('/function.node', fs.readFileSync(functionPath)); + seqVfs.writeFileSync(`/${libraryName}`, fs.readFileSync(libraryPath)); + const seqMount = seqVfs.mount(); + const addon = require(path.join(seqMount, 'function.node')); + assert.strictEqual(addon(), 'world'); + + // Resolved to the addon, the library would have no add_i32 to look up. + const { lib, functions } = ffi.dlopen(path.join(seqMount, libraryName), { + add_i32: fixtureSymbols.add_i32, + }); + try { + assert.strictEqual(functions.add_i32(40, 2), 42); + } finally { + lib.close(); + seqVfs.unmount(); + } +}); diff --git a/test/parallel/test-dlopen-binary-image-cleanup.js b/test/parallel/test-dlopen-binary-image-cleanup.js index dabaeabaa0c..93a6cf7521b 100644 --- a/test/parallel/test-dlopen-binary-image-cleanup.js +++ b/test/parallel/test-dlopen-binary-image-cleanup.js @@ -7,9 +7,8 @@ // this checks both halves of the contract: // // Linux: an anonymous memfd loaded through /proc/self/fd - nothing ever -// reaches the filesystem, and AfterOpen() closes the descriptor -// once the load owns its mapping, so repeated loads must not -// accumulate open descriptors. +// reaches the filesystem, and the fd is closed right after the +// load, whether or not it worked. // other POSIX: a mkdtemp() directory unlinked and rmdir()ed right after the // load, so nothing is left even while the process runs. // Windows: the loader maps the file by path for the DLL's lifetime, so @@ -45,27 +44,48 @@ const child = ` // the load can only come from the bytes and their materialized image. const virtualPath = ${JSON.stringify(path.join(addonPath, '..', 'nowhere', 'binding.node'))}; - // On Linux the image is a descriptor rather than a file, so count them: each - // load must hand its fd to the mapping and close it, leaving no growth. + // On Linux the image is a memfd rather than a file, so count those: no load + // may keep one. const fdDir = '/proc/self/fd'; - const countFds = () => { - try { return fs.readdirSync(fdDir).length; } catch { return -1; } + const imageFds = () => { + let fds; + try { fds = fs.readdirSync(fdDir); } catch { return null; } + return fds.filter((fd) => { + try { + return fs.readlinkSync(\`\${fdDir}/\${fd}\`).startsWith('/memfd:node-addon'); + } catch { return false; } + }); }; - const before = countFds(); // Load repeatedly: each load materializes its own image, so a leak of an - // image, a descriptor or a retained handle shows up as growth. - for (let i = 0; i < 5; i++) { + // image or a retained handle shows up as growth. + const loads = 5; + for (let i = 0; i < loads; i++) { const m = { exports: {} }; // flags undefined: keep the default dlopen(2) mode - 0 is not valid // everywhere (glibc rejects it with EINVAL). dlopenBinary(m, virtualPath, undefined, bytes); if (m.exports.hello() !== 'world') throw new Error('addon did not load'); } + const afterLoads = imageFds(); - const after = countFds(); - if (before !== -1 && after > before) { - throw new Error(\`descriptor leak: \${before} -> \${after} after 5 loads\`); + for (let i = 0; i < loads; i++) { + try { + dlopenBinary({ exports: {} }, virtualPath, undefined, Buffer.from('nope')); + throw new Error('loading garbage bytes did not fail'); + } catch (err) { + if (err.code !== 'ERR_DLOPEN_FAILED') throw err; + } + } + const afterFailures = imageFds(); + + if (afterLoads !== null) { + if (afterLoads.length !== 0) { + throw new Error(\`loads kept images: \${afterLoads}\`); + } + if (afterFailures.length !== 0) { + throw new Error(\`failed loads kept images: \${afterFailures}\`); + } } process.exit(0); `; diff --git a/test/parallel/test-vfs-addon-sequence.js b/test/parallel/test-vfs-addon-sequence.js new file mode 100644 index 00000000000..8f334d8f9a0 --- /dev/null +++ b/test/parallel/test-vfs-addon-sequence.js @@ -0,0 +1,60 @@ +// Flags: --experimental-vfs --disable-warning=ExperimentalWarning +'use strict'; +const common = require('../common'); +const assert = require('node:assert'); +const { spawnSync } = require('node:child_process'); +const fs = require('node:fs'); +const path = require('node:path'); +const vfs = require('node:vfs'); + +const addonPath = (name) => path.join( + __dirname, '..', 'addons', name, 'build', common.buildType, 'binding.node'); +const helloPath = addonPath('hello-world'); +const functionPath = addonPath('hello-world-function-export'); +if (!fs.existsSync(helloPath) || !fs.existsSync(functionPath)) { + common.skip('the hello-world addons are not built'); +} + +const myVfs = vfs.create(); +myVfs.writeFileSync('/hello.node', fs.readFileSync(helloPath)); +myVfs.writeFileSync('/function.node', fs.readFileSync(functionPath)); +const mountPoint = myVfs.mount(); + +const hello = require(path.join(mountPoint, 'hello.node')); +assert.strictEqual(typeof hello, 'object'); +assert.strictEqual(hello.hello(), 'world'); + +// hello-world-function-export replaces its exports with a function. Resolved +// to the first image, this would be another { hello } object instead. +const fn = require(path.join(mountPoint, 'function.node')); +assert.strictEqual(typeof fn, 'function'); +assert.strictEqual(fn(), 'world'); +assert.notStrictEqual(fn, hello); + +myVfs.unmount(); + +// An addon on the main thread stays loaded and keeps the path it was loaded +// through, so enough of them leave no fd number to load another through. Loading +// has to carry on regardless, through the temp-file fallback. +if (common.isLinux) { + const limit = 128; + const child = ` + const assert = require('node:assert'); + const fs = require('node:fs'); + const path = require('node:path'); + const vfs = require('node:vfs'); + const myVfs = vfs.create(); + myVfs.writeFileSync('/function.node', fs.readFileSync(${JSON.stringify(functionPath)})); + const mountPoint = myVfs.mount(); + for (let i = 0; i < ${limit * 2}; i++) { + const addonPath = path.join(mountPoint, 'function.node'); + assert.strictEqual(require(addonPath)(), 'world'); + delete require.cache[addonPath]; + } + `; + const { status, stderr } = spawnSync('/bin/sh', [ + '-c', `ulimit -n ${limit} && exec "$0" "$@"`, + process.execPath, '--experimental-vfs', '--disable-warning=ExperimentalWarning', '-e', child, + ], { encoding: 'utf8' }); + assert.strictEqual(status, 0, stderr); +} diff --git a/test/parallel/test-vfs-addon.js b/test/parallel/test-vfs-addon.js index 7ea8fdbf794..e5adb160369 100644 --- a/test/parallel/test-vfs-addon.js +++ b/test/parallel/test-vfs-addon.js @@ -3,8 +3,8 @@ const common = require('../common'); const assert = require('assert'); const fs = require('fs'); -const os = require('os'); const path = require('path'); +const tmpdir = require('../common/tmpdir'); const vfs = require('node:vfs'); const addonPath = path.join( @@ -21,7 +21,11 @@ const myVfs = vfs.create(); myVfs.writeFileSync('/binding.node', fs.readFileSync(addonPath)); const mountPoint = myVfs.mount(); -const before = new Set(fs.readdirSync(os.tmpdir())); +// Images land in TMPDIR, which other tests loading addons share. Point it at a +// directory this test owns, so their images cannot pass for a leak here. +tmpdir.refresh(); +process.env.TMPDIR = tmpdir.path; + const addon = require(path.join(mountPoint, 'binding.node')); assert.strictEqual(addon.hello(), 'world'); @@ -29,8 +33,8 @@ assert.strictEqual(addon.hello(), 'world'); // temp image is unlinked right after loading, so no addon temp file lingers. // (Windows keeps a delete-on-close file until exit, so skip the check there.) if (process.platform !== 'win32') { - const leaked = fs.readdirSync(os.tmpdir()) - .filter((f) => f.startsWith('node-addon') && !before.has(f)); + const leaked = fs.readdirSync(tmpdir.path) + .filter((f) => f.startsWith('node-addon')); assert.deepStrictEqual(leaked, [], `addon temp not cleaned up: ${leaked}`); } From ecbd6f78792e2009a7fd99c66708718a1a9d7116 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Thu, 22 Oct 2026 11:15:41 +0200 Subject: [PATCH 262/331] tls,tools: update BoringSSL pin and TLS errors Use BoringSSL 0.20261020.0 for shared-library builds and expose the package wrapper's version to the matrix updater. The new verifier no longer emits UNABLE_TO_VERIFY_LEAF_SIGNATURE after Node's verification callback accepts a missing-issuer error. Expect UNABLE_TO_GET_ISSUER_CERT_LOCALLY for the affected leaf certificates and suggest --use-system-ca for that error. Drop the SSL_get_server_tmp_key() fallback now that BoringSSL supplies SSL_get_peer_tmp_key() as a compatibility stub. Refs: https://boringssl-review.googlesource.com/c/boringssl/+/103849 Refs: https://github.com/electron/electron/pull/55110/changes/b457e70e339e8bb3066b210edfb6f96582cdb374 Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/66922 Backport-PR-URL: https://github.com/nodejs/node/pull/67442 Reviewed-By: Antoine du Hamel --- deps/ncrypto/ncrypto.cc | 4 ---- src/crypto/crypto_common.cc | 3 +++ .../test-https-proxy-request-handshake-failure.mjs | 5 +++-- test/common/tls.js | 6 ++++++ test/internet/test-tls-add-ca-cert.js | 2 +- .../test-http2-session-reuse-different-authority.js | 5 +++-- test/parallel/test-https-agent-create-connection.js | 7 ++++--- .../test-https-session-reuse-different-servername.js | 5 +++-- test/parallel/test-https-simple.js | 4 +++- test/parallel/test-https-strict.js | 10 ++++++---- test/parallel/test-tls-addca.js | 3 ++- test/parallel/test-tls-client-auth.js | 3 ++- test/parallel/test-tls-client-cert-resumption.js | 3 ++- test/parallel/test-tls-friendly-error-message.js | 4 +++- .../test-tls-session-reuse-different-servername.js | 5 +++-- ...st-tls-set-default-ca-certificates-append-fetch.mjs | 4 ++-- ...set-default-ca-certificates-append-https-request.js | 4 ++-- ...est-tls-set-default-ca-certificates-reset-fetch.mjs | 3 ++- ...-set-default-ca-certificates-reset-https-request.js | 3 ++- test/parallel/test-tls-socket-default-options.js | 10 +++++----- test/system-ca/test-native-intermediate-certs.mjs | 4 +++- ...st-set-default-ca-certificates-append-system-ca.mjs | 3 ++- test/system-ca/test-use-system-ca-worker-disable.mjs | 4 +++- test/system-ca/test-use-system-ca-worker-enable.mjs | 4 +++- tools/nix/openssl-matrix.nix | 4 ++-- 25 files changed, 70 insertions(+), 42 deletions(-) diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index ef811c0bc81..b9e93847ff6 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -5020,11 +5020,7 @@ bool SSLPointer::isServer() const { EVPKeyPointer SSLPointer::getPeerTempKey() const { if (!ssl_) return {}; EVP_PKEY* raw_key = nullptr; -#ifndef OPENSSL_IS_BORINGSSL if (!SSL_get_peer_tmp_key(get(), &raw_key)) return {}; -#else - if (!SSL_get_server_tmp_key(get(), &raw_key)) return {}; -#endif return EVPKeyPointer(raw_key); } diff --git a/src/crypto/crypto_common.cc b/src/crypto/crypto_common.cc index ad056b5610b..759353f08f0 100644 --- a/src/crypto/crypto_common.cc +++ b/src/crypto/crypto_common.cc @@ -59,6 +59,9 @@ MaybeLocal GetValidationErrorReason(Environment* env, int err) { // Suggest --use-system-ca if the error indicates a certificate issue bool suggest_system_ca = (err == X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE) || +#ifdef OPENSSL_IS_BORINGSSL + (err == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY) || +#endif (err == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT) || ((err == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT) && !env->options()->use_system_ca); diff --git a/test/client-proxy/test-https-proxy-request-handshake-failure.mjs b/test/client-proxy/test-https-proxy-request-handshake-failure.mjs index 251d136afaa..dcae2b024ff 100644 --- a/test/client-proxy/test-https-proxy-request-handshake-failure.mjs +++ b/test/client-proxy/test-https-proxy-request-handshake-failure.mjs @@ -13,6 +13,7 @@ if (!common.hasCrypto) // https must be dynamically imported so that builds without crypto support // can skip it. const { default: https } = await import('node:https'); +const { untrustedLeafErrorCode } = await import('../common/tls.js'); const server = https.createServer({ cert: fixtures.readKey('agent8-cert.pem'), @@ -36,8 +37,8 @@ const { code, signal, stderr, stdout } = await runProxiedRequest({ HTTPS_PROXY: `http://localhost:${proxy.address().port}`, }); -// The proxy client should get a UNABLE_TO_VERIFY_LEAF_SIGNATURE during TLS handshake. -assert.match(stderr, /UNABLE_TO_VERIFY_LEAF_SIGNATURE/); +// The proxy client should report the untrusted leaf during the TLS handshake. +assert.match(stderr, new RegExp(untrustedLeafErrorCode)); assert.strictEqual(stdout, ''); assert.strictEqual(code, 0); assert.strictEqual(signal, null); diff --git a/test/common/tls.js b/test/common/tls.js index 8568659d13c..a841f96b614 100644 --- a/test/common/tls.js +++ b/test/common/tls.js @@ -4,6 +4,12 @@ const crypto = require('crypto'); const net = require('net'); const assert = require('assert'); +const { isBoringSSL } = require('./crypto'); + +// BoringSSL reports the missing issuer directly for a lone, non-self-signed +// leaf. OpenSSL replaces it with a leaf signature verification error. +exports.untrustedLeafErrorCode = isBoringSSL ? + 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY' : 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'; exports.ccs = Buffer.from('140303000101', 'hex'); diff --git a/test/internet/test-tls-add-ca-cert.js b/test/internet/test-tls-add-ca-cert.js index 3f76f2b95e7..2ee1bbcab59 100644 --- a/test/internet/test-tls-add-ca-cert.js +++ b/test/internet/test-tls-add-ca-cert.js @@ -34,7 +34,7 @@ tls.connect(opts, common.mustCall(end)); // The .ca option replaces the well-known roots, so connection fails. opts.ca = caCert; tls.connect(opts, fail).on('error', common.mustCall((err) => { - assert.strictEqual(err.message, 'unable to get local issuer certificate'); + assert.strictEqual(err.code, 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY'); })); function fail() { diff --git a/test/parallel/test-http2-session-reuse-different-authority.js b/test/parallel/test-http2-session-reuse-different-authority.js index d76f17a728f..7ff47e65d33 100644 --- a/test/parallel/test-http2-session-reuse-different-authority.js +++ b/test/parallel/test-http2-session-reuse-different-authority.js @@ -5,6 +5,7 @@ if (!common.hasCrypto) const assert = require('assert'); const fixtures = require('../common/fixtures'); +const { untrustedLeafErrorCode } = require('../common/tls'); const h2 = require('http2'); const tls = require('tls'); const { once } = require('events'); @@ -125,7 +126,7 @@ server.on('stream', (stream) => { session: first.session, }), { - code: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', + code: untrustedLeafErrorCode, }, ); @@ -136,7 +137,7 @@ server.on('stream', (stream) => { maxVersion: 'TLSv1.2', }), { - code: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', + code: untrustedLeafErrorCode, }, ); } finally { diff --git a/test/parallel/test-https-agent-create-connection.js b/test/parallel/test-https-agent-create-connection.js index 56e967476c8..5c4c23cdbe8 100644 --- a/test/parallel/test-https-agent-create-connection.js +++ b/test/parallel/test-https-agent-create-connection.js @@ -5,6 +5,8 @@ const fixtures = require('../common/fixtures'); if (!common.hasCrypto) common.skip('missing crypto'); +const { untrustedLeafErrorCode } = require('../common/tls'); + const assert = require('assert'); const https = require('https'); @@ -17,7 +19,6 @@ const options = { const expectedHeader = /^HTTP\/1\.1 200 OK/; const expectedBody = /hello world\n/; -const expectCertError = /^UNABLE_TO_VERIFY_LEAF_SIGNATURE$/; function checkRequest(socket, server) { let result = ''; @@ -112,7 +113,7 @@ function createServer() { const options = null; const socket = agent.createConnection(port, host, options); socket.on('error', common.mustCall((e) => { - assert.match(e.code, expectCertError); + assert.strictEqual(e.code, untrustedLeafErrorCode); server.close(); })); })); @@ -127,7 +128,7 @@ function createServer() { const options = undefined; const socket = agent.createConnection(port, host, options); socket.on('error', common.mustCall((e) => { - assert.match(e.code, expectCertError); + assert.strictEqual(e.code, untrustedLeafErrorCode); server.close(); })); })); diff --git a/test/parallel/test-https-session-reuse-different-servername.js b/test/parallel/test-https-session-reuse-different-servername.js index 138acd69350..3f2c0c62ae9 100644 --- a/test/parallel/test-https-session-reuse-different-servername.js +++ b/test/parallel/test-https-session-reuse-different-servername.js @@ -5,6 +5,7 @@ if (!common.hasCrypto) const assert = require('assert'); const fixtures = require('../common/fixtures'); +const { untrustedLeafErrorCode } = require('../common/tls'); const https = require('https'); const tls = require('tls'); const { once } = require('events'); @@ -104,7 +105,7 @@ const server = https.createServer({ ca: [load('ca1-cert.pem')], }), { - code: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', + code: untrustedLeafErrorCode, }, ); @@ -116,7 +117,7 @@ const server = https.createServer({ ca: [load('ca1-cert.pem')], }), { - code: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', + code: untrustedLeafErrorCode, }, ); } finally { diff --git a/test/parallel/test-https-simple.js b/test/parallel/test-https-simple.js index b0562a1cd98..042bc4aa66c 100644 --- a/test/parallel/test-https-simple.js +++ b/test/parallel/test-https-simple.js @@ -26,6 +26,8 @@ const fixtures = require('../common/fixtures'); if (!common.hasCrypto) common.skip('missing crypto'); +const { untrustedLeafErrorCode } = require('../common/tls'); + const assert = require('assert'); const https = require('https'); @@ -93,7 +95,7 @@ server.listen(0, common.mustCall(() => { const checkCertReq = https.request(options, common.mustNotCall()).end(); checkCertReq.on('error', common.mustCall((e) => { - assert.strictEqual(e.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(e.code, untrustedLeafErrorCode); done(); })); })); diff --git a/test/parallel/test-https-strict.js b/test/parallel/test-https-strict.js index a72168289d5..3b27753209f 100644 --- a/test/parallel/test-https-strict.js +++ b/test/parallel/test-https-strict.js @@ -25,6 +25,8 @@ const fixtures = require('../common/fixtures'); if (!common.hasCrypto) common.skip('missing crypto'); +const { untrustedLeafErrorCode } = require('../common/tls'); + // Disable strict server certificate validation by the client process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'; @@ -167,7 +169,7 @@ function allListening() { const port3 = server3.address().port; // server1: host 'agent1', signed by ca1 - makeReq('/inv1', port1, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + makeReq('/inv1', port1, untrustedLeafErrorCode); makeReq('/inv1-ca1', port1, 'ERR_TLS_CERT_ALTNAME_INVALID', null, ca1); makeReq('/inv1-ca1ca2', port1, 'ERR_TLS_CERT_ALTNAME_INVALID', @@ -175,7 +177,7 @@ function allListening() { makeReq('/val1-ca1', port1, null, 'agent1', ca1); makeReq('/val1-ca1ca2', port1, null, 'agent1', [ca1, ca2]); makeReq('/inv1-ca2', port1, - 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', 'agent1', ca2); + untrustedLeafErrorCode, 'agent1', ca2); // server2: self-signed, host = 'agent2' // doesn't matter that thename matches, all of these will error. @@ -186,14 +188,14 @@ function allListening() { 'agent2', [ca1, ca2]); // server3: host 'agent3', signed by ca2 - makeReq('/inv3', port3, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + makeReq('/inv3', port3, untrustedLeafErrorCode); makeReq('/inv3-ca2', port3, 'ERR_TLS_CERT_ALTNAME_INVALID', null, ca2); makeReq('/inv3-ca1ca2', port3, 'ERR_TLS_CERT_ALTNAME_INVALID', null, [ca1, ca2]); makeReq('/val3-ca2', port3, null, 'agent3', ca2); makeReq('/val3-ca1ca2', port3, null, 'agent3', [ca1, ca2]); makeReq('/inv3-ca1', port3, - 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', 'agent1', ca1); + untrustedLeafErrorCode, 'agent1', ca1); } diff --git a/test/parallel/test-tls-addca.js b/test/parallel/test-tls-addca.js index a99d53f55d3..4935350b857 100644 --- a/test/parallel/test-tls-addca.js +++ b/test/parallel/test-tls-addca.js @@ -9,6 +9,7 @@ const fixtures = require('../common/fixtures'); const { assert, connect, keys, tls } = require(fixtures.path('tls-connect')); +const { untrustedLeafErrorCode } = require('../common/tls'); const contextWithoutCert = tls.createSecureContext({}); const contextWithCert = tls.createSecureContext({}); @@ -34,7 +35,7 @@ connect({ server: serverOptions, }, common.mustCall((err, pair, cleanup) => { assert(err); - assert.strictEqual(err.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.code, untrustedLeafErrorCode); cleanup(); // This time it should connect because contextWithCert includes the needed CA diff --git a/test/parallel/test-tls-client-auth.js b/test/parallel/test-tls-client-auth.js index da06156e2e0..509dc3f4bd6 100644 --- a/test/parallel/test-tls-client-auth.js +++ b/test/parallel/test-tls-client-auth.js @@ -11,6 +11,7 @@ const { hasOpenSSL, isBoringSSL } = require('../common/crypto'); const { assert, connect, keys, tls } = require(fixtures.path('tls-connect')); +const { untrustedLeafErrorCode } = require('../common/tls'); // Use ec10 and agent10, they are the only identities with intermediate CAs. const client = keys.ec10; @@ -185,7 +186,7 @@ connect({ cert: server.single, }, }, common.mustCall((err, pair, cleanup) => { - assert.strictEqual(err.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.code, untrustedLeafErrorCode); return cleanup(); })); diff --git a/test/parallel/test-tls-client-cert-resumption.js b/test/parallel/test-tls-client-cert-resumption.js index 790809678d6..3fb90e0080c 100644 --- a/test/parallel/test-tls-client-cert-resumption.js +++ b/test/parallel/test-tls-client-cert-resumption.js @@ -22,6 +22,7 @@ const assert = require('assert'); const crypto = require('crypto'); const tls = require('tls'); const fixtures = require('../common/fixtures'); +const { untrustedLeafErrorCode } = require('../common/tls'); const { once } = require('events'); const ca = fixtures.readKey('ca1-cert.pem'); @@ -47,7 +48,7 @@ const CLIENTS = { cert: fixtures.readKey('agent3-cert.pem'), }, authorized: false, - authorizationError: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', + authorizationError: untrustedLeafErrorCode, peerCN: 'agent3', }, missing: { // No client certificate diff --git a/test/parallel/test-tls-friendly-error-message.js b/test/parallel/test-tls-friendly-error-message.js index 84471da487b..2d734789e3d 100644 --- a/test/parallel/test-tls-friendly-error-message.js +++ b/test/parallel/test-tls-friendly-error-message.js @@ -25,6 +25,7 @@ if (!common.hasCrypto) common.skip('missing crypto'); const fixtures = require('../common/fixtures'); +const { untrustedLeafErrorCode } = require('../common/tls'); const assert = require('assert'); const tls = require('tls'); @@ -39,6 +40,7 @@ tls.createServer({ key, cert }).on('connection', common.mustCall(function() { })).listen(0, common.mustCall(function() { const options = { port: this.address().port, rejectUnauthorized: true }; tls.connect(options).on('error', common.mustCall(function(err) { - assert.strictEqual(err.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.code, untrustedLeafErrorCode); + assert.match(err.message, /try running Node\.js with --use-system-ca/); })); })); diff --git a/test/parallel/test-tls-session-reuse-different-servername.js b/test/parallel/test-tls-session-reuse-different-servername.js index c3ae4be1578..1692f6bab05 100644 --- a/test/parallel/test-tls-session-reuse-different-servername.js +++ b/test/parallel/test-tls-session-reuse-different-servername.js @@ -5,6 +5,7 @@ if (!common.hasCrypto) const assert = require('assert'); const fixtures = require('../common/fixtures'); +const { untrustedLeafErrorCode } = require('../common/tls'); const tls = require('tls'); const { once } = require('events'); @@ -90,7 +91,7 @@ async function testVersion(minVersion, maxVersion) { return socket; }), { - code: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', + code: untrustedLeafErrorCode, }, ); @@ -107,7 +108,7 @@ async function testVersion(minVersion, maxVersion) { return socket; }), { - code: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', + code: untrustedLeafErrorCode, }, ); } finally { diff --git a/test/parallel/test-tls-set-default-ca-certificates-append-fetch.mjs b/test/parallel/test-tls-set-default-ca-certificates-append-fetch.mjs index ca8436b22b0..af27acb7bf4 100644 --- a/test/parallel/test-tls-set-default-ca-certificates-append-fetch.mjs +++ b/test/parallel/test-tls-set-default-ca-certificates-append-fetch.mjs @@ -11,7 +11,7 @@ import assert from 'node:assert'; if (!common.hasCrypto) common.skip('missing crypto'); -const { includesCert } = await import('../common/tls.js'); +const { includesCert, untrustedLeafErrorCode } = await import('../common/tls.js'); const { default: https } = await import('node:https'); const { default: tls } = await import('node:tls'); @@ -37,7 +37,7 @@ const url = `https://localhost:${server.address().port}/hello-world`; await assert.rejects( fetch(url), (err) => { - assert.strictEqual(err.cause.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.cause.code, untrustedLeafErrorCode); return true; }, ); diff --git a/test/parallel/test-tls-set-default-ca-certificates-append-https-request.js b/test/parallel/test-tls-set-default-ca-certificates-append-https-request.js index d7a3baded42..f20cb010ca8 100644 --- a/test/parallel/test-tls-set-default-ca-certificates-append-https-request.js +++ b/test/parallel/test-tls-set-default-ca-certificates-append-https-request.js @@ -10,7 +10,7 @@ const assert = require('assert'); const https = require('https'); const tls = require('tls'); const fixtures = require('../common/fixtures'); -const { includesCert } = require('../common/tls'); +const { includesCert, untrustedLeafErrorCode } = require('../common/tls'); const bundledCerts = tls.getCACertificates('bundled'); const fixtureCert = fixtures.readKey('fake-startcom-root-cert.pem'); @@ -43,7 +43,7 @@ server.listen(0, common.mustCall(() => { req1.on('error', common.mustCall((err) => { console.log(err); // Should fail with certificate verification error - assert.strictEqual(err.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.code, untrustedLeafErrorCode); // Now add the fake-startcom-root-cert to bundled certs - connection should succeed tls.setDefaultCACertificates([...bundledCerts, fixtureCert]); diff --git a/test/parallel/test-tls-set-default-ca-certificates-reset-fetch.mjs b/test/parallel/test-tls-set-default-ca-certificates-reset-fetch.mjs index 479b415d4c5..363497cbe82 100644 --- a/test/parallel/test-tls-set-default-ca-certificates-reset-fetch.mjs +++ b/test/parallel/test-tls-set-default-ca-certificates-reset-fetch.mjs @@ -11,6 +11,7 @@ import assert from 'node:assert'; if (!common.hasCrypto) common.skip('missing crypto'); +const { untrustedLeafErrorCode } = await import('../common/tls.js'); const { default: https } = await import('node:https'); const { default: tls } = await import('node:tls'); @@ -39,7 +40,7 @@ tls.setDefaultCACertificates([]); await assert.rejects( fetch(`https://127.0.0.1:${server.address().port}/empty-ca-test`), (err) => { - assert.strictEqual(err.cause.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.cause.code, untrustedLeafErrorCode); return true; }, ); diff --git a/test/parallel/test-tls-set-default-ca-certificates-reset-https-request.js b/test/parallel/test-tls-set-default-ca-certificates-reset-https-request.js index 7389cacf6d6..b4fe577ab46 100644 --- a/test/parallel/test-tls-set-default-ca-certificates-reset-https-request.js +++ b/test/parallel/test-tls-set-default-ca-certificates-reset-https-request.js @@ -9,6 +9,7 @@ const assert = require('assert'); const https = require('https'); const tls = require('tls'); const fixtures = require('../common/fixtures'); +const { untrustedLeafErrorCode } = require('../common/tls'); // Test HTTPS connection succeeds with proper CA, fails after removing it const server = https.createServer({ @@ -49,7 +50,7 @@ server.listen(0, common.mustCall(() => { req2.on('error', common.mustCall((err) => { // Should fail with certificate verification error. - assert.strictEqual(err.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.code, untrustedLeafErrorCode); server.close(); })); diff --git a/test/parallel/test-tls-socket-default-options.js b/test/parallel/test-tls-socket-default-options.js index 8dfd912285d..e7ad1be3d42 100644 --- a/test/parallel/test-tls-socket-default-options.js +++ b/test/parallel/test-tls-socket-default-options.js @@ -8,13 +8,14 @@ const assert = require('assert'); const { connect, keys, tls } = require(fixtures.path('tls-connect')); +const { untrustedLeafErrorCode } = require('../common/tls'); test(undefined, (err) => { - assert.strictEqual(err.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.code, untrustedLeafErrorCode); }); test({}, (err) => { - assert.strictEqual(err.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.code, untrustedLeafErrorCode); }); test( @@ -30,8 +31,7 @@ test( test( { secureContext: tls.createSecureContext(), ca: keys.agent1.ca }, (err) => { - assert.strictEqual(err.code, - 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.code, untrustedLeafErrorCode); }); function test(client, callback) { @@ -42,7 +42,7 @@ function test(client, callback) { cert: keys.agent1.cert, }, }, common.mustCall(function(err, pair, cleanup) { - assert.strictEqual(err.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.code, untrustedLeafErrorCode); let recv = ''; pair.server.server.once('secureConnection', common.mustCall((conn) => { conn.on('data', (data) => recv += data); diff --git a/test/system-ca/test-native-intermediate-certs.mjs b/test/system-ca/test-native-intermediate-certs.mjs index edf1315422f..9638176b9be 100644 --- a/test/system-ca/test-native-intermediate-certs.mjs +++ b/test/system-ca/test-native-intermediate-certs.mjs @@ -11,6 +11,8 @@ if (!common.hasCrypto) { common.skip('requires crypto'); } +const { untrustedLeafErrorCode } = await import('../common/tls.js'); + // To run this test, the system needs to be configured to trust // the CA certificate first (which needs an interactive GUI approval, e.g. TouchID): // see the README.md in this folder for instructions on how to do this. @@ -72,7 +74,7 @@ describe('use-system-ca', function() { if (common.isWindows) { assert.strictEqual(err.cause.code, 'UNABLE_TO_GET_ISSUER_CERT'); } else { - assert.strictEqual(err.cause.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.cause.code, untrustedLeafErrorCode); } } }); diff --git a/test/system-ca/test-set-default-ca-certificates-append-system-ca.mjs b/test/system-ca/test-set-default-ca-certificates-append-system-ca.mjs index 0cbd9804c36..c9a4cc25a04 100644 --- a/test/system-ca/test-set-default-ca-certificates-append-system-ca.mjs +++ b/test/system-ca/test-set-default-ca-certificates-append-system-ca.mjs @@ -13,6 +13,7 @@ if (!common.hasCrypto) { common.skip('requires crypto'); } +const { untrustedLeafErrorCode } = await import('../common/tls.js'); const { default: https } = await import('node:https'); const { default: tls } = await import('node:tls'); @@ -32,7 +33,7 @@ const url = `https://localhost:${server.address().port}/hello-world`; await assert.rejects( fetch(url), (err) => { - assert.strictEqual(err.cause.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.cause.code, untrustedLeafErrorCode); return true; }, ); diff --git a/test/system-ca/test-use-system-ca-worker-disable.mjs b/test/system-ca/test-use-system-ca-worker-disable.mjs index 43f3f293760..be8497bb54c 100644 --- a/test/system-ca/test-use-system-ca-worker-disable.mjs +++ b/test/system-ca/test-use-system-ca-worker-disable.mjs @@ -14,6 +14,8 @@ if (!common.hasCrypto) { common.skip('requires crypto'); } +const { untrustedLeafErrorCode } = await import('../common/tls.js'); + // To run this test, the system needs to be configured to trust // the CA certificate first (which needs an interactive GUI approval, e.g. TouchID): // see the README.md in this folder for instructions on how to do this. @@ -61,7 +63,7 @@ describe('use-system-ca', function() { const [message] = await once(worker, 'message'); assert.strictEqual(message.ok, false); assert( - message.code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE' || + message.code === untrustedLeafErrorCode || message.code === 'SELF_SIGNED_CERT_IN_CHAIN', `Expected certificate verification error but got: ${JSON.stringify( message, diff --git a/test/system-ca/test-use-system-ca-worker-enable.mjs b/test/system-ca/test-use-system-ca-worker-enable.mjs index f5f3faab481..3b8d7d71a71 100644 --- a/test/system-ca/test-use-system-ca-worker-enable.mjs +++ b/test/system-ca/test-use-system-ca-worker-enable.mjs @@ -14,6 +14,8 @@ if (!common.hasCrypto) { common.skip('requires crypto'); } +const { untrustedLeafErrorCode } = await import('../common/tls.js'); + // To run this test, the system needs to be configured to trust // the CA certificate first (which needs an interactive GUI approval, e.g. TouchID): // see the README.md in this folder for instructions on how to do this. @@ -57,7 +59,7 @@ describe('use-system-ca', function() { workerData: { url }, }); await assert.rejects(fetch(url), (err) => { - assert.strictEqual(err.cause.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'); + assert.strictEqual(err.cause.code, untrustedLeafErrorCode); return true; }); diff --git a/tools/nix/openssl-matrix.nix b/tools/nix/openssl-matrix.nix index 2a6a30183e2..66ded6de0d9 100644 --- a/tools/nix/openssl-matrix.nix +++ b/tools/nix/openssl-matrix.nix @@ -10,8 +10,8 @@ # Using an updated version of BoringSSL as we do not support the old version anymore. boringssl = pkgs.callPackage (builtins.fetchurl { - url = "https://github.com/NixOS/nixpkgs/raw/6062ba1a1b8b6281b12533c9075a2dbeb38f7e49/pkgs/by-name/bo/boringssl/package.nix"; - sha256 = "01n2ga83ds5m9hz88z635g3q1c141ka2qs9k576c62v3fdpgcj6i"; + url = "https://github.com/NixOS/nixpkgs/raw/1c17f6e5f086bf6b259e7a28f68657ed8548a25a/pkgs/by-name/bo/boringssl/package.nix"; + sha256 = "10cw2np6shjanxa2vzfxsrbyz451g1b6qan2v9c1ln75i3n5zn8a"; }) { }; # Other OpenSSL variants we want to test for: From e76a35c134842160d16536294246998a07723f70 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Tue, 27 Oct 2026 13:35:30 +0100 Subject: [PATCH 263/331] crypto: preserve errors during X.509 issuer checks X509View::isIssuedBy() clears the caller's OpenSSL error queue on entry and exit, including when either certificate is missing. Use a mark/pop scope to discard errors from the issuer check without losing earlier diagnostics. Cover successful checks, mismatches, malformed extensions, and null inputs with empty and populated queues. Assisted-by: Codex Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/66898 Backport-PR-URL: https://github.com/nodejs/node/pull/67442 Reviewed-By: Antoine du Hamel --- deps/ncrypto/ncrypto.cc | 2 +- test/cctest/test_node_crypto.cc | 99 +++++++++++++++++++++++++++++++++ 2 files changed, 100 insertions(+), 1 deletion(-) diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index b9e93847ff6..f9d2fbcdfad 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -1619,7 +1619,7 @@ bool X509View::isCA() const { } bool X509View::isIssuedBy(const X509View& issuer) const { - ClearErrorOnReturn clearErrorOnReturn; + MarkPopErrorOnReturn mark_pop_error_on_return; if (cert_ == nullptr || issuer.cert_ == nullptr) return false; return X509_check_issued(const_cast(issuer.cert_), const_cast(cert_)) == X509_V_OK; diff --git a/test/cctest/test_node_crypto.cc b/test/cctest/test_node_crypto.cc index df387ab00f9..15a063453b2 100644 --- a/test/cctest/test_node_crypto.cc +++ b/test/cctest/test_node_crypto.cc @@ -1025,6 +1025,105 @@ TEST(NodeCrypto, X509FormattingPreservesUnrelatedErrors) { ERR_clear_error(); } +TEST(NodeCrypto, X509IssuerChecksPreserveUnrelatedErrors) { + ncrypto::ClearErrorOnReturn clear_errors; + auto ctx = EVPKeyCtxPointer::NewFromAlgorithm(KeyAlgorithm::RSA); + ASSERT_TRUE(ctx); + ASSERT_TRUE(ctx.initForKeygen()); + ASSERT_TRUE(ctx.setRsaKeygenBits(2048)); + EVP_PKEY* raw = nullptr; + ASSERT_EQ(EVP_PKEY_keygen(ctx.get(), &raw), 1); + EVPKeyPointer key(raw); + + ncrypto::X509Pointer cert(X509_new()); + ASSERT_TRUE(cert); + ASSERT_EQ(X509_set_version(cert.get(), 2), 1); + ASSERT_EQ(ASN1_INTEGER_set(X509_get_serialNumber(cert.get()), 1), 1); + ASSERT_EQ( + ASN1_TIME_set_string(X509_getm_notBefore(cert.get()), "20260101000000Z"), + 1); + ASSERT_EQ( + ASN1_TIME_set_string(X509_getm_notAfter(cert.get()), "20270101000000Z"), + 1); + X509NamePointer name(X509_NAME_new()); + ASSERT_TRUE(name); + ASSERT_EQ(X509_NAME_add_entry_by_txt( + name.get(), + "CN", + MBSTRING_ASC, + reinterpret_cast("issuer"), + -1, + -1, + 0), + 1); + ASSERT_EQ(X509_set_subject_name(cert.get(), name.get()), 1); + ASSERT_EQ(X509_set_issuer_name(cert.get(), name.get()), 1); + ASSERT_EQ(X509_set_pubkey(cert.get(), key.get()), 1); + ASSERT_GT(X509_sign(cert.get(), key.get(), EVP_sha256()), 0); + + X509NamePointer mismatch_name(X509_NAME_dup(name.get())); + ASSERT_TRUE(mismatch_name); + ASSERT_EQ(X509_NAME_add_entry_by_txt( + mismatch_name.get(), + "OU", + MBSTRING_ASC, + reinterpret_cast("other"), + -1, + -1, + 0), + 1); + + ncrypto::DeleteFnPtr invalid_value( + ASN1_OCTET_STRING_new()); + ASSERT_TRUE(invalid_value); + const unsigned char truncated_sequence[] = {0x30}; + ASSERT_EQ( + ASN1_OCTET_STRING_set( + invalid_value.get(), truncated_sequence, sizeof(truncated_sequence)), + 1); + X509ExtensionPointer invalid_constraints(X509_EXTENSION_create_by_NID( + nullptr, NID_basic_constraints, 0, invalid_value.get())); + ASSERT_TRUE(invalid_constraints); + + for (const bool seed_error : {true, false}) { + // Reparse each issuer so extension-cache failures are exercised each time. + auto matching_issuer = cert.view().clone(); + auto mismatch = cert.view().clone(); + auto malformed = cert.view().clone(); + ASSERT_TRUE(matching_issuer); + ASSERT_TRUE(mismatch); + ASSERT_TRUE(malformed); + ASSERT_EQ(X509_set_subject_name(mismatch.get(), mismatch_name.get()), 1); + ASSERT_EQ(X509_add_ext(malformed.get(), invalid_constraints.get(), -1), 1); + + const auto check = [seed_error](ncrypto::X509View subject, + ncrypto::X509View issuer, + bool issued) { + ERR_clear_error(); + if (seed_error) { +#if NCRYPTO_USE_OPENSSL3_PROVIDER + ERR_raise(ERR_LIB_USER, 1); +#elif NCRYPTO_USE_BORINGSSL || NCRYPTO_USE_LEGACY_OPENSSL + ERR_put_error(ERR_LIB_USER, 0, 1, __FILE__, __LINE__); +#else +#error "Unsupported crypto backend" +#endif + } + const auto expected = ERR_peek_error(); + if (seed_error) ASSERT_NE(expected, 0UL); + EXPECT_EQ(subject.isIssuedBy(issuer), issued); + EXPECT_EQ(ERR_get_error(), expected); + EXPECT_EQ(ERR_get_error(), 0UL); + }; + + check(cert.view(), matching_issuer.view(), true); + check(cert.view(), mismatch.view(), false); + check(cert.view(), malformed.view(), false); + check({}, matching_issuer.view(), false); + check(cert.view(), {}, false); + } +} + TEST(NodeCrypto, X509KeyVisitorsHandleMissingPublicKey) { ncrypto::X509Pointer cert(X509_new()); ASSERT_TRUE(cert); From 92f61d001f4df9a7a5234803011a27c964b911ab Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 4 Nov 2026 10:20:53 +0100 Subject: [PATCH 264/331] crypto: add X509Certificate inspection getters Expose version, subjectName, issuerName, extensions, tbs, and signature without requiring callers to parse display strings or certificate DER. Names include complete DER and grouped, ordered RDN attributes. Extensions retain their order, duplicate and unknown OIDs, criticality, and raw values. Expose the exact signed TBSCertificate bytes and the signature octets, algorithm OID, and DER parameters. Return fresh objects, arrays, and Buffers from the new getters, leaving existing getter caching unchanged. Report inspection failures as ERR_CRYPTO_INVALID_X509_CERTIFICATE. Fixes: https://github.com/nodejs/node/issues/48730 Assisted-by: Codex Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/67082 Backport-PR-URL: https://github.com/nodejs/node/pull/67442 Reviewed-By: Antoine du Hamel --- deps/ncrypto/ncrypto.cc | 168 ++++++++ deps/ncrypto/ncrypto.h | 28 ++ doc/api/crypto.md | 208 ++++++++++ doc/api/errors.md | 10 + lib/internal/crypto/x509.js | 41 ++ lib/internal/errors.js | 2 + src/crypto/crypto_x509.cc | 388 ++++++++++++++++++ src/crypto/crypto_x509.h | 3 + src/env_properties.h | 5 + test/cctest/test_node_crypto.cc | 8 + .../test-crypto-x509-chain-snapshot.js | 34 ++ test/parallel/test-crypto-x509-inspection.js | 281 +++++++++++++ typings/internalBinding/crypto.d.ts | 32 ++ 13 files changed, 1208 insertions(+) create mode 100644 test/parallel/test-crypto-x509-inspection.js diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index f9d2fbcdfad..33c3423495a 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -56,6 +56,15 @@ using BignumCtxPointer = DeleteFnPtr; using BignumGenCallbackPointer = DeleteFnPtr; using NetscapeSPKIPointer = DeleteFnPtr; +struct ASN1SequenceDeleter final { + void operator()(ASN1_SEQUENCE_ANY* sequence) const { + sk_ASN1_TYPE_pop_free(sequence, ASN1_TYPE_free); + } +}; + +using ASN1SequencePointer = + std::unique_ptr; + #if NCRYPTO_USE_OPENSSL3_PROVIDER using X509PubKeyPointer = DeleteFnPtr; // OSSL_STORE_close() returns int, so it needs a void-returning adapter to be @@ -1618,6 +1627,165 @@ bool X509View::isCA() const { return X509_check_ca(const_cast(cert_)) == 1; } +namespace { +bool CopyStringBytes(const ASN1_STRING* value, + std::vector* output) { + if (value == nullptr) return false; + const int length = ASN1_STRING_length(value); + const unsigned char* data = ASN1_STRING_get0_data(value); + if (length < 0 || (length > 0 && data == nullptr)) return false; + if (length == 0) { + output->clear(); + } else { + output->assign(data, data + static_cast(length)); + } + return true; +} + +bool CanConvertNameValueToUtf8(const ASN1_STRING* value) { + if (value == nullptr) return false; + switch (ASN1_STRING_type(value)) { + case V_ASN1_UTF8STRING: + case V_ASN1_NUMERICSTRING: + case V_ASN1_PRINTABLESTRING: + case V_ASN1_T61STRING: + case V_ASN1_IA5STRING: + case V_ASN1_UTCTIME: + case V_ASN1_GENERALIZEDTIME: + case V_ASN1_ISO64STRING: + case V_ASN1_UNIVERSALSTRING: + case V_ASN1_BMPSTRING: + return true; + default: + return false; + } +} + +std::optional GetEncodedRdnCount(const X509_NAME* name) { + const unsigned char* der = nullptr; + size_t der_length = 0; + if (X509_NAME_get0_der(const_cast(name), &der, &der_length) != + 1 || + der == nullptr || der_length > static_cast(LONG_MAX)) { + return std::nullopt; + } + + const unsigned char* cursor = der; + ASN1SequencePointer rdns(d2i_ASN1_SEQUENCE_ANY( + nullptr, &cursor, static_cast(der_length))); // NOLINT(runtime/int) + if (!rdns || cursor != der + der_length) return std::nullopt; + + const OPENSSL_SIZE_T count = sk_ASN1_TYPE_num(rdns.get()); + for (OPENSSL_SIZE_T i = 0; i < count; i++) { + const ASN1_TYPE* rdn = sk_ASN1_TYPE_value(rdns.get(), i); + if (rdn == nullptr || ASN1_TYPE_get(rdn) != V_ASN1_SET) { + return std::nullopt; + } + } + return static_cast(count); +} + +std::optional InspectName(const X509_NAME* name) { + if (name == nullptr) return std::nullopt; + const int count = X509_NAME_entry_count(name); + if (count < 0) return std::nullopt; + const auto encoded_rdn_count = GetEncodedRdnCount(name); + if (!encoded_rdn_count.has_value()) return std::nullopt; + + X509NameInspection output; + output.reserve(static_cast(count)); + int previous_set = -1; + for (int i = 0; i < count; i++) { + const X509_NAME_ENTRY* entry = X509_NAME_get_entry(name, i); + if (entry == nullptr) return std::nullopt; + + const ASN1_OBJECT* object = X509_NAME_ENTRY_get_object(entry); + const ASN1_STRING* value = X509_NAME_ENTRY_get_data(entry); + auto oid = ObjectToText(object, true); + const int set = X509_NAME_ENTRY_set(entry); + if (!oid.has_value() || value == nullptr || set < 0 || + (set != previous_set && + (previous_set == INT_MAX || set != previous_set + 1))) { + return std::nullopt; + } + previous_set = set; + + X509NameAttribute attribute{ + .set = set, + .oid = std::move(oid.value()), + }; + if (CanConvertNameValueToUtf8(value)) { + unsigned char* data = nullptr; + const int length = ASN1_STRING_to_UTF8(&data, value); + DataPointer owned(data, length > 0 ? static_cast(length) : 0); + if (length < 0 || (length > 0 && !owned)) return std::nullopt; + attribute.value = + length == 0 ? std::string() + : std::string(reinterpret_cast(owned.get()), + static_cast(length)); + } + output.push_back(std::move(attribute)); + } + const size_t inspected_rdn_count = + previous_set < 0 ? 0 : static_cast(previous_set) + 1; + if (inspected_rdn_count != encoded_rdn_count.value()) return std::nullopt; + return output; +} + +std::optional> InspectExtensions( + const X509* certificate) { + if (certificate == nullptr) return std::nullopt; + const int count = X509_get_ext_count(certificate); + if (count < 0) return std::nullopt; + + std::vector output; + output.reserve(static_cast(count)); + for (int i = 0; i < count; i++) { + const X509_EXTENSION* extension = X509_get_ext(certificate, i); + if (extension == nullptr) return std::nullopt; + + auto* mutable_extension = const_cast(extension); + auto oid = ObjectToText(X509_EXTENSION_get_object(mutable_extension), true); + const ASN1_OCTET_STRING* value = X509_EXTENSION_get_data(mutable_extension); + if (!oid.has_value() || value == nullptr) return std::nullopt; + + X509RawExtension inspected{ + .oid = std::move(oid.value()), + .critical = X509_EXTENSION_get_critical(mutable_extension) != 0, + }; + if (!CopyStringBytes(value, &inspected.value)) return std::nullopt; + output.push_back(std::move(inspected)); + } + return output; +} +} // namespace + +std::optional X509View::getVersion() const { + MarkPopErrorOnReturn mark_pop_error_on_return; + if (cert_ == nullptr) return std::nullopt; + const long version = X509_get_version(cert_); // NOLINT(runtime/int) + if (version < 0 || version > 2) return std::nullopt; + return static_cast(version) + 1; +} + +std::optional X509View::inspectSubjectName() const { + MarkPopErrorOnReturn mark_pop_error_on_return; + if (cert_ == nullptr) return std::nullopt; + return InspectName(X509_get_subject_name(cert_)); +} + +std::optional X509View::inspectIssuerName() const { + MarkPopErrorOnReturn mark_pop_error_on_return; + if (cert_ == nullptr) return std::nullopt; + return InspectName(X509_get_issuer_name(cert_)); +} + +std::optional> X509View::inspectExtensions() + const { + MarkPopErrorOnReturn mark_pop_error_on_return; + return InspectExtensions(cert_); +} + bool X509View::isIssuedBy(const X509View& issuer) const { MarkPopErrorOnReturn mark_pop_error_on_return; if (cert_ == nullptr || issuer.cert_ == nullptr) return false; diff --git a/deps/ncrypto/ncrypto.h b/deps/ncrypto/ncrypto.h index 9a501a551b4..d5b7ec78f55 100644 --- a/deps/ncrypto/ncrypto.h +++ b/deps/ncrypto/ncrypto.h @@ -73,6 +73,15 @@ #define NCRYPTO_USE_LEGACY_KEY_TYPES 0 #endif +// OpenSSL 4 makes ASN1_STRING opaque and provides a checked BIT STRING length +// accessor. Earlier OpenSSL releases and pinned BoringSSL expose the decoded +// unused-bit count through ASN1_STRING::flags. +#if !NCRYPTO_USE_BORINGSSL && OPENSSL_VERSION_PREREQ(4, 0) +#define NCRYPTO_HAS_ASN1_BIT_STRING_GET_LENGTH 1 +#else +#define NCRYPTO_HAS_ASN1_BIT_STRING_GET_LENGTH 0 +#endif + #if NCRYPTO_USE_OPENSSL3_PROVIDER #include #include @@ -1642,6 +1651,20 @@ class X509Name final { int total_; }; +struct X509NameAttribute final { + int set = 0; + std::string oid; + std::optional value; +}; + +using X509NameInspection = std::vector; + +struct X509RawExtension final { + std::string oid; + bool critical = false; + std::vector value; +}; + class X509View final { public: static X509View From(const SSLPointer& ssl); @@ -1679,6 +1702,11 @@ class X509View final { Result getPublicKey() const; StackOfASN1 getKeyUsage() const; + std::optional getVersion() const; + std::optional inspectSubjectName() const; + std::optional inspectIssuerName() const; + std::optional> inspectExtensions() const; + bool isCA() const; bool isIssuedBy(const X509View& other) const; bool checkPrivateKey(const EVPKeyPointer& pkey) const; diff --git a/doc/api/crypto.md b/doc/api/crypto.md index 0a294ecaa32..d07486be85f 100644 --- a/doc/api/crypto.md +++ b/doc/api/crypto.md @@ -3134,6 +3134,47 @@ added: v15.6.0 Checks whether the public key for this certificate is consistent with the given private key. +### `x509.extensions` + + + +* Type: {Object\[]} + * `oid` {string} The canonical dotted-decimal extension OID. + * `critical` {boolean} Whether the extension is critical. + * `value` {Buffer} The bytes contained in the extension's `extnValue` OCTET + STRING. The OCTET STRING tag and length are not included. + +One entry is returned for every extension, in the order in which it appears in +the certificate. Unknown extensions and repeated OIDs are included. The +contents of `value` are not decoded according to `oid`. A certificate with no +extensions produces an empty array. + +Unlike [`x509.subjectAltName`][], [`x509.infoAccess`][], and +[`x509.keyUsage`][] (Extended Key Usage), which decode or format selected +extension types, this property exposes raw extension contents. `value` contains +the exact extension value bytes, not a complete encoded `Extension` record. +The extension-specific syntax is not validated. + +Each access returns a new array containing new objects and `Buffer`s. Modifying +them does not affect the certificate or later accesses. + +For example, a Basic Constraints extension allowing a certificate to act as a +CA can appear as: + +```js +console.log(x509.extensions[0]); +// { +// oid: '2.5.29.19', +// critical: true, +// value: +// } +``` + +Accessing this property throws `ERR_CRYPTO_INVALID_X509_CERTIFICATE` if the +extensions cannot be inspected. + ### `x509.fingerprint` + +* Type: {Object} + * `raw` {Buffer} The complete DER-encoded `Name`. + * `rdns` {Array\} The relative distinguished name sequence. + * `oid` {string} The canonical dotted-decimal object identifier. + * `value` {string} A UTF-8 representation of the attribute value. This + property is omitted when the ASN.1 value type is not supported for text + conversion. + +The issuer distinguished name, also exposed as a formatted string by +[`x509.issuer`][]. The outer `rdns` array contains the relative distinguished +names in encoded order. Each inner array represents one relative distinguished +name and contains its attributes in encoded order. A valid empty name has an +empty `rdns` array. + +`rdns` is a decoded view and does not include ASN.1 value types. Use `raw` for a +lossless representation of the complete name, including attribute values whose +`value` property is omitted from `rdns`. + +Each access returns newly allocated objects, arrays, and a `Buffer`. +Modifying them does not affect the certificate or later accesses. + +For example: + +```js +console.log(x509.issuerName.rdns); +// [ +// [ { oid: '2.5.4.6', value: 'US' } ], +// [ { oid: '2.5.4.10', value: 'Example CA' } ] +// ] +``` + +Accessing this property throws `ERR_CRYPTO_INVALID_X509_CERTIFICATE` if the +issuer name cannot be inspected. + ### `x509.keyUsage` + +* Type: {Object} + * `raw` {Buffer} The complete DER-encoded `Name`. + * `rdns` {Array\} The relative distinguished name sequence. + * `oid` {string} The canonical dotted-decimal object identifier. + * `value` {string} A UTF-8 representation of the attribute value. This + property is omitted when the ASN.1 value type is not supported for text + conversion. + +The subject distinguished name, also exposed as a formatted string by +[`x509.subject`][]. The outer `rdns` array contains the relative distinguished +names in encoded order. Each inner array represents one relative distinguished +name and contains its attributes in encoded order. A valid empty name has an +empty `rdns` array. + +`rdns` is a decoded view and does not include ASN.1 value types. Use `raw` for a +lossless representation of the complete name, including attribute values whose +`value` property is omitted from `rdns`. + +Each access returns newly allocated objects, arrays, and a `Buffer`. +Modifying them does not affect the certificate or later accesses. + +For example, attributes in the same inner array belong to one multi-valued +relative distinguished name: + +```js +console.log(x509.subjectName.rdns); +// [ +// [ { oid: '2.5.4.6', value: 'US' } ], +// [ +// { oid: '2.5.4.11', value: 'Security' }, +// { oid: '2.5.4.10', value: 'Example Corp' } +// ], +// [ { oid: '2.5.4.3', value: 'example.com' } ] +// ] +``` + +Accessing this property throws `ERR_CRYPTO_INVALID_X509_CERTIFICATE` if the +subject name cannot be inspected. + +### `x509.tbs` + + + +* Type: {Buffer} + +Unlike [`x509.raw`][], which contains the whole certificate, this property +contains only the complete encoded `TBSCertificate`: the exact bytes covered +by the certificate's signature. They are copied from the certificate encoding, +not reconstructed from decoded fields. + +Each access returns a new `Buffer`. Modifying it does not affect the certificate +or later accesses. + +Accessing this property throws `ERR_CRYPTO_INVALID_X509_CERTIFICATE` if the +`TBSCertificate` cannot be inspected. + ### `x509.toJSON()` + +* Type: {Object} + * `algorithm` {Object} The certificate-level `signatureAlgorithm` paired with + the `signatureValue`. + * `oid` {string} The canonical dotted-decimal algorithm OID. + * `parameters` {Buffer} The complete DER-encoded ASN.1 parameters. This + property is omitted when the parameters are absent. + * `value` {Buffer} The signature octets contained in the certificate's + `signatureValue` BIT STRING. + +`algorithm.oid` identifies the same certificate-level algorithm as +[`x509.signatureAlgorithmOid`][]. In addition to the algorithm identification +provided by that property and [`x509.signatureAlgorithm`][], this property +exposes the algorithm parameters and signature bytes. + +The parameters are DER-encoded independently; the complete encoded +`AlgorithmIdentifier` and BIT STRING wrappers are not returned. Accessing this +property does not verify the signature. + +Each access returns new outer and `algorithm` objects, with new `Buffer`s for +`value` and `parameters` when present. Modifying them does not affect the +certificate or later accesses. + +For example, a certificate signed using RSA with SHA-256 can produce: + +```js +console.log(x509.signature); +// { +// algorithm: { +// oid: '1.2.840.113549.1.1.11', +// parameters: +// }, +// value: +// } +``` + +Accessing this property throws `ERR_CRYPTO_INVALID_X509_CERTIFICATE` if the +signature cannot be inspected. + ### `x509.signatureAlgorithm` + +* Type: {number} + +The certificate version: `1` for X.509 v1, `2` for X.509 v2, or `3` for X.509 +v3. A certificate with no encoded version field has version `1`. + ### `x509.verify(publicKey)` + +An X.509 certificate field could not be inspected. + ### `ERR_CRYPTO_JOB_INIT_FAILED` diff --git a/lib/internal/crypto/x509.js b/lib/internal/crypto/x509.js index 0a0da0296a8..30681da0b12 100644 --- a/lib/internal/crypto/x509.js +++ b/lib/internal/crypto/x509.js @@ -48,6 +48,7 @@ const { const { codes: { + ERR_CRYPTO_INVALID_X509_CERTIFICATE, ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_INVALID_THIS, @@ -135,22 +136,28 @@ const { fingerprint512: nativeFingerprint512, getIssuerCert: nativeGetIssuerCert, infoAccess: nativeInfoAccess, + issuerName: nativeIssuerName, issuer: nativeIssuer, + extensions: nativeExtensions, keyUsage: nativeKeyUsage, pem: nativePem, publicKey: nativePublicKey, raw: nativeRaw, serialNumber: nativeSerialNumber, + signature: nativeSignature, signatureAlgorithm: nativeSignatureAlgorithm, signatureAlgorithmOid: nativeSignatureAlgorithmOid, subject: nativeSubject, + subjectName: nativeSubjectName, subjectAltName: nativeSubjectAltName, toLegacy: nativeToLegacy, validFrom: nativeValidFrom, validFromDate: nativeValidFromDate, validTo: nativeValidTo, validToDate: nativeValidToDate, + version: nativeVersion, verify: nativeVerify, + tbs: nativeTbs, } = NativeX509Certificate.prototype; let getState; @@ -165,6 +172,16 @@ const { return state[index]; } + function getInspectionValue(certificate, getter) { + getState(certificate); + const value = FunctionPrototypeCall(getter, certificate); + if (value === undefined) { + throw new ERR_CRYPTO_INVALID_X509_CERTIFICATE( + 'the certificate cannot be inspected'); + } + return value; + } + class X509Certificate { constructor(buffer) { if (typeof buffer === 'string') @@ -296,6 +313,30 @@ const { this, kSlotSignatureAlgorithmOid, nativeSignatureAlgorithmOid); } + get version() { + return getInspectionValue(this, nativeVersion); + } + + get subjectName() { + return getInspectionValue(this, nativeSubjectName); + } + + get issuerName() { + return getInspectionValue(this, nativeIssuerName); + } + + get extensions() { + return getInspectionValue(this, nativeExtensions); + } + + get tbs() { + return getInspectionValue(this, nativeTbs); + } + + get signature() { + return getInspectionValue(this, nativeSignature); + } + get raw() { return getCachedValue(this, kSlotRaw, nativeRaw); } diff --git a/lib/internal/errors.js b/lib/internal/errors.js index 2d8551302bd..117ad1e9793 100644 --- a/lib/internal/errors.js +++ b/lib/internal/errors.js @@ -1193,6 +1193,8 @@ E('ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE', 'Invalid key object type %s, expected %s.', TypeError); E('ERR_CRYPTO_INVALID_MAC', 'Invalid MAC: %s', TypeError); E('ERR_CRYPTO_INVALID_STATE', 'Invalid state for operation %s', Error); +E('ERR_CRYPTO_INVALID_X509_CERTIFICATE', + 'Invalid X.509 certificate: %s', Error); E('ERR_CRYPTO_KEM_NOT_SUPPORTED', 'KEM is not supported', Error); E('ERR_CRYPTO_MAC_FINALIZED', 'MAC already finalized', Error); E('ERR_CRYPTO_MAC_NOT_SUPPORTED', 'MAC is not supported', Error); diff --git a/src/crypto/crypto_x509.cc b/src/crypto/crypto_x509.cc index 3a9c296970a..f24f1c8407f 100644 --- a/src/crypto/crypto_x509.cc +++ b/src/crypto/crypto_x509.cc @@ -28,6 +28,7 @@ using ncrypto::Digest; using ncrypto::MarkPopErrorOnReturn; using ncrypto::SSLPointer; using ncrypto::X509Name; +using ncrypto::X509NameInspection; using ncrypto::X509Pointer; using ncrypto::X509View; using v8::Array; @@ -392,6 +393,381 @@ MaybeLocal GetKeyUsage(Environment* env, const X509View& cert) { return Array::New(env->isolate(), vec.data(), vec.size()); } +bool SetValue(Local context, + Local object, + Local name, + Local value) { + return object->CreateDataProperty(context, name, value).FromMaybe(false); +} + +bool SetArrayValue(Local context, + Local array, + uint32_t index, + Local value) { + return array->CreateDataProperty(context, index, value).FromMaybe(false); +} + +MaybeLocal CopyBuffer(Environment* env, + ncrypto::Buffer value) { + const char* data = + value.len == 0 ? "" : reinterpret_cast(value.data); + return Buffer::Copy(env, data, value.len); +} + +MaybeLocal CopyBuffer(Environment* env, + const std::vector& value) { + return CopyBuffer(env, {.data = value.data(), .len = value.size()}); +} + +std::optional OidToText(const ASN1_OBJECT* object) { + if (object == nullptr) return std::nullopt; + const int length = OBJ_obj2txt(nullptr, 0, object, 1); + if (length <= 0 || length == std::numeric_limits::max()) { + return std::nullopt; + } + std::string output(static_cast(length) + 1, '\0'); + if (OBJ_obj2txt(output.data(), length + 1, object, 1) != length) { + return std::nullopt; + } + output.resize(static_cast(length)); + return output; +} + +struct SequenceSpan final { + ncrypto::Buffer encoded; + ncrypto::Buffer content; +}; + +bool ReadSequence(ncrypto::Buffer input, + SequenceSpan* out) { + if (out == nullptr || input.data == nullptr || input.len == 0 || + input.len > static_cast(LONG_MAX)) { + return false; + } + + const unsigned char* const start = input.data; + const unsigned char* content = start; + long content_length = 0; // NOLINT(runtime/int) + int tag = 0; + int tag_class = 0; + const int flags = + ASN1_get_object(&content, + &content_length, + &tag, + &tag_class, + static_cast(input.len)); // NOLINT(runtime/int) + constexpr int kIndefiniteLength = 0x01; + constexpr int kDecodeError = 0x80; + if ((flags & (kIndefiniteLength | kDecodeError)) != 0 || + (flags & V_ASN1_CONSTRUCTED) == 0 || tag != V_ASN1_SEQUENCE || + tag_class != V_ASN1_UNIVERSAL || content_length < 0) { + return false; + } + + const size_t header_length = static_cast(content - start); + const size_t length = static_cast(content_length); + if (header_length > input.len || length > input.len - header_length) { + return false; + } + *out = { + .encoded = {.data = start, .len = header_length + length}, + .content = {.data = content, .len = length}, + }; + return true; +} + +std::optional> GetExactTbs( + const X509CertificateSnapshot::DER& certificate) { + SequenceSpan outer; + const ncrypto::Buffer encoded{ + .data = certificate.data(), + .len = certificate.size(), + }; + if (!ReadSequence(encoded, &outer) || outer.encoded.len != encoded.len) { + return std::nullopt; + } + + SequenceSpan tbs; + if (!ReadSequence(outer.content, &tbs)) return std::nullopt; + return tbs.encoded; +} + +bool GetNameDer(const X509_NAME* name, + ncrypto::Buffer* encoded) { + if (name == nullptr || encoded == nullptr) return false; + const unsigned char* data = nullptr; + size_t length = 0; + if (X509_NAME_get0_der(const_cast(name), &data, &length) != 1 || + (data == nullptr && length != 0)) { + return false; + } + *encoded = {.data = data, .len = length}; + return true; +} + +MaybeLocal CreateName(Environment* env, + const X509NameInspection& native, + const X509_NAME* name) { + Local context = env->context(); + size_t rdn_count = 0; + for (const auto& attribute : native) { + if (attribute.set < 0) return {}; + const size_t set = static_cast(attribute.set); + if (set == rdn_count) { + rdn_count++; + } else if (rdn_count == 0 || set != rdn_count - 1) { + return {}; + } + } + + if (rdn_count > static_cast(INT_MAX)) return {}; + Local rdns = Array::New(env->isolate(), static_cast(rdn_count)); + LocalVector groups(env->isolate()); + groups.reserve(rdn_count); + std::vector group_lengths(rdn_count, 0); + for (size_t i = 0; i < rdn_count; i++) { + Local group = Array::New(env->isolate()); + if (!SetArrayValue(context, rdns, i, group)) return {}; + groups.push_back(group); + } + + for (const auto& attribute : native) { + Local output = Object::New(env->isolate()); + if (!SetValue(context, + output, + env->oid_string(), + OneByteString(env->isolate(), attribute.oid))) { + return {}; + } + if (attribute.value.has_value()) { + Local value; + if (!ToV8Value(env, attribute.value.value()).ToLocal(&value) || + !SetValue(context, output, env->value_string(), value)) { + return {}; + } + } + const size_t rdn_index = static_cast(attribute.set); + if (!SetArrayValue( + context, groups[rdn_index], group_lengths[rdn_index]++, output)) { + return {}; + } + } + + ncrypto::Buffer encoded; + Local raw; + Local output = Object::New(env->isolate()); + if (!GetNameDer(name, &encoded) || !CopyBuffer(env, encoded).ToLocal(&raw) || + !SetValue(context, output, env->raw_string(), raw) || + !SetValue(context, output, env->rdns_string(), rdns)) { + return {}; + } + return output; +} + +MaybeLocal CreateRawExtensions( + Environment* env, + const std::vector& extensions) { + Local context = env->context(); + if (extensions.size() > static_cast(INT_MAX)) return {}; + Local output = + Array::New(env->isolate(), static_cast(extensions.size())); + for (size_t i = 0; i < extensions.size(); i++) { + const auto& extension = extensions[i]; + Local value = Object::New(env->isolate()); + Local bytes; + if (!CopyBuffer(env, extension.value).ToLocal(&bytes) || + !SetValue(context, + value, + env->oid_string(), + OneByteString(env->isolate(), extension.oid)) || + !SetValue(context, + value, + env->critical_string(), + Boolean::New(env->isolate(), extension.critical)) || + !SetValue(context, value, env->value_string(), bytes) || + !SetArrayValue(context, output, i, value)) { + return {}; + } + } + return output; +} + +MaybeLocal CreateAlgorithmIdentifier(Environment* env, + const X509_ALGOR* native) { + if (native == nullptr) return {}; + const ASN1_OBJECT* native_oid = nullptr; + int parameter_type = V_ASN1_UNDEF; + const void* parameter_value = nullptr; + X509_ALGOR_get0(&native_oid, ¶meter_type, ¶meter_value, native); + auto oid = OidToText(native_oid); + if (!oid.has_value()) return {}; + + Local context = env->context(); + Local output = Object::New(env->isolate()); + if (!SetValue(context, + output, + env->oid_string(), + OneByteString(env->isolate(), oid.value()))) { + return {}; + } + if (parameter_type != V_ASN1_UNDEF) { + ncrypto::DeleteFnPtr native_parameters( + ASN1_TYPE_new()); + if (!native_parameters || + ASN1_TYPE_set1( + native_parameters.get(), parameter_type, parameter_value) != 1) { + return {}; + } + const int length = i2d_ASN1_TYPE(native_parameters.get(), nullptr); + if (length <= 0) return {}; + std::vector encoded(static_cast(length)); + unsigned char* cursor = encoded.data(); + if (i2d_ASN1_TYPE(native_parameters.get(), &cursor) != length || + cursor != encoded.data() + encoded.size()) { + return {}; + } + + Local parameters; + if (!CopyBuffer(env, encoded).ToLocal(¶meters) || + !SetValue(context, output, env->parameters_string(), parameters)) { + return {}; + } + } + return output; +} + +MaybeLocal CreateSignature(Environment* env, + const X509View& certificate) { + const ASN1_BIT_STRING* native_signature = nullptr; + const X509_ALGOR* native_algorithm = nullptr; + X509_get0_signature(&native_signature, &native_algorithm, certificate.get()); + if (native_signature == nullptr || native_algorithm == nullptr || + ASN1_STRING_type(native_signature) != V_ASN1_BIT_STRING) { + return {}; + } + + const int native_length = ASN1_STRING_length(native_signature); + const unsigned char* native_data = ASN1_STRING_get0_data(native_signature); + if (native_length < 0 || (native_length > 0 && native_data == nullptr)) { + return {}; + } +#if NCRYPTO_HAS_ASN1_BIT_STRING_GET_LENGTH + size_t byte_length = 0; + int unused_bits = 0; + if (ASN1_BIT_STRING_get_length( + native_signature, &byte_length, &unused_bits) != 1 || + unused_bits != 0 || byte_length != static_cast(native_length)) { + return {}; + } +#elif NCRYPTO_USE_OPENSSL3_PROVIDER || NCRYPTO_USE_BORINGSSL || \ + NCRYPTO_USE_LEGACY_OPENSSL + if ((native_signature->flags & ASN1_STRING_FLAG_BITS_LEFT) != 0 && + (native_signature->flags & 0x07) != 0) { + return {}; + } +#else +#error "Unsupported crypto backend" +#endif + + const ncrypto::Buffer signature{ + .data = native_data, + .len = static_cast(native_length), + }; + + Local algorithm; + Local value; + if (!CreateAlgorithmIdentifier(env, native_algorithm).ToLocal(&algorithm) || + !CopyBuffer(env, signature).ToLocal(&value)) { + return {}; + } + + Local context = env->context(); + Local output = Object::New(env->isolate()); + if (!SetValue(context, output, env->algorithm_string(), algorithm) || + !SetValue(context, output, env->value_string(), value)) { + return {}; + } + return output; +} + +void Version(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + X509Certificate* certificate; + ASSIGN_OR_RETURN_UNWRAP(&certificate, args.This()); + const auto version = certificate->view().getVersion(); + if (!version.has_value()) return; + args.GetReturnValue().Set( + Integer::New(env->isolate(), static_cast(version.value()))); +} + +void StructuredName(const FunctionCallbackInfo& args, bool subject) { + Environment* env = Environment::GetCurrent(args); + X509Certificate* certificate; + ASSIGN_OR_RETURN_UNWRAP(&certificate, args.This()); + + const auto native = subject ? certificate->view().inspectSubjectName() + : certificate->view().inspectIssuerName(); + if (!native.has_value()) return; + + MarkPopErrorOnReturn mark_pop_error_on_return; + const X509_NAME* name = subject ? X509_get_subject_name(certificate->get()) + : X509_get_issuer_name(certificate->get()); + Local output; + if (!CreateName(env, native.value(), name).ToLocal(&output)) { + return; + } + args.GetReturnValue().Set(output); +} + +void SubjectName(const FunctionCallbackInfo& args) { + StructuredName(args, true); +} + +void IssuerName(const FunctionCallbackInfo& args) { + StructuredName(args, false); +} + +void Extensions(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + X509Certificate* certificate; + ASSIGN_OR_RETURN_UNWRAP(&certificate, args.This()); + + const auto extensions = certificate->view().inspectExtensions(); + Local output; + if (!extensions.has_value() || + !CreateRawExtensions(env, extensions.value()).ToLocal(&output)) { + return; + } + args.GetReturnValue().Set(output); +} + +void Tbs(const FunctionCallbackInfo& args) { + MarkPopErrorOnReturn mark_pop_error_on_return; + Environment* env = Environment::GetCurrent(args); + X509Certificate* certificate; + ASSIGN_OR_RETURN_UNWRAP(&certificate, args.This()); + + const auto tbs = GetExactTbs(certificate->snapshot_der()); + Local output; + if (!tbs.has_value() || !CopyBuffer(env, tbs.value()).ToLocal(&output)) { + return; + } + args.GetReturnValue().Set(output); +} + +void Signature(const FunctionCallbackInfo& args) { + MarkPopErrorOnReturn mark_pop_error_on_return; + Environment* env = Environment::GetCurrent(args); + X509Certificate* certificate; + ASSIGN_OR_RETURN_UNWRAP(&certificate, args.This()); + + Local output; + if (!CreateSignature(env, certificate->view()).ToLocal(&output)) { + return; + } + args.GetReturnValue().Set(output); +} + void Pem(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); X509Certificate* cert; @@ -1011,6 +1387,12 @@ Local X509Certificate::GetConstructorTemplate( SetProtoMethodNoSideEffect(isolate, tmpl, "serialNumber", SerialNumber); SetProtoMethodNoSideEffect(isolate, tmpl, "pem", Pem); SetProtoMethodNoSideEffect(isolate, tmpl, "raw", Der); + SetProtoMethodNoSideEffect(isolate, tmpl, "version", Version); + SetProtoMethodNoSideEffect(isolate, tmpl, "subjectName", SubjectName); + SetProtoMethodNoSideEffect(isolate, tmpl, "issuerName", IssuerName); + SetProtoMethodNoSideEffect(isolate, tmpl, "extensions", Extensions); + SetProtoMethodNoSideEffect(isolate, tmpl, "tbs", Tbs); + SetProtoMethodNoSideEffect(isolate, tmpl, "signature", Signature); SetProtoMethodNoSideEffect(isolate, tmpl, "publicKey", PublicKey); SetProtoMethodNoSideEffect(isolate, tmpl, "checkCA", CheckCA); SetProtoMethodNoSideEffect(isolate, tmpl, "checkHost", CheckHost); @@ -1448,6 +1830,12 @@ void X509Certificate::RegisterExternalReferences( registry->Register(SerialNumber); registry->Register(Pem); registry->Register(Der); + registry->Register(Version); + registry->Register(SubjectName); + registry->Register(IssuerName); + registry->Register(Extensions); + registry->Register(Tbs); + registry->Register(Signature); registry->Register(PublicKey); registry->Register(CheckCA); registry->Register(CheckHost); diff --git a/src/crypto/crypto_x509.h b/src/crypto/crypto_x509.h index e618edd8e5a..73f3799fed8 100644 --- a/src/crypto/crypto_x509.h +++ b/src/crypto/crypto_x509.h @@ -128,6 +128,9 @@ class X509Certificate final : public BaseObject { inline ncrypto::X509View view() const { return *cert_; } inline X509* get() { return cert_->get(); } + inline const X509CertificateSnapshot::DER& snapshot_der() const { + return snapshot_->at(snapshot_index_); + } v8::MaybeLocal toObject(Environment* env); static v8::MaybeLocal toObject(Environment* env, diff --git a/src/env_properties.h b/src/env_properties.h index 29939311a80..dae83758330 100644 --- a/src/env_properties.h +++ b/src/env_properties.h @@ -112,6 +112,7 @@ V(code_string, "code") \ V(config_string, "config") \ V(constants_string, "constants") \ + V(critical_string, "critical") \ V(cwd_string, "cwd") \ V(data_string, "data") \ V(database_string, "database") \ @@ -244,6 +245,7 @@ V(node_string, "node") \ V(object_string, "Object") \ V(ocsp_request_string, "OCSPRequest") \ + V(oid_string, "oid") \ V(ok_string, "ok") \ V(oncertcb_string, "oncertcb") \ V(onchange_string, "onchange") \ @@ -276,6 +278,7 @@ V(p256_string, "P-256") \ V(p384_string, "P-384") \ V(p521_string, "P-521") \ + V(parameters_string, "parameters") \ V(parse_error_string, "Parse Error") \ V(password_string, "password") \ V(path_string, "path") \ @@ -301,6 +304,8 @@ V(psk_string, "psk") \ V(public_exponent_string, "publicExponent") \ V(rate_string, "rate") \ + V(raw_string, "raw") \ + V(rdns_string, "rdns") \ V(read_host_object_string, "_readHostObject") \ V(readable_string, "readable") \ V(read_bigints_string, "readBigInts") \ diff --git a/test/cctest/test_node_crypto.cc b/test/cctest/test_node_crypto.cc index 15a063453b2..d01e13e534f 100644 --- a/test/cctest/test_node_crypto.cc +++ b/test/cctest/test_node_crypto.cc @@ -1022,6 +1022,14 @@ TEST(NodeCrypto, X509FormattingPreservesUnrelatedErrors) { const ncrypto::BIOPointer subject = cert.view().getSubject(); ASSERT_TRUE(subject); EXPECT_EQ(ERR_peek_error(), expected); + EXPECT_TRUE(cert.view().getVersion().has_value()); + EXPECT_EQ(ERR_peek_error(), expected); + EXPECT_TRUE(cert.view().inspectSubjectName().has_value()); + EXPECT_EQ(ERR_peek_error(), expected); + EXPECT_TRUE(cert.view().inspectIssuerName().has_value()); + EXPECT_EQ(ERR_peek_error(), expected); + EXPECT_TRUE(cert.view().inspectExtensions().has_value()); + EXPECT_EQ(ERR_peek_error(), expected); ERR_clear_error(); } diff --git a/test/parallel/test-crypto-x509-chain-snapshot.js b/test/parallel/test-crypto-x509-chain-snapshot.js index 433abd9fcca..7b091c84679 100644 --- a/test/parallel/test-crypto-x509-chain-snapshot.js +++ b/test/parallel/test-crypto-x509-chain-snapshot.js @@ -21,12 +21,46 @@ const issuer = new X509Certificate(fixtures.readKey('ca3-cert.pem')); function assertChain(actual) { assert(actual instanceof X509Certificate); assert.deepStrictEqual(actual.raw, leaf.raw); + assertInspection(actual, leaf); assert.strictEqual(actual.issuerCertificate, actual.issuerCertificate); assert(actual.issuerCertificate instanceof X509Certificate); assert.deepStrictEqual(actual.issuerCertificate.raw, issuer.raw); + assertInspection(actual.issuerCertificate, issuer); assert.strictEqual(actual.issuerCertificate.issuerCertificate, undefined); } +function assertInspection(actual, expected) { + assert.strictEqual(actual.version, expected.version); + + const subjectName = actual.subjectName; + const issuerName = actual.issuerName; + const extensions = actual.extensions; + const tbs = actual.tbs; + const signature = actual.signature; + + assert.deepStrictEqual(subjectName, expected.subjectName); + assert.deepStrictEqual(issuerName, expected.issuerName); + assert.deepStrictEqual(extensions, expected.extensions); + assert.deepStrictEqual(tbs, expected.tbs); + assert.deepStrictEqual(signature, expected.signature); + + subjectName.raw.fill(0); + issuerName.raw.fill(0); + for (const extension of extensions) extension.value.fill(0); + subjectName.rdns.length = 0; + issuerName.rdns.length = 0; + extensions.length = 0; + tbs.fill(0); + signature.value.fill(0); + signature.algorithm.parameters?.fill(0); + + assert.deepStrictEqual(actual.subjectName, expected.subjectName); + assert.deepStrictEqual(actual.issuerName, expected.issuerName); + assert.deepStrictEqual(actual.extensions, expected.extensions); + assert.deepStrictEqual(actual.tbs, expected.tbs); + assert.deepStrictEqual(actual.signature, expected.signature); +} + function legacyChainRaw(certificate) { const result = []; const seen = new Set(); diff --git a/test/parallel/test-crypto-x509-inspection.js b/test/parallel/test-crypto-x509-inspection.js new file mode 100644 index 00000000000..54ee7dae359 --- /dev/null +++ b/test/parallel/test-crypto-x509-inspection.js @@ -0,0 +1,281 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('assert'); +const { X509Certificate } = require('crypto'); +const { isBoringSSL } = require('../common/crypto'); +const fixtures = require('../common/fixtures'); + +function load(name) { + return new X509Certificate(fixtures.readKey(name)); +} + +function readDer(input, offset = 0) { + const start = offset; + const tag = input[offset++]; + let length = input[offset++]; + if ((length & 0x80) !== 0) { + const octets = length & 0x7f; + length = 0; + for (let i = 0; i < octets; i++) + length = (length * 256) + input[offset++]; + } + return { + tag, + start, + contentStart: offset, + end: offset + length, + }; +} + +function readChildren(input, parent) { + const children = []; + for (let offset = parent.contentStart; offset < parent.end;) { + const child = readDer(input, offset); + children.push(child); + offset = child.end; + } + return children; +} + +function encodeDer(tag, content) { + let length; + if (content.length < 128) { + length = Buffer.of(content.length); + } else { + const octets = []; + for (let value = content.length; value !== 0; value >>>= 8) + octets.unshift(value & 0xff); + length = Buffer.of(0x80 | octets.length, ...octets); + } + return Buffer.concat([Buffer.of(tag), length, content]); +} + +function rawElement(input, element) { + return input.subarray(element.start, element.end); +} + +function appendExtensions(raw, additions) { + const certificate = readDer(raw); + const certificateFields = readChildren(raw, certificate); + const tbs = certificateFields[0]; + const tbsFields = readChildren(raw, tbs); + const extensionIndex = tbsFields.findIndex(({ tag }) => tag === 0xa3); + assert.notStrictEqual(extensionIndex, -1); + + const wrapper = tbsFields[extensionIndex]; + const extensionSequence = readChildren(raw, wrapper)[0]; + const extensions = readChildren(raw, extensionSequence) + .map((element) => rawElement(raw, element)); + extensions.push(...additions); + + const newWrapper = encodeDer(0xa3, encodeDer( + 0x30, Buffer.concat(extensions))); + const newTbsFields = tbsFields.map((element, index) => + (index === extensionIndex ? newWrapper : rawElement(raw, element))); + const newTbs = encodeDer(0x30, Buffer.concat(newTbsFields)); + const newCertificateFields = certificateFields.map((element, index) => + (index === 0 ? newTbs : rawElement(raw, element))); + return encodeDer(0x30, Buffer.concat(newCertificateFields)); +} + +function replaceVersion(raw, value) { + const certificate = readDer(raw); + const certificateFields = readChildren(raw, certificate); + const tbs = certificateFields[0]; + const tbsFields = readChildren(raw, tbs); + assert.strictEqual(tbsFields[0].tag, 0xa0); + const version = encodeDer(0xa0, encodeDer(0x02, value)); + const newTbs = encodeDer(0x30, Buffer.concat(tbsFields.map( + (element, index) => (index === 0 ? version : rawElement(raw, element))))); + return encodeDer(0x30, Buffer.concat(certificateFields.map( + (element, index) => (index === 0 ? newTbs : rawElement(raw, element))))); +} + +function replaceSubject(raw, value) { + const certificate = readDer(raw); + const certificateFields = readChildren(raw, certificate); + const tbs = certificateFields[0]; + const tbsFields = readChildren(raw, tbs); + const fieldOffset = tbsFields[0].tag === 0xa0 ? 1 : 0; + const subjectIndex = fieldOffset + 4; + const newTbs = encodeDer(0x30, Buffer.concat(tbsFields.map( + (element, index) => + (index === subjectIndex ? value : rawElement(raw, element))))); + return encodeDer(0x30, Buffer.concat(certificateFields.map( + (element, index) => (index === 0 ? newTbs : rawElement(raw, element))))); +} + +const keyUsageExtension = Buffer.from( + '300b0603551d0f0404030205a0', 'hex'); +const unknownExtension = Buffer.from( + '300906032a030404020500', 'hex'); +const criticalUnknownExtension = Buffer.from( + '300c06032a03040101ff04020500', 'hex'); + +{ + const cert = load('agent1-cert.pem'); + const raw = cert.raw; + const certificate = readDer(raw); + const [tbs] = readChildren(raw, certificate); + const tbsFields = readChildren(raw, tbs); + const fieldOffset = tbsFields[0].tag === 0xa0 ? 1 : 0; + const issuer = tbsFields[fieldOffset + 2]; + const subject = tbsFields[fieldOffset + 4]; + + assert.strictEqual(cert.version, 3); + assert.strictEqual(cert.subjectName.rdns.at(-1)[0].oid, + '1.2.840.113549.1.9.1'); + assert.strictEqual(cert.subjectName.rdns.at(-1)[0].value, + 'ry@tinyclouds.org'); + assert.deepStrictEqual(cert.subjectName.raw, rawElement(raw, subject)); + assert.strictEqual(cert.issuerName.rdns.at(-2)[0].value, 'ca1'); + assert.deepStrictEqual(cert.issuerName.raw, rawElement(raw, issuer)); + + assert.deepStrictEqual(cert.extensions.map(({ oid, critical }) => ({ + oid, + critical, + })), [{ + oid: '1.3.6.1.5.5.7.1.1', + critical: false, + }]); + assert(cert.extensions[0].value.length > 0); + + assert.deepStrictEqual(cert.tbs, rawElement(raw, tbs)); + + assert.deepStrictEqual(cert.signature.algorithm, { + oid: '1.2.840.113549.1.1.11', + parameters: Buffer.from('0500', 'hex'), + }); + assert(cert.signature.value.length > 0); +} + +// Raw inspection preserves extension order, duplicates, criticality, and the +// exact bytes inside extnValue without interpreting the extension syntax. +{ + const source = load('agent1-cert.pem'); + const cert = new X509Certificate(appendExtensions(source.raw, [ + keyUsageExtension, + unknownExtension, + criticalUnknownExtension, + ])); + + assert.deepStrictEqual(cert.extensions.slice(-3), [ + { + oid: '2.5.29.15', + critical: false, + value: Buffer.from('030205a0', 'hex'), + }, + { + oid: '1.2.3.4', + critical: false, + value: Buffer.from('0500', 'hex'), + }, + { + oid: '1.2.3.4', + critical: true, + value: Buffer.from('0500', 'hex'), + }, + ]); +} + +// An empty Name is valid, but an RDN is a nonempty SET OF attributes. OpenSSL +// does not expose empty RDNs through X509_NAME entries, so inspection must not +// silently collapse this malformed Name into a valid empty one. +{ + const source = load('agent1-cert.pem'); + const emptyRdnName = encodeDer(0x30, encodeDer(0x31, Buffer.alloc(0))); + const malformed = replaceSubject(source.raw, emptyRdnName); + let cert; + try { + cert = new X509Certificate(malformed); + } catch (err) { + if (!isBoringSSL || err.code !== 'ERR_OSSL_PEM_NO_START_LINE') { + throw err; + } + } + if (cert !== undefined) { + assert.throws(() => cert.subjectName, { + code: 'ERR_CRYPTO_INVALID_X509_CERTIFICATE', + }); + } +} + +// Reject unsupported versions at whichever native parsing layer observes them +// first. Backends that accept the encoding must reject it before converting +// OpenSSL's long result to the public one-based version number. +{ + const source = load('agent1-cert.pem'); + let cert; + try { + cert = new X509Certificate(replaceVersion( + source.raw, Buffer.from('7fffffffffffffff', 'hex'))); + } catch (err) { + assert.strictEqual(err.code, isBoringSSL ? + 'ERR_OSSL_PEM_NO_START_LINE' : 'ERR_OSSL_X509_INVALID_VERSION'); + } + if (cert !== undefined) { + assert.throws(() => cert.version, { + code: 'ERR_CRYPTO_INVALID_X509_CERTIFICATE', + }); + } +} + +// Inspection uses the immutable native snapshot, not the mutable Buffer cached +// by the legacy raw getter. +{ + const cert = load('agent1-cert.pem'); + cert.raw.fill(0); + assert.strictEqual(cert.version, 3); + assert.strictEqual(cert.subjectName.rdns.at(-1)[0].value, + 'ry@tinyclouds.org'); +} + +// New structured getters return fresh defensive values. Existing legacy +// getters retain their current identity behavior in this backportable change. +{ + const cert = load('leaf-from-intermediate-cert.pem'); + const subjectName = cert.subjectName; + const subjectRaw = subjectName.raw; + const extensions = cert.extensions; + const tbs = cert.tbs; + const signature = cert.signature; + const parameters = signature.algorithm.parameters; + + subjectName.rdns.length = 0; + subjectRaw.fill(0); + extensions.length = 0; + tbs.fill(0); + signature.value.fill(0); + parameters.fill(0); + + assert(cert.subjectName.rdns.length > 0); + assert.notDeepStrictEqual(cert.subjectName.raw, subjectRaw); + assert(cert.extensions.length > 0); + assert.notStrictEqual(cert.tbs[0], 0); + assert.notStrictEqual(cert.signature.value[0], 0); + assert.notStrictEqual(cert.signature.algorithm.parameters[0], 0); + assert.strictEqual(cert.raw, cert.raw); +} + +for (const name of [ + 'version', + 'subjectName', + 'issuerName', + 'extensions', + 'tbs', + 'signature', +]) { + const descriptor = Object.getOwnPropertyDescriptor( + X509Certificate.prototype, name); + assert.strictEqual(typeof descriptor.get, 'function'); + assert.strictEqual(descriptor.set, undefined); + assert.strictEqual(descriptor.enumerable, false); + assert.strictEqual(descriptor.configurable, true); + assert.throws(() => descriptor.get.call({}), { + code: 'ERR_INVALID_THIS', + }); +} diff --git a/typings/internalBinding/crypto.d.ts b/typings/internalBinding/crypto.d.ts index f136f76322f..0e57e71e17a 100644 --- a/typings/internalBinding/crypto.d.ts +++ b/typings/internalBinding/crypto.d.ts @@ -726,6 +726,32 @@ declare namespace InternalCryptoBinding { getIssuer(): Buffer | null; } + interface X509NameAttribute { + oid: string; + value?: string; + } + + interface X509Name { + raw: Buffer; + rdns: X509NameAttribute[][]; + } + + interface X509RawExtension { + oid: string; + critical: boolean; + value: Buffer; + } + + interface X509AlgorithmIdentifier { + oid: string; + parameters?: Buffer; + } + + interface X509Signature { + algorithm: X509AlgorithmIdentifier; + value: Buffer; + } + interface X509CertificateHandle { subject(): string; subjectAltName(): string | undefined; @@ -743,6 +769,12 @@ declare namespace InternalCryptoBinding { serialNumber(): string; signatureAlgorithm(): string | undefined; signatureAlgorithmOid(): string | undefined; + version(): number | undefined; + subjectName(): X509Name | undefined; + issuerName(): X509Name | undefined; + extensions(): X509RawExtension[] | undefined; + tbs(): Buffer | undefined; + signature(): X509Signature | undefined; raw(): Buffer; publicKey(): KeyObjectHandle; pem(): string; From a2605a07b631760a06ca0dbd6d7a2a159b8f3d24 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 4 Nov 2026 10:29:22 +0100 Subject: [PATCH 265/331] crypto: skip DH checks for recognized groups Explicit DH parameters are recognized as named groups during OpenSSL provider import, but DHPointer::check() only skips primality checks for groups constructed by name. This makes createDiffieHellman() block for seconds on standard MODP groups. Query the imported key's group name to restore the legacy DH_check() shortcut without changing key generation. Add a deterministic regression test with randomness disabled and cover explicit and padded parameters through the JavaScript API. Fixes: https://github.com/nodejs/node/issues/67067 Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/67071 Backport-PR-URL: https://github.com/nodejs/node/pull/67442 Reviewed-By: Antoine du Hamel --- deps/ncrypto/ncrypto.cc | 9 +++ test/cctest/test_node_crypto.cc | 50 ++++++++++++++++ test/parallel/test-crypto-dh-known-groups.js | 61 ++++++++++++++++++++ 3 files changed, 120 insertions(+) create mode 100644 test/parallel/test-crypto-dh-known-groups.js diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index 33c3423495a..2ca15e13b1a 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -2496,6 +2496,15 @@ DHPointer::CheckResult DHPointer::check() { // through the provider instead of preserving the historical verifyError. if (group_name_ != nullptr) return CheckResult::NONE; + // Like DH_check(), skip primality checks for groups OpenSSL recognizes from + // explicitly supplied parameters. + size_t group_name_len = 0; + if (dh_ && + EVP_PKEY_get_group_name(dh_.get(), nullptr, 0, &group_name_len) == 1 && + group_name_len > 0) { + return CheckResult::NONE; + } + DeleteFnPtr p; DeleteFnPtr g; DeleteFnPtr q; diff --git a/test/cctest/test_node_crypto.cc b/test/cctest/test_node_crypto.cc index d01e13e534f..27ee5fe3b51 100644 --- a/test/cctest/test_node_crypto.cc +++ b/test/cctest/test_node_crypto.cc @@ -22,6 +22,7 @@ #include #include #include +#include #endif using ncrypto::Ec; @@ -120,6 +121,55 @@ TEST(NodeCrypto, KeyAlgorithmNames) { } #if NCRYPTO_USE_OPENSSL3_PROVIDER +TEST(NodeCrypto, DhNamedGroupCheckDoesNotRequireRandomness) { + ncrypto::ClearErrorOnReturn clear_errors; + ncrypto::DeleteFnPtr libctx( + OSSL_LIB_CTX_new()); + ASSERT_TRUE(libctx); + ASSERT_EQ( + RAND_set_DRBG_type( + libctx.get(), "node-test-unavailable-rng", nullptr, nullptr, nullptr), + 1); + OSSL_LIB_CTX* previous_libctx = OSSL_LIB_CTX_set0_default(libctx.get()); + auto restore_libctx = node::OnScopeLeave( + [previous_libctx] { OSSL_LIB_CTX_set0_default(previous_libctx); }); + + // Primality checks need randomness. Known groups must skip those checks. + unsigned char random_byte; + ASSERT_NE(RAND_bytes_ex(libctx.get(), &random_byte, 1, 0), 1); + ERR_clear_error(); + + using DH = ncrypto::DHPointer; + for (const char* name : + {"modp5", "modp14", "modp15", "modp16", "modp17", "modp18"}) { + auto prime = DH::FindGroup(name); + auto generator = DH::GetStandardGenerator(); + ASSERT_TRUE(prime); + ASSERT_TRUE(generator); + auto dh = DH::New(std::move(prime), std::move(generator)); + ASSERT_TRUE(dh); + EXPECT_EQ(dh.check(), DH::CheckResult::NONE) << name; + } + + auto prime = DH::FindGroup("modp14"); + auto generator = DH::GetStandardGenerator(); + ASSERT_TRUE(prime); + ASSERT_TRUE(generator); + ASSERT_EQ(BN_add_word(prime.get(), 1), 1); + auto composite = DH::New(std::move(prime), std::move(generator)); + ASSERT_TRUE(composite); + EXPECT_EQ(composite.check(), DH::CheckResult::P_NOT_PRIME); + + prime = DH::FindGroup("modp14"); + generator = DH::GetStandardGenerator(); + ASSERT_TRUE(prime); + ASSERT_TRUE(generator); + ASSERT_EQ(BN_add_word(generator.get(), 1), 1); + auto other_generator = DH::New(std::move(prime), std::move(generator)); + ASSERT_TRUE(other_generator); + EXPECT_EQ(other_generator.check(), DH::CheckResult::CHECK_FAILED); +} + TEST(NodeCrypto, ProviderPkcs1PublicKeyImport) { ncrypto::ClearErrorOnReturn clear_errors; auto ctx = EVPKeyCtxPointer::NewFromAlgorithm(KeyAlgorithm::RSA); diff --git a/test/parallel/test-crypto-dh-known-groups.js b/test/parallel/test-crypto-dh-known-groups.js new file mode 100644 index 00000000000..0ff0ba957a5 --- /dev/null +++ b/test/parallel/test-crypto-dh-known-groups.js @@ -0,0 +1,61 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const crypto = require('node:crypto'); +const { hasFIPS, isBoringSSL } = require('../common/crypto'); + +if (isBoringSSL) + common.skip('OpenSSL named-group validation'); + +const groups = ['modp14', 'modp15', 'modp16', 'modp17', 'modp18']; +if (!hasFIPS(3)) + groups.unshift('modp5'); + +const privateKey = Buffer.from('01020304', 'hex'); +const generator = Buffer.from([2]); + +for (const name of groups) { + const peer = crypto.getDiffieHellman(name); + const prime = peer.getPrime(); + const peerPublicKey = peer.generateKeys(); + + // SSH encodes positive integers with a leading zero when necessary. + for (const [p, g] of [ + [prime, 2], + [Buffer.concat([Buffer.from([0]), prime]), Buffer.from([0, 2])], + ]) { + const dh = crypto.createDiffieHellman(p, g); + assert.strictEqual(dh.verifyError, 0); + assert.deepStrictEqual(dh.getPrime(), prime); + assert.deepStrictEqual(dh.getGenerator(), generator); + + dh.setPrivateKey(privateKey); + const publicKey = dh.generateKeys(); + assert.deepStrictEqual(dh.generateKeys(), publicKey); + assert.deepStrictEqual(dh.getPrivateKey(), privateKey); + assert.deepStrictEqual(dh.computeSecret(peerPublicKey), + peer.computeSecret(publicKey)); + } +} + +// A known modulus alone must not bypass validation of different parameters. +{ + const prime = crypto.getDiffieHellman('modp14').getPrime(); + const notPrime = Buffer.from(prime); + notPrime[notPrime.length - 1] &= 0xfe; + assert.strictEqual( + crypto.createDiffieHellman(notPrime, 2).verifyError & + crypto.constants.DH_CHECK_P_NOT_PRIME, + crypto.constants.DH_CHECK_P_NOT_PRIME); + + const notGenerator = Buffer.from(prime); + notGenerator[notGenerator.length - 1]--; + assert.strictEqual( + crypto.createDiffieHellman(prime, notGenerator).verifyError & + crypto.constants.DH_NOT_SUITABLE_GENERATOR, + crypto.constants.DH_NOT_SUITABLE_GENERATOR); +} From d5f2e3da8e0ceca39b82d7a51bd8aaaa2906e996 Mon Sep 17 00:00:00 2001 From: Yagiz Nizipli Date: Thu, 29 Oct 2026 12:12:30 -0400 Subject: [PATCH 266/331] crypto: cache digests for synchronous operations createHmac(), createSign(), createVerify() and the synchronous one-shot sign, verify, HKDF and PBKDF2 functions looked up their digest with Digest::FromName(). That returns OpenSSL's legacy EVP_MD, so every EVP_DigestInit_ex() and HMAC init had to fetch the provider implementation again through the method store. Look these digests up through the per-Environment cache that createHash() and crypto.hash() already use. Jobs on the thread pool keep using Digest::FromName(): with the cache, Web Crypto digest and HMAC throughput went down, because workers that finish sooner have to be woken up for each new job more often. Signed-off-by: Yagiz Nizipli Assisted-by: Grok PR-URL: https://github.com/nodejs/node/pull/67109 Backport-PR-URL: https://github.com/nodejs/node/pull/67442 Reviewed-By: Antoine du Hamel --- deps/ncrypto/ncrypto.cc | 10 ++++++++++ deps/ncrypto/ncrypto.h | 3 +++ src/crypto/crypto_hash.cc | 19 +++++++++++++++++++ src/crypto/crypto_hash.h | 12 ++++++++++++ src/crypto/crypto_hkdf.cc | 4 ++-- src/crypto/crypto_hmac.cc | 3 ++- src/crypto/crypto_pbkdf2.cc | 4 ++-- src/crypto/crypto_sig.cc | 5 +++-- .../parallel/test-crypto-digest-cache-fips.js | 4 ++-- 9 files changed, 55 insertions(+), 9 deletions(-) diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index 2ca15e13b1a..f9a6e912be9 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -8912,6 +8912,16 @@ const Digest Digest::Fetch(const char* name) { return Digest(); } +const Digest Digest::Ref(const EVP_MD* md) { +#if NCRYPTO_USE_OPENSSL3_PROVIDER + if (md != nullptr && EVP_MD_get0_provider(md) != nullptr) { + if (EVP_MD_up_ref(const_cast(md)) != 1) return Digest(); + return Digest(DeleteFnPtr(const_cast(md))); + } +#endif + return Digest(md); +} + // ============================================================================ // KEM Implementation #if OPENSSL_WITH_KEM diff --git a/deps/ncrypto/ncrypto.h b/deps/ncrypto/ncrypto.h index d5b7ec78f55..1658416c983 100644 --- a/deps/ncrypto/ncrypto.h +++ b/deps/ncrypto/ncrypto.h @@ -390,6 +390,9 @@ class Digest final { static const Digest FromName(const char* name); static const Digest Fetch(const char* name); + // Returns a Digest that holds its own reference to md if md was fetched from + // a provider. + static const Digest Ref(const EVP_MD* md); private: const EVP_MD* md_ = nullptr; diff --git a/src/crypto/crypto_hash.cc b/src/crypto/crypto_hash.cc index b221b68a4a4..c3c64e51519 100644 --- a/src/crypto/crypto_hash.cc +++ b/src/crypto/crypto_hash.cc @@ -357,6 +357,25 @@ const EVP_MD* GetDigestImplementation( #endif } +const ncrypto::Digest GetDigest(Environment* env, const char* name) { +#if NCRYPTO_USE_OPENSSL3_PROVIDER + MaybeCachedMD result = FetchAndMaybeCacheMD(env, name); + if (result.cached_md != nullptr) { + return ncrypto::Digest::Ref(result.cached_md); + } + return result.digest; +#else + return ncrypto::Digest::FromName(name); +#endif +} + +const ncrypto::Digest GetDigestForJob(Environment* env, + CryptoJobMode mode, + const char* name) { + if (mode == kCryptoJobSync) return GetDigest(env, name); + return ncrypto::Digest::FromName(name); +} + void MarkInvalidXofLength() { #if NCRYPTO_USE_OPENSSL3_PROVIDER ERR_raise(ERR_LIB_EVP, EVP_R_NOT_XOF_OR_INVALID_LENGTH); diff --git a/src/crypto/crypto_hash.h b/src/crypto/crypto_hash.h index 1cdfa2054e4..7aaac944786 100644 --- a/src/crypto/crypto_hash.h +++ b/src/crypto/crypto_hash.h @@ -12,6 +12,18 @@ namespace node { namespace crypto { +// Like ncrypto::Digest::FromName(), but caches provider implementations per +// Environment so that later lookups do not have to fetch them again. +const ncrypto::Digest GetDigest(Environment* env, const char* name); + +// GetDigest() for synchronous jobs. Jobs on the thread pool keep using +// ncrypto::Digest::FromName(): there, the cache lowered Web Crypto digest and +// HMAC throughput, because workers that finish sooner have to be woken up for +// each new job more often. +const ncrypto::Digest GetDigestForJob(Environment* env, + CryptoJobMode mode, + const char* name); + class Hash final : public BaseObject { public: static void Initialize(Environment* env, v8::Local target); diff --git a/src/crypto/crypto_hkdf.cc b/src/crypto/crypto_hkdf.cc index 64e0bbb0d77..8e9809f280b 100644 --- a/src/crypto/crypto_hkdf.cc +++ b/src/crypto/crypto_hkdf.cc @@ -1,6 +1,7 @@ #include "crypto/crypto_hkdf.h" #include "async_wrap-inl.h" #include "base_object-inl.h" +#include "crypto/crypto_hash.h" #include "crypto/crypto_keys.h" #include "env-inl.h" #include "memory_tracker-inl.h" @@ -9,7 +10,6 @@ namespace node { -using ncrypto::Digest; using v8::FunctionCallbackInfo; using v8::JustVoid; using v8::Maybe; @@ -54,7 +54,7 @@ Maybe HKDFTraits::AdditionalConfig( CHECK(args[offset + 4]->IsUint32()); // Length Utf8Value hash(env->isolate(), args[offset]); - params->digest = Digest::FromName(*hash); + params->digest = GetDigestForJob(env, mode, *hash); if (!params->digest) [[unlikely]] { THROW_ERR_CRYPTO_INVALID_DIGEST(env, "Invalid digest: %s", hash); return Nothing(); diff --git a/src/crypto/crypto_hmac.cc b/src/crypto/crypto_hmac.cc index 541dfe7e781..36f07c7d98d 100644 --- a/src/crypto/crypto_hmac.cc +++ b/src/crypto/crypto_hmac.cc @@ -1,6 +1,7 @@ #include "crypto/crypto_hmac.h" #include "async_wrap-inl.h" #include "base_object-inl.h" +#include "crypto/crypto_hash.h" #include "crypto/crypto_keys.h" #include "crypto/crypto_sig.h" #include "crypto/crypto_util.h" @@ -69,7 +70,7 @@ void Hmac::New(const FunctionCallbackInfo& args) { void Hmac::HmacInit(const char* hash_type, const char* key, int key_len) { HandleScope scope(env()->isolate()); - Digest md = Digest::FromName(hash_type); + Digest md = GetDigest(env(), hash_type); if (!md) [[unlikely]] { return THROW_ERR_CRYPTO_INVALID_DIGEST( env(), "Invalid digest: %s", hash_type); diff --git a/src/crypto/crypto_pbkdf2.cc b/src/crypto/crypto_pbkdf2.cc index ec0dfed171f..29aca157cdf 100644 --- a/src/crypto/crypto_pbkdf2.cc +++ b/src/crypto/crypto_pbkdf2.cc @@ -1,6 +1,7 @@ #include "crypto/crypto_pbkdf2.h" #include "async_wrap-inl.h" #include "base_object-inl.h" +#include "crypto/crypto_hash.h" #include "crypto/crypto_keys.h" #include "crypto/crypto_util.h" #include "env-inl.h" @@ -11,7 +12,6 @@ namespace node { -using ncrypto::Digest; using v8::FunctionCallbackInfo; using v8::Int32; using v8::JustVoid; @@ -104,7 +104,7 @@ Maybe PBKDF2Traits::AdditionalConfig( } Utf8Value name(args.GetIsolate(), args[offset + 4]); - params->digest = Digest::FromName(*name); + params->digest = GetDigestForJob(env, mode, *name); if (!params->digest) [[unlikely]] { THROW_ERR_CRYPTO_INVALID_DIGEST(env, "Invalid digest: %s", name); return Nothing(); diff --git a/src/crypto/crypto_sig.cc b/src/crypto/crypto_sig.cc index 400dce70ad2..53bd4827351 100644 --- a/src/crypto/crypto_sig.cc +++ b/src/crypto/crypto_sig.cc @@ -2,6 +2,7 @@ #include "async_wrap-inl.h" #include "base_object-inl.h" #include "crypto/crypto_ec.h" +#include "crypto/crypto_hash.h" #include "crypto/crypto_keys.h" #include "crypto/crypto_util.h" #include "env-inl.h" @@ -315,7 +316,7 @@ bool VerifyPrehashed(const EVPKeyPointer& key, SignBase::Error SignBase::Init(const char* digest) { CHECK_NULL(mdctx_); - auto md = Digest::FromName(digest); + auto md = GetDigest(env(), digest); if (!md) [[unlikely]] return Error::UnknownDigest; @@ -666,7 +667,7 @@ Maybe SignTraits::AdditionalConfig( if (args[offset + 7]->IsString()) { Utf8Value digest(env->isolate(), args[offset + 7]); - params->digest = Digest::FromName(*digest); + params->digest = GetDigestForJob(env, mode, *digest); if (!params->digest) [[unlikely]] { THROW_ERR_CRYPTO_INVALID_DIGEST(env, "Invalid digest: %s", digest); return Nothing(); diff --git a/test/parallel/test-crypto-digest-cache-fips.js b/test/parallel/test-crypto-digest-cache-fips.js index aa316ea15a9..c94772f68f3 100644 --- a/test/parallel/test-crypto-digest-cache-fips.js +++ b/test/parallel/test-crypto-digest-cache-fips.js @@ -4,8 +4,8 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); -const { isBoringSSL } = require('../common/crypto'); -if (isBoringSSL) +const { hasOpenSSL, isBoringSSL } = require('../common/crypto'); +if (isBoringSSL || !hasOpenSSL(3)) common.skip('this test requires OpenSSL provider support'); const { isMainThread } = require('worker_threads'); From e24a2c50694545cbf2660d2516e45e516ff36dc2 Mon Sep 17 00:00:00 2001 From: Yagiz Nizipli Date: Thu, 29 Oct 2026 11:21:04 -0400 Subject: [PATCH 267/331] crypto: reuse HMAC contexts in createHmac() Every HMAC context was created with EVP_MAC_fetch() and keyed with the digest passed by name, so the provider fetched the digest again on each init. Both lookups go through OpenSSL's method store. Keep an HMAC context without a key for each digest in the per-Environment digest cache, and duplicate it in createHmac(). A duplicated context already has its digest, so keying it with the same digest no longer fetches anything. Signed-off-by: Yagiz Nizipli Assisted-by: Grok PR-URL: https://github.com/nodejs/node/pull/67109 Backport-PR-URL: https://github.com/nodejs/node/pull/67442 Reviewed-By: Antoine du Hamel --- deps/ncrypto/ncrypto.cc | 59 +++++++++++++++++++++++++++++++++++++++ deps/ncrypto/ncrypto.h | 14 ++++++++++ src/crypto/crypto_hash.cc | 12 ++++++++ src/crypto/crypto_hash.h | 6 ++++ src/crypto/crypto_hmac.cc | 2 +- 5 files changed, 92 insertions(+), 1 deletion(-) diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index f9a6e912be9..6d9c42e0581 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -5480,16 +5480,39 @@ DigestCache::Result DigestCache::insert(const char* name, #endif } +DigestCache::~DigestCache() = default; + void DigestCache::reset(uint64_t generation) { #if NCRYPTO_USE_OPENSSL3_PROVIDER if (generation_ == generation) return; aliases_.clear(); + hmac_templates_.clear(); digests_.clear(); first_id_ = next_id_; #endif generation_ = generation; } +#if NCRYPTO_USE_OPENSSL3_PROVIDER +const HMACCtxPointer* DigestCache::getHmacTemplate(const EVP_MD* digest, + uint64_t generation) { + if (generation_ != generation || digest == nullptr) return nullptr; + for (size_t index = 0; index < digests_.size(); index++) { + if (digests_[index].get() != digest) continue; + if (hmac_templates_.size() <= index) { + hmac_templates_.resize(digests_.size()); + } + if (!hmac_templates_[index]) { + auto ctx = HMACCtxPointer::New(Digest::Ref(digest)); + if (!ctx) return nullptr; + hmac_templates_[index] = std::make_unique(std::move(ctx)); + } + return hmac_templates_[index].get(); + } + return nullptr; +} +#endif + const DigestCache::AliasMap& DigestCache::aliases() const { #if NCRYPTO_USE_OPENSSL3_PROVIDER return aliases_; @@ -8556,7 +8579,9 @@ HMACCtxPointer::HMACCtxPointer(EVPMacPointer&& mac, EVPMacCtxPointer&& ctx) HMACCtxPointer::HMACCtxPointer(HMACCtxPointer&& other) noexcept : mac_(std::move(other.mac_)), ctx_(std::move(other.ctx_)), + md_(other.md_), md_size_(other.md_size_) { + other.md_ = nullptr; other.md_size_ = 0; } @@ -8564,7 +8589,9 @@ HMACCtxPointer& HMACCtxPointer::operator=(HMACCtxPointer&& other) noexcept { if (this == &other) return *this; mac_ = std::move(other.mac_); ctx_ = std::move(other.ctx_); + md_ = other.md_; md_size_ = other.md_size_; + other.md_ = nullptr; other.md_size_ = 0; return *this; } @@ -8576,11 +8603,13 @@ HMACCtxPointer::~HMACCtxPointer() { void HMACCtxPointer::reset() { ctx_.reset(); mac_.reset(); + md_ = nullptr; md_size_ = 0; } bool HMACCtxPointer::init(const Buffer& buf, const Digest& md) { if (!ctx_ || !md) return false; + if (md.get() == md_) return ctx_.init(buf); const char* md_name = EVP_MD_get0_name(md); if (md_name == nullptr) return false; @@ -8592,6 +8621,7 @@ bool HMACCtxPointer::init(const Buffer& buf, const Digest& md) { }; if (!ctx_.init(buf, params)) return false; + md_ = md.get(); md_size_ = md.size(); return true; } @@ -8623,6 +8653,16 @@ bool HMACCtxPointer::digestInto(Buffer* buf) { return true; } +HMACCtxPointer HMACCtxPointer::clone() const { + if (!ctx_) return {}; + EVPMacCtxPointer ctx(EVP_MAC_CTX_dup(ctx_.get())); + if (!ctx) return {}; + HMACCtxPointer result(EVPMacPointer(), std::move(ctx)); + result.md_ = md_; + result.md_size_ = md_size_; + return result; +} + HMACCtxPointer HMACCtxPointer::New() { auto mac = EVPMacPointer::Fetch(OSSL_MAC_NAME_HMAC); if (!mac) return {}; @@ -8632,6 +8672,25 @@ HMACCtxPointer HMACCtxPointer::New() { return HMACCtxPointer(std::move(mac), std::move(ctx)); } + +HMACCtxPointer HMACCtxPointer::New(const Digest& md) { + if (!md) return {}; + const char* md_name = EVP_MD_get0_name(md); + if (md_name == nullptr) return {}; + + auto result = New(); + if (!result) return {}; + + OSSL_PARAM params[] = { + OSSL_PARAM_construct_utf8_string( + OSSL_MAC_PARAM_DIGEST, const_cast(md_name), 0), + OSSL_PARAM_construct_end(), + }; + if (EVP_MAC_CTX_set_params(result.ctx_.get(), params) != 1) return {}; + result.md_ = md.get(); + result.md_size_ = md.size(); + return result; +} #endif // OPENSSL_WITH_EVP_MAC DataPointer hashDigest(const Buffer& buf, diff --git a/deps/ncrypto/ncrypto.h b/deps/ncrypto/ncrypto.h index 1658416c983..a2af519d8b2 100644 --- a/deps/ncrypto/ncrypto.h +++ b/deps/ncrypto/ncrypto.h @@ -329,6 +329,7 @@ class DataPointer; class DHPointer; class ECKeyPointer; class EVPKeyPointer; +class HMACCtxPointer; class KeyAlgorithm; class MacCache; class EVPMacCtxPointer; @@ -425,6 +426,7 @@ class DigestCache final { CaseInsensitiveNameEqual>; DigestCache() = default; + ~DigestCache(); NCRYPTO_DISALLOW_COPY_AND_MOVE(DigestCache) Result lookup(const char* name, uint64_t generation) const; @@ -445,6 +447,12 @@ class DigestCache final { Result insert(const char* name, const EVP_MD* digest, uint64_t generation); void reset(uint64_t generation); const AliasMap& aliases() const; +#if NCRYPTO_USE_OPENSSL3_PROVIDER + // Returns an HMAC context for the cached digest that has no key yet. + // Duplicating it avoids fetching HMAC and the digest for every context. + const HMACCtxPointer* getHmacTemplate(const EVP_MD* digest, + uint64_t generation); +#endif private: uint64_t generation_ = 0; @@ -456,6 +464,7 @@ class DigestCache final { uint32_t first_id_ = 0; uint32_t next_id_ = 0; std::vector digests_; + std::vector> hmac_templates_; AliasMap aliases_; #endif }; @@ -2139,14 +2148,19 @@ class HMACCtxPointer final { bool update(const Buffer& buf); DataPointer digest(); bool digestInto(Buffer* buf); + HMACCtxPointer clone() const; static HMACCtxPointer New(); + // Creates a context that already uses md, so that init() does not have to + // fetch md again when it is called with the same digest. + static HMACCtxPointer New(const Digest& md); private: HMACCtxPointer(EVPMacPointer&& mac, EVPMacCtxPointer&& ctx); EVPMacPointer mac_; EVPMacCtxPointer ctx_; + const EVP_MD* md_ = nullptr; size_t md_size_ = 0; }; #endif // OPENSSL_WITH_EVP_MAC diff --git a/src/crypto/crypto_hash.cc b/src/crypto/crypto_hash.cc index c3c64e51519..7b26925c897 100644 --- a/src/crypto/crypto_hash.cc +++ b/src/crypto/crypto_hash.cc @@ -376,6 +376,18 @@ const ncrypto::Digest GetDigestForJob(Environment* env, return ncrypto::Digest::FromName(name); } +ncrypto::HMACCtxPointer NewHmacContext(Environment* env, + const ncrypto::Digest& md) { +#if NCRYPTO_USE_OPENSSL3_PROVIDER + SynchronizeHashCache(env); + if (const auto* hmac_template = env->provider_digest_cache->getHmacTemplate( + md, env->hash_cache_generation)) { + if (auto ctx = hmac_template->clone()) return ctx; + } +#endif + return ncrypto::HMACCtxPointer::New(); +} + void MarkInvalidXofLength() { #if NCRYPTO_USE_OPENSSL3_PROVIDER ERR_raise(ERR_LIB_EVP, EVP_R_NOT_XOF_OR_INVALID_LENGTH); diff --git a/src/crypto/crypto_hash.h b/src/crypto/crypto_hash.h index 7aaac944786..322ff83da69 100644 --- a/src/crypto/crypto_hash.h +++ b/src/crypto/crypto_hash.h @@ -24,6 +24,12 @@ const ncrypto::Digest GetDigestForJob(Environment* env, CryptoJobMode mode, const char* name); +// Returns an HMAC context to be keyed with md. Contexts for digests from +// GetDigest() are duplicated from a cached template, so keying them does not +// fetch HMAC or md again. +ncrypto::HMACCtxPointer NewHmacContext(Environment* env, + const ncrypto::Digest& md); + class Hash final : public BaseObject { public: static void Initialize(Environment* env, v8::Local target); diff --git a/src/crypto/crypto_hmac.cc b/src/crypto/crypto_hmac.cc index 36f07c7d98d..8345b68bc90 100644 --- a/src/crypto/crypto_hmac.cc +++ b/src/crypto/crypto_hmac.cc @@ -79,7 +79,7 @@ void Hmac::HmacInit(const char* hash_type, const char* key, int key_len) { key = ""; } - ctx_ = HMACCtxPointer::New(); + ctx_ = NewHmacContext(env(), md); ncrypto::Buffer key_buf{ .data = key, .len = static_cast(key_len), From 9216dbe5c1b6ace356565d7af5a2ae03bd8a57bf Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Fri, 6 Nov 2026 08:28:07 +0100 Subject: [PATCH 268/331] crypto: prevent stale OpenSSL errors Clear errors raised by key comparison, SPKAC parsing, and JWK import. Ensure TLS and private-key parsing only inspect errors from their own OpenSSL calls. Assisted-by: Codex Signed-off-by: Matteo Collina PR-URL: https://github.com/nodejs/node/pull/67225 Backport-PR-URL: https://github.com/nodejs/node/pull/67442 Reviewed-By: Antoine du Hamel --- deps/ncrypto/ncrypto.cc | 4 + src/crypto/crypto_keys.cc | 3 + src/crypto/crypto_tls.cc | 26 +++++ test/cctest/test_node_crypto.cc | 54 +++++++++++ test/cctest/test_node_crypto_env.cc | 50 ++++++++++ test/parallel/test-crypto-encap-decap.js | 2 +- .../test-crypto-openssl-error-queue.js | 46 +++++++++ .../test-crypto-pqc-key-objects-ml-dsa.js | 2 +- .../test-crypto-pqc-key-objects-ml-kem.js | 4 +- .../test-crypto-pqc-key-objects-slh-dsa.js | 2 +- test/parallel/test-tls-openssl-error-queue.js | 95 +++++++++++++++++++ 11 files changed, 283 insertions(+), 5 deletions(-) create mode 100644 test/parallel/test-crypto-openssl-error-queue.js create mode 100644 test/parallel/test-tls-openssl-error-queue.js diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index 6d9c42e0581..9edb016d236 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -945,6 +945,7 @@ int64_t PortableTimeGM(struct tm* t) { // SPKAC bool VerifySpkac(const char* input, size_t length) { + ClearErrorOnReturn clear_error_on_return; #ifdef OPENSSL_IS_BORINGSSL // OpenSSL uses EVP_DecodeBlock, which explicitly removes trailing characters, // while BoringSSL uses EVP_DecodedLength and EVP_DecodeBase64, which do not. @@ -963,6 +964,7 @@ bool VerifySpkac(const char* input, size_t length) { } BIOPointer ExportPublicKey(const char* input, size_t length) { + ClearErrorOnReturn clear_error_on_return; BIOPointer bio(BIO_new(BIO_s_mem())); if (!bio) return {}; @@ -984,6 +986,7 @@ BIOPointer ExportPublicKey(const char* input, size_t length) { } Buffer ExportChallenge(const char* input, size_t length) { + ClearErrorOnReturn clear_error_on_return; #ifdef OPENSSL_IS_BORINGSSL // OpenSSL uses EVP_DecodeBlock, which explicitly removes trailing characters, // while BoringSSL uses EVP_DecodedLength and EVP_DecodeBase64, which do not. @@ -4518,6 +4521,7 @@ bool ECKeyHasMissingOid(const EVPKeyPointer& key) { EVPKeyPointer::ParseKeyResult EVPKeyPointer::TryParsePrivateKey( const PrivateKeyEncodingConfig& config, const Buffer& buffer) { + ERR_clear_error(); static constexpr auto keyOrError = [](EVPKeyPointer pkey, bool had_passphrase = false) { if (unsigned long err = ERR_peek_error()) { // NOLINT(runtime/int) diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc index 64bbd6da072..66baf0809af 100644 --- a/src/crypto/crypto_keys.cc +++ b/src/crypto/crypto_keys.cc @@ -21,6 +21,7 @@ namespace node { using ncrypto::BignumPointer; using ncrypto::BIOPointer; +using ncrypto::ClearErrorOnReturn; using ncrypto::ECKeyPointer; using ncrypto::ECPointPointer; using ncrypto::EVPKeyCtxPointer; @@ -681,6 +682,7 @@ static KeyObjectData ImportRawKey(Environment* env, // Shared helper for importing a JWK asymmetric key. Extracts kty from the // JWK object and dispatches to the appropriate importer. static KeyObjectData ImportJWKFromArgs(Environment* env, Local jwk) { + ClearErrorOnReturn clear_error_on_return; Local kty; if (!jwk->Get(env->context(), env->jwk_kty_string()).ToLocal(&kty) || !kty->IsString()) { @@ -1312,6 +1314,7 @@ void KeyObjectHandle::Equals(const FunctionCallbackInfo& args) { case kKeyTypePublic: // Fall through case kKeyTypePrivate: { + ClearErrorOnReturn clear_error_on_return; EVP_PKEY* pkey = key.GetAsymmetricKey().get(); EVP_PKEY* pkey2 = key2.GetAsymmetricKey().get(); #if OPENSSL_VERSION_MAJOR >= 3 diff --git a/src/crypto/crypto_tls.cc b/src/crypto/crypto_tls.cc index 9058f937561..ed20b14e0a1 100644 --- a/src/crypto/crypto_tls.cc +++ b/src/crypto/crypto_tls.cc @@ -73,6 +73,20 @@ namespace crypto { namespace { +void InjectOpenSSLErrorForTesting(const FunctionCallbackInfo&) { +#if NCRYPTO_USE_OPENSSL3_PROVIDER + ERR_raise(ERR_LIB_USER, ERR_R_INTERNAL_ERROR); +#elif NCRYPTO_USE_BORINGSSL || NCRYPTO_USE_LEGACY_OPENSSL + ERR_put_error(ERR_LIB_USER, 0, ERR_R_INTERNAL_ERROR, __FILE__, __LINE__); +#else +#error "Unsupported crypto backend" +#endif +} + +void HasOpenSSLErrorForTesting(const FunctionCallbackInfo& args) { + args.GetReturnValue().Set(ERR_peek_error() != 0); +} + // Our custom implementation of the certificate verify callback // used when establishing a TLS handshake. Because we cannot perform // I/O quickly enough with X509_STORE_CTX_ APIs in this callback, @@ -902,6 +916,7 @@ void TLSWrap::ClearOut() { for (;;) { { SSLLibraryCallScope ssl_library_call_scope(this); + if (ERR_set_mark() != 0) ERR_clear_error(); read = SSL_read(ssl_.get(), out + length, kClearOutChunkSize - length); } Debug(this, "Read %d bytes of cleartext output", read); @@ -1033,6 +1048,7 @@ void TLSWrap::ClearIn() { int written; { SSLLibraryCallScope ssl_library_call_scope(this); + if (ERR_set_mark() != 0) ERR_clear_error(); written = SSL_write(ssl_.get(), bs->Data(), bs->ByteLength()); } Debug(this, "Writing %zu bytes, written = %d", bs->ByteLength(), written); @@ -1235,6 +1251,7 @@ int TLSWrap::DoWrite(WriteWrap* w, NodeBIO::FromBIO(enc_out_)->set_allocate_tls_hint(length); { SSLLibraryCallScope ssl_library_call_scope(this); + if (ERR_set_mark() != 0) ERR_clear_error(); written = SSL_write(ssl_.get(), bs->Data(), length); } } else { @@ -1243,6 +1260,7 @@ int TLSWrap::DoWrite(WriteWrap* w, NodeBIO::FromBIO(enc_out_)->set_allocate_tls_hint(buf->len); { SSLLibraryCallScope ssl_library_call_scope(this); + if (ERR_set_mark() != 0) ERR_clear_error(); written = SSL_write(ssl_.get(), buf->base, buf->len); } @@ -2402,6 +2420,12 @@ void TLSWrap::Initialize( Isolate* isolate = env->isolate(); SetMethod(context, target, "wrap", TLSWrap::Wrap); + SetMethod(context, + target, + "injectOpenSSLErrorForTesting", + InjectOpenSSLErrorForTesting); + SetMethodNoSideEffect( + context, target, "hasOpenSSLErrorForTesting", HasOpenSSLErrorForTesting); NODE_DEFINE_CONSTANT(target, HAVE_SSL_TRACE); @@ -2496,6 +2520,8 @@ void TLSWrap::Initialize( void TLSWrap::RegisterExternalReferences(ExternalReferenceRegistry* registry) { registry->Register(TLSWrap::Wrap); registry->Register(GetWriteQueueSize); + registry->Register(InjectOpenSSLErrorForTesting); + registry->Register(HasOpenSSLErrorForTesting); registry->Register(CertCbDone); registry->Register(ClientHelloDone); diff --git a/test/cctest/test_node_crypto.cc b/test/cctest/test_node_crypto.cc index 27ee5fe3b51..69d31a37462 100644 --- a/test/cctest/test_node_crypto.cc +++ b/test/cctest/test_node_crypto.cc @@ -71,6 +71,16 @@ std::string BioContents(const ncrypto::BIOPointer& bio) { return std::string(mem->data, mem->length); } +void RaiseTestError() { +#if NCRYPTO_USE_OPENSSL3_PROVIDER + ERR_raise(ERR_LIB_USER, ERR_R_INTERNAL_ERROR); +#elif NCRYPTO_USE_BORINGSSL || NCRYPTO_USE_LEGACY_OPENSSL + ERR_put_error(ERR_LIB_USER, 0, ERR_R_INTERNAL_ERROR, __FILE__, __LINE__); +#else +#error "Unsupported crypto backend" +#endif +} + } // namespace /* @@ -102,6 +112,50 @@ TEST(NodeCrypto, TryGetIntCipherOutputLength) { 0, static_cast(INT_MAX) + 1, &output_len)); } +TEST(NodeCrypto, SpkacOperationsClearErrorQueue) { + ncrypto::ClearErrorOnReturn clear_errors; + constexpr std::string_view invalid = "garbage"; + + EXPECT_FALSE(ncrypto::VerifySpkac(invalid.data(), invalid.size())); + EXPECT_EQ(ERR_peek_error(), 0UL); + + EXPECT_FALSE(ncrypto::ExportPublicKey(invalid.data(), invalid.size())); + EXPECT_EQ(ERR_peek_error(), 0UL); + + const auto challenge = + ncrypto::ExportChallenge(invalid.data(), invalid.size()); + EXPECT_EQ(challenge.data, nullptr); + EXPECT_EQ(challenge.len, 0UL); + EXPECT_EQ(ERR_peek_error(), 0UL); +} + +TEST(NodeCrypto, PrivateKeyParsingIgnoresUnrelatedErrors) { + ncrypto::ClearErrorOnReturn clear_errors; + auto ctx = EVPKeyCtxPointer::NewFromAlgorithm(KeyAlgorithm::RSA); + ASSERT_TRUE(ctx); + ASSERT_TRUE(ctx.initForKeygen()); + ASSERT_TRUE(ctx.setRsaKeygenBits(2048)); + EVP_PKEY* raw = nullptr; + ASSERT_EQ(EVP_PKEY_keygen(ctx.get(), &raw), 1); + EVPKeyPointer key(raw); + + const EVPKeyPointer::PrivateKeyEncodingConfig config( + false, + EVPKeyPointer::PKFormatType::PEM, + EVPKeyPointer::PKEncodingType::PKCS8); + auto encoded = key.writePrivateKey(config); + ASSERT_TRUE(encoded); + const BUF_MEM* mem = encoded.value; + ASSERT_NE(mem, nullptr); + + RaiseTestError(); + ASSERT_NE(ERR_peek_error(), 0UL); + auto parsed = EVPKeyPointer::TryParsePrivateKey( + config, {reinterpret_cast(mem->data), mem->length}); + EXPECT_TRUE(parsed); + EXPECT_EQ(ERR_peek_error(), 0UL); +} + TEST(NodeCrypto, KeyAlgorithmNames) { EXPECT_EQ(KeyAlgorithm::FromName("rsa-pss"), &KeyAlgorithm::RSA_PSS); EXPECT_EQ(KeyAlgorithm::FromName("ML-DSA-44"), &KeyAlgorithm::ML_DSA_44); diff --git a/test/cctest/test_node_crypto_env.cc b/test/cctest/test_node_crypto_env.cc index fddf584d7d4..7b9100d40db 100644 --- a/test/cctest/test_node_crypto_env.cc +++ b/test/cctest/test_node_crypto_env.cc @@ -35,6 +35,56 @@ TEST_F(NodeCryptoEnv, LoadBIO) { "any errors on the OpenSSL error stack\n"; } +TEST_F(NodeCryptoEnv, KeyObjectEqualsClearsErrorQueue) { + v8::HandleScope handle_scope(isolate_); + Argv argv; + Env env{handle_scope, argv}; + + ERR_clear_error(); + auto result = node::LoadEnvironment(*env, R"JS( + const { generateKeyPairSync } = require('node:crypto'); + const rsa = generateKeyPairSync('rsa', { modulusLength: 2048 }); + const ec = generateKeyPairSync('ec', { namedCurve: 'P-256' }); + return rsa.publicKey.equals(ec.publicKey); + )JS") + .ToLocalChecked(); + EXPECT_TRUE(result->IsFalse()); + EXPECT_EQ(ERR_peek_error(), 0UL); +} + +TEST_F(NodeCryptoEnv, InvalidEcJwkClearsErrorQueue) { + v8::HandleScope handle_scope(isolate_); + Argv argv; + Env env{handle_scope, argv}; + + ERR_clear_error(); + auto result = node::LoadEnvironment(*env, R"JS( + const { diffieHellman, generateKeyPairSync } = require('node:crypto'); + const { privateKey } = generateKeyPairSync( + 'ec', { namedCurve: 'P-256' }); + try { + diffieHellman({ + privateKey, + publicKey: { + key: { + kty: 'EC', + crv: 'P-256', + x: 'AAAA', + y: 'AAAA', + }, + format: 'jwk', + }, + }); + return false; + } catch (error) { + return error.code === 'ERR_CRYPTO_INVALID_JWK'; + } + )JS") + .ToLocalChecked(); + EXPECT_TRUE(result->IsTrue()); + EXPECT_EQ(ERR_peek_error(), 0UL); +} + #if NCRYPTO_USE_OPENSSL3_PROVIDER TEST_F(NodeCryptoEnv, ExportIncompleteRsaPrivateKeyAsJwk) { v8::HandleScope handle_scope(isolate_); diff --git a/test/parallel/test-crypto-encap-decap.js b/test/parallel/test-crypto-encap-decap.js index 199ad68fa36..aa3b6bae6d9 100644 --- a/test/parallel/test-crypto-encap-decap.js +++ b/test/parallel/test-crypto-encap-decap.js @@ -116,7 +116,7 @@ for (const [name, { }] of Object.entries(keys)) { if (!supported) { assert.throws(() => crypto.encapsulate(publicKey), - { code: /ERR_OSSL_EVP_DECODE_ERROR|ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM|ERR_CRYPTO_OPERATION_FAILED/ }); + { code: /ERR_OSSL_UNSUPPORTED|ERR_OSSL_PEM_NO_START_LINE|ERR_CRYPTO_OPERATION_FAILED/ }); continue; } diff --git a/test/parallel/test-crypto-openssl-error-queue.js b/test/parallel/test-crypto-openssl-error-queue.js new file mode 100644 index 00000000000..3c3329a819d --- /dev/null +++ b/test/parallel/test-crypto-openssl-error-queue.js @@ -0,0 +1,46 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { + Certificate, + createPrivateKey, + createPublicKey, + diffieHellman, + generateKeyPairSync, +} = require('node:crypto'); +const fixtures = require('../common/fixtures'); + +const privateKeyPem = fixtures.readKey('rsa_private.pem'); +const rsaPublicKey = createPublicKey(fixtures.readKey('rsa_public.pem')); +const ec = generateKeyPairSync('ec', { namedCurve: 'P-256' }); + +function parseValidPrivateKey() { + // This must not pick up an error from the preceding operation. + createPrivateKey(privateKeyPem); +} + +assert.strictEqual(rsaPublicKey.equals(ec.publicKey), false); +parseValidPrivateKey(); + +for (const method of ['verifySpkac', 'exportPublicKey', 'exportChallenge']) { + Certificate[method](Buffer.from('garbage')); + parseValidPrivateKey(); +} + +assert.throws(() => diffieHellman({ + privateKey: ec.privateKey, + publicKey: { + key: { + kty: 'EC', + crv: 'P-256', + x: 'AAAA', + y: 'AAAA', + }, + format: 'jwk', + }, +}), { code: 'ERR_CRYPTO_INVALID_JWK' }); +parseValidPrivateKey(); diff --git a/test/parallel/test-crypto-pqc-key-objects-ml-dsa.js b/test/parallel/test-crypto-pqc-key-objects-ml-dsa.js index cd8f8c926f5..03ce40417ae 100644 --- a/test/parallel/test-crypto-pqc-key-objects-ml-dsa.js +++ b/test/parallel/test-crypto-pqc-key-objects-ml-dsa.js @@ -102,7 +102,7 @@ for (const [asymmetricKeyType, pubLen] of [ if (!hasOpenSSL(3, 5) && !isBoringSSL) { assert.throws(() => createPublicKey(keys.public), { - code: hasOpenSSL(3) ? 'ERR_OSSL_EVP_DECODE_ERROR' : 'ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM', + code: hasOpenSSL(3) ? 'ERR_OSSL_UNSUPPORTED' : 'ERR_OSSL_PEM_NO_START_LINE', }); for (const pem of [keys.private, keys.private_seed_only, keys.private_priv_only]) { diff --git a/test/parallel/test-crypto-pqc-key-objects-ml-kem.js b/test/parallel/test-crypto-pqc-key-objects-ml-kem.js index d08a479f421..598c367e253 100644 --- a/test/parallel/test-crypto-pqc-key-objects-ml-kem.js +++ b/test/parallel/test-crypto-pqc-key-objects-ml-kem.js @@ -102,7 +102,7 @@ for (const [asymmetricKeyType, pubLen] of [ if (!hasOpenSSL(3, 5) && !isBoringSSL) { assert.throws(() => createPublicKey(keys.public), { - code: hasOpenSSL(3) ? 'ERR_OSSL_EVP_DECODE_ERROR' : 'ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM', + code: hasOpenSSL(3) ? 'ERR_OSSL_UNSUPPORTED' : 'ERR_OSSL_PEM_NO_START_LINE', }); for (const pem of [keys.private, keys.private_seed_only, keys.private_priv_only]) { @@ -113,7 +113,7 @@ for (const [asymmetricKeyType, pubLen] of [ } else if (isBoringSSL && asymmetricKeyType === 'ml-kem-512') { // BoringSSL does not support ML-KEM-512. assert.throws(() => createPublicKey(keys.public), - { code: 'ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM' }); + { code: 'ERR_OSSL_PEM_NO_START_LINE' }); for (const pem of [keys.private, keys.private_seed_only, keys.private_priv_only]) { assert.throws(() => createPrivateKey(pem), { code: 'ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM' }); diff --git a/test/parallel/test-crypto-pqc-key-objects-slh-dsa.js b/test/parallel/test-crypto-pqc-key-objects-slh-dsa.js index eff309468c3..032b4a254b0 100644 --- a/test/parallel/test-crypto-pqc-key-objects-slh-dsa.js +++ b/test/parallel/test-crypto-pqc-key-objects-slh-dsa.js @@ -101,7 +101,7 @@ for (const asymmetricKeyType of [ if (!hasOpenSSL(3, 5)) { assert.throws(() => createPublicKey(keys.public), { - code: hasOpenSSL(3) ? 'ERR_OSSL_EVP_DECODE_ERROR' : 'ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM', + code: hasOpenSSL(3) ? 'ERR_OSSL_UNSUPPORTED' : 'ERR_OSSL_PEM_NO_START_LINE', }); assert.throws(() => createPrivateKey(keys.private), { diff --git a/test/parallel/test-tls-openssl-error-queue.js b/test/parallel/test-tls-openssl-error-queue.js new file mode 100644 index 00000000000..944f5d7a2cf --- /dev/null +++ b/test/parallel/test-tls-openssl-error-queue.js @@ -0,0 +1,95 @@ +// Flags: --expose-internals +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { fork } = require('node:child_process'); +const https = require('node:https'); +const fixtures = require('../common/fixtures'); + +if (process.argv[2] === 'server') { + const { + hasOpenSSLErrorForTesting, + injectOpenSSLErrorForTesting, + } = require('internal/test/binding').internalBinding('tls_wrap'); + + let requests = 0; + const server = https.createServer({ + key: fixtures.readKey('agent1-key.pem'), + cert: fixtures.readKey('agent1-cert.pem'), + }, common.mustCall((req, res) => { + requests++; + if (requests === 1) { + res.on('finish', common.mustCall(() => { + injectOpenSSLErrorForTesting(); + process.send({ injected: true }); + })); + res.end('first'); + return; + } + + const queueIsClear = !hasOpenSSLErrorForTesting(); + res.on('finish', common.mustCall(() => { + server.close(common.mustCall(() => process.disconnect())); + })); + res.end(queueIsClear ? 'clear' : 'dirty'); + }, 2)); + + server.listen(0, '127.0.0.1', common.mustCall(() => { + process.send({ port: server.address().port }); + })); + return; +} + +function nextMessage(child) { + return new Promise((resolve) => child.once('message', resolve)); +} + +function request(port, agent) { + return new Promise((resolve, reject) => { + https.get({ + agent, + host: '127.0.0.1', + port, + rejectUnauthorized: false, + }, (res) => { + const socket = res.socket; + let body = ''; + res.setEncoding('utf8'); + res.on('data', (chunk) => body += chunk); + res.on('end', () => resolve({ body, socket })); + }).on('error', reject); + }); +} + +async function main() { + const child = fork(__filename, ['server']); + const exited = new Promise((resolve, reject) => { + child.once('error', reject); + child.once('exit', (code, signal) => { + if (code === 0) { + resolve(); + } else { + reject(new Error(`server exited with code ${code}, signal ${signal}`)); + } + }); + }); + + const { port } = await nextMessage(child); + const injected = nextMessage(child); + const agent = new https.Agent({ keepAlive: true, maxSockets: 1 }); + const first = await request(port, agent); + assert.strictEqual(first.body, 'first'); + assert.deepStrictEqual(await injected, { injected: true }); + + const second = await request(port, agent); + assert.strictEqual(second.socket, first.socket); + assert.strictEqual(second.body, 'clear'); + agent.destroy(); + await exited; +} + +main().then(common.mustCall()); From 7265f62f95bbba179d40d280f8fca2a3b5f51ce4 Mon Sep 17 00:00:00 2001 From: Brad Anderson Date: Mon, 9 Nov 2026 13:52:14 -0500 Subject: [PATCH 269/331] crypto: fix ncrypto provider behavior Honor requested primality check counts with provider-backed OpenSSL. Support empty passphrases for encrypted SEC1 PEM output. Assisted-by: Codex Signed-off-by: Brad Anderson PR-URL: https://github.com/nodejs/node/pull/67039 Backport-PR-URL: https://github.com/nodejs/node/pull/67442 Reviewed-By: Antoine du Hamel --- deps/ncrypto/ncrypto.cc | 54 ++++++++++--- test/cctest/test_node_crypto.cc | 76 +++++++++++++++++++ .../test-crypto-key-export-sec1-passphrase.js | 46 +++++++++++ 3 files changed, 164 insertions(+), 12 deletions(-) create mode 100644 test/parallel/test-crypto-key-export-sec1-passphrase.js diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index 9edb016d236..6b21cf4530b 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -736,6 +736,8 @@ BignumPointer BignumPointer::clone() { int BignumPointer::isPrime(int nchecks, BignumPointer::PrimeCheckCallback innerCb) const { BignumCtxPointer ctx(BN_CTX_new()); + if (!ctx) [[unlikely]] + return -1; BignumGenCallbackPointer cb(nullptr); if (innerCb != nullptr) { cb = BignumGenCallbackPointer(BN_GENCB_new()); @@ -753,7 +755,17 @@ int BignumPointer::isPrime(int nchecks, &innerCb); } #if NCRYPTO_USE_OPENSSL3_PROVIDER - return BN_check_prime(get(), ctx.get(), cb.get()); + const int minimum_checks = GetBitCount(get()) > 2048 ? 128 : 64; + const int repetitions = + nchecks > minimum_checks ? 1 + (nchecks - 1) / minimum_checks : 1; + for (int i = 0; i < repetitions; i++) { + // BN_check_prime() may return without invoking the callback (e.g. small + // primes resolved by trial division), so check cancellation here too. + if (i > 0 && innerCb != nullptr && !innerCb(1, -1)) return -1; + const int result = BN_check_prime(get(), ctx.get(), cb.get()); + if (result != 1) return result; + } + return 1; #elif NCRYPTO_USE_BORINGSSL int is_probably_prime = 0; if (BN_primality_test( @@ -4472,6 +4484,9 @@ int WriteDERView(const void* x, unsigned char** out) { bool WriteEncryptedTraditionalPEM(BIO* bio, const EVP_PKEY* pkey, + int selection, + const char* structure, + const char* label, const EVP_CIPHER* cipher, Buffer passphrase) { if (passphrase.len > static_cast(INT_MAX)) return false; @@ -4479,7 +4494,7 @@ bool WriteEncryptedTraditionalPEM(BIO* bio, unsigned char* der = nullptr; size_t der_len = 0; OSSLEncoderCtxPointer ctx(OSSL_ENCODER_CTX_new_for_pkey( - pkey, OSSL_KEYMGMT_SELECT_KEYPAIR, "DER", "pkcs1", nullptr)); + pkey, selection, "DER", structure, nullptr)); if (!ctx) return false; const int result = OSSL_ENCODER_to_data(ctx.get(), &der, &der_len); @@ -4489,7 +4504,7 @@ bool WriteEncryptedTraditionalPEM(BIO* bio, DERView der_view{der_storage.get(), der_len}; return PEM_ASN1_write_bio( WriteDERView, - PEM_STRING_RSA, + label, bio, &der_view, cipher, @@ -4701,8 +4716,13 @@ Result EVPKeyPointer::writePrivateKey( const EVP_CIPHER* cipher = config.format == PKFormatType::PEM ? config.cipher.get() : nullptr; if (cipher != nullptr && passphrase.len == 0) { - err = - !WriteEncryptedTraditionalPEM(bio.get(), get(), cipher, passphrase); + err = !WriteEncryptedTraditionalPEM(bio.get(), + get(), + OSSL_KEYMGMT_SELECT_KEYPAIR, + "pkcs1", + PEM_STRING_RSA, + cipher, + passphrase); } else { err = !WriteEncodedPKey(bio.get(), get(), @@ -4797,13 +4817,23 @@ Result EVPKeyPointer::writePrivateKey( #if NCRYPTO_USE_OPENSSL3_PROVIDER const EVP_CIPHER* cipher = config.format == PKFormatType::PEM ? config.cipher.get() : nullptr; - err = !WriteEncodedPKey(bio.get(), - get(), - OSSL_KEYMGMT_SELECT_ALL, - config.format, - "type-specific", - cipher, - passphrase); + if (cipher != nullptr && passphrase.len == 0) { + err = !WriteEncryptedTraditionalPEM(bio.get(), + get(), + OSSL_KEYMGMT_SELECT_ALL, + "type-specific", + PEM_STRING_ECPRIVATEKEY, + cipher, + passphrase); + } else { + err = !WriteEncodedPKey(bio.get(), + get(), + OSSL_KEYMGMT_SELECT_ALL, + config.format, + "type-specific", + cipher, + passphrase); + } #else #if OPENSSL_VERSION_MAJOR >= 3 const EC_KEY* ec = EVP_PKEY_get0_EC_KEY(get()); diff --git a/test/cctest/test_node_crypto.cc b/test/cctest/test_node_crypto.cc index 69d31a37462..c46d0e248b9 100644 --- a/test/cctest/test_node_crypto.cc +++ b/test/cctest/test_node_crypto.cc @@ -491,6 +491,82 @@ TEST(NodeCrypto, RsaPrimeProduct) { EXPECT_FALSE(rsa.checkPrimeProduct()); } +#if NCRYPTO_USE_OPENSSL3_PROVIDER +namespace { +constexpr int kMinimumPrimeChecks = 64; + +bool CheckMersennePrime(int exponent, int requested_checks) { + auto candidate = ncrypto::BignumPointer::New(); + if (!candidate || BN_set_bit(candidate.get(), exponent) != 1 || + BN_sub_word(candidate.get(), 1) != 1) { + return false; + } + + int completed_checks = 0; + const int result = candidate.isPrime( + requested_checks, [&completed_checks](int event, int iteration) { + if (event == 1 && iteration >= 0) completed_checks++; + return true; + }); + return result == 1 && completed_checks >= requested_checks; +} +} // namespace + +TEST(NodeCrypto, BignumPrimeChecksHonorRequestedCount) { + EXPECT_TRUE(CheckMersennePrime(127, kMinimumPrimeChecks + 1)); + EXPECT_TRUE(CheckMersennePrime(2203, 129)); +} + +TEST(NodeCrypto, BignumPrimeCheckCancellation) { + auto candidate = ncrypto::BignumPointer::New(); + ASSERT_TRUE(candidate); + ASSERT_EQ(BN_set_bit(candidate.get(), 127), 1); + ASSERT_EQ(BN_sub_word(candidate.get(), 1), 1); + + int invocations = 0; + int completed_checks = 0; + bool valid_events = true; + const int result = + candidate.isPrime(kMinimumPrimeChecks + 1, [&](int event, int iteration) { + if (event != 1) { + valid_events = false; + return false; + } + if (iteration == -1) { + invocations++; + return true; + } + if (iteration != completed_checks % kMinimumPrimeChecks) { + valid_events = false; + return false; + } + if (completed_checks == kMinimumPrimeChecks) return false; + completed_checks++; + return true; + }); + EXPECT_EQ(result, -1); + EXPECT_TRUE(valid_events); + EXPECT_EQ(invocations, 3); + EXPECT_EQ(completed_checks, kMinimumPrimeChecks); + ERR_clear_error(); +} + +TEST(NodeCrypto, BignumPrimeCheckCancellationSmallPrime) { + // 311 is resolved by trial division, so OpenSSL never invokes the callback. + auto candidate = ncrypto::BignumPointer::New(); + ASSERT_TRUE(candidate); + ASSERT_EQ(BN_set_word(candidate.get(), 311), 1); + + int invocations = 0; + const int result = candidate.isPrime(INT_MAX, [&](int, int) { + invocations++; + return false; + }); + EXPECT_EQ(result, -1); + EXPECT_EQ(invocations, 1); +} +#endif + TEST(NodeCrypto, EcKeyComponents) { ncrypto::ClearErrorOnReturn clear_errors; ncrypto::BignumPointer x; diff --git a/test/parallel/test-crypto-key-export-sec1-passphrase.js b/test/parallel/test-crypto-key-export-sec1-passphrase.js new file mode 100644 index 00000000000..b9456e5f590 --- /dev/null +++ b/test/parallel/test-crypto-key-export-sec1-passphrase.js @@ -0,0 +1,46 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const { hasFIPS, hasOpenSSL } = require('../common/crypto'); + +if (!hasOpenSSL(3)) + common.skip('OpenSSL 3 provider encoders are required'); +if (hasFIPS(3)) + common.skip('SEC1 private key encoding is not supported in FIPS mode'); + +const assert = require('assert'); +const { + createPrivateKey, + generateKeyPairSync, +} = require('crypto'); + +const { privateKey } = generateKeyPairSync('ec', { + namedCurve: 'prime256v1', +}); + +for (const passphrase of [ + Buffer.alloc(0), + Buffer.from([0x62, 0x69, 0x00, 0x6e, 0x61, 0x72, 0x79]), +]) { + const pem = privateKey.export({ + type: 'sec1', + format: 'pem', + cipher: 'aes-128-cbc', + passphrase, + }); + assert.match(pem.toString(), /^-----BEGIN EC PRIVATE KEY-----\n/); + assert.strictEqual(createPrivateKey({ key: pem, passphrase }) + .asymmetricKeyType, 'ec'); + // A wrong CBC password can occasionally yield valid padding, in which case + // ASN.1 decoding fails instead. + assert.throws(() => createPrivateKey({ + key: pem, + passphrase: Buffer.from('wrong'), + }), { code: /^ERR_OSSL_(BAD_DECRYPT|UNSUPPORTED)$/ }); + assert.throws(() => createPrivateKey({ key: pem }), { + code: 'ERR_OSSL_CRYPTO_INTERRUPTED_OR_CANCELLED', + }); +} From e7c0957ffc7a3912f139c9dd8dc33412e00a451d Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 11 Nov 2026 11:56:08 +0100 Subject: [PATCH 270/331] crypto: remove the FIPS provider name check FIPS-capable providers can use names other than fips. Remove the named-provider lookup and explicit self-test from the startup flags, leaving algorithm availability checks to each operation. Signed-off-by: Filip Skokan Assisted-by: Codex PR-URL: https://github.com/nodejs/node/pull/67358 Backport-PR-URL: https://github.com/nodejs/node/pull/67442 Reviewed-By: Antoine du Hamel --- doc/api/cli.md | 11 ++- doc/api/crypto.md | 13 ++- doc/node.1 | 11 ++- src/crypto/crypto_util.cc | 13 --- .../openssl3-conf/fips_no_provider.cnf | 17 ++++ test/parallel/test-crypto-fips.js | 94 ++++++++++++------- 6 files changed, 97 insertions(+), 62 deletions(-) create mode 100644 test/fixtures/openssl3-conf/fips_no_provider.cnf diff --git a/doc/api/cli.md b/doc/api/cli.md index 24925d718fb..8a6ccbfe953 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -1177,9 +1177,11 @@ priority than `--dns-result-order`. added: v6.0.0 --> -Enable [FIPS mode][] at startup. With OpenSSL 3, a configured provider named -`fips` must be available and initialize successfully. With OpenSSL 1.1.1, -Node.js must be built against a FIPS-capable OpenSSL. +Enable [FIPS mode][] at startup. With OpenSSL 3, this adds `fips=yes` to +OpenSSL's default property query. This does not load or validate a FIPS +provider or run its self-tests. Configure OpenSSL to load the provider +separately. With OpenSSL 1.1.1, Node.js must be built against a FIPS-capable +OpenSSL. ### `--enable-fips-indicator-events` @@ -1745,7 +1747,8 @@ changes: --> Enable [FIPS mode][] at startup and prevent it from being disabled from script -code. The same OpenSSL requirements as [`--enable-fips`][] apply. +code. With OpenSSL 3, this changes the default property query as described for +[`--enable-fips`][]. An optional mode can be specified using `--force-fips=mode`: diff --git a/doc/api/crypto.md b/doc/api/crypto.md index d07486be85f..400675803dd 100644 --- a/doc/api/crypto.md +++ b/doc/api/crypto.md @@ -6794,9 +6794,9 @@ OpenSSL-backed APIs. This method only affects subsequent algorithm fetches. Node.js initializes some OpenSSL state before application code runs. When the property query must be active from process startup, set `default_properties = fips=yes` in the OpenSSL -configuration or use [`--enable-fips`][] or [`--force-fips`][]. The command-line -flags additionally require a configured provider named `fips` to initialize and -pass its self-test; Node.js fails to start otherwise. +configuration or use [`--enable-fips`][] or [`--force-fips`][]. Like this method, +the command-line flags change the property query without loading or validating +a provider or running its self-tests. Throws an error if OpenSSL cannot change the state. FIPS mode cannot be disabled when Node.js was started with `--force-fips`. With OpenSSL 1.1.1, @@ -7436,10 +7436,9 @@ default section name. On OpenSSL 3, the configuration above enables the `fips=yes` property query at startup. The following controls are also available: -* [`--enable-fips`][] and [`--force-fips`][] enable the property query and - additionally require the configured provider named `fips` to initialize and - pass its self-test. Node.js exits if that check fails. `--force-fips` also - prevents FIPS mode from being disabled from script code. With +* [`--enable-fips`][] and [`--force-fips`][] enable the property query at startup. + They do not load or validate a provider or run its self-tests. `--force-fips` + also prevents FIPS mode from being disabled from script code. With `--force-fips=strict`, Node.js also rejects non-approved operations reported through the OpenSSL FIPS indicator callback. * [`crypto.setFips()`][] changes the FIPS/property-query state. On OpenSSL 3, it diff --git a/doc/node.1 b/doc/node.1 index 14a0a606b5c..20a69ef4f4e 100644 --- a/doc/node.1 +++ b/doc/node.1 @@ -710,9 +710,11 @@ The default is \fBverbatim\fR and \fBdns.setDefaultResultOrder()\fR have higher priority than \fB--dns-result-order\fR. . .It Fl -enable-fips -Enable FIPS mode at startup. With OpenSSL 3, a configured provider named -\fBfips\fR must be available and initialize successfully. With OpenSSL 1.1.1, -Node.js must be built against a FIPS-capable OpenSSL. +Enable FIPS mode at startup. With OpenSSL 3, this adds \fBfips=yes\fR to +OpenSSL's default property query. This does not load or validate a FIPS +provider or run its self-tests. Configure OpenSSL to load the provider +separately. With OpenSSL 1.1.1, Node.js must be built against a FIPS-capable +OpenSSL. . .It Fl -enable-fips-indicator-events Publish OpenSSL FIPS indicator results to the @@ -929,7 +931,8 @@ Disable loading native addons that are not context-aware. . .It Fl -force-fips Ns = Ns Ar [mode] Enable FIPS mode at startup and prevent it from being disabled from script -code. The same OpenSSL requirements as \fB--enable-fips\fR apply. +code. With OpenSSL 3, this changes the default property query as described for +\fB--enable-fips\fR. An optional mode can be specified using \fB--force-fips=mode\fR: .Bl -bullet .It diff --git a/src/crypto/crypto_util.cc b/src/crypto/crypto_util.cc index a99b4f10af2..f4f442d029c 100644 --- a/src/crypto/crypto_util.cc +++ b/src/crypto/crypto_util.cc @@ -451,19 +451,6 @@ std::optional ProcessFipsOptions() { const bool force_fips = per_process::cli_options->force_fips_crypto; if (!enable_fips && !force_fips) return std::nullopt; -#if OPENSSL_VERSION_MAJOR >= 3 - // Whether FIPS-approved implementations are reachable is decided by the - // OpenSSL configuration, not by Node.js. Refuse to start rather than - // restrict the default property query to a provider that is not there, - // which would leave every operation failing as unsupported. - if (!ncrypto::testFipsEnabled()) { - const std::string option = force_fips ? "--force-fips" : "--enable-fips"; - return option + " requires an active OpenSSL provider named \"fips\". " - "FIPS mode is configured through OpenSSL; see " - "https://nodejs.org/api/crypto.html#fips-mode"; - } -#endif - CryptoErrorList errors{CryptoErrorList::Option::NONE}; if (!ncrypto::setFipsEnabled(true, &errors)) { std::string error = "OpenSSL error when trying to enable FIPS"; diff --git a/test/fixtures/openssl3-conf/fips_no_provider.cnf b/test/fixtures/openssl3-conf/fips_no_provider.cnf new file mode 100644 index 00000000000..ee36d5b31a0 --- /dev/null +++ b/test/fixtures/openssl3-conf/fips_no_provider.cnf @@ -0,0 +1,17 @@ +nodejs_conf = nodejs_init +openssl_conf = nodejs_init + +[nodejs_init] +providers = provider_sect +random = random_sect + +[provider_sect] +default = default_sect + +[default_sect] +activate = 1 + +# Allow startup randomness while other operations use the default properties. +[random_sect] +properties = fips=no +seed_properties = fips=no diff --git a/test/parallel/test-crypto-fips.js b/test/parallel/test-crypto-fips.js index ad67ec181c7..19a5c0ad0bd 100644 --- a/test/parallel/test-crypto-fips.js +++ b/test/parallel/test-crypto-fips.js @@ -12,8 +12,8 @@ if (isBoringSSL) const assert = require('assert'); const spawnSync = require('child_process').spawnSync; const path = require('path'); -const { spawnSyncAndAssert } = require('../common/child_process'); const fixtures = require('../common/fixtures'); +const { spawnSyncAndAssert } = require('../common/child_process'); const { internalBinding } = require('internal/test/binding'); const { testFipsCrypto } = internalBinding('crypto'); @@ -78,32 +78,66 @@ function testHelper(stream, args, expectedStatus, expectedOutput, cmd, env) { responseHandler(child[stream], expectedOutput); } -// --enable-fips should raise an error if OpenSSL is not FIPS enabled. -testHelper( - testFipsCrypto() ? 'stdout' : 'stderr', - ['--enable-fips'], - testFipsCrypto() ? kNoFailure : kGenericUserError, - testFipsCrypto() ? FIPS_ENABLED : FIPS_ENABLE_ERROR_STRING, - 'require("crypto").getFips()', - process.env); +if (hasOpenSSL(3)) { + const fipsFlags = ['--enable-fips', '--force-fips', '--force-fips=provider']; + if (hasOpenSSL(3, 4)) + fipsFlags.push('--force-fips=strict'); + + // The flags change the default property query without requiring a provider + // named "fips". This configuration supplies the RNG needed during startup, + // but has no cryptographic implementations matching fips=yes. + for (const flag of fipsFlags) { + spawnSyncAndAssert(process.execPath, [ + flag, + `--openssl-config=${fixtures.path('openssl3-conf', 'fips_no_provider.cnf')}`, + '-e', ` + const assert = require('assert'); + const crypto = require('crypto'); + assert.strictEqual(crypto.getFips(), 1); + assert.throws(() => crypto.createHash('sha256'), { + code: 'ERR_OSSL_EVP_UNSUPPORTED', + }); + if (${flag === '--enable-fips'}) { + crypto.setFips(false); + assert.strictEqual(crypto.getFips(), 0); + crypto.createHash('sha256'); + } else { + assert.throws(() => crypto.setFips(false), { + code: 'ERR_CRYPTO_FIPS_FORCED', + }); + assert.strictEqual(crypto.getFips(), 1); + } + `, + ], { stdout: '', stderr: '' }); + } +} else { + // --enable-fips should raise an error if OpenSSL is not FIPS enabled. + testHelper( + testFipsCrypto() ? 'stdout' : 'stderr', + ['--enable-fips'], + testFipsCrypto() ? kNoFailure : kGenericUserError, + testFipsCrypto() ? FIPS_ENABLED : FIPS_ENABLE_ERROR_STRING, + 'require("crypto").getFips()', + process.env); -// --force-fips should raise an error if OpenSSL is not FIPS enabled. -testHelper( - testFipsCrypto() ? 'stdout' : 'stderr', - ['--force-fips'], - testFipsCrypto() ? kNoFailure : kGenericUserError, - testFipsCrypto() ? FIPS_ENABLED : FIPS_FORCE_ERROR_STRING, - 'require("crypto").getFips()', - process.env); + // --force-fips should raise an error if OpenSSL is not FIPS enabled. + testHelper( + testFipsCrypto() ? 'stdout' : 'stderr', + ['--force-fips'], + testFipsCrypto() ? kNoFailure : kGenericUserError, + testFipsCrypto() ? FIPS_ENABLED : FIPS_FORCE_ERROR_STRING, + 'require("crypto").getFips()', + process.env); -// Explicit provider mode should preserve the behavior of bare --force-fips. -testHelper( - testFipsCrypto() ? 'stdout' : 'stderr', - ['--force-fips=provider'], - testFipsCrypto() ? kNoFailure : kGenericUserError, - testFipsCrypto() ? FIPS_ENABLED : FIPS_FORCE_ERROR_STRING, - 'require("crypto").getFips()', - process.env); + // Explicit provider mode should preserve the behavior of bare --force-fips. + testHelper( + testFipsCrypto() ? 'stdout' : 'stderr', + ['--force-fips=provider'], + testFipsCrypto() ? kNoFailure : kGenericUserError, + testFipsCrypto() ? FIPS_ENABLED : FIPS_FORCE_ERROR_STRING, + 'require("crypto").getFips()', + process.env); +} { spawnSyncAndAssert( @@ -113,15 +147,7 @@ testHelper( }); } -if (hasOpenSSL(3, 4)) { - testHelper( - testFipsCrypto() ? 'stdout' : 'stderr', - ['--force-fips=strict'], - testFipsCrypto() ? kNoFailure : kGenericUserError, - testFipsCrypto() ? FIPS_ENABLED : FIPS_FORCE_ERROR_STRING, - 'require("crypto").getFips()', - process.env); -} else { +if (!hasOpenSSL(3, 4)) { spawnSyncAndAssert( process.execPath, ['--enable-fips-indicator-events', '-e', '0'], { status: 9, From 61f750e8751bd8273cba81f20437abae86a1cdbf Mon Sep 17 00:00:00 2001 From: npm CLI robot Date: Wed, 4 Nov 2026 23:50:30 +0000 Subject: [PATCH 271/331] deps: upgrade npm to 11.21.2 PR-URL: https://github.com/nodejs/node/pull/67264 Reviewed-By: Richard Lau --- deps/npm/docs/content/commands/npm-ls.md | 2 +- deps/npm/docs/content/commands/npm-stage.md | 3 +- deps/npm/docs/content/commands/npm.md | 2 +- deps/npm/docs/output/commands/npm-access.html | 4 +- .../npm/docs/output/commands/npm-adduser.html | 4 +- .../output/commands/npm-approve-scripts.html | 4 +- deps/npm/docs/output/commands/npm-audit.html | 4 +- deps/npm/docs/output/commands/npm-bugs.html | 4 +- deps/npm/docs/output/commands/npm-cache.html | 4 +- deps/npm/docs/output/commands/npm-ci.html | 4 +- .../docs/output/commands/npm-completion.html | 4 +- deps/npm/docs/output/commands/npm-config.html | 4 +- deps/npm/docs/output/commands/npm-dedupe.html | 4 +- .../output/commands/npm-deny-scripts.html | 4 +- .../docs/output/commands/npm-deprecate.html | 4 +- deps/npm/docs/output/commands/npm-diff.html | 4 +- .../docs/output/commands/npm-dist-tag.html | 4 +- deps/npm/docs/output/commands/npm-docs.html | 4 +- deps/npm/docs/output/commands/npm-doctor.html | 4 +- deps/npm/docs/output/commands/npm-edit.html | 4 +- deps/npm/docs/output/commands/npm-exec.html | 4 +- .../npm/docs/output/commands/npm-explain.html | 4 +- .../npm/docs/output/commands/npm-explore.html | 4 +- .../docs/output/commands/npm-find-dupes.html | 4 +- deps/npm/docs/output/commands/npm-fund.html | 4 +- deps/npm/docs/output/commands/npm-get.html | 4 +- .../docs/output/commands/npm-help-search.html | 4 +- deps/npm/docs/output/commands/npm-help.html | 4 +- deps/npm/docs/output/commands/npm-init.html | 4 +- .../output/commands/npm-install-ci-test.html | 4 +- .../output/commands/npm-install-scripts.html | 4 +- .../output/commands/npm-install-test.html | 4 +- .../npm/docs/output/commands/npm-install.html | 4 +- deps/npm/docs/output/commands/npm-link.html | 4 +- deps/npm/docs/output/commands/npm-ll.html | 4 +- deps/npm/docs/output/commands/npm-login.html | 4 +- deps/npm/docs/output/commands/npm-logout.html | 4 +- deps/npm/docs/output/commands/npm-ls.html | 6 +- deps/npm/docs/output/commands/npm-org.html | 4 +- .../docs/output/commands/npm-outdated.html | 4 +- deps/npm/docs/output/commands/npm-owner.html | 4 +- deps/npm/docs/output/commands/npm-pack.html | 4 +- deps/npm/docs/output/commands/npm-ping.html | 4 +- deps/npm/docs/output/commands/npm-pkg.html | 4 +- deps/npm/docs/output/commands/npm-prefix.html | 4 +- .../npm/docs/output/commands/npm-profile.html | 4 +- deps/npm/docs/output/commands/npm-prune.html | 4 +- .../npm/docs/output/commands/npm-publish.html | 4 +- deps/npm/docs/output/commands/npm-query.html | 4 +- .../npm/docs/output/commands/npm-rebuild.html | 4 +- deps/npm/docs/output/commands/npm-repo.html | 4 +- .../npm/docs/output/commands/npm-restart.html | 4 +- deps/npm/docs/output/commands/npm-root.html | 4 +- deps/npm/docs/output/commands/npm-run.html | 4 +- deps/npm/docs/output/commands/npm-sbom.html | 4 +- deps/npm/docs/output/commands/npm-search.html | 4 +- deps/npm/docs/output/commands/npm-set.html | 4 +- .../docs/output/commands/npm-shrinkwrap.html | 4 +- deps/npm/docs/output/commands/npm-stage.html | 7 +- deps/npm/docs/output/commands/npm-star.html | 4 +- deps/npm/docs/output/commands/npm-stars.html | 4 +- deps/npm/docs/output/commands/npm-start.html | 4 +- deps/npm/docs/output/commands/npm-stop.html | 4 +- deps/npm/docs/output/commands/npm-team.html | 4 +- deps/npm/docs/output/commands/npm-test.html | 4 +- deps/npm/docs/output/commands/npm-token.html | 4 +- deps/npm/docs/output/commands/npm-trust.html | 4 +- .../docs/output/commands/npm-undeprecate.html | 4 +- .../docs/output/commands/npm-uninstall.html | 4 +- .../docs/output/commands/npm-unpublish.html | 4 +- deps/npm/docs/output/commands/npm-unstar.html | 4 +- deps/npm/docs/output/commands/npm-update.html | 4 +- .../npm/docs/output/commands/npm-version.html | 4 +- deps/npm/docs/output/commands/npm-view.html | 4 +- deps/npm/docs/output/commands/npm-whoami.html | 4 +- deps/npm/docs/output/commands/npm.html | 6 +- deps/npm/docs/output/commands/npx.html | 4 +- .../docs/output/configuring-npm/folders.html | 4 +- .../docs/output/configuring-npm/install.html | 4 +- .../output/configuring-npm/npm-global.html | 4 +- .../docs/output/configuring-npm/npm-json.html | 4 +- .../configuring-npm/npm-shrinkwrap-json.html | 4 +- .../docs/output/configuring-npm/npmrc.html | 4 +- .../output/configuring-npm/package-json.html | 4 +- .../configuring-npm/package-lock-json.html | 4 +- deps/npm/docs/output/using-npm/config.html | 4 +- .../using-npm/dependency-selectors.html | 4 +- .../npm/docs/output/using-npm/developers.html | 4 +- deps/npm/docs/output/using-npm/logging.html | 4 +- deps/npm/docs/output/using-npm/orgs.html | 4 +- .../docs/output/using-npm/package-spec.html | 4 +- deps/npm/docs/output/using-npm/registry.html | 4 +- deps/npm/docs/output/using-npm/removal.html | 4 +- deps/npm/docs/output/using-npm/scope.html | 4 +- deps/npm/docs/output/using-npm/scripts.html | 4 +- .../npm/docs/output/using-npm/workspaces.html | 4 +- deps/npm/lib/cli/entry.js | 2 +- deps/npm/lib/commands/dist-tag.js | 14 + deps/npm/lib/commands/publish.js | 8 +- deps/npm/lib/utils/allow-scripts-cmd.js | 14 +- deps/npm/lib/utils/allow-scripts-prune.js | 3 +- deps/npm/lib/utils/oidc.js | 91 +++- deps/npm/man/man1/npm-access.1 | 2 +- deps/npm/man/man1/npm-adduser.1 | 2 +- deps/npm/man/man1/npm-approve-scripts.1 | 2 +- deps/npm/man/man1/npm-audit.1 | 2 +- deps/npm/man/man1/npm-bugs.1 | 2 +- deps/npm/man/man1/npm-cache.1 | 2 +- deps/npm/man/man1/npm-ci.1 | 2 +- deps/npm/man/man1/npm-completion.1 | 2 +- deps/npm/man/man1/npm-config.1 | 2 +- deps/npm/man/man1/npm-dedupe.1 | 2 +- deps/npm/man/man1/npm-deny-scripts.1 | 2 +- deps/npm/man/man1/npm-deprecate.1 | 2 +- deps/npm/man/man1/npm-diff.1 | 2 +- deps/npm/man/man1/npm-dist-tag.1 | 2 +- deps/npm/man/man1/npm-docs.1 | 2 +- deps/npm/man/man1/npm-doctor.1 | 2 +- deps/npm/man/man1/npm-edit.1 | 2 +- deps/npm/man/man1/npm-exec.1 | 2 +- deps/npm/man/man1/npm-explain.1 | 2 +- deps/npm/man/man1/npm-explore.1 | 2 +- deps/npm/man/man1/npm-find-dupes.1 | 2 +- deps/npm/man/man1/npm-fund.1 | 2 +- deps/npm/man/man1/npm-get.1 | 2 +- deps/npm/man/man1/npm-help-search.1 | 2 +- deps/npm/man/man1/npm-help.1 | 2 +- deps/npm/man/man1/npm-init.1 | 2 +- deps/npm/man/man1/npm-install-ci-test.1 | 2 +- deps/npm/man/man1/npm-install-scripts.1 | 2 +- deps/npm/man/man1/npm-install-test.1 | 2 +- deps/npm/man/man1/npm-install.1 | 2 +- deps/npm/man/man1/npm-link.1 | 2 +- deps/npm/man/man1/npm-ll.1 | 2 +- deps/npm/man/man1/npm-login.1 | 2 +- deps/npm/man/man1/npm-logout.1 | 2 +- deps/npm/man/man1/npm-ls.1 | 4 +- deps/npm/man/man1/npm-org.1 | 2 +- deps/npm/man/man1/npm-outdated.1 | 2 +- deps/npm/man/man1/npm-owner.1 | 2 +- deps/npm/man/man1/npm-pack.1 | 2 +- deps/npm/man/man1/npm-ping.1 | 2 +- deps/npm/man/man1/npm-pkg.1 | 2 +- deps/npm/man/man1/npm-prefix.1 | 2 +- deps/npm/man/man1/npm-profile.1 | 2 +- deps/npm/man/man1/npm-prune.1 | 2 +- deps/npm/man/man1/npm-publish.1 | 2 +- deps/npm/man/man1/npm-query.1 | 2 +- deps/npm/man/man1/npm-rebuild.1 | 2 +- deps/npm/man/man1/npm-repo.1 | 2 +- deps/npm/man/man1/npm-restart.1 | 2 +- deps/npm/man/man1/npm-root.1 | 2 +- deps/npm/man/man1/npm-run.1 | 2 +- deps/npm/man/man1/npm-sbom.1 | 2 +- deps/npm/man/man1/npm-search.1 | 2 +- deps/npm/man/man1/npm-set.1 | 2 +- deps/npm/man/man1/npm-shrinkwrap.1 | 2 +- deps/npm/man/man1/npm-stage.1 | 6 +- deps/npm/man/man1/npm-star.1 | 2 +- deps/npm/man/man1/npm-stars.1 | 2 +- deps/npm/man/man1/npm-start.1 | 2 +- deps/npm/man/man1/npm-stop.1 | 2 +- deps/npm/man/man1/npm-team.1 | 2 +- deps/npm/man/man1/npm-test.1 | 2 +- deps/npm/man/man1/npm-token.1 | 2 +- deps/npm/man/man1/npm-trust.1 | 2 +- deps/npm/man/man1/npm-undeprecate.1 | 2 +- deps/npm/man/man1/npm-uninstall.1 | 2 +- deps/npm/man/man1/npm-unpublish.1 | 2 +- deps/npm/man/man1/npm-unstar.1 | 2 +- deps/npm/man/man1/npm-update.1 | 2 +- deps/npm/man/man1/npm-version.1 | 2 +- deps/npm/man/man1/npm-view.1 | 2 +- deps/npm/man/man1/npm-whoami.1 | 2 +- deps/npm/man/man1/npm.1 | 4 +- deps/npm/man/man1/npx.1 | 2 +- deps/npm/man/man5/folders.5 | 2 +- deps/npm/man/man5/install.5 | 2 +- deps/npm/man/man5/npm-global.5 | 2 +- deps/npm/man/man5/npm-json.5 | 2 +- deps/npm/man/man5/npm-shrinkwrap-json.5 | 2 +- deps/npm/man/man5/npmrc.5 | 2 +- deps/npm/man/man5/package-json.5 | 2 +- deps/npm/man/man5/package-lock-json.5 | 2 +- deps/npm/man/man7/config.7 | 2 +- deps/npm/man/man7/dependency-selectors.7 | 2 +- deps/npm/man/man7/developers.7 | 2 +- deps/npm/man/man7/logging.7 | 2 +- deps/npm/man/man7/orgs.7 | 2 +- deps/npm/man/man7/package-spec.7 | 2 +- deps/npm/man/man7/registry.7 | 2 +- deps/npm/man/man7/removal.7 | 2 +- deps/npm/man/man7/scope.7 | 2 +- deps/npm/man/man7/scripts.7 | 2 +- deps/npm/man/man7/workspaces.7 | 2 +- .../arborist/lib/arborist/build-ideal-tree.js | 4 +- .../@npmcli/arborist/lib/script-allowed.js | 56 ++- .../@npmcli/arborist/package.json | 2 +- .../npm/node_modules/@npmcli/config/README.md | 2 + .../node_modules/@npmcli/config/lib/index.js | 2 + .../node_modules/@npmcli/config/package.json | 2 +- .../@npmcli/promise-spawn/lib/index.js | 11 +- .../@npmcli/promise-spawn/package.json | 5 +- .../node_modules/bin-links/lib/get-paths.js | 2 + deps/npm/node_modules/bin-links/package.json | 3 +- .../brace-expansion/dist/commonjs/index.js | 94 +++- .../brace-expansion/dist/esm/index.js | 92 +++- .../node_modules/brace-expansion/package.json | 3 +- .../http-cache-semantics/index.js | 41 +- .../http-cache-semantics/package.json | 6 +- .../node_modules/ip-address/dist/common.js | 52 +- deps/npm/node_modules/ip-address/dist/ipv4.js | 107 +++- deps/npm/node_modules/ip-address/dist/ipv6.js | 178 +++++-- .../ip-address/dist/v4/constants.js | 41 +- .../ip-address/dist/v6/constants.js | 51 +- deps/npm/node_modules/ip-address/package.json | 5 +- deps/npm/node_modules/libnpmdiff/package.json | 4 +- deps/npm/node_modules/libnpmexec/README.md | 10 +- deps/npm/node_modules/libnpmexec/lib/index.js | 8 +- .../node_modules/libnpmexec/lib/run-script.js | 27 +- deps/npm/node_modules/libnpmexec/package.json | 4 +- deps/npm/node_modules/libnpmfund/package.json | 4 +- deps/npm/node_modules/libnpmpack/package.json | 4 +- deps/npm/node_modules/pacote/lib/registry.js | 73 ++- deps/npm/node_modules/pacote/package.json | 5 +- .../postcss-selector-parser/dist/parser.js | 45 +- .../postcss-selector-parser/package.json | 9 +- deps/npm/node_modules/semver/classes/range.js | 4 +- .../node_modules/semver/internal/constants.js | 30 ++ .../internal/trim-comparator-whitespace.js | 438 ++++++++++++++++ deps/npm/node_modules/semver/package.json | 2 +- .../undici/docs/docs/api/Client.md | 2 + .../docs/docs/api/DiagnosticsChannel.md | 4 +- .../node_modules/undici/lib/core/request.js | 70 ++- .../undici/lib/dispatcher/agent.js | 8 +- .../undici/lib/dispatcher/client-h1.js | 43 +- .../undici/lib/dispatcher/client-h2.js | 92 +++- .../undici/lib/dispatcher/client.js | 5 +- .../undici/lib/dispatcher/dispatcher-base.js | 9 + .../undici/lib/handler/retry-handler.js | 37 +- .../lib/web/eventsource/eventsource-stream.js | 476 ++++++++++++------ .../undici/lib/web/eventsource/eventsource.js | 5 +- .../undici/lib/web/fetch/index.js | 16 +- .../undici/lib/web/websocket/connection.js | 2 +- .../lib/web/websocket/permessage-deflate.js | 5 + .../undici/lib/web/websocket/receiver.js | 14 + deps/npm/node_modules/undici/package.json | 2 +- deps/npm/package.json | 20 +- deps/npm/test/fixtures/mock-oidc.js | 5 +- deps/npm/test/lib/cli/entry.js | 30 ++ deps/npm/test/lib/commands/approve-scripts.js | 247 +++++++++ deps/npm/test/lib/commands/dist-tag.js | 376 ++++++++++++++ deps/npm/test/lib/commands/install-scripts.js | 61 +++ deps/npm/test/lib/commands/publish.js | 117 +++++ deps/npm/test/lib/commands/stage/index.js | 27 + deps/npm/test/lib/utils/oidc.js | 239 +++++++++ 256 files changed, 3369 insertions(+), 681 deletions(-) create mode 100644 deps/npm/node_modules/semver/internal/trim-comparator-whitespace.js create mode 100644 deps/npm/test/lib/utils/oidc.js diff --git a/deps/npm/docs/content/commands/npm-ls.md b/deps/npm/docs/content/commands/npm-ls.md index e3be39fcf04..3e01552722c 100644 --- a/deps/npm/docs/content/commands/npm-ls.md +++ b/deps/npm/docs/content/commands/npm-ls.md @@ -23,7 +23,7 @@ Note that nested packages will *also* show the paths to the specified packages. For example, running `npm ls promzard` in npm's source tree will show: ```bash -npm@11.20.0 /path/to/npm +npm@11.21.2 /path/to/npm └─┬ init-package-json@0.0.4 └── promzard@0.1.5 ``` diff --git a/deps/npm/docs/content/commands/npm-stage.md b/deps/npm/docs/content/commands/npm-stage.md index 4228a43cce7..e4154e82b78 100644 --- a/deps/npm/docs/content/commands/npm-stage.md +++ b/deps/npm/docs/content/commands/npm-stage.md @@ -40,6 +40,7 @@ Key behaviors: version for that package. * You can still publish packages normally while you have staged packages pending. +* Staged publishing will allow you to create a new package if it does not exist. * You can stage multiple versions of the same package. * `npm stage publish` has parity with `npm publish` and will respect `"private": true` in `package.json`, refusing to stage the package. @@ -50,8 +51,6 @@ Before using `npm stage` commands, ensure the following requirements are met: * **Write permissions on the package:** You must have write access to the package you're configuring. -* **Package must exist:** The package you're configuring must already exist - on the npm registry. * **2FA enabled on your account:** Commands that require 2FA will prompt you to authenticate. If you don't already have 2FA enabled on your account, you must enable it before using these commands. diff --git a/deps/npm/docs/content/commands/npm.md b/deps/npm/docs/content/commands/npm.md index 7789159b987..0206d6aa087 100644 --- a/deps/npm/docs/content/commands/npm.md +++ b/deps/npm/docs/content/commands/npm.md @@ -14,7 +14,7 @@ Note: This command is unaware of workspaces. ### Version -11.20.0 +11.21.2 ### Description diff --git a/deps/npm/docs/output/commands/npm-access.html b/deps/npm/docs/output/commands/npm-access.html index 9e232c895e9..3feec9298ef 100644 --- a/deps/npm/docs/output/commands/npm-access.html +++ b/deps/npm/docs/output/commands/npm-access.html @@ -186,9 +186,9 @@
-

+

npm-access - @11.20.0 + @11.21.2

Set access level on published packages
diff --git a/deps/npm/docs/output/commands/npm-adduser.html b/deps/npm/docs/output/commands/npm-adduser.html index f1fdd66f309..af06b3609bc 100644 --- a/deps/npm/docs/output/commands/npm-adduser.html +++ b/deps/npm/docs/output/commands/npm-adduser.html @@ -186,9 +186,9 @@
-

+

npm-adduser - @11.20.0 + @11.21.2

Add a registry user account
diff --git a/deps/npm/docs/output/commands/npm-approve-scripts.html b/deps/npm/docs/output/commands/npm-approve-scripts.html index 8b54f89168b..9324166c7b9 100644 --- a/deps/npm/docs/output/commands/npm-approve-scripts.html +++ b/deps/npm/docs/output/commands/npm-approve-scripts.html @@ -186,9 +186,9 @@
-

+

npm-approve-scripts - @11.20.0 + @11.21.2

Approve install scripts for specific dependencies
diff --git a/deps/npm/docs/output/commands/npm-audit.html b/deps/npm/docs/output/commands/npm-audit.html index d093dc1d253..fec2c0eeec4 100644 --- a/deps/npm/docs/output/commands/npm-audit.html +++ b/deps/npm/docs/output/commands/npm-audit.html @@ -186,9 +186,9 @@
-

+

npm-audit - @11.20.0 + @11.21.2

Run a security audit
diff --git a/deps/npm/docs/output/commands/npm-bugs.html b/deps/npm/docs/output/commands/npm-bugs.html index 98cc06a6698..6bc1b9c4f26 100644 --- a/deps/npm/docs/output/commands/npm-bugs.html +++ b/deps/npm/docs/output/commands/npm-bugs.html @@ -186,9 +186,9 @@
-

+

npm-bugs - @11.20.0 + @11.21.2

Report bugs for a package in a web browser
diff --git a/deps/npm/docs/output/commands/npm-cache.html b/deps/npm/docs/output/commands/npm-cache.html index 9f49c537846..831035e343f 100644 --- a/deps/npm/docs/output/commands/npm-cache.html +++ b/deps/npm/docs/output/commands/npm-cache.html @@ -186,9 +186,9 @@
-

+

npm-cache - @11.20.0 + @11.21.2

Manipulates packages cache
diff --git a/deps/npm/docs/output/commands/npm-ci.html b/deps/npm/docs/output/commands/npm-ci.html index 5ef13e2947b..2f2900c3eae 100644 --- a/deps/npm/docs/output/commands/npm-ci.html +++ b/deps/npm/docs/output/commands/npm-ci.html @@ -186,9 +186,9 @@
-

+

npm-ci - @11.20.0 + @11.21.2

Clean install a project
diff --git a/deps/npm/docs/output/commands/npm-completion.html b/deps/npm/docs/output/commands/npm-completion.html index 69e1b5771a2..a89ad0fa110 100644 --- a/deps/npm/docs/output/commands/npm-completion.html +++ b/deps/npm/docs/output/commands/npm-completion.html @@ -186,9 +186,9 @@
-

+

npm-completion - @11.20.0 + @11.21.2

Tab Completion for npm
diff --git a/deps/npm/docs/output/commands/npm-config.html b/deps/npm/docs/output/commands/npm-config.html index bb6a7770b93..c08848fb8e1 100644 --- a/deps/npm/docs/output/commands/npm-config.html +++ b/deps/npm/docs/output/commands/npm-config.html @@ -186,9 +186,9 @@
-

+

npm-config - @11.20.0 + @11.21.2

Manage the npm configuration files
diff --git a/deps/npm/docs/output/commands/npm-dedupe.html b/deps/npm/docs/output/commands/npm-dedupe.html index 8437b66e533..6f33135ca9a 100644 --- a/deps/npm/docs/output/commands/npm-dedupe.html +++ b/deps/npm/docs/output/commands/npm-dedupe.html @@ -186,9 +186,9 @@
-

+

npm-dedupe - @11.20.0 + @11.21.2

Reduce duplication in the package tree
diff --git a/deps/npm/docs/output/commands/npm-deny-scripts.html b/deps/npm/docs/output/commands/npm-deny-scripts.html index 53789799855..f844e396844 100644 --- a/deps/npm/docs/output/commands/npm-deny-scripts.html +++ b/deps/npm/docs/output/commands/npm-deny-scripts.html @@ -186,9 +186,9 @@
-

+

npm-deny-scripts - @11.20.0 + @11.21.2

Deny install scripts for specific dependencies
diff --git a/deps/npm/docs/output/commands/npm-deprecate.html b/deps/npm/docs/output/commands/npm-deprecate.html index bbd8d76fac0..9bc0fc612a5 100644 --- a/deps/npm/docs/output/commands/npm-deprecate.html +++ b/deps/npm/docs/output/commands/npm-deprecate.html @@ -186,9 +186,9 @@
-

+

npm-deprecate - @11.20.0 + @11.21.2

Deprecate a version of a package
diff --git a/deps/npm/docs/output/commands/npm-diff.html b/deps/npm/docs/output/commands/npm-diff.html index 0a23ac8cf7b..4b41ca886c2 100644 --- a/deps/npm/docs/output/commands/npm-diff.html +++ b/deps/npm/docs/output/commands/npm-diff.html @@ -186,9 +186,9 @@
-

+

npm-diff - @11.20.0 + @11.21.2

The registry diff command
diff --git a/deps/npm/docs/output/commands/npm-dist-tag.html b/deps/npm/docs/output/commands/npm-dist-tag.html index b5d56fa965f..032b78e75f4 100644 --- a/deps/npm/docs/output/commands/npm-dist-tag.html +++ b/deps/npm/docs/output/commands/npm-dist-tag.html @@ -186,9 +186,9 @@
-

+

npm-dist-tag - @11.20.0 + @11.21.2

Modify package distribution tags
diff --git a/deps/npm/docs/output/commands/npm-docs.html b/deps/npm/docs/output/commands/npm-docs.html index ee20bd23abd..e39ea14464d 100644 --- a/deps/npm/docs/output/commands/npm-docs.html +++ b/deps/npm/docs/output/commands/npm-docs.html @@ -186,9 +186,9 @@
-

+

npm-docs - @11.20.0 + @11.21.2

Open documentation for a package in a web browser
diff --git a/deps/npm/docs/output/commands/npm-doctor.html b/deps/npm/docs/output/commands/npm-doctor.html index c7a3368b35c..30492a8f038 100644 --- a/deps/npm/docs/output/commands/npm-doctor.html +++ b/deps/npm/docs/output/commands/npm-doctor.html @@ -186,9 +186,9 @@
-

+

npm-doctor - @11.20.0 + @11.21.2

Check the health of your npm environment
diff --git a/deps/npm/docs/output/commands/npm-edit.html b/deps/npm/docs/output/commands/npm-edit.html index ab465f52017..aed37190cef 100644 --- a/deps/npm/docs/output/commands/npm-edit.html +++ b/deps/npm/docs/output/commands/npm-edit.html @@ -186,9 +186,9 @@
-

+

npm-edit - @11.20.0 + @11.21.2

Edit an installed package
diff --git a/deps/npm/docs/output/commands/npm-exec.html b/deps/npm/docs/output/commands/npm-exec.html index 67b114949b7..0dd426d8d27 100644 --- a/deps/npm/docs/output/commands/npm-exec.html +++ b/deps/npm/docs/output/commands/npm-exec.html @@ -186,9 +186,9 @@
-

+

npm-exec - @11.20.0 + @11.21.2

Run a command from a local or remote npm package
diff --git a/deps/npm/docs/output/commands/npm-explain.html b/deps/npm/docs/output/commands/npm-explain.html index 3cc89e27ceb..fe176731c99 100644 --- a/deps/npm/docs/output/commands/npm-explain.html +++ b/deps/npm/docs/output/commands/npm-explain.html @@ -186,9 +186,9 @@
-

+

npm-explain - @11.20.0 + @11.21.2

Explain installed packages
diff --git a/deps/npm/docs/output/commands/npm-explore.html b/deps/npm/docs/output/commands/npm-explore.html index 028b6ba5ba8..1e4ff4af713 100644 --- a/deps/npm/docs/output/commands/npm-explore.html +++ b/deps/npm/docs/output/commands/npm-explore.html @@ -186,9 +186,9 @@
-

+

npm-explore - @11.20.0 + @11.21.2

Browse an installed package
diff --git a/deps/npm/docs/output/commands/npm-find-dupes.html b/deps/npm/docs/output/commands/npm-find-dupes.html index 3476968389e..fd42595f230 100644 --- a/deps/npm/docs/output/commands/npm-find-dupes.html +++ b/deps/npm/docs/output/commands/npm-find-dupes.html @@ -186,9 +186,9 @@
-

+

npm-find-dupes - @11.20.0 + @11.21.2

Find duplication in the package tree
diff --git a/deps/npm/docs/output/commands/npm-fund.html b/deps/npm/docs/output/commands/npm-fund.html index 181e029e6c1..180479da8c0 100644 --- a/deps/npm/docs/output/commands/npm-fund.html +++ b/deps/npm/docs/output/commands/npm-fund.html @@ -186,9 +186,9 @@
-

+

npm-fund - @11.20.0 + @11.21.2

Retrieve funding information
diff --git a/deps/npm/docs/output/commands/npm-get.html b/deps/npm/docs/output/commands/npm-get.html index 02feaf3e737..03cd64c2413 100644 --- a/deps/npm/docs/output/commands/npm-get.html +++ b/deps/npm/docs/output/commands/npm-get.html @@ -186,9 +186,9 @@
-

+

npm-get - @11.20.0 + @11.21.2

Get a value from the npm configuration
diff --git a/deps/npm/docs/output/commands/npm-help-search.html b/deps/npm/docs/output/commands/npm-help-search.html index b32d1585994..51925baf1aa 100644 --- a/deps/npm/docs/output/commands/npm-help-search.html +++ b/deps/npm/docs/output/commands/npm-help-search.html @@ -186,9 +186,9 @@
-

+

npm-help-search - @11.20.0 + @11.21.2

Search npm help documentation
diff --git a/deps/npm/docs/output/commands/npm-help.html b/deps/npm/docs/output/commands/npm-help.html index 4e0a516a694..69383c4ea7a 100644 --- a/deps/npm/docs/output/commands/npm-help.html +++ b/deps/npm/docs/output/commands/npm-help.html @@ -186,9 +186,9 @@
-

+

npm-help - @11.20.0 + @11.21.2

Get help on npm
diff --git a/deps/npm/docs/output/commands/npm-init.html b/deps/npm/docs/output/commands/npm-init.html index b0fefd70408..6b9f1fb1f30 100644 --- a/deps/npm/docs/output/commands/npm-init.html +++ b/deps/npm/docs/output/commands/npm-init.html @@ -186,9 +186,9 @@
-

+

npm-init - @11.20.0 + @11.21.2

Create a package.json file
diff --git a/deps/npm/docs/output/commands/npm-install-ci-test.html b/deps/npm/docs/output/commands/npm-install-ci-test.html index 1c62ffb640b..506ef87743d 100644 --- a/deps/npm/docs/output/commands/npm-install-ci-test.html +++ b/deps/npm/docs/output/commands/npm-install-ci-test.html @@ -186,9 +186,9 @@
-

+

npm-install-ci-test - @11.20.0 + @11.21.2

Install a project with a clean slate and run tests
diff --git a/deps/npm/docs/output/commands/npm-install-scripts.html b/deps/npm/docs/output/commands/npm-install-scripts.html index 746b9bcbb9c..494a80c7806 100644 --- a/deps/npm/docs/output/commands/npm-install-scripts.html +++ b/deps/npm/docs/output/commands/npm-install-scripts.html @@ -186,9 +186,9 @@
-

+

npm-install-scripts - @11.20.0 + @11.21.2

Manage install-script approvals for dependencies
diff --git a/deps/npm/docs/output/commands/npm-install-test.html b/deps/npm/docs/output/commands/npm-install-test.html index 17542aae9e7..9c567c396c9 100644 --- a/deps/npm/docs/output/commands/npm-install-test.html +++ b/deps/npm/docs/output/commands/npm-install-test.html @@ -186,9 +186,9 @@
-

+

npm-install-test - @11.20.0 + @11.21.2

Install package(s) and run tests
diff --git a/deps/npm/docs/output/commands/npm-install.html b/deps/npm/docs/output/commands/npm-install.html index 47ac2f05628..5954c822193 100644 --- a/deps/npm/docs/output/commands/npm-install.html +++ b/deps/npm/docs/output/commands/npm-install.html @@ -186,9 +186,9 @@
-

+

npm-install - @11.20.0 + @11.21.2

Install a package
diff --git a/deps/npm/docs/output/commands/npm-link.html b/deps/npm/docs/output/commands/npm-link.html index bb707c9d73b..49656649d22 100644 --- a/deps/npm/docs/output/commands/npm-link.html +++ b/deps/npm/docs/output/commands/npm-link.html @@ -186,9 +186,9 @@
-

+

npm-link - @11.20.0 + @11.21.2

Symlink a package folder
diff --git a/deps/npm/docs/output/commands/npm-ll.html b/deps/npm/docs/output/commands/npm-ll.html index c54f5a6e41e..e56f1fcf0f1 100644 --- a/deps/npm/docs/output/commands/npm-ll.html +++ b/deps/npm/docs/output/commands/npm-ll.html @@ -186,9 +186,9 @@
-

+

npm-ll - @11.20.0 + @11.21.2

List installed packages
diff --git a/deps/npm/docs/output/commands/npm-login.html b/deps/npm/docs/output/commands/npm-login.html index 16703d1ce17..efa0880e352 100644 --- a/deps/npm/docs/output/commands/npm-login.html +++ b/deps/npm/docs/output/commands/npm-login.html @@ -186,9 +186,9 @@
-

+

npm-login - @11.20.0 + @11.21.2

Login to a registry user account
diff --git a/deps/npm/docs/output/commands/npm-logout.html b/deps/npm/docs/output/commands/npm-logout.html index f5712b45634..1d365feb30a 100644 --- a/deps/npm/docs/output/commands/npm-logout.html +++ b/deps/npm/docs/output/commands/npm-logout.html @@ -186,9 +186,9 @@
-

+

npm-logout - @11.20.0 + @11.21.2

Log out of the registry
diff --git a/deps/npm/docs/output/commands/npm-ls.html b/deps/npm/docs/output/commands/npm-ls.html index e09112e22d8..b78078a3366 100644 --- a/deps/npm/docs/output/commands/npm-ls.html +++ b/deps/npm/docs/output/commands/npm-ls.html @@ -186,9 +186,9 @@
-

+

npm-ls - @11.20.0 + @11.21.2

List installed packages
@@ -209,7 +209,7 @@

Description

Positional arguments are name@version-range identifiers, which will limit the results to only the paths to the packages named. Note that nested packages will also show the paths to the specified packages. For example, running npm ls promzard in npm's source tree will show:

-
npm@11.20.0 /path/to/npm
+
npm@11.21.2 /path/to/npm
 └─┬ init-package-json@0.0.4
   └── promzard@0.1.5
 
diff --git a/deps/npm/docs/output/commands/npm-org.html b/deps/npm/docs/output/commands/npm-org.html index 7618c07e555..ec6986644d9 100644 --- a/deps/npm/docs/output/commands/npm-org.html +++ b/deps/npm/docs/output/commands/npm-org.html @@ -186,9 +186,9 @@
-

+

npm-org - @11.20.0 + @11.21.2

Manage orgs
diff --git a/deps/npm/docs/output/commands/npm-outdated.html b/deps/npm/docs/output/commands/npm-outdated.html index b4a7eaf7223..a8285b18ce3 100644 --- a/deps/npm/docs/output/commands/npm-outdated.html +++ b/deps/npm/docs/output/commands/npm-outdated.html @@ -186,9 +186,9 @@
-

+

npm-outdated - @11.20.0 + @11.21.2

Check for outdated packages
diff --git a/deps/npm/docs/output/commands/npm-owner.html b/deps/npm/docs/output/commands/npm-owner.html index 83a0cabfe39..114fcd7ff58 100644 --- a/deps/npm/docs/output/commands/npm-owner.html +++ b/deps/npm/docs/output/commands/npm-owner.html @@ -186,9 +186,9 @@
-

+

npm-owner - @11.20.0 + @11.21.2

Manage package owners
diff --git a/deps/npm/docs/output/commands/npm-pack.html b/deps/npm/docs/output/commands/npm-pack.html index 9acd4c9d20e..d5c2bc9ecc3 100644 --- a/deps/npm/docs/output/commands/npm-pack.html +++ b/deps/npm/docs/output/commands/npm-pack.html @@ -186,9 +186,9 @@
-

+

npm-pack - @11.20.0 + @11.21.2

Create a tarball from a package
diff --git a/deps/npm/docs/output/commands/npm-ping.html b/deps/npm/docs/output/commands/npm-ping.html index 72779cc4512..0ae2afe0521 100644 --- a/deps/npm/docs/output/commands/npm-ping.html +++ b/deps/npm/docs/output/commands/npm-ping.html @@ -186,9 +186,9 @@
-

+

npm-ping - @11.20.0 + @11.21.2

Ping npm registry
diff --git a/deps/npm/docs/output/commands/npm-pkg.html b/deps/npm/docs/output/commands/npm-pkg.html index 7ae9d0b42fb..5ad85163e90 100644 --- a/deps/npm/docs/output/commands/npm-pkg.html +++ b/deps/npm/docs/output/commands/npm-pkg.html @@ -186,9 +186,9 @@
-

+

npm-pkg - @11.20.0 + @11.21.2

Manages your package.json
diff --git a/deps/npm/docs/output/commands/npm-prefix.html b/deps/npm/docs/output/commands/npm-prefix.html index b0043c87e35..60db61a48dc 100644 --- a/deps/npm/docs/output/commands/npm-prefix.html +++ b/deps/npm/docs/output/commands/npm-prefix.html @@ -186,9 +186,9 @@
-

+

npm-prefix - @11.20.0 + @11.21.2

Display prefix
diff --git a/deps/npm/docs/output/commands/npm-profile.html b/deps/npm/docs/output/commands/npm-profile.html index 1183e9ef1f2..663552d02e7 100644 --- a/deps/npm/docs/output/commands/npm-profile.html +++ b/deps/npm/docs/output/commands/npm-profile.html @@ -186,9 +186,9 @@
-

+

npm-profile - @11.20.0 + @11.21.2

Change settings on your registry profile
diff --git a/deps/npm/docs/output/commands/npm-prune.html b/deps/npm/docs/output/commands/npm-prune.html index 97728f904ef..f6a02b96841 100644 --- a/deps/npm/docs/output/commands/npm-prune.html +++ b/deps/npm/docs/output/commands/npm-prune.html @@ -186,9 +186,9 @@
-

+

npm-prune - @11.20.0 + @11.21.2

Remove extraneous packages
diff --git a/deps/npm/docs/output/commands/npm-publish.html b/deps/npm/docs/output/commands/npm-publish.html index 60a816323cd..8b6334352a9 100644 --- a/deps/npm/docs/output/commands/npm-publish.html +++ b/deps/npm/docs/output/commands/npm-publish.html @@ -186,9 +186,9 @@
-

+

npm-publish - @11.20.0 + @11.21.2

Publish a package
diff --git a/deps/npm/docs/output/commands/npm-query.html b/deps/npm/docs/output/commands/npm-query.html index 0211cd7a25e..c58709f7c5b 100644 --- a/deps/npm/docs/output/commands/npm-query.html +++ b/deps/npm/docs/output/commands/npm-query.html @@ -186,9 +186,9 @@
-

+

npm-query - @11.20.0 + @11.21.2

Dependency selector query
diff --git a/deps/npm/docs/output/commands/npm-rebuild.html b/deps/npm/docs/output/commands/npm-rebuild.html index f25623251ff..012f165685d 100644 --- a/deps/npm/docs/output/commands/npm-rebuild.html +++ b/deps/npm/docs/output/commands/npm-rebuild.html @@ -186,9 +186,9 @@
-

+

npm-rebuild - @11.20.0 + @11.21.2

Rebuild a package
diff --git a/deps/npm/docs/output/commands/npm-repo.html b/deps/npm/docs/output/commands/npm-repo.html index 943c5177cbf..eb9f27e5bb9 100644 --- a/deps/npm/docs/output/commands/npm-repo.html +++ b/deps/npm/docs/output/commands/npm-repo.html @@ -186,9 +186,9 @@
-

+

npm-repo - @11.20.0 + @11.21.2

Open package repository page in the browser
diff --git a/deps/npm/docs/output/commands/npm-restart.html b/deps/npm/docs/output/commands/npm-restart.html index fce2e5b294e..f64c839eef1 100644 --- a/deps/npm/docs/output/commands/npm-restart.html +++ b/deps/npm/docs/output/commands/npm-restart.html @@ -186,9 +186,9 @@
-

+

npm-restart - @11.20.0 + @11.21.2

Restart a package
diff --git a/deps/npm/docs/output/commands/npm-root.html b/deps/npm/docs/output/commands/npm-root.html index 88acaa9e893..1c72502851b 100644 --- a/deps/npm/docs/output/commands/npm-root.html +++ b/deps/npm/docs/output/commands/npm-root.html @@ -186,9 +186,9 @@
-

+

npm-root - @11.20.0 + @11.21.2

Display npm root
diff --git a/deps/npm/docs/output/commands/npm-run.html b/deps/npm/docs/output/commands/npm-run.html index ae867e8897f..f5fc445afc2 100644 --- a/deps/npm/docs/output/commands/npm-run.html +++ b/deps/npm/docs/output/commands/npm-run.html @@ -186,9 +186,9 @@
-

+

npm-run - @11.20.0 + @11.21.2

Run arbitrary package scripts
diff --git a/deps/npm/docs/output/commands/npm-sbom.html b/deps/npm/docs/output/commands/npm-sbom.html index ec88592fa2d..16117732078 100644 --- a/deps/npm/docs/output/commands/npm-sbom.html +++ b/deps/npm/docs/output/commands/npm-sbom.html @@ -186,9 +186,9 @@
-

+

npm-sbom - @11.20.0 + @11.21.2

Generate a Software Bill of Materials (SBOM)
diff --git a/deps/npm/docs/output/commands/npm-search.html b/deps/npm/docs/output/commands/npm-search.html index 57b07bf1be8..b81f53e7706 100644 --- a/deps/npm/docs/output/commands/npm-search.html +++ b/deps/npm/docs/output/commands/npm-search.html @@ -186,9 +186,9 @@
-

+

npm-search - @11.20.0 + @11.21.2

Search for packages
diff --git a/deps/npm/docs/output/commands/npm-set.html b/deps/npm/docs/output/commands/npm-set.html index 8ae84be0249..51dbbbeed71 100644 --- a/deps/npm/docs/output/commands/npm-set.html +++ b/deps/npm/docs/output/commands/npm-set.html @@ -186,9 +186,9 @@
-

+

npm-set - @11.20.0 + @11.21.2

Set a value in the npm configuration
diff --git a/deps/npm/docs/output/commands/npm-shrinkwrap.html b/deps/npm/docs/output/commands/npm-shrinkwrap.html index 761e5b79b26..41c7ef2bbf2 100644 --- a/deps/npm/docs/output/commands/npm-shrinkwrap.html +++ b/deps/npm/docs/output/commands/npm-shrinkwrap.html @@ -186,9 +186,9 @@
-

+

npm-shrinkwrap - @11.20.0 + @11.21.2

Lock down dependency versions for publication
diff --git a/deps/npm/docs/output/commands/npm-stage.html b/deps/npm/docs/output/commands/npm-stage.html index 4ffbe2c9cc0..6cf400f9621 100644 --- a/deps/npm/docs/output/commands/npm-stage.html +++ b/deps/npm/docs/output/commands/npm-stage.html @@ -186,9 +186,9 @@
-

+

npm-stage - @11.20.0 + @11.21.2

Stage packages for publishing
@@ -226,6 +226,7 @@

Description

version for that package.
  • You can still publish packages normally while you have staged packages pending.
  • +
  • Staged publishing will allow you to create a new package if it does not exist.
  • You can stage multiple versions of the same package.
  • npm stage publish has parity with npm publish and will respect "private": true in package.json, refusing to stage the package.
  • @@ -235,8 +236,6 @@

    Prerequisites

    • Write permissions on the package: You must have write access to the package you're configuring.
    • -
    • Package must exist: The package you're configuring must already exist -on the npm registry.
    • 2FA enabled on your account: Commands that require 2FA will prompt you to authenticate. If you don't already have 2FA enabled on your account, you must enable it before using these commands.
    • diff --git a/deps/npm/docs/output/commands/npm-star.html b/deps/npm/docs/output/commands/npm-star.html index e627cb613ee..de2c5e677c2 100644 --- a/deps/npm/docs/output/commands/npm-star.html +++ b/deps/npm/docs/output/commands/npm-star.html @@ -186,9 +186,9 @@
      -

      +

      npm-star - @11.20.0 + @11.21.2

      Mark your favorite packages
      diff --git a/deps/npm/docs/output/commands/npm-stars.html b/deps/npm/docs/output/commands/npm-stars.html index d87d857cbeb..39cad8e82e7 100644 --- a/deps/npm/docs/output/commands/npm-stars.html +++ b/deps/npm/docs/output/commands/npm-stars.html @@ -186,9 +186,9 @@
      -

      +

      npm-stars - @11.20.0 + @11.21.2

      View packages marked as favorites
      diff --git a/deps/npm/docs/output/commands/npm-start.html b/deps/npm/docs/output/commands/npm-start.html index d276c536d4e..08a76f247d8 100644 --- a/deps/npm/docs/output/commands/npm-start.html +++ b/deps/npm/docs/output/commands/npm-start.html @@ -186,9 +186,9 @@
      -

      +

      npm-start - @11.20.0 + @11.21.2

      Start a package
      diff --git a/deps/npm/docs/output/commands/npm-stop.html b/deps/npm/docs/output/commands/npm-stop.html index bb7a86fe6e0..ec42d3fe2d1 100644 --- a/deps/npm/docs/output/commands/npm-stop.html +++ b/deps/npm/docs/output/commands/npm-stop.html @@ -186,9 +186,9 @@
      -

      +

      npm-stop - @11.20.0 + @11.21.2

      Stop a package
      diff --git a/deps/npm/docs/output/commands/npm-team.html b/deps/npm/docs/output/commands/npm-team.html index 1d4fe77056d..61767122694 100644 --- a/deps/npm/docs/output/commands/npm-team.html +++ b/deps/npm/docs/output/commands/npm-team.html @@ -186,9 +186,9 @@
      -

      +

      npm-team - @11.20.0 + @11.21.2

      Manage organization teams and team memberships
      diff --git a/deps/npm/docs/output/commands/npm-test.html b/deps/npm/docs/output/commands/npm-test.html index 22662fa99ad..137f2279d0a 100644 --- a/deps/npm/docs/output/commands/npm-test.html +++ b/deps/npm/docs/output/commands/npm-test.html @@ -186,9 +186,9 @@
      -

      +

      npm-test - @11.20.0 + @11.21.2

      Test a package
      diff --git a/deps/npm/docs/output/commands/npm-token.html b/deps/npm/docs/output/commands/npm-token.html index 7329915528d..b499c363b12 100644 --- a/deps/npm/docs/output/commands/npm-token.html +++ b/deps/npm/docs/output/commands/npm-token.html @@ -186,9 +186,9 @@
      -

      +

      npm-token - @11.20.0 + @11.21.2

      Manage your authentication tokens
      diff --git a/deps/npm/docs/output/commands/npm-trust.html b/deps/npm/docs/output/commands/npm-trust.html index 4f2cd57ecd5..c86b8052fc9 100644 --- a/deps/npm/docs/output/commands/npm-trust.html +++ b/deps/npm/docs/output/commands/npm-trust.html @@ -186,9 +186,9 @@
      -

      +

      npm-trust - @11.20.0 + @11.21.2

      Manage trusted publishing relationships between packages and CI/CD providers
      diff --git a/deps/npm/docs/output/commands/npm-undeprecate.html b/deps/npm/docs/output/commands/npm-undeprecate.html index 6bf5195e4f0..7d5033e57bb 100644 --- a/deps/npm/docs/output/commands/npm-undeprecate.html +++ b/deps/npm/docs/output/commands/npm-undeprecate.html @@ -186,9 +186,9 @@
      -

      +

      npm-undeprecate - @11.20.0 + @11.21.2

      Undeprecate a version of a package
      diff --git a/deps/npm/docs/output/commands/npm-uninstall.html b/deps/npm/docs/output/commands/npm-uninstall.html index c7bd23fe17f..c01ed879ceb 100644 --- a/deps/npm/docs/output/commands/npm-uninstall.html +++ b/deps/npm/docs/output/commands/npm-uninstall.html @@ -186,9 +186,9 @@
      -

      +

      npm-uninstall - @11.20.0 + @11.21.2

      Remove a package
      diff --git a/deps/npm/docs/output/commands/npm-unpublish.html b/deps/npm/docs/output/commands/npm-unpublish.html index 80fbe894b17..35143300873 100644 --- a/deps/npm/docs/output/commands/npm-unpublish.html +++ b/deps/npm/docs/output/commands/npm-unpublish.html @@ -186,9 +186,9 @@
      -

      +

      npm-unpublish - @11.20.0 + @11.21.2

      Remove a package from the registry
      diff --git a/deps/npm/docs/output/commands/npm-unstar.html b/deps/npm/docs/output/commands/npm-unstar.html index f061163d223..7143910a99e 100644 --- a/deps/npm/docs/output/commands/npm-unstar.html +++ b/deps/npm/docs/output/commands/npm-unstar.html @@ -186,9 +186,9 @@
      -

      +

      npm-unstar - @11.20.0 + @11.21.2

      Remove an item from your favorite packages
      diff --git a/deps/npm/docs/output/commands/npm-update.html b/deps/npm/docs/output/commands/npm-update.html index 6d8f260b7be..c0ed8d2107c 100644 --- a/deps/npm/docs/output/commands/npm-update.html +++ b/deps/npm/docs/output/commands/npm-update.html @@ -186,9 +186,9 @@
      -

      +

      npm-update - @11.20.0 + @11.21.2

      Update packages
      diff --git a/deps/npm/docs/output/commands/npm-version.html b/deps/npm/docs/output/commands/npm-version.html index 22667d199ee..58cfc01644c 100644 --- a/deps/npm/docs/output/commands/npm-version.html +++ b/deps/npm/docs/output/commands/npm-version.html @@ -186,9 +186,9 @@
      -

      +

      npm-version - @11.20.0 + @11.21.2

      Bump a package version
      diff --git a/deps/npm/docs/output/commands/npm-view.html b/deps/npm/docs/output/commands/npm-view.html index d6892fd94d5..510ffb92a0e 100644 --- a/deps/npm/docs/output/commands/npm-view.html +++ b/deps/npm/docs/output/commands/npm-view.html @@ -186,9 +186,9 @@
      -

      +

      npm-view - @11.20.0 + @11.21.2

      View registry info
      diff --git a/deps/npm/docs/output/commands/npm-whoami.html b/deps/npm/docs/output/commands/npm-whoami.html index de1960ac172..102c605edce 100644 --- a/deps/npm/docs/output/commands/npm-whoami.html +++ b/deps/npm/docs/output/commands/npm-whoami.html @@ -186,9 +186,9 @@
      -

      +

      npm-whoami - @11.20.0 + @11.21.2

      Display npm username
      diff --git a/deps/npm/docs/output/commands/npm.html b/deps/npm/docs/output/commands/npm.html index 0f03bc8548e..7f63a2be16d 100644 --- a/deps/npm/docs/output/commands/npm.html +++ b/deps/npm/docs/output/commands/npm.html @@ -186,9 +186,9 @@
      -

      +

      npm - @11.20.0 + @11.21.2

      javascript package manager
      @@ -203,7 +203,7 @@

      Table of contents

    Note: This command is unaware of workspaces.

    Version

    -

    11.20.0

    +

    11.21.2

    Description

    npm is the package manager for the Node JavaScript platform. It puts modules in place so that node can find them, and manages dependency conflicts intelligently.

    diff --git a/deps/npm/docs/output/commands/npx.html b/deps/npm/docs/output/commands/npx.html index 80673580a6f..b3b0e89ed19 100644 --- a/deps/npm/docs/output/commands/npx.html +++ b/deps/npm/docs/output/commands/npx.html @@ -186,9 +186,9 @@
    -

    +

    npx - @11.20.0 + @11.21.2

    Run a command from a local or remote npm package
    diff --git a/deps/npm/docs/output/configuring-npm/folders.html b/deps/npm/docs/output/configuring-npm/folders.html index edf68a7fda4..c5a561062e5 100644 --- a/deps/npm/docs/output/configuring-npm/folders.html +++ b/deps/npm/docs/output/configuring-npm/folders.html @@ -186,9 +186,9 @@
    -

    +

    Folders - @11.20.0 + @11.21.2

    Folder structures used by npm
    diff --git a/deps/npm/docs/output/configuring-npm/install.html b/deps/npm/docs/output/configuring-npm/install.html index 8356ea4bc55..e3d7cf17d6a 100644 --- a/deps/npm/docs/output/configuring-npm/install.html +++ b/deps/npm/docs/output/configuring-npm/install.html @@ -186,9 +186,9 @@
    -

    +

    Install - @11.20.0 + @11.21.2

    Download and install node and npm
    diff --git a/deps/npm/docs/output/configuring-npm/npm-global.html b/deps/npm/docs/output/configuring-npm/npm-global.html index edf68a7fda4..c5a561062e5 100644 --- a/deps/npm/docs/output/configuring-npm/npm-global.html +++ b/deps/npm/docs/output/configuring-npm/npm-global.html @@ -186,9 +186,9 @@
    -

    +

    Folders - @11.20.0 + @11.21.2

    Folder structures used by npm
    diff --git a/deps/npm/docs/output/configuring-npm/npm-json.html b/deps/npm/docs/output/configuring-npm/npm-json.html index 70ef8ced0fc..517bbe8a44a 100644 --- a/deps/npm/docs/output/configuring-npm/npm-json.html +++ b/deps/npm/docs/output/configuring-npm/npm-json.html @@ -186,9 +186,9 @@
    -

    +

    package.json - @11.20.0 + @11.21.2

    Specifics of npm's package.json handling
    diff --git a/deps/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html b/deps/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html index eb90cfd59de..ba197a3ed14 100644 --- a/deps/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html +++ b/deps/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html @@ -186,9 +186,9 @@
    -

    +

    npm-shrinkwrap.json - @11.20.0 + @11.21.2

    A publishable lockfile
    diff --git a/deps/npm/docs/output/configuring-npm/npmrc.html b/deps/npm/docs/output/configuring-npm/npmrc.html index 462664c7325..ac82e59af63 100644 --- a/deps/npm/docs/output/configuring-npm/npmrc.html +++ b/deps/npm/docs/output/configuring-npm/npmrc.html @@ -186,9 +186,9 @@
    -

    +

    .npmrc - @11.20.0 + @11.21.2

    The npm config files
    diff --git a/deps/npm/docs/output/configuring-npm/package-json.html b/deps/npm/docs/output/configuring-npm/package-json.html index 70ef8ced0fc..517bbe8a44a 100644 --- a/deps/npm/docs/output/configuring-npm/package-json.html +++ b/deps/npm/docs/output/configuring-npm/package-json.html @@ -186,9 +186,9 @@
    -

    +

    package.json - @11.20.0 + @11.21.2

    Specifics of npm's package.json handling
    diff --git a/deps/npm/docs/output/configuring-npm/package-lock-json.html b/deps/npm/docs/output/configuring-npm/package-lock-json.html index 8022b532fa4..0cb259d286a 100644 --- a/deps/npm/docs/output/configuring-npm/package-lock-json.html +++ b/deps/npm/docs/output/configuring-npm/package-lock-json.html @@ -186,9 +186,9 @@
    -

    +

    package-lock.json - @11.20.0 + @11.21.2

    A manifestation of the manifest
    diff --git a/deps/npm/docs/output/using-npm/config.html b/deps/npm/docs/output/using-npm/config.html index 457b0d079bd..0d6ec849317 100644 --- a/deps/npm/docs/output/using-npm/config.html +++ b/deps/npm/docs/output/using-npm/config.html @@ -186,9 +186,9 @@
    -

    +

    Config - @11.20.0 + @11.21.2

    About npm configuration
    diff --git a/deps/npm/docs/output/using-npm/dependency-selectors.html b/deps/npm/docs/output/using-npm/dependency-selectors.html index baa45c36cbb..94dbed94836 100644 --- a/deps/npm/docs/output/using-npm/dependency-selectors.html +++ b/deps/npm/docs/output/using-npm/dependency-selectors.html @@ -186,9 +186,9 @@
    -

    +

    Dependency Selectors - @11.20.0 + @11.21.2

    Dependency Selector Syntax & Querying
    diff --git a/deps/npm/docs/output/using-npm/developers.html b/deps/npm/docs/output/using-npm/developers.html index 27c9b109d8e..d9774e68bff 100644 --- a/deps/npm/docs/output/using-npm/developers.html +++ b/deps/npm/docs/output/using-npm/developers.html @@ -186,9 +186,9 @@
    -

    +

    Developers - @11.20.0 + @11.21.2

    Developer guide
    diff --git a/deps/npm/docs/output/using-npm/logging.html b/deps/npm/docs/output/using-npm/logging.html index 08314392eea..0d191c03717 100644 --- a/deps/npm/docs/output/using-npm/logging.html +++ b/deps/npm/docs/output/using-npm/logging.html @@ -186,9 +186,9 @@
    -

    +

    Logging - @11.20.0 + @11.21.2

    Why, What & How we Log
    diff --git a/deps/npm/docs/output/using-npm/orgs.html b/deps/npm/docs/output/using-npm/orgs.html index 242620475df..20f2cb67cd0 100644 --- a/deps/npm/docs/output/using-npm/orgs.html +++ b/deps/npm/docs/output/using-npm/orgs.html @@ -186,9 +186,9 @@
    -

    +

    Organizations - @11.20.0 + @11.21.2

    Working with teams & organizations
    diff --git a/deps/npm/docs/output/using-npm/package-spec.html b/deps/npm/docs/output/using-npm/package-spec.html index b7adbecf2d5..0ba71462d0f 100644 --- a/deps/npm/docs/output/using-npm/package-spec.html +++ b/deps/npm/docs/output/using-npm/package-spec.html @@ -186,9 +186,9 @@
    -

    +

    Package spec - @11.20.0 + @11.21.2

    Package name specifier
    diff --git a/deps/npm/docs/output/using-npm/registry.html b/deps/npm/docs/output/using-npm/registry.html index 4da60fd44fa..54d4f433e72 100644 --- a/deps/npm/docs/output/using-npm/registry.html +++ b/deps/npm/docs/output/using-npm/registry.html @@ -186,9 +186,9 @@
    -

    +

    Registry - @11.20.0 + @11.21.2

    The JavaScript Package Registry
    diff --git a/deps/npm/docs/output/using-npm/removal.html b/deps/npm/docs/output/using-npm/removal.html index 26f86fd3921..b058622923a 100644 --- a/deps/npm/docs/output/using-npm/removal.html +++ b/deps/npm/docs/output/using-npm/removal.html @@ -186,9 +186,9 @@
    -

    +

    Removal - @11.20.0 + @11.21.2

    Cleaning the slate
    diff --git a/deps/npm/docs/output/using-npm/scope.html b/deps/npm/docs/output/using-npm/scope.html index fa268bacf0e..81dcafdb276 100644 --- a/deps/npm/docs/output/using-npm/scope.html +++ b/deps/npm/docs/output/using-npm/scope.html @@ -186,9 +186,9 @@
    -

    +

    Scope - @11.20.0 + @11.21.2

    Scoped packages
    diff --git a/deps/npm/docs/output/using-npm/scripts.html b/deps/npm/docs/output/using-npm/scripts.html index bc7875c2368..c0d35eceb43 100644 --- a/deps/npm/docs/output/using-npm/scripts.html +++ b/deps/npm/docs/output/using-npm/scripts.html @@ -186,9 +186,9 @@
    -

    +

    Scripts - @11.20.0 + @11.21.2

    How npm handles the "scripts" field
    diff --git a/deps/npm/docs/output/using-npm/workspaces.html b/deps/npm/docs/output/using-npm/workspaces.html index 412a16b9f03..c5ce10d261a 100644 --- a/deps/npm/docs/output/using-npm/workspaces.html +++ b/deps/npm/docs/output/using-npm/workspaces.html @@ -186,9 +186,9 @@
    -

    +

    Workspaces - @11.20.0 + @11.21.2

    Working with workspaces
    diff --git a/deps/npm/lib/cli/entry.js b/deps/npm/lib/cli/entry.js index 962c62a5766..fb15683f48e 100644 --- a/deps/npm/lib/cli/entry.js +++ b/deps/npm/lib/cli/entry.js @@ -26,7 +26,7 @@ module.exports = async (process, validateEngines) => { // It is now safe to log a warning if they are using a version of node that is not going to fail on syntax errors but is still unsupported and untested and might not work reliably. // This is safe to use the logger now which we want since this will show up in the error log too. - if (!satisfies(validateEngines.node, validateEngines.engines)) { + if (!satisfies(validateEngines.node, validateEngines.engines, { includePrerelease: true })) { log.warn('cli', validateEngines.unsupportedMessage) } diff --git a/deps/npm/lib/commands/dist-tag.js b/deps/npm/lib/commands/dist-tag.js index 4b51e839d78..fe4b4c8e809 100644 --- a/deps/npm/lib/commands/dist-tag.js +++ b/deps/npm/lib/commands/dist-tag.js @@ -3,6 +3,7 @@ const npmFetch = require('npm-registry-fetch') const semver = require('semver') const { log, output } = require('proc-log') const { otplease } = require('../utils/auth.js') +const { oidc } = require('../utils/oidc.js') const pkgJson = require('@npmcli/package-json') const BaseCommand = require('../base-cmd.js') @@ -101,6 +102,7 @@ class DistTag extends BaseCommand { throw new Error('Tag name must not be a valid SemVer range: ' + t) } + await this.#oidc(spec, opts) const tags = await this.fetchTags(spec, opts) if (tags[t] === version) { log.warn('dist-tag add', t, 'is already set to version', version) @@ -130,6 +132,7 @@ class DistTag extends BaseCommand { throw this.usageError() } + await this.#oidc(spec, opts) const tags = await this.fetchTags(spec, opts) if (!tags[tag]) { log.info('dist-tag del', tag, 'is not a dist-tag on', spec.name) @@ -163,6 +166,7 @@ class DistTag extends BaseCommand { spec = npa(spec) try { + await this.#oidc(spec, opts) const tags = await this.fetchTags(spec, opts) const msg = Object.keys(tags).map(k => `${k}: ${tags[k]}`).sort().join('\n') @@ -202,6 +206,16 @@ class DistTag extends BaseCommand { return data } + + async #oidc (spec, opts) { + const registry = npmFetch.pickRegistry(spec, opts) + await oidc({ + packageName: spec.name, + registry, + opts, + config: this.npm.config, + }) + } } module.exports = DistTag diff --git a/deps/npm/lib/commands/publish.js b/deps/npm/lib/commands/publish.js index aea01cc10e7..dcc6a8be8c2 100644 --- a/deps/npm/lib/commands/publish.js +++ b/deps/npm/lib/commands/publish.js @@ -144,7 +144,13 @@ class Publish extends BaseCommand { const registry = npmFetch.pickRegistry(resolved, opts) - await oidc({ packageName: manifest.name, registry, opts, config: this.npm.config }) + await oidc({ + packageName: manifest.name, + registry, + opts, + config: this.npm.config, + enableProvenanceAutoConfiguration: true, + }) const creds = this.npm.config.getCredentialsByURI(registry) const noCreds = !(creds.token || creds.username || creds.certfile && creds.keyfile) diff --git a/deps/npm/lib/utils/allow-scripts-cmd.js b/deps/npm/lib/utils/allow-scripts-cmd.js index 315b7b0b4fb..cbcbe4df29a 100644 --- a/deps/npm/lib/utils/allow-scripts-cmd.js +++ b/deps/npm/lib/utils/allow-scripts-cmd.js @@ -221,15 +221,13 @@ class AllowScriptsCmd extends BaseCommand { // edge name. A version or range on the arg narrows the match to installed // versions that satisfy it. Bundled deps are excluded for the same reason // as --all. Args that match nothing are returned in `unmatched`. + // Links stay matchable by their edge name (e.g. `foo` -> `file:./local-foo`), but each match is dereferenced to its target and deduplicated, since scripts only run on the target and keying policy off a Link's resolved spec writes store paths under install-strategy=linked (npm/cli#9939). const matched = [] const unmatched = [] for (const arg of args) { const { name: wantName, range } = parsePositional(arg) - const found = [] + const found = new Set() for (const node of arb.actualTree.inventory.values()) { - if (node.isProjectRoot || node.isWorkspace || node.inBundle) { - continue - } const { name, version } = trustedDisplay(node) if (!name || name !== wantName) { continue @@ -237,9 +235,13 @@ class AllowScriptsCmd extends BaseCommand { if (range && (!version || !semver.satisfies(version, range, { loose: true }))) { continue } - found.push(node) + const target = node.isLink ? node.target : node + if (!target || target.isProjectRoot || target.isWorkspace || target.inBundle) { + continue + } + found.add(target) } - if (found.length === 0) { + if (found.size === 0) { unmatched.push(arg) } else { matched.push(...found) diff --git a/deps/npm/lib/utils/allow-scripts-prune.js b/deps/npm/lib/utils/allow-scripts-prune.js index 1111b45d9ca..264ad6dcc96 100644 --- a/deps/npm/lib/utils/allow-scripts-prune.js +++ b/deps/npm/lib/utils/allow-scripts-prune.js @@ -29,7 +29,8 @@ const classifyUnusedEntries = (allowScripts, nodes) => { continue } - const matching = nodes.filter(({ node }) => matches(node, key)) + // Pass deny intent so an unverifiable version fails closed: an active versioned deny must not be classified as unused while its broad allow survives. + const matching = nodes.filter(({ node }) => matches(node, key, value === false)) if (matching.length === 0) { removed.push({ key, value, reason: 'not-installed' }) continue diff --git a/deps/npm/lib/utils/oidc.js b/deps/npm/lib/utils/oidc.js index 203aaf3143a..7f18170b1b0 100644 --- a/deps/npm/lib/utils/oidc.js +++ b/deps/npm/lib/utils/oidc.js @@ -5,6 +5,62 @@ const fetch = require('make-fetch-happen') const npa = require('npm-package-arg') const libaccess = require('libnpmaccess') +/** + * Caches the runtime state of the active OIDC token exchange + * so it can be cleared on subsequent OIDC attempts in workflows + * that run OIDC multiple times within one runtime execution, + * preventing the previous exchange token from being reused. + */ +let activeExchangeRecord + +const setOidcToken = ({ config, opts, authTokenKey, token }) => { + activeExchangeRecord = { + config, + authTokenKey, + token, + previousCliToken: config.get(authTokenKey, 'cli'), + opts, + previousOptsToken: opts[authTokenKey], + } + opts[authTokenKey] = token + config.set(authTokenKey, token, 'cli') + log.verbose('oidc', 'Successfully retrieved and set token') +} + +const clearOidcToken = ({ config, opts }) => { + if (!activeExchangeRecord) { + return + } + + const { + config: previousConfig, + authTokenKey, + token, + previousCliToken, + opts: previousOpts, + previousOptsToken, + } = activeExchangeRecord + if (previousConfig.get(authTokenKey, 'cli') === token) { + if (previousCliToken === undefined) { + previousConfig.delete(authTokenKey, 'cli') + } else { + previousConfig.set(authTokenKey, previousCliToken, 'cli') + } + } + for (const requestOpts of new Set([previousOpts, opts])) { + if (requestOpts[authTokenKey] === token) { + const fallback = requestOpts === previousOpts ? previousOptsToken : config.get(authTokenKey) + if (fallback === undefined) { + delete requestOpts[authTokenKey] + } else { + requestOpts[authTokenKey] = fallback + } + } + } + activeExchangeRecord = undefined + log.verbose('oidc', 'Cleared previous exchange token') +} + /** * Handles OpenID Connect (OIDC) token retrieval and exchange for CI environments. * @@ -13,18 +69,35 @@ const libaccess = require('libnpmaccess') * * This function is intended to never throw, as it mutates the state of the `opts` and `config` objects on success. * OIDC is always an optional feature, and the function should not throw if OIDC is not configured by the registry. + * Before each attempt, it restores credentials replaced by the previous exchange so package-specific tokens are never used as fallback credentials. * * @see https://github.com/watson/ci-info for CI environment detection. * @see https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect for GitHub Actions OIDC. * @see https://circleci.com/docs/openid-connect-tokens/ for CircleCI OIDC. */ -async function oidc ({ packageName, registry, opts, config }) { +async function oidc ({ + // Selects the package-specific npm token exchange endpoint. + packageName, + // Determines the OIDC audience, exchange host, and registry-scoped auth key. + registry, + // Mutable request options for the current command, often called flatOptions. + // The exchanged token is added here so subsequent registry requests use it immediately. + opts, + // npm's live configuration state. This is also updated so credential lookups see the token. + config, + // Publish and stage publish can infer provenance from trusted-publishing claims and package + // visibility so users do not need to set --provenance. Other commands that use OIDC, such as + // npm dist-tag, only need token exchange and must not enable unrelated publish provenance. + enableProvenanceAutoConfiguration = false, +}) { /* * This code should never run when people try to publish locally on their machines. * It is designed to execute only in Continuous Integration (CI) environments. */ try { + clearOidcToken({ config, opts }) + if (!( /** @see https://github.com/watson/ci-info/blob/v4.2.0/vendors.json#L152 */ ciInfo.GITHUB_ACTIONS || @@ -133,13 +206,17 @@ async function oidc ({ packageName, registry, opts, config }) { } /* - * The "opts" object is a clone of npm.flatOptions and is passed through the `publish` command, eventually reaching `otplease`. - * To ensure the token is accessible during the publishing process, it must be directly attached to the `opts` object. - * Additionally, the token is required by the "live" configuration or getters within `config`. + * `opts` is derived from npm.flatOptions and carried through the current command. + * Publish and dist-tag pass it to later registry requests, including mutations wrapped by + * `otplease`, so the exchanged token must be attached directly to this object. + * The non-persistable cli layer also makes the token available to credential lookups without + * modifying any file-backed configuration. */ - opts[authTokenKey] = response.token - config.set(authTokenKey, response.token, 'user') - log.verbose('oidc', `Successfully retrieved and set token`) + setOidcToken({ config, opts, authTokenKey, token: response.token }) + + if (!enableProvenanceAutoConfiguration) { + return undefined + } try { const isDefaultProvenance = config.isDefault('provenance') diff --git a/deps/npm/man/man1/npm-access.1 b/deps/npm/man/man1/npm-access.1 index ce8b4b2347e..ceb3f6c17fa 100644 --- a/deps/npm/man/man1/npm-access.1 +++ b/deps/npm/man/man1/npm-access.1 @@ -1,4 +1,4 @@ -.TH "NPM-ACCESS" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-ACCESS" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-access\fR - Set access level on published packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-adduser.1 b/deps/npm/man/man1/npm-adduser.1 index 99c40da9021..cf798639583 100644 --- a/deps/npm/man/man1/npm-adduser.1 +++ b/deps/npm/man/man1/npm-adduser.1 @@ -1,4 +1,4 @@ -.TH "NPM-ADDUSER" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-ADDUSER" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-adduser\fR - Add a registry user account .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-approve-scripts.1 b/deps/npm/man/man1/npm-approve-scripts.1 index ea3b8559af3..dedc97ea43f 100644 --- a/deps/npm/man/man1/npm-approve-scripts.1 +++ b/deps/npm/man/man1/npm-approve-scripts.1 @@ -1,4 +1,4 @@ -.TH "NPM-APPROVE-SCRIPTS" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-APPROVE-SCRIPTS" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-approve-scripts\fR - Approve install scripts for specific dependencies .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-audit.1 b/deps/npm/man/man1/npm-audit.1 index d66317be2a6..f849ab67df2 100644 --- a/deps/npm/man/man1/npm-audit.1 +++ b/deps/npm/man/man1/npm-audit.1 @@ -1,4 +1,4 @@ -.TH "NPM-AUDIT" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-AUDIT" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-audit\fR - Run a security audit .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-bugs.1 b/deps/npm/man/man1/npm-bugs.1 index be2e0ec4073..666d56f830a 100644 --- a/deps/npm/man/man1/npm-bugs.1 +++ b/deps/npm/man/man1/npm-bugs.1 @@ -1,4 +1,4 @@ -.TH "NPM-BUGS" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-BUGS" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-bugs\fR - Report bugs for a package in a web browser .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-cache.1 b/deps/npm/man/man1/npm-cache.1 index 08a904d5e7a..e31c02d0197 100644 --- a/deps/npm/man/man1/npm-cache.1 +++ b/deps/npm/man/man1/npm-cache.1 @@ -1,4 +1,4 @@ -.TH "NPM-CACHE" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-CACHE" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-cache\fR - Manipulates packages cache .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-ci.1 b/deps/npm/man/man1/npm-ci.1 index b0611e9a121..9c9d0a3fb1a 100644 --- a/deps/npm/man/man1/npm-ci.1 +++ b/deps/npm/man/man1/npm-ci.1 @@ -1,4 +1,4 @@ -.TH "NPM-CI" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-CI" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-ci\fR - Clean install a project .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-completion.1 b/deps/npm/man/man1/npm-completion.1 index b84d2dc1fd6..efd483b409d 100644 --- a/deps/npm/man/man1/npm-completion.1 +++ b/deps/npm/man/man1/npm-completion.1 @@ -1,4 +1,4 @@ -.TH "NPM-COMPLETION" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-COMPLETION" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-completion\fR - Tab Completion for npm .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-config.1 b/deps/npm/man/man1/npm-config.1 index 2bbcce24963..976fc2f6d8b 100644 --- a/deps/npm/man/man1/npm-config.1 +++ b/deps/npm/man/man1/npm-config.1 @@ -1,4 +1,4 @@ -.TH "NPM-CONFIG" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-CONFIG" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-config\fR - Manage the npm configuration files .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-dedupe.1 b/deps/npm/man/man1/npm-dedupe.1 index f7f3cfc935f..a49b48681de 100644 --- a/deps/npm/man/man1/npm-dedupe.1 +++ b/deps/npm/man/man1/npm-dedupe.1 @@ -1,4 +1,4 @@ -.TH "NPM-DEDUPE" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-DEDUPE" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-dedupe\fR - Reduce duplication in the package tree .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-deny-scripts.1 b/deps/npm/man/man1/npm-deny-scripts.1 index 0477e41503b..826b8ca1333 100644 --- a/deps/npm/man/man1/npm-deny-scripts.1 +++ b/deps/npm/man/man1/npm-deny-scripts.1 @@ -1,4 +1,4 @@ -.TH "NPM-DENY-SCRIPTS" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-DENY-SCRIPTS" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-deny-scripts\fR - Deny install scripts for specific dependencies .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-deprecate.1 b/deps/npm/man/man1/npm-deprecate.1 index 4caab6c3ad9..0aa94ec5898 100644 --- a/deps/npm/man/man1/npm-deprecate.1 +++ b/deps/npm/man/man1/npm-deprecate.1 @@ -1,4 +1,4 @@ -.TH "NPM-DEPRECATE" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-DEPRECATE" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-deprecate\fR - Deprecate a version of a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-diff.1 b/deps/npm/man/man1/npm-diff.1 index e2122d844c6..777fe47a026 100644 --- a/deps/npm/man/man1/npm-diff.1 +++ b/deps/npm/man/man1/npm-diff.1 @@ -1,4 +1,4 @@ -.TH "NPM-DIFF" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-DIFF" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-diff\fR - The registry diff command .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-dist-tag.1 b/deps/npm/man/man1/npm-dist-tag.1 index 7a85fbab68d..37c86f432d9 100644 --- a/deps/npm/man/man1/npm-dist-tag.1 +++ b/deps/npm/man/man1/npm-dist-tag.1 @@ -1,4 +1,4 @@ -.TH "NPM-DIST-TAG" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-DIST-TAG" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-dist-tag\fR - Modify package distribution tags .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-docs.1 b/deps/npm/man/man1/npm-docs.1 index ef586a86d27..50e31e8735a 100644 --- a/deps/npm/man/man1/npm-docs.1 +++ b/deps/npm/man/man1/npm-docs.1 @@ -1,4 +1,4 @@ -.TH "NPM-DOCS" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-DOCS" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-docs\fR - Open documentation for a package in a web browser .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-doctor.1 b/deps/npm/man/man1/npm-doctor.1 index 05c5c4d9dcc..8ef2fa2ad59 100644 --- a/deps/npm/man/man1/npm-doctor.1 +++ b/deps/npm/man/man1/npm-doctor.1 @@ -1,4 +1,4 @@ -.TH "NPM-DOCTOR" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-DOCTOR" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-doctor\fR - Check the health of your npm environment .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-edit.1 b/deps/npm/man/man1/npm-edit.1 index 7bf09de5223..8f1a7dfcb89 100644 --- a/deps/npm/man/man1/npm-edit.1 +++ b/deps/npm/man/man1/npm-edit.1 @@ -1,4 +1,4 @@ -.TH "NPM-EDIT" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-EDIT" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-edit\fR - Edit an installed package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-exec.1 b/deps/npm/man/man1/npm-exec.1 index b3132e062c7..dc36459b4d5 100644 --- a/deps/npm/man/man1/npm-exec.1 +++ b/deps/npm/man/man1/npm-exec.1 @@ -1,4 +1,4 @@ -.TH "NPM-EXEC" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-EXEC" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-exec\fR - Run a command from a local or remote npm package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-explain.1 b/deps/npm/man/man1/npm-explain.1 index 1abb4a0e94d..069fcd70580 100644 --- a/deps/npm/man/man1/npm-explain.1 +++ b/deps/npm/man/man1/npm-explain.1 @@ -1,4 +1,4 @@ -.TH "NPM-EXPLAIN" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-EXPLAIN" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-explain\fR - Explain installed packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-explore.1 b/deps/npm/man/man1/npm-explore.1 index fc45ae27ae2..341994714fa 100644 --- a/deps/npm/man/man1/npm-explore.1 +++ b/deps/npm/man/man1/npm-explore.1 @@ -1,4 +1,4 @@ -.TH "NPM-EXPLORE" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-EXPLORE" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-explore\fR - Browse an installed package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-find-dupes.1 b/deps/npm/man/man1/npm-find-dupes.1 index 5804305f900..bafc5d9f549 100644 --- a/deps/npm/man/man1/npm-find-dupes.1 +++ b/deps/npm/man/man1/npm-find-dupes.1 @@ -1,4 +1,4 @@ -.TH "NPM-FIND-DUPES" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-FIND-DUPES" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-find-dupes\fR - Find duplication in the package tree .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-fund.1 b/deps/npm/man/man1/npm-fund.1 index 10eca78547a..a3c47fad3b8 100644 --- a/deps/npm/man/man1/npm-fund.1 +++ b/deps/npm/man/man1/npm-fund.1 @@ -1,4 +1,4 @@ -.TH "NPM-FUND" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-FUND" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-fund\fR - Retrieve funding information .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-get.1 b/deps/npm/man/man1/npm-get.1 index b67dfc6ed7e..1e3cb0119c9 100644 --- a/deps/npm/man/man1/npm-get.1 +++ b/deps/npm/man/man1/npm-get.1 @@ -1,4 +1,4 @@ -.TH "NPM-GET" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-GET" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-get\fR - Get a value from the npm configuration .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-help-search.1 b/deps/npm/man/man1/npm-help-search.1 index 44c464dc229..10eac50e9bb 100644 --- a/deps/npm/man/man1/npm-help-search.1 +++ b/deps/npm/man/man1/npm-help-search.1 @@ -1,4 +1,4 @@ -.TH "NPM-HELP-SEARCH" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-HELP-SEARCH" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-help-search\fR - Search npm help documentation .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-help.1 b/deps/npm/man/man1/npm-help.1 index 6c0dac1a9b9..221b0526e37 100644 --- a/deps/npm/man/man1/npm-help.1 +++ b/deps/npm/man/man1/npm-help.1 @@ -1,4 +1,4 @@ -.TH "NPM-HELP" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-HELP" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-help\fR - Get help on npm .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-init.1 b/deps/npm/man/man1/npm-init.1 index 3774607b93d..73ebb727ff5 100644 --- a/deps/npm/man/man1/npm-init.1 +++ b/deps/npm/man/man1/npm-init.1 @@ -1,4 +1,4 @@ -.TH "NPM-INIT" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-INIT" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-init\fR - Create a package.json file .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-install-ci-test.1 b/deps/npm/man/man1/npm-install-ci-test.1 index 0725d13e7a9..01ea550da99 100644 --- a/deps/npm/man/man1/npm-install-ci-test.1 +++ b/deps/npm/man/man1/npm-install-ci-test.1 @@ -1,4 +1,4 @@ -.TH "NPM-INSTALL-CI-TEST" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-INSTALL-CI-TEST" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-install-ci-test\fR - Install a project with a clean slate and run tests .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-install-scripts.1 b/deps/npm/man/man1/npm-install-scripts.1 index 9d4076cd8fd..1de6e2c71ef 100644 --- a/deps/npm/man/man1/npm-install-scripts.1 +++ b/deps/npm/man/man1/npm-install-scripts.1 @@ -1,4 +1,4 @@ -.TH "NPM-INSTALL-SCRIPTS" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-INSTALL-SCRIPTS" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-install-scripts\fR - Manage install-script approvals for dependencies .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-install-test.1 b/deps/npm/man/man1/npm-install-test.1 index f552f5d3935..fb7f6ad652d 100644 --- a/deps/npm/man/man1/npm-install-test.1 +++ b/deps/npm/man/man1/npm-install-test.1 @@ -1,4 +1,4 @@ -.TH "NPM-INSTALL-TEST" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-INSTALL-TEST" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-install-test\fR - Install package(s) and run tests .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-install.1 b/deps/npm/man/man1/npm-install.1 index 06e7759a10f..6e6b595c5bb 100644 --- a/deps/npm/man/man1/npm-install.1 +++ b/deps/npm/man/man1/npm-install.1 @@ -1,4 +1,4 @@ -.TH "NPM-INSTALL" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-INSTALL" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-install\fR - Install a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-link.1 b/deps/npm/man/man1/npm-link.1 index 9e03ea12635..9c884b32fbf 100644 --- a/deps/npm/man/man1/npm-link.1 +++ b/deps/npm/man/man1/npm-link.1 @@ -1,4 +1,4 @@ -.TH "NPM-LINK" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-LINK" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-link\fR - Symlink a package folder .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-ll.1 b/deps/npm/man/man1/npm-ll.1 index 8fd1de7651e..a5794eeb02d 100644 --- a/deps/npm/man/man1/npm-ll.1 +++ b/deps/npm/man/man1/npm-ll.1 @@ -1,4 +1,4 @@ -.TH "NPM-LL" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-LL" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-ll\fR - List installed packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-login.1 b/deps/npm/man/man1/npm-login.1 index aef0a9f0387..00f30771b59 100644 --- a/deps/npm/man/man1/npm-login.1 +++ b/deps/npm/man/man1/npm-login.1 @@ -1,4 +1,4 @@ -.TH "NPM-LOGIN" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-LOGIN" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-login\fR - Login to a registry user account .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-logout.1 b/deps/npm/man/man1/npm-logout.1 index 941e7fdc0a5..3e7200cc1e9 100644 --- a/deps/npm/man/man1/npm-logout.1 +++ b/deps/npm/man/man1/npm-logout.1 @@ -1,4 +1,4 @@ -.TH "NPM-LOGOUT" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-LOGOUT" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-logout\fR - Log out of the registry .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-ls.1 b/deps/npm/man/man1/npm-ls.1 index 96705c0c5aa..dc12c29f1a0 100644 --- a/deps/npm/man/man1/npm-ls.1 +++ b/deps/npm/man/man1/npm-ls.1 @@ -1,4 +1,4 @@ -.TH "NPM-LS" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-LS" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-ls\fR - List installed packages .SS "Synopsis" @@ -20,7 +20,7 @@ Positional arguments are \fBname@version-range\fR identifiers, which will limit .P .RS 2 .nf -npm@11.20.0 /path/to/npm +npm@11.21.2 /path/to/npm └─┬ init-package-json@0.0.4 └── promzard@0.1.5 .fi diff --git a/deps/npm/man/man1/npm-org.1 b/deps/npm/man/man1/npm-org.1 index 38b8cdcf245..58bea33b5e2 100644 --- a/deps/npm/man/man1/npm-org.1 +++ b/deps/npm/man/man1/npm-org.1 @@ -1,4 +1,4 @@ -.TH "NPM-ORG" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-ORG" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-org\fR - Manage orgs .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-outdated.1 b/deps/npm/man/man1/npm-outdated.1 index 2995ee08434..d34c347088f 100644 --- a/deps/npm/man/man1/npm-outdated.1 +++ b/deps/npm/man/man1/npm-outdated.1 @@ -1,4 +1,4 @@ -.TH "NPM-OUTDATED" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-OUTDATED" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-outdated\fR - Check for outdated packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-owner.1 b/deps/npm/man/man1/npm-owner.1 index a1644110b92..d5d234979a8 100644 --- a/deps/npm/man/man1/npm-owner.1 +++ b/deps/npm/man/man1/npm-owner.1 @@ -1,4 +1,4 @@ -.TH "NPM-OWNER" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-OWNER" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-owner\fR - Manage package owners .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-pack.1 b/deps/npm/man/man1/npm-pack.1 index ea2ef910637..f3a7f77cced 100644 --- a/deps/npm/man/man1/npm-pack.1 +++ b/deps/npm/man/man1/npm-pack.1 @@ -1,4 +1,4 @@ -.TH "NPM-PACK" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-PACK" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-pack\fR - Create a tarball from a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-ping.1 b/deps/npm/man/man1/npm-ping.1 index d3590506a26..c6a347a93bb 100644 --- a/deps/npm/man/man1/npm-ping.1 +++ b/deps/npm/man/man1/npm-ping.1 @@ -1,4 +1,4 @@ -.TH "NPM-PING" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-PING" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-ping\fR - Ping npm registry .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-pkg.1 b/deps/npm/man/man1/npm-pkg.1 index 3c72c3739a5..05ca067c19c 100644 --- a/deps/npm/man/man1/npm-pkg.1 +++ b/deps/npm/man/man1/npm-pkg.1 @@ -1,4 +1,4 @@ -.TH "NPM-PKG" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-PKG" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-pkg\fR - Manages your package.json .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-prefix.1 b/deps/npm/man/man1/npm-prefix.1 index 1b5cf9e8e5b..d257e9ba0aa 100644 --- a/deps/npm/man/man1/npm-prefix.1 +++ b/deps/npm/man/man1/npm-prefix.1 @@ -1,4 +1,4 @@ -.TH "NPM-PREFIX" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-PREFIX" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-prefix\fR - Display prefix .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-profile.1 b/deps/npm/man/man1/npm-profile.1 index 256f451dc45..e60248cdfe2 100644 --- a/deps/npm/man/man1/npm-profile.1 +++ b/deps/npm/man/man1/npm-profile.1 @@ -1,4 +1,4 @@ -.TH "NPM-PROFILE" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-PROFILE" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-profile\fR - Change settings on your registry profile .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-prune.1 b/deps/npm/man/man1/npm-prune.1 index 8c2823dc7a8..f7f4bf2d695 100644 --- a/deps/npm/man/man1/npm-prune.1 +++ b/deps/npm/man/man1/npm-prune.1 @@ -1,4 +1,4 @@ -.TH "NPM-PRUNE" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-PRUNE" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-prune\fR - Remove extraneous packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-publish.1 b/deps/npm/man/man1/npm-publish.1 index 5b89d5a1020..aad3180fee8 100644 --- a/deps/npm/man/man1/npm-publish.1 +++ b/deps/npm/man/man1/npm-publish.1 @@ -1,4 +1,4 @@ -.TH "NPM-PUBLISH" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-PUBLISH" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-publish\fR - Publish a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-query.1 b/deps/npm/man/man1/npm-query.1 index 244e8b96469..62d17dc5dbf 100644 --- a/deps/npm/man/man1/npm-query.1 +++ b/deps/npm/man/man1/npm-query.1 @@ -1,4 +1,4 @@ -.TH "NPM-QUERY" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-QUERY" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-query\fR - Dependency selector query .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-rebuild.1 b/deps/npm/man/man1/npm-rebuild.1 index 3fb1df08bc5..e4c818dcff9 100644 --- a/deps/npm/man/man1/npm-rebuild.1 +++ b/deps/npm/man/man1/npm-rebuild.1 @@ -1,4 +1,4 @@ -.TH "NPM-REBUILD" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-REBUILD" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-rebuild\fR - Rebuild a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-repo.1 b/deps/npm/man/man1/npm-repo.1 index a68132d520b..64fb13ad727 100644 --- a/deps/npm/man/man1/npm-repo.1 +++ b/deps/npm/man/man1/npm-repo.1 @@ -1,4 +1,4 @@ -.TH "NPM-REPO" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-REPO" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-repo\fR - Open package repository page in the browser .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-restart.1 b/deps/npm/man/man1/npm-restart.1 index 8d1deb3ff11..6b7333de08e 100644 --- a/deps/npm/man/man1/npm-restart.1 +++ b/deps/npm/man/man1/npm-restart.1 @@ -1,4 +1,4 @@ -.TH "NPM-RESTART" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-RESTART" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-restart\fR - Restart a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-root.1 b/deps/npm/man/man1/npm-root.1 index 7090dca70da..e43130a5de0 100644 --- a/deps/npm/man/man1/npm-root.1 +++ b/deps/npm/man/man1/npm-root.1 @@ -1,4 +1,4 @@ -.TH "NPM-ROOT" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-ROOT" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-root\fR - Display npm root .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-run.1 b/deps/npm/man/man1/npm-run.1 index fe72ce5905a..44a0a413945 100644 --- a/deps/npm/man/man1/npm-run.1 +++ b/deps/npm/man/man1/npm-run.1 @@ -1,4 +1,4 @@ -.TH "NPM-RUN" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-RUN" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-run\fR - Run arbitrary package scripts .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-sbom.1 b/deps/npm/man/man1/npm-sbom.1 index 531b802b659..977e99d3680 100644 --- a/deps/npm/man/man1/npm-sbom.1 +++ b/deps/npm/man/man1/npm-sbom.1 @@ -1,4 +1,4 @@ -.TH "NPM-SBOM" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-SBOM" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-sbom\fR - Generate a Software Bill of Materials (SBOM) .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-search.1 b/deps/npm/man/man1/npm-search.1 index bf07a91bbc1..fdf8b0d9d4b 100644 --- a/deps/npm/man/man1/npm-search.1 +++ b/deps/npm/man/man1/npm-search.1 @@ -1,4 +1,4 @@ -.TH "NPM-SEARCH" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-SEARCH" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-search\fR - Search for packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-set.1 b/deps/npm/man/man1/npm-set.1 index 4478b11a645..98aa226928e 100644 --- a/deps/npm/man/man1/npm-set.1 +++ b/deps/npm/man/man1/npm-set.1 @@ -1,4 +1,4 @@ -.TH "NPM-SET" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-SET" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-set\fR - Set a value in the npm configuration .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-shrinkwrap.1 b/deps/npm/man/man1/npm-shrinkwrap.1 index 48949aa9d49..10b329ad53f 100644 --- a/deps/npm/man/man1/npm-shrinkwrap.1 +++ b/deps/npm/man/man1/npm-shrinkwrap.1 @@ -1,4 +1,4 @@ -.TH "NPM-SHRINKWRAP" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-SHRINKWRAP" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-shrinkwrap\fR - Lock down dependency versions for publication .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-stage.1 b/deps/npm/man/man1/npm-stage.1 index 0f2df23539c..e7f5ee6dabd 100644 --- a/deps/npm/man/man1/npm-stage.1 +++ b/deps/npm/man/man1/npm-stage.1 @@ -1,4 +1,4 @@ -.TH "NPM-STAGE" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-STAGE" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-stage\fR - Stage packages for publishing .SS "Synopsis" @@ -25,6 +25,8 @@ Staged packages share the same semver version unique index as published packages .IP \(bu 4 You can still publish packages normally while you have staged packages pending. .IP \(bu 4 +Staged publishing will allow you to create a new package if it does not exist. +.IP \(bu 4 You can stage multiple versions of the same package. .IP \(bu 4 \fBnpm stage publish\fR has parity with \fBnpm publish\fR and will respect \fB"private": true\fR in \fBpackage.json\fR, refusing to stage the package. @@ -37,8 +39,6 @@ Before using \fBnpm stage\fR commands, ensure the following requirements are met .IP \(bu 4 \fBWrite permissions on the package:\fR You must have write access to the package you're configuring. .IP \(bu 4 -\fBPackage must exist:\fR The package you're configuring must already exist on the npm registry. -.IP \(bu 4 \fB2FA enabled on your account:\fR Commands that require 2FA will prompt you to authenticate. If you don't already have 2FA enabled on your account, you must enable it before using these commands. .RE 0 diff --git a/deps/npm/man/man1/npm-star.1 b/deps/npm/man/man1/npm-star.1 index 1c05090c3a2..cfe66082f5d 100644 --- a/deps/npm/man/man1/npm-star.1 +++ b/deps/npm/man/man1/npm-star.1 @@ -1,4 +1,4 @@ -.TH "NPM-STAR" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-STAR" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-star\fR - Mark your favorite packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-stars.1 b/deps/npm/man/man1/npm-stars.1 index 27ee3c674f0..3edd9394710 100644 --- a/deps/npm/man/man1/npm-stars.1 +++ b/deps/npm/man/man1/npm-stars.1 @@ -1,4 +1,4 @@ -.TH "NPM-STARS" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-STARS" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-stars\fR - View packages marked as favorites .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-start.1 b/deps/npm/man/man1/npm-start.1 index 17c42ab4023..482e12f920b 100644 --- a/deps/npm/man/man1/npm-start.1 +++ b/deps/npm/man/man1/npm-start.1 @@ -1,4 +1,4 @@ -.TH "NPM-START" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-START" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-start\fR - Start a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-stop.1 b/deps/npm/man/man1/npm-stop.1 index 1d544669cbf..28b9dcca489 100644 --- a/deps/npm/man/man1/npm-stop.1 +++ b/deps/npm/man/man1/npm-stop.1 @@ -1,4 +1,4 @@ -.TH "NPM-STOP" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-STOP" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-stop\fR - Stop a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-team.1 b/deps/npm/man/man1/npm-team.1 index 1d42f0f514c..0fbcab4e8cf 100644 --- a/deps/npm/man/man1/npm-team.1 +++ b/deps/npm/man/man1/npm-team.1 @@ -1,4 +1,4 @@ -.TH "NPM-TEAM" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-TEAM" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-team\fR - Manage organization teams and team memberships .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-test.1 b/deps/npm/man/man1/npm-test.1 index 8136624750b..5d7fce9ea53 100644 --- a/deps/npm/man/man1/npm-test.1 +++ b/deps/npm/man/man1/npm-test.1 @@ -1,4 +1,4 @@ -.TH "NPM-TEST" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-TEST" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-test\fR - Test a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-token.1 b/deps/npm/man/man1/npm-token.1 index dafb3148e68..6b8b7f1432b 100644 --- a/deps/npm/man/man1/npm-token.1 +++ b/deps/npm/man/man1/npm-token.1 @@ -1,4 +1,4 @@ -.TH "NPM-TOKEN" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-TOKEN" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-token\fR - Manage your authentication tokens .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-trust.1 b/deps/npm/man/man1/npm-trust.1 index 87d202f3cef..49b9493aed9 100644 --- a/deps/npm/man/man1/npm-trust.1 +++ b/deps/npm/man/man1/npm-trust.1 @@ -1,4 +1,4 @@ -.TH "NPM-TRUST" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-TRUST" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-trust\fR - Manage trusted publishing relationships between packages and CI/CD providers .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-undeprecate.1 b/deps/npm/man/man1/npm-undeprecate.1 index 6b3b29e1e56..dcede198e83 100644 --- a/deps/npm/man/man1/npm-undeprecate.1 +++ b/deps/npm/man/man1/npm-undeprecate.1 @@ -1,4 +1,4 @@ -.TH "NPM-UNDEPRECATE" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-UNDEPRECATE" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-undeprecate\fR - Undeprecate a version of a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-uninstall.1 b/deps/npm/man/man1/npm-uninstall.1 index 896258939ad..5be1016a76e 100644 --- a/deps/npm/man/man1/npm-uninstall.1 +++ b/deps/npm/man/man1/npm-uninstall.1 @@ -1,4 +1,4 @@ -.TH "NPM-UNINSTALL" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-UNINSTALL" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-uninstall\fR - Remove a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-unpublish.1 b/deps/npm/man/man1/npm-unpublish.1 index f99202071c0..f60f2629ebd 100644 --- a/deps/npm/man/man1/npm-unpublish.1 +++ b/deps/npm/man/man1/npm-unpublish.1 @@ -1,4 +1,4 @@ -.TH "NPM-UNPUBLISH" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-UNPUBLISH" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-unpublish\fR - Remove a package from the registry .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-unstar.1 b/deps/npm/man/man1/npm-unstar.1 index 60bf9fea8bd..14c130030cf 100644 --- a/deps/npm/man/man1/npm-unstar.1 +++ b/deps/npm/man/man1/npm-unstar.1 @@ -1,4 +1,4 @@ -.TH "NPM-UNSTAR" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-UNSTAR" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-unstar\fR - Remove an item from your favorite packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-update.1 b/deps/npm/man/man1/npm-update.1 index 3e13678d0b9..09149b799a3 100644 --- a/deps/npm/man/man1/npm-update.1 +++ b/deps/npm/man/man1/npm-update.1 @@ -1,4 +1,4 @@ -.TH "NPM-UPDATE" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-UPDATE" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-update\fR - Update packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-version.1 b/deps/npm/man/man1/npm-version.1 index 064e3a0b752..099e09b920f 100644 --- a/deps/npm/man/man1/npm-version.1 +++ b/deps/npm/man/man1/npm-version.1 @@ -1,4 +1,4 @@ -.TH "NPM-VERSION" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-VERSION" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-version\fR - Bump a package version .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-view.1 b/deps/npm/man/man1/npm-view.1 index de67d3f900c..d3ae4185cd1 100644 --- a/deps/npm/man/man1/npm-view.1 +++ b/deps/npm/man/man1/npm-view.1 @@ -1,4 +1,4 @@ -.TH "NPM-VIEW" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-VIEW" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-view\fR - View registry info .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-whoami.1 b/deps/npm/man/man1/npm-whoami.1 index ddfde867876..c3ce1bc97b3 100644 --- a/deps/npm/man/man1/npm-whoami.1 +++ b/deps/npm/man/man1/npm-whoami.1 @@ -1,4 +1,4 @@ -.TH "NPM-WHOAMI" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM-WHOAMI" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-whoami\fR - Display npm username .SS "Synopsis" diff --git a/deps/npm/man/man1/npm.1 b/deps/npm/man/man1/npm.1 index 2f4b30a1f13..c8ea8a2cc74 100644 --- a/deps/npm/man/man1/npm.1 +++ b/deps/npm/man/man1/npm.1 @@ -1,4 +1,4 @@ -.TH "NPM" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPM" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm\fR - javascript package manager .SS "Synopsis" @@ -12,7 +12,7 @@ npm Note: This command is unaware of workspaces. .SS "Version" .P -11.20.0 +11.21.2 .SS "Description" .P npm is the package manager for the Node JavaScript platform. It puts modules in place so that node can find them, and manages dependency conflicts intelligently. diff --git a/deps/npm/man/man1/npx.1 b/deps/npm/man/man1/npx.1 index a50bf96cf46..c99e9692469 100644 --- a/deps/npm/man/man1/npx.1 +++ b/deps/npm/man/man1/npx.1 @@ -1,4 +1,4 @@ -.TH "NPX" "1" "September 2026" "NPM@11.20.0" "" +.TH "NPX" "1" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpx\fR - Run a command from a local or remote npm package .SS "Synopsis" diff --git a/deps/npm/man/man5/folders.5 b/deps/npm/man/man5/folders.5 index 40aa02afd34..ecca3409f8d 100644 --- a/deps/npm/man/man5/folders.5 +++ b/deps/npm/man/man5/folders.5 @@ -1,4 +1,4 @@ -.TH "FOLDERS" "5" "September 2026" "NPM@11.20.0" "" +.TH "FOLDERS" "5" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBFolders\fR - Folder structures used by npm .SS "Description" diff --git a/deps/npm/man/man5/install.5 b/deps/npm/man/man5/install.5 index af38748dc56..9687aa67026 100644 --- a/deps/npm/man/man5/install.5 +++ b/deps/npm/man/man5/install.5 @@ -1,4 +1,4 @@ -.TH "INSTALL" "5" "September 2026" "NPM@11.20.0" "" +.TH "INSTALL" "5" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBInstall\fR - Download and install node and npm .SS "Description" diff --git a/deps/npm/man/man5/npm-global.5 b/deps/npm/man/man5/npm-global.5 index 40aa02afd34..ecca3409f8d 100644 --- a/deps/npm/man/man5/npm-global.5 +++ b/deps/npm/man/man5/npm-global.5 @@ -1,4 +1,4 @@ -.TH "FOLDERS" "5" "September 2026" "NPM@11.20.0" "" +.TH "FOLDERS" "5" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBFolders\fR - Folder structures used by npm .SS "Description" diff --git a/deps/npm/man/man5/npm-json.5 b/deps/npm/man/man5/npm-json.5 index 41f16abf240..639e431c897 100644 --- a/deps/npm/man/man5/npm-json.5 +++ b/deps/npm/man/man5/npm-json.5 @@ -1,4 +1,4 @@ -.TH "PACKAGE.JSON" "5" "September 2026" "NPM@11.20.0" "" +.TH "PACKAGE.JSON" "5" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBpackage.json\fR - Specifics of npm's package.json handling .SS "Description" diff --git a/deps/npm/man/man5/npm-shrinkwrap-json.5 b/deps/npm/man/man5/npm-shrinkwrap-json.5 index ec1a2cdcfab..d8fae509e4a 100644 --- a/deps/npm/man/man5/npm-shrinkwrap-json.5 +++ b/deps/npm/man/man5/npm-shrinkwrap-json.5 @@ -1,4 +1,4 @@ -.TH "NPM-SHRINKWRAP.JSON" "5" "September 2026" "NPM@11.20.0" "" +.TH "NPM-SHRINKWRAP.JSON" "5" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBnpm-shrinkwrap.json\fR - A publishable lockfile .SS "Description" diff --git a/deps/npm/man/man5/npmrc.5 b/deps/npm/man/man5/npmrc.5 index d41c7e36a63..03557880a5e 100644 --- a/deps/npm/man/man5/npmrc.5 +++ b/deps/npm/man/man5/npmrc.5 @@ -1,4 +1,4 @@ -.TH ".NPMRC" "5" "September 2026" "NPM@11.20.0" "" +.TH ".NPMRC" "5" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fB.npmrc\fR - The npm config files .SS "Description" diff --git a/deps/npm/man/man5/package-json.5 b/deps/npm/man/man5/package-json.5 index 41f16abf240..639e431c897 100644 --- a/deps/npm/man/man5/package-json.5 +++ b/deps/npm/man/man5/package-json.5 @@ -1,4 +1,4 @@ -.TH "PACKAGE.JSON" "5" "September 2026" "NPM@11.20.0" "" +.TH "PACKAGE.JSON" "5" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBpackage.json\fR - Specifics of npm's package.json handling .SS "Description" diff --git a/deps/npm/man/man5/package-lock-json.5 b/deps/npm/man/man5/package-lock-json.5 index 46d19e3b57a..960fef79eb2 100644 --- a/deps/npm/man/man5/package-lock-json.5 +++ b/deps/npm/man/man5/package-lock-json.5 @@ -1,4 +1,4 @@ -.TH "PACKAGE-LOCK.JSON" "5" "September 2026" "NPM@11.20.0" "" +.TH "PACKAGE-LOCK.JSON" "5" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBpackage-lock.json\fR - A manifestation of the manifest .SS "Description" diff --git a/deps/npm/man/man7/config.7 b/deps/npm/man/man7/config.7 index 92fba90eec0..bd5661545e4 100644 --- a/deps/npm/man/man7/config.7 +++ b/deps/npm/man/man7/config.7 @@ -1,4 +1,4 @@ -.TH "CONFIG" "7" "September 2026" "NPM@11.20.0" "" +.TH "CONFIG" "7" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBConfig\fR - About npm configuration .SS "Description" diff --git a/deps/npm/man/man7/dependency-selectors.7 b/deps/npm/man/man7/dependency-selectors.7 index c81faa51b8c..5884af196f7 100644 --- a/deps/npm/man/man7/dependency-selectors.7 +++ b/deps/npm/man/man7/dependency-selectors.7 @@ -1,4 +1,4 @@ -.TH "SELECTORS" "7" "September 2026" "NPM@11.20.0" "" +.TH "SELECTORS" "7" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBSelectors\fR - Dependency Selector Syntax & Querying .SS "Description" diff --git a/deps/npm/man/man7/developers.7 b/deps/npm/man/man7/developers.7 index 8d240d09d82..89a7b8e8647 100644 --- a/deps/npm/man/man7/developers.7 +++ b/deps/npm/man/man7/developers.7 @@ -1,4 +1,4 @@ -.TH "DEVELOPERS" "7" "September 2026" "NPM@11.20.0" "" +.TH "DEVELOPERS" "7" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBDevelopers\fR - Developer guide .SS "Description" diff --git a/deps/npm/man/man7/logging.7 b/deps/npm/man/man7/logging.7 index a0464b5231c..a20bb662ed0 100644 --- a/deps/npm/man/man7/logging.7 +++ b/deps/npm/man/man7/logging.7 @@ -1,4 +1,4 @@ -.TH "LOGGING" "7" "September 2026" "NPM@11.20.0" "" +.TH "LOGGING" "7" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBLogging\fR - Why, What & How we Log .SS "Description" diff --git a/deps/npm/man/man7/orgs.7 b/deps/npm/man/man7/orgs.7 index 7c01081ea03..58ad4741081 100644 --- a/deps/npm/man/man7/orgs.7 +++ b/deps/npm/man/man7/orgs.7 @@ -1,4 +1,4 @@ -.TH "ORGANIZATIONS" "7" "September 2026" "NPM@11.20.0" "" +.TH "ORGANIZATIONS" "7" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBOrganizations\fR - Working with teams & organizations .SS "Description" diff --git a/deps/npm/man/man7/package-spec.7 b/deps/npm/man/man7/package-spec.7 index 9261a4edc18..1eda237ed7a 100644 --- a/deps/npm/man/man7/package-spec.7 +++ b/deps/npm/man/man7/package-spec.7 @@ -1,4 +1,4 @@ -.TH "SPEC" "7" "September 2026" "NPM@11.20.0" "" +.TH "SPEC" "7" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBspec\fR - Package name specifier .SS "Description" diff --git a/deps/npm/man/man7/registry.7 b/deps/npm/man/man7/registry.7 index a529ad8c25d..1e0ac20aa4a 100644 --- a/deps/npm/man/man7/registry.7 +++ b/deps/npm/man/man7/registry.7 @@ -1,4 +1,4 @@ -.TH "REGISTRY" "7" "September 2026" "NPM@11.20.0" "" +.TH "REGISTRY" "7" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBRegistry\fR - The JavaScript Package Registry .SS "Description" diff --git a/deps/npm/man/man7/removal.7 b/deps/npm/man/man7/removal.7 index de3d5663c0b..fa1a46000a0 100644 --- a/deps/npm/man/man7/removal.7 +++ b/deps/npm/man/man7/removal.7 @@ -1,4 +1,4 @@ -.TH "REMOVAL" "7" "September 2026" "NPM@11.20.0" "" +.TH "REMOVAL" "7" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBRemoval\fR - Cleaning the slate .SS "Synopsis" diff --git a/deps/npm/man/man7/scope.7 b/deps/npm/man/man7/scope.7 index 37b246569f7..914ea789118 100644 --- a/deps/npm/man/man7/scope.7 +++ b/deps/npm/man/man7/scope.7 @@ -1,4 +1,4 @@ -.TH "SCOPE" "7" "September 2026" "NPM@11.20.0" "" +.TH "SCOPE" "7" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBScope\fR - Scoped packages .SS "Description" diff --git a/deps/npm/man/man7/scripts.7 b/deps/npm/man/man7/scripts.7 index d49e9941ba4..b1b268cc8d1 100644 --- a/deps/npm/man/man7/scripts.7 +++ b/deps/npm/man/man7/scripts.7 @@ -1,4 +1,4 @@ -.TH "SCRIPTS" "7" "September 2026" "NPM@11.20.0" "" +.TH "SCRIPTS" "7" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBScripts\fR - How npm handles the "scripts" field .SS "Description" diff --git a/deps/npm/man/man7/workspaces.7 b/deps/npm/man/man7/workspaces.7 index 7e74e51a60e..b866bab8d2f 100644 --- a/deps/npm/man/man7/workspaces.7 +++ b/deps/npm/man/man7/workspaces.7 @@ -1,4 +1,4 @@ -.TH "WORKSPACES" "7" "September 2026" "NPM@11.20.0" "" +.TH "WORKSPACES" "7" "November 2026" "NPM@11.21.2" "" .SH "NAME" \fBWorkspaces\fR - Working with workspaces .SS "Description" diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/arborist/build-ideal-tree.js b/deps/npm/node_modules/@npmcli/arborist/lib/arborist/build-ideal-tree.js index 7ff7a21cf9b..02fcb86aaa0 100644 --- a/deps/npm/node_modules/@npmcli/arborist/lib/arborist/build-ideal-tree.js +++ b/deps/npm/node_modules/@npmcli/arborist/lib/arborist/build-ideal-tree.js @@ -1526,7 +1526,7 @@ This is a one-time fix-up, please be patient... // allow it. either we're overriding, or it's not something // that will be installed by default anyway, and we'll fail when // we get to the point where we need to, if we need to. - if (conflictOK || !required.has(dep)) { + if (conflictOK || !required.has(dep) || this.#loadFailures.has(dep)) { edge.peerConflicted = true continue } @@ -1560,7 +1560,7 @@ This is a one-time fix-up, please be patient... // isn't also required, then there's a good chance we won't need it, // so allow it for now and let it conflict if it turns out to actually // be necessary for the installation. - if (conflictOK || !required.has(edge.from)) { + if (conflictOK || !required.has(edge.from) || this.#loadFailures.has(current)) { continue } diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/script-allowed.js b/deps/npm/node_modules/@npmcli/arborist/lib/script-allowed.js index 629625f8e4f..b560884aac6 100644 --- a/deps/npm/node_modules/@npmcli/arborist/lib/script-allowed.js +++ b/deps/npm/node_modules/@npmcli/arborist/lib/script-allowed.js @@ -1,3 +1,4 @@ +const { resolve, sep } = require('node:path') const npa = require('npm-package-arg') const semver = require('semver') const versionFromTgz = require('./version-from-tgz.js') @@ -99,6 +100,23 @@ const matches = (node, key, failClosed) => { } } +// True when the node lives in the linked install strategy's `node_modules/.store` directory; such registry-managed packages must never derive identity from the store's internal `file:` link specs. +const isStoreBacked = (node) => { + if (node?.isInStore) { + return true + } + // Nodes loaded from the hidden lockfile do not retain isInStore, so fall back to the path, anchored to this tree's own store so an unrelated project's `.store` never qualifies. + const paths = [node?.path, node?.realpath].filter(p => typeof p === 'string') + const roots = [node?.root?.path, node?.root?.realpath].filter(p => typeof p === 'string') + for (const root of roots) { + const store = resolve(root, 'node_modules', '.store') + if (paths.some(path => path.startsWith(`${store}${sep}`))) { + return true + } + } + return false +} + const resolvedSourceSpecs = (node) => { const specs = [] const seen = new Set() @@ -112,7 +130,8 @@ const resolvedSourceSpecs = (node) => { add(node?.resolved) - if (!node?.resolved && node?.linksIn && typeof node.linksIn[Symbol.iterator] === 'function') { + if (!node?.resolved && !isStoreBacked(node) && + node?.linksIn && typeof node.linksIn[Symbol.iterator] === 'function') { let hasIncomingLink = false for (const link of node.linksIn) { hasIncomingLink = true @@ -235,10 +254,32 @@ const getTrustedRegistryIdentity = (node) => { } const nameFromEdges = (node) => { - if (!node.edgesIn || typeof node.edgesIn[Symbol.iterator] !== 'function') { + const name = nameFromEdgeSet(node?.edgesIn) + if (name || !isStoreBacked(node) || node?.edgesIn?.size !== 0) { + return name + } + // A store-backed link target carries no edges of its own; they land on the incoming Links, so consult their edges instead, refusing when a Link is non-registry, unidentified, or disagrees with another Link. + let linkName = null + if (node?.linksIn && typeof node.linksIn[Symbol.iterator] === 'function') { + for (const link of node.linksIn) { + if (!link.isRegistryDependency) { + return null + } + const name = nameFromEdgeSet(link.edgesIn) + if (!name || (linkName && linkName !== name)) { + return null + } + linkName = name + } + } + return linkName +} + +const nameFromEdgeSet = (edgesIn) => { + if (!edgesIn || typeof edgesIn[Symbol.iterator] !== 'function') { return null } - for (const edge of node.edgesIn) { + for (const edge of edgesIn) { let parsed try { parsed = npa.resolve(edge.name, edge.spec) @@ -350,7 +391,14 @@ const isRegistryNode = (node) => { // edge resolves to a registry spec, which is much harder to spoof than // the URL. if (typeof node.isRegistryDependency === 'boolean') { - return node.isRegistryDependency + if (node.isRegistryDependency) { + return true + } + // A store-backed link target carries no edges of its own; they land on the incoming Links (npm/cli#9939), so delegate the edge-based check to them, but never for ordinary local symlink targets that share the same topology. + if (isStoreBacked(node) && node.edgesIn?.size === 0 && node.linksIn?.size > 0) { + return [...node.linksIn].every(link => link.isRegistryDependency) + } + return false } // Fall back to URL parsing for nodes without the arborist getter // (e.g. test fixtures, lockfiles with omit-lockfile-registry-resolved). diff --git a/deps/npm/node_modules/@npmcli/arborist/package.json b/deps/npm/node_modules/@npmcli/arborist/package.json index 8bd0ffeaa94..feb07ad86ff 100644 --- a/deps/npm/node_modules/@npmcli/arborist/package.json +++ b/deps/npm/node_modules/@npmcli/arborist/package.json @@ -1,6 +1,6 @@ { "name": "@npmcli/arborist", - "version": "9.9.2", + "version": "9.9.3", "description": "Manage node_modules trees", "dependencies": { "@gar/promise-retry": "^1.0.0", diff --git a/deps/npm/node_modules/@npmcli/config/README.md b/deps/npm/node_modules/@npmcli/config/README.md index 6a948d9b11a..b86557d6b31 100644 --- a/deps/npm/node_modules/@npmcli/config/README.md +++ b/deps/npm/node_modules/@npmcli/config/README.md @@ -180,6 +180,8 @@ Set the key to the specified value, at the specified level in the config stack. Delete the configuration key from the specified level in the config stack. +Deleting an override exposes the next applicable value from the lower-priority sources and invalidates cached flattened options. + ### `config.validate(where)` Verify that all known configuration options are set to valid values, and log a warning if they are invalid. diff --git a/deps/npm/node_modules/@npmcli/config/lib/index.js b/deps/npm/node_modules/@npmcli/config/lib/index.js index a1acb7969b2..2f3a487be89 100644 --- a/deps/npm/node_modules/@npmcli/config/lib/index.js +++ b/deps/npm/node_modules/@npmcli/config/lib/index.js @@ -236,6 +236,8 @@ class Config { if (['global', 'user', 'project'].includes(where)) { delete raw[key] } + this.data.get(where)[_valid] = null + this.#flatOptions = null } async load () { diff --git a/deps/npm/node_modules/@npmcli/config/package.json b/deps/npm/node_modules/@npmcli/config/package.json index dcc39cef2ac..546f7696afa 100644 --- a/deps/npm/node_modules/@npmcli/config/package.json +++ b/deps/npm/node_modules/@npmcli/config/package.json @@ -1,6 +1,6 @@ { "name": "@npmcli/config", - "version": "10.13.0", + "version": "10.14.0", "files": [ "bin/", "lib/" diff --git a/deps/npm/node_modules/@npmcli/promise-spawn/lib/index.js b/deps/npm/node_modules/@npmcli/promise-spawn/lib/index.js index 1faf62c9157..d6d2c8cd048 100644 --- a/deps/npm/node_modules/@npmcli/promise-spawn/lib/index.js +++ b/deps/npm/node_modules/@npmcli/promise-spawn/lib/index.js @@ -83,20 +83,27 @@ const spawnWithShell = (cmd, args, opts, extra) => { if (isCmd) { let doubleEscape = false - // find the actual command we're running + // Decode the executable token so escaped batch shims still get double escaping. let initialCmd = '' let insideQuotes = false for (let i = 0; i < cmd.length; ++i) { const char = cmd.charAt(i) + if (char === '^' && !insideQuotes && i + 1 < cmd.length) { + initialCmd += cmd.charAt(++i) + continue + } if (char === ' ' && !insideQuotes) { break } initialCmd += char - if (char === '"' || char === "'") { + if (char === '"') { insideQuotes = !insideQuotes } } + if (initialCmd.startsWith('"') && initialCmd.endsWith('"')) { + initialCmd = initialCmd.slice(1, -1) + } let pathToInitial try { diff --git a/deps/npm/node_modules/@npmcli/promise-spawn/package.json b/deps/npm/node_modules/@npmcli/promise-spawn/package.json index f00ee324355..747e7e1dcad 100644 --- a/deps/npm/node_modules/@npmcli/promise-spawn/package.json +++ b/deps/npm/node_modules/@npmcli/promise-spawn/package.json @@ -1,6 +1,6 @@ { "name": "@npmcli/promise-spawn", - "version": "9.0.1", + "version": "9.0.2", "files": [ "bin/", "lib/" @@ -43,7 +43,8 @@ "templateOSS": { "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.", "version": "4.28.0", - "publish": true + "publish": true, + "backport": 9 }, "dependencies": { "which": "^6.0.0" diff --git a/deps/npm/node_modules/bin-links/lib/get-paths.js b/deps/npm/node_modules/bin-links/lib/get-paths.js index b93e6982dce..871a9c4a812 100644 --- a/deps/npm/node_modules/bin-links/lib/get-paths.js +++ b/deps/npm/node_modules/bin-links/lib/get-paths.js @@ -5,11 +5,13 @@ const binTarget = require('./bin-target.js') const manTarget = require('./man-target.js') const { resolve, basename, extname } = require('path') const isWindows = require('./is-windows.js') +const normalize = require('npm-normalize-package-bin') module.exports = ({ path, pkg, global, top }) => { if (top && !global) { return [] } + pkg = normalize({ ...pkg }) const binSet = [] const binTarg = binTarget({ path, top }) if (pkg.bin) { diff --git a/deps/npm/node_modules/bin-links/package.json b/deps/npm/node_modules/bin-links/package.json index 80a63323e88..ad14153c11e 100644 --- a/deps/npm/node_modules/bin-links/package.json +++ b/deps/npm/node_modules/bin-links/package.json @@ -1,6 +1,6 @@ { "name": "bin-links", - "version": "6.0.2", + "version": "6.0.3", "description": "JavaScript package binary linker", "main": "./lib/index.js", "scripts": { @@ -57,6 +57,7 @@ "windowsCI": false, "version": "4.30.0", "publish": true, + "backport": 6, "updateNpm": false, "latestCiVersion": 24 } diff --git a/deps/npm/node_modules/brace-expansion/dist/commonjs/index.js b/deps/npm/node_modules/brace-expansion/dist/commonjs/index.js index 869a6bee238..48cf0d3dabc 100644 --- a/deps/npm/node_modules/brace-expansion/dist/commonjs/index.js +++ b/deps/npm/node_modules/brace-expansion/dist/commonjs/index.js @@ -1,6 +1,6 @@ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -exports.EXPANSION_MAX_LENGTH = exports.EXPANSION_MAX = void 0; +exports.EXPANSION_MAX_REWRITES = exports.EXPANSION_MAX_DEPTH = exports.EXPANSION_MAX_LENGTH = exports.EXPANSION_MAX = void 0; exports.expand = expand; const balanced_match_1 = require("balanced-match"); const escSlash = '\0SLASH' + Math.random() + '\0'; @@ -30,6 +30,24 @@ exports.EXPANSION_MAX = 100_000; // realistic expansion (100k results hitting `EXPANSION_MAX` measure ~1M // characters) so legitimate input is unaffected. exports.EXPANSION_MAX_LENGTH = 4_000_000; +// `expand_` recurses once per level of brace *nesting* - both when expanding a +// set's comma members and when re-wrapping a set whose body is a single part. +// The CVE-2026-14257 fix made the *tail* iterative (recursion on `m.post`, one +// level per chained group), which left nesting depth unbounded: about 3,100 +// levels of `{{{...a,b...}}}` - only ~6KB of input - exhausted the native stack +// and crashed the process. `EXPANSION_MAX_DEPTH` bounds how deep the parser +// will follow nesting. It sits far above any realistic pattern and well below +// the depth at which the stack runs out. +exports.EXPANSION_MAX_DEPTH = 1_000; +// Bash keeps a quirk where a brace group followed by a comma set still expands +// (`{a},b}`). The parser implements it by rewriting the string and restarting +// the scan, absorbing one `}` per pass. `n` trailing braces therefore cost `n` +// full passes over a string that itself grows by one `escClose` sentinel each +// time - quadratic in `n`, with a ~26x constant from the sentinel's length. +// 128KB of `'{a}' + '}'.repeat(n) + ',z}'` blocked the event loop for 27 +// seconds to produce two results. `EXPANSION_MAX_REWRITES` bounds how many +// times the scan may restart. Real `{a},b}` input needs a handful. +exports.EXPANSION_MAX_REWRITES = 1_000; function numeric(str) { return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0); } @@ -49,37 +67,52 @@ function unescapeBraces(str) { .replace(escCommaPattern, ',') .replace(escPeriodPattern, '.'); } +// Like `target.push(...items)` but doesn't overflow the stack +function pushAll(target, items) { + for (let i = 0; i < items.length; i++) { + target.push(items[i]); + } +} /** * Basically just str.split(","), but handling cases * where we have nested braced sections, which should be * treated as individual members, like {a,{b,c},d} */ function parseCommaParts(str) { - if (!str) { - return ['']; - } const parts = []; - const m = (0, balanced_match_1.balanced)('{', '}', str); - if (!m) { - return str.split(','); - } - const { pre, body, post } = m; - const p = pre.split(','); - p[p.length - 1] += '{' + body + '}'; - const postParts = parseCommaParts(post); - if (post.length) { - ; - p[p.length - 1] += postParts.shift(); - p.push.apply(p, postParts); + // Walk the brace groups iteratively. Recursing on `post` once per group let a + // chain of them exhaust the stack - the parsing-side counterpart to + // the `expand_` overflow fixed for CVE-2026-14257, and not something `max` or + // `maxLength` can bound, since it happens before expansion. + // + // The part the next chunk continues + let carry = ''; + for (;;) { + const m = (0, balanced_match_1.balanced)('{', '}', str); + if (!m) { + const tail = str.split(','); + tail[0] = carry + tail[0]; + pushAll(parts, tail); + return parts; + } + const { pre, body, post } = m; + const p = pre.split(','); + p[0] = carry + p[0]; + p[p.length - 1] += '{' + body + '}'; + if (!post.length) { + pushAll(parts, p); + return parts; + } + carry = p.pop(); + pushAll(parts, p); + str = post; } - parts.push.apply(parts, p); - return parts; } function expand(str, options = {}) { if (!str) { return []; } - const { max = exports.EXPANSION_MAX, maxLength = exports.EXPANSION_MAX_LENGTH } = options; + const { max = exports.EXPANSION_MAX, maxLength = exports.EXPANSION_MAX_LENGTH, maxDepth = exports.EXPANSION_MAX_DEPTH, maxRewrites = exports.EXPANSION_MAX_REWRITES, } = options; // I don't know why Bash 4.3 does this, but it does. // Anything starting with {} will have the first two bytes preserved // but *only* at the top level, so {},a}b will not expand to anything, @@ -89,7 +122,7 @@ function expand(str, options = {}) { if (str.slice(0, 2) === '{}') { str = '\\{\\}' + str.slice(2); } - return expand_(escapeBraces(str), max, maxLength, true).map(unescapeBraces); + return expand_(escapeBraces(str), max, maxLength, maxDepth, 0, maxRewrites, true).map(unescapeBraces); } function embrace(str) { return '{' + str + '}'; @@ -184,7 +217,13 @@ function expandSequence(body, isAlphaSequence, max, maxLength) { } return N; } -function expand_(str, max, maxLength, isTop) { +function expand_(str, max, maxLength, maxDepth, depth, maxRewrites, isTop) { + // Too deeply nested to keep following: treat the rest as literal, the same + // way a group that cannot expand is already handled. Truncating rather than + // throwing keeps `expand` total, matching `max` and `maxLength`. + if (depth > maxDepth) { + return [str]; + } // Consume the string's top-level brace groups left to right, threading a // running set of combined prefixes (`acc`). Expanding the tail iteratively - // rather than recursing on `m.post` once per group - keeps the native stack @@ -196,6 +235,9 @@ function expand_(str, max, maxLength, isTop) { // comma set - a sequence like `{a..\}` may legitimately yield ''. The drop // is on the final strings, so it is applied to whichever `combine` produces // them (the one with no brace set left in the tail). + // How many times the `{a},b}` rewrite below has restarted the scan. Each pass + // re-reads the whole string, so leaving this unbounded is quadratic. + let rewrites = 0; let dropEmpties = false; let firstGroup = true; for (;;) { @@ -220,7 +262,8 @@ function expand_(str, max, maxLength, isTop) { const isOptions = m.body.indexOf(',') >= 0; if (!isSequence && !isOptions) { // {a},b} - if (m.post.match(/,(?!,).*\}/)) { + if (rewrites < maxRewrites && m.post.match(/,(?!,).*\}/)) { + rewrites++; str = m.pre + '{' + m.body + escClose + m.post; isTop = true; continue; @@ -240,7 +283,7 @@ function expand_(str, max, maxLength, isTop) { let n = parseCommaParts(m.body); if (n.length === 1 && n[0] !== undefined) { // x{{a,b}}y ==> x{a}y x{b}y - n = expand_(n[0], max, maxLength, false).map(embrace); + n = expand_(n[0], max, maxLength, maxDepth, depth + 1, maxRewrites, false).map(embrace); //XXX is this necessary? Can't seem to hit it in tests. /* c8 ignore start */ if (n.length === 1) { @@ -266,12 +309,13 @@ function expand_(str, max, maxLength, isTop) { values = []; let valuesLength = 0; outer: for (let j = 0; j < n.length; j++) { - const expanded = expand_(n[j], max, maxLength, false); + const expanded = expand_(n[j], max, maxLength, maxDepth, depth + 1, maxRewrites, false); for (let k = 0; k < expanded.length; k++) { const v = expanded[k]; if (dropsEmpties && !v) continue; - if (values.length >= max || valuesLength + v.length > maxLength) { + if (values.length >= max || + valuesLength + v.length > maxLength) { break outer; } values.push(v); diff --git a/deps/npm/node_modules/brace-expansion/dist/esm/index.js b/deps/npm/node_modules/brace-expansion/dist/esm/index.js index fd68f570292..0e0cc962307 100644 --- a/deps/npm/node_modules/brace-expansion/dist/esm/index.js +++ b/deps/npm/node_modules/brace-expansion/dist/esm/index.js @@ -26,6 +26,24 @@ export const EXPANSION_MAX = 100_000; // realistic expansion (100k results hitting `EXPANSION_MAX` measure ~1M // characters) so legitimate input is unaffected. export const EXPANSION_MAX_LENGTH = 4_000_000; +// `expand_` recurses once per level of brace *nesting* - both when expanding a +// set's comma members and when re-wrapping a set whose body is a single part. +// The CVE-2026-14257 fix made the *tail* iterative (recursion on `m.post`, one +// level per chained group), which left nesting depth unbounded: about 3,100 +// levels of `{{{...a,b...}}}` - only ~6KB of input - exhausted the native stack +// and crashed the process. `EXPANSION_MAX_DEPTH` bounds how deep the parser +// will follow nesting. It sits far above any realistic pattern and well below +// the depth at which the stack runs out. +export const EXPANSION_MAX_DEPTH = 1_000; +// Bash keeps a quirk where a brace group followed by a comma set still expands +// (`{a},b}`). The parser implements it by rewriting the string and restarting +// the scan, absorbing one `}` per pass. `n` trailing braces therefore cost `n` +// full passes over a string that itself grows by one `escClose` sentinel each +// time - quadratic in `n`, with a ~26x constant from the sentinel's length. +// 128KB of `'{a}' + '}'.repeat(n) + ',z}'` blocked the event loop for 27 +// seconds to produce two results. `EXPANSION_MAX_REWRITES` bounds how many +// times the scan may restart. Real `{a},b}` input needs a handful. +export const EXPANSION_MAX_REWRITES = 1_000; function numeric(str) { return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0); } @@ -45,37 +63,52 @@ function unescapeBraces(str) { .replace(escCommaPattern, ',') .replace(escPeriodPattern, '.'); } +// Like `target.push(...items)` but doesn't overflow the stack +function pushAll(target, items) { + for (let i = 0; i < items.length; i++) { + target.push(items[i]); + } +} /** * Basically just str.split(","), but handling cases * where we have nested braced sections, which should be * treated as individual members, like {a,{b,c},d} */ function parseCommaParts(str) { - if (!str) { - return ['']; - } const parts = []; - const m = balanced('{', '}', str); - if (!m) { - return str.split(','); - } - const { pre, body, post } = m; - const p = pre.split(','); - p[p.length - 1] += '{' + body + '}'; - const postParts = parseCommaParts(post); - if (post.length) { - ; - p[p.length - 1] += postParts.shift(); - p.push.apply(p, postParts); + // Walk the brace groups iteratively. Recursing on `post` once per group let a + // chain of them exhaust the stack - the parsing-side counterpart to + // the `expand_` overflow fixed for CVE-2026-14257, and not something `max` or + // `maxLength` can bound, since it happens before expansion. + // + // The part the next chunk continues + let carry = ''; + for (;;) { + const m = balanced('{', '}', str); + if (!m) { + const tail = str.split(','); + tail[0] = carry + tail[0]; + pushAll(parts, tail); + return parts; + } + const { pre, body, post } = m; + const p = pre.split(','); + p[0] = carry + p[0]; + p[p.length - 1] += '{' + body + '}'; + if (!post.length) { + pushAll(parts, p); + return parts; + } + carry = p.pop(); + pushAll(parts, p); + str = post; } - parts.push.apply(parts, p); - return parts; } export function expand(str, options = {}) { if (!str) { return []; } - const { max = EXPANSION_MAX, maxLength = EXPANSION_MAX_LENGTH } = options; + const { max = EXPANSION_MAX, maxLength = EXPANSION_MAX_LENGTH, maxDepth = EXPANSION_MAX_DEPTH, maxRewrites = EXPANSION_MAX_REWRITES, } = options; // I don't know why Bash 4.3 does this, but it does. // Anything starting with {} will have the first two bytes preserved // but *only* at the top level, so {},a}b will not expand to anything, @@ -85,7 +118,7 @@ export function expand(str, options = {}) { if (str.slice(0, 2) === '{}') { str = '\\{\\}' + str.slice(2); } - return expand_(escapeBraces(str), max, maxLength, true).map(unescapeBraces); + return expand_(escapeBraces(str), max, maxLength, maxDepth, 0, maxRewrites, true).map(unescapeBraces); } function embrace(str) { return '{' + str + '}'; @@ -180,7 +213,13 @@ function expandSequence(body, isAlphaSequence, max, maxLength) { } return N; } -function expand_(str, max, maxLength, isTop) { +function expand_(str, max, maxLength, maxDepth, depth, maxRewrites, isTop) { + // Too deeply nested to keep following: treat the rest as literal, the same + // way a group that cannot expand is already handled. Truncating rather than + // throwing keeps `expand` total, matching `max` and `maxLength`. + if (depth > maxDepth) { + return [str]; + } // Consume the string's top-level brace groups left to right, threading a // running set of combined prefixes (`acc`). Expanding the tail iteratively - // rather than recursing on `m.post` once per group - keeps the native stack @@ -192,6 +231,9 @@ function expand_(str, max, maxLength, isTop) { // comma set - a sequence like `{a..\}` may legitimately yield ''. The drop // is on the final strings, so it is applied to whichever `combine` produces // them (the one with no brace set left in the tail). + // How many times the `{a},b}` rewrite below has restarted the scan. Each pass + // re-reads the whole string, so leaving this unbounded is quadratic. + let rewrites = 0; let dropEmpties = false; let firstGroup = true; for (;;) { @@ -216,7 +258,8 @@ function expand_(str, max, maxLength, isTop) { const isOptions = m.body.indexOf(',') >= 0; if (!isSequence && !isOptions) { // {a},b} - if (m.post.match(/,(?!,).*\}/)) { + if (rewrites < maxRewrites && m.post.match(/,(?!,).*\}/)) { + rewrites++; str = m.pre + '{' + m.body + escClose + m.post; isTop = true; continue; @@ -236,7 +279,7 @@ function expand_(str, max, maxLength, isTop) { let n = parseCommaParts(m.body); if (n.length === 1 && n[0] !== undefined) { // x{{a,b}}y ==> x{a}y x{b}y - n = expand_(n[0], max, maxLength, false).map(embrace); + n = expand_(n[0], max, maxLength, maxDepth, depth + 1, maxRewrites, false).map(embrace); //XXX is this necessary? Can't seem to hit it in tests. /* c8 ignore start */ if (n.length === 1) { @@ -262,12 +305,13 @@ function expand_(str, max, maxLength, isTop) { values = []; let valuesLength = 0; outer: for (let j = 0; j < n.length; j++) { - const expanded = expand_(n[j], max, maxLength, false); + const expanded = expand_(n[j], max, maxLength, maxDepth, depth + 1, maxRewrites, false); for (let k = 0; k < expanded.length; k++) { const v = expanded[k]; if (dropsEmpties && !v) continue; - if (values.length >= max || valuesLength + v.length > maxLength) { + if (values.length >= max || + valuesLength + v.length > maxLength) { break outer; } values.push(v); diff --git a/deps/npm/node_modules/brace-expansion/package.json b/deps/npm/node_modules/brace-expansion/package.json index 4376400796c..a5c96ebe02f 100644 --- a/deps/npm/node_modules/brace-expansion/package.json +++ b/deps/npm/node_modules/brace-expansion/package.json @@ -1,7 +1,7 @@ { "name": "brace-expansion", "description": "Brace expansion as known from sh/bash", - "version": "5.0.9", + "version": "5.0.12", "files": [ "dist" ], @@ -29,6 +29,7 @@ "test": "tap", "snap": "tap", "format": "prettier --write .", + "format:check": "prettier --check .", "benchmark": "node benchmark/index.js", "typedoc": "typedoc --tsconfig .tshy/esm.json ./src/*.ts" }, diff --git a/deps/npm/node_modules/http-cache-semantics/index.js b/deps/npm/node_modules/http-cache-semantics/index.js index f01e9a16b47..56c26025074 100644 --- a/deps/npm/node_modules/http-cache-semantics/index.js +++ b/deps/npm/node_modules/http-cache-semantics/index.js @@ -334,12 +334,13 @@ module.exports = class CachePolicy { /** * @param {{headers: Record, synchronous: boolean}|undefined} revalidation - Revalidation information, if any. - * @returns {{response: {headers: Record}, revalidation: {headers: Record, synchronous: boolean}|undefined}} An object with a cached response headers and revalidation info. + * @returns {{response: HttpResponse, revalidation: {headers: Record, synchronous: boolean}|undefined}} An object with a cached response headers and revalidation info. */ _evaluateRequestHitResult(revalidation) { return { response: { headers: this.responseHeaders(), + status: this._status, }, revalidation, }; @@ -387,9 +388,9 @@ module.exports = class CachePolicy { * } * ``` * @param {HttpRequest} req - new incoming HTTP request - * @returns {{response: {headers: Record}|undefined, revalidation: {headers: Record, synchronous: boolean}|undefined}} An object containing keys: + * @returns {{response: HttpResponse|undefined, revalidation: {headers: Record, synchronous: boolean}|undefined}} An object containing keys: * - revalidation: { headers: Record, synchronous: boolean } Set if you should send this to the origin server - * - response: { headers: Record } Set if you can respond to the client with these cached headers + * - response: HttpResponse Set if you can respond to the client with these cached headers */ evaluateRequest(req) { this._assertRequestHasHeaders(req); @@ -484,18 +485,32 @@ module.exports = class CachePolicy { return true; } - // A Vary header field-value of "*" always fails to match - if (this._resHeaders.vary === '*') { - return false; - } - const fields = this._resHeaders.vary .trim() .toLowerCase() .split(/\s*,\s*/); + for (const name of fields) { - if (req.headers[name] !== this._reqHeaders[name]) return false; + // A Vary header field-value of "*" always fails to match + if (name === '*') { + return false; + } + + const newReq = Object.prototype.hasOwnProperty.call( + req.headers, + name + ) && req.headers[name]; + + const cachedReq = Object.prototype.hasOwnProperty.call( + this._reqHeaders, + name + ) && this._reqHeaders[name]; + + if (newReq !== cachedReq) { + return false; + } } + return true; } @@ -556,6 +571,14 @@ module.exports = class CachePolicy { return headers; } + /** + * Returns the status code of the cached response. + * @returns {number} The response status code. + */ + status() { + return this._status; + } + /** * Returns the Date header value from the response or the current time if invalid. * @returns {number} Timestamp (in milliseconds) representing the Date header or response time. diff --git a/deps/npm/node_modules/http-cache-semantics/package.json b/deps/npm/node_modules/http-cache-semantics/package.json index d45dfa1274e..06a565ffb7e 100644 --- a/deps/npm/node_modules/http-cache-semantics/package.json +++ b/deps/npm/node_modules/http-cache-semantics/package.json @@ -1,6 +1,6 @@ { "name": "http-cache-semantics", - "version": "4.2.0", + "version": "4.3.0", "description": "Parses Cache-Control and other headers. Helps building correct HTTP caches and proxies", "repository": { "type": "git", @@ -14,9 +14,9 @@ "files": [ "index.js" ], - "author": "Kornel Lesiński (https://kornel.ski/)", + "author": "Kornel Lesiński (https://kornel.ski/)", "license": "BSD-2-Clause", "devDependencies": { - "mocha": "^11.0" + "mocha": "^12.0" } } diff --git a/deps/npm/node_modules/ip-address/dist/common.js b/deps/npm/node_modules/ip-address/dist/common.js index 0c15d21e3a3..9c9ecf03ff2 100644 --- a/deps/npm/node_modules/ip-address/dist/common.js +++ b/deps/npm/node_modules/ip-address/dist/common.js @@ -2,6 +2,8 @@ Object.defineProperty(exports, "__esModule", { value: true }); exports.isInSubnet = isInSubnet; exports.isHostInSubnet = isHostInSubnet; +exports.isGloballyReachable = isGloballyReachable; +exports.offsetBigInt = offsetBigInt; exports.isCorrect = isCorrect; exports.prefixLengthFromMask = prefixLengthFromMask; exports.assertByteArray = assertByteArray; @@ -36,10 +38,56 @@ function isInSubnet(address) { * {@link isInSubnet} when classifying a single address — notably when the * address came from untrusted input and the result backs a trust-boundary * decision such as an SSRF allow/deny filter. + * + * An address of one family is never inside a network of the other, so an + * `Address4` against an `Address6` (or the reverse) is `false`. To compare + * across families, convert first: `Address6.fromAddress4()`, `to4()`, or + * `toAddress4Nat64()`. */ function isHostInSubnet(address) { + // mask() is a bit string of the family's width, and the leading bits of a + // 32-bit string can coincide with those of a 128-bit one (a00::1 and + // 10.0.0.0/8 both mask to 00001010), so the widths must agree before the + // strings are compared. + if (this.binaryZeroPad().length !== address.binaryZeroPad().length) { + return false; + } return this.mask(address.subnetMask) === address.mask(); } +/** + * Returns whether the registry marks this address globally reachable: the + * answer of the most specific entry containing it that has one, or `true` + * when no entry contains it. + */ +function isGloballyReachable(entries) { + let best = null; + for (let i = 0; i < entries.length; i++) { + const entry = entries[i]; + if (entry.reachable !== null && + isHostInSubnet.call(this, entry.subnet) && + (best === null || entry.subnet.subnetMask > best.subnet.subnetMask)) { + best = entry; + } + } + return best === null ? true : best.reachable; +} +/** + * Adds `n` to `value` and returns the result, throwing `AddressError` unless + * `n` is an integer and the result stays within `[0, 2**bits - 1]`. + */ +function offsetBigInt(value, n, bits, family) { + if (typeof n === 'number' && !Number.isSafeInteger(n)) { + throw new address_error_1.AddressError(`${family} offset must be an integer`); + } + if (typeof n !== 'number' && typeof n !== 'bigint') { + throw new address_error_1.AddressError(`${family} offset must be an integer`); + } + const result = value + BigInt(n); + if (result < BigInt(0) || result > (BigInt(1) << BigInt(bits)) - BigInt(1)) { + throw new address_error_1.AddressError(`${family} offset leaves the address space`); + } + return result; +} function isCorrect(defaultBits) { return function isCorrectForm() { if (this.addressMinusSuffix !== this.correctForm()) { @@ -97,10 +145,10 @@ function stringToPaddedHex(numberString) { */ function testBit(binaryValue, position) { const { length } = binaryValue; - if (position > length) { + if (position >= length) { return false; } - const positionInString = length - position; + const positionInString = length - position - 1; return binaryValue.substring(positionInString, positionInString + 1) === '1'; } //# sourceMappingURL=common.js.map \ No newline at end of file diff --git a/deps/npm/node_modules/ip-address/dist/ipv4.js b/deps/npm/node_modules/ip-address/dist/ipv4.js index 1360e1836a0..4b9cf98b608 100644 --- a/deps/npm/node_modules/ip-address/dist/ipv4.js +++ b/deps/npm/node_modules/ip-address/dist/ipv4.js @@ -48,7 +48,9 @@ class Address4 { */ this.isCorrect = isCorrect4; /** - * Returns true if the given address is in the subnet of the current address + * Returns true if the given address is in the subnet of the current address. + * An `Address6` is never in the subnet of an `Address4`; convert with + * `to4()` or `Address6.fromAddress4()` to compare across families. * @returns {boolean} */ this.isInSubnet = common.isInSubnet; @@ -58,6 +60,8 @@ class Address4 { * when classifying a single address, so the answer doesn't change with the * CIDR suffix the caller happened to write — notably when the address came * from untrusted input and the result backs a trust-boundary decision. + * An `Address6` is never in the subnet of an `Address4`; convert with + * `to4()` or `Address6.fromAddress4()` to compare across families. * @returns {boolean} */ this.isHostInSubnet = common.isHostInSubnet; @@ -72,6 +76,13 @@ class Address4 { } address = address.replace(constants.RE_SUBNET_STRING, ''); } + // Four three-digit octets and three dots: the longest well-formed address + // is 15 characters. Longer input is rejected before parsing, as Address6 + // does at its own limit. + const longest = constants.GROUPS * 4 - 1; + if (address.length > longest) { + throw new address_error_1.AddressError(`IPv4 addresses are at most ${longest} characters.`); + } this.addressMinusSuffix = address; this.parsedAddress = this.parse(address); } @@ -213,16 +224,27 @@ class Address4 { return Address4.fromHex(integer.toString(16).padStart(8, '0')); } /** - * Return an address from in-addr.arpa form + * Return an address from in-addr.arpa form: the four octets reversed, with + * or without the `.in-addr.arpa` suffix and root dot, in any case. Throws + * `AddressError` unless the reversed labels form a valid IPv4 address, so + * `fromArpa(x.reverseForm())` round-trips {@link reverseForm}. * @param {string} arpaFormAddress - an 'in-addr.arpa' form ipv4 address * @returns {Adress4} * @example - * var address = Address4.fromArpa(42.2.0.192.in-addr.arpa.) + * var address = Address4.fromArpa('42.2.0.192.in-addr.arpa.') * address.correctForm(); // '192.0.2.42' */ static fromArpa(arpaFormAddress) { - // remove ending ".in-addr.arpa." or just "." - const leader = arpaFormAddress.replace(/(\.in-addr\.arpa)?\.$/, ''); + // A 15-character address, a "/32" prefix length and ".in-addr.arpa.": the + // longest name is 32 characters. Longer input is rejected before its + // labels are split, as the constructor does at its own limit. + const longest = constants.GROUPS * 4 - 1 + '/32'.length + '.in-addr.arpa.'.length; + if (arpaFormAddress.length > longest) { + throw new address_error_1.AddressError(`in-addr.arpa names are at most ${longest} characters.`); + } + // remove an ending ".in-addr.arpa", in any case and with or without the + // root dot, as Address6.fromArpa does for ".ip6.arpa" + const leader = arpaFormAddress.replace(/(\.in-addr\.arpa)?\.?$/i, ''); const address = leader.split('.').reverse().join('.'); return new Address4(address); } @@ -285,6 +307,33 @@ class Address4 { const adjust = BigInt('1'); return Address4.fromBigInt(this._startAddress() + adjust); } + /** + * Returns the address `n` addresses after this one (or before, when `n` is + * negative), keeping this address's subnet mask. Throws `AddressError` when + * the result would fall outside the IPv4 address space or `n` is not an + * integer. + * @param {number | bigint} n + * @returns {Address4} + * @example + * new Address4('10.0.0.0/24').offset(1).correctForm(); // '10.0.0.1' + */ + offset(n) { + return Address4.fromBigInt(common.offsetBigInt(this.bigInt(), n, constants.BITS, 'IPv4')).withSubnetMask(this.subnetMask); + } + /** + * Returns the network that follows this address's network: the address after + * {@link endAddress}, with the same subnet mask. Throws `AddressError` when + * this network is the last one in the address space. + * @returns {Address4} + * @example + * new Address4('10.0.0.0/24').nextNetwork().networkForm(); // '10.0.1.0/24' + */ + nextNetwork() { + return Address4.fromBigInt(common.offsetBigInt(this._endAddress(), 1, constants.BITS, 'IPv4')).withSubnetMask(this.subnetMask); + } + withSubnetMask(subnetMask) { + return new Address4(`${this.correctForm()}/${subnetMask}`); + } /** * Helper function getting end address. * @returns {bigint} @@ -462,6 +511,43 @@ class Address4 { isCGNAT() { return this.isHostInSubnet(CGNAT_V4); } + /** + * Returns true if the address is in one of the documentation ranges + * `192.0.2.0/24`, `198.51.100.0/24`, or `203.0.113.0/24` ([RFC 5737](https://datatracker.ietf.org/doc/html/rfc5737)). + * @returns {boolean} + */ + isDocumentation() { + return DOCUMENTATION_V4.some((subnet) => this.isHostInSubnet(subnet)); + } + /** + * Returns true if the address is in the benchmarking range `198.18.0.0/15` ([RFC 2544](https://datatracker.ietf.org/doc/html/rfc2544)). + * @returns {boolean} + */ + isBenchmarking() { + return this.isHostInSubnet(BENCHMARKING_V4); + } + /** + * Returns true if the address is in the reserved range `240.0.0.0/4` ([RFC 1112](https://datatracker.ietf.org/doc/html/rfc1112)), + * which includes the limited broadcast address. + * @returns {boolean} + */ + isReserved() { + return this.isHostInSubnet(RESERVED_V4); + } + /** + * Returns true if the address is globally reachable: not multicast, and not + * in any block the [IANA IPv4 Special-Purpose Address Registry](https://www.iana.org/assignments/iana-ipv4-special-registry/) + * marks as not globally reachable. That covers everything the individual + * classifiers name (private, loopback, link-local, CGNAT, unspecified, + * broadcast, documentation, benchmarking, reserved) and the blocks they do + * not, such as `0.0.0.0/8` and the IETF protocol assignments in + * `192.0.0.0/24`. This is the single predicate to use where a request must + * not reach an internal or special-purpose destination; see SECURITY.md. + * @returns {boolean} + */ + isGlobal() { + return !this.isMulticast() && common.isGloballyReachable.call(this, SPECIAL_PURPOSE_V4); + } /** * Returns a zero-padded base-2 string representation of the address * @returns {string} @@ -502,4 +588,15 @@ const LINK_LOCAL_V4 = new Address4('169.254.0.0/16'); const UNSPECIFIED_V4 = new Address4('0.0.0.0/32'); const BROADCAST_V4 = new Address4('255.255.255.255/32'); const CGNAT_V4 = new Address4('100.64.0.0/10'); +const DOCUMENTATION_V4 = [ + new Address4('192.0.2.0/24'), + new Address4('198.51.100.0/24'), + new Address4('203.0.113.0/24'), +]; +const BENCHMARKING_V4 = new Address4('198.18.0.0/15'); +const RESERVED_V4 = new Address4('240.0.0.0/4'); +const SPECIAL_PURPOSE_V4 = constants.SPECIAL_PURPOSE.map(([cidr, , reachable]) => ({ + subnet: new Address4(cidr), + reachable, +})); //# sourceMappingURL=ipv4.js.map \ No newline at end of file diff --git a/deps/npm/node_modules/ip-address/dist/ipv6.js b/deps/npm/node_modules/ip-address/dist/ipv6.js index d5f4fdb9c87..e1c840c02b9 100644 --- a/deps/npm/node_modules/ip-address/dist/ipv6.js +++ b/deps/npm/node_modules/ip-address/dist/ipv6.js @@ -92,7 +92,9 @@ class Address6 { this.zone = ''; // #region Attributes /** - * Returns true if the given address is in the subnet of the current address + * Returns true if the given address is in the subnet of the current address. + * An `Address4` is never in the subnet of an `Address6`; convert with + * `Address6.fromAddress4()` or `to4()` to compare across families. * @returns {boolean} */ this.isInSubnet = common.isInSubnet; @@ -102,6 +104,8 @@ class Address6 { * when classifying a single address, so the answer doesn't change with the * CIDR suffix the caller happened to write — notably when the address came * from untrusted input and the result backs a trust-boundary decision. + * An `Address4` is never in the subnet of an `Address6`; convert with + * `Address6.fromAddress4()` or `to4()` to compare across families. * @returns {boolean} */ this.isHostInSubnet = common.isHostInSubnet; @@ -135,10 +139,23 @@ class Address6 { if (/\//.test(address)) { throw new address_error_1.AddressError('Invalid subnet mask.'); } - const zone = constants6.RE_ZONE_STRING.exec(address); - if (zone) { - this.zone = zone[0]; - address = address.replace(constants6.RE_ZONE_STRING, ''); + // A zone runs from the first `%` to the end of the input and holds no line + // terminator. Finding it by index reads the input once, where matching + // RE_ZONE_STRING retries from every `%` that a line terminator disqualifies. + const zoneStart = address.indexOf('%'); + if (zoneStart !== -1 && /^.*$/.test(address.slice(zoneStart))) { + this.zone = address.slice(zoneStart); + address = address.slice(0, zoneStart); + } + // The longest well-formed address is all but the last two groups written + // as four hex digits with their colons, then a 15-character dotted quad: + // 5 * (groups - 2) + 15, which is 45 for eight groups, the same line + // CPython's ipaddress module draws. Rejecting longer input here keeps the + // parse diagnostics, which wrap every offending character in a span, + // proportional to an address rather than to whatever was passed in. + const longest = this.groups * 5 + 5; + if (address.length > longest) { + throw new address_error_1.AddressError(`IPv6 addresses are at most ${longest} characters.`); } this.addressMinusSuffix = address; this.parsedAddress = this.parse(this.addressMinusSuffix); @@ -339,28 +356,32 @@ class Address6 { return new Address6(`::ffff:${address4.correctForm()}/${mask6}`); } /** - * Return an address from ip6.arpa form + * Return an address from ip6.arpa form. A full 32-nibble name gives a /128 + * address; a shorter name, as used for a delegated reverse zone, gives the + * network it covers, with a subnet mask of four bits per nibble, so + * `fromArpa(x.reverseForm())` round-trips {@link reverseForm} for any prefix. * @param {string} arpaFormAddress - an 'ip6.arpa' form address * @returns {Adress6} * @example * var address = Address6.fromArpa(e.f.f.f.3.c.2.6.f.f.f.e.6.6.8.e.1.0.6.7.9.4.e.c.0.0.0.0.1.0.0.2.ip6.arpa.) * address.correctForm(); // '2001:0:ce49:7601:e866:efff:62c3:fffe' + * Address6.fromArpa('8.b.d.0.1.0.0.2.ip6.arpa.').networkForm(); // '2001:db8::/32' */ static fromArpa(arpaFormAddress) { - // remove ending ".ip6.arpa." or just "." - let address = arpaFormAddress.replace(/(\.ip6\.arpa)?\.$/, ''); - const semicolonAmount = 7; - // correct ip6.arpa form with ending removed will be 63 characters - if (address.length !== 63) { + // remove an ending ".ip6.arpa", in any case and with or without the root + // dot + const nibbles = arpaFormAddress.replace(/(\.ip6\.arpa)?\.?$/i, ''); + if (!/^[0-9a-f](\.[0-9a-f]){0,31}$/i.test(nibbles)) { throw new address_error_1.AddressError("Invalid 'ip6.arpa' form."); } - const parts = address.split('.').reverse(); - for (let i = semicolonAmount; i > 0; i--) { - const insertIndex = i * 4; - parts.splice(insertIndex, 0, ':'); + const reversed = nibbles.split('.').reverse(); + const subnetMask = reversed.length * 4; + const hex = reversed.join('').padEnd(32, '0'); + const groups = []; + for (let i = 0; i < constants6.GROUPS; i++) { + groups.push(hex.slice(i * 4, (i + 1) * 4)); } - address = parts.join(''); - return new Address6(address); + return new Address6(`${groups.join(':')}/${subnetMask}`); } /** * Return the Microsoft UNC transcription of the address @@ -424,22 +445,53 @@ class Address6 { return BigInt(`0b${this.mask() + '1'.repeat(constants6.BITS - this.subnetMask)}`); } /** - * The last address in the range given by this address' subnet - * Often referred to as the Broadcast + * The last address in the range given by this address's subnet. IPv6 has + * no broadcast address, so this is an ordinary assignable address (in a + * 64-bit-interface-identifier subnet it falls inside the reserved + * subnet-anycast block of [RFC 2526](https://datatracker.ietf.org/doc/html/rfc2526)). * @returns {Address6} */ endAddress() { return Address6.fromBigInt(this._endAddress()); } /** - * The last host address in the range given by this address's subnet ie - * the last address prior to the Broadcast Address + * The address one before {@link endAddress}. This is the IPv6 counterpart + * of the IPv4 method that skips the broadcast address; IPv6 has no broadcast, + * so it drops exactly one address and does not model the 128 reserved + * subnet-anycast identifiers of [RFC 2526](https://datatracker.ietf.org/doc/html/rfc2526). * @returns {Address6} */ endAddressExclusive() { const adjust = BigInt('1'); return Address6.fromBigInt(this._endAddress() - adjust); } + /** + * Returns the address `n` addresses after this one (or before, when `n` is + * negative), keeping this address's subnet mask. Throws `AddressError` when + * the result would fall outside the IPv6 address space or `n` is not an + * integer. + * @param {number | bigint} n + * @returns {Address6} + * @example + * new Address6('2001:db8::/64').offset(1).correctForm(); // '2001:db8::1' + */ + offset(n) { + return Address6.fromBigInt(common.offsetBigInt(this.bigInt(), n, constants6.BITS, 'IPv6')).withSubnetMask(this.subnetMask); + } + /** + * Returns the network that follows this address's network: the address after + * {@link endAddress}, with the same subnet mask. Throws `AddressError` when + * this network is the last one in the address space. + * @returns {Address6} + * @example + * new Address6('2001:db8::/64').nextNetwork().networkForm(); // '2001:db8:0:1::/64' + */ + nextNetwork() { + return Address6.fromBigInt(common.offsetBigInt(this._endAddress(), 1, constants6.BITS, 'IPv6')).withSubnetMask(this.subnetMask); + } + withSubnetMask(subnetMask) { + return new Address6(`${this.correctForm()}/${subnetMask}`); + } /** * The hex form of the subnet mask, e.g. `ffff:ffff:ffff:ffff::` for a * `/64`. Returns an `Address6`; call `.correctForm()` for the string. @@ -1022,7 +1074,10 @@ class Address6 { return this.addressMinusSuffix === this.canonicalForm(); } /** - * Returns true if the address is a link local address, false otherwise + * Returns true if the address is a link-local unicast address in `fe80::/10` + * ([RFC 4291 §2.4](https://datatracker.ietf.org/doc/html/rfc4291#section-2.4)) + * or an IPv4-mapped / NAT64 address whose embedded IPv4 address is link-local + * (`169.254.0.0/16`, e.g. `::ffff:169.254.169.254`), false otherwise. * @returns {boolean} */ isLinkLocal() { @@ -1030,12 +1085,7 @@ class Address6 { if (embedded) { return embedded.isLinkLocal(); } - // Zeroes are required, i.e. we can't check isHostInSubnet with 'fe80::/10' - if (this.getBitsBase2(0, 64) === - '1111111010000000000000000000000000000000000000000000000000000000') { - return true; - } - return false; + return this.isHostInSubnet(LINK_LOCAL_SUBNET); } /** * Returns true if the address is a multicast address, false otherwise @@ -1127,12 +1177,20 @@ class Address6 { } /** * Returns true if the address is private, i.e. a Unique Local Address in - * `fc00::/7` ([RFC 4193](https://datatracker.ietf.org/doc/html/rfc4193)) or an - * IPv4-mapped / NAT64 address whose embedded IPv4 address is in one of the - * [RFC 1918](https://datatracker.ietf.org/doc/html/rfc1918) private ranges - * (e.g. `::ffff:10.0.0.1`). This is the IPv6 counterpart to + * `fc00::/7` ([RFC 4193](https://datatracker.ietf.org/doc/html/rfc4193)), an + * address in the NAT64 local-use range `64:ff9b:1::/48` + * ([RFC 8215](https://datatracker.ietf.org/doc/html/rfc8215)), or an + * IPv4-mapped / NAT64 well-known address whose embedded IPv4 address is in + * one of the [RFC 1918](https://datatracker.ietf.org/doc/html/rfc1918) + * private ranges (e.g. `::ffff:10.0.0.1`). This is the IPv6 counterpart to * {@link Address4.isPrivate}; use it instead of {@link isULA} when you need to * catch mapped RFC 1918 addresses as well as native ULAs. + * + * The local-use NAT64 range is reported private as a whole rather than by + * its embedded IPv4 address: an operator may carve a prefix of any RFC 6052 + * length out of `64:ff9b:1::/48`, so the same bits decode to different IPv4 + * addresses under different deployments and no single decoding is correct. + * Use {@link toAddress4Nat64} with the deployment's prefix to decode one. * @returns {boolean} */ isPrivate() { @@ -1140,7 +1198,7 @@ class Address6 { if (embedded) { return embedded.isPrivate(); } - return this.isULA(); + return this.isULA() || this.isHostInSubnet(NAT64_LOCAL_USE_SUBNET); } /** * Returns true if the address is an IPv4-mapped / NAT64 address whose embedded @@ -1188,7 +1246,49 @@ class Address6 { * @returns {boolean} */ isDocumentation() { - return this.isHostInSubnet(DOCUMENTATION_SUBNET); + return DOCUMENTATION_SUBNETS.some((subnet) => this.isHostInSubnet(subnet)); + } + /** + * Returns true if the address is in the benchmarking range `2001:2::/48` + * ([RFC 5180](https://datatracker.ietf.org/doc/html/rfc5180)) or is an + * IPv4-mapped / NAT64 address whose embedded IPv4 address is in + * `198.18.0.0/15`, false otherwise. + * @returns {boolean} + */ + isBenchmarking() { + const embedded = this.embeddedIPv4(); + if (embedded) { + return embedded.isBenchmarking(); + } + return this.isHostInSubnet(BENCHMARKING_SUBNET); + } + /** + * Returns true if the address is globally reachable: inside the global + * unicast allocation `2000::/3` (the only range the [IANA IPv6 Address Space + * Registry](https://www.iana.org/assignments/ipv6-address-space/) assigns + * for global unicast; everything else is reserved, ULA, link-local, or + * multicast) and not in any block the [IANA IPv6 Special-Purpose Address Registry](https://www.iana.org/assignments/iana-ipv6-special-registry/) + * marks as not globally reachable. An IPv4-mapped or NAT64 well-known + * address answers for its embedded IPv4 address, so `::ffff:10.0.0.1` and + * `64:ff9b::7f00:1` are not global. Teredo (`2001::/32`) and 6to4 + * (`2002::/16`) are not global either: the registry lists them as N/A and a + * packet to one needs a relay. + * + * This covers everything the individual classifiers name and the blocks they + * do not: the discard-only prefix `100::/64`, the IETF protocol assignments + * in `2001::/23`, the deprecated site-local `fec0::/10` and IPv4-compatible + * `::/96` ranges, and unallocated space such as `4000::/3`. It is the single + * predicate to use where a request must not reach an internal or + * special-purpose destination; see SECURITY.md. + * @returns {boolean} + */ + isGlobal() { + const embedded = this.embeddedIPv4(); + if (embedded) { + return embedded.isGlobal(); + } + return (this.isHostInSubnet(GLOBAL_UNICAST_SUBNET) && + common.isGloballyReachable.call(this, SPECIAL_PURPOSE_V6)); } // #endregion // #region HTML @@ -1347,7 +1447,15 @@ const TYPE_SUBNETS = Object.keys(constants6.TYPES).map((subnet) => [ const TEREDO_SUBNET = new Address6('2001::/32'); const SIX_TO_FOUR_SUBNET = new Address6('2002::/16'); const ULA_SUBNET = new Address6('fc00::/7'); -const DOCUMENTATION_SUBNET = new Address6('2001:db8::/32'); +const LINK_LOCAL_SUBNET = new Address6('fe80::/10'); +const DOCUMENTATION_SUBNETS = [new Address6('2001:db8::/32'), new Address6('3fff::/20')]; +const BENCHMARKING_SUBNET = new Address6('2001:2::/48'); +const GLOBAL_UNICAST_SUBNET = new Address6('2000::/3'); +const SPECIAL_PURPOSE_V6 = constants6.SPECIAL_PURPOSE.map(([cidr, , reachable]) => ({ + subnet: new Address6(cidr), + reachable, +})); const IPV4_MAPPED_SUBNET = new Address6('::ffff:0:0/96'); const NAT64_WELL_KNOWN_SUBNET = new Address6('64:ff9b::/96'); +const NAT64_LOCAL_USE_SUBNET = new Address6('64:ff9b:1::/48'); //# sourceMappingURL=ipv6.js.map \ No newline at end of file diff --git a/deps/npm/node_modules/ip-address/dist/v4/constants.js b/deps/npm/node_modules/ip-address/dist/v4/constants.js index 158288b7de6..f25120d6068 100644 --- a/deps/npm/node_modules/ip-address/dist/v4/constants.js +++ b/deps/npm/node_modules/ip-address/dist/v4/constants.js @@ -1,6 +1,6 @@ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -exports.RE_SUBNET_STRING = exports.RE_ADDRESS = exports.GROUPS = exports.BITS = void 0; +exports.SPECIAL_PURPOSE = exports.RE_SUBNET_STRING = exports.RE_ADDRESS = exports.GROUPS = exports.BITS = void 0; exports.BITS = 32; exports.GROUPS = 4; // Each octet is 0-255 written without a leading zero. A leading zero is @@ -9,4 +9,43 @@ exports.GROUPS = 4; // disagree with the network stack about which host a string names. exports.RE_ADDRESS = /^(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])$/g; exports.RE_SUBNET_STRING = /\/\d{1,2}$/; +/** + * The IANA IPv4 Special-Purpose Address Registry + * (https://www.iana.org/assignments/iana-ipv4-special-registry/), one entry + * per block: `[cidr, name, globallyReachable]`. A `null` reachability means + * the registry leaves the column blank and the block inherits the answer of + * the block containing it (or is global when nothing contains it). + * + * `Address4.isGlobal()` answers from the most specific entry containing the + * address. `test/data/iana-corpus.json` is generated from the registry's CSV + * and pins this table to it. + */ +exports.SPECIAL_PURPOSE = [ + ['0.0.0.0/8', 'This network', false], + ['0.0.0.0/32', 'This host on this network', false], + ['10.0.0.0/8', 'Private-Use', false], + ['100.64.0.0/10', 'Shared Address Space', false], + ['127.0.0.0/8', 'Loopback', false], + ['169.254.0.0/16', 'Link Local', false], + ['172.16.0.0/12', 'Private-Use', false], + ['192.0.0.0/24', 'IETF Protocol Assignments', false], + ['192.0.0.0/29', 'IPv4 Service Continuity Prefix', false], + ['192.0.0.8/32', 'IPv4 dummy address', false], + ['192.0.0.9/32', 'Port Control Protocol Anycast', true], + ['192.0.0.10/32', 'Traversal Using Relays around NAT Anycast', true], + ['192.0.0.170/32', 'NAT64/DNS64 Discovery', false], + ['192.0.0.171/32', 'NAT64/DNS64 Discovery', false], + ['192.0.2.0/24', 'Documentation (TEST-NET-1)', false], + ['192.31.196.0/24', 'AS112-v4', true], + ['192.52.193.0/24', 'AMT', true], + ['192.88.99.0/24', 'Deprecated (6to4 Relay Anycast)', null], + ['192.88.99.2/32', '6a44-relay anycast address', false], + ['192.168.0.0/16', 'Private-Use', false], + ['192.175.48.0/24', 'Direct Delegation AS112 Service', true], + ['198.18.0.0/15', 'Benchmarking', false], + ['198.51.100.0/24', 'Documentation (TEST-NET-2)', false], + ['203.0.113.0/24', 'Documentation (TEST-NET-3)', false], + ['240.0.0.0/4', 'Reserved', false], + ['255.255.255.255/32', 'Limited Broadcast', false], +]; //# sourceMappingURL=constants.js.map \ No newline at end of file diff --git a/deps/npm/node_modules/ip-address/dist/v6/constants.js b/deps/npm/node_modules/ip-address/dist/v6/constants.js index 4616cad66b6..777146c1a1a 100644 --- a/deps/npm/node_modules/ip-address/dist/v6/constants.js +++ b/deps/npm/node_modules/ip-address/dist/v6/constants.js @@ -1,6 +1,6 @@ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -exports.RE_URL_WITH_PORT = exports.RE_URL = exports.RE_ZONE_STRING = exports.RE_SUBNET_STRING = exports.RE_BAD_ADDRESS = exports.RE_BAD_CHARACTERS = exports.TYPES = exports.SCOPES = exports.GROUPS = exports.BITS = void 0; +exports.SPECIAL_PURPOSE = exports.RE_URL_WITH_PORT = exports.RE_URL = exports.RE_ZONE_STRING = exports.RE_SUBNET_STRING = exports.RE_BAD_ADDRESS = exports.RE_BAD_CHARACTERS = exports.TYPES = exports.SCOPES = exports.GROUPS = exports.BITS = void 0; exports.BITS = 128; exports.GROUPS = 8; /** @@ -48,8 +48,14 @@ exports.TYPES = { 'ff00::/8': 'Multicast', 'fe80::/10': 'Link-local unicast', 'fc00::/7': 'Unique local', + '2001::/32': 'Teredo', + '2001:2::/48': 'Benchmarking', '2002::/16': '6to4', '2001:db8::/32': 'Documentation', + '3fff::/20': 'Documentation', + '100::/64': 'Discard-only', + 'fec0::/10': 'Site-local unicast (deprecated)', + '::/96': 'IPv4-compatible (deprecated)', '64:ff9b::/96': 'NAT64 (well-known)', '64:ff9b:1::/48': 'NAT64 (local-use)', }; @@ -75,8 +81,51 @@ exports.RE_SUBNET_STRING = /\/\d{1,3}(?=%|$)/; * A regular expression that matches an IPv6 zone * @memberof Address6 * @static + * @deprecated Takes quadratic time on input holding many `%` characters + * followed by a line terminator. The library finds the zone by index, as + * `Address6`'s constructor shows, and 11.0.0 removes this export. */ exports.RE_ZONE_STRING = /%.*$/; exports.RE_URL = /^(?:\[([0-9a-f:.]+)\]|([0-9a-f:.]+))(?:[/?#].*)?$/i; exports.RE_URL_WITH_PORT = /^\[([0-9a-f:.]+)\]:([0-9]{1,5})(?:[/?#].*)?$/i; +/** + * The IANA IPv6 Special-Purpose Address Registry + * (https://www.iana.org/assignments/iana-ipv6-special-registry/), one entry + * per block: `[cidr, name, globallyReachable]`. A `null` reachability means + * the registry says N/A or leaves the column blank; N/A blocks (Teredo, 6to4) + * are treated as not globally reachable, since a packet to one needs a relay, + * and blank blocks inherit the answer of the block containing them. + * + * `Address6.isGlobal()` answers from the most specific entry containing the + * address, after delegating IPv4-mapped and NAT64 well-known addresses to the + * embedded IPv4 address. `test/data/iana-corpus.json` is generated from the + * registry's CSV and pins this table to it. + */ +exports.SPECIAL_PURPOSE = [ + ['::1/128', 'Loopback Address', false], + ['::/128', 'Unspecified Address', false], + ['::ffff:0:0/96', 'IPv4-mapped Address', false], + ['64:ff9b::/96', 'IPv4-IPv6 Translat.', true], + ['64:ff9b:1::/48', 'IPv4-IPv6 Translat.', false], + ['100::/64', 'Discard-Only Address Block', false], + ['100:0:0:1::/64', 'Dummy IPv6 Prefix', false], + ['2001::/23', 'IETF Protocol Assignments', false], + ['2001::/32', 'TEREDO', false], + ['2001:1::1/128', 'Port Control Protocol Anycast', true], + ['2001:1::2/128', 'Traversal Using Relays around NAT Anycast', true], + ['2001:1::3/128', 'DNS-SD Service Registration Protocol Anycast', true], + ['2001:2::/48', 'Benchmarking', false], + ['2001:3::/32', 'AMT', true], + ['2001:4:112::/48', 'AS112-v6', true], + ['2001:10::/28', 'Deprecated (previously ORCHID)', null], + ['2001:20::/28', 'ORCHIDv2', true], + ['2001:30::/28', 'Drone Remote ID Protocol Entity Tags (DETs) Prefix', true], + ['2001:db8::/32', 'Documentation', false], + ['2002::/16', '6to4', false], + ['2620:4f:8000::/48', 'Direct Delegation AS112 Service', true], + ['3fff::/20', 'Documentation', false], + ['5f00::/16', 'Segment Routing (SRv6) SIDs', false], + ['fc00::/7', 'Unique-Local', false], + ['fe80::/10', 'Link-Local Unicast', false], +]; //# sourceMappingURL=constants.js.map \ No newline at end of file diff --git a/deps/npm/node_modules/ip-address/package.json b/deps/npm/node_modules/ip-address/package.json index 6ea2d24bd62..ee0bdeca619 100644 --- a/deps/npm/node_modules/ip-address/package.json +++ b/deps/npm/node_modules/ip-address/package.json @@ -16,13 +16,14 @@ "bigint", "browser" ], - "version": "10.5.0", + "version": "10.7.5", "author": "Beau Gunderson (https://beaugunderson.com/)", "license": "MIT", "main": "dist/ip-address.js", "types": "dist/ip-address.d.ts", "scripts": { "docs": "tsx scripts/build-readme.ts", + "docs:check": "tsx scripts/build-readme.ts --check", "build": "rm -rf dist; mkdir dist; tsc", "prepack": "npm run docs && npm run build", "prepare": "git config core.hooksPath hooks || true", @@ -79,7 +80,7 @@ "eslint-plugin-import": "^2.32.0", "eslint-plugin-prettier": "^5.5.5", "eslint-plugin-sort-imports-es6-autofix": "^0.6.0", - "mocha": "^11.7.5", + "mocha": "^12.0.3", "monocart-coverage-reports": "^2.12.11", "prettier": "^3.8.3", "source-map-support": "^0.5.21", diff --git a/deps/npm/node_modules/libnpmdiff/package.json b/deps/npm/node_modules/libnpmdiff/package.json index f9836046f44..c94bf2cfd54 100644 --- a/deps/npm/node_modules/libnpmdiff/package.json +++ b/deps/npm/node_modules/libnpmdiff/package.json @@ -1,6 +1,6 @@ { "name": "libnpmdiff", - "version": "8.1.13", + "version": "8.1.14", "description": "The registry diff", "repository": { "type": "git", @@ -47,7 +47,7 @@ "tap": "^16.3.8" }, "dependencies": { - "@npmcli/arborist": "^9.9.2", + "@npmcli/arborist": "^9.9.3", "@npmcli/installed-package-contents": "^4.0.0", "binary-extensions": "^3.0.0", "diff": "^8.0.2", diff --git a/deps/npm/node_modules/libnpmexec/README.md b/deps/npm/node_modules/libnpmexec/README.md index 84512ac5904..59c35f8a639 100644 --- a/deps/npm/node_modules/libnpmexec/README.md +++ b/deps/npm/node_modules/libnpmexec/README.md @@ -28,7 +28,7 @@ await libexec({ - `opts`: - `args`: List of pkgs to execute **Array**, defaults to `[]` - - `call`: An alternative command to run when using `packages` option **String**, defaults to empty string. + - `call`: An alternative shell script to run when using `packages` option **String**, defaults to empty string. Unlike an executable selected from `args` or a package's `bin`, this is intentionally interpreted as shell syntax. - `cache`: The path location to where the npm cache folder is placed **String** - `npxCache`: The path location to where the npx cache folder is placed **String** - `chalk`: Chalk instance to use for colors? **Required** @@ -42,6 +42,14 @@ await libexec({ - `yes`: Should skip download confirmation prompt when fetching missing packages from the registry? **Boolean** - `registry`, `cache`, and more options that are forwarded to [@npmcli/arborist](https://github.com/npm/cli/blob/latest/workspaces/arborist/README.md) and [pacote](https://github.com/npm/pacote/#options) **Object** + Executable names are escaped for the selected shell, including POSIX shells and + PowerShell used on Windows. For inferred PowerShell invocations, arguments are + also escaped as literal strings. With `cmd.exe`, executable names containing double + quotes, percent signs, exclamation marks, or control characters are rejected + with `EINVALIDCOMMAND`. Use a bin name without these characters. On a matching + npx-cache hit, command selection uses the installed package's `bin` rather than + the registry's bin metadata. + ## LICENSE [ISC](./LICENSE) diff --git a/deps/npm/node_modules/libnpmexec/lib/index.js b/deps/npm/node_modules/libnpmexec/lib/index.js index 4d7c1266546..56dcf7c7369 100644 --- a/deps/npm/node_modules/libnpmexec/lib/index.js +++ b/deps/npm/node_modules/libnpmexec/lib/index.js @@ -267,8 +267,8 @@ const exec = async (opts) => { }) const lockPath = join(installDir, 'concurrency.lock') const npxTree = await withLock(lockPath, () => npxArb.loadActual()) - await Promise.all(needInstall.map(async ({ spec }) => { - const { manifest } = await missingFromTree({ + await Promise.all(needInstall.map(async ({ spec, manifest: requestedManifest }) => { + const { manifest, node } = await missingFromTree({ spec, tree: npxTree, flatOptions, @@ -281,6 +281,10 @@ const exec = async (opts) => { } else { add.push(manifest._id) } + } else if (needPackageCommandSwap && commandManifest === requestedManifest) { + // A cache hit must use the installed bin, not mutable registry metadata. + commandManifest = node.package + args[0] = getBinFromManifest(commandManifest) } })) diff --git a/deps/npm/node_modules/libnpmexec/lib/run-script.js b/deps/npm/node_modules/libnpmexec/lib/run-script.js index 2de40454f9d..a7ce6915c74 100644 --- a/deps/npm/node_modules/libnpmexec/lib/run-script.js +++ b/deps/npm/node_modules/libnpmexec/lib/run-script.js @@ -3,7 +3,10 @@ const runScript = require('@npmcli/run-script') const pkgJson = require('@npmcli/package-json') const { log, output } = require('proc-log') const noTTY = require('./no-tty.js') -const isWindowsShell = require('./is-windows.js') +const isWindows = require('./is-windows.js') + +const isCmd = shell => /(?:^|[\\/])cmd(?:\.exe)?$/i.test(shell) +const isPowerShell = shell => /(?:^|[\\/])(?:powershell|pwsh)(?:\.exe)?$/i.test(shell) const run = async ({ args, @@ -15,10 +18,24 @@ const run = async ({ runPath, scriptShell, }) => { - // escape executable path - // necessary for preventing bash/cmd keywords from overriding - if (!isWindowsShell) { - if (args.length > 0) { + if (!call && args.length > 0) { + const shell = scriptShell || (isWindows ? process.env.ComSpec || 'cmd' : 'sh') + if (isCmd(shell)) { + // Variable expansion (including delayed expansion) and embedded quotes + // cannot be safely escaped here. Control characters are invalid filenames. + if (/["%!]/.test(args[0]) || [...args[0]].some(c => c.charCodeAt(0) < 32)) { + throw Object.assign( + new Error(`Invalid executable name for cmd.exe: ${JSON.stringify(args[0])}`), + { code: 'EINVALIDCOMMAND' } + ) + } + // Protect both cmd.exe's metacharacter parsing and executable-name parsing. + args[0] = `"${args[0]}"`.replace(/[ ^&()<>|";,*?=@]/g, '^$&') + } else if (isPowerShell(shell)) { + // Encode the whole invocation to avoid promise-spawn's POSIX argument escaping. + const quotedArgs = args.map(arg => `'${arg.replace(/['\u2018-\u201b]/g, '$&$&')}'`) + args = [`& ${quotedArgs.join(' ')}`] + } else { // single-quote so shell metacharacters in the executable name are taken // literally; double quotes still expand $(), backticks, $var and " args[0] = `'${args[0].replace(/'/g, `'\\''`)}'` diff --git a/deps/npm/node_modules/libnpmexec/package.json b/deps/npm/node_modules/libnpmexec/package.json index 116a7194043..4a050f2e609 100644 --- a/deps/npm/node_modules/libnpmexec/package.json +++ b/deps/npm/node_modules/libnpmexec/package.json @@ -1,6 +1,6 @@ { "name": "libnpmexec", - "version": "10.3.3", + "version": "10.3.5", "files": [ "bin/", "lib/" @@ -61,7 +61,7 @@ }, "dependencies": { "@gar/promise-retry": "^1.0.0", - "@npmcli/arborist": "^9.9.2", + "@npmcli/arborist": "^9.9.3", "@npmcli/package-json": "^7.0.0", "@npmcli/run-script": "^10.0.0", "ci-info": "^4.0.0", diff --git a/deps/npm/node_modules/libnpmfund/package.json b/deps/npm/node_modules/libnpmfund/package.json index dcae1eb7476..a11ee6d5b98 100644 --- a/deps/npm/node_modules/libnpmfund/package.json +++ b/deps/npm/node_modules/libnpmfund/package.json @@ -1,6 +1,6 @@ { "name": "libnpmfund", - "version": "7.0.27", + "version": "7.0.28", "main": "lib/index.js", "files": [ "bin/", @@ -46,7 +46,7 @@ "tap": "^16.3.8" }, "dependencies": { - "@npmcli/arborist": "^9.9.2" + "@npmcli/arborist": "^9.9.3" }, "engines": { "node": "^20.17.0 || >=22.9.0" diff --git a/deps/npm/node_modules/libnpmpack/package.json b/deps/npm/node_modules/libnpmpack/package.json index c4b3dc30d7e..e77a05ef6a1 100644 --- a/deps/npm/node_modules/libnpmpack/package.json +++ b/deps/npm/node_modules/libnpmpack/package.json @@ -1,6 +1,6 @@ { "name": "libnpmpack", - "version": "9.1.14", + "version": "9.1.15", "description": "Programmatic API for the bits behind npm pack", "author": "GitHub Inc.", "main": "lib/index.js", @@ -37,7 +37,7 @@ "bugs": "https://github.com/npm/libnpmpack/issues", "homepage": "https://npmjs.com/package/libnpmpack", "dependencies": { - "@npmcli/arborist": "^9.9.2", + "@npmcli/arborist": "^9.9.3", "@npmcli/run-script": "^10.0.0", "npm-package-arg": "^13.0.0", "pacote": "^21.0.2" diff --git a/deps/npm/node_modules/pacote/lib/registry.js b/deps/npm/node_modules/pacote/lib/registry.js index f50b27956db..25278564da9 100644 --- a/deps/npm/node_modules/pacote/lib/registry.js +++ b/deps/npm/node_modules/pacote/lib/registry.js @@ -113,6 +113,70 @@ class RegistryFetcher extends Fetcher { } } + // Registry signatures and attestations authenticate `name@version`, so the + // manifest must claim the requested name and be listed under its own + // version. Otherwise a registry could replay validly signed metadata from + // another package (or another version) and have it verify as this one. + #verifyManifestIdentity (packument, picked) { + const pickedId = `${picked.name}@${picked.version}` + if (picked.name !== this.spec.name) { + const message = [ + `${this.spec.name} registry manifest has mismatched package name:`, + `expected ${this.spec.name} but got ${pickedId}`, + ].join(' ') + throw Object.assign(new Error(message), { + code: 'EMANIFESTMISMATCH', + expected: this.spec.name, + found: pickedId, + }) + } + if (picked._id && picked._id !== pickedId) { + const message = [ + `${pickedId} registry manifest has mismatched id:`, + `expected ${pickedId} but got ${picked._id}`, + ].join(' ') + throw Object.assign(new Error(message), { + code: 'EMANIFESTMISMATCH', + expected: pickedId, + found: picked._id, + }) + } + + // without dist there are no signatures or attestations to authenticate + if (!picked.dist) { + return + } + + // npm-pick-manifest may return a shallow copy, so match on the dist object + const matchesPickedManifest = manifest => manifest.dist === picked.dist + const versionCollections = [ + packument.versions, + packument.stagedVersions?.versions, + packument.policyRestrictions?.versions, + ] + const matchingVersionKeys = [] + for (const manifestsByVersion of versionCollections) { + for (const versionKey in manifestsByVersion) { + if (Object.hasOwn(manifestsByVersion, versionKey) && + matchesPickedManifest(manifestsByVersion[versionKey])) { + matchingVersionKeys.push(versionKey) + } + } + } + + if (matchingVersionKeys.some(versionKey => versionKey !== picked.version)) { + const message = [ + `${pickedId} registry manifest has mismatched version:`, + `listed in the packument as ${matchingVersionKeys.join(', ')}`, + ].join(' ') + throw Object.assign(new Error(message), { + code: 'EMANIFESTMISMATCH', + expected: matchingVersionKeys, + found: pickedId, + }) + } + } + async manifest () { if (this.package) { return this.package @@ -127,11 +191,16 @@ class RegistryFetcher extends Fetcher { const packument = await this.packument() const steps = PackageJson.normalizeSteps.filter(s => s !== '_attributes') - const mani = await new PackageJson().fromContent(pickManifest(packument, this.spec.fetchSpec, { + const picked = pickManifest(packument, this.spec.fetchSpec, { ...this.opts, defaultTag: this.defaultTag, before: this.before, - })).normalize({ steps }).then(p => p.content) + }) + if (this.opts.verifySignatures || this.opts.verifyAttestations) { + this.#verifyManifestIdentity(packument, picked) + } + const mani = await new PackageJson().fromContent(picked) + .normalize({ steps }).then(p => p.content) /* XXX add ETARGET and E403 revalidation of cached packuments here */ diff --git a/deps/npm/node_modules/pacote/package.json b/deps/npm/node_modules/pacote/package.json index ee9bea58fc0..7b90e43f095 100644 --- a/deps/npm/node_modules/pacote/package.json +++ b/deps/npm/node_modules/pacote/package.json @@ -1,6 +1,6 @@ { "name": "pacote", - "version": "21.5.1", + "version": "21.5.2", "description": "JavaScript package downloader", "author": "GitHub Inc.", "bin": { @@ -75,6 +75,7 @@ "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.", "version": "5.1.0", "windowsCI": false, - "publish": "true" + "publish": "true", + "backport": 21 } } diff --git a/deps/npm/node_modules/postcss-selector-parser/dist/parser.js b/deps/npm/node_modules/postcss-selector-parser/dist/parser.js index d462e71aad7..50cf16a86fe 100644 --- a/deps/npm/node_modules/postcss-selector-parser/dist/parser.js +++ b/deps/npm/node_modules/postcss-selector-parser/dist/parser.js @@ -154,8 +154,9 @@ function indexesOf(array, item) { return indexes; } function uniqs() { - var list = Array.prototype.concat.apply([], arguments); - return list.filter(function (item, i) { return i === list.indexOf(item); }); + // A Set keeps the first-occurrence order the previous filter/indexOf pass + // produced, without its quadratic cost on long index lists. + return Array.from(new Set(Array.prototype.concat.apply([], arguments))); } var Parser = /** @class */ (function () { function Parser(rule, options) { @@ -200,6 +201,11 @@ var Parser = /** @class */ (function () { attr.push(this.currToken); this.position++; } + if (!this.currToken) { + // Ran off the end of the token stream: the attribute was never closed. + // Point at the opening bracket, which is where the author needs to look. + return this.expected("closing square bracket", startingToken[tokenize_1.FIELDS.START_POS]); + } if (this.currToken[tokenize_1.FIELDS.TYPE] !== tokens.closeSquare) { return this.expected("closing square bracket", this.currToken[tokenize_1.FIELDS.START_POS]); } @@ -260,7 +266,7 @@ var Parser = /** @class */ (function () { } if (commentBefore) { (0, util_1.ensureObject)(node, "raws", "spaces", "attribute"); - node.raws.spaces.attribute.before = spaceBefore; + node.raws.spaces.attribute.before = commentBefore; commentBefore = ""; } node.namespace = (node.namespace || "") + content; @@ -686,7 +692,21 @@ var Parser = /** @class */ (function () { return this.error("Unexpected '|'.", this.currToken[tokenize_1.FIELDS.START_POS]); }; Parser.prototype.namespace = function () { - var before = (this.prevToken && this.content(this.prevToken)) || true; + var prev = this.prevToken; + // Only treat the previous token as a namespace prefix when it can actually + // be one (a type/word or the universal `*`). A comment, comma, combinator + // or whitespace before `|` means an empty namespace, not a prefix. + var before = prev && + (prev[tokenize_1.FIELDS.TYPE] === tokens.word || + prev[tokenize_1.FIELDS.TYPE] === tokens.asterisk || + prev[tokenize_1.FIELDS.TYPE] === tokens.ampersand) + ? this.content(prev) + : true; + if (!this.nextToken) { + // A trailing `|` with nothing after it. `unexpectedPipe` reports against + // `currToken`, which is the pipe itself and always present here. + return this.unexpectedPipe(); + } if (this.nextToken[tokenize_1.FIELDS.TYPE] === tokens.word) { this.position++; return this.word(before); @@ -716,6 +736,7 @@ var Parser = /** @class */ (function () { Parser.prototype.parentheses = function () { var last = this.current.last; var unbalanced = 1; + var openingToken = this.currToken; this.position++; if (last && last.type === types.PSEUDO) { var selector = new selector_1.default({ @@ -785,7 +806,9 @@ var Parser = /** @class */ (function () { } } if (unbalanced) { - return this.expected("closing parenthesis", this.currToken[tokenize_1.FIELDS.START_POS]); + // `currToken` is undefined when the token stream ran out before the + // parenthesis was closed; fall back to the opening one. + return this.expected("closing parenthesis", (this.currToken || openingToken)[tokenize_1.FIELDS.START_POS]); } }; Parser.prototype.pseudo = function () { @@ -890,8 +913,14 @@ var Parser = /** @class */ (function () { // Eliminate Sass interpolations from the list of id indexes var interpolations = indexesOf(word, "#{"); if (interpolations.length) { - hasId = hasId.filter(function (hashIndex) { return !~interpolations.indexOf(hashIndex); }); + var interpolationIndexes_1 = new Set(interpolations); + hasId = hasId.filter(function (hashIndex) { return !interpolationIndexes_1.has(hashIndex); }); } + // Membership tests are built once. Scanning the arrays per index would make + // a flat selector such as `.a.a.a...` quadratic in its number of class/id + // indexes, which is enough to pin a CPU core on attacker-supplied input. + var classIndexes = new Set(hasClass); + var idIndexes = new Set(hasId); var indices = (0, sortAscending_1.default)(uniqs(__spreadArray(__spreadArray([0], __read(hasClass), false), __read(hasId), false))); indices.forEach(function (ind, i) { var index = indices[i + 1] || word.length; @@ -903,7 +932,7 @@ var Parser = /** @class */ (function () { var current = _this.currToken; var sourceIndex = current[tokenize_1.FIELDS.START_POS] + indices[i]; var source = getSource(current[1], current[2] + ind, current[3], current[2] + (index - 1)); - if (~hasClass.indexOf(ind)) { + if (classIndexes.has(ind)) { var classNameOpts = { value: value.slice(1), source: source, @@ -911,7 +940,7 @@ var Parser = /** @class */ (function () { }; node = new className_1.default(unescapeProp(classNameOpts, "value")); } - else if (~hasId.indexOf(ind)) { + else if (idIndexes.has(ind)) { var idOpts = { value: value.slice(1), source: source, diff --git a/deps/npm/node_modules/postcss-selector-parser/package.json b/deps/npm/node_modules/postcss-selector-parser/package.json index 12b12199b43..5a7f19963ff 100644 --- a/deps/npm/node_modules/postcss-selector-parser/package.json +++ b/deps/npm/node_modules/postcss-selector-parser/package.json @@ -1,7 +1,7 @@ { "name": "postcss-selector-parser", "description": "Selector parser with built in methods for working with selector strings.", - "version": "7.1.4", + "version": "7.1.6", "devDependencies": { "oxfmt": "^0.54.0", "oxlint": "^1.69.0", @@ -45,6 +45,10 @@ }, "homepage": "https://github.com/postcss/postcss-selector-parser", "contributors": [ + { + "name": "Maxime Thirouin", + "url": "https://moox.io" + }, { "name": "Ben Briggs", "email": "beneb.info@gmail.com", @@ -52,8 +56,7 @@ }, { "name": "Chris Eppstein", - "email": "chris@eppsteins.net", - "url": "http://twitter.com/chriseppstein" + "email": "chris@eppsteins.net" } ], "repository": { diff --git a/deps/npm/node_modules/semver/classes/range.js b/deps/npm/node_modules/semver/classes/range.js index a7d6556febb..a14845a9668 100644 --- a/deps/npm/node_modules/semver/classes/range.js +++ b/deps/npm/node_modules/semver/classes/range.js @@ -119,7 +119,7 @@ class Range { debug('hyphen replace', range) // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` - range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace) + range = trimComparatorWhitespace(range) debug('comparator trim', range) // `~ 1.2.3` => `~1.2.3` @@ -224,11 +224,11 @@ const parseOptions = require('../internal/parse-options') const Comparator = require('./comparator') const debug = require('../internal/debug') const SemVer = require('./semver') +const trimComparatorWhitespace = require('../internal/trim-comparator-whitespace') const { safeRe: re, src, t, - comparatorTrimReplace, tildeTrimReplace, caretTrimReplace, } = require('../internal/re') diff --git a/deps/npm/node_modules/semver/internal/constants.js b/deps/npm/node_modules/semver/internal/constants.js index 6d1db915433..0c8d4ba26b1 100644 --- a/deps/npm/node_modules/semver/internal/constants.js +++ b/deps/npm/node_modules/semver/internal/constants.js @@ -15,6 +15,35 @@ const MAX_SAFE_COMPONENT_LENGTH = 16 // the shortest version with a build 0.0.0+BUILD. const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6 +// ECMAScript whitespace and line terminators matched by \s. +const WHITESPACE_CHARACTERS = [ + '\t', + '\n', + '\v', + '\f', + '\r', + ' ', + '\u00a0', + '\u1680', + '\u2000', + '\u2001', + '\u2002', + '\u2003', + '\u2004', + '\u2005', + '\u2006', + '\u2007', + '\u2008', + '\u2009', + '\u200a', + '\u2028', + '\u2029', + '\u202f', + '\u205f', + '\u3000', + '\ufeff', +] + const RELEASE_TYPES = [ 'major', 'premajor', @@ -30,6 +59,7 @@ module.exports = { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, MAX_SAFE_INTEGER, + WHITESPACE_CHARACTERS, RELEASE_TYPES, SEMVER_SPEC_VERSION, FLAG_INCLUDE_PRERELEASE: 0b001, diff --git a/deps/npm/node_modules/semver/internal/trim-comparator-whitespace.js b/deps/npm/node_modules/semver/internal/trim-comparator-whitespace.js new file mode 100644 index 00000000000..de6e6387b6b --- /dev/null +++ b/deps/npm/node_modules/semver/internal/trim-comparator-whitespace.js @@ -0,0 +1,438 @@ +// @ts-check +'use strict' + +// Reproduce safeRe[COMPARATORTRIM] replacement boundaries, not version +// validation. Each end-index finder returns an exclusive end, or its start +// on no match. +// Positions count from zero. An end of 3 means characters 0, 1, and 2 were read; +// range.slice(start, end) gives the matched text, not a converted number. +const { + MAX_LENGTH, + MAX_SAFE_BUILD_LENGTH, + WHITESPACE_CHARACTERS, +} = require('./constants') + +/** + * Remembers the last two rows of digits so their characters need not be reread. + * Positions start at -1 until a row has been found. + * + * @typedef {object} DigitRunCache + * @property {number} start The first character of the most recently found row. + * @property {number} end The position after that row's last character. + * @property {number} previousStart The first character of the previous row. + * @property {number} previousEnd The position after the previous row. + */ + +// One entry per UTF-16 code unit keeps membership checks constant-time. +const whitespace = new Uint8Array(0x10000) +for (const char of WHITESPACE_CHARACTERS) { + whitespace[char.charCodeAt(0)] = 1 +} + +/** + * Checks whether a character is whitespace, like a space, tab, or newline. + * Looking past the end of the string returns false. + * + * @param {string|undefined} char One character, or undefined past the string's end. + * @returns {boolean} Whether the character is whitespace. + * @example isWhitespace(' ') // true + * @example isWhitespace('1') // false + */ +const isWhitespace = char => + char !== undefined && whitespace[char.charCodeAt(0)] === 1 + +/** + * Checks for v, =, or whitespace before the version number. + * These are historical version prefixes, not range operators: + * < and > are handled separately, as are tilde and caret ranges. + * + * @param {string|undefined} char One character to check. + * @returns {boolean} Whether the character can belong to a version prefix. + * @example isVersionPrefix('=') // true + * @example isVersionPrefix('>') // false + */ +const isVersionPrefix = char => + char === 'v' || + char === '=' || + isWhitespace(char) + +/** + * Checks whether a character is one of the digits 0 through 9. + * + * @param {string|undefined} char One character to check. + * @returns {boolean} Whether the character is an ASCII digit. + * @example isDigit('7') // true + * @example isDigit('.') // false + */ +const isDigit = char => char !== undefined && char >= '0' && char <= '9' + +/** + * Checks whether a character is an English letter, uppercase or lowercase. + * + * @param {string|undefined} char One character to check. + * @returns {boolean} Whether the character is an ASCII letter. + * @example isLetter('b') // true + * @example isLetter('7') // false + */ +const isLetter = char => + char !== undefined && ( + (char >= 'a' && char <= 'z') || + (char >= 'A' && char <= 'Z') + ) + +/** + * Checks for a letter, digit, or hyphen: the characters allowed inside + * prerelease and build names such as beta-1. + * + * @param {string|undefined} char One character to check. + * @returns {boolean} Whether the character can be part of an identifier. + * @example isIdentifierCharacter('-') // true + * @example isIdentifierCharacter('.') // false; dots separate identifiers + */ +const isIdentifierCharacter = char => isDigit(char) || isLetter(char) || char === '-' + +/** + * Checks whether a version component can begin here: with a digit or + * a wildcard such as x, X, or *. + * + * @param {string|undefined} char One character to check. + * @returns {boolean} Whether a number or wildcard can start with this character. + * @example isVersionStart('x') // true + * @example isVersionStart('v') // false; v belongs to the prefix + */ +const isVersionStart = char => + isDigit(char) || + char === 'x' || + char === 'X' || + char === '*' + +/** + * Finds the end of a row of digits, but returns no more than limit digits. + * Remembers the last two rows so looking at them again does not reread them. + * + * @param {string} range The text to read; it is not changed. + * @param {number} start The position of the first character to check. + * @param {number} limit The most digit characters the returned match can include. + * @param {DigitRunCache} digitRuns Shared cache of digit-run positions, updated in place. + * @returns {number} The position after the matched digits, or start if none match. + * @example findDigitsEndIndex('123abc', 0, 10, digitRuns) // 3, pointing at a + * @example findDigitsEndIndex('123abc', 0, 2, digitRuns) // 2, pointing at the unread 3 + */ +const findDigitsEndIndex = (range, start, limit, digitRuns) => { + if (!isDigit(range[start])) { + return start + } + if (start >= digitRuns.start && start < digitRuns.end) { + return Math.min(start + limit, digitRuns.end) + } + if (start >= digitRuns.previousStart && start < digitRuns.previousEnd) { + return Math.min(start + limit, digitRuns.previousEnd) + } + let end = start + 1 + while (isDigit(range[end])) { + end++ + } + // A failed full version can rewind from its second run to its first. + digitRuns.previousStart = digitRuns.start + digitRuns.previousEnd = digitRuns.end + digitRuns.start = start + digitRuns.end = end + return Math.min(start + limit, end) +} + +/** + * Reads a number using the old regex's length and leading-zero rules. + * Strict mode reads just the first zero in 012; loose mode can read all three. + * + * @param {string} range The text to read; it is not changed. + * @param {number} start The position where the number should begin. + * @param {boolean} loose Whether to allow leading zeros. + * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed. + * @returns {number} The position after the matched digits, not their numeric value. + * @example findVersionNumberEndIndex('012', 0, false, digitRuns) // 1 + * @example findVersionNumberEndIndex('012', 0, true, digitRuns) // 3 + */ +const findVersionNumberEndIndex = (range, start, loose, digitRuns) => { + if (!loose && range[start] === '0') { + return start + 1 + } + // Strict syntax allows an initial nonzero digit plus MAX_LENGTH digits. + return findDigitsEndIndex(range, start, loose ? MAX_LENGTH : MAX_LENGTH + 1, digitRuns) +} + +/** + * Reads one piece of a prerelease name, such as beta or 1 in beta.1. + * Tries the letter-or-hyphen form first, then the number-only form. + * + * @param {string} range The text to read; it is not changed. + * @param {number} start The position where the identifier should begin. + * @param {boolean} loose Whether numeric identifiers may have leading zeros. + * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed. + * @returns {number} The position after the identifier, or start if none matches. + * @example findPrereleaseIdentifierEndIndex('beta.1', 0, false, digitRuns) // 4, at the dot + * @example findPrereleaseIdentifierEndIndex('001beta', 0, false, digitRuns) // 7 + */ +const findPrereleaseIdentifierEndIndex = (range, start, loose, digitRuns) => { + const digitsEnd = findDigitsEndIndex(range, start, MAX_LENGTH, digitRuns) + // The legacy regex tries a nonnumeric identifier before a numeric one. + if (isLetter(range[digitsEnd]) || range[digitsEnd] === '-') { + let end = digitsEnd + 1 + const limit = end + MAX_SAFE_BUILD_LENGTH + while (end < limit && isIdentifierCharacter(range[end])) { + end++ + } + return end + } + return findVersionNumberEndIndex(range, start, loose, digitRuns) +} + +/** + * Reads a prerelease suffix such as -beta.1, one dot-separated piece at a time. + * Loose mode also allows the name without its opening hyphen. + * + * @param {string} range The text to read; it is not changed. + * @param {number} start The position where the suffix should begin, including -. + * @param {boolean} loose Whether the opening hyphen is optional and zeros allowed. + * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed. + * @returns {number} The position after the matched suffix, or start if absent. + * @example findPrereleaseEndIndex('-beta.1+sha', 0, false, digitRuns) // 7, at the plus + * @example findPrereleaseEndIndex('beta', 0, false, digitRuns) // 0; no opening hyphen + */ +const findPrereleaseEndIndex = (range, start, loose, digitRuns) => { + const hyphen = range[start] === '-' + if (!loose && !hyphen) { + return start + } + const identifierStart = start + (hyphen ? 1 : 0) + let end = findPrereleaseIdentifierEndIndex(range, identifierStart, loose, digitRuns) + if (end === identifierStart) { + if (!loose || !hyphen) { + return start + } + // In loose syntax, a lone hyphen can itself be the identifier. + end = findPrereleaseIdentifierEndIndex(range, start, loose, digitRuns) + } + while (range[end] === '.') { + const next = findPrereleaseIdentifierEndIndex(range, end + 1, loose, digitRuns) + if (next === end + 1) { + break + } + end = next + } + return end +} + +/** + * Reads one build-name piece, such as sha or 123 in +sha.123. + * Stops at a disallowed character or the old regex's length limit. + * + * @param {string} range The text to read; it is not changed. + * @param {number} start The position where the identifier should begin. + * @returns {number} The position after the identifier, or start if none matches. + * @example findBuildIdentifierEndIndex('sha.123', 0) // 3, at the dot + * @example findBuildIdentifierEndIndex('001', 0) // 3; leading zeros are allowed + */ +const findBuildIdentifierEndIndex = (range, start) => { + let end = start + while (end - start < MAX_SAFE_BUILD_LENGTH && isIdentifierCharacter(range[end])) { + end++ + } + return end +} + +/** + * Reads optional build metadata such as +sha.123. + * Leaves the position unchanged if there is no plus sign followed by a name. + * + * @param {string} range The text to read; it is not changed. + * @param {number} start The position where the opening + should be. + * @returns {number} The position after the matched metadata, or start if absent. + * @example findBuildEndIndex('+sha.123 <2', 0) // 8, at the space + * @example findBuildEndIndex('+', 0) // 0; a plus sign alone is not a match + */ +const findBuildEndIndex = (range, start) => { + if (range[start] !== '+') { + return start + } + let end = findBuildIdentifierEndIndex(range, start + 1) + if (end === start + 1) { + return start + } + while (range[end] === '.') { + const next = findBuildIdentifierEndIndex(range, end + 1) + if (next === end + 1) { + break + } + end = next + } + return end +} + +/** + * Reads three numbers separated by dots, then any prerelease and build suffixes. + * Uses loose rules, so forms such as 01.02.03beta can match here. + * + * @param {string} range The text to read; it is not changed. + * @param {number} start The position of the first number, after any prefix. + * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed. + * @returns {number} The position after the version match, or start if none matches. + * @example findLooseFullVersionEndIndex('1.2.3-beta+sha <2', 0, digitRuns) // 14 + * @example findLooseFullVersionEndIndex('1.2', 0, digitRuns) // 0; needs three numbers + */ +const findLooseFullVersionEndIndex = (range, start, digitRuns) => { + let end = start + for (let component = 0; component < 3; component++) { + const next = findVersionNumberEndIndex(range, end, true, digitRuns) + if (next === end) { + return start + } + end = next + if (component < 2) { + if (range[end] !== '.') { + return start + } + end++ + } + } + const prereleaseEnd = findPrereleaseEndIndex(range, end, true, digitRuns) + return findBuildEndIndex(range, prereleaseEnd) +} + +/** + * Reads one component of a partial or wildcard version, such as 2 or x in 2.x. + * Numbers use strict leading-zero rules; wildcards take up one character. + * + * @param {string} range The text to read; it is not changed. + * @param {number} start The position where the component should begin. + * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed. + * @returns {number} The position after the component, or start if none matches. + * @example findPartialVersionComponentEndIndex('2.x', 0, digitRuns) // 1, at the dot + * @example findPartialVersionComponentEndIndex('2.x', 2, digitRuns) // 3, after x + */ +const findPartialVersionComponentEndIndex = (range, start, digitRuns) => { + if (isDigit(range[start])) { + return findVersionNumberEndIndex(range, start, false, digitRuns) + } + return isVersionStart(range[start]) ? start + 1 : start +} + +/** + * Reads up to three components, allowing forms such as 1, 1.2, or 1.x. + * After the third component, also reads any strict prerelease and build suffixes. + * + * @param {string} range The text to read; it is not changed. + * @param {number} start The position of a number or wildcard, after any prefix. + * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed. + * @returns {number} The position after the matched version text. + * @example findPartialVersionEndIndex('1.x <2', 0, digitRuns) // 3, at the space + * @example findPartialVersionEndIndex('1.', 0, digitRuns) // 1; the trailing dot is unread + */ +const findPartialVersionEndIndex = (range, start, digitRuns) => { + let end = findPartialVersionComponentEndIndex(range, start, digitRuns) + for (let component = 0; component < 2; component++) { + if (range[end] !== '.') { + return end + } + const next = findPartialVersionComponentEndIndex(range, end + 1, digitRuns) + if (next === end + 1) { + return end + } + end = next + } + const prereleaseEnd = findPrereleaseEndIndex(range, end, false, digitRuns) + return findBuildEndIndex(range, prereleaseEnd) +} + +/** + * Finds where a version match ends, without deciding whether the range is valid. + * Tries a loose full version first, then a partial or wildcard version, just + * like the old regex's LOOSEPLAIN and XRANGEPLAIN alternatives. + * + * @param {string} range The text to read; it is not changed. + * @param {number} start The position of a number or wildcard, after any prefix. + * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed. + * @returns {number} The position where scanning the next candidate can resume. + * @example findVersionEndIndex('1.2.3 <2', 0, digitRuns) // 5, at the space + * @example findVersionEndIndex('1.x <2', 0, digitRuns) // 3, at the space + */ +const findVersionEndIndex = (range, start, digitRuns) => { + const fullVersionEnd = findLooseFullVersionEndIndex(range, start, digitRuns) + return fullVersionEnd !== start + ? fullVersionEnd + : findPartialVersionEndIndex(range, start, digitRuns) +} + +/** + * Finds the one whitespace character the old replacement would remove. + * Keeps leading whitespace, skips an optional operator, and checks immediately + * after it. Returns -1 if there is nothing to remove. + * + * @param {string} range The text containing a candidate already found by the caller. + * @param {number} matchStart The candidate's position, including leading whitespace. + * @returns {number} The position of the removable whitespace, or -1 if absent. + * @example findRemovableWhitespaceIndex(' > 1', 0) // 2; keep the space at position 0 + * @example findRemovableWhitespaceIndex('>1', 0) // -1 + */ +const findRemovableWhitespaceIndex = (range, matchStart) => { + let position = matchStart + if (isWhitespace(range[position])) { + position++ + } + if (range[position] === '<' || range[position] === '>') { + position++ + } + if (range[position] === '=') { + position++ + } + return isWhitespace(range[position]) ? position : -1 +} + +/** + * Joins an operator to its version, turning > 1.2.3 into >1.2.3. + * Copies everything else according to the old regex's matching rules. + * Moves forward through prefixes and whole versions to avoid repeatedly + * searching the same characters on long inputs. + * + * @param {string} range The range text to process; the original string is unchanged. + * @returns {string} The range with matched operator whitespace removed. + * @example trimComparatorWhitespace('> 1.2.3 < 2') // '>1.2.3 <2' + * @example trimComparatorWhitespace('> invalid') // '> invalid' + */ +const trimComparatorWhitespace = range => { + let result = '' + let copyFrom = 0 + let cursor = 0 + const digitRuns = { start: -1, end: -1, previousStart: -1, previousEnd: -1 } + + while (cursor < range.length) { + const matchStart = cursor + if (range[cursor] === '<' || range[cursor] === '>') { + cursor++ + } else if (!isVersionPrefix(range[cursor]) && !isVersionStart(range[cursor])) { + cursor++ + continue + } + + // Consume a v/=/whitespace run once, even when no version follows it. + while (cursor < range.length && isVersionPrefix(range[cursor])) { + cursor++ + } + if (!isVersionStart(range[cursor])) { + continue + } + + const whitespacePosition = findRemovableWhitespaceIndex(range, matchStart) + if (whitespacePosition !== -1) { + result += range.slice(copyFrom, whitespacePosition) + copyFrom = whitespacePosition + 1 + } + + // Skip the entire match, so a prerelease's trailing v cannot be + // reconsidered as the prefix of another version. + cursor = findVersionEndIndex(range, cursor, digitRuns) + } + + return result + range.slice(copyFrom) +} + +module.exports = trimComparatorWhitespace diff --git a/deps/npm/node_modules/semver/package.json b/deps/npm/node_modules/semver/package.json index 0cb7c7bb465..80bf748cd04 100644 --- a/deps/npm/node_modules/semver/package.json +++ b/deps/npm/node_modules/semver/package.json @@ -1,6 +1,6 @@ { "name": "semver", - "version": "7.8.5", + "version": "7.8.6", "description": "The semantic version parser used by npm.", "main": "index.js", "scripts": { diff --git a/deps/npm/node_modules/undici/docs/docs/api/Client.md b/deps/npm/node_modules/undici/docs/docs/api/Client.md index e0d41b47805..ca6e336f226 100644 --- a/deps/npm/node_modules/undici/docs/docs/api/Client.md +++ b/deps/npm/node_modules/undici/docs/docs/api/Client.md @@ -29,6 +29,8 @@ Returns: `Client` * **webSocket** `WebSocketOptions` (optional) - WebSocket-specific configuration options. * **maxFragments** `number` (optional) - Default: `131072` - Maximum number of fragments in a message. Set to 0 to disable the limit. * **maxPayloadSize** `number` (optional) - Default: `134217728` (128 MB) - Maximum allowed payload size in bytes for WebSocket messages. Applied to uncompressed messages, compressed frame payloads, and decompressed (permessage-deflate) messages. Set to 0 to disable the limit. +* **eventSource** `EventSourceOptions` (optional) - EventSource-specific configuration options. + * **maxEventSize** `number` (optional) - The maximum total bytes of data and metadata field values retained for a pending EventSource event. Each unfinished line is separately limited to this value plus seven syntax bytes. The number of `data:` lines per event and input chunks buffered for an unfinished line are each limited to `min(131072, max(1024, floor(maxEventSize / 128)))` to bound object overhead. Set to `0` to disable these limits. Default: `buffer.kStringMaxLength`. * **pipelining** `number | null` (optional) - Default: `1` - The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Carefully consider your workload and environment before enabling concurrent requests as pipelining may reduce performance if used incorrectly. Pipelining is sensitive to network stack settings as well as head of line blocking caused by e.g. long running requests. Set to `0` to disable keep-alive connections. * **connect** `ConnectOptions | Function | null` (optional) - Default: `null`. * **strictContentLength** `Boolean` (optional) - Default: `true` - Whether to treat request content length mismatches as errors. If true, an error is thrown when the request content-length header doesn't match the length of the request body. diff --git a/deps/npm/node_modules/undici/docs/docs/api/DiagnosticsChannel.md b/deps/npm/node_modules/undici/docs/docs/api/DiagnosticsChannel.md index 099c072f6c6..aefb1009c63 100644 --- a/deps/npm/node_modules/undici/docs/docs/api/DiagnosticsChannel.md +++ b/deps/npm/node_modules/undici/docs/docs/api/DiagnosticsChannel.md @@ -40,7 +40,8 @@ diagnosticsChannel.channel('undici:request:bodySent').subscribe(({ request }) => ## `undici:request:headers` -This message is published after the response headers have been received, i.e. the response has been completed. +This message is published after the response headers have been received. This includes a successful CONNECT or +protocol upgrade response. ```js import diagnosticsChannel from 'diagnostics_channel' @@ -57,6 +58,7 @@ diagnosticsChannel.channel('undici:request:headers').subscribe(({ request, respo ## `undici:request:trailers` This message is published after the response body and trailers have been received, i.e. the response has been completed. +After an upgraded socket is passed to the request handler, this message is published with an empty `trailers` array. ```js import diagnosticsChannel from 'diagnostics_channel' diff --git a/deps/npm/node_modules/undici/lib/core/request.js b/deps/npm/node_modules/undici/lib/core/request.js index 8e7ecc73084..0b2b1a8d9d7 100644 --- a/deps/npm/node_modules/undici/lib/core/request.js +++ b/deps/npm/node_modules/undici/lib/core/request.js @@ -263,11 +263,77 @@ class Request { } } - onUpgrade (statusCode, headers, socket) { + /** + * @param {number|null} statusCode + * @param {Buffer[]|null} headers + * @param {import('node:stream').Duplex} socket + * @param {string} [statusText] + */ + onUpgrade (statusCode, headers, socket, statusText = '') { + this.onFinally() + assert(!this.aborted) assert(!this.completed) - return this[kHandler].onUpgrade(statusCode, headers, socket) + if (statusCode !== null) { + this.#publishUpgradeHeaders(statusCode, headers, statusText) + } + + const result = this[kHandler].onUpgrade(statusCode, headers, socket) + + if (!this.aborted) { + this.completed = true + if (statusCode !== null) { + this.#publishUpgradeTrailers() + } + } + + return result + } + + /** + * @param {number} statusCode + * @param {import('node:http2').IncomingHttpHeaders} headers + * @param {(headers: import('node:http2').IncomingHttpHeaders) => Buffer[]} parseHeaders + * @param {string} [statusText] + */ + onUpgradeResponse (statusCode, headers, parseHeaders, statusText = '') { + assert(!this.aborted) + assert(this.completed) + + if (channels.headers.hasSubscribers) { + this.#publishUpgradeHeaders(statusCode, parseHeaders(headers), statusText) + } + this.#publishUpgradeTrailers() + } + + /** + * @param {Error} error + */ + onUpgradeError (error) { + assert(!this.aborted) + assert(this.completed) + + if (channels.error.hasSubscribers) { + channels.error.publish({ request: this, error }) + } + } + + /** + * @param {number} statusCode + * @param {Buffer[]} headers + * @param {string} statusText + */ + #publishUpgradeHeaders (statusCode, headers, statusText) { + if (channels.headers.hasSubscribers) { + channels.headers.publish({ request: this, response: { statusCode, headers, statusText } }) + } + } + + #publishUpgradeTrailers () { + if (channels.trailers.hasSubscribers) { + channels.trailers.publish({ request: this, trailers: [] }) + } } onComplete (trailers) { diff --git a/deps/npm/node_modules/undici/lib/dispatcher/agent.js b/deps/npm/node_modules/undici/lib/dispatcher/agent.js index 90b46fe3aeb..416ab3edda3 100644 --- a/deps/npm/node_modules/undici/lib/dispatcher/agent.js +++ b/deps/npm/node_modules/undici/lib/dispatcher/agent.js @@ -23,7 +23,7 @@ function defaultFactory (origin, opts) { } class Agent extends DispatcherBase { - constructor ({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) { + constructor ({ factory = defaultFactory, maxRedirections = 0, connect, tls, ...options } = {}) { if (typeof factory !== 'function') { throw new InvalidArgumentError('factory must be a function.') } @@ -42,11 +42,15 @@ class Agent extends DispatcherBase { connect = { ...connect } } + if (tls && typeof tls !== 'function') { + tls = { ...tls } + } + this[kInterceptors] = options.interceptors?.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })] - this[kOptions] = { ...util.deepClone(options), connect } + this[kOptions] = { ...util.deepClone(options), connect, tls } this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : undefined diff --git a/deps/npm/node_modules/undici/lib/dispatcher/client-h1.js b/deps/npm/node_modules/undici/lib/dispatcher/client-h1.js index a801ecb3604..7d1fdbdf6e7 100644 --- a/deps/npm/node_modules/undici/lib/dispatcher/client-h1.js +++ b/deps/npm/node_modules/undici/lib/dispatcher/client-h1.js @@ -432,7 +432,7 @@ class Parser { } onUpgrade (head) { - const { upgrade, client, socket, headers, statusCode } = this + const { upgrade, client, socket, headers, statusCode, statusText } = this assert(upgrade) assert(client[kSocket] === socket) @@ -467,9 +467,10 @@ class Parser { client.emit('disconnect', client[kUrl], [client], new InformationalError('upgrade')) try { - request.onUpgrade(statusCode, headers, socket) - } catch (err) { - util.destroy(socket, err) + request.onUpgrade(statusCode, headers, socket, statusText) + } catch (error) { + util.errorRequest(client, request, error) + util.destroy(socket, error) } client[kResume]() @@ -726,8 +727,6 @@ async function connectH1 (client, socket) { socket[kParser] = new Parser(client, socket, llhttpInstance) addListener(socket, 'error', function (err) { - assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID') - const parser = this[kParser] // On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded @@ -876,7 +875,7 @@ async function connectH1 (client, socket) { function clearIdleSocketValidation (socket) { if (socket[kIdleSocketValidationTimeout]) { - clearTimeout(socket[kIdleSocketValidationTimeout]) + clearImmediate(socket[kIdleSocketValidationTimeout]) socket[kIdleSocketValidationTimeout] = null } @@ -885,15 +884,23 @@ function clearIdleSocketValidation (socket) { function scheduleIdleSocketValidation (client, socket) { socket[kIdleSocketValidation] = 1 - socket[kIdleSocketValidationTimeout] = setTimeout(() => { + // Yield to the check phase (after poll) so unsolicited bytes / FIN / RST + // already pending on this idle keep-alive socket are processed before the + // next request is written (GHSA-35p6-xmwp-9g52). + // + // setTimeout(0) pays Node's ~1ms timer floor on every sequential reuse + // (#5493). setImmediate avoids that, but an *unref'd* Immediate lets poll + // block for ~500ms when the event loop is otherwise idle (#5600 / #5606). + // A ref'd Immediate both keeps the pending request alive and makes poll + // return immediately — the hybrid those issues asked for. + socket[kIdleSocketValidationTimeout] = setImmediate(() => { socket[kIdleSocketValidationTimeout] = null socket[kIdleSocketValidation] = 2 if (client[kSocket] === socket && !socket.destroyed) { client[kResume]() } - }, 0) - socket[kIdleSocketValidationTimeout].unref?.() + }) } /** @@ -1042,12 +1049,22 @@ function writeH1 (client, request) { const socket = client[kSocket] clearIdleSocketValidation(socket) - const abort = (err) => { - if (request.aborted || request.completed) { + /** + * @param {Error} [error] + */ + const abort = (error) => { + if (request.aborted) { + return + } + + if (request.completed) { + if (request.upgrade || request.method === 'CONNECT') { + util.destroy(socket, new InformationalError('aborted')) + } return } - util.errorRequest(client, request, err || new RequestAbortedError()) + util.errorRequest(client, request, error || new RequestAbortedError()) util.destroy(body) util.destroy(socket, new InformationalError('aborted')) diff --git a/deps/npm/node_modules/undici/lib/dispatcher/client-h2.js b/deps/npm/node_modules/undici/lib/dispatcher/client-h2.js index 4a52effb1f3..f417aa3d186 100644 --- a/deps/npm/node_modules/undici/lib/dispatcher/client-h2.js +++ b/deps/npm/node_modules/undici/lib/dispatcher/client-h2.js @@ -1,6 +1,7 @@ 'use strict' const assert = require('node:assert') +const { errorMonitor } = require('node:events') const { pipeline } = require('node:stream') const util = require('../core/util.js') const { @@ -77,6 +78,15 @@ function parseH2Headers (headers) { return result } +/** + * @param {import('node:http2').IncomingHttpHeaders} headers + * @returns {Buffer[]} + */ +function parseH2ResponseHeaders (headers) { + const { [HTTP2_HEADER_STATUS]: _statusCode, ...realHeaders } = headers + return parseH2Headers(realHeaders) +} + async function connectH2 (client, socket) { client[kSocket] = socket @@ -126,8 +136,6 @@ async function connectH2 (client, socket) { socket[kHTTP2Session] = session util.addListener(socket, 'error', function (err) { - assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID') - this[kError] = err this[kClient][kOnError](err) @@ -201,8 +209,6 @@ function resumeH2 (client) { } function onHttp2SessionError (err) { - assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID') - this[kSocket][kError] = err this[kClient][kOnError](err) } @@ -297,22 +303,32 @@ function writeH2 (client, request) { headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ''}` headers[HTTP2_HEADER_METHOD] = method - const abort = (err) => { - if (request.aborted || request.completed) { + /** + * @param {Error} [error] + */ + const abort = (error) => { + if (request.aborted) { return } - err = err || new RequestAbortedError() + if (request.completed) { + if (method === 'CONNECT' && stream != null) { + util.destroy(stream, error || new RequestAbortedError()) + } + return + } - util.errorRequest(client, request, err) + error = error || new RequestAbortedError() + + util.errorRequest(client, request, error) if (stream != null) { - util.destroy(stream, err) + util.destroy(stream, error) } // We do not destroy the socket as we can continue using the session // the stream get's destroyed and the session remains to create new streams - util.destroy(body, err) + util.destroy(body, error) client[kQueue][client[kRunningIdx]++] = null client[kResume]() } @@ -331,25 +347,57 @@ function writeH2 (client, request) { if (method === 'CONNECT') { session.ref() - // We are already connected, streams are pending, first request - // will create a new stream. We trigger a request to create the stream and wait until - // `ready` event is triggered // We disabled endStream to allow the user to write to the stream stream = session.request(headers, { endStream: false, signal }) + let upgradeResponseFinished = false + + /** + * @param {import('node:http2').IncomingHttpHeaders} headers + */ + const onResponse = (headers) => { + upgradeResponseFinished = true + stream.off(errorMonitor, onUpgradeError) + request.onUpgradeResponse(Number(headers[HTTP2_HEADER_STATUS]), headers, parseH2ResponseHeaders) + } - if (stream.id && !stream.pending) { - request.onUpgrade(null, null, stream) - ++session[kOpenStreams] - client[kQueue][client[kRunningIdx]++] = null - } else { - stream.once('ready', () => { + /** + * @param {Error} error + */ + const onUpgradeError = (error) => { + upgradeResponseFinished = true + stream.off('response', onResponse) + request.onUpgradeError(error) + } + + const onReady = () => { + try { request.onUpgrade(null, null, stream) - ++session[kOpenStreams] - client[kQueue][client[kRunningIdx]++] = null - }) + } catch (error) { + stream.off('response', onResponse) + abort(error) + return + } + + if (request.aborted) { + return + } + + stream.off('error', abort) + stream.once(errorMonitor, onUpgradeError) + client[kQueue][client[kRunningIdx]++] = null } + stream.once('response', onResponse) + stream.once('error', abort) + ++session[kOpenStreams] + onReady() + stream.once('close', () => { + if (!upgradeResponseFinished && request.completed) { + stream.off('response', onResponse) + stream.off(errorMonitor, onUpgradeError) + request.onUpgradeError(new InformationalError(`HTTP/2: "stream error" received - code ${stream.rstCode}`)) + } session[kOpenStreams] -= 1 if (session[kOpenStreams] === 0) session.unref() }) diff --git a/deps/npm/node_modules/undici/lib/dispatcher/client.js b/deps/npm/node_modules/undici/lib/dispatcher/client.js index 18472fffd77..9efe80e3002 100644 --- a/deps/npm/node_modules/undici/lib/dispatcher/client.js +++ b/deps/npm/node_modules/undici/lib/dispatcher/client.js @@ -107,9 +107,10 @@ class Client extends DispatcherBase { // h2 maxConcurrentStreams, allowH2, - webSocket + webSocket, + eventSource } = {}) { - super({ webSocket }) + super({ webSocket, eventSource }) if (keepAlive !== undefined) { throw new InvalidArgumentError('unsupported keepAlive, use pipelining=0 instead') diff --git a/deps/npm/node_modules/undici/lib/dispatcher/dispatcher-base.js b/deps/npm/node_modules/undici/lib/dispatcher/dispatcher-base.js index 371a3ea1f6f..e90e4b379ef 100644 --- a/deps/npm/node_modules/undici/lib/dispatcher/dispatcher-base.js +++ b/deps/npm/node_modules/undici/lib/dispatcher/dispatcher-base.js @@ -1,5 +1,6 @@ 'use strict' +const buffer = require('node:buffer') const Dispatcher = require('./dispatcher') const { ClientDestroyedError, @@ -12,6 +13,7 @@ const kOnDestroyed = Symbol('onDestroyed') const kOnClosed = Symbol('onClosed') const kInterceptedDispatch = Symbol('Intercepted Dispatch') const kWebSocketOptions = Symbol('webSocketOptions') +const kEventSourceOptions = Symbol('eventSourceOptions') class DispatcherBase extends Dispatcher { constructor (opts) { @@ -22,6 +24,7 @@ class DispatcherBase extends Dispatcher { this[kClosed] = false this[kOnClosed] = [] this[kWebSocketOptions] = opts?.webSocket ?? {} + this[kEventSourceOptions] = opts?.eventSource ?? {} } get webSocketOptions () { @@ -31,6 +34,12 @@ class DispatcherBase extends Dispatcher { } } + get eventSourceOptions () { + return { + maxEventSize: this[kEventSourceOptions].maxEventSize ?? buffer.kStringMaxLength + } + } + get destroyed () { return this[kDestroyed] } diff --git a/deps/npm/node_modules/undici/lib/handler/retry-handler.js b/deps/npm/node_modules/undici/lib/handler/retry-handler.js index c62a2409f3a..7084c2b5652 100644 --- a/deps/npm/node_modules/undici/lib/handler/retry-handler.js +++ b/deps/npm/node_modules/undici/lib/handler/retry-handler.js @@ -90,6 +90,7 @@ class RetryHandler { this.end = null this.etag = null this.resume = null + this.headersSent = false // Handle possible onConnect duplication this.handler.onConnect(reason => { @@ -102,6 +103,20 @@ class RetryHandler { }) } + checkpointResponseEnd (headers, resume) { + if (this.end == null && this.opts.method !== 'HEAD') { + const contentLength = headers['content-length'] + this.end = contentLength != null ? Number(contentLength) - 1 : null + + assert( + this.end == null || Number.isFinite(this.end), + 'invalid content-length' + ) + } + + this.resume = this.end != null ? resume : null + } + onRequestSent () { if (this.handler.onRequestSent) { this.handler.onRequestSent() @@ -190,7 +205,12 @@ class RetryHandler { this.retryCount += 1 if (statusCode >= 300) { - if (this.retryOpts.statusCodes.includes(statusCode) === false) { + // Only expose a response if no earlier attempt has reached the caller. + // Otherwise abort this attempt so the error settles the existing body + // instead of replacing it with a new response. + if (!this.headersSent && this.retryOpts.statusCodes.includes(statusCode) === false) { + this.headersSent = true + this.checkpointResponseEnd(headers, resume) return this.handler.onHeaders( statusCode, rawHeaders, @@ -259,8 +279,15 @@ class RetryHandler { const { start, size, end = size - 1 } = contentRange - assert(this.start === start, 'content-range mismatch') - assert(this.end == null || this.end === end, 'content-range mismatch') + if (this.start !== start || (this.end != null && this.end !== end)) { + this.abort( + new RequestRetryError('Content-Range mismatch', statusCode, { + headers, + data: { count: this.retryCount } + }) + ) + return false + } this.resume = resume return true @@ -272,6 +299,7 @@ class RetryHandler { const range = parseRangeHeader(headers['content-range']) if (range == null) { + this.headersSent = true return this.handler.onHeaders( statusCode, rawHeaders, @@ -310,6 +338,7 @@ class RetryHandler { ) this.resume = resume + this.headersSent = true this.etag = headers.etag != null ? headers.etag : null // Weak etags are not useful for comparison nor cache @@ -349,7 +378,7 @@ class RetryHandler { } onError (err) { - if (this.aborted || isDisturbed(this.opts.body)) { + if (this.aborted || isDisturbed(this.opts.body) || (this.headersSent && this.resume == null)) { return this.handler.onError(err) } diff --git a/deps/npm/node_modules/undici/lib/web/eventsource/eventsource-stream.js b/deps/npm/node_modules/undici/lib/web/eventsource/eventsource-stream.js index 754934568d0..9172602ad05 100644 --- a/deps/npm/node_modules/undici/lib/web/eventsource/eventsource-stream.js +++ b/deps/npm/node_modules/undici/lib/web/eventsource/eventsource-stream.js @@ -1,4 +1,5 @@ 'use strict' +const buffer = require('node:buffer') const { Transform } = require('node:stream') const { isASCIINumber, isValidLastEventId } = require('./util') @@ -23,6 +24,63 @@ const COLON = 0x3A */ const SPACE = 0x20 +const defaultMaxEventSize = buffer.kStringMaxLength + +const DATA = Buffer.from('data') +const EVENT = Buffer.from('event') +const ID = Buffer.from('id') +const RETRY = Buffer.from('retry') + +// Each data field creates a string node, and each unconsumed input chunk keeps +// a Buffer wrapper. The absolute ceiling protects the large default byte limit. +const minParserItems = 1024 +const maxParserItems = 131072 +const bytesPerParserItem = 128 + +function isASCIINumberBytes (buffer, start) { + if (start >= buffer.length) { + return false + } + + for (let i = start; i < buffer.length; i++) { + if (buffer[i] < 0x30 || buffer[i] > 0x39) { + return false + } + } + + return true +} + +function isValidLastEventIdBytes (buffer, start) { + for (let i = start; i < buffer.length; i++) { + if (buffer[i] === 0x00) { + return false + } + } + + return true +} + +function isFieldName (line, length, field) { + if (length !== field.length) { + return false + } + + for (let i = 0; i < length; i++) { + if (line[i] !== field[i]) { + return false + } + } + + return true +} + +function createMaxEventSizeExceededError () { + const error = new Error('EventSource message size exceeded') + error.aborted = false + return error +} + /** * @typedef {object} EventSourceStreamEvent * @type {object} @@ -63,11 +121,21 @@ class EventSourceStream extends Transform { eventEndCheck = false /** - * @type {Buffer} + * @type {Buffer[]} */ - buffer = null + chunks = [] + chunkIndex = 0 pos = 0 + lineChunkIndex = 0 + linePos = 0 + lineLength = 0 + eventSize = 0 + eventFieldSizes = { data: 0, event: 0, id: 0, retry: 0 } + dataLineCount = 0 + maxEventSize + maxDataLines + maxBufferedChunks event = { data: undefined, @@ -78,6 +146,7 @@ class EventSourceStream extends Transform { /** * @param {object} options + * @param {number} [options.maxEventSize] * @param {eventSourceSettings} options.eventSourceSettings * @param {Function} [options.push] */ @@ -89,6 +158,12 @@ class EventSourceStream extends Transform { super(options) this.state = options.eventSourceSettings || {} + this.maxEventSize = options.maxEventSize ?? defaultMaxEventSize + const parserItemLimit = this.maxEventSize > 0 + ? Math.min(maxParserItems, Math.max(minParserItems, Math.floor(this.maxEventSize / bytesPerParserItem))) + : 0 + this.maxDataLines = parserItemLimit + this.maxBufferedChunks = parserItemLimit if (options.push) { this.push = options.push } @@ -106,92 +181,28 @@ class EventSourceStream extends Transform { return } - // Cache the chunk in the buffer, as the data might not be complete while - // processing it - // TODO: Investigate if there is a more performant way to handle - // incoming chunks - // see: https://github.com/nodejs/undici/issues/2630 - if (this.buffer) { - this.buffer = Buffer.concat([this.buffer, chunk]) - } else { - this.buffer = chunk + // A leading line ending can immediately release the currently buffered + // line, even when it uses the final allowed chunk slot. + if (this.maxEventSize > 0 && + this.chunks.length >= this.maxBufferedChunks && + chunk[0] !== LF && chunk[0] !== CR) { + callback(createMaxEventSizeExceededError()) + return } + this.chunks.push(chunk) // Strip leading byte-order-mark if we opened the stream and started // the processing of the incoming data if (this.checkBOM) { - switch (this.buffer.length) { - case 1: - // Check if the first byte is the same as the first byte of the BOM - if (this.buffer[0] === BOM[0]) { - // If it is, we need to wait for more data - callback() - return - } - // Set the checkBOM flag to false as we don't need to check for the - // BOM anymore - this.checkBOM = false - - // The buffer only contains one byte so we need to wait for more data - callback() - return - case 2: - // Check if the first two bytes are the same as the first two bytes - // of the BOM - if ( - this.buffer[0] === BOM[0] && - this.buffer[1] === BOM[1] - ) { - // If it is, we need to wait for more data, because the third byte - // is needed to determine if it is the BOM or not - callback() - return - } - - // Set the checkBOM flag to false as we don't need to check for the - // BOM anymore - this.checkBOM = false - break - case 3: - // Check if the first three bytes are the same as the first three - // bytes of the BOM - if ( - this.buffer[0] === BOM[0] && - this.buffer[1] === BOM[1] && - this.buffer[2] === BOM[2] - ) { - // If it is, we can drop the buffered data, as it is only the BOM - this.buffer = Buffer.alloc(0) - // Set the checkBOM flag to false as we don't need to check for the - // BOM anymore - this.checkBOM = false - - // Await more data - callback() - return - } - // If it is not the BOM, we can start processing the data - this.checkBOM = false - break - default: - // The buffer is longer than 3 bytes, so we can drop the BOM if it is - // present - if ( - this.buffer[0] === BOM[0] && - this.buffer[1] === BOM[1] && - this.buffer[2] === BOM[2] - ) { - // Remove the BOM from the buffer - this.buffer = this.buffer.subarray(3) - } - - // Set the checkBOM flag to false as we don't need to check for the - this.checkBOM = false - break + if (this.handleBOM()) { + callback() + return } } - while (this.pos < this.buffer.length) { + while (this.hasCurrentByte()) { + const byte = this.currentByte() + // If the previous line ended with an end-of-line, we need to check // if the next character is also an end-of-line. if (this.eventEndCheck) { @@ -204,10 +215,9 @@ class EventSourceStream extends Transform { if (this.crlfCheck) { // If the current character is a line feed, we can remove it // from the buffer and reset the crlfCheck flag - if (this.buffer[this.pos] === LF) { - this.buffer = this.buffer.subarray(this.pos + 1) - this.pos = 0 + if (byte === LF) { this.crlfCheck = false + this.consumeCurrentByte() // It is possible that the line feed is not the end of the // event. We need to check if the next character is an @@ -223,19 +233,17 @@ class EventSourceStream extends Transform { this.crlfCheck = false } - if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) { + if (byte === LF || byte === CR) { // If the current character is a carriage return, we need to // set the crlfCheck flag to true, as we need to check if the // next character is a line feed so we can remove it from the // buffer - if (this.buffer[this.pos] === CR) { + if (byte === CR) { this.crlfCheck = true } - this.buffer = this.buffer.subarray(this.pos + 1) - this.pos = 0 - if ( - this.event.data !== undefined || this.event.event || this.event.id || this.event.retry) { + this.consumeCurrentByte() + if (this.hasPendingEvent()) { this.processEvent(this.event) } this.clearEvent() @@ -249,22 +257,23 @@ class EventSourceStream extends Transform { // If the current character is an end-of-line, we can process the // line - if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) { + if (byte === LF || byte === CR) { // If the current character is a carriage return, we need to // set the crlfCheck flag to true, as we need to check if the // next character is a line feed - if (this.buffer[this.pos] === CR) { + if (byte === CR) { this.crlfCheck = true } // In any case, we can process the line as we reached an // end-of-line character - this.parseLine(this.buffer.subarray(0, this.pos), this.event) - - // Remove the processed line from the buffer - this.buffer = this.buffer.subarray(this.pos + 1) - // Reset the position as we removed the processed line from the buffer - this.pos = 0 + try { + this.parseLine(this.readLine(), this.event) + } catch (error) { + callback(error) + return + } + this.consumeCurrentByte() // A line was processed and this could be the end of the event. We need // to check if the next line is empty to determine if the event is // finished. @@ -272,15 +281,28 @@ class EventSourceStream extends Transform { continue } - this.pos++ + // readLine() is only called after CR or LF. Reject an unfinished line + // before it can retain an unbounded number of decoded chunks. The seven + // extra bytes allow the longest field prefix ("event: " or "retry: "). + if (this.maxEventSize > 0 && ++this.lineLength > this.maxEventSize + 7) { + callback(createMaxEventSizeExceededError()) + return + } + this.advanceCursor() } callback() } + _destroy (error, callback) { + this.chunks.length = 0 + this.clearEvent() + super._destroy(error, callback) + } + /** * @param {Buffer} line - * @param {EventStreamEvent} event + * @param {EventSourceStreamEvent} event */ parseLine (line, event) { // If the line is empty (a blank line) @@ -297,67 +319,74 @@ class EventSourceStream extends Transform { return } - let field = '' - let value = '' + let fieldLength = line.length + let valueStart = line.length // If the line contains a U+003A COLON character (:) if (colonPosition !== -1) { - // Collect the characters on the line before the first U+003A COLON - // character (:), and let field be that string. - // TODO: Investigate if there is a more performant way to extract the - // field - // see: https://github.com/nodejs/undici/issues/2630 - field = line.subarray(0, colonPosition).toString('utf8') + fieldLength = colonPosition // Collect the characters on the line after the first U+003A COLON // character (:), and let value be that string. // If value starts with a U+0020 SPACE character, remove it from value. - let valueStart = colonPosition + 1 + valueStart = colonPosition + 1 if (line[valueStart] === SPACE) { ++valueStart } - // TODO: Investigate if there is a more performant way to extract the - // value - // see: https://github.com/nodejs/undici/issues/2630 - value = line.subarray(valueStart).toString('utf8') - - // Otherwise, the string is not empty but does not contain a U+003A COLON - // character (:) - } else { - // Process the field using the steps described below, using the whole - // line as the field name, and the empty string as the field value. - field = line.toString('utf8') - value = '' } - // Modify the event with the field name and value. The value is also - // decoded as UTF-8 - switch (field) { - case 'data': - if (event[field] === undefined) { - event[field] = value - } else { - event[field] += `\n${value}` - } - break - case 'retry': - if (isASCIINumber(value)) { - event[field] = value - } - break - case 'id': - if (isValidLastEventId(value)) { - event[field] = value - } - break - case 'event': - if (value.length > 0) { - event[field] = value - } - break + if (isFieldName(line, fieldLength, DATA)) { + if (this.maxEventSize > 0 && this.dataLineCount >= this.maxDataLines) { + throw createMaxEventSizeExceededError() + } + const valueBytes = line.length - valueStart + const dataSize = this.eventFieldSizes.data + (event.data === undefined ? 0 : 1) + valueBytes + this.setEventFieldSize('data', dataSize) + + const value = line.toString('utf8', valueStart) + + if (event.data === undefined) { + event.data = value + } else { + event.data += `\n${value}` + } + this.dataLineCount++ + return + } + + if (isFieldName(line, fieldLength, RETRY)) { + if (isASCIINumberBytes(line, valueStart)) { + this.setEventFieldSize('retry', line.length - valueStart) + event.retry = line.toString('utf8', valueStart) + } + return + } + + if (isFieldName(line, fieldLength, ID)) { + if (isValidLastEventIdBytes(line, valueStart)) { + this.setEventFieldSize('id', line.length - valueStart) + event.id = line.toString('utf8', valueStart) + } + return + } + + if (isFieldName(line, fieldLength, EVENT)) { + if (valueStart < line.length) { + this.setEventFieldSize('event', line.length - valueStart) + event.event = line.toString('utf8', valueStart) + } } } + setEventFieldSize (field, size) { + const eventSize = this.eventSize - this.eventFieldSizes[field] + size + if (this.maxEventSize > 0 && eventSize > this.maxEventSize) { + throw createMaxEventSizeExceededError() + } + this.eventSize = eventSize + this.eventFieldSizes[field] = size + } + /** * @param {EventSourceStreamEvent} event */ @@ -384,13 +413,160 @@ class EventSourceStream extends Transform { } clearEvent () { - this.event = { - data: undefined, - event: undefined, - id: undefined, - retry: undefined + this.event.data = undefined + this.event.event = undefined + this.event.id = undefined + this.event.retry = undefined + this.eventSize = 0 + this.dataLineCount = 0 + this.eventFieldSizes.data = 0 + this.eventFieldSizes.event = 0 + this.eventFieldSizes.id = 0 + this.eventFieldSizes.retry = 0 + } + + hasPendingEvent () { + return this.event.data !== undefined || + this.event.event !== undefined || + this.event.id !== undefined || + this.event.retry !== undefined + } + + hasCurrentByte () { + return this.chunkIndex < this.chunks.length && + this.pos < this.chunks[this.chunkIndex].length + } + + currentByte () { + return this.chunks[this.chunkIndex][this.pos] + } + + consumeCurrentByte () { + this.advanceCursor() + this.syncLineStartToCursor() + } + + advanceCursor () { + this.pos++ + + while (this.chunkIndex < this.chunks.length && this.pos >= this.chunks[this.chunkIndex].length) { + this.chunkIndex++ + this.pos = 0 + } + } + + syncLineStartToCursor () { + this.lineChunkIndex = this.chunkIndex + this.linePos = this.pos + this.lineLength = 0 + this.dropConsumedChunks() + } + + dropConsumedChunks () { + if (this.lineChunkIndex > 0) { + const consumed = this.lineChunkIndex + this.chunks.splice(0, consumed) + this.lineChunkIndex = 0 + this.chunkIndex -= consumed + } + + if (this.chunkIndex === this.chunks.length) { + this.chunks.length = 0 + this.chunkIndex = 0 + this.pos = 0 + this.lineChunkIndex = 0 + this.linePos = 0 } } + + readLine () { + if (this.lineChunkIndex === this.chunkIndex) { + return this.chunks[this.chunkIndex].subarray(this.linePos, this.pos) + } + + const chunks = [] + let length = 0 + + for (let i = this.lineChunkIndex; i <= this.chunkIndex; i++) { + const chunk = this.chunks[i] + const start = i === this.lineChunkIndex ? this.linePos : 0 + const end = i === this.chunkIndex ? this.pos : chunk.length + const slice = chunk.subarray(start, end) + length += slice.length + chunks.push(slice) + } + + return Buffer.concat(chunks, length) + } + + peekBufferedByte (offset) { + let chunkIndex = this.lineChunkIndex + let pos = this.linePos + + while (chunkIndex < this.chunks.length) { + const chunk = this.chunks[chunkIndex] + const remaining = chunk.length - pos + + if (offset < remaining) { + return chunk[pos + offset] + } + + offset -= remaining + chunkIndex++ + pos = 0 + } + } + + discardLeadingBytes (count) { + while (count > 0 && this.lineChunkIndex < this.chunks.length) { + const chunk = this.chunks[this.lineChunkIndex] + const remaining = chunk.length - this.linePos + + if (count < remaining) { + this.linePos += count + count = 0 + } else { + count -= remaining + this.lineChunkIndex++ + this.linePos = 0 + } + } + + this.chunkIndex = this.lineChunkIndex + this.pos = this.linePos + this.dropConsumedChunks() + } + + handleBOM () { + const first = this.peekBufferedByte(0) + const second = this.peekBufferedByte(1) + const third = this.peekBufferedByte(2) + + if (second === undefined) { + if (first === BOM[0]) { + return true + } + + this.checkBOM = false + return true + } + + if (third === undefined) { + if (first === BOM[0] && second === BOM[1]) { + return true + } + + this.checkBOM = false + return false + } + + if (first === BOM[0] && second === BOM[1] && third === BOM[2]) { + this.discardLeadingBytes(3) + } + + this.checkBOM = false + return !this.hasCurrentByte() + } } module.exports = { diff --git a/deps/npm/node_modules/undici/lib/web/eventsource/eventsource.js b/deps/npm/node_modules/undici/lib/web/eventsource/eventsource.js index 5a488ffce27..6092645bf2c 100644 --- a/deps/npm/node_modules/undici/lib/web/eventsource/eventsource.js +++ b/deps/npm/node_modules/undici/lib/web/eventsource/eventsource.js @@ -11,6 +11,7 @@ const { isNetworkError } = require('../fetch/response') const { delay } = require('./util') const { kEnumerableProperty } = require('../../core/util') const { environmentSettingsObject } = require('../fetch/util') +const { getGlobalDispatcher } = require('../../global') let experimentalWarned = false @@ -292,6 +293,7 @@ class EventSource extends EventTarget { const eventSourceStream = new EventSourceStream({ eventSourceSettings: this.#state, + maxEventSize: this.#dispatcher.eventSourceOptions?.maxEventSize, push: (event) => { this.dispatchEvent(createFastMessageEvent( event.type, @@ -470,7 +472,8 @@ webidl.converters.EventSourceInitDict = webidl.dictionaryConverter([ }, { key: 'dispatcher', // undici only - converter: webidl.converters.any + converter: webidl.converters.any, + defaultValue: () => getGlobalDispatcher() } ]) diff --git a/deps/npm/node_modules/undici/lib/web/fetch/index.js b/deps/npm/node_modules/undici/lib/web/fetch/index.js index 9a685d680a1..b3b21873dcd 100644 --- a/deps/npm/node_modules/undici/lib/web/fetch/index.js +++ b/deps/npm/node_modules/undici/lib/web/fetch/index.js @@ -1950,8 +1950,10 @@ async function httpNetworkFetch ( // 19. Run these steps in parallel: // 1. Run these steps, but abort when fetchParams is canceled: - fetchParams.controller.onAborted = onAborted - fetchParams.controller.on('terminated', onAborted) + if (!fetchParams.controller.resume) { + fetchParams.controller.on('terminated', onAborted) + } + fetchParams.controller.resume = async () => { // 1. While true while (true) { @@ -2120,8 +2122,6 @@ async function httpNetworkFetch ( } location = headersList.get('location', true) - this.body = new Readable({ read: resume }) - const decoders = [] const willFollow = location && request.redirect === 'follow' && @@ -2139,7 +2139,7 @@ async function httpNetworkFetch ( // CVE fix similar to urllib3 (GHSA-gm62-xv2j-4w53) and curl (CVE-2022-32206). const maxContentEncodings = 5 if (codings.length > maxContentEncodings) { - reject(new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`)) + this.abort(new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`)) return true } @@ -2172,6 +2172,8 @@ async function httpNetworkFetch ( } } + this.body = new Readable({ read: resume }) + const onError = this.onError.bind(this) resolve({ @@ -2218,10 +2220,6 @@ async function httpNetworkFetch ( fetchParams.controller.off('terminated', this.abort) } - if (fetchParams.controller.onAborted) { - fetchParams.controller.off('terminated', fetchParams.controller.onAborted) - } - fetchParams.controller.ended = true this.body.push(null) diff --git a/deps/npm/node_modules/undici/lib/web/websocket/connection.js b/deps/npm/node_modules/undici/lib/web/websocket/connection.js index bb87d361e4b..1197b9b650c 100644 --- a/deps/npm/node_modules/undici/lib/web/websocket/connection.js +++ b/deps/npm/node_modules/undici/lib/web/websocket/connection.js @@ -192,7 +192,7 @@ function establishWebSocketConnection (url, protocols, client, ws, onEstablish, // is specified, the server needs to include the same field and one of // the selected subprotocol values in its response for the connection to // be established. - if (!requestProtocols.includes(secProtocol)) { + if (requestProtocols === null || !requestProtocols.includes(secProtocol)) { failWebsocketConnection(ws, 'Protocol was not set in the opening handshake.') return } diff --git a/deps/npm/node_modules/undici/lib/web/websocket/permessage-deflate.js b/deps/npm/node_modules/undici/lib/web/websocket/permessage-deflate.js index 6a6e43899c5..0b3d493db82 100644 --- a/deps/npm/node_modules/undici/lib/web/websocket/permessage-deflate.js +++ b/deps/npm/node_modules/undici/lib/web/websocket/permessage-deflate.js @@ -63,7 +63,12 @@ class PerMessageDeflate { if (this.#maxPayloadSize > 0 && this.#inflate[kLength] > this.#maxPayloadSize) { callback(new MessageSizeExceededError()) + // The inflater may still hold buffered input that can emit a late + // zlib error. Remove the data listener, then deterministically stop + // the stream so a subsequent 'error' cannot fire without a listener + // (which would terminate the process as an unhandled error event). this.#inflate.removeAllListeners() + this.#inflate.destroy() this.#inflate = null return } diff --git a/deps/npm/node_modules/undici/lib/web/websocket/receiver.js b/deps/npm/node_modules/undici/lib/web/websocket/receiver.js index a7dea7fae1c..b36ef9f9378 100644 --- a/deps/npm/node_modules/undici/lib/web/websocket/receiver.js +++ b/deps/npm/node_modules/undici/lib/web/websocket/receiver.js @@ -249,6 +249,20 @@ class ByteParser extends Writable { if (isControlFrame(this.#info.opcode)) { this.#loop = this.parseControlFrame(body) this.#state = parserStates.INFO + + // If the automatic PONG/CLOSE reply filled the socket's write buffer, + // stop parsing and resume on drain so a PING flood cannot grow the + // outbound queue without bound. + const socket = this.ws[kResponse].socket + if (this.#loop && socket.writableNeedDrain) { + this.#loop = false + socket.once('drain', () => { + if (this.destroyed) return + this.#loop = true + this.run(callback) + }) + return + } } else { if (!this.#info.compressed) { if (!this.writeFragments(body)) { diff --git a/deps/npm/node_modules/undici/package.json b/deps/npm/node_modules/undici/package.json index cd46deca244..4bccc5455b8 100644 --- a/deps/npm/node_modules/undici/package.json +++ b/deps/npm/node_modules/undici/package.json @@ -1,6 +1,6 @@ { "name": "undici", - "version": "6.28.0", + "version": "6.29.1", "description": "An HTTP/1.1 client, written from scratch for Node.js", "homepage": "https://undici.nodejs.org", "bugs": { diff --git a/deps/npm/package.json b/deps/npm/package.json index 44b3ca52029..49b1151d17d 100644 --- a/deps/npm/package.json +++ b/deps/npm/package.json @@ -1,5 +1,5 @@ { - "version": "11.20.0", + "version": "11.21.2", "name": "npm", "description": "a package manager for JavaScript", "workspaces": [ @@ -52,13 +52,13 @@ }, "dependencies": { "@isaacs/string-locale-compare": "^1.1.0", - "@npmcli/arborist": "^9.9.2", - "@npmcli/config": "^10.13.0", + "@npmcli/arborist": "^9.9.3", + "@npmcli/config": "^10.14.0", "@npmcli/fs": "^5.0.0", "@npmcli/map-workspaces": "^5.0.3", "@npmcli/metavuln-calculator": "^9.0.3", "@npmcli/package-json": "^7.0.5", - "@npmcli/promise-spawn": "^9.0.1", + "@npmcli/promise-spawn": "^9.0.2", "@npmcli/redact": "^4.0.0", "@npmcli/run-script": "^10.0.4", "@sigstore/tuf": "^4.0.2", @@ -77,11 +77,11 @@ "is-cidr": "^6.0.4", "json-parse-even-better-errors": "^5.0.0", "libnpmaccess": "^10.0.3", - "libnpmdiff": "^8.1.13", - "libnpmexec": "^10.3.3", - "libnpmfund": "^7.0.27", + "libnpmdiff": "^8.1.14", + "libnpmexec": "^10.3.5", + "libnpmfund": "^7.0.28", "libnpmorg": "^8.0.1", - "libnpmpack": "^9.1.14", + "libnpmpack": "^9.1.15", "libnpmpublish": "^11.2.1", "libnpmsearch": "^9.0.1", "libnpmteam": "^8.0.2", @@ -101,12 +101,12 @@ "npm-registry-fetch": "^19.1.1", "npm-user-validate": "^4.0.0", "p-map": "^7.0.4", - "pacote": "^21.5.1", + "pacote": "^21.5.2", "parse-conflict-json": "^5.0.1", "proc-log": "^6.1.0", "qrcode-terminal": "^0.12.0", "read": "^5.0.1", - "semver": "^7.8.5", + "semver": "^7.8.6", "spdx-expression-parse": "^4.0.0", "ssri": "^13.0.1", "supports-color": "^10.2.2", diff --git a/deps/npm/test/fixtures/mock-oidc.js b/deps/npm/test/fixtures/mock-oidc.js index e2e11b27224..86735571b94 100644 --- a/deps/npm/test/fixtures/mock-oidc.js +++ b/deps/npm/test/fixtures/mock-oidc.js @@ -54,6 +54,7 @@ const mockOidc = async (t, { mockGithubOidcOptions = false, mockOidcTokenExchangeOptions = false, publishOptions = {}, + publish = true, provenance = false, oidcVisibilityOptions = false, }) => { @@ -139,7 +140,9 @@ const mockOidc = async (t, { registry.getVisibility({ spec: packageName, visibility: oidcVisibilityOptions }) } - registry.publish(packageName, publishOptions) + if (publish) { + registry.publish(packageName, publishOptions) + } /** * this will nock / mock all the successful requirements for provenance and diff --git a/deps/npm/test/lib/cli/entry.js b/deps/npm/test/lib/cli/entry.js index 369927dace0..640b06359cc 100644 --- a/deps/npm/test/lib/cli/entry.js +++ b/deps/npm/test/lib/cli/entry.js @@ -150,6 +150,36 @@ t.test('unsupported node version', async t => { ) }) +t.test('prerelease node versions', async t => { + for (const [version, supported] of [ + ['v27.0.0-alpha.0.0.0', true], + ['v28.0.0-alpha.0.0.0', true], + ['v27.0.0-rc.0', true], + ['v26.0.0-alpha.0', true], + ['v23.0.0-alpha.0', true], + ['v22.9.1-alpha.0', true], + ['v20.17.1-alpha.0', true], + ['v22.9.0-alpha.0', false], + ['v21.0.0-alpha.0', false], + ['v20.17.0-alpha.0', false], + ]) { + await t.test(version, async t => { + const { cli, logs } = await cliMock(t, { + globals: { + 'process.argv': ['node', 'npm', '--version'], + 'process.version': version, + }, + }) + await cli(process) + if (supported) { + t.strictSame(logs.warn, []) + } else { + t.match(logs.warn[0], `does not support Node.js ${version}.`) + } + }) + } +}) + t.test('non-ascii dash', async t => { const { cli, logs } = await cliMock(t, { globals: { diff --git a/deps/npm/test/lib/commands/approve-scripts.js b/deps/npm/test/lib/commands/approve-scripts.js index 1f29cb89894..f9ab63510a2 100644 --- a/deps/npm/test/lib/commands/approve-scripts.js +++ b/deps/npm/test/lib/commands/approve-scripts.js @@ -859,3 +859,250 @@ t.test('approve-scripts --all with only bundled deps has nothing to review', asy const pkg = JSON.parse(fs.readFileSync(resolve(prefix, 'package.json'), 'utf8')) t.notOk(pkg.allowScripts, 'no allowScripts written') }) + +// Layout produced by install-strategy=linked: the real package lives in the store, node_modules holds a symlink to it, and the hidden lockfile records that isolated layout (npm/cli#9939). +const setupLinkedProject = (t, { allowScripts, noResolved = false } = {}) => { + const storeDir = 'canvas@1.0.0-c2FsdHNhbHRzYWx0c2FsdA' + const storeLoc = `node_modules/.store/${storeDir}/node_modules/canvas` + const tarUrl = noResolved + ? undefined + : 'https://registry.npmjs.org/canvas/-/canvas-1.0.0.tgz' + const pkg = { + name: 'host', + version: '1.0.0', + dependencies: { canvas: '^1.0.0' }, + } + if (allowScripts !== undefined) { + pkg.allowScripts = allowScripts + } + return { + 'package.json': JSON.stringify(pkg, null, 2), + 'package-lock.json': JSON.stringify({ + name: pkg.name, + version: pkg.version, + lockfileVersion: 3, + requires: true, + packages: { + '': pkg, + 'node_modules/canvas': { + version: '1.0.0', + resolved: tarUrl, + hasInstallScript: true, + }, + }, + }), + node_modules: { + '.package-lock.json': JSON.stringify({ + lockfileVersion: 3, + requires: true, + packages: { + [`node_modules/.store/${storeDir}`]: {}, + [storeLoc]: { + version: '1.0.0', + resolved: tarUrl, + hasInstallScript: true, + }, + 'node_modules/canvas': { + resolved: storeLoc, + link: true, + }, + }, + }), + '.store': { + [storeDir]: { + node_modules: { + canvas: { + 'package.json': JSON.stringify({ + name: 'canvas', + version: '1.0.0', + scripts: { install: 'echo install' }, + }), + }, + }, + }, + }, + canvas: t.fixture('symlink', `.store/${storeDir}/node_modules/canvas`), + }, + } +} + +// loadActual only trusts the hidden lockfile when it is newer than every dir under node_modules (assertNoNewer allows 10ms), and fixture creation order makes that racy, so bump its mtime past the fixture writes. +const trustHiddenLockfile = (prefix) => { + const future = new Date(Date.now() + 60_000) + fs.utimesSync(resolve(prefix, 'node_modules', '.package-lock.json'), future, future) +} + +t.test('approve-scripts under linked strategy writes a registry pin, not store paths', async t => { + const { npm, prefix } = await mockNpm(t, { + prefixDir: setupLinkedProject(t), + }) + trustHiddenLockfile(prefix) + await npm.exec('approve-scripts', ['canvas']) + + const pkg = JSON.parse(fs.readFileSync(resolve(prefix, 'package.json'), 'utf8')) + t.strictSame(pkg.allowScripts, { 'canvas@1.0.0': true }) +}) + +t.test('approve-scripts --all under linked strategy writes a registry pin, not store paths', async t => { + const { npm, prefix } = await mockNpm(t, { + prefixDir: setupLinkedProject(t), + config: { all: true }, + }) + trustHiddenLockfile(prefix) + await npm.exec('approve-scripts', []) + + const pkg = JSON.parse(fs.readFileSync(resolve(prefix, 'package.json'), 'utf8')) + t.strictSame(pkg.allowScripts, { 'canvas@1.0.0': true }) +}) + +t.test('approve-scripts --pending is empty when the registry pin covers a linked store package', async t => { + const { npm, prefix, joinedOutput } = await mockNpm(t, { + prefixDir: setupLinkedProject(t, { allowScripts: { 'canvas@1.0.0': true } }), + config: { 'allow-scripts-pending': true }, + }) + trustHiddenLockfile(prefix) + await npm.exec('approve-scripts', []) + t.match(joinedOutput(), /No packages with unreviewed install scripts/) +}) + +t.test('deny-scripts under linked strategy writes a name-only deny', async t => { + const { npm, prefix } = await mockNpm(t, { + prefixDir: setupLinkedProject(t), + }) + trustHiddenLockfile(prefix) + await npm.exec('deny-scripts', ['canvas']) + + const pkg = JSON.parse(fs.readFileSync(resolve(prefix, 'package.json'), 'utf8')) + t.strictSame(pkg.allowScripts, { canvas: false }) +}) + +const setupLocalFileDepProject = (t) => { + const pkg = { + name: 'host', + version: '1.0.0', + dependencies: { foo: 'file:./local-foo' }, + } + return { + 'package.json': JSON.stringify(pkg, null, 2), + 'package-lock.json': JSON.stringify({ + name: 'host', + version: '1.0.0', + lockfileVersion: 3, + requires: true, + packages: { + '': pkg, + 'local-foo': { + name: 'local-foo', + version: '1.0.0', + hasInstallScript: true, + }, + 'node_modules/foo': { + resolved: 'local-foo', + link: true, + }, + }, + }), + 'local-foo': { + 'package.json': JSON.stringify({ + name: 'local-foo', + version: '1.0.0', + scripts: { install: 'echo install' }, + }), + }, + node_modules: { + foo: t.fixture('symlink', '../local-foo'), + }, + } +} + +t.test('approve-scripts finds a local file: dep through its link', async t => { + // The Link is named `foo` while its target is named `local-foo`; positional matching must dereference the Link instead of skipping it (npm/cli#9939 review). + const { npm, prefix } = await mockNpm(t, { + prefixDir: setupLocalFileDepProject(t), + }) + await npm.exec('approve-scripts', ['foo']) + + const pkg = JSON.parse(fs.readFileSync(resolve(prefix, 'package.json'), 'utf8')) + t.strictSame(pkg.allowScripts, { 'file:../local-foo': true }) +}) + +t.test('deny-scripts finds a local file: dep through its link', async t => { + const { npm, prefix } = await mockNpm(t, { + prefixDir: setupLocalFileDepProject(t), + }) + await npm.exec('deny-scripts', ['foo']) + + const pkg = JSON.parse(fs.readFileSync(resolve(prefix, 'package.json'), 'utf8')) + t.strictSame(pkg.allowScripts, { 'file:../local-foo': false }) +}) + +t.test('approve-scripts under linked strategy without resolved URLs approves by name', async t => { + // omit-lockfile-registry-resolved: the store package has no resolved URL, so it cannot be pinned but must still be approved by name via the incoming Link's edge. + const { npm, prefix } = await mockNpm(t, { + prefixDir: setupLinkedProject(t, { noResolved: true }), + }) + trustHiddenLockfile(prefix) + await npm.exec('approve-scripts', ['canvas']) + + const pkg = JSON.parse(fs.readFileSync(resolve(prefix, 'package.json'), 'utf8')) + t.strictSame(pkg.allowScripts, { canvas: true }) +}) + +for (const state of ['missing', 'stale']) { + t.test(`prune keeps denies with a ${state} hidden lockfile`, async t => { + // With no trusted version, the versioned deny still blocks at runtime, so prune must fail closed and keep it instead of flipping the effective policy to allowed (npm/cli#9941 review). + const Arborist = require('@npmcli/arborist') + const isScriptAllowed = require('@npmcli/arborist/lib/script-allowed.js') + const allowScripts = { + canvas: true, + 'canvas@1.0.0': false, + } + + const { npm, prefix } = await mockNpm(t, { + prefixDir: setupLinkedProject(t, { allowScripts }), + config: { 'install-strategy': 'linked' }, + }) + + const hidden = resolve(prefix, 'node_modules', '.package-lock.json') + if (state === 'missing') { + fs.unlinkSync(hidden) + } else { + fs.utimesSync(hidden, new Date(0), new Date(0)) + } + + t.equal(npm.config.get('omit-lockfile-registry-resolved'), false) + + const arb = new Arborist({ ...npm.flatOptions, path: prefix }) + const tree = await arb.loadActual() + const target = [...tree.inventory.values()] + .find(node => !node.isLink && node.name === 'canvas') + + t.ok(target, 'finds the installed target') + t.strictSame( + isScriptAllowed.getTrustedRegistryIdentity(target), + { name: 'canvas', version: null }, + 'recovers the registry name without inventing a trusted version' + ) + t.equal( + isScriptAllowed(target, allowScripts), + false, + 'the versioned deny blocks the package before pruning' + ) + + await npm.exec('install-scripts', ['prune']) + + const pkg = JSON.parse( + fs.readFileSync(resolve(prefix, 'package.json'), 'utf8') + ) + t.strictSame( + pkg.allowScripts, + allowScripts, + 'pruning preserves both the allow and its active deny exception' + ) + t.equal( + isScriptAllowed(target, pkg.allowScripts), + false, + 'the package remains denied after pruning' + ) + }) +} diff --git a/deps/npm/test/lib/commands/dist-tag.js b/deps/npm/test/lib/commands/dist-tag.js index 5de9acb1da8..531ade8aab7 100644 --- a/deps/npm/test/lib/commands/dist-tag.js +++ b/deps/npm/test/lib/commands/dist-tag.js @@ -1,6 +1,13 @@ const t = require('tap') const realFetch = require('npm-registry-fetch') +const npa = require('npm-package-arg') const mockNpm = require('../../fixtures/mock-npm') +const { + circleciIdToken, + githubIdToken, + gitlabIdToken, + mockOidc, +} = require('../../fixtures/mock-oidc') const fixtures = { workspace: { @@ -61,6 +68,30 @@ const tags = { }, } +const mockTagRequests = ({ + registry, + packageName, + token, + tags: tagData, + mutation, +}) => { + const spec = npa(packageName) + const path = `/-/package/${spec.escapedName}/dist-tags` + const authorization = `Bearer ${token}` + + registry.nock.get(registry.fullPath(path)) + .matchHeader('authorization', authorization) + .reply(200, tagData) + + if (mutation) { + registry.nock[mutation.method.toLowerCase()]( + registry.fullPath(`${path}/${encodeURIComponent(mutation.tag)}`) + ) + .matchHeader('authorization', authorization) + .reply(200, {}) + } +} + const mockDist = async (t, { ...npmOpts } = {}) => { const getTag = async (url) => ({ ...tags })[url] @@ -362,6 +393,351 @@ t.test('remove missing pkg name', async t => { ) }) +t.test('oidc token exchange', async t => { + const packageName = '@npmcli/test-package' + const fallbackToken = 'existing-fallback-token' + const exchangeToken = 'exchange-token' + const privateGithubToken = githubIdToken({ visibility: 'private' }) + + const setup = (t, options = {}) => mockOidc(t, { + packageName, + publish: false, + ...options, + }) + + t.test('list uses the exchanged token', async t => { + const { npm, registry } = await setup(t, { + oidcOptions: { github: true }, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + idToken: privateGithubToken, + }, + mockOidcTokenExchangeOptions: { + idToken: privateGithubToken, + body: { token: exchangeToken }, + }, + }) + mockTagRequests({ + registry, + packageName, + token: exchangeToken, + tags: { latest: '1.0.0' }, + }) + + await npm.exec('dist-tag', ['list', packageName]) + }) + + t.test('add uses the exchanged token for GET and PUT', async t => { + const { npm, registry } = await setup(t, { + oidcOptions: { github: true }, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + idToken: privateGithubToken, + }, + mockOidcTokenExchangeOptions: { + idToken: privateGithubToken, + body: { token: exchangeToken }, + }, + }) + mockTagRequests({ + registry, + packageName, + token: exchangeToken, + tags: { latest: '1.0.0' }, + mutation: { method: 'PUT', tag: 'next' }, + }) + + await npm.exec('dist-tag', ['add', `${packageName}@2.0.0`, 'next']) + }) + + t.test('remove uses the exchanged token for GET and DELETE', async t => { + const { npm, registry } = await setup(t, { + oidcOptions: { github: true }, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + idToken: privateGithubToken, + }, + mockOidcTokenExchangeOptions: { + idToken: privateGithubToken, + body: { token: exchangeToken }, + }, + }) + mockTagRequests({ + registry, + packageName, + token: exchangeToken, + tags: { latest: '1.0.0', old: '0.9.0' }, + mutation: { method: 'DELETE', tag: 'old' }, + }) + + await npm.exec('dist-tag', ['remove', packageName, 'old']) + }) + + for (const [provider, oidcOptions, idToken] of [ + ['gitlab', { gitlab: true, NPM_ID_TOKEN: gitlabIdToken({ visibility: 'private' }) }, gitlabIdToken({ visibility: 'private' })], + ['circleci', { circleci: true, NPM_ID_TOKEN: circleciIdToken() }, circleciIdToken()], + ]) { + t.test(`${provider} uses NPM_ID_TOKEN for exchange`, async t => { + const providerIdToken = oidcOptions.NPM_ID_TOKEN || idToken + const { npm, registry } = await setup(t, { + oidcOptions, + mockOidcTokenExchangeOptions: { + idToken: providerIdToken, + body: { token: exchangeToken }, + }, + }) + mockTagRequests({ + registry, + packageName, + token: exchangeToken, + tags: { latest: '1.0.0' }, + }) + + await npm.exec('dist-tag', ['list', packageName]) + }) + } + + t.test('custom scoped registry uses its audience and auth key', async t => { + const registryUrl = 'https://registry.zzz.org' + const { npm, registry } = await setup(t, { + oidcOptions: { github: true }, + config: { + '@npmcli:registry': registryUrl, + }, + mockGithubOidcOptions: { + audience: 'npm:registry.zzz.org', + idToken: privateGithubToken, + }, + mockOidcTokenExchangeOptions: { + idToken: privateGithubToken, + body: { token: exchangeToken }, + }, + load: { + registry: registryUrl, + }, + }) + mockTagRequests({ + registry, + packageName, + token: exchangeToken, + tags: { latest: '1.0.0' }, + }) + + await npm.exec('dist-tag', ['list', packageName]) + }) + + for (const testCase of [ + { + name: 'no CI', + oidcOptions: {}, + }, + { + name: 'missing GitHub OIDC permissions', + oidcOptions: { github: true, ACTIONS_ID_TOKEN_REQUEST_URL: '' }, + }, + { + name: 'GitHub identity token request failure', + oidcOptions: { github: true }, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + statusCode: 500, + }, + }, + { + name: 'token exchange failure', + oidcOptions: { github: true }, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + idToken: privateGithubToken, + }, + mockOidcTokenExchangeOptions: { + idToken: privateGithubToken, + statusCode: 500, + body: { message: 'exchange failed' }, + }, + }, + { + name: 'token exchange response missing token', + oidcOptions: { github: true }, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + idToken: privateGithubToken, + }, + mockOidcTokenExchangeOptions: { + idToken: privateGithubToken, + body: {}, + }, + }, + ]) { + t.test(`${testCase.name} preserves fallback credentials`, async t => { + const { npm, registry } = await setup(t, { + config: { + '//registry.npmjs.org/:_authToken': fallbackToken, + }, + ...testCase, + }) + mockTagRequests({ + registry, + packageName, + token: fallbackToken, + tags: { latest: '1.0.0' }, + }) + + await npm.exec('dist-tag', ['list', packageName]) + }) + } + + t.test('current package list exchanges after resolving its name', async t => { + const { npm, registry } = await setup(t, { + oidcOptions: { github: true }, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + idToken: privateGithubToken, + }, + mockOidcTokenExchangeOptions: { + idToken: privateGithubToken, + body: { token: exchangeToken }, + }, + }) + mockTagRequests({ + registry, + packageName, + token: exchangeToken, + tags: { latest: '1.0.0' }, + }) + + await npm.exec('dist-tag', ['list']) + }) + + t.test('workspace list exchanges separately for each package', async t => { + const workspaceToken = githubIdToken({ visibility: 'private' }) + const prefixDir = { + 'package.json': JSON.stringify({ + name: 'workspace-root', + version: '1.0.0', + workspaces: ['workspace-a', 'workspace-b'], + }), + 'workspace-a': { + 'package.json': JSON.stringify({ + name: 'workspace-a', + version: '1.0.0', + }), + }, + 'workspace-b': { + 'package.json': JSON.stringify({ + name: 'workspace-b', + version: '1.0.0', + }), + }, + } + const { npm, registry } = await setup(t, { + oidcOptions: { github: true }, + config: { workspaces: true }, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + idToken: workspaceToken, + times: 2, + }, + load: { prefixDir }, + }) + + for (const [name, token] of [ + ['workspace-a', 'workspace-a-exchange-token'], + ['workspace-b', 'workspace-b-exchange-token'], + ]) { + registry.mockOidcTokenExchange({ + packageName: name, + idToken: workspaceToken, + body: { token }, + }) + mockTagRequests({ + registry, + packageName: name, + token, + tags: { latest: '1.0.0' }, + }) + } + + await npm.exec('dist-tag', []) + }) + + t.test('workspace list restores fallback credentials after a failed exchange', async t => { + const { npm, registry } = await setup(t, { + oidcOptions: { github: true }, + config: { workspaces: true }, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + idToken: privateGithubToken, + times: 3, + }, + load: { + prefixDir: fixtures.workspace, + homeDir: { + '.npmrc': `//registry.npmjs.org/:_authToken=${fallbackToken}`, + }, + }, + }) + for (const [name, token] of [ + ['workspace-a', exchangeToken], + ['workspace-b', fallbackToken], + ['workspace-c', 'workspace-c-exchange-token'], + ]) { + const failed = name === 'workspace-b' + registry.mockOidcTokenExchange({ + packageName: name, + idToken: privateGithubToken, + statusCode: failed ? 404 : 200, + body: failed ? { message: 'No trusted publisher configured' } : { token }, + }) + mockTagRequests({ + registry, + packageName: name, + token, + tags: { latest: '1.0.0' }, + }) + } + + await npm.exec('dist-tag', []) + }) + + t.test('does not run publish provenance checks', async t => { + const publicGithubToken = githubIdToken({ visibility: 'public' }) + let visibilityCalls = 0 + const { npm, registry } = await setup(t, { + oidcOptions: { github: true }, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + idToken: publicGithubToken, + }, + mockOidcTokenExchangeOptions: { + idToken: publicGithubToken, + body: { token: exchangeToken }, + }, + load: { + mocks: { + libnpmaccess: { + getVisibility: () => { + visibilityCalls++ + return { public: true } + }, + }, + }, + }, + }) + mockTagRequests({ + registry, + packageName, + token: exchangeToken, + tags: { latest: '1.0.0' }, + }) + + await npm.exec('dist-tag', ['list', packageName]) + t.equal(visibilityCalls, 0, 'must not check package visibility') + }) + + t.end() +}) + t.test('completion', async t => { const { distTag } = await mockDist(t) diff --git a/deps/npm/test/lib/commands/install-scripts.js b/deps/npm/test/lib/commands/install-scripts.js index 523aba42bdd..e3c42ac2485 100644 --- a/deps/npm/test/lib/commands/install-scripts.js +++ b/deps/npm/test/lib/commands/install-scripts.js @@ -334,3 +334,64 @@ t.test('install-scripts prune fails for global installs', async t => { { code: 'EGLOBAL' } ) }) + +t.test('install-scripts prune under linked strategy keeps the registry pin, drops store paths', async t => { + // Regression for npm/cli#9939: the buggy writer produced file:.store keys; prune must drop those and keep the valid registry pin covering the store package. + const storeDir = 'canvas@1.0.0-c2FsdHNhbHRzYWx0c2FsdA' + const storeLoc = `node_modules/.store/${storeDir}/node_modules/canvas` + const tarUrl = 'https://registry.npmjs.org/canvas/-/canvas-1.0.0.tgz' + const pkg = { + name: 'host', + version: '1.0.0', + dependencies: { canvas: '^1.0.0' }, + allowScripts: { + 'canvas@1.0.0': true, + [`file:.store/${storeDir}/node_modules/canvas`]: true, + }, + } + const { npm, prefix, joinedOutput } = await mockNpm(t, { + prefixDir: { + 'package.json': JSON.stringify(pkg, null, 2), + node_modules: { + '.package-lock.json': JSON.stringify({ + lockfileVersion: 3, + requires: true, + packages: { + [`node_modules/.store/${storeDir}`]: {}, + [storeLoc]: { + version: '1.0.0', + resolved: tarUrl, + hasInstallScript: true, + }, + 'node_modules/canvas': { + resolved: storeLoc, + link: true, + }, + }, + }), + '.store': { + [storeDir]: { + node_modules: { + canvas: { + 'package.json': JSON.stringify({ + name: 'canvas', + version: '1.0.0', + scripts: { install: 'echo install' }, + }), + }, + }, + }, + }, + canvas: t.fixture('symlink', `.store/${storeDir}/node_modules/canvas`), + }, + }, + }) + // loadActual only trusts the hidden lockfile when it is newer than every dir under node_modules (assertNoNewer allows 10ms), and fixture creation order makes that racy, so bump its mtime past the fixture writes. + const future = new Date(Date.now() + 60_000) + fs.utimesSync(resolve(prefix, 'node_modules', '.package-lock.json'), future, future) + await npm.exec('install-scripts', ['prune']) + + const updated = JSON.parse(fs.readFileSync(resolve(prefix, 'package.json'), 'utf8')) + t.strictSame(updated.allowScripts, { 'canvas@1.0.0': true }) + t.match(joinedOutput(), /file:\.store.*\(package not installed\)/) +}) diff --git a/deps/npm/test/lib/commands/publish.js b/deps/npm/test/lib/commands/publish.js index 8b20c5671aa..c0f231dc9db 100644 --- a/deps/npm/test/lib/commands/publish.js +++ b/deps/npm/test/lib/commands/publish.js @@ -1363,6 +1363,123 @@ t.test('oidc token exchange - no provenance', t => { }, })) + for (const fallback of [true, false]) { + t.test(`workspace exchange failure ${fallback ? 'restores fallback' : 'requires auth'}`, async t => { + const fallbackToken = 'existing-fallback-token' + const { npm, registry } = await mockOidc(t, { + oidcOptions: { github: true }, + publish: false, + config: { workspaces: true }, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + idToken: githubPrivateIdToken, + times: 2, + }, + load: { + homeDir: fallback ? { + '.npmrc': `//registry.npmjs.org/:_authToken=${fallbackToken}`, + } : {}, + prefixDir: { + 'package.json': JSON.stringify({ + name: 'workspace-root', + version: '1.0.0', + workspaces: ['workspace-a', 'workspace-b'], + }), + 'workspace-a': { + 'package.json': JSON.stringify({ name: 'workspace-a', version: '1.0.0' }), + }, + 'workspace-b': { + 'package.json': JSON.stringify({ name: 'workspace-b', version: '1.0.0' }), + }, + }, + }, + }) + registry.mockOidcTokenExchange({ + packageName: 'workspace-a', + idToken: githubPrivateIdToken, + body: { token: 'workspace-a-exchange-token' }, + }) + registry.publish('workspace-a', { token: 'workspace-a-exchange-token' }) + registry.mockOidcTokenExchange({ + packageName: 'workspace-b', + idToken: githubPrivateIdToken, + statusCode: 404, + body: { message: 'No trusted publisher configured' }, + }) + if (fallback) { + registry.publish('workspace-b', { token: fallbackToken }) + await npm.exec('publish', []) + } else { + await t.rejects(npm.exec('publish', []), { code: 'ENEEDAUTH' }) + } + t.equal( + npm.config.getCredentialsByURI('https://registry.npmjs.org/').token, + fallback ? fallbackToken : undefined + ) + }) + } + + t.test('sequential operations clear OIDC tokens after exchange failure', async t => { + // These calls share one npm instance, unlike separate CLI invocations. + // The workspace tests above cover one real --workspaces command; this also checks recovery. + const packages = ['workflow-one', 'workflow-two', 'workflow-three'] + const registryUrl = 'https://registry.npmjs.org/' + const authTokenKey = '//registry.npmjs.org/:_authToken' + const { npm, registry, joinedOutput } = await mockOidc(t, { + oidcOptions: { github: true }, + publish: false, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + idToken: githubPrivateIdToken, + times: 3, + }, + load: { + prefixDir: { + 'package.json': JSON.stringify({ name: 'workflow-root', version: '1.0.0' }), + ...Object.fromEntries(packages.map(name => [name, { + 'package.json': JSON.stringify({ name, version: '1.0.0' }), + }])), + }, + }, + }) + t.equal(npm.config.getCredentialsByURI(registryUrl).token, undefined, 'no fallback token') + + registry.mockOidcTokenExchange({ + packageName: packages[0], + idToken: githubPrivateIdToken, + body: { token: 'first-exchange-token' }, + }) + registry.publish(packages[0], { token: 'first-exchange-token' }) + await npm.exec('publish', [`./${packages[0]}`]) + t.equal(npm.flatOptions[authTokenKey], 'first-exchange-token') + t.match(joinedOutput(), '+ workflow-one@1.0.0') + + registry.mockOidcTokenExchange({ + packageName: packages[1], + idToken: githubPrivateIdToken, + statusCode: 404, + body: { message: 'No trusted publisher configured' }, + }) + await t.rejects( + npm.exec('publish', [`./${packages[1]}`]), + { code: 'ENEEDAUTH' }, + 'failed exchange cannot reuse the previous operation token' + ) + t.equal(npm.config.getCredentialsByURI(registryUrl).token, undefined, 'token is cleared') + t.notOk(Object.hasOwn(npm.flatOptions, authTokenKey), 'flat options contain no stale token') + t.notMatch(joinedOutput(), '+ workflow-two@1.0.0') + + registry.mockOidcTokenExchange({ + packageName: packages[2], + idToken: githubPrivateIdToken, + body: { token: 'third-exchange-token' }, + }) + registry.publish(packages[2], { token: 'third-exchange-token' }) + await npm.exec('publish', [`./${packages[2]}`]) + t.equal(npm.flatOptions[authTokenKey], 'third-exchange-token') + t.match(joinedOutput(), '+ workflow-three@1.0.0') + }) + t.test('dry-run can be used to check oidc config but not publish', oidcPublishTest({ oidcOptions: { github: true }, config: { diff --git a/deps/npm/test/lib/commands/stage/index.js b/deps/npm/test/lib/commands/stage/index.js index bd81c7aab5e..127c0ea8252 100644 --- a/deps/npm/test/lib/commands/stage/index.js +++ b/deps/npm/test/lib/commands/stage/index.js @@ -3,6 +3,7 @@ const { load: loadMockNpm } = require('../../../fixtures/mock-npm') const MockRegistry = require('@npmcli/mock-registry') const path = require('node:path') const fs = require('node:fs') +const { githubIdToken, mockOidc } = require('../../../fixtures/mock-oidc') const pkg = '@npmcli/test-package' const token = 'test-auth-token' @@ -31,6 +32,32 @@ t.test('stages a package from cwd', async t => { t.match(joinedOutput(), /\+ @npmcli\/test-package@1\.0\.0 \(staged\)/) }) +t.test('stages a package with the OIDC exchange token', async t => { + const idToken = githubIdToken({ visibility: 'private' }) + const exchangeToken = 'exchange-token' + const { npm, registry } = await mockOidc(t, { + packageName: pkg, + oidcOptions: { github: true }, + mockGithubOidcOptions: { + audience: 'npm:registry.npmjs.org', + idToken, + }, + mockOidcTokenExchangeOptions: { + idToken, + body: { token: exchangeToken }, + }, + publishOptions: { + noPut: true, + }, + }) + + registry.nock.post('/-/stage/package/@npmcli%2ftest-package') + .matchHeader('authorization', `Bearer ${exchangeToken}`) + .reply(201, {}) + + await npm.exec('stage', ['publish']) +}) + t.test('stages with --dry-run', async t => { const { npm, joinedOutput, logs } = await loadMockNpm(t, { config: { ...authConfig, 'dry-run': true }, diff --git a/deps/npm/test/lib/utils/oidc.js b/deps/npm/test/lib/utils/oidc.js new file mode 100644 index 00000000000..72f77261266 --- /dev/null +++ b/deps/npm/test/lib/utils/oidc.js @@ -0,0 +1,239 @@ +const t = require('tap') +const { readFile } = require('node:fs/promises') +const { join } = require('node:path') +const mockGlobals = require('@npmcli/mock-globals') +const mockNpm = require('../../fixtures/mock-npm') +const tmock = require('../../fixtures/tmock') + +const registry = 'https://registry.npmjs.org/' +const authTokenKey = '//registry.npmjs.org/:_authToken' +const fallbackToken = 'fallback-token' +const exchangeToken = 'exchange-token' + +const setup = async t => { + const { npm } = await mockNpm(t, { + config: ({ globalPrefix, home, prefix }) => ({ + globalconfig: join(globalPrefix, 'etc', 'npmrc'), + prefix, + userconfig: join(home, '.npmrc'), + }), + globals: ({ globalPrefix, home, prefix }) => ({ + 'process.env.NPM_CONFIG_GLOBALCONFIG': join(globalPrefix, 'etc', 'npmrc'), + 'process.env.NPM_CONFIG_PREFIX': prefix, + 'process.env.NPM_CONFIG_USERCONFIG': join(home, '.npmrc'), + }), + npm: ({ other }) => ({ + npmRoot: join(other, 'node'), + }), + otherDirs: { + node: { npmrc: '' }, + }, + }) + mockGlobals(t, { + 'process.env.NPM_ID_TOKEN': 'identity-token', + 'process.env.ACTIONS_ID_TOKEN_REQUEST_URL': 'https://github.com/actions/id-token', + 'process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN': 'request-token', + }) + const ci = { GITLAB: true } + const responses = [{ token: exchangeToken }] + const { oidc } = tmock(t, '{LIB}/utils/oidc.js', { + 'ci-info': ci, + 'npm-registry-fetch': { + json: async (_url, opts) => { + const response = responses.shift() + if (response instanceof Error) { + throw response + } + if (typeof response === 'function') { + return response(opts) + } + return response + }, + }, + 'make-fetch-happen': async () => ({ + ok: false, + status: 500, + json: async () => ({}), + }), + }) + const run = async (opts = { ...npm.flatOptions }, registryUrl = registry) => { + await oidc({ packageName: 'test-package', registry: registryUrl, opts, config: npm.config }) + return opts + } + return { npm, ci, responses, run, oidc } +} + +for (const failure of [ + 'exchange failure', + 'missing exchange token', + 'missing identity token', + 'unsupported CI', + 'missing GitHub permissions', + 'GitHub identity request failure', +]) { + t.test(`restores credentials before ${failure}`, async t => { + const { npm, ci, responses, run } = await setup(t) + npm.config.set(authTokenKey, fallbackToken, 'user') + const firstOpts = await run() + t.equal(firstOpts[authTokenKey], exchangeToken) + t.equal(npm.config.get(authTokenKey), exchangeToken) + t.equal(npm.config.get(authTokenKey, 'cli'), exchangeToken) + t.equal(npm.config.get(authTokenKey, 'user'), fallbackToken, 'user config is never overwritten') + + if (failure === 'exchange failure') { + responses.push(new Error('exchange failed')) + } else if (failure === 'missing exchange token') { + responses.push({}) + } else if (failure === 'unsupported CI') { + ci.GITLAB = false + } else { + delete process.env.NPM_ID_TOKEN + if (failure !== 'missing identity token') { + ci.GITLAB = false + ci.GITHUB_ACTIONS = true + if (failure === 'missing GitHub permissions') { + delete process.env.ACTIONS_ID_TOKEN_REQUEST_URL + } + } + } + + const nextOpts = await run() + t.equal(nextOpts[authTokenKey], fallbackToken, 'next request uses fallback credentials') + t.equal(firstOpts[authTokenKey], fallbackToken, 'previous options no longer contain the token') + t.equal(npm.config.get(authTokenKey, 'cli'), undefined, 'clears the runtime override') + t.equal(npm.config.get(authTokenKey, 'user'), fallbackToken, 'preserves user config') + t.equal(npm.flatOptions[authTokenKey], fallbackToken, 'restores flattened config') + }) +} + +for (const source of ['user', 'global', 'project', 'env', 'cli', 'none']) { + t.test(`preserves ${source} credentials when reusing flat options`, async t => { + const { npm, responses, run } = await setup(t) + if (source !== 'none') { + npm.config.set(authTokenKey, fallbackToken, source) + } + const opts = npm.flatOptions + await run(opts) + t.equal(npm.config.getCredentialsByURI(registry).token, exchangeToken) + // Populate the flat-options cache with the temporary runtime token. + const nextOpts = npm.flatOptions + responses.push({}) + await run(opts) + + const expected = source === 'none' ? undefined : fallbackToken + t.equal(opts[authTokenKey], expected) + t.equal(npm.config.get(authTokenKey), expected) + t.equal(npm.flatOptions[authTokenKey], expected) + t.equal(npm.config.get(authTokenKey, 'user'), source === 'user' ? fallbackToken : undefined) + t.not(npm.flatOptions, nextOpts, 'invalidates the cached temporary credentials') + if (source === 'none') { + t.notOk(Object.hasOwn(opts, authTokenKey), 'removes the temporary option entirely') + } + }) +} + +t.test('does not restore an earlier exchange token after multiple successes', async t => { + const { npm, responses, run } = await setup(t) + npm.config.set(authTokenKey, fallbackToken, 'user') + await run() + responses.push({ token: 'second-exchange-token' }) + const secondOpts = await run() + t.equal(secondOpts[authTokenKey], 'second-exchange-token') + responses.push({}) + const thirdOpts = await run() + t.equal(thirdOpts[authTokenKey], fallbackToken) + t.equal(npm.config.get(authTokenKey), fallbackToken) +}) + +t.test('clears the previous token before starting another exchange', async t => { + const { npm, responses, run } = await setup(t) + npm.config.set(authTokenKey, fallbackToken, 'user') + const firstOpts = await run() + responses.push(opts => { + t.equal(npm.config.get(authTokenKey), fallbackToken, 'old token is already cleared') + t.equal(firstOpts[authTokenKey], fallbackToken, 'old request options are already cleared') + t.equal(opts[authTokenKey], 'identity-token', 'exchange uses the identity token') + return { token: 'new-exchange-token' } + }) + const nextOpts = await run() + t.equal(nextOpts[authTokenKey], 'new-exchange-token') + t.equal(npm.config.get(authTokenKey), 'new-exchange-token') +}) + +t.test('clears the previous registry token when switching registries', async t => { + const { npm, responses, run } = await setup(t) + const otherRegistry = 'https://other.registry.npmjs.org/' + const otherKey = '//other.registry.npmjs.org/:_authToken' + npm.config.set(authTokenKey, fallbackToken, 'user') + npm.config.set(otherKey, 'other-fallback', 'user') + await run() + responses.push({ token: 'other-exchange-token' }) + const otherOpts = await run(undefined, otherRegistry) + t.equal(otherOpts[authTokenKey], fallbackToken) + t.equal(otherOpts[otherKey], 'other-exchange-token') + responses.push({}) + const nextOpts = await run() + t.equal(nextOpts[authTokenKey], fallbackToken) + t.equal(nextOpts[otherKey], 'other-fallback') + t.equal(npm.config.get(otherKey), 'other-fallback') +}) + +t.test('preserves credentials explicitly replaced after an exchange', async t => { + const { npm, responses, run } = await setup(t) + const opts = await run() + npm.config.set(authTokenKey, 'updated-user-token', 'user') + opts[authTokenKey] = 'updated-request-token' + responses.push({}) + await run(opts) + t.equal(npm.config.get(authTokenKey), 'updated-user-token') + t.equal(opts[authTokenKey], 'updated-request-token') +}) + +t.test('preserves a runtime credential replaced independently of OIDC', async t => { + const { npm, responses, run } = await setup(t) + await run() + npm.config.set(authTokenKey, 'updated-runtime-token', 'cli') + responses.push({}) + const opts = await run() + t.equal(npm.config.get(authTokenKey, 'cli'), 'updated-runtime-token') + t.equal(opts[authTokenKey], 'updated-runtime-token') +}) + +t.test('saving config during an exchange never persists the OIDC token', async t => { + const { npm, run } = await setup(t) + const sources = ['user', 'project', 'global'] + for (const source of sources) { + npm.config.set(authTokenKey, `${source}-fallback`, source) + } + await run() + t.equal(npm.config.get(authTokenKey, 'cli'), exchangeToken) + await t.rejects(npm.config.save('cli'), { message: 'invalid config location param: cli' }) + for (const source of sources) { + t.equal(npm.config.get(authTokenKey, source), `${source}-fallback`) + await npm.config.save(source) + const content = await readFile(npm.config.data.get(source).source, 'utf8') + t.match(content, `${authTokenKey}=${source}-fallback`) + t.notMatch(content, exchangeToken) + } +}) + +t.test('the next invocation clears the token even with a different config', async t => { + const { npm, ci, run, oidc } = await setup(t) + npm.config.set(authTokenKey, fallbackToken, 'user') + const opts = await run() + ci.GITLAB = false + await oidc({ packageName: 'other-package', registry, opts: {}, config: {} }) + t.equal(npm.config.get(authTokenKey, 'cli'), undefined) + t.equal(npm.config.get(authTokenKey), fallbackToken) + t.equal(opts[authTokenKey], fallbackToken) +}) + +t.test('does not copy package-specific fallback options into the next package', async t => { + const { npm, responses, run } = await setup(t) + npm.config.set(authTokenKey, fallbackToken, 'user') + const firstOpts = await run({ ...npm.flatOptions, [authTokenKey]: 'package-specific-token' }) + responses.push({}) + const nextOpts = await run() + t.equal(firstOpts[authTokenKey], 'package-specific-token') + t.equal(nextOpts[authTokenKey], fallbackToken) +}) From 5baf2e0d69c652fb81e995d27d75133e7b4eaba9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dominik=20Inf=C3=BChr?= Date: Mon, 12 Oct 2026 15:13:31 +0200 Subject: [PATCH 272/331] deps: V8: cherry-pick 497c2e6a2434 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Original commit message: [heap] Always decrement age in RetainMaps() When the prototype and constructor were already marked we did not age the map because of the assumption that this would only keep the transition tree alive. However, this does not hold because of the JSFunctions inside an AccessorPair in DescriptorArray. This can result in retaining maps indefinitely when not triggering memory reducing GCs. This CL therefore simplifies the code to always age maps instead. This is neutral on Speedometer and Jetstream. Bug: 571157135 Change-Id: I8fb633a0ec0c1d66e4596390ca48e1c7006c9cc2 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8557820 Commit-Queue: Dominik Inführ Reviewed-by: Michael Lippautz Cr-Commit-Position: refs/heads/main@{#110622} Refs: https://github.com/v8/v8/commit/497c2e6a2434af02b44417b55b1576702922f5e9 PR-URL: https://github.com/nodejs/node/pull/66728 Reviewed-by: Antoine du Hamel --- common.gypi | 2 +- deps/v8/src/heap/mark-compact.cc | 12 +----------- 2 files changed, 2 insertions(+), 12 deletions(-) diff --git a/common.gypi b/common.gypi index 2967d1e63a4..d48884868e1 100644 --- a/common.gypi +++ b/common.gypi @@ -44,7 +44,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.40', + 'v8_embedder_string': '-node.41', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/heap/mark-compact.cc b/deps/v8/src/heap/mark-compact.cc index 90bf197a8c7..adf8f97f3b5 100644 --- a/deps/v8/src/heap/mark-compact.cc +++ b/deps/v8/src/heap/mark-compact.cc @@ -2536,17 +2536,7 @@ void MarkCompactCollector::RetainMaps() { MarkingHelper::WorklistTarget::kRegular, map); } } - Tagged prototype = map->prototype(); - if (age > 0 && IsHeapObject(prototype) && - MarkingHelper::IsUnmarkedAndNotAlwaysLive( - heap_, marking_state_, Cast(prototype))) { - // The prototype is not marked, age the map. - new_age = age - 1; - } else { - // The prototype and the constructor are marked, this map keeps only - // transition tree alive, not JSObjects. Do not age the map. - new_age = age; - } + new_age = age > 0 ? age - 1 : 0; } else { new_age = v8_flags.retain_maps_for_n_gc; } From 7c7371d039ade53881733ce672d1ae58dba04574 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Olivier=20Fl=C3=BCckiger?= Date: Fri, 10 Jul 2026 09:02:35 +0000 Subject: [PATCH 273/331] deps: V8: cherry-pick c21a93ec80d5 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Original commit message: [sandbox] Fix JSDispatchTable entry mark-bit erasure A race condition exists in V8's concurrent marking and deoptimization logic where Code::SetMarkedForDeoptimization updates a dispatch table entry without running a write barrier. During concurrent marking, a background thread's CAS mark can be overwritten by the mutator's blind store, leading to a live entry being swept. Fixed: 525686865 Change-Id: I0cebd44b62ad5c16c19d73e5586058b1d2265ee4 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8074259 Commit-Queue: Olivier Flückiger Reviewed-by: Dominik Inführ Auto-Submit: Olivier Flückiger Cr-Commit-Position: refs/heads/main@{#108583} Refs: https://github.com/v8/v8/commit/c21a93ec80d526fd270b119a2e8b7e26623d1b3b PR-URL: https://github.com/nodejs/node/pull/66729 Fixes: https://github.com/nodejs/node/issues/66661 Reviewed-by: Antoine du Hamel --- common.gypi | 2 +- deps/v8/src/objects/code.cc | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/common.gypi b/common.gypi index d48884868e1..2f092e215de 100644 --- a/common.gypi +++ b/common.gypi @@ -44,7 +44,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.41', + 'v8_embedder_string': '-node.42', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/objects/code.cc b/deps/v8/src/objects/code.cc index ddc928254e8..a035b69aeb5 100644 --- a/deps/v8/src/objects/code.cc +++ b/deps/v8/src/objects/code.cc @@ -226,6 +226,10 @@ void Code::SetMarkedForDeoptimization(Isolate* isolate, } else { jdt.SetCodeNoWriteBarrier(handle, *BUILTIN_CODE(isolate, CompileLazy)); } + // TODO(olivf, 525686865): Fix the race in dispatch handle marking by + // going back to a CAS loop. + static_assert(JSDispatchTable::kWriteBarrierSetsEntryMarkBit); + jdt.Mark(handle); } // Ensure we don't try to patch the entry multiple times. set_js_dispatch_handle(kNullJSDispatchHandle); From 190faa493242ffc6f6cb65c2c86d29b283fd2582 Mon Sep 17 00:00:00 2001 From: Milad Fa Date: Wed, 10 Jun 2026 15:11:23 +0000 Subject: [PATCH 274/331] deps: V8: cherry-pick f331137d5968 Original commit message: PPC: Fix safepoint record This patch is needed after http://crrev.com/c/7899697 started failing this test intermittently during GC on pntr compressed debug builds: ``` === mjsunit/compiler/regress-crbug-1464516 === --- stderr --- # # Fatal error in ../../src/objects/tagged-impl.h, line 138 # Debug check failed: kCanBeWeak || (!IsSmi() == HAS_STRONG_HEAP_OBJECT_TAG(ptr_)). ``` PPC could emit a trampoline pool right after `MacroAssembler::Call` returns which could make any subsequent `DefineSafepoint` calls record the incorrect `pc_offset` as it then points to after the emitted pool. This CL patches every "MacroAssembler::Call" site to record the pc_offset before the trampoline pool is emitted similar to how it's done on riscv. It's essentially porting the following changes to PPC: f385232a87a46af77c97e9095c8a25e559c37ce7 2c6618f2d927a91dd54727abf096828521f7439f Change-Id: I2095bce8b69b0c4f064117ed95ee2f3245436e62 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/7918866 Reviewed-by: Darius Mercadier Reviewed-by: John Commit-Queue: Milad Farazmand Cr-Commit-Position: refs/heads/main@{#107921} Refs: https://github.com/v8/v8/commit/f331137d5968b4665485eb20de618093a8b17d82 PR-URL: https://github.com/nodejs/node/pull/67261 Reviewed-By: Richard Lau --- common.gypi | 2 +- deps/v8/src/codegen/assembler.h | 11 ++++++----- deps/v8/src/codegen/ppc/assembler-ppc.h | 14 ++++++++++++++ deps/v8/src/codegen/ppc/macro-assembler-ppc.cc | 7 ++++++- 4 files changed, 27 insertions(+), 7 deletions(-) diff --git a/common.gypi b/common.gypi index 2f092e215de..5b73c404fee 100644 --- a/common.gypi +++ b/common.gypi @@ -44,7 +44,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.42', + 'v8_embedder_string': '-node.43', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/codegen/assembler.h b/deps/v8/src/codegen/assembler.h index 834ed253ad3..7800d4eaa94 100644 --- a/deps/v8/src/codegen/assembler.h +++ b/deps/v8/src/codegen/assembler.h @@ -389,11 +389,12 @@ class V8_EXPORT_PRIVATE AssemblerBase : public Malloced { void skip_bytes(int num_bytes) { pc_ += num_bytes; } -// MIPS, LOONG, and RISC-V need to use their own implementations to avoid the -// influence of branch trampolines. They provide their implementations in the -// architecture-specific assembler subclasses. -#if !defined(V8_TARGET_ARCH_MIPS64) && !defined(V8_TARGET_ARCH_LOONG64) && \ - !defined(V8_TARGET_ARCH_RISCV32) && !defined(V8_TARGET_ARCH_RISCV64) +// MIPS, LOONG, RISC-V, and PPC64 need to use their own implementations to avoid +// the influence of branch trampolines. They provide their implementations in +// the architecture-specific assembler subclasses. +#if !defined(V8_TARGET_ARCH_MIPS64) && !defined(V8_TARGET_ARCH_LOONG64) && \ + !defined(V8_TARGET_ARCH_RISCV32) && !defined(V8_TARGET_ARCH_RISCV64) && \ + !defined(V8_TARGET_ARCH_PPC64) int pc_offset_for_safepoint() const { return pc_offset(); } #endif diff --git a/deps/v8/src/codegen/ppc/assembler-ppc.h b/deps/v8/src/codegen/ppc/assembler-ppc.h index a6db5191663..132fd205e8a 100644 --- a/deps/v8/src/codegen/ppc/assembler-ppc.h +++ b/deps/v8/src/codegen/ppc/assembler-ppc.h @@ -205,6 +205,13 @@ class Assembler : public AssemblerBase { // Unused on this architecture. void ClearInternalState() {} + // On PPC64, we sometimes need to emit branch trampolines between emitting + // a call instruction (bctrl) and recording a safepoint. This means that + // we have to be careful to make sure the safepoint is recorded at the right + // position. So we record the pc right after emitting the call instruction + // and use this for the safepoint. + int pc_offset_for_safepoint() const { return pc_offset_for_safepoint_; } + inline void CheckTrampolinePoolQuick(int extra_space = 0) { if (pc_offset() >= next_trampoline_check_ - extra_space) { CheckTrampolinePool(); @@ -1364,6 +1371,8 @@ class Assembler : public AssemblerBase { // Record reloc info for current pc_ void RecordRelocInfo(RelocInfo::Mode rmode, intptr_t data = 0); + + void RecordPcForSafepoint() { pc_offset_for_safepoint_ = pc_offset(); } ConstantPoolEntry::Access ConstantPoolAddEntry(RelocInfo::Mode rmode, intptr_t value) { bool sharing_ok = @@ -1445,6 +1454,11 @@ class Assembler : public AssemblerBase { // The bound position, before this we cannot do instruction elimination. int last_bound_pos_; + + // Keep track of the last call instruction (bctrl/bl) position to ensure that + // we can generate a correct safepoint even in the presence of a branch + // trampoline between emitting the call and recording the safepoint. + int pc_offset_for_safepoint_ = -1; // Optimizable cmpi information. int optimizable_cmpi_pos_; CRegister cmpi_cr_ = CRegister::no_reg(); diff --git a/deps/v8/src/codegen/ppc/macro-assembler-ppc.cc b/deps/v8/src/codegen/ppc/macro-assembler-ppc.cc index a36c153d895..7ddc07f51da 100644 --- a/deps/v8/src/codegen/ppc/macro-assembler-ppc.cc +++ b/deps/v8/src/codegen/ppc/macro-assembler-ppc.cc @@ -257,6 +257,7 @@ void MacroAssembler::Call(Register target) { // branch via link register and set LK bit for return point mtctr(target); bctrl(); + RecordPcForSafepoint(); } void MacroAssembler::CallJSEntry(Register target) { @@ -284,6 +285,7 @@ void MacroAssembler::Call(Address target, RelocInfo::Mode rmode, mov(ip, Operand(target, rmode)); mtctr(ip); bctrl(); + RecordPcForSafepoint(); } void MacroAssembler::Call(Handle code, RelocInfo::Mode rmode, @@ -417,7 +419,10 @@ Operand MacroAssembler::ClearedValue() const { return Operand(static_cast(i::kClearedWeakValue.ptr())); } -void MacroAssembler::Call(Label* target) { b(target, SetLK); } +void MacroAssembler::Call(Label* target) { + b(target, SetLK); + RecordPcForSafepoint(); +} void MacroAssembler::Push(Handle handle) { mov(r0, Operand(handle)); From bca95eb33103e11de053a45e5f32fdbcc1530b7a Mon Sep 17 00:00:00 2001 From: pthier Date: Thu, 7 May 2026 10:35:51 +0200 Subject: [PATCH 275/331] deps: V8: backport e540e1161b02 Original commit message: [regexp] Fix modifiers for ChoiceNodes during Analysis During the analysis pass we didn't reset flags after visiting alternatives of a ChoiceNode, which is required as the sub-graph of an alternative might modify the flags. Fixed: 510487690 Change-Id: I6b2660a98b34cd12740538af4ce61685609934a0 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/7826630 Commit-Queue: Patrick Thier Auto-Submit: Patrick Thier Reviewed-by: Jakob Linke Commit-Queue: Jakob Linke Cr-Commit-Position: refs/heads/main@{#107120} Refs: https://github.com/v8/v8/commit/e540e1161b0217ada6d59c8bc5a3a42fd3e27f40 Refs: https://github.com/nodejs/node/issues/66277 PR-URL: https://github.com/nodejs/node/pull/67207 Reviewed-by: Antoine du Hamel --- common.gypi | 2 +- deps/v8/src/regexp/regexp-compiler.cc | 5 +++++ deps/v8/test/mjsunit/regress/regress-510487690.js | 5 +++++ 3 files changed, 11 insertions(+), 1 deletion(-) create mode 100644 deps/v8/test/mjsunit/regress/regress-510487690.js diff --git a/common.gypi b/common.gypi index 5b73c404fee..f09d8601955 100644 --- a/common.gypi +++ b/common.gypi @@ -44,7 +44,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.43', + 'v8_embedder_string': '-node.44', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/regexp/regexp-compiler.cc b/deps/v8/src/regexp/regexp-compiler.cc index a3e7c170d43..eb13b95d5cf 100644 --- a/deps/v8/src/regexp/regexp-compiler.cc +++ b/deps/v8/src/regexp/regexp-compiler.cc @@ -3841,8 +3841,13 @@ class Analysis : public NodeVisitor { } void VisitChoice(ChoiceNode* that) override { + // Flags need to be reset to the state of the ChoiceNode at the beginning + // of each alternative, as flags might be modified when visiting an + // alternative. + RegExpFlags header_flags = flags(); for (int i = 0; i < that->alternatives()->length(); i++) { EnsureAnalyzed(that->alternatives()->at(i).node()); + set_flags(header_flags); if (has_failed()) return; STATIC_FOR_EACH(Propagators::VisitChoice(that, i)); } diff --git a/deps/v8/test/mjsunit/regress/regress-510487690.js b/deps/v8/test/mjsunit/regress/regress-510487690.js new file mode 100644 index 00000000000..856fb25b272 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-510487690.js @@ -0,0 +1,5 @@ +// Copyright 2026 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +assertTrue(/(?i:x|[a-f])/.test("F")); From c54a21b132218bd372179db64fb4538fcb62036a Mon Sep 17 00:00:00 2001 From: pthier Date: Tue, 16 Jun 2026 11:58:46 +0200 Subject: [PATCH 276/331] deps: V8: cherry-pick 19e7a57bce3e Original commit message: [regexp] Reset flags after resetting state in Parser When restoring the previous state after parsing a closing parenthesis we also need to restore flags explicitly from the restored state. Fixed: 523687962 Change-Id: I63a5bd9fec2f9b7f6fb43b6893027c3c3d0755f0 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/7950157 Auto-Submit: Patrick Thier Commit-Queue: Jakob Linke Reviewed-by: Jakob Linke Cr-Commit-Position: refs/heads/main@{#108021} Refs: https://github.com/v8/v8/commit/19e7a57bce3eaae13cfc4f9ddfaaaa2c0fcca78e Refs: https://github.com/nodejs/node/issues/66277 PR-URL: https://github.com/nodejs/node/pull/67207 Reviewed-by: Antoine du Hamel --- common.gypi | 2 +- deps/v8/src/regexp/regexp-parser.cc | 1 + deps/v8/test/mjsunit/regexp-modifiers.js | 2 ++ 3 files changed, 4 insertions(+), 1 deletion(-) diff --git a/common.gypi b/common.gypi index f09d8601955..e208978fabb 100644 --- a/common.gypi +++ b/common.gypi @@ -44,7 +44,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.44', + 'v8_embedder_string': '-node.45', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/regexp/regexp-parser.cc b/deps/v8/src/regexp/regexp-parser.cc index 2792cd0f1e9..0c9bbad8497 100644 --- a/deps/v8/src/regexp/regexp-parser.cc +++ b/deps/v8/src/regexp/regexp-parser.cc @@ -988,6 +988,7 @@ RegExpTree* RegExpParserImpl::ParseDisjunction() { // Restore previous state. state = state->previous_state(); builder = state->builder(); + flags_ = builder->flags(); builder->AddAtom(body); // For compatibility with JSC and ES3, we allow quantifiers after diff --git a/deps/v8/test/mjsunit/regexp-modifiers.js b/deps/v8/test/mjsunit/regexp-modifiers.js index e012dc8d406..50c891c8ac8 100644 --- a/deps/v8/test/mjsunit/regexp-modifiers.js +++ b/deps/v8/test/mjsunit/regexp-modifiers.js @@ -73,3 +73,5 @@ test( /(?m:^f(?si:.o)$)/, ['foo', '\nfoO', 'f\no\n', '\nf\rO\n'], ['Foo', 'F\no\n']); test(/(?i:.oo)/, ['Foo', 'FOO', 'fOo', 'foO']); + +test(/(?i:foo)[x-z]/v, ['Foox', 'fOoz'], ['fooX','FooZ']); From 9adc368ed3ed375e00f2df1873fe7cd85e9eadab Mon Sep 17 00:00:00 2001 From: Jakob Linke Date: Thu, 6 Aug 2026 12:51:51 +0200 Subject: [PATCH 277/331] deps: V8: backport b69a1a1d8613 Original commit message: [regexp] Record flags on deferred worklist items ActionNode::Emit for MODIFY_FLAGS was previously changed to restore outer_flags on the way out to avoid leaking inner flags to trailing deferred nodes. However, this caused nodes deferred from within the modifier group to be compiled with the outer flags when processed by Compiler::Assemble. Instead of restoring flags in ActionNode::Emit, record the active flags at the point where a node is deferred in Compiler::AddWork, and restore them from the work-list item before emitting it. This partially reverts https://chromium-review.googlesource.com/c/v8/v8/+/8174589. Change-Id: I3a552f9223b88ba99889e4375b8d1ea761257b94 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8213283 Reviewed-by: Patrick Thier Auto-Submit: Jakob Linke Commit-Queue: Patrick Thier Cr-Commit-Position: refs/heads/main@{#109102} Refs: https://github.com/v8/v8/commit/b69a1a1d8613472f7a3f174060356687ba4255fa Co-authored-by: Radu Samson Refs: https://github.com/nodejs/node/issues/66277 PR-URL: https://github.com/nodejs/node/pull/67207 Reviewed-by: Antoine du Hamel --- common.gypi | 2 +- deps/v8/src/regexp/regexp-compiler.cc | 6 ++++-- deps/v8/src/regexp/regexp-compiler.h | 9 +++++++-- deps/v8/test/mjsunit/regexp-modifiers.js | 14 ++++++++++++++ 4 files changed, 26 insertions(+), 5 deletions(-) diff --git a/common.gypi b/common.gypi index e208978fabb..03233fedb64 100644 --- a/common.gypi +++ b/common.gypi @@ -44,7 +44,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.45', + 'v8_embedder_string': '-node.46', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/regexp/regexp-compiler.cc b/deps/v8/src/regexp/regexp-compiler.cc index eb13b95d5cf..23027f93012 100644 --- a/deps/v8/src/regexp/regexp-compiler.cc +++ b/deps/v8/src/regexp/regexp-compiler.cc @@ -346,7 +346,7 @@ RegExpCompiler::CompilationResult RegExpCompiler::Assemble( return CompilationResult::RegExpTooBig(); }; - ZoneVector work_list(zone()); + ZoneVector work_list(zone()); work_list_ = &work_list; Label fail; macro_assembler_->PushBacktrack(&fail); @@ -357,11 +357,13 @@ RegExpCompiler::CompilationResult RegExpCompiler::Assemble( macro_assembler_->BindJumpTarget(&fail); macro_assembler_->Fail(); while (!work_list.empty()) { - RegExpNode* node = work_list.back(); + WorkItem item = work_list.back(); + RegExpNode* node = item.node; TRACE_WITH_NODE(this, "Popping from worklist ", node); work_list.pop_back(); node->set_on_work_list(false); if (!node->label()->is_bound()) { + set_flags(item.flags); if (node->Emit(this, &new_trace).IsError()) { return ReportError(); } diff --git a/deps/v8/src/regexp/regexp-compiler.h b/deps/v8/src/regexp/regexp-compiler.h index 6e5a8dcb66e..d90bf720da0 100644 --- a/deps/v8/src/regexp/regexp-compiler.h +++ b/deps/v8/src/regexp/regexp-compiler.h @@ -570,10 +570,15 @@ class RegExpCompiler { // lead surrogate and start matching from there. RegExpNode* OptionallyStepBackToLeadSurrogate(RegExpNode* on_success); + struct WorkItem { + RegExpNode* node; + RegExpFlags flags; + }; + inline void AddWork(RegExpNode* node) { if (!node->on_work_list() && !node->label()->is_bound()) { node->set_on_work_list(true); - work_list_->push_back(node); + work_list_->push_back({node, flags()}); } } @@ -644,7 +649,7 @@ class RegExpCompiler { int next_register_; int unicode_lookaround_stack_register_; int unicode_lookaround_position_register_; - ZoneVector* work_list_; + ZoneVector* work_list_; int recursion_depth_; RegExpFlags flags_; RegExpMacroAssembler* macro_assembler_; diff --git a/deps/v8/test/mjsunit/regexp-modifiers.js b/deps/v8/test/mjsunit/regexp-modifiers.js index 50c891c8ac8..72bf8840871 100644 --- a/deps/v8/test/mjsunit/regexp-modifiers.js +++ b/deps/v8/test/mjsunit/regexp-modifiers.js @@ -75,3 +75,17 @@ test( test(/(?i:.oo)/, ['Foo', 'FOO', 'fOo', 'foO']); test(/(?i:foo)[x-z]/v, ['Foox', 'fOoz'], ['fooX','FooZ']); + +// Nodes inside a modifier group deferred to the work list must be compiled with +// the group's inner flags, not the outer flags. +test( + /^(?i:(?:a|b)(?:c|d)(?:e|f)(?:g|h)(?:i|j)(?:k|l)(?:m|n)X)/, + ['acegikmx', 'acegikmX', 'bdfhjlnx', 'bdfhjlnX'], + ['acegikmy', 'bdfhjlny']); + +// Symmetrically, nodes inside a (?-i:...) group under outer /i must compile +// case-sensitively even when deferred. +test( + /^(?-i:(?:a|b)(?:c|d)(?:e|f)(?:g|h)(?:i|j)(?:k|l)(?:m|n)x)/i, + ['acegikmx', 'bdfhjlnx'], + ['acegikmX', 'bdfhjlnX']); From 42e3a14f1f821a28a89551bf49d16d883b3b312a Mon Sep 17 00:00:00 2001 From: pthier Date: Thu, 13 Aug 2026 13:28:09 +0200 Subject: [PATCH 278/331] deps: V8: backport d315af3d83cf Original commit message: [regexp] Reset compiler flags between word boundary branches When compiling \b and \B word boundary checks in AssertionNode where the succeeding character type is unknown, two code paths (before_non_word and before_word) are generated sequentially. If the boundary assertion is placed inside a modifier group (e.g. (?i:\.|\bNULL)), emitting the first branch traverses through on_success and reaches the ActionNode that restores outer flags at group exit. This mutates flags without restoring it when returning to emit the second branch. Consequently, subsequent nodes in the second branch (before_word) were incorrectly compiled with outer flags instead of the modifier group's flags. This CL saves compiler->flags() and restores them before emitting the before_word branch in AssertionNode::EmitBoundaryCheck. TAG=agy Fixed: 544575761 Change-Id: I7f08bcb99c749d5e22636c8bd6eb44bd1d3e2e39 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8257209 Reviewed-by: Victor Gomes Commit-Queue: Patrick Thier Cr-Commit-Position: refs/heads/main@{#109236} Refs: https://github.com/v8/v8/commit/d315af3d83cfe3bc1709f5b140db393db42790b3 Refs: https://github.com/nodejs/node/issues/66277 PR-URL: https://github.com/nodejs/node/pull/67207 Reviewed-by: Antoine du Hamel --- common.gypi | 2 +- deps/v8/src/regexp/regexp-compiler.cc | 2 ++ deps/v8/test/mjsunit/regexp-modifiers.js | 13 +++++++++++++ 3 files changed, 16 insertions(+), 1 deletion(-) diff --git a/common.gypi b/common.gypi index 03233fedb64..214edd31cd8 100644 --- a/common.gypi +++ b/common.gypi @@ -44,7 +44,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.46', + 'v8_embedder_string': '-node.47', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/regexp/regexp-compiler.cc b/deps/v8/src/regexp/regexp-compiler.cc index 23027f93012..397361031e5 100644 --- a/deps/v8/src/regexp/regexp-compiler.cc +++ b/deps/v8/src/regexp/regexp-compiler.cc @@ -2134,6 +2134,7 @@ EmitResult AssertionNode::EmitBoundaryCheck(RegExpCompiler* compiler, } bool at_boundary = (assertion_type_ == AssertionNode::AT_BOUNDARY); if (next_is_word_character == Trace::UNKNOWN) { + const RegExpFlags flags = compiler->flags(); Label before_non_word; Label before_word; if (trace->characters_preloaded() != 1) { @@ -2148,6 +2149,7 @@ EmitResult AssertionNode::EmitBoundaryCheck(RegExpCompiler* compiler, at_boundary ? kIsNonWord : kIsWord)); assembler->GoTo(&ok); + compiler->set_flags(flags); assembler->Bind(&before_word); RETURN_IF_ERROR(BacktrackIfPrevious(compiler, trace, at_boundary ? kIsWord : kIsNonWord)); diff --git a/deps/v8/test/mjsunit/regexp-modifiers.js b/deps/v8/test/mjsunit/regexp-modifiers.js index 72bf8840871..a57f266b606 100644 --- a/deps/v8/test/mjsunit/regexp-modifiers.js +++ b/deps/v8/test/mjsunit/regexp-modifiers.js @@ -89,3 +89,16 @@ test( /^(?-i:(?:a|b)(?:c|d)(?:e|f)(?:g|h)(?:i|j)(?:k|l)(?:m|n)x)/i, ['acegikmx', 'bdfhjlnx'], ['acegikmX', 'bdfhjlnX']); + +// Boundary assertions inside modifier groups with alternations must not leak +// flags between branches during code generation. +test(/(?i:\.|\bNULL)/, ['null', 'NULL', 'Null', '.foo'], ['xyz']); +test(/(?i:\bNULL|\.)/, ['null', 'NULL', '.foo'], ['xyz']); +test(/(?i:\.|\BNULL)/, ['xnull', 'xNULL'], ['null', 'xyz']); +test(/(?i:\W|\bNULL)/, ['null', 'NULL', '!'], ['x']); +test(/(?i:!|\?|\bNULL)/, ['null', 'NULL', '!', '?'], ['x']); +test(/(?i:\.|\bnUll)/, ['null', 'NULL']); +test(/(?i:\.|\bnuLl)/, ['null', 'NULL']); +test(/(?i:\.|\bnulL)/, ['null', 'NULL']); +test(/(?-i:(?i:\.|\bNULL))/, ['null', 'NULL', '.foo'], ['xyz']); +test(/(?i:(?-i:\.|\bNULL))/, ['NULL', '.foo'], ['null', 'xyz']); From df1b8db2a292c4bcd019f35f5a46b1e474fdadc6 Mon Sep 17 00:00:00 2001 From: Jakob Linke Date: Mon, 3 Aug 2026 12:23:20 +0200 Subject: [PATCH 279/331] deps: V8: backport 1e7ee91de775 Original commit message: [regexp] Reset flags between negative lookaround branches e540e1161b0 (bug 510487690) reset the analysis-time flags between the alternatives of a ChoiceNode, since an alternative's sub-graph may contain a MODIFY_FLAGS node. NegativeLookaroundChoiceNode has its own visitor and was left out, so a modifier group inside a negative lookaround still leaks its flags into the continuation. /(?!(?i:x|y))[K]/.exec('kz') // "k", should be null The lookaround body is visited first and leaves the group's flags behind; the continuation's class ranges are then made case independent under those flags rather than the pattern's, so [K] picks up 'k'. Only class ranges are affected: TextNode::MakeCaseIndependent materializes the equivalents during analysis, while atoms get their case closure at emission time from the restored flags. A single- alternative body does not reproduce either, since its restore node is emitted last. Change-Id: I4077076b9dbee6acf75918a2c4f7bf7d86cab059 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8175612 Auto-Submit: Jakob Linke Reviewed-by: Patrick Thier Commit-Queue: Patrick Thier Cr-Commit-Position: refs/heads/main@{#109043} Refs: https://github.com/v8/v8/commit/1e7ee91de77500f9905ebbc5bed33c2186b1e871 Co-authored-by: Radu Samson Refs: https://github.com/nodejs/node/issues/66277 PR-URL: https://github.com/nodejs/node/pull/67207 Reviewed-by: Antoine du Hamel --- common.gypi | 2 +- deps/v8/src/regexp/regexp-compiler.cc | 2 ++ deps/v8/test/mjsunit/regexp-modifiers.js | 8 ++++++++ 3 files changed, 11 insertions(+), 1 deletion(-) diff --git a/common.gypi b/common.gypi index 214edd31cd8..03ed837f607 100644 --- a/common.gypi +++ b/common.gypi @@ -44,7 +44,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.47', + 'v8_embedder_string': '-node.48', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/regexp/regexp-compiler.cc b/deps/v8/src/regexp/regexp-compiler.cc index 397361031e5..ba1452be9fc 100644 --- a/deps/v8/src/regexp/regexp-compiler.cc +++ b/deps/v8/src/regexp/regexp-compiler.cc @@ -3889,11 +3889,13 @@ class Analysis : public NodeVisitor { NegativeLookaroundChoiceNode* that) override { DCHECK_EQ(that->alternatives()->length(), 2); // Lookaround and continue. + RegExpFlags header_flags = flags(); EnsureAnalyzed(that->lookaround_node()); if (has_failed()) return; STATIC_FOR_EACH( Propagators::VisitNegativeLookaroundChoiceLookaroundNode(that)); + set_flags(header_flags); EnsureAnalyzed(that->continue_node()); if (has_failed()) return; STATIC_FOR_EACH( diff --git a/deps/v8/test/mjsunit/regexp-modifiers.js b/deps/v8/test/mjsunit/regexp-modifiers.js index a57f266b606..91b1f2364bd 100644 --- a/deps/v8/test/mjsunit/regexp-modifiers.js +++ b/deps/v8/test/mjsunit/regexp-modifiers.js @@ -102,3 +102,11 @@ test(/(?i:\.|\bnuLl)/, ['null', 'NULL']); test(/(?i:\.|\bnulL)/, ['null', 'NULL']); test(/(?-i:(?i:\.|\bNULL))/, ['null', 'NULL', '.foo'], ['xyz']); test(/(?i:(?-i:\.|\bNULL))/, ['NULL', '.foo'], ['null', 'xyz']); + +// A modifier group inside a negative lookaround must not leak its flags into +// the continuation. Analysis visits the two branches of the lookaround choice +// in sequence, so without a reset the continuation's classes are made case +// independent under the group's flags rather than the pattern's. +test(/(?!(?i:x|y))[K]/, ['K'], ['k']); +test(/(? Date: Mon, 7 Sep 2026 13:48:46 +0800 Subject: [PATCH 280/331] deps: V8: backport 8521e2e77535 Original commit message: [riscv]Fix unordered FP comparison and emit at the consumer The lowering for kFloatLessThanOrUnordered and kFloatLessThanOrEqualOrUnordered incorrectly mapped to (LT, true) and (LE, true), respectively. Since ComputeBranchInfo can negate a branch condition after emitting the comparison, complementary conditions must use the same comparison and invert its predicate. The incorrect mappings dropped the negation, breaking NaN semantics. For example, optimized Wasm loops like `do { x += 1.0; } while (!(x > 0.0));` produced wrong results. Fix the mappings: kFloatLessThanOrUnordered now uses negated GE, and kFloatLessThanOrEqualOrUnordered uses negated GT. To prevent this class of bug, also convert kRiscvCmpS and kRiscvCmpD into pseudo-instructions like the integer kRiscvCmp. The actual comparison is now emitted at the single flags consumer (branch, boolean materialization, or select) through the new EmitFPCompare helper, using the consumer's final FlagsCondition. This ensures the predicate and machine condition are resolved consistently. Generated code remains byte-identical. Bug: 557938134 Change-Id: I230e181753c5e9c6e7fbea651e551192a76e4005 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8360836 Reviewed-by: Ji Qiu Auto-Submit: Yahan Lu (LuYahan) Commit-Queue: Ji Qiu Cr-Commit-Position: refs/heads/main@{#109690} Refs: https://github.com/v8/v8/commit/8521e2e77535a5c255d15ff8deb459fc7260c54d Co-authored-by: LuYahan PR-URL: https://github.com/nodejs/node/pull/65898 Reviewed-by: Antoine du Hamel --- common.gypi | 2 +- .../backend/riscv/code-generator-riscv.cc | 98 ++++++++++--------- 2 files changed, 53 insertions(+), 47 deletions(-) diff --git a/common.gypi b/common.gypi index 03ed837f607..6937aead0d1 100644 --- a/common.gypi +++ b/common.gypi @@ -44,7 +44,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.48', + 'v8_embedder_string': '-node.49', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/compiler/backend/riscv/code-generator-riscv.cc b/deps/v8/src/compiler/backend/riscv/code-generator-riscv.cc index ed33d5d3c67..15ba9ca08ef 100644 --- a/deps/v8/src/compiler/backend/riscv/code-generator-riscv.cc +++ b/deps/v8/src/compiler/backend/riscv/code-generator-riscv.cc @@ -433,8 +433,8 @@ FPUCondition FlagsConditionToConditionCmpFPU(bool* predicate, *predicate = true; return GE; case kFloatLessThanOrUnordered: - *predicate = true; - return LT; + *predicate = false; + return GE; case kFloatGreaterThanOrUnordered: *predicate = false; return LE; @@ -442,8 +442,8 @@ FPUCondition FlagsConditionToConditionCmpFPU(bool* predicate, *predicate = false; return LT; case kFloatLessThanOrEqualOrUnordered: - *predicate = true; - return LE; + *predicate = false; + return GT; default: *predicate = true; break; @@ -451,6 +451,44 @@ FPUCondition FlagsConditionToConditionCmpFPU(bool* predicate, UNREACHABLE(); } +// Emits the actual floating-point comparison for a kRiscvCmpS/kRiscvCmpD +// instruction, materializing its boolean result (0 or 1) into {dst}. +// The comparison itself is a pseudo-instruction (like the integer kRiscvCmp): +// nothing is emitted at the instruction site. Instead, the comparison and the +// FPUCondition-to-machine mapping are resolved together here, at the single +// flags consumer (branch, boolean materialization, or select), using the +// consumer's final FlagsCondition {condition} (which ComputeBranchInfo may +// have negated for branches). This makes it structurally impossible for +// complementary conditions to observe a comparison that was emitted for a +// different condition. +// The returned predicate tells the consumer how to interpret {dst}: when +// false, the comparison result must be inverted to obtain the condition's +// truth value (this is how conditions involving "unordered" are expressed +// with RISC-V's NaN-false flt/fle/feq instructions). +void EmitFPCompare(MacroAssembler* masm, RiscvOperandConverter& i, + Instruction* instr, FlagsCondition condition, Register dst, + bool* predicate) { + FPUCondition cc = FlagsConditionToConditionCmpFPU(predicate, condition); + if (instr->arch_opcode() == kRiscvCmpS) { + FPURegister left = i.InputOrZeroSingleRegister(0); + FPURegister right = i.InputOrZeroSingleRegister(1); + if ((left == kSingleRegZero || right == kSingleRegZero) && + !masm->IsSingleZeroRegSet()) { + masm->LoadFPRImmediate(kSingleRegZero, 0.0f); + } + masm->CompareF32(dst, cc, left, right); + } else { + DCHECK_EQ(instr->arch_opcode(), kRiscvCmpD); + FPURegister left = i.InputOrZeroDoubleRegister(0); + FPURegister right = i.InputOrZeroDoubleRegister(1); + if ((left == kDoubleRegZero || right == kDoubleRegZero) && + !masm->IsDoubleZeroRegSet()) { + masm->LoadFPRImmediate(kDoubleRegZero, 0.0); + } + masm->CompareF64(dst, cc, left, right); + } +} + #if V8_ENABLE_WEBASSEMBLY class WasmOutOfLineTrap : public OutOfLineCode { public: @@ -1597,26 +1635,10 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction( // Pseudo-instruction used for cmpzero/branch. No opcode emitted here. break; - case kRiscvCmpS: { - FPURegister left = i.InputOrZeroSingleRegister(0); - FPURegister right = i.InputOrZeroSingleRegister(1); - bool predicate; - FPUCondition cc = - FlagsConditionToConditionCmpFPU(&predicate, instr->flags_condition()); - - if ((left == kSingleRegZero || right == kSingleRegZero) && - !__ IsSingleZeroRegSet()) { - __ LoadFPRImmediate(kSingleRegZero, 0.0f); - } - switch (FlagsModeField::decode(instr->opcode())) { - case kFlags_set: - __ CompareF32(i.OutputRegister(), cc, left, right); - break; - default: - __ CompareF32(kScratchReg, cc, left, right); - break; - } - } break; + case kRiscvCmpS: + // Pseudo-instruction used for FP cmp/branch. No opcode emitted here; + // the comparison is emitted by the flags consumer via EmitFPCompare. + break; case kRiscvAddS: // TODO(plind): add special case: combine mult & add. __ fadd_s(i.OutputDoubleRegister(), i.InputDoubleRegister(0), @@ -1645,25 +1667,10 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction( __ fsqrt_s(i.OutputDoubleRegister(), i.InputDoubleRegister(0)); break; } - case kRiscvCmpD: { - FPURegister left = i.InputOrZeroDoubleRegister(0); - FPURegister right = i.InputOrZeroDoubleRegister(1); - bool predicate; - FPUCondition cc = - FlagsConditionToConditionCmpFPU(&predicate, instr->flags_condition()); - if ((left == kDoubleRegZero || right == kDoubleRegZero) && - !__ IsDoubleZeroRegSet()) { - __ LoadFPRImmediate(kDoubleRegZero, 0.0); - } - switch (FlagsModeField::decode(instr->opcode())) { - case kFlags_set: - __ CompareF64(i.OutputRegister(), cc, left, right); - break; - default: - __ CompareF64(kScratchReg, cc, left, right); - break; - } - } break; + case kRiscvCmpD: + // Pseudo-instruction used for FP cmp/branch. No opcode emitted here; + // the comparison is emitted by the flags consumer via EmitFPCompare. + break; #if V8_TARGET_ARCH_RISCV32 case kRiscvAddPair: __ AddPair(i.OutputRegister(0), i.OutputRegister(1), i.InputRegister(0), @@ -4600,8 +4607,7 @@ void AssembleBranchToLabels(CodeGenerator* gen, MacroAssembler* masm, } else if (instr->arch_opcode() == kRiscvCmpS || instr->arch_opcode() == kRiscvCmpD) { bool predicate; - FlagsConditionToConditionCmpFPU(&predicate, condition); - // floating-point compare result is set in kScratchReg + EmitFPCompare(masm, i, instr, condition, kScratchReg, &predicate); if (predicate) { __ BranchTrueF(kScratchReg, tlabel); } else { @@ -5005,7 +5011,7 @@ void CodeGenerator::AssembleArchBoolean(Instruction* instr, } else if (instr->arch_opcode() == kRiscvCmpD || instr->arch_opcode() == kRiscvCmpS) { bool predicate; - FlagsConditionToConditionCmpFPU(&predicate, condition); + EmitFPCompare(masm(), i, instr, condition, result, &predicate); // RISCV compare returns 0 or 1, do nothing when predicate; otherwise // toggle result (i.e., 0 -> 1, 1 -> 0) if (!predicate) { From 8e95e486d2eb9a774cf9389e88022a2385747b4a Mon Sep 17 00:00:00 2001 From: Austin Burdine Date: Thu, 8 Oct 2026 09:25:54 -0400 Subject: [PATCH 281/331] deps: V8: backport 2444c109f4f8 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Original commit message: [heap] Treat zero allocation throughput as a low allocation rate Since https://crrev.com/c/5935313 allocation throughput is tracked with SmoothedBytesAndDuration, which has no lower bound. A sampled throughput of exactly 0 -- nothing was allocated, or the smoothed value decayed to 0 after a long idle period -- made ComputeMutatorUtilizationImpl() return a mutator utilization of 0 ("maximal allocation"). For an isolate that never allocates on the CppHeap, HasLowAllocationRate() is then never true and the MemoryReducer cannot start a GC through its low-allocation condition; only the 100s watchdog can. Node.js hits this for any process that does not use node:vm. Remove the special case. A mutator speed of 0 now yields a mutator utilization of 1, i.e. the lowest possible allocation rate. gc_speed is either the conservative default or at least 1 byte/ms, so the formula stays well defined. Bug: 570738027 Change-Id: I84cd51607df3c31c2f1e02bb2fe258e5506131ce Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8521518 Reviewed-by: Dominik Inführ Commit-Queue: Dominik Inführ Reviewed-by: Omer Katz Commit-Queue: Omer Katz Cr-Commit-Position: refs/heads/main@{#110599} Refs: https://github.com/v8/v8/commit/2444c109f4f8165024971e15b12eb4611b4cd676 Co-authored-by: Antoine du Hamel Reviewed-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/66736 --- common.gypi | 2 +- deps/v8/AUTHORS | 1 + deps/v8/src/heap/gc-tracer.h | 2 + deps/v8/src/heap/heap.cc | 2 - deps/v8/src/heap/heap.h | 2 +- .../test/unittests/heap/gc-tracer-unittest.cc | 39 +++++++++++++++++++ 6 files changed, 44 insertions(+), 4 deletions(-) diff --git a/common.gypi b/common.gypi index 6937aead0d1..3b39cad99d9 100644 --- a/common.gypi +++ b/common.gypi @@ -44,7 +44,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.49', + 'v8_embedder_string': '-node.50', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/AUTHORS b/deps/v8/AUTHORS index 404f8901990..c5c4fa07ee1 100644 --- a/deps/v8/AUTHORS +++ b/deps/v8/AUTHORS @@ -77,6 +77,7 @@ Artem Kobzar Arthur Islamov Asuka Shikina Aurèle Barrière +Austin Burdine Aviv Keller Bala Avulapati Bangfu Tao diff --git a/deps/v8/src/heap/gc-tracer.h b/deps/v8/src/heap/gc-tracer.h index f980e340981..400457874a2 100644 --- a/deps/v8/src/heap/gc-tracer.h +++ b/deps/v8/src/heap/gc-tracer.h @@ -648,6 +648,7 @@ class V8_EXPORT_PRIVATE GCTracer { FRIEND_TEST(GCTracerTest, BackgroundMajorMCScope); FRIEND_TEST(GCTracerTest, CyclePriorities); FRIEND_TEST(GCTracerTest, EmbedderAllocationThroughput); + FRIEND_TEST(GCTracerTest, HighAllocationRateWithEmbedderAllocation); FRIEND_TEST(GCTracerTest, MultithreadedBackgroundScope); FRIEND_TEST(GCTracerTest, NewSpaceAllocationThroughput); FRIEND_TEST(GCTracerTest, PerGenerationAllocationThroughput); @@ -656,6 +657,7 @@ class V8_EXPORT_PRIVATE GCTracer { FRIEND_TEST(GCTracerTest, IncrementalMarkingDetails); FRIEND_TEST(GCTracerTest, IncrementalScope); FRIEND_TEST(GCTracerTest, IncrementalMarkingSpeed); + FRIEND_TEST(GCTracerTest, LowAllocationRateWithZeroEmbedderAllocation); FRIEND_TEST(GCTracerTest, MutatorUtilization); FRIEND_TEST(GCTracerTest, RecordMarkCompactHistograms); FRIEND_TEST(GCTracerTest, RecordScavengerHistograms); diff --git a/deps/v8/src/heap/heap.cc b/deps/v8/src/heap/heap.cc index 82682a78cd7..9471e577880 100644 --- a/deps/v8/src/heap/heap.cc +++ b/deps/v8/src/heap/heap.cc @@ -3572,9 +3572,7 @@ namespace { double ComputeMutatorUtilizationImpl(double mutator_speed, std::optional gc_speed) { - constexpr double kMinMutatorUtilization = 0.0; constexpr double kConservativeGcSpeedInBytesPerMillisecond = 200000; - if (mutator_speed == 0) return kMinMutatorUtilization; if (!gc_speed) gc_speed = kConservativeGcSpeedInBytesPerMillisecond; // Derivation: // mutator_utilization = mutator_time / (mutator_time + gc_time) diff --git a/deps/v8/src/heap/heap.h b/deps/v8/src/heap/heap.h index c51facdc2cf..8aa77cb115f 100644 --- a/deps/v8/src/heap/heap.h +++ b/deps/v8/src/heap/heap.h @@ -674,7 +674,7 @@ class Heap final { // null. V8_INLINE bool CanSafepoint() const { return deserialization_complete(); } - bool HasLowAllocationRate(); + V8_EXPORT_PRIVATE bool HasLowAllocationRate(); bool HasHighFragmentation(); void ActivateMemoryReducerIfNeeded(); diff --git a/deps/v8/test/unittests/heap/gc-tracer-unittest.cc b/deps/v8/test/unittests/heap/gc-tracer-unittest.cc index 5f31ddcd812..8e6031b73f0 100644 --- a/deps/v8/test/unittests/heap/gc-tracer-unittest.cc +++ b/deps/v8/test/unittests/heap/gc-tracer-unittest.cc @@ -179,6 +179,45 @@ TEST_F(GCTracerTest, IncrementalScope) { tracer->current_.scopes[GCTracer::Scope::MC_INCREMENTAL]); } +TEST_F(GCTracerTest, LowAllocationRateWithZeroEmbedderAllocation) { + if (v8_flags.stress_incremental_marking) return; + Heap* heap = i_isolate()->heap(); + GCTracer* tracer = heap->tracer(); + tracer->ResetForTesting(); + tracer->allocation_time_ = base::TimeTicks(); + + // Two samples 100 ms apart. Young and old generation allocate a little; + // the embedder (CppHeap) and external memory allocate nothing at all, as + // in an embedder that never uses cppgc (e.g. Node.js without node:vm). + tracer->SampleAllocation(base::TimeTicks::FromMsTicksForTesting(0), 0, 0, 0, + 0); + tracer->SampleAllocation(base::TimeTicks::FromMsTicksForTesting(100), 100, + 100, 0, 0); + + EXPECT_DOUBLE_EQ(0.0, + tracer->EmbedderAllocationThroughputInBytesPerMillisecond()); + EXPECT_TRUE(heap->HasLowAllocationRate()); +} + +TEST_F(GCTracerTest, HighAllocationRateWithEmbedderAllocation) { + if (v8_flags.stress_incremental_marking) return; + Heap* heap = i_isolate()->heap(); + GCTracer* tracer = heap->tracer(); + tracer->ResetForTesting(); + tracer->allocation_time_ = base::TimeTicks(); + + // Same as above, but the embedder allocates heavily: 1 GB over 100 ms is + // ~10^7 B/ms, so the embedder term must still report a high allocation + // rate (mu = 200000 / (10^7 + 200000) < 0.993). + tracer->SampleAllocation(base::TimeTicks::FromMsTicksForTesting(0), 0, 0, 0, + 0); + tracer->SampleAllocation(base::TimeTicks::FromMsTicksForTesting(100), 100, + 100, size_t{1} << 30, 0); + + EXPECT_GT(tracer->EmbedderAllocationThroughputInBytesPerMillisecond(), 0.0); + EXPECT_FALSE(heap->HasLowAllocationRate()); +} + TEST_F(GCTracerTest, IncrementalMarkingDetails) { if (v8_flags.stress_incremental_marking) return; GCTracer* tracer = i_isolate()->heap()->tracer(); From 9f5ec47ce3bc7eecab9f1b359ceebd72d7ea4e07 Mon Sep 17 00:00:00 2001 From: Barath Raj <129966260+barathraj048@users.noreply.github.com> Date: Fri, 13 Nov 2026 15:57:30 +0530 Subject: [PATCH 282/331] http2: do not reset stream before END_STREAM is sent When a compat API response finishes and the request had no body, kMaybeDestroy() takes the graceful-close path and sends RST_STREAM(NO_ERROR) right away. If the connection flow-control window is exhausted at that point, the empty END_STREAM DATA frame is still queued, so the reset goes out first and the END_STREAM frame is dropped, truncating an otherwise complete response. Skip the graceful close when the request already ended with its HEADERS frame, since there is no request body to abort. Fixes: https://github.com/nodejs/node/issues/66525 Refs: https://github.com/nodejs/node/pull/64265 Refs: https://github.com/nodejs/node/pull/64663 Signed-off-by: Barath PR-URL: https://github.com/nodejs/node/pull/66672 Reviewed-By: Matteo Collina Reviewed-By: Efe Karasakal --- lib/internal/http2/core.js | 9 +- ...-serverresponse-end-stream-flow-control.js | 128 ++++++++++++++++++ 2 files changed, 134 insertions(+), 3 deletions(-) create mode 100644 test/parallel/test-http2-compat-serverresponse-end-stream-flow-control.js diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js index 4e6d211999c..5dc3097fa5a 100644 --- a/lib/internal/http2/core.js +++ b/lib/internal/http2/core.js @@ -2598,15 +2598,18 @@ class Http2Stream extends Duplex { } // We've submitted a response from our server session, have not attempted - // to process any incoming data, and have no trailers. This means we can - // attempt to gracefully close the session. + // to process any incoming data, and have no trailers. If the client may + // still be sending a request body, gracefully close the stream to stop it. + // If the request already ended with its headers, there is nothing to stop, + // and closing early could reset the stream before END_STREAM is sent. const state = this[kState]; if (this.headersSent && this[kSession] && this[kSession][kType] === NGHTTP2_SESSION_SERVER && !(state.flags & STREAM_FLAGS_HAS_TRAILERS) && !state.didRead && - this.readableFlowing === null) { + this.readableFlowing === null && + !this.endAfterHeaders) { // By using setImmediate we allow pushStreams to make it through // before the stream is officially closed. This prevents a bug // in most browsers where those pushStreams would be rejected. diff --git a/test/parallel/test-http2-compat-serverresponse-end-stream-flow-control.js b/test/parallel/test-http2-compat-serverresponse-end-stream-flow-control.js new file mode 100644 index 00000000000..416b3447d83 --- /dev/null +++ b/test/parallel/test-http2-compat-serverresponse-end-stream-flow-control.js @@ -0,0 +1,128 @@ +'use strict'; + +// Regression test for https://github.com/nodejs/node/issues/66525. +// A compat API response to a request without a body must end with +// END_STREAM, even if the connection flow-control window is exhausted +// when the empty END_STREAM DATA frame is submitted. Previously the +// stream was reset with RST_STREAM(NO_ERROR) and the queued END_STREAM +// frame was dropped. + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('assert'); +const http2 = require('http2'); +const net = require('net'); + +const kData = 0; +const kHeaders = 1; +const kRstStream = 3; +const kSettings = 4; +const kWindowUpdate = 8; +const kFlagEndStream = 0x1; +const kFlagAck = 0x1; +const kFlagsEndStreamEndHeaders = 0x5; + +function frame(type, flags, id, payload = Buffer.alloc(0)) { + const header = Buffer.alloc(9); + header.writeUIntBE(payload.length, 0, 3); + header[3] = type; + header[4] = flags; + header.writeUInt32BE(id, 5); + return Buffer.concat([header, payload]); +} + +// Minimal HPACK encoding of a GET request for `path`: indexed :method GET, +// indexed :scheme http, and literal :path and :authority without Huffman. +function requestHeaders(path) { + const literal = (index, value) => + Buffer.concat([Buffer.from([index, value.length]), Buffer.from(value)]); + return Buffer.concat([ + Buffer.from([0x82, 0x86]), + literal(0x04, path), + literal(0x01, 'localhost'), + ]); +} + +let client; +let endStreamReceived = false; +let serverStreamClosed = false; + +function maybeFinish() { + if (endStreamReceived && serverStreamClosed) { + client.destroy(); + server.close(); + } +} + +const server = http2.createServer(); + +server.on('stream', common.mustCall((stream, headers) => { + if (headers[':path'] === '/small') { + // The stream must still close on its own once END_STREAM has been sent. + stream.on('close', common.mustCall(() => { + serverStreamClosed = true; + maybeFinish(); + })); + } +}, 2)); + +const responses = {}; +server.on('request', common.mustCall((req, res) => { + responses[req.url] = res; + if (!responses['/small'] || !responses['/big']) return; + // After /small's body has been written, let /big exhaust the connection + // window before /small's END_STREAM frame is submitted. + responses['/small'].stream.once('wantTrailers', () => { + responses['/big'].end('y'.repeat(1_000_000)); + }); + responses['/small'].end('x'.repeat(1000)); +}, 2)); + +server.listen(0, common.mustCall(() => { + // A raw client that does not send WINDOW_UPDATE until later, so the + // connection window stays exhausted once /big has drained it. + client = net.connect(server.address().port, common.mustCall(() => { + client.write(Buffer.concat([ + Buffer.from('PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'), + frame(kSettings, 0, 0), + frame(kHeaders, kFlagsEndStreamEndHeaders, 1, requestHeaders('/big')), + frame(kHeaders, kFlagsEndStreamEndHeaders, 3, requestHeaders('/small')), + ])); + })); + + let buffered = Buffer.alloc(0); + client.on('data', common.mustCallAtLeast((chunk) => { + buffered = Buffer.concat([buffered, chunk]); + while (buffered.length >= 9 && + buffered.length >= 9 + buffered.readUIntBE(0, 3)) { + const length = buffered.readUIntBE(0, 3); + const type = buffered[3]; + const flags = buffered[4]; + const id = buffered.readUInt32BE(5) & 0x7fffffff; + buffered = buffered.subarray(9 + length); + + if (type === kSettings && !(flags & kFlagAck)) + client.write(frame(kSettings, kFlagAck, 0)); + if (id !== 3) continue; + + assert.ok(type !== kRstStream || endStreamReceived, + 'stream /small was reset before END_STREAM was sent'); + if ((type === kData || type === kHeaders) && (flags & kFlagEndStream)) { + endStreamReceived = true; + maybeFinish(); + } + } + })); + + // Reopen the windows later. A correct server sends /small's END_STREAM then. + setTimeout(common.mustCall(() => { + const increment = Buffer.alloc(4); + increment.writeUInt32BE(10_000_000); + client.write(Buffer.concat([ + frame(kWindowUpdate, 0, 0, increment), + frame(kWindowUpdate, 0, 1, increment), + ])); + }), common.platformTimeout(300)); +})); From dec658010dad8072f8eabc66b12e3ef0299063e2 Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Tue, 13 Oct 2026 10:33:38 -0300 Subject: [PATCH 283/331] doc: list openssl-store channel and drop field in permissions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The node:permission-model:openssl-store diagnostics channel and the --allow-openssl-store flag were introduced in https://github.com/nodejs/node/pull/63949, but the Audit Mode section of the permissions documentation was not updated to list them. Refs: https://github.com/nodejs/node/pull/63949 Signed-off-by: RafaelGSS PR-URL: https://github.com/nodejs/node/pull/66558 Reviewed-By: Ulises Gascón --- doc/api/permissions.md | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/doc/api/permissions.md b/doc/api/permissions.md index 65849c4ffc3..44de2ffce67 100644 --- a/doc/api/permissions.md +++ b/doc/api/permissions.md @@ -158,8 +158,9 @@ Audit mode is useful for discovering what permissions your application requires before deploying with [`--permission`][]. It can also be combined with the [`--allow-fs-read`][], [`--allow-fs-write`][], [`--allow-net`][], [`--allow-child-process`][], [`--allow-worker`][], [`--allow-addons`][], -[`--allow-wasi`][], and [`--allow-ffi`][] flags to audit a subset of -permissions while granting others. +[`--allow-wasi`][], [`--allow-ffi`][], [`--allow-inspector`][], +and [`--allow-openssl-store`][] flags to audit a subset +of permissions while granting others. When a permission check fails in audit mode, a message is published to the diagnostics channel corresponding to the denied scope. The channel names are: @@ -172,12 +173,15 @@ diagnostics channel corresponding to the denied scope. The channel names are: * `node:permission-model:wasi` — WASI * `node:permission-model:addon` — Native Addons * `node:permission-model:ffi` — FFI +* `node:permission-model:openssl-store` — OpenSSL STORE loaders Each message is an object with the following properties: * `permission` {string} The name of the denied permission scope. * `resource` {string} The resource that access was denied to (e.g. a file path or host). +* `drop` {boolean|undefined} `true` when the message was published by + [`permission.drop()`][] rather than by a failed permission check. ```js const diagnostics_channel = require('node:diagnostics_channel'); @@ -420,6 +424,7 @@ Developers relying on --permission to sandbox untrusted code should be aware tha [`--allow-ffi`]: cli.md#--allow-ffi [`--allow-fs-read`]: cli.md#--allow-fs-read [`--allow-fs-write`]: cli.md#--allow-fs-write +[`--allow-inspector`]: cli.md#--allow-inspector [`--allow-net`]: cli.md#--allow-net [`--allow-openssl-store`]: cli.md#--allow-openssl-store [`--allow-wasi`]: cli.md#--allow-wasi @@ -429,4 +434,5 @@ Developers relying on --permission to sandbox untrusted code should be aware tha [`--permission`]: cli.md#--permission [`crypto.createPrivateKey()`]: crypto.md#cryptocreateprivatekeykey [`npx`]: https://docs.npmjs.com/cli/commands/npx +[`permission.drop()`]: process.md#processpermissiondropscope-reference [`permission.has()`]: process.md#processpermissionhasscope-reference From 02342352f2bc989c0a7249b578d33b41e0b172b7 Mon Sep 17 00:00:00 2001 From: joao-oliveira-softtor Date: Fri, 23 Oct 2026 04:04:37 -0300 Subject: [PATCH 284/331] test_runner: add option to forbid exclusive tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add --test-forbid-only and the forbidOnly run() option to detect accidentally committed exclusive tests. Reject only declarations and runOnly(true) in both isolation modes, and record a run-level failure so TODO and expected failures cannot absorb the error. Document the runtime-only detection and add regression coverage for filtering, option inheritance, both isolation modes, and disabled guards. Refs: https://github.com/nodejs/node/issues/60917 Assisted-by: a coding agent Signed-off-by: João Victor PR-URL: https://github.com/nodejs/node/pull/66578 Reviewed-By: Colin Ihrig Reviewed-By: Chemi Atlow --- doc/api/cli.md | 17 +++ doc/api/test.md | 15 +++ doc/node.1 | 12 ++ lib/internal/test_runner/runner.js | 13 ++ lib/internal/test_runner/test.js | 15 +++ lib/internal/test_runner/utils.js | 2 + src/node_options.cc | 6 + src/node_options.h | 1 + test/parallel/test-runner-forbid-only.js | 153 +++++++++++++++++++++++ 9 files changed, 234 insertions(+) create mode 100644 test/parallel/test-runner-forbid-only.js diff --git a/doc/api/cli.md b/doc/api/cli.md index 8a6ccbfe953..879b71d1b74 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -3214,6 +3214,22 @@ added: v22.8.0 Require a minimum percent of covered lines. If code coverage does not reach the threshold specified, the process will exit with code `1`. +### `--test-forbid-only` + + + +Fails the test run if a test or suite is declared with `only: true`, including +the `test.only()`, `it.only()`, `suite.only()`, and `describe.only()` shorthands, +or if `testContext.runOnly(true)` is called. This is useful in CI to prevent +accidentally committing exclusive tests that exclude the rest of a test suite. + +This option applies with either test isolation mode and takes precedence over +`--test-only`. Name filtering, TODO markers, and expected failures do not suppress +detected violations. Only declarations evaluated during the run are checked; +code inside a skipped test callback is not evaluated. + ### `--test-force-exit` -## [Unreleased] - ReleaseDate +# [Unreleased] - ReleaseDate + +# [0.2.6] - 2026-05-27 + +## Added +- Support for multi-line doc comments (#57, #62) + +## Changed +- Use `BTreeMap` for determinism in generated code (#52) +- Add `#[allow(unused_assignments)]` to generated code (#56) +- Exclude development scripts from published package (#60) +- Bump `pretty_assertions` dependency to 1.4.0 (#53) # [0.2.5] - 2024-06-20 @@ -50,7 +61,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 lines are needed. -[Unreleased]: https://github.com/yaahc/displaydoc/compare/v0.2.4...HEAD +[Unreleased]: https://github.com/yaahc/displaydoc/compare/v0.2.6...HEAD +[0.2.6]: https://github.com/yaahc/displaydoc/compare/v0.2.5...v0.2.6 +[0.2.5]: https://github.com/yaahc/displaydoc/compare/v0.2.4...v0.2.5 [0.2.4]: https://github.com/yaahc/displaydoc/compare/v0.2.3...v0.2.4 [0.2.3]: https://github.com/yaahc/displaydoc/compare/v0.2.2...v0.2.3 [0.2.2]: https://github.com/yaahc/displaydoc/compare/v0.2.1...v0.2.2 diff --git a/deps/crates/vendor/displaydoc-v0_2/Cargo.lock b/deps/crates/vendor/displaydoc-v0_2/Cargo.lock index 5e313d2eec1..2b166f6551e 100644 --- a/deps/crates/vendor/displaydoc-v0_2/Cargo.lock +++ b/deps/crates/vendor/displaydoc-v0_2/Cargo.lock @@ -3,33 +3,14 @@ version = 3 [[package]] -name = "ansi_term" -version = "0.11.0" +name = "diff" +version = "0.1.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b" -dependencies = [ - "winapi", -] - -[[package]] -name = "ctor" -version = "0.1.26" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096" -dependencies = [ - "quote", - "syn 1.0.109", -] - -[[package]] -name = "difference" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198" +checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8" [[package]] name = "displaydoc" -version = "0.2.5" +version = "0.2.6" dependencies = [ "libc", "pretty_assertions", @@ -37,34 +18,34 @@ dependencies = [ "quote", "rustversion", "static_assertions", - "syn 2.0.66", + "syn", "thiserror", "trybuild", ] [[package]] name = "equivalent" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" [[package]] name = "glob" -version = "0.3.1" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" +checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" [[package]] name = "hashbrown" -version = "0.14.5" +version = "0.16.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" [[package]] name = "indexmap" -version = "2.2.6" +version = "2.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26" +checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2" dependencies = [ "equivalent", "hashbrown", @@ -72,111 +53,111 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.11" +version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" +checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" [[package]] name = "libc" -version = "0.2.155" +version = "0.2.178" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" +checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091" [[package]] name = "memchr" -version = "2.7.4" +version = "2.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" - -[[package]] -name = "output_vt100" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "628223faebab4e3e40667ee0b2336d34a5b960ff60ea743ddfdbcf7770bcfb66" -dependencies = [ - "winapi", -] +checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" [[package]] name = "pretty_assertions" -version = "0.6.1" +version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f81e1644e1b54f5a68959a29aa86cde704219254669da328ecfdf6a1f09d427" +checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d" dependencies = [ - "ansi_term", - "ctor", - "difference", - "output_vt100", + "diff", + "yansi", ] [[package]] name = "proc-macro2" -version = "1.0.85" +version = "1.0.103" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22244ce15aa966053a896d1accb3a6e68469b97c7f33f284b99f0d576879fc23" +checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.36" +version = "1.0.42" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" +checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f" dependencies = [ "proc-macro2", ] [[package]] name = "rustversion" -version = "1.0.17" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" [[package]] name = "ryu" -version = "1.0.18" +version = "1.0.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" +checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" [[package]] name = "serde" -version = "1.0.203" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.203" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn", ] [[package]] name = "serde_json" -version = "1.0.117" +version = "1.0.145" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3" +checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" dependencies = [ "itoa", + "memchr", "ryu", "serde", + "serde_core", ] [[package]] name = "serde_spanned" -version = "0.6.6" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "79e674e01f999af37c49f70a6ede167a8a60b2503e56c5599532a65baa5969a0" +checksum = "e24345aa0fe688594e73770a5f6d1b216508b4f93484c0026d521acd30134392" dependencies = [ - "serde", + "serde_core", ] [[package]] @@ -187,9 +168,9 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" [[package]] name = "syn" -version = "1.0.109" +version = "2.0.111" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87" dependencies = [ "proc-macro2", "quote", @@ -197,15 +178,10 @@ dependencies = [ ] [[package]] -name = "syn" -version = "2.0.66" +name = "target-triple" +version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c42f3f41a2de00b01c0aaad383c5a45241efc8b2d1eda5661812fda5f3cdcff5" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] +checksum = "591ef38edfb78ca4771ee32cf494cb8771944bee237a9b91fc9c1424ac4b777b" [[package]] name = "termcolor" @@ -218,187 +194,116 @@ dependencies = [ [[package]] name = "thiserror" -version = "1.0.61" +version = "1.0.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.61" +version = "1.0.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn", ] [[package]] name = "toml" -version = "0.8.14" +version = "0.9.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f49eb2ab21d2f26bd6db7bf383edc527a7ebaee412d17af4d40fdccd442f335" +checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8" dependencies = [ - "serde", + "indexmap", + "serde_core", "serde_spanned", "toml_datetime", - "toml_edit", + "toml_parser", + "toml_writer", + "winnow", ] [[package]] name = "toml_datetime" -version = "0.6.6" +version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf" +checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533" dependencies = [ - "serde", + "serde_core", ] [[package]] -name = "toml_edit" -version = "0.22.14" +name = "toml_parser" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f21c7aaf97f1bd9ca9d4f9e73b0a6c74bd5afef56f2bc931943a6e1c37e04e38" +checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e" dependencies = [ - "indexmap", - "serde", - "serde_spanned", - "toml_datetime", "winnow", ] +[[package]] +name = "toml_writer" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2" + [[package]] name = "trybuild" -version = "1.0.96" +version = "1.0.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33a5f13f11071020bb12de7a16b925d2d58636175c20c11dc5f96cb64bb6c9b3" +checksum = "3e17e807bff86d2a06b52bca4276746584a78375055b6e45843925ce2802b335" dependencies = [ "glob", "serde", "serde_derive", "serde_json", + "target-triple", "termcolor", "toml", ] [[package]] name = "unicode-ident" -version = "1.0.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" - -[[package]] -name = "winapi" -version = "0.3.9" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" -dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", -] - -[[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" +checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5" [[package]] name = "winapi-util" -version = "0.1.8" +version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ "windows-sys", ] [[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" +name = "windows-link" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" [[package]] name = "windows-sys" -version = "0.52.0" +version = "0.61.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" dependencies = [ - "windows-targets", + "windows-link", ] [[package]] -name = "windows-targets" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb" -dependencies = [ - "windows_aarch64_gnullvm", - "windows_aarch64_msvc", - "windows_i686_gnu", - "windows_i686_gnullvm", - "windows_i686_msvc", - "windows_x86_64_gnu", - "windows_x86_64_gnullvm", - "windows_x86_64_msvc", -] - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6" - -[[package]] -name = "windows_i686_gnu" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670" - -[[package]] -name = "windows_i686_gnullvm" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9" - -[[package]] -name = "windows_i686_msvc" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.52.5" +name = "winnow" +version = "0.7.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0" +checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829" [[package]] -name = "winnow" -version = "0.6.13" +name = "yansi" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59b5e5f6c299a3c7890b876a2a587f3115162487e704907d9b6cd29473052ba1" -dependencies = [ - "memchr", -] +checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049" diff --git a/deps/crates/vendor/displaydoc-v0_2/Cargo.toml b/deps/crates/vendor/displaydoc-v0_2/Cargo.toml index 0202d998578..1d1043e443c 100644 --- a/deps/crates/vendor/displaydoc-v0_2/Cargo.toml +++ b/deps/crates/vendor/displaydoc-v0_2/Cargo.toml @@ -13,8 +13,23 @@ edition = "2021" rust-version = "1.56.0" name = "displaydoc" -version = "0.2.5" +version = "0.2.6" authors = ["Jane Lusby "] +build = false +include = [ + "Cargo.toml", + "README.md", + "LICENSE-MIT", + "LICENSE-APACHE", + "CHANGELOG.md", + "src/**/*.rs", + "tests/**/*.rs", +] +autolib = false +autobins = false +autoexamples = false +autotests = false +autobenches = false description = """ A derive macro for implementing the display Trait via a doc comment and string interpolation """ @@ -41,47 +56,72 @@ pre-release-hook = ["./update-readme.sh"] [[package.metadata.release.pre-release-replacements]] file = "CHANGELOG.md" -replace = "{{version}}" search = "Unreleased" +replace = "{{version}}" [[package.metadata.release.pre-release-replacements]] -exactly = 1 file = "src/lib.rs" -replace = "#![doc(html_root_url = \"https://docs.rs/{{crate_name}}/{{version}}\")]" search = '#!\[doc\(html_root_url.*' +replace = '#![doc(html_root_url = "https://docs.rs/{{crate_name}}/{{version}}")]' +exactly = 1 [[package.metadata.release.pre-release-replacements]] file = "CHANGELOG.md" -replace = "{{date}}" search = "ReleaseDate" +replace = "{{date}}" [[package.metadata.release.pre-release-replacements]] -exactly = 1 file = "CHANGELOG.md" +search = "" replace = """ # [Unreleased] - ReleaseDate""" -search = "" +exactly = 1 [[package.metadata.release.pre-release-replacements]] -exactly = 1 file = "CHANGELOG.md" -replace = "...{{tag_name}}" search = '\.\.\.HEAD' +replace = "...{{tag_name}}" +exactly = 1 [[package.metadata.release.pre-release-replacements]] -exactly = 1 file = "CHANGELOG.md" +search = "" replace = """ [Unreleased]: https://github.com/yaahc/{{crate_name}}/compare/{{tag_name}}...HEAD""" -search = "" +exactly = 1 + +[features] +default = ["std"] +std = [] [lib] +name = "displaydoc" path = "src/lib.rs" proc-macro = true +[[test]] +name = "compile_tests" +path = "tests/compile_tests.rs" + +[[test]] +name = "happy" +path = "tests/happy.rs" + +[[test]] +name = "no_std" +path = "tests/no_std.rs" + +[[test]] +name = "num_in_field" +path = "tests/num_in_field.rs" + +[[test]] +name = "variantless" +path = "tests/variantless.rs" + [dependencies.proc-macro2] version = "1.0" @@ -96,7 +136,7 @@ version = "0.2" default-features = false [dev-dependencies.pretty_assertions] -version = "0.6.1" +version = "1.4.0" [dev-dependencies.rustversion] version = "1.0.0" @@ -109,7 +149,3 @@ version = "1.0.24" [dev-dependencies.trybuild] version = "1.0" - -[features] -default = ["std"] -std = [] diff --git a/deps/crates/vendor/displaydoc-v0_2/Cargo.toml.orig b/deps/crates/vendor/displaydoc-v0_2/Cargo.toml.orig index c80116c26c5..7015d71fc59 100644 --- a/deps/crates/vendor/displaydoc-v0_2/Cargo.toml.orig +++ b/deps/crates/vendor/displaydoc-v0_2/Cargo.toml.orig @@ -1,6 +1,6 @@ [package] name = "displaydoc" -version = "0.2.5" +version = "0.2.6" rust-version = "1.56.0" authors = ["Jane Lusby "] edition = "2021" @@ -13,6 +13,7 @@ keywords = ["display", "derive"] description = """ A derive macro for implementing the display Trait via a doc comment and string interpolation """ +include = ["Cargo.toml", "README.md", "LICENSE-MIT", "LICENSE-APACHE", "CHANGELOG.md", "src/**/*.rs", "tests/**/*.rs"] [lib] proc-macro = true @@ -32,7 +33,7 @@ trybuild = "1.0" static_assertions = "1.1" libc = { version = "0.2", default-features = false } rustversion = "1.0.0" -pretty_assertions = "0.6.1" +pretty_assertions = "1.4.0" thiserror = "1.0.24" [package.metadata.docs.rs] diff --git a/deps/crates/vendor/displaydoc-v0_2/README.md b/deps/crates/vendor/displaydoc-v0_2/README.md index a609b0f270a..ef24e175231 100644 --- a/deps/crates/vendor/displaydoc-v0_2/README.md +++ b/deps/crates/vendor/displaydoc-v0_2/README.md @@ -75,8 +75,8 @@ assert!("oh no, an error: muahaha i am an error" == &format!("{}", error)); - Two optional attributes can be added to your types next to the derive: - `#[ignore_extra_doc_attributes]` makes the macro ignore any doc - comment attributes (or `///` lines) after the first. Multi-line - comments using `///` are otherwise treated as an error, so use this + comment attributes (or `///` lines) after the last non-empty line. Multi-line + comments with line breaks using `///` are otherwise treated as an error, so use this attribute or consider switching to block doc comments (`/** */`). - `#[prefix_enum_doc_attributes]` combines the doc comment message on @@ -85,7 +85,7 @@ assert!("oh no, an error: muahaha i am an error" == &format!("{}", error)); becomes mandatory. When added to any other type, it has no effect. - In case you want to have an independent doc comment, the - `#[displaydoc("...")` atrribute may be used on the variant or struct to + `#[displaydoc("...")` attribute may be used on the variant or struct to override it.
    diff --git a/deps/crates/vendor/displaydoc-v0_2/README.tpl b/deps/crates/vendor/displaydoc-v0_2/README.tpl deleted file mode 100644 index 6206a9e7e63..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/README.tpl +++ /dev/null @@ -1,23 +0,0 @@ -derive(Display) /// `From` -=============== - -[![Latest Version](https://img.shields.io/crates/v/displaydoc.svg)](https://crates.io/crates/displaydoc) -[![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/displaydoc) - -{{readme}} - - -#### License - - -Licensed under either of Apache License, Version -2.0 or MIT license at your option. - - -
    - - -Unless you explicitly state otherwise, any contribution intentionally submitted -for inclusion in this crate by you, as defined in the Apache-2.0 license, shall -be dual licensed as above, without any additional terms or conditions. - diff --git a/deps/crates/vendor/displaydoc-v0_2/examples/simple.rs b/deps/crates/vendor/displaydoc-v0_2/examples/simple.rs deleted file mode 100644 index f4aad2131fd..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/examples/simple.rs +++ /dev/null @@ -1,36 +0,0 @@ -use displaydoc::Display; - -#[derive(Debug, Display)] -pub enum DataStoreError { - /// data store disconnected - Disconnect, - /// the data for key `{0}` is not available - Redaction(String), - /// invalid header (expected {expected:?}, found {found:?}) - InvalidHeader { expected: String, found: String }, - /// unknown data store error - Unknown, -} - -fn main() { - let disconnect = DataStoreError::Disconnect; - println!( - "Enum value `Disconnect` should be printed as:\n\t{}", - disconnect - ); - - let redaction = DataStoreError::Redaction(String::from("Dummy")); - println!( - "Enum value `Redaction` should be printed as:\n\t{}", - redaction - ); - - let invalid_header = DataStoreError::InvalidHeader { - expected: String::from("https"), - found: String::from("http"), - }; - println!( - "Enum value `InvalidHeader` should be printed as:\n\t{}", - invalid_header - ); -} diff --git a/deps/crates/vendor/displaydoc-v0_2/src/attr.rs b/deps/crates/vendor/displaydoc-v0_2/src/attr.rs index afda4b90fa6..29f0d496480 100644 --- a/deps/crates/vendor/displaydoc-v0_2/src/attr.rs +++ b/deps/crates/vendor/displaydoc-v0_2/src/attr.rs @@ -69,50 +69,54 @@ impl AttrsHelper { return Ok(Some(display)); } - let num_doc_attrs = attrs + let literals = attrs .iter() .filter(|attr| attr.path().is_ident("doc")) - .count(); + .map(|attr| match &attr.meta { + Meta::NameValue(syn::MetaNameValue { + value: + syn::Expr::Lit(syn::ExprLit { + lit: syn::Lit::Str(lit), + .. + }), + .. + }) => lit, + _ => unimplemented!(), + }); + + let span = match literals.clone().next() { + Some(lit) => lit.span(), + None => return Ok(None), + }; - if !self.ignore_extra_doc_attributes && num_doc_attrs > 1 { - panic!("Multi-line comments are disabled by default by displaydoc. Please consider using block doc comments (/** */) or adding the #[ignore_extra_doc_attributes] attribute to your type next to the derive."); - } + let strs = literals.map(|lit| { + // Make an attempt at cleaning up multiline doc comments. + let doc_str = lit + .value() + .lines() + .map(|line| line.trim().trim_start_matches('*').trim()) + .collect::>() + .join("\n") + .trim() + .to_string(); + (!doc_str.is_empty()).then(|| doc_str) + }); - for attr in attrs { - if attr.path().is_ident("doc") { - let lit = match &attr.meta { - Meta::NameValue(syn::MetaNameValue { - value: - syn::Expr::Lit(syn::ExprLit { - lit: syn::Lit::Str(lit), - .. - }), - .. - }) => lit, - _ => unimplemented!(), - }; - - // Make an attempt at cleaning up multiline doc comments. - let doc_str = lit - .value() - .lines() - .map(|line| line.trim().trim_start_matches('*').trim()) - .collect::>() - .join("\n"); - - let lit = LitStr::new(doc_str.trim(), lit.span()); - - let mut display = Display { - fmt: lit, - args: TokenStream::new(), - }; - - display.expand_shorthand(); - return Ok(Some(display)); - } - } + let joined = if self.ignore_extra_doc_attributes { + strs.take_while(|x| x.is_some()).collect::>>() + } else { + strs.collect::>>() + }.unwrap_or_else(|| { + panic!("Paragraph breaks in multi-line doc comments are disabled by default by displaydoc. Please consider using block doc comments (/** */) or adding the #[ignore_extra_doc_attributes] attribute to your type next to the derive"); + }).join(" "); + + let mut display = Display { + fmt: LitStr::new(&joined, span), + args: TokenStream::new(), + }; - Ok(None) + display.expand_shorthand(); + Ok(Some(display)) } pub(crate) fn display_with_input( diff --git a/deps/crates/vendor/displaydoc-v0_2/src/expand.rs b/deps/crates/vendor/displaydoc-v0_2/src/expand.rs index 3b146f81ecd..69658266ad3 100644 --- a/deps/crates/vendor/displaydoc-v0_2/src/expand.rs +++ b/deps/crates/vendor/displaydoc-v0_2/src/expand.rs @@ -9,7 +9,7 @@ use syn::{ TypeParamBound, TypePath, WhereClause, WherePredicate, }; -use std::collections::HashMap; +use std::collections::BTreeMap; pub(crate) fn derive(input: &DeriveInput) -> Result { let impls = match &input.data { @@ -92,11 +92,12 @@ fn impl_struct(input: &DeriveInput, data: &DataStruct) -> Result { quote! { impl #impl_generics ::core::fmt::Display for #ty #ty_generics #where_clause { fn fmt(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - // NB: This destructures the fields of `self` into named variables (for unnamed - // fields, it uses _0, _1, etc as above). The `#[allow(unused_variables)]` - // section means it doesn't have to parse the individual field references out of - // the docstring. - #[allow(unused_variables)] + // NB: This destructures the fields of `self` into named + // variables (for unnamed fields, it uses _0, _1, etc as + // above). The `#[allow(unused_variables, unused_assignments)]` + // section means it doesn't have to parse the individual field + // references out of the docstring. + #[allow(unused_variables, unused_assignments)] let #pat = self; #display } @@ -224,9 +225,9 @@ fn add_display_constraint_to_type_predicate( fn extract_trait_constraints_from_source( where_clause: &WhereClause, type_params: &[&TypeParam], -) -> HashMap> { +) -> BTreeMap> { // Add trait bounds provided at the declaration site of type parameters for the struct/enum. - let mut param_constraint_mapping: HashMap> = type_params + let mut param_constraint_mapping: BTreeMap> = type_params .iter() .map(|type_param| { let trait_bounds: Vec = type_param @@ -396,7 +397,7 @@ fn impl_enum(input: &DeriveInput, data: &DataEnum) -> Result { Ok(quote! { impl #impl_generics ::core::fmt::Display for #ty #ty_generics #where_clause { fn fmt(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - #[allow(unused_variables)] + #[allow(unused_variables, unused_assignments)] match self { #(#arms,)* } diff --git a/deps/crates/vendor/displaydoc-v0_2/src/lib.rs b/deps/crates/vendor/displaydoc-v0_2/src/lib.rs index 8824ff05ba8..5a93a709977 100644 --- a/deps/crates/vendor/displaydoc-v0_2/src/lib.rs +++ b/deps/crates/vendor/displaydoc-v0_2/src/lib.rs @@ -70,8 +70,8 @@ //! - Two optional attributes can be added to your types next to the derive: //! //! - `#[ignore_extra_doc_attributes]` makes the macro ignore any doc -//! comment attributes (or `///` lines) after the first. Multi-line -//! comments using `///` are otherwise treated as an error, so use this +//! comment attributes (or `///` lines) after the last non-empty line. Multi-line +//! comments with line breaks using `///` are otherwise treated as an error, so use this //! attribute or consider switching to block doc comments (`/** */`). //! //! - `#[prefix_enum_doc_attributes]` combines the doc comment message on @@ -80,7 +80,7 @@ //! becomes mandatory. When added to any other type, it has no effect. //! //! - In case you want to have an independent doc comment, the -//! `#[displaydoc("...")` atrribute may be used on the variant or struct to +//! `#[displaydoc("...")` attribute may be used on the variant or struct to //! override it. //! //!
    @@ -92,7 +92,7 @@ //! //! 2. **Does this crate work with `Path` and `PathBuf` via the `Display` trait?** //! * Yuuup. This crate uses @dtolnay's [autoref specialization technique](https://github.com/dtolnay/case-studies/blob/master/autoref-specialization/README.md) to add a special trait for types to get the display impl. It then specializes for `Path` and `PathBuf`, and when either of these types are found, it calls `self.display()` to get a `std::path::Display<'_>` type which can be used with the `Display` format specifier! -#![doc(html_root_url = "https://docs.rs/displaydoc/0.2.3")] +#![doc(html_root_url = "https://docs.rs/displaydoc/0.2.6")] #![cfg_attr(docsrs, feature(doc_cfg))] #![warn( rust_2018_idioms, diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/compile_tests.rs b/deps/crates/vendor/displaydoc-v0_2/tests/compile_tests.rs index 29c72a86214..6513eb70e9f 100644 --- a/deps/crates/vendor/displaydoc-v0_2/tests/compile_tests.rs +++ b/deps/crates/vendor/displaydoc-v0_2/tests/compile_tests.rs @@ -3,27 +3,12 @@ #[test] fn no_std() { let t = trybuild::TestCases::new(); - #[cfg(not(feature = "std"))] - t.compile_fail("tests/no_std/without.rs"); - #[cfg(not(feature = "std"))] - t.compile_fail("tests/no_std/multi_line.rs"); - #[cfg(not(feature = "std"))] - t.pass("tests/no_std/multi_line_allow.rs"); - #[cfg(not(feature = "std"))] - t.compile_fail("tests/no_std/enum_prefix_missing.rs"); - #[cfg(not(feature = "std"))] - t.pass("tests/no_std/enum_prefix.rs"); - #[cfg(feature = "std")] - t.compile_fail("tests/std/without.rs"); - #[cfg(feature = "std")] - t.compile_fail("tests/std/multi_line.rs"); - #[cfg(feature = "std")] - t.pass("tests/std/multi_line_allow.rs"); - #[cfg(feature = "std")] - t.compile_fail("tests/std/enum_prefix_missing.rs"); - #[cfg(feature = "std")] - t.pass("tests/std/enum_prefix.rs"); - #[cfg(feature = "std")] - t.pass("tests/std/multiple.rs"); - t.pass("tests/no_std/with.rs"); + t.compile_fail("tests/ui/without.rs"); + t.compile_fail("tests/ui/multi_line_line_break.rs"); + t.compile_fail("tests/ui/multi_line_line_break_block.rs"); + t.pass("tests/ui/multi_line.rs"); + t.pass("tests/ui/multi_line_allow.rs"); + t.compile_fail("tests/ui/enum_prefix_missing.rs"); + t.pass("tests/ui/enum_prefix.rs"); + t.pass("tests/ui/multiple.rs"); } diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/happy.rs b/deps/crates/vendor/displaydoc-v0_2/tests/happy.rs index 85aa78f1379..7d94e1601ed 100644 --- a/deps/crates/vendor/displaydoc-v0_2/tests/happy.rs +++ b/deps/crates/vendor/displaydoc-v0_2/tests/happy.rs @@ -12,11 +12,53 @@ struct HappyStruct { #[derive(Display)] #[ignore_extra_doc_attributes] /// Just a basic struct {thing} -/// and this line should get ignored +/// and this line should not get ignored struct HappyStruct2 { thing: &'static str, } +#[derive(Display)] +/// Really fancy first line with thing: {thing} +/// Really cool second line +struct HappyMultiLine { + thing: &'static str, +} + +#[derive(Display)] +#[ignore_extra_doc_attributes] +/// multi +/// line +/// +/// new paragraph should be ignored +struct HappyMultilineWithIgnore; + +#[derive(Display)] +enum MixedBlockAndLineComments { + /** + * hello + * block + * comment + */ + /// line comment + BlockFirst, + /// line comment + /** + * hello + * block + * comment + */ + LineFirst, + /** + * block + * comment + */ + /** + * block + * comment2 + */ + DoubleBlock, +} + #[derive(Display)] enum Happy { /// I really like Variant1 @@ -109,7 +151,30 @@ fn does_it_print() { ); assert_display(HappyStruct { thing: "hi" }, "Just a basic struct hi"); - assert_display(HappyStruct2 { thing: "hi2" }, "Just a basic struct hi2"); + assert_display( + HappyStruct2 { thing: "hi2" }, + "Just a basic struct hi2 and this line should not get ignored", + ); + + assert_display( + HappyMultiLine { thing: "rust" }, + "Really fancy first line with thing: rust Really cool second line", + ); + + assert_display(HappyMultilineWithIgnore, "multi line"); + + assert_display( + MixedBlockAndLineComments::BlockFirst, + "hello\nblock\ncomment line comment", + ); + assert_display( + MixedBlockAndLineComments::LineFirst, + "line comment hello\nblock\ncomment", + ); + assert_display( + MixedBlockAndLineComments::DoubleBlock, + "block\ncomment block\ncomment2", + ); assert_display(inner_mod::InnerHappy::Variant1, "I really like Variant1"); assert_display( diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/no_std.rs b/deps/crates/vendor/displaydoc-v0_2/tests/no_std.rs new file mode 100644 index 00000000000..e74727d5da0 --- /dev/null +++ b/deps/crates/vendor/displaydoc-v0_2/tests/no_std.rs @@ -0,0 +1,44 @@ +#![no_std] +#![allow(unused)] + +// This test ensures that the generated code doesn't reference any stdlib items. + +use displaydoc::Display; + +#[derive(Display)] +/// Just a basic struct {thing} +struct HappyStruct { + thing: &'static str, +} + +#[derive(Display)] +#[ignore_extra_doc_attributes] +/// Just a basic struct {thing} +/// and this line should get ignored +struct HappyStruct2 { + thing: &'static str, +} + +#[derive(Display)] +enum Happy { + /// I really like Variant1 + Variant1, + /// Variant2 is pretty swell 2 + Variant2, + /// Variant3 is okay {sometimes} + Variant3 { sometimes: &'static str }, + /** + * Variant4 wants to have a lot of lines + * + * Lets see how this works out for it + */ + Variant4, + /// Variant5 has a parameter {0} and some regular comments + // A regular comment that won't get picked + Variant5(u32), + + /// These docs are ignored + #[displaydoc("Variant7 has a parameter {0} and uses #[displaydoc]")] + /// These docs are also ignored + Variant7(u32), +} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/enum_prefix.rs b/deps/crates/vendor/displaydoc-v0_2/tests/no_std/enum_prefix.rs deleted file mode 100644 index 5538e2751aa..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/enum_prefix.rs +++ /dev/null @@ -1,36 +0,0 @@ -#![cfg_attr(not(feature = "std"), allow(internal_features), feature(lang_items, start))] -#![cfg_attr(not(feature = "std"), no_std)] - -#[cfg_attr(not(feature = "std"), start)] -fn start(_argc: isize, _argv: *const *const u8) -> isize { - 0 -} -#[lang = "eh_personality"] -#[no_mangle] -#[cfg(not(feature = "std"))] -pub extern "C" fn rust_eh_personality() {} -#[panic_handler] -#[cfg(not(feature = "std"))] -fn panic(_info: &core::panic::PanicInfo) -> ! { - unsafe { - libc::abort(); - } -} - -use displaydoc::Display; - -/// this type is pretty swell -#[derive(Display)] -#[prefix_enum_doc_attributes] -enum TestType { - /// this variant is too - Variant1, - - /// this variant is two - Variant2, -} - -static_assertions::assert_impl_all!(TestType: core::fmt::Display); - -#[cfg(feature = "std")] -fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/enum_prefix_missing.rs b/deps/crates/vendor/displaydoc-v0_2/tests/no_std/enum_prefix_missing.rs deleted file mode 100644 index 71710726f3b..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/enum_prefix_missing.rs +++ /dev/null @@ -1,35 +0,0 @@ -#![cfg_attr(not(feature = "std"), allow(internal_features), feature(lang_items, start))] -#![cfg_attr(not(feature = "std"), no_std)] - -#[cfg_attr(not(feature = "std"), start)] -fn start(_argc: isize, _argv: *const *const u8) -> isize { - 0 -} -#[lang = "eh_personality"] -#[no_mangle] -#[cfg(not(feature = "std"))] -pub extern "C" fn rust_eh_personality() {} -#[panic_handler] -#[cfg(not(feature = "std"))] -fn panic(_info: &core::panic::PanicInfo) -> ! { - unsafe { - libc::abort(); - } -} - -use displaydoc::Display; - -#[derive(Display)] -#[prefix_enum_doc_attributes] -enum TestType { - /// this variant is too - Variant1, - - /// this variant is two - Variant2, -} - -static_assertions::assert_impl_all!(TestType: core::fmt::Display); - -#[cfg(feature = "std")] -fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/enum_prefix_missing.stderr b/deps/crates/vendor/displaydoc-v0_2/tests/no_std/enum_prefix_missing.stderr deleted file mode 100644 index 8cf7993271b..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/enum_prefix_missing.stderr +++ /dev/null @@ -1,22 +0,0 @@ -error: proc-macro derive panicked - --> $DIR/enum_prefix_missing.rs:22:10 - | -22 | #[derive(Display)] - | ^^^^^^^ - | - = help: message: Missing doc comment on enum with #[prefix_enum_doc_attributes]. Please remove the attribute or add a doc comment to the enum itself. - -error[E0277]: `TestType` doesn't implement `Display` - --> $DIR/enum_prefix_missing.rs:32:37 - | -32 | static_assertions::assert_impl_all!(TestType: core::fmt::Display); - | ^^^^^^^^ `TestType` cannot be formatted with the default formatter - | - = help: the trait `Display` is not implemented for `TestType` - = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead -note: required by a bound in `assert_impl_all` - --> $DIR/enum_prefix_missing.rs:32:1 - | -32 | static_assertions::assert_impl_all!(TestType: core::fmt::Display); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `assert_impl_all` - = note: this error originates in the macro `static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/multi_line.rs b/deps/crates/vendor/displaydoc-v0_2/tests/no_std/multi_line.rs deleted file mode 100644 index ca4215cdc3c..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/multi_line.rs +++ /dev/null @@ -1,37 +0,0 @@ -#![cfg_attr(not(feature = "std"), allow(internal_features), feature(lang_items, start))] -#![cfg_attr(not(feature = "std"), no_std)] - -#[cfg_attr(not(feature = "std"), start)] -fn start(_argc: isize, _argv: *const *const u8) -> isize { - 0 -} -#[lang = "eh_personality"] -#[no_mangle] -#[cfg(not(feature = "std"))] -pub extern "C" fn rust_eh_personality() {} -#[panic_handler] -#[cfg(not(feature = "std"))] -fn panic(_info: &core::panic::PanicInfo) -> ! { - unsafe { - libc::abort(); - } -} - -use displaydoc::Display; - -/// this type is pretty swell -#[derive(Display)] -enum TestType { - /// This one is okay - Variant1, - - /// Multi - /// line - /// doc. - Variant2, -} - -static_assertions::assert_impl_all!(TestType: core::fmt::Display); - -#[cfg(feature = "std")] -fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/multi_line.stderr b/deps/crates/vendor/displaydoc-v0_2/tests/no_std/multi_line.stderr deleted file mode 100644 index f3d77b9e4b9..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/multi_line.stderr +++ /dev/null @@ -1,22 +0,0 @@ -error: proc-macro derive panicked - --> $DIR/multi_line.rs:23:10 - | -23 | #[derive(Display)] - | ^^^^^^^ - | - = help: message: Multi-line comments are disabled by default by displaydoc. Please consider using block doc comments (/** */) or adding the #[ignore_extra_doc_attributes] attribute to your type next to the derive. - -error[E0277]: `TestType` doesn't implement `Display` - --> $DIR/multi_line.rs:34:37 - | -34 | static_assertions::assert_impl_all!(TestType: core::fmt::Display); - | ^^^^^^^^ `TestType` cannot be formatted with the default formatter - | - = help: the trait `Display` is not implemented for `TestType` - = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead -note: required by a bound in `assert_impl_all` - --> $DIR/multi_line.rs:34:1 - | -34 | static_assertions::assert_impl_all!(TestType: core::fmt::Display); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `assert_impl_all` - = note: this error originates in the macro `static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/multi_line_allow.rs b/deps/crates/vendor/displaydoc-v0_2/tests/no_std/multi_line_allow.rs deleted file mode 100644 index 84676817ea7..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/multi_line_allow.rs +++ /dev/null @@ -1,38 +0,0 @@ -#![cfg_attr(not(feature = "std"), allow(internal_features), feature(lang_items, start))] -#![cfg_attr(not(feature = "std"), no_std)] - -#[cfg_attr(not(feature = "std"), start)] -fn start(_argc: isize, _argv: *const *const u8) -> isize { - 0 -} -#[lang = "eh_personality"] -#[no_mangle] -#[cfg(not(feature = "std"))] -pub extern "C" fn rust_eh_personality() {} -#[panic_handler] -#[cfg(not(feature = "std"))] -fn panic(_info: &core::panic::PanicInfo) -> ! { - unsafe { - libc::abort(); - } -} - -use displaydoc::Display; - -/// this type is pretty swell -#[derive(Display)] -#[ignore_extra_doc_attributes] -enum TestType { - /// This one is okay - Variant1, - - /// Multi - /// line - /// doc. - Variant2, -} - -static_assertions::assert_impl_all!(TestType: core::fmt::Display); - -#[cfg(feature = "std")] -fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/with.rs b/deps/crates/vendor/displaydoc-v0_2/tests/no_std/with.rs deleted file mode 100644 index 67aef473aa4..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/with.rs +++ /dev/null @@ -1,32 +0,0 @@ -#![feature(lang_items, start)] -#![no_std] - -#[start] -#[cfg(not(feature = "std"))] -fn start(_argc: isize, _argv: *const *const u8) -> isize { - 0 -} - -#[lang = "eh_personality"] -#[no_mangle] -#[cfg(not(feature = "std"))] -pub extern "C" fn rust_eh_personality() {} - -#[panic_handler] -#[cfg(not(feature = "std"))] -fn panic(_info: &core::panic::PanicInfo) -> ! { - unsafe { - libc::abort(); - } -} - -#[cfg(feature = "std")] -fn main() {} - -use displaydoc::Display; - -/// this type is pretty swell -#[derive(Display)] -struct FakeType; - -static_assertions::assert_impl_all!(FakeType: core::fmt::Display); diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/without.rs b/deps/crates/vendor/displaydoc-v0_2/tests/no_std/without.rs deleted file mode 100644 index 04d4b8fa695..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/without.rs +++ /dev/null @@ -1,28 +0,0 @@ -#![cfg_attr(not(feature = "std"), allow(internal_features), feature(lang_items, start))] -#![cfg_attr(not(feature = "std"), no_std)] - -#[cfg_attr(not(feature = "std"), start)] -fn start(_argc: isize, _argv: *const *const u8) -> isize { - 0 -} -#[lang = "eh_personality"] -#[no_mangle] -#[cfg(not(feature = "std"))] -pub extern "C" fn rust_eh_personality() {} -#[panic_handler] -#[cfg(not(feature = "std"))] -fn panic(_info: &core::panic::PanicInfo) -> ! { - unsafe { - libc::abort(); - } -} - -use displaydoc::Display; - -/// this type is pretty swell -struct FakeType; - -static_assertions::assert_impl_all!(FakeType: core::fmt::Display); - -#[cfg(feature = "std")] -fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/without.stderr b/deps/crates/vendor/displaydoc-v0_2/tests/no_std/without.stderr deleted file mode 100644 index a12edc4a384..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/no_std/without.stderr +++ /dev/null @@ -1,22 +0,0 @@ -warning: unused import: `displaydoc::Display` - --> $DIR/without.rs:20:5 - | -20 | use displaydoc::Display; - | ^^^^^^^^^^^^^^^^^^^ - | - = note: `#[warn(unused_imports)]` on by default - -error[E0277]: `FakeType` doesn't implement `Display` - --> $DIR/without.rs:25:37 - | -25 | static_assertions::assert_impl_all!(FakeType: core::fmt::Display); - | ^^^^^^^^ `FakeType` cannot be formatted with the default formatter - | - = help: the trait `Display` is not implemented for `FakeType` - = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead -note: required by a bound in `assert_impl_all` - --> $DIR/without.rs:25:1 - | -25 | static_assertions::assert_impl_all!(FakeType: core::fmt::Display); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `assert_impl_all` - = note: this error originates in the macro `static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/std/enum_prefix.rs b/deps/crates/vendor/displaydoc-v0_2/tests/std/enum_prefix.rs deleted file mode 100644 index 7e6abcce8f6..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/std/enum_prefix.rs +++ /dev/null @@ -1,36 +0,0 @@ -#![cfg_attr(not(feature = "std"), feature(lang_items, start))] -#![cfg_attr(not(feature = "std"), no_std)] - -#[cfg_attr(not(feature = "std"), start)] -fn start(_argc: isize, _argv: *const *const u8) -> isize { - 0 -} -#[lang = "eh_personality"] -#[no_mangle] -#[cfg(not(feature = "std"))] -pub extern "C" fn rust_eh_personality() {} -#[panic_handler] -#[cfg(not(feature = "std"))] -fn panic(_info: &core::panic::PanicInfo) -> ! { - unsafe { - libc::abort(); - } -} - -use displaydoc::Display; - -/// this type is pretty swell -#[derive(Display)] -#[prefix_enum_doc_attributes] -enum TestType { - /// this variant is too - Variant1, - - /// this variant is two - Variant2, -} - -static_assertions::assert_impl_all!(TestType: core::fmt::Display); - -#[cfg(feature = "std")] -fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/std/enum_prefix_missing.rs b/deps/crates/vendor/displaydoc-v0_2/tests/std/enum_prefix_missing.rs deleted file mode 100644 index 45c312b7e25..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/std/enum_prefix_missing.rs +++ /dev/null @@ -1,35 +0,0 @@ -#![cfg_attr(not(feature = "std"), feature(lang_items, start))] -#![cfg_attr(not(feature = "std"), no_std)] - -#[cfg_attr(not(feature = "std"), start)] -fn start(_argc: isize, _argv: *const *const u8) -> isize { - 0 -} -#[lang = "eh_personality"] -#[no_mangle] -#[cfg(not(feature = "std"))] -pub extern "C" fn rust_eh_personality() {} -#[panic_handler] -#[cfg(not(feature = "std"))] -fn panic(_info: &core::panic::PanicInfo) -> ! { - unsafe { - libc::abort(); - } -} - -use displaydoc::Display; - -#[derive(Display)] -#[prefix_enum_doc_attributes] -enum TestType { - /// this variant is too - Variant1, - - /// this variant is two - Variant2, -} - -static_assertions::assert_impl_all!(TestType: core::fmt::Display); - -#[cfg(feature = "std")] -fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/std/enum_prefix_missing.stderr b/deps/crates/vendor/displaydoc-v0_2/tests/std/enum_prefix_missing.stderr deleted file mode 100644 index 09e1db68b4e..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/std/enum_prefix_missing.stderr +++ /dev/null @@ -1,22 +0,0 @@ -error: proc-macro derive panicked - --> $DIR/enum_prefix_missing.rs:22:10 - | -22 | #[derive(Display)] - | ^^^^^^^ - | - = help: message: Missing doc comment on enum with #[prefix_enum_doc_attributes]. Please remove the attribute or add a doc comment to the enum itself. - -error[E0277]: `TestType` doesn't implement `std::fmt::Display` - --> $DIR/enum_prefix_missing.rs:32:37 - | -32 | static_assertions::assert_impl_all!(TestType: core::fmt::Display); - | ^^^^^^^^ `TestType` cannot be formatted with the default formatter - | - = help: the trait `std::fmt::Display` is not implemented for `TestType` - = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead -note: required by a bound in `assert_impl_all` - --> $DIR/enum_prefix_missing.rs:32:1 - | -32 | static_assertions::assert_impl_all!(TestType: core::fmt::Display); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `assert_impl_all` - = note: this error originates in the macro `static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/std/multi_line.rs b/deps/crates/vendor/displaydoc-v0_2/tests/std/multi_line.rs deleted file mode 100644 index ca4215cdc3c..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/std/multi_line.rs +++ /dev/null @@ -1,37 +0,0 @@ -#![cfg_attr(not(feature = "std"), allow(internal_features), feature(lang_items, start))] -#![cfg_attr(not(feature = "std"), no_std)] - -#[cfg_attr(not(feature = "std"), start)] -fn start(_argc: isize, _argv: *const *const u8) -> isize { - 0 -} -#[lang = "eh_personality"] -#[no_mangle] -#[cfg(not(feature = "std"))] -pub extern "C" fn rust_eh_personality() {} -#[panic_handler] -#[cfg(not(feature = "std"))] -fn panic(_info: &core::panic::PanicInfo) -> ! { - unsafe { - libc::abort(); - } -} - -use displaydoc::Display; - -/// this type is pretty swell -#[derive(Display)] -enum TestType { - /// This one is okay - Variant1, - - /// Multi - /// line - /// doc. - Variant2, -} - -static_assertions::assert_impl_all!(TestType: core::fmt::Display); - -#[cfg(feature = "std")] -fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/std/multi_line.stderr b/deps/crates/vendor/displaydoc-v0_2/tests/std/multi_line.stderr deleted file mode 100644 index c36a75db2a1..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/std/multi_line.stderr +++ /dev/null @@ -1,22 +0,0 @@ -error: proc-macro derive panicked - --> $DIR/multi_line.rs:23:10 - | -23 | #[derive(Display)] - | ^^^^^^^ - | - = help: message: Multi-line comments are disabled by default by displaydoc. Please consider using block doc comments (/** */) or adding the #[ignore_extra_doc_attributes] attribute to your type next to the derive. - -error[E0277]: `TestType` doesn't implement `std::fmt::Display` - --> $DIR/multi_line.rs:34:37 - | -34 | static_assertions::assert_impl_all!(TestType: core::fmt::Display); - | ^^^^^^^^ `TestType` cannot be formatted with the default formatter - | - = help: the trait `std::fmt::Display` is not implemented for `TestType` - = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead -note: required by a bound in `assert_impl_all` - --> $DIR/multi_line.rs:34:1 - | -34 | static_assertions::assert_impl_all!(TestType: core::fmt::Display); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `assert_impl_all` - = note: this error originates in the macro `static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/std/multi_line_allow.rs b/deps/crates/vendor/displaydoc-v0_2/tests/std/multi_line_allow.rs deleted file mode 100644 index e09e8fcf2cc..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/std/multi_line_allow.rs +++ /dev/null @@ -1,38 +0,0 @@ -#![cfg_attr(not(feature = "std"), feature(lang_items, start))] -#![cfg_attr(not(feature = "std"), no_std)] - -#[cfg_attr(not(feature = "std"), start)] -fn start(_argc: isize, _argv: *const *const u8) -> isize { - 0 -} -#[lang = "eh_personality"] -#[no_mangle] -#[cfg(not(feature = "std"))] -pub extern "C" fn rust_eh_personality() {} -#[panic_handler] -#[cfg(not(feature = "std"))] -fn panic(_info: &core::panic::PanicInfo) -> ! { - unsafe { - libc::abort(); - } -} - -use displaydoc::Display; - -/// this type is pretty swell -#[derive(Display)] -#[ignore_extra_doc_attributes] -enum TestType { - /// This one is okay - Variant1, - - /// Multi - /// line - /// doc. - Variant2, -} - -static_assertions::assert_impl_all!(TestType: core::fmt::Display); - -#[cfg(feature = "std")] -fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/std/multiple.rs b/deps/crates/vendor/displaydoc-v0_2/tests/std/multiple.rs deleted file mode 100644 index 66d59b76903..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/std/multiple.rs +++ /dev/null @@ -1,38 +0,0 @@ -#![feature(lang_items, start)] -#![no_std] - -#[start] -#[cfg(not(feature = "std"))] -fn start(_argc: isize, _argv: *const *const u8) -> isize { - 0 -} - -#[lang = "eh_personality"] -#[no_mangle] -#[cfg(not(feature = "std"))] -pub extern "C" fn rust_eh_personality() {} - -#[panic_handler] -#[cfg(not(feature = "std"))] -fn panic(_info: &core::panic::PanicInfo) -> ! { - unsafe { - libc::abort(); - } -} - -#[cfg(feature = "std")] -fn main() {} - -use displaydoc::Display; - -/// this type is pretty swell -#[derive(Display)] -struct FakeType; - -static_assertions::assert_impl_all!(FakeType: core::fmt::Display); - -/// this type is pretty swell2 -#[derive(Display)] -struct FakeType2; - -static_assertions::assert_impl_all!(FakeType2: core::fmt::Display); diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/std/without.rs b/deps/crates/vendor/displaydoc-v0_2/tests/std/without.rs deleted file mode 100644 index 04d4b8fa695..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/std/without.rs +++ /dev/null @@ -1,28 +0,0 @@ -#![cfg_attr(not(feature = "std"), allow(internal_features), feature(lang_items, start))] -#![cfg_attr(not(feature = "std"), no_std)] - -#[cfg_attr(not(feature = "std"), start)] -fn start(_argc: isize, _argv: *const *const u8) -> isize { - 0 -} -#[lang = "eh_personality"] -#[no_mangle] -#[cfg(not(feature = "std"))] -pub extern "C" fn rust_eh_personality() {} -#[panic_handler] -#[cfg(not(feature = "std"))] -fn panic(_info: &core::panic::PanicInfo) -> ! { - unsafe { - libc::abort(); - } -} - -use displaydoc::Display; - -/// this type is pretty swell -struct FakeType; - -static_assertions::assert_impl_all!(FakeType: core::fmt::Display); - -#[cfg(feature = "std")] -fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/std/without.stderr b/deps/crates/vendor/displaydoc-v0_2/tests/std/without.stderr deleted file mode 100644 index 4f0d71316c9..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/tests/std/without.stderr +++ /dev/null @@ -1,22 +0,0 @@ -warning: unused import: `displaydoc::Display` - --> $DIR/without.rs:20:5 - | -20 | use displaydoc::Display; - | ^^^^^^^^^^^^^^^^^^^ - | - = note: `#[warn(unused_imports)]` on by default - -error[E0277]: `FakeType` doesn't implement `std::fmt::Display` - --> $DIR/without.rs:25:37 - | -25 | static_assertions::assert_impl_all!(FakeType: core::fmt::Display); - | ^^^^^^^^ `FakeType` cannot be formatted with the default formatter - | - = help: the trait `std::fmt::Display` is not implemented for `FakeType` - = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead -note: required by a bound in `assert_impl_all` - --> $DIR/without.rs:25:1 - | -25 | static_assertions::assert_impl_all!(FakeType: core::fmt::Display); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `assert_impl_all` - = note: this error originates in the macro `static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/ui/enum_prefix.rs b/deps/crates/vendor/displaydoc-v0_2/tests/ui/enum_prefix.rs new file mode 100644 index 00000000000..ba0dd702a46 --- /dev/null +++ b/deps/crates/vendor/displaydoc-v0_2/tests/ui/enum_prefix.rs @@ -0,0 +1,16 @@ +use displaydoc::Display; + +/// this type is pretty swell +#[derive(Display)] +#[prefix_enum_doc_attributes] +enum TestType { + /// this variant is too + Variant1, + + /// this variant is two + Variant2, +} + +static_assertions::assert_impl_all!(TestType: core::fmt::Display); + +fn main() {} \ No newline at end of file diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/ui/enum_prefix_missing.rs b/deps/crates/vendor/displaydoc-v0_2/tests/ui/enum_prefix_missing.rs new file mode 100644 index 00000000000..78301f97671 --- /dev/null +++ b/deps/crates/vendor/displaydoc-v0_2/tests/ui/enum_prefix_missing.rs @@ -0,0 +1,15 @@ +use displaydoc::Display; + +#[derive(Display)] +#[prefix_enum_doc_attributes] +enum TestType { + /// this variant is too + Variant1, + + /// this variant is two + Variant2, +} + +static_assertions::assert_impl_all!(TestType: core::fmt::Display); + +fn main() {} \ No newline at end of file diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/ui/multi_line.rs b/deps/crates/vendor/displaydoc-v0_2/tests/ui/multi_line.rs new file mode 100644 index 00000000000..dcb5ba5e823 --- /dev/null +++ b/deps/crates/vendor/displaydoc-v0_2/tests/ui/multi_line.rs @@ -0,0 +1,20 @@ +use displaydoc::Display; + +/// this type is pretty swell +#[derive(Display)] +enum TestType { + /// This one is okay + Variant1, + + /// Multi + /// line + /// doc + /// is + /// pretty + /// swell + Variant2, +} + +static_assertions::assert_impl_all!(TestType: core::fmt::Display); + +fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/ui/multi_line_allow.rs b/deps/crates/vendor/displaydoc-v0_2/tests/ui/multi_line_allow.rs new file mode 100644 index 00000000000..fb544cf9960 --- /dev/null +++ b/deps/crates/vendor/displaydoc-v0_2/tests/ui/multi_line_allow.rs @@ -0,0 +1,27 @@ +use displaydoc::Display; + +/// this type is pretty swell +#[derive(Display)] +#[ignore_extra_doc_attributes] +enum TestType { + /// This one is okay + Variant1, + + /// Multi + /// line + /// doc. + Variant2, + + /// Multi + /// line + /// doc + /// + /// with + /// line + /// breaks + Variant3, +} + +static_assertions::assert_impl_all!(TestType: core::fmt::Display); + +fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/ui/multi_line_line_break.rs b/deps/crates/vendor/displaydoc-v0_2/tests/ui/multi_line_line_break.rs new file mode 100644 index 00000000000..503a2db7b66 --- /dev/null +++ b/deps/crates/vendor/displaydoc-v0_2/tests/ui/multi_line_line_break.rs @@ -0,0 +1,20 @@ +use displaydoc::Display; + +#[derive(Display)] +/// Multi +/// line +/// doc +/// with +/// line +/// break +/// +/// is +/// pretty +/// not +/// swell +/// 😞👊 +struct TestType; + +static_assertions::assert_impl_all!(TestType: core::fmt::Display); + +fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/ui/multi_line_line_break_block.rs b/deps/crates/vendor/displaydoc-v0_2/tests/ui/multi_line_line_break_block.rs new file mode 100644 index 00000000000..a79d96bd285 --- /dev/null +++ b/deps/crates/vendor/displaydoc-v0_2/tests/ui/multi_line_line_break_block.rs @@ -0,0 +1,14 @@ +use displaydoc::Display; + +#[derive(Display)] +/** + * block + */ +/** + * + */ +struct TestType; + +static_assertions::assert_impl_all!(TestType: core::fmt::Display); + +fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/ui/multiple.rs b/deps/crates/vendor/displaydoc-v0_2/tests/ui/multiple.rs new file mode 100644 index 00000000000..d0489064010 --- /dev/null +++ b/deps/crates/vendor/displaydoc-v0_2/tests/ui/multiple.rs @@ -0,0 +1,15 @@ +use displaydoc::Display; + +/// this type is pretty swell +#[derive(Display)] +struct FakeType; + +static_assertions::assert_impl_all!(FakeType: core::fmt::Display); + +/// this type is pretty swell2 +#[derive(Display)] +struct FakeType2; + +static_assertions::assert_impl_all!(FakeType2: core::fmt::Display); + +fn main() {} \ No newline at end of file diff --git a/deps/crates/vendor/displaydoc-v0_2/tests/ui/without.rs b/deps/crates/vendor/displaydoc-v0_2/tests/ui/without.rs new file mode 100644 index 00000000000..1aa85e13467 --- /dev/null +++ b/deps/crates/vendor/displaydoc-v0_2/tests/ui/without.rs @@ -0,0 +1,8 @@ +use displaydoc::Display; + +/// this type is pretty swell +struct FakeType; + +static_assertions::assert_impl_all!(FakeType: core::fmt::Display); + +fn main() {} diff --git a/deps/crates/vendor/displaydoc-v0_2/update-readme.sh b/deps/crates/vendor/displaydoc-v0_2/update-readme.sh deleted file mode 100755 index f67bfd566b6..00000000000 --- a/deps/crates/vendor/displaydoc-v0_2/update-readme.sh +++ /dev/null @@ -1,5 +0,0 @@ -#! /usr/bin/env bash - -cargo readme > ./README.md -git add ./README.md -git commit -m "Update readme" || true diff --git a/deps/crates/vendor/either-v1/.cargo_vcs_info.json b/deps/crates/vendor/either-v1/.cargo_vcs_info.json index 1cca00e9368..148bd94dd5b 100644 --- a/deps/crates/vendor/either-v1/.cargo_vcs_info.json +++ b/deps/crates/vendor/either-v1/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "59ae1fce0cec62c886fcd486e06b7e219bc7ce48" + "sha1": "8f4ecd9964ea909a7f989a3668a2710310a0e62f" }, "path_in_vcs": "" } \ No newline at end of file diff --git a/deps/crates/vendor/either-v1/.github/workflows/ci.yml b/deps/crates/vendor/either-v1/.github/workflows/ci.yml index 2f3843b7a2e..1c6dbb0a5e3 100644 --- a/deps/crates/vendor/either-v1/.github/workflows/ci.yml +++ b/deps/crates/vendor/either-v1/.github/workflows/ci.yml @@ -32,6 +32,13 @@ jobs: path: ~/.cargo/registry/index key: cargo-${{ matrix.rust }}-git-index + - name: Lock MSRV-compatible dependencies + if: startsWith(matrix.rust, '1') + env: + CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS: fallback + # Note that this uses the runner's pre-installed stable cargo + run: cargo generate-lockfile + - name: Set up Rust uses: dtolnay/rust-toolchain@master with: diff --git a/deps/crates/vendor/either-v1/Cargo.lock b/deps/crates/vendor/either-v1/Cargo.lock index 3c336a9a934..3064f8b7e5c 100644 --- a/deps/crates/vendor/either-v1/Cargo.lock +++ b/deps/crates/vendor/either-v1/Cargo.lock @@ -4,7 +4,7 @@ version = 3 [[package]] name = "either" -version = "1.15.0" +version = "1.16.0" dependencies = [ "serde", "serde_json", @@ -12,54 +12,48 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.15" +version = "1.0.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" - -[[package]] -name = "memchr" -version = "2.7.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" +checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c" [[package]] name = "proc-macro2" -version = "1.0.94" +version = "1.0.71" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84" +checksum = "75cb1540fadbd5b8fbccc4dddad2734eba435053f725621c070711a14bb5f4b8" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.39" +version = "1.0.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1f1914ce909e1658d9907913b4b91947430c7d9be598b15a1912935b8c04801" +checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" dependencies = [ "proc-macro2", ] [[package]] name = "ryu" -version = "1.0.20" +version = "1.0.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" +checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c" [[package]] name = "serde" -version = "1.0.218" +version = "1.0.193" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8dfc9d19bdbf6d17e22319da49161d5d0108e4188e8b680aef6299eed22df60" +checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.218" +version = "1.0.193" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f09503e191f4e797cb8aac08e9a4a4695c5edf6a2e70e376d961ddd5c969f82b" +checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3" dependencies = [ "proc-macro2", "quote", @@ -68,21 +62,20 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.140" +version = "1.0.108" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373" +checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b" dependencies = [ "itoa", - "memchr", "ryu", "serde", ] [[package]] name = "syn" -version = "2.0.99" +version = "2.0.43" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e02e925281e18ffd9d640e234264753c43edc62d64b2d4cf898f1bc5e75f3fc2" +checksum = "ee659fb5f3d355364e1f3e5bc10fb82068efbf824a1e9d1c9504244a6469ad53" dependencies = [ "proc-macro2", "quote", @@ -91,6 +84,6 @@ dependencies = [ [[package]] name = "unicode-ident" -version = "1.0.18" +version = "1.0.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" +checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" diff --git a/deps/crates/vendor/either-v1/Cargo.toml b/deps/crates/vendor/either-v1/Cargo.toml index 68b38fd8097..15de8104b8b 100644 --- a/deps/crates/vendor/either-v1/Cargo.toml +++ b/deps/crates/vendor/either-v1/Cargo.toml @@ -13,8 +13,7 @@ edition = "2021" rust-version = "1.63.0" name = "either" -version = "1.15.0" -authors = ["bluss"] +version = "1.16.0" build = false autolib = false autobins = false @@ -37,17 +36,17 @@ categories = [ license = "MIT OR Apache-2.0" repository = "https://github.com/rayon-rs/either" +[package.metadata.release] +allow-branch = ["main"] +sign-tag = true +tag-name = "{{version}}" + [package.metadata.docs.rs] features = ["serde"] [package.metadata.playground] features = ["serde"] -[package.metadata.release] -allow-branch = ["main"] -sign-tag = true -tag-name = "{{version}}" - [features] default = ["std"] std = [] diff --git a/deps/crates/vendor/either-v1/Cargo.toml.orig b/deps/crates/vendor/either-v1/Cargo.toml.orig index 1d17f73cc4d..fc46d174ece 100644 --- a/deps/crates/vendor/either-v1/Cargo.toml.orig +++ b/deps/crates/vendor/either-v1/Cargo.toml.orig @@ -1,7 +1,6 @@ [package] name = "either" -version = "1.15.0" -authors = ["bluss"] +version = "1.16.0" edition = "2021" rust-version = "1.63.0" diff --git a/deps/crates/vendor/either-v1/README.rst b/deps/crates/vendor/either-v1/README.rst index 7665f1ff0dd..10f392a75b9 100644 --- a/deps/crates/vendor/either-v1/README.rst +++ b/deps/crates/vendor/either-v1/README.rst @@ -31,6 +31,22 @@ How to use with cargo:: Recent Changes -------------- +- 1.16.0 + + - Add many new methods dealing with each side, by @A4-Tacks: + + - ``inspect_left`` and ``inspect_right`` (#124) + + - ``left_and`` and ``right_and`` (#125) + + - ``is_left_and`` and ``is_right_and`` (#126) + + - ``map_left_or`` and ``map_right_or`` (#127) + + - Add a version of ``for_both!`` with a single ``ident``, by @A4-Tacks (#128) + + - Add a ``map_both!`` macro, by @JohnScience (#109) and @ronnodas (#137) + - 1.15.0 - Fix ``serde`` support when building without ``std``, by @klkvr (#119) diff --git a/deps/crates/vendor/either-v1/src/iterator.rs b/deps/crates/vendor/either-v1/src/iterator.rs index d54fab793d9..a5535f0530c 100644 --- a/deps/crates/vendor/either-v1/src/iterator.rs +++ b/deps/crates/vendor/either-v1/src/iterator.rs @@ -1,4 +1,4 @@ -use super::{for_both, Either, Left, Right}; +use super::{Either, Left, Right}; use core::iter; macro_rules! wrap_either { @@ -185,7 +185,7 @@ where type Item = Either; fn next(&mut self) -> Option { - Some(map_either!(self.inner, ref mut inner => inner.next()?)) + Some(map_both!(self.inner, ref mut inner => inner.next()?)) } fn size_hint(&self) -> (usize, Option) { @@ -211,11 +211,11 @@ where } fn last(self) -> Option { - Some(map_either!(self.inner, inner => inner.last()?)) + Some(map_both!(self.inner, inner => inner.last()?)) } fn nth(&mut self, n: usize) -> Option { - Some(map_either!(self.inner, ref mut inner => inner.nth(n)?)) + Some(map_both!(self.inner, ref mut inner => inner.nth(n)?)) } fn collect(self) -> B @@ -275,11 +275,11 @@ where R: DoubleEndedIterator, { fn next_back(&mut self) -> Option { - Some(map_either!(self.inner, ref mut inner => inner.next_back()?)) + Some(map_both!(self.inner, ref mut inner => inner.next_back()?)) } fn nth_back(&mut self, n: usize) -> Option { - Some(map_either!(self.inner, ref mut inner => inner.nth_back(n)?)) + Some(map_both!(self.inner, ref mut inner => inner.nth_back(n)?)) } fn rfold(self, init: Acc, f: G) -> Acc diff --git a/deps/crates/vendor/either-v1/src/lib.rs b/deps/crates/vendor/either-v1/src/lib.rs index e2265eb7104..ec16cee0019 100644 --- a/deps/crates/vendor/either-v1/src/lib.rs +++ b/deps/crates/vendor/either-v1/src/lib.rs @@ -58,7 +58,12 @@ pub enum Either { /// This macro is useful in cases where both sides of [`Either`] can be interacted with /// in the same way even though the don't share the same type. /// -/// Syntax: `either::for_both!(` *expression* `,` *pattern* `=>` *expression* `)` +/// Syntax: +/// +/// - `either::for_both!(` *expression* `,` *pattern* `=>` *expression* `)` +/// - `either::for_both!(` *ident* `=>` *expression* `)` +/// +/// Unlike [`map_both!`], this macro converges both variants to the type returned by the expression. /// /// # Example /// @@ -77,6 +82,22 @@ pub enum Either { /// assert_eq!(length(owned), 12); /// } /// ``` +/// +/// ``` +/// use either::Either; +/// +/// fn length(s: Either>) -> usize { +/// either::for_both!(s => s.len()) +/// } +/// +/// fn main() { +/// let string = Either::Left("Hello world!".to_owned()); +/// let bytes = Either::Right(b"Hello world!".to_vec()); +/// +/// assert_eq!(length(string), 12); +/// assert_eq!(length(bytes), 12); +/// } +/// ``` #[macro_export] macro_rules! for_both { ($value:expr, $pattern:pat => $result:expr) => { @@ -85,6 +106,59 @@ macro_rules! for_both { $crate::Either::Right($pattern) => $result, } }; + ($name:ident => $result:expr) => { + match $name { + $crate::Either::Left($name) => $result, + $crate::Either::Right($name) => $result, + } + }; +} + +/// Evaluate the provided expression for both [`Either::Left`] and [`Either::Right`], +/// returning an [`Either`] with the results. +/// +/// This macro is useful in cases where both sides of [`Either`] can be interacted with +/// in the same way even though the don't share the same type. +/// +/// Syntax: `either::map_both!(` *expression* `,` *pattern* `=>` *expression* `)` +/// +/// Unlike [`for_both!`], this macro returns an [`Either`] with the results of the expressions. +/// +/// # Example +/// +/// ``` +/// use either::Either; +/// +/// struct Wrapper(T); +/// +/// fn wrap( +/// owned_or_borrowed: Either, +/// ) -> Either, Wrapper<&'static str>> { +/// either::map_both!(owned_or_borrowed, s => Wrapper(s)) +/// } +/// ``` +/// +/// ``` +/// use either::Either; +/// +/// fn widen(x: Either) -> Either { +/// either::map_both!(x => x.into()) +/// } +/// ``` +#[macro_export] +macro_rules! map_both { + ($value:expr, $pattern:pat => $result:expr) => { + match $value { + $crate::Either::Left($pattern) => $crate::Either::Left($result), + $crate::Either::Right($pattern) => $crate::Either::Right($result), + } + }; + ($name:ident => $result:expr) => { + match $name { + $crate::Either::Left($name) => $crate::Either::Left($result), + $crate::Either::Right($name) => $crate::Either::Right($result), + } + }; } /// Macro for unwrapping the left side of an [`Either`], which fails early @@ -130,15 +204,6 @@ macro_rules! try_right { }; } -macro_rules! map_either { - ($value:expr, $pattern:pat => $result:expr) => { - match $value { - Left($pattern) => Left($result), - Right($pattern) => Right($result), - } - }; -} - mod iterator; pub use self::iterator::IterEither; @@ -179,6 +244,56 @@ impl Either { } } + /// Returns `true` if the value is [`Left`] and the value inside of it matches a predicate. + /// + /// # Examples + /// + /// ``` + /// use either::*; + /// + /// let left0: Either = Left(0); + /// let left2: Either = Left(2); + /// let right: Either = Right(2); + /// + /// assert_eq!(left2.is_left_and(|n| n > 1), true); + /// assert_eq!(left0.is_left_and(|n| n > 1), false); + /// assert_eq!(right.is_left_and(|n| n > 1), false); + /// ``` + pub fn is_left_and(self, f: F) -> bool + where + F: FnOnce(L) -> bool, + { + match self { + Left(left) => f(left), + Right(_) => false, + } + } + + /// Returns `true` if the value is [`Right`] and the value inside of it matches a predicate. + /// + /// # Examples + /// + /// ``` + /// use either::*; + /// + /// let right0: Either = Right(0); + /// let right2: Either = Right(2); + /// let left: Either = Left(2); + /// + /// assert_eq!(right2.is_right_and(|n| n > 1), true); + /// assert_eq!(right0.is_right_and(|n| n > 1), false); + /// assert_eq!(left.is_right_and(|n| n > 1), false); + /// ``` + pub fn is_right_and(self, f: F) -> bool + where + F: FnOnce(R) -> bool, + { + match self { + Left(_) => false, + Right(right) => f(right), + } + } + /// Return true if the value is the `Right` variant. /// /// ``` @@ -240,7 +355,7 @@ impl Either { /// assert_eq!(right.as_ref(), Right(&"some value")); /// ``` pub fn as_ref(&self) -> Either<&L, &R> { - map_either!(self, inner => inner) + map_both!(self, inner => inner) } /// Convert `&mut Either` to `Either<&mut L, &mut R>`. @@ -262,7 +377,7 @@ impl Either { /// assert_eq!(right, Right(123)); /// ``` pub fn as_mut(&mut self) -> Either<&mut L, &mut R> { - map_either!(self, inner => inner) + map_both!(self, inner => inner) } /// Convert `Pin<&Either>` to `Either, Pin<&R>>`, @@ -270,7 +385,7 @@ impl Either { pub fn as_pin_ref(self: Pin<&Self>) -> Either, Pin<&R>> { // SAFETY: We can use `new_unchecked` because the `inner` parts are // guaranteed to be pinned, as they come from `self` which is pinned. - unsafe { map_either!(Pin::get_ref(self), inner => Pin::new_unchecked(inner)) } + unsafe { map_both!(Pin::get_ref(self), inner => Pin::new_unchecked(inner)) } } /// Convert `Pin<&mut Either>` to `Either, Pin<&mut R>>`, @@ -281,7 +396,7 @@ impl Either { // to be pinned, as they come from `self` which is pinned, and we never // offer an unpinned `&mut L` or `&mut R` through `Pin<&mut Self>`. We // also don't have an implementation of `Drop`, nor manual `Unpin`. - unsafe { map_either!(Pin::get_unchecked_mut(self), inner => Pin::new_unchecked(inner)) } + unsafe { map_both!(Pin::get_unchecked_mut(self), inner => Pin::new_unchecked(inner)) } } /// Convert `Either` to `Either`. @@ -346,6 +461,54 @@ impl Either { } } + /// Returns the provided default (if [`Right`]), or + /// applies a function to the contained value (if [`Left`]). + /// + /// # Examples + /// + /// ``` + /// use either::*; + /// + /// let x: Either<_, i32> = Left(123); + /// assert_eq!(x.map_left_or(0, |n| n * 2), 246); + /// + /// let x: Either = Right(123); + /// assert_eq!(x.map_left_or(0, |n| n * 2), 0); + /// ``` + pub fn map_left_or(self, default: S, f: F) -> S + where + F: FnOnce(L) -> S, + { + match self { + Left(left) => f(left), + Right(_) => default, + } + } + + /// Returns the provided default (if [`Left`]), or + /// applies a function to the contained value (if [`Right`]). + /// + /// # Examples + /// + /// ``` + /// use either::*; + /// + /// let x: Either<_, i32> = Left(123); + /// assert_eq!(x.map_right_or(0, |n| n * 2), 0); + /// + /// let x: Either = Right(123); + /// assert_eq!(x.map_right_or(0, |n| n * 2), 246); + /// ``` + pub fn map_right_or(self, default: S, f: F) -> S + where + F: FnOnce(R) -> S, + { + match self { + Left(_) => default, + Right(right) => f(right), + } + } + /// Apply the functions `f` and `g` to the `Left` and `Right` variants /// respectively. This is equivalent to /// [bimap](https://hackage.haskell.org/package/bifunctors-5/docs/Data-Bifunctor.html) @@ -462,6 +625,62 @@ impl Either { } } + /// Returns `other` if the value is [`Left`], otherwise returns the [`Right`] value of `self`. + /// + /// Arguments passed to `left_and` are eagerly evaluated; if you are passing the + /// result of a function call, it is recommended to use [`left_and_then`], which is + /// lazily evaluated. + /// + /// [`left_and_then`]: Either::left_and_then + /// + /// # Examples + /// + /// ``` + /// use either::*; + /// + /// let left: Either<_, u32> = Left(123); + /// assert_eq!(left.left_and::<()>(Right(246)), Right(246)); + /// assert_eq!(left.left_and(Left(246)), Left(246)); + /// + /// let right: Either = Right(123); + /// assert_eq!(right.left_and::<()>(Right(246)), Right(123)); + /// assert_eq!(right.left_and(Left(246)), Right(123)); + /// ``` + pub fn left_and(self, other: Either) -> Either { + match self { + Left(_) => other, + Right(r) => Right(r), + } + } + + /// Returns `other` if the value is [`Right`], otherwise returns the [`Left`] value of `self`. + /// + /// Arguments passed to `right_and` are eagerly evaluated; if you are passing the + /// result of a function call, it is recommended to use [`right_and_then`], which is + /// lazily evaluated. + /// + /// [`right_and_then`]: Either::right_and_then + /// + /// # Examples + /// + /// ``` + /// use either::*; + /// + /// let left: Either<_, u32> = Left(123); + /// assert_eq!(left.right_and(Right(246)), Left(123)); + /// assert_eq!(left.right_and::<()>(Left(246)), Left(123)); + /// + /// let right: Either = Right(123); + /// assert_eq!(right.right_and(Right(246)), Right(246)); + /// assert_eq!(right.right_and::<()>(Left(246)), Left(246)); + /// ``` + pub fn right_and(self, other: Either) -> Either { + match self { + Left(l) => Left(l), + Right(_) => other, + } + } + /// Apply the function `f` on the value in the `Left` variant if it is present. /// /// ``` @@ -523,7 +742,7 @@ impl Either { L: IntoIterator, R: IntoIterator, { - map_either!(self, inner => inner.into_iter()) + map_both!(self, inner => inner.into_iter()) } /// Borrow the inner value as an iterator. @@ -546,7 +765,7 @@ impl Either { for<'a> &'a L: IntoIterator, for<'a> &'a R: IntoIterator::Item>, { - map_either!(self, inner => inner.into_iter()) + map_both!(self, inner => inner.into_iter()) } /// Mutably borrow the inner value as an iterator. @@ -577,7 +796,7 @@ impl Either { for<'a> &'a mut L: IntoIterator, for<'a> &'a mut R: IntoIterator::Item>, { - map_either!(self, inner => inner.into_iter()) + map_both!(self, inner => inner.into_iter()) } /// Converts an `Either` of `Iterator`s to be an `Iterator` of `Either`s @@ -594,14 +813,12 @@ impl Either { /// assert_eq!(right.factor_into_iter().collect::>(), vec![Right(0), Right(1)]); /// /// ``` - // TODO(MSRV): doc(alias) was stabilized in Rust 1.48 - // #[doc(alias = "transpose")] pub fn factor_into_iter(self) -> IterEither where L: IntoIterator, R: IntoIterator, { - IterEither::new(map_either!(self, inner => inner.into_iter())) + IterEither::new(map_both!(self, inner => inner.into_iter())) } /// Borrows an `Either` of `Iterator`s to be an `Iterator` of `Either`s @@ -625,7 +842,7 @@ impl Either { for<'a> &'a L: IntoIterator, for<'a> &'a R: IntoIterator, { - IterEither::new(map_either!(self, inner => inner.into_iter())) + IterEither::new(map_both!(self, inner => inner.into_iter())) } /// Mutably borrows an `Either` of `Iterator`s to be an `Iterator` of `Either`s @@ -651,7 +868,7 @@ impl Either { for<'a> &'a mut L: IntoIterator, for<'a> &'a mut R: IntoIterator, { - IterEither::new(map_either!(self, inner => inner.into_iter())) + IterEither::new(map_both!(self, inner => inner.into_iter())) } /// Return left value or given value @@ -807,6 +1024,7 @@ impl Either { /// let right: Either<(), _> = Right(3); /// right.unwrap_left(); /// ``` + #[track_caller] pub fn unwrap_left(self) -> L where R: core::fmt::Debug, @@ -838,6 +1056,7 @@ impl Either { /// let left: Either<_, ()> = Left(3); /// left.unwrap_right(); /// ``` + #[track_caller] pub fn unwrap_right(self) -> R where L: core::fmt::Debug, @@ -867,6 +1086,7 @@ impl Either { /// let right: Either<(), _> = Right(3); /// right.expect_left("value was Right"); /// ``` + #[track_caller] pub fn expect_left(self, msg: &str) -> L where R: core::fmt::Debug, @@ -896,6 +1116,7 @@ impl Either { /// let left: Either<_, ()> = Left(3); /// left.expect_right("value was Right"); /// ``` + #[track_caller] pub fn expect_right(self, msg: &str) -> R where L: core::fmt::Debug, @@ -906,6 +1127,56 @@ impl Either { } } + /// Calls a function with a reference to the contained value if [`Left`]. + /// + /// Returns the original self. + /// + /// # Examples + /// + /// ``` + /// use either::*; + /// + /// # fn foo() -> Either { Right(2) } + /// let x = foo() + /// .inspect_left(|n| println!("left: {n}")) + /// .left_or(0); + /// ``` + pub fn inspect_left(self, f: F) -> Self + where + F: FnOnce(&L), + { + if let Left(ref left) = self { + f(left); + } + + self + } + + /// Calls a function with a reference to the contained value if [`Right`]. + /// + /// Returns the original self. + /// + /// # Examples + /// + /// ``` + /// use either::*; + /// + /// # fn foo() -> Either { Right(2) } + /// let x = foo() + /// .inspect_right(|n| println!("right: {n}")) + /// .left_or(0); + /// ``` + pub fn inspect_right(self, f: F) -> Self + where + F: FnOnce(&R), + { + if let Right(ref right) = self { + f(right); + } + + self + } + /// Convert the contained value into `T` /// /// # Examples @@ -938,8 +1209,7 @@ impl Either, Option> { /// let right: Either>, _> = Right(Some(String::new())); /// assert_eq!(right.factor_none(), Some(Right(String::new()))); /// ``` - // TODO(MSRV): doc(alias) was stabilized in Rust 1.48 - // #[doc(alias = "transpose")] + #[doc(alias = "transpose")] pub fn factor_none(self) -> Option> { match self { Left(l) => l.map(Either::Left), @@ -949,7 +1219,7 @@ impl Either, Option> { } impl Either, Result> { - /// Factors out a homogenous type from an `Either` of [`Result`]. + /// Factors out a homogeneous type from an `Either` of [`Result`]. /// /// Here, the homogeneous type is the `Err` type of the [`Result`]. /// @@ -961,8 +1231,7 @@ impl Either, Result> { /// let right: Either, u32>, _> = Right(Ok(String::new())); /// assert_eq!(right.factor_err(), Ok(Right(String::new()))); /// ``` - // TODO(MSRV): doc(alias) was stabilized in Rust 1.48 - // #[doc(alias = "transpose")] + #[doc(alias = "transpose")] pub fn factor_err(self) -> Result, E> { match self { Left(l) => l.map(Either::Left), @@ -972,7 +1241,7 @@ impl Either, Result> { } impl Either, Result> { - /// Factors out a homogenous type from an `Either` of [`Result`]. + /// Factors out a homogeneous type from an `Either` of [`Result`]. /// /// Here, the homogeneous type is the `Ok` type of the [`Result`]. /// @@ -984,8 +1253,7 @@ impl Either, Result> { /// let right: Either>, _> = Right(Err(String::new())); /// assert_eq!(right.factor_ok(), Err(Right(String::new()))); /// ``` - // TODO(MSRV): doc(alias) was stabilized in Rust 1.48 - // #[doc(alias = "transpose")] + #[doc(alias = "transpose")] pub fn factor_ok(self) -> Result> { match self { Left(l) => l.map_err(Either::Left), @@ -1067,10 +1335,7 @@ impl Either { where F: FnOnce(T) -> M, { - match self { - Left(l) => Left(f(l)), - Right(r) => Right(f(r)), - } + map_both!(self, t => f(t)) } } @@ -1082,7 +1347,7 @@ impl Either<&L, &R> { L: Clone, R: Clone, { - map_either!(self, inner => inner.clone()) + map_both!(self, inner => inner.clone()) } /// Maps an `Either<&L, &R>` to an `Either` by copying the contents of @@ -1092,7 +1357,7 @@ impl Either<&L, &R> { L: Copy, R: Copy, { - map_either!(self, inner => *inner) + map_both!(self, inner => *inner) } } @@ -1104,7 +1369,7 @@ impl Either<&mut L, &mut R> { L: Clone, R: Clone, { - map_either!(self, inner => inner.clone()) + map_both!(self, inner => inner.clone()) } /// Maps an `Either<&mut L, &mut R>` to an `Either` by copying the contents of @@ -1114,7 +1379,7 @@ impl Either<&mut L, &mut R> { L: Copy, R: Copy, { - map_either!(self, inner => *inner) + map_both!(self, inner => *inner) } } diff --git a/deps/crates/vendor/either-v1/src/serde_untagged.rs b/deps/crates/vendor/either-v1/src/serde_untagged.rs index 72078c3ec8e..d62dd7d0654 100644 --- a/deps/crates/vendor/either-v1/src/serde_untagged.rs +++ b/deps/crates/vendor/either-v1/src/serde_untagged.rs @@ -1,9 +1,9 @@ -//! Untagged serialization/deserialization support for Either. +//! Untagged serialization/deserialization support for `Either`. //! //! `Either` uses default, externally-tagged representation. //! However, sometimes it is useful to support several alternative types. -//! For example, we may have a field which is generally Map -//! but in typical cases Vec would suffice, too. +//! For example, we may have a field which is generally a `HashMap` +//! but in typical cases `Vec` would suffice, too. //! //! ```rust //! # fn main() -> Result<(), Box> { diff --git a/deps/crates/vendor/either-v1/src/serde_untagged_optional.rs b/deps/crates/vendor/either-v1/src/serde_untagged_optional.rs index fb3239ace1d..d1316935c4d 100644 --- a/deps/crates/vendor/either-v1/src/serde_untagged_optional.rs +++ b/deps/crates/vendor/either-v1/src/serde_untagged_optional.rs @@ -1,9 +1,9 @@ -//! Untagged serialization/deserialization support for Option>. +//! Untagged serialization/deserialization support for `Option>`. //! //! `Either` uses default, externally-tagged representation. //! However, sometimes it is useful to support several alternative types. -//! For example, we may have a field which is generally Map -//! but in typical cases Vec would suffice, too. +//! For example, we may have a field which is generally a `HashMap` +//! but in typical cases `Vec` would suffice, too. //! //! ```rust //! # fn main() -> Result<(), Box> { diff --git a/deps/crates/vendor/icu_locale_core-v2/src/extensions/mod.rs b/deps/crates/vendor/icu_locale_core-v2/src/extensions/mod.rs index 72ae65d44e6..47b2b81c457 100644 --- a/deps/crates/vendor/icu_locale_core-v2/src/extensions/mod.rs +++ b/deps/crates/vendor/icu_locale_core-v2/src/extensions/mod.rs @@ -11,7 +11,7 @@ //! * [`Unicode Extensions`] - marked as `u`. //! * [`Transform Extensions`] - marked as `t`. //! * [`Private Use Extensions`] - marked as `x`. -//! * [`Other Extensions`] - marked as any `a-z` except of `u`, `t` and `x`. +//! * [`Other Extensions`] - marked as any `a-z` or `0-9` except `u`, `t`, and `x`. //! //! One can think of extensions as a bag of extra information on top of basic 4 [`subtags`]. //! @@ -102,7 +102,7 @@ impl ExtensionType { UNICODE_EXT_CHAR => Ok(Self::Unicode), TRANSFORM_EXT_CHAR => Ok(Self::Transform), PRIVATE_EXT_CHAR => Ok(Self::Private), - 'a'..='z' => Ok(Self::Other(key)), + 'a'..='z' | '0'..='9' => Ok(Self::Other(key)), _ => Err(ParseError::InvalidExtension), } } @@ -397,4 +397,12 @@ fn test_writeable() { .extensions, "a-foo-t-foo-u-foo-w-foo-z-foo-x-foo", ); + assert_writeable_eq!( + "en-1-ext-value".parse::().unwrap().extensions, + "1-ext-value", + ); + assert_writeable_eq!( + "und-a-foo-1-bar".parse::().unwrap().extensions, + "1-bar-a-foo", + ); } diff --git a/deps/crates/vendor/icu_locale_core-v2/src/extensions/other/mod.rs b/deps/crates/vendor/icu_locale_core-v2/src/extensions/other/mod.rs index 8934c4dff76..51e2495751f 100644 --- a/deps/crates/vendor/icu_locale_core-v2/src/extensions/other/mod.rs +++ b/deps/crates/vendor/icu_locale_core-v2/src/extensions/other/mod.rs @@ -93,7 +93,7 @@ impl Other { /// /// # Panics /// - /// Panics if `ext` is not ASCII alphabetic. + /// Panics if `ext` is not ASCII alphanumeric. /// /// # Examples /// @@ -114,7 +114,7 @@ impl Other { #[allow(dead_code)] pub(crate) fn from_short_slice_unchecked(ext: u8, keys: ShortBoxSlice) -> Self { - assert!(ext.is_ascii_alphabetic()); + assert!(ext.is_ascii_alphanumeric()); // Safety invariant upheld here: ext checked as ASCII above Self { ext, keys } } @@ -156,7 +156,7 @@ impl Other { /// assert_eq!(other_ext.get_ext_str(), "a"); /// ``` pub fn get_ext_str(&self) -> &str { - debug_assert!(self.ext.is_ascii_alphabetic()); + debug_assert!(self.ext.is_ascii_alphanumeric()); // Safety: from safety invariant on self.ext (that it is ASCII) unsafe { core::str::from_utf8_unchecked(core::slice::from_ref(&self.ext)) } } @@ -254,6 +254,9 @@ mod tests { let oe: Other = "o-foo-bar".parse().expect("Failed to parse Other"); assert_eq!(oe.to_string(), "o-foo-bar"); + let oe: Other = "1-foo-bar".parse().expect("Failed to parse Other"); + assert_eq!(oe.to_string(), "1-foo-bar"); + let oe: Result = "o".parse(); assert!(oe.is_err()); } diff --git a/deps/crates/vendor/icu_locale_core-v2/tests/fixtures/locale.json b/deps/crates/vendor/icu_locale_core-v2/tests/fixtures/locale.json index 93679a0667b..c55f5e7ae56 100644 --- a/deps/crates/vendor/icu_locale_core-v2/tests/fixtures/locale.json +++ b/deps/crates/vendor/icu_locale_core-v2/tests/fixtures/locale.json @@ -294,5 +294,38 @@ "type": "Locale", "identifier": "en-a-bar-u-foo-w-bar-x-u-foo" } + }, + { + "input": { + "type": "Locale", + "identifier": "en-1-ext-value" + }, + "output": { + "type": "Locale", + "language": "en", + "extensions": { + "other": ["1-ext-value"] + } + } + }, + { + "input": { + "type": "Locale", + "identifier": "en-w-bar-1-foo" + }, + "output": { + "type": "Locale", + "identifier": "en-1-foo-w-bar" + } + }, + { + "input": { + "type": "Locale", + "identifier": "en-w-bar-1-foo-u-baz" + }, + "output": { + "type": "Locale", + "identifier": "en-1-foo-u-baz-w-bar" + } } ] diff --git a/deps/crates/vendor/icu_locale_core-v2/tests/fixtures/mod.rs b/deps/crates/vendor/icu_locale_core-v2/tests/fixtures/mod.rs index dd89ce86ff6..8867f34312a 100644 --- a/deps/crates/vendor/icu_locale_core-v2/tests/fixtures/mod.rs +++ b/deps/crates/vendor/icu_locale_core-v2/tests/fixtures/mod.rs @@ -5,6 +5,7 @@ use std::collections::HashMap; use std::convert::{TryFrom, TryInto}; +use icu_locale_core::extensions::other; use icu_locale_core::extensions::private; use icu_locale_core::extensions::transform; use icu_locale_core::extensions::unicode; @@ -40,7 +41,8 @@ pub struct LocaleExtensions { transform: Option, #[serde(default)] private: Vec, - _other: Option, + #[serde(default)] + other: Vec, } impl TryFrom for Extensions { @@ -95,6 +97,13 @@ impl TryFrom for Extensions { .map(|v| private::Subtag::try_from_str(v).expect("Failed to add field.")) .collect(); ext.private = private::Private::from_vec_unchecked(v); + let mut other: Vec = input + .other + .iter() + .map(|v| other::Other::try_from_str(v).expect("Failed to parse Other extension")) + .collect(); + other.sort(); + ext.other = other; Ok(ext) } } diff --git a/deps/crates/vendor/icu_locale_core-v2/tests/locale.rs b/deps/crates/vendor/icu_locale_core-v2/tests/locale.rs index 5a700bcc724..ddea6144298 100644 --- a/deps/crates/vendor/icu_locale_core-v2/tests/locale.rs +++ b/deps/crates/vendor/icu_locale_core-v2/tests/locale.rs @@ -117,3 +117,18 @@ fn test_locale_strict_cmp() { } } } + +#[test] +fn test_locale_total_cmp() { + let l_1_bar = "und-1-bar".parse::().unwrap(); + let l_a_foo = "und-a-foo".parse::().unwrap(); + let l_2_baz = "und-2-baz".parse::().unwrap(); + + assert_eq!(l_1_bar.total_cmp(&l_a_foo), std::cmp::Ordering::Less); + assert_eq!(l_1_bar.total_cmp(&l_2_baz), std::cmp::Ordering::Less); + assert_eq!(l_2_baz.total_cmp(&l_a_foo), std::cmp::Ordering::Less); + + let l_en_1 = "en-1-ext-value".parse::().unwrap(); + let l_en_a = "en-a-ext-value".parse::().unwrap(); + assert_eq!(l_en_1.total_cmp(&l_en_a), std::cmp::Ordering::Less); +} diff --git a/deps/crates/vendor/ixdtf-v0_6/.cargo_vcs_info.json b/deps/crates/vendor/ixdtf-v0_6/.cargo_vcs_info.json index a32e9d347a5..5b911edad6a 100644 --- a/deps/crates/vendor/ixdtf-v0_6/.cargo_vcs_info.json +++ b/deps/crates/vendor/ixdtf-v0_6/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "29dfe2790b6cfdab94ca6a6b69f58ce54802dbf7" + "sha1": "c9fac4e625ccb2c6a7aa35079fff9709db4385ac" }, "path_in_vcs": "utils/ixdtf" } \ No newline at end of file diff --git a/deps/crates/vendor/ixdtf-v0_6/Cargo.lock b/deps/crates/vendor/ixdtf-v0_6/Cargo.lock index d4a518a1bde..7c3507fe1f6 100644 --- a/deps/crates/vendor/ixdtf-v0_6/Cargo.lock +++ b/deps/crates/vendor/ixdtf-v0_6/Cargo.lock @@ -4,9 +4,9 @@ version = 3 [[package]] name = "aho-corasick" -version = "1.1.3" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" dependencies = [ "memchr", ] @@ -19,9 +19,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" [[package]] name = "anstyle" -version = "1.0.13" +version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" [[package]] name = "autocfg" @@ -31,9 +31,9 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" [[package]] name = "bumpalo" -version = "3.19.0" +version = "3.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" +checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb" [[package]] name = "cast" @@ -210,13 +210,13 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.15" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" [[package]] name = "ixdtf" -version = "0.6.4" +version = "0.6.5" dependencies = [ "criterion", "serde-json-core", @@ -224,9 +224,9 @@ dependencies = [ [[package]] name = "js-sys" -version = "0.3.81" +version = "0.3.91" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305" +checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c" dependencies = [ "once_cell", "wasm-bindgen", @@ -234,21 +234,15 @@ dependencies = [ [[package]] name = "libc" -version = "0.2.177" +version = "0.2.183" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976" - -[[package]] -name = "log" -version = "0.4.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432" +checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d" [[package]] name = "memchr" -version = "2.7.6" +version = "2.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" [[package]] name = "num-traits" @@ -261,9 +255,9 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.21.3" +version = "1.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" [[package]] name = "oorandom" @@ -301,18 +295,18 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.103" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.41" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] @@ -339,9 +333,9 @@ dependencies = [ [[package]] name = "regex" -version = "1.12.2" +version = "1.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4" +checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276" dependencies = [ "aho-corasick", "memchr", @@ -351,9 +345,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.13" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" dependencies = [ "aho-corasick", "memchr", @@ -362,9 +356,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.8" +version = "0.8.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58" +checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a" [[package]] name = "rustversion" @@ -374,9 +368,9 @@ checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" [[package]] name = "ryu" -version = "1.0.20" +version = "1.0.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" +checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f" [[package]] name = "same-file" @@ -429,22 +423,22 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.145" +version = "1.0.149" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" dependencies = [ "itoa", "memchr", - "ryu", "serde", "serde_core", + "zmij", ] [[package]] name = "syn" -version = "2.0.108" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", @@ -463,9 +457,9 @@ dependencies = [ [[package]] name = "unicode-ident" -version = "1.0.20" +version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "462eeb75aeb73aea900253ce739c8e18a67423fadf006037cd3ff27e82748a06" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" [[package]] name = "walkdir" @@ -479,9 +473,9 @@ dependencies = [ [[package]] name = "wasm-bindgen" -version = "0.2.104" +version = "0.2.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d" +checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e" dependencies = [ "cfg-if", "once_cell", @@ -490,25 +484,11 @@ dependencies = [ "wasm-bindgen-shared", ] -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.104" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19" -dependencies = [ - "bumpalo", - "log", - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-shared", -] - [[package]] name = "wasm-bindgen-macro" -version = "0.2.104" +version = "0.2.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119" +checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -516,31 +496,31 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.104" +version = "0.2.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7" +checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3" dependencies = [ + "bumpalo", "proc-macro2", "quote", "syn", - "wasm-bindgen-backend", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.104" +version = "0.2.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1" +checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16" dependencies = [ "unicode-ident", ] [[package]] name = "web-sys" -version = "0.3.81" +version = "0.3.91" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120" +checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9" dependencies = [ "js-sys", "wasm-bindgen", @@ -569,3 +549,9 @@ checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" dependencies = [ "windows-link", ] + +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" diff --git a/deps/crates/vendor/ixdtf-v0_6/Cargo.toml b/deps/crates/vendor/ixdtf-v0_6/Cargo.toml index 2f2ddf27a41..86d0018211b 100644 --- a/deps/crates/vendor/ixdtf-v0_6/Cargo.toml +++ b/deps/crates/vendor/ixdtf-v0_6/Cargo.toml @@ -13,7 +13,7 @@ edition = "2021" rust-version = "1.82" name = "ixdtf" -version = "0.6.4" +version = "0.6.5" authors = ["The ICU4X Project Developers"] build = false include = [ @@ -35,7 +35,16 @@ autobenches = false description = "Parser for Internet eXtended DateTime Format" homepage = "https://icu4x.unicode.org" readme = "README.md" -categories = ["internationalization"] +keywords = [ + "iso8601", + "date-time", +] +categories = [ + "internationalization", + "localization", + "no-std", + "embedded", +] license = "Unicode-3.0" repository = "https://github.com/unicode-org/icu4x" @@ -65,3 +74,52 @@ default-features = false [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies.criterion] version = "0.5.0" + +[lints.clippy] +alloc-instead-of-core = "warn" +branches-sharing-code = "warn" +collection_is_never_read = "warn" +crosspointer_transmute = "warn" +dbg_macro = "warn" +debug_assert_with_mut_call = "warn" +doc_markdown = "warn" +exhaustive_enums = "deny" +exhaustive_structs = "deny" +fn_to_numeric_cast_any = "warn" +infinite_loop = "warn" +large_stack_arrays = "warn" +mismatching_type_param_order = "warn" +missing_fields_in_debug = "warn" +missing_transmute_annotations = "warn" +negative_feature_names = "warn" +or-fun-call = "warn" +same_functions_in_if_condition = "warn" +todo = "warn" +transmute_bytes_to_str = "warn" +transmute_int_to_bool = "warn" +transmute_int_to_non_zero = "warn" +transmute_ptr_to_ptr = "warn" +transmute_ptr_to_ref = "warn" +transmute_undefined_repr = "warn" +transmutes_expressible_as_ptr_casts = "warn" +trivially_copy_pass_by_ref = "deny" +unnecessary-wraps = "warn" +useless_transmute = "warn" +wildcard_dependencies = "warn" + +[lints.rust] +missing_debug_implementations = "deny" +trivial_numeric_casts = "deny" +unused_lifetimes = "warn" +unused_macro_rules = "warn" +unused_qualifications = "warn" + +[lints.rust.unexpected_cfgs] +level = "warn" +priority = 0 +check-cfg = [ + "cfg(icu4c_enable_renaming)", + "cfg(needs_alloc_error_handler)", + "cfg(icu4x_run_size_tests)", + "cfg(icu4x_unstable_fast_trie_only)", +] diff --git a/deps/crates/vendor/ixdtf-v0_6/Cargo.toml.orig b/deps/crates/vendor/ixdtf-v0_6/Cargo.toml.orig index 86e56c71baf..69c4b9e586c 100644 --- a/deps/crates/vendor/ixdtf-v0_6/Cargo.toml.orig +++ b/deps/crates/vendor/ixdtf-v0_6/Cargo.toml.orig @@ -5,10 +5,11 @@ [package] name = "ixdtf" description = "Parser for Internet eXtended DateTime Format" -version = "0.6.4" +version = "0.6.5" +categories.workspace = true +keywords = ["iso8601", "date-time"] authors.workspace = true -categories.workspace = true edition.workspace = true homepage.workspace = true include.workspace = true @@ -36,3 +37,6 @@ criterion = { workspace = true } [package.metadata.cargo-semver-checks.lints] workspace = true + +[lints] +workspace = true diff --git a/deps/crates/vendor/ixdtf-v0_6/src/core.rs b/deps/crates/vendor/ixdtf-v0_6/src/core.rs index b60d0965027..a24a04cb347 100644 --- a/deps/crates/vendor/ixdtf-v0_6/src/core.rs +++ b/deps/crates/vendor/ixdtf-v0_6/src/core.rs @@ -4,82 +4,9 @@ //! Core functionality for `ixdtf`'s parsers +use crate::encoding::EncodingType; use crate::{ParseError, ParserResult}; -mod private { - pub trait Sealed {} -} - -/// A trait for defining various supported encodings -/// and implementing functionality that is encoding -/// sensitive / specific. -pub trait EncodingType: private::Sealed { - type CodeUnit: PartialEq + core::fmt::Debug + Clone; - - /// Get a slice from the underlying source using for start..end - fn slice(source: &[Self::CodeUnit], start: usize, end: usize) -> Option<&[Self::CodeUnit]>; - - /// Retrieve the provided code unit index and returns the value as an ASCII byte - /// or None if the value is not ASCII representable. - fn get_ascii(source: &[Self::CodeUnit], index: usize) -> ParserResult>; - - /// Checks for the known calendar annotation key `u-ca`. - fn check_calendar_key(key: &[Self::CodeUnit]) -> bool; -} - -/// A marker type that signals a parser should parse the source as UTF-16 bytes. -#[derive(Debug, PartialEq, Clone)] -#[allow(clippy::exhaustive_structs)] // ZST Marker trait, no fields should be added -pub struct Utf16; - -impl private::Sealed for Utf16 {} - -impl EncodingType for Utf16 { - type CodeUnit = u16; - fn slice(source: &[Self::CodeUnit], start: usize, end: usize) -> Option<&[Self::CodeUnit]> { - source.get(start..end) - } - - fn get_ascii(source: &[Self::CodeUnit], index: usize) -> ParserResult> { - source.get(index).copied().map(to_ascii_byte).transpose() - } - - fn check_calendar_key(key: &[Self::CodeUnit]) -> bool { - key == [0x75, 0x2d, 0x63, 0x61] - } -} - -#[inline] -fn to_ascii_byte(b: u16) -> ParserResult { - if !(0x01..0x7F).contains(&b) { - return Err(ParseError::NonAsciiCodePoint); - } - Ok(b as u8) -} - -/// A marker type that signals a parser should parse the source as UTF-8 bytes. -#[derive(Debug, PartialEq, Clone)] -#[allow(clippy::exhaustive_structs)] // ZST Marker trait, no fields should be added. -pub struct Utf8; - -impl private::Sealed for Utf8 {} - -impl EncodingType for Utf8 { - type CodeUnit = u8; - - fn slice<'a>(source: &[Self::CodeUnit], start: usize, end: usize) -> Option<&[Self::CodeUnit]> { - source.get(start..end) - } - - fn get_ascii(source: &[Self::CodeUnit], index: usize) -> ParserResult> { - Ok(source.get(index).copied()) - } - - fn check_calendar_key(key: &[Self::CodeUnit]) -> bool { - key == "u-ca".as_bytes() - } -} - // ==== Mini cursor implementation for Iso8601 targets ==== /// `Cursor` is a small cursor implementation for parsing Iso8601 grammar. @@ -152,7 +79,7 @@ impl<'a, T: EncodingType> Cursor<'a, T> { /// Returns the next value as a digit /// /// # Errors - /// - Returns an AbruptEnd error if cursor ends. + /// - Returns an [`ParseError::AbruptEnd`] error if cursor ends. pub(crate) fn next_digit(&mut self) -> ParserResult> { let ascii_char = self.next_or(ParseError::AbruptEnd { location: "digit" })?; if ascii_char.is_ascii_digit() { @@ -162,7 +89,7 @@ impl<'a, T: EncodingType> Cursor<'a, T> { } } - /// A utility next method that returns an `AbruptEnd` error if invalid. + /// A utility next method that returns an [`ParseError::AbruptEnd`] error if invalid. pub(crate) fn next_or(&mut self, err: ParseError) -> ParserResult { self.next()?.ok_or(err) } diff --git a/deps/crates/vendor/ixdtf-v0_6/src/encoding.rs b/deps/crates/vendor/ixdtf-v0_6/src/encoding.rs new file mode 100644 index 00000000000..700b2220656 --- /dev/null +++ b/deps/crates/vendor/ixdtf-v0_6/src/encoding.rs @@ -0,0 +1,85 @@ +// This file is part of ICU4X. For terms of use, please see the file +// called LICENSE at the top level of the ICU4X source tree +// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ). + +//! This module contains the supported encoding for `ixdtf` parsing. + +use crate::{ParseError, ParserResult}; + +mod private { + pub trait Sealed {} +} + +/// A trait for defining various supported encodings +/// and implementing functionality that is encoding +/// sensitive / specific. +pub trait EncodingType: private::Sealed { + /// The code unit for the current encoding. + type CodeUnit: PartialEq + core::fmt::Debug + Clone; + + /// Get a slice from the underlying source using for start..end + #[doc(hidden)] + fn slice(source: &[Self::CodeUnit], start: usize, end: usize) -> Option<&[Self::CodeUnit]>; + + /// Retrieve the provided code unit index and returns the value as an ASCII byte + /// or None if the value is not ASCII representable. + #[doc(hidden)] + fn get_ascii(source: &[Self::CodeUnit], index: usize) -> ParserResult>; + + /// Checks for the known calendar annotation key `u-ca`. + #[doc(hidden)] + fn check_calendar_key(key: &[Self::CodeUnit]) -> bool; +} + +/// A marker type that signals a parser should parse the source as UTF-16 bytes. +#[derive(Debug, PartialEq, Clone)] +#[allow(clippy::exhaustive_structs)] // ZST Marker trait, no fields should be added +pub struct Utf16; + +impl private::Sealed for Utf16 {} + +impl EncodingType for Utf16 { + type CodeUnit = u16; + fn slice(source: &[Self::CodeUnit], start: usize, end: usize) -> Option<&[Self::CodeUnit]> { + source.get(start..end) + } + + fn get_ascii(source: &[Self::CodeUnit], index: usize) -> ParserResult> { + source.get(index).copied().map(to_ascii_byte).transpose() + } + + fn check_calendar_key(key: &[Self::CodeUnit]) -> bool { + key == [0x75, 0x2d, 0x63, 0x61] + } +} + +#[inline] +fn to_ascii_byte(b: u16) -> ParserResult { + if !(0x01..0x7F).contains(&b) { + return Err(ParseError::NonAsciiCodePoint); + } + Ok(b as u8) +} + +/// A marker type that signals a parser should parse the source as UTF-8 bytes. +#[derive(Debug, PartialEq, Clone)] +#[allow(clippy::exhaustive_structs)] // ZST Marker trait, no fields should be added. +pub struct Utf8; + +impl private::Sealed for Utf8 {} + +impl EncodingType for Utf8 { + type CodeUnit = u8; + + fn slice(source: &[Self::CodeUnit], start: usize, end: usize) -> Option<&[Self::CodeUnit]> { + source.get(start..end) + } + + fn get_ascii(source: &[Self::CodeUnit], index: usize) -> ParserResult> { + Ok(source.get(index).copied()) + } + + fn check_calendar_key(key: &[Self::CodeUnit]) -> bool { + key == "u-ca".as_bytes() + } +} diff --git a/deps/crates/vendor/ixdtf-v0_6/src/error.rs b/deps/crates/vendor/ixdtf-v0_6/src/error.rs index 91fb6b91b9f..417e422ab5a 100644 --- a/deps/crates/vendor/ixdtf-v0_6/src/error.rs +++ b/deps/crates/vendor/ixdtf-v0_6/src/error.rs @@ -76,10 +76,6 @@ pub enum ParseError { impl core::error::Error for ParseError {} impl ParseError { - pub(crate) fn abrupt_end(location: &'static str) -> Self { - ParseError::AbruptEnd { location } - } - /// Convert this error to a static string representation pub fn to_static_string(&self) -> &'static str { match *self { diff --git a/deps/crates/vendor/ixdtf-v0_6/src/lib.rs b/deps/crates/vendor/ixdtf-v0_6/src/lib.rs index e12df2f3550..ccb0fd23583 100644 --- a/deps/crates/vendor/ixdtf-v0_6/src/lib.rs +++ b/deps/crates/vendor/ixdtf-v0_6/src/lib.rs @@ -2,6 +2,19 @@ // called LICENSE at the top level of the ICU4X source tree // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ). +// https://github.com/unicode-org/icu4x/blob/main/documents/process/boilerplate.md#library-annotations +#![cfg_attr(not(any(test, doc)), no_std)] +#![cfg_attr( + not(test), + deny( + clippy::indexing_slicing, + clippy::unwrap_used, + clippy::expect_used, + clippy::panic, + ) +)] +// #![warn(missing_docs)] + //! Parsers for extended date time string and Duration parsing. //! //! The [Internet Extended Date/Time Fmt (IXDTF)][rfc9557] is laid out by RFC 9557. RFC 9557 @@ -373,32 +386,15 @@ //! [rfc3339]: https://datatracker.ietf.org/doc/html/rfc3339 //! [temporal-grammar]: https://tc39.es/proposal-temporal/#sec-temporal-iso8601grammar -#![no_std] -#![cfg_attr( - not(test), - deny( - clippy::indexing_slicing, - clippy::unwrap_used, - clippy::expect_used, - clippy::panic, - clippy::exhaustive_structs, - clippy::exhaustive_enums, - clippy::trivially_copy_pass_by_ref, - missing_debug_implementations, - ) -)] +mod error; pub(crate) mod core; -mod error; + +pub mod encoding; pub mod parsers; pub mod records; pub use error::ParseError; -/// This module contains the supported encoding for `ixdtf` parsing. -pub mod encoding { - pub use crate::core::{Utf16, Utf8}; -} - /// The `ixdtf` crate's Result type. pub type ParserResult = Result; diff --git a/deps/crates/vendor/ixdtf-v0_6/src/parsers/annotations.rs b/deps/crates/vendor/ixdtf-v0_6/src/parsers/annotations.rs index dc4610e18a8..054d2db0c3e 100644 --- a/deps/crates/vendor/ixdtf-v0_6/src/parsers/annotations.rs +++ b/deps/crates/vendor/ixdtf-v0_6/src/parsers/annotations.rs @@ -6,7 +6,7 @@ use crate::{ assert_syntax, - core::EncodingType, + encoding::EncodingType, parsers::{ grammar::{ is_a_key_char, is_a_key_leading_char, is_annotation_close, diff --git a/deps/crates/vendor/ixdtf-v0_6/src/parsers/datetime.rs b/deps/crates/vendor/ixdtf-v0_6/src/parsers/datetime.rs index 420044f261e..b61ee30b2fa 100644 --- a/deps/crates/vendor/ixdtf-v0_6/src/parsers/datetime.rs +++ b/deps/crates/vendor/ixdtf-v0_6/src/parsers/datetime.rs @@ -6,7 +6,7 @@ use crate::{ assert_syntax, - core::EncodingType, + encoding::EncodingType, parsers::{ annotations, grammar::{is_annotation_open, is_date_time_separator, is_hyphen, is_utc_designator}, @@ -106,7 +106,7 @@ fn parse_date(cursor: &mut Cursor) -> ParserResult(cursor: &mut Cursor) -> ParserResult( cursor: &mut Cursor<'a, T>, handler: impl FnMut(Annotation<'a, T>) -> Option>, @@ -170,7 +170,7 @@ pub(crate) fn parse_year_month( // ==== `MonthDay` parsing functions ==== -/// Parses an AnnotatedMonthDay. +/// Parses an `AnnotatedMonthDay`. pub(crate) fn parse_annotated_month_day<'a, T: EncodingType>( cursor: &mut Cursor<'a, T>, handler: impl FnMut(Annotation<'a, T>) -> Option>, @@ -202,14 +202,14 @@ pub(crate) fn parse_annotated_month_day<'a, T: EncodingType>( /// Parses a `DateSpecMonthDay` pub(crate) fn parse_month_day(cursor: &mut Cursor) -> ParserResult { - let hyphenated = cursor - .check(is_hyphen)? - .ok_or(ParseError::abrupt_end("MonthDay"))?; + let hyphenated = cursor.check(is_hyphen)?.ok_or(ParseError::AbruptEnd { + location: "MonthDay", + })?; cursor.advance_if(hyphenated); let balanced_hyphens = hyphenated - && cursor - .check(is_hyphen)? - .ok_or(ParseError::abrupt_end("MonthDay"))?; + && cursor.check(is_hyphen)?.ok_or(ParseError::AbruptEnd { + location: "MonthDay", + })?; cursor.advance_if(balanced_hyphens); if hyphenated && !balanced_hyphens { diff --git a/deps/crates/vendor/ixdtf-v0_6/src/parsers/duration.rs b/deps/crates/vendor/ixdtf-v0_6/src/parsers/duration.rs index c3d5e845f06..3f9dac9cbd9 100644 --- a/deps/crates/vendor/ixdtf-v0_6/src/parsers/duration.rs +++ b/deps/crates/vendor/ixdtf-v0_6/src/parsers/duration.rs @@ -6,7 +6,7 @@ use crate::{ assert_syntax, - core::EncodingType, + encoding::EncodingType, parsers::{ grammar::{ is_ascii_sign, is_day_designator, is_duration_designator, is_hour_designator, @@ -23,24 +23,26 @@ use crate::{ pub(crate) fn parse_duration( cursor: &mut Cursor, ) -> ParserResult { - let sign = if cursor - .check(is_ascii_sign)? - .ok_or_else(|| ParseError::abrupt_end("DurationStart"))? - { + let sign = if cursor.check(is_ascii_sign)?.ok_or(ParseError::AbruptEnd { + location: "DurationStart", + })? { cursor.next_or(ParseError::ImplAssert)? == b'+' } else { true }; assert_syntax!( - is_duration_designator(cursor.next_or(ParseError::abrupt_end("DurationDesignator"))?), + is_duration_designator(cursor.next_or(ParseError::AbruptEnd { + location: "DurationDesignator" + })?), DurationDisgnator, ); let date = if cursor .check(is_time_designator)? - .ok_or(ParseError::abrupt_end("Duration"))? - { + .ok_or(ParseError::AbruptEnd { + location: "Duration", + })? { None } else { Some(parse_date_duration(cursor)?) @@ -75,9 +77,9 @@ pub(crate) fn parse_date_duration( while cursor.check_or(false, |ch| ch.is_ascii_digit())? { let mut value: u64 = 0; while cursor.check_or(false, |ch| ch.is_ascii_digit())? { - let digit = cursor - .next_digit()? - .ok_or_else(|| ParseError::abrupt_end("DateDuration"))?; + let digit = cursor.next_digit()?.ok_or(ParseError::AbruptEnd { + location: "DateDuration", + })?; value = value .checked_mul(10) .and_then(|v| v.checked_add(u64::from(digit))) @@ -116,7 +118,11 @@ pub(crate) fn parse_date_duration( date.days = value; previous_unit = DateUnit::Day; } - Some(_) | None => return Err(ParseError::abrupt_end("DateDurationDesignator")), + Some(_) | None => { + return Err(ParseError::AbruptEnd { + location: "DateDurationDesignator", + }) + } } } @@ -149,9 +155,9 @@ pub(crate) fn parse_time_duration( while cursor.check_or(false, |c| c.is_ascii_digit())? { let mut value: u64 = 0; while cursor.check_or(false, |c| c.is_ascii_digit())? { - let digit = cursor - .next_digit()? - .ok_or_else(|| ParseError::abrupt_end("TimeDurationDigit"))?; + let digit = cursor.next_digit()?.ok_or(ParseError::AbruptEnd { + location: "TimeDurationDigit", + })?; value = value .checked_mul(10) .and_then(|v| v.checked_add(u64::from(digit))) @@ -191,7 +197,11 @@ pub(crate) fn parse_time_duration( } previous_unit = TimeUnit::Second; } - Some(_) | None => return Err(ParseError::abrupt_end("TimeDurationDesignator")), + Some(_) | None => { + return Err(ParseError::AbruptEnd { + location: "TimeDurationDesignator", + }) + } } if fraction.is_some() { @@ -221,6 +231,8 @@ pub(crate) fn parse_time_duration( seconds: time.2, fraction: time.3, })), - TimeUnit::None => Err(ParseError::abrupt_end("TimeDurationDesignator")), + TimeUnit::None => Err(ParseError::AbruptEnd { + location: "TimeDurationDesignator", + }), } } diff --git a/deps/crates/vendor/ixdtf-v0_6/src/parsers/mod.rs b/deps/crates/vendor/ixdtf-v0_6/src/parsers/mod.rs index 662d4940566..76673dc6794 100644 --- a/deps/crates/vendor/ixdtf-v0_6/src/parsers/mod.rs +++ b/deps/crates/vendor/ixdtf-v0_6/src/parsers/mod.rs @@ -4,8 +4,9 @@ //! The parser module contains the implementation details for `IxdtfParser` and `IsoDurationParser` -use crate::core::{EncodingType, Utf16, Utf8}; -use crate::{core::Cursor, ParserResult}; +use crate::core::Cursor; +use crate::encoding::{EncodingType, Utf16, Utf8}; +use crate::ParserResult; #[cfg(feature = "duration")] use crate::records::DurationParseRecord; @@ -116,7 +117,8 @@ impl<'a, T: EncodingType> IxdtfParser<'a, T> { /// Parses the source as an [extended Date/Time string][rfc9557]. /// /// This is the baseline parse method for `ixdtf`. For this method, the - /// TimeRecord, UTCOffsetRecord, and all annotations are optional. + /// [`TimeRecord`](crate::records::TimeRecord), [`UtcOffsetRecord`], + /// and all annotations are optional. /// /// # Example /// @@ -159,7 +161,7 @@ impl<'a, T: EncodingType> IxdtfParser<'a, T> { self.parse_year_month_with_annotation_handler(Some) } - /// Parses the source as an extended YearMonth string with an Annotation handler. + /// Parses the source as an extended `YearMonth` string with an Annotation handler. /// /// For more, see [Implementing Annotation Handlers](crate#implementing-annotation-handlers) pub fn parse_year_month_with_annotation_handler( @@ -192,7 +194,7 @@ impl<'a, T: EncodingType> IxdtfParser<'a, T> { self.parse_month_day_with_annotation_handler(Some) } - /// Parses the source as an extended MonthDay string with an Annotation handler. + /// Parses the source as an extended `MonthDay` string with an Annotation handler. /// /// For more, see [Implementing Annotation Handlers](crate#implementing-annotation-handlers) pub fn parse_month_day_with_annotation_handler( diff --git a/deps/crates/vendor/ixdtf-v0_6/src/parsers/tests.rs b/deps/crates/vendor/ixdtf-v0_6/src/parsers/tests.rs index a4edc6e583b..45d505551b3 100644 --- a/deps/crates/vendor/ixdtf-v0_6/src/parsers/tests.rs +++ b/deps/crates/vendor/ixdtf-v0_6/src/parsers/tests.rs @@ -9,7 +9,7 @@ use alloc::string::String; use alloc::vec::Vec; use crate::{ - core::Utf16, + encoding::Utf16, parsers::IxdtfParser, records::{ Annotation, DateRecord, Fraction, IxdtfParseRecord, TimeRecord, TimeZoneAnnotation, @@ -1103,7 +1103,7 @@ fn test_zulu_offset() { second: 0, fraction: None, }), - offset: Some(crate::records::UtcOffsetRecordOrZ::Z), + offset: Some(UtcOffsetRecordOrZ::Z), tz: Some(TimeZoneAnnotation { critical: false, tz: TimeZoneRecord::Name("America/Chicago".as_bytes()) diff --git a/deps/crates/vendor/ixdtf-v0_6/src/parsers/time.rs b/deps/crates/vendor/ixdtf-v0_6/src/parsers/time.rs index f67ecd5ae88..5ef65d6bb8b 100644 --- a/deps/crates/vendor/ixdtf-v0_6/src/parsers/time.rs +++ b/deps/crates/vendor/ixdtf-v0_6/src/parsers/time.rs @@ -8,7 +8,7 @@ use core::num::NonZeroU8; use crate::{ assert_syntax, - core::EncodingType, + encoding::EncodingType, parsers::{ datetime::{parse_month_day, parse_year_month}, grammar::{ diff --git a/deps/crates/vendor/ixdtf-v0_6/src/parsers/timezone.rs b/deps/crates/vendor/ixdtf-v0_6/src/parsers/timezone.rs index 9c4741f1404..9b51cbc7338 100644 --- a/deps/crates/vendor/ixdtf-v0_6/src/parsers/timezone.rs +++ b/deps/crates/vendor/ixdtf-v0_6/src/parsers/timezone.rs @@ -15,7 +15,7 @@ use super::{ }; use crate::{ assert_syntax, - core::EncodingType, + encoding::EncodingType, records::{ FullPrecisionOffset, MinutePrecisionOffset, Sign, TimeZoneAnnotation, TimeZoneRecord, UtcOffsetRecord, UtcOffsetRecordOrZ, @@ -39,19 +39,22 @@ pub(crate) fn parse_ambiguous_tz_annotation<'a, T: EncodingType>( ) -> ParserResult>> { // Peek position + 1 to check for critical flag. let mut current_peek = 1; - let critical = cursor - .peek_n(current_peek)? - .map(is_critical_flag) - .ok_or(ParseError::abrupt_end("AmbiguousAnnotation"))?; + let critical = + cursor + .peek_n(current_peek)? + .map(is_critical_flag) + .ok_or(ParseError::AbruptEnd { + location: "AmbiguousAnnotation", + })?; // Advance cursor if critical flag present. if critical { current_peek += 1; } - let leading_char = cursor - .peek_n(current_peek)? - .ok_or(ParseError::abrupt_end("AmbiguousAnnotation"))?; + let leading_char = cursor.peek_n(current_peek)?.ok_or(ParseError::AbruptEnd { + location: "AmbiguousAnnotation", + })?; // Ambigious start values when lowercase alpha that is shared between `TzLeadingChar` and `KeyLeadingChar`. if is_a_key_leading_char(leading_char) { @@ -69,7 +72,9 @@ pub(crate) fn parse_ambiguous_tz_annotation<'a, T: EncodingType>( peek_pos += 1; } - Err(ParseError::abrupt_end("AmbiguousAnnotation")) + Err(ParseError::AbruptEnd { + location: "AmbiguousAnnotation", + }) } else { // Unambiguously not a non-tz annotation, try parsing a tz annotation let tz = parse_tz_annotation(cursor)?; @@ -106,7 +111,9 @@ pub(crate) fn parse_time_zone<'a, T: EncodingType>( ) -> ParserResult> { let is_iana = cursor .check(is_tz_leading_char)? - .ok_or(ParseError::abrupt_end("TimeZoneAnnotation"))?; + .ok_or(ParseError::AbruptEnd { + location: "TimeZoneAnnotation", + })?; let is_offset = cursor.check_or(false, is_ascii_sign)?; if is_iana { @@ -203,7 +210,9 @@ pub(crate) fn parse_utc_offset_minute_precision( cursor: &mut Cursor, ) -> ParserResult<(MinutePrecisionOffset, bool)> { // https://www.rfc-editor.org/rfc/rfc3339#section-5.6 - let sign = cursor.next_or(ParseError::abrupt_end("time-numoffset"))?; + let sign = cursor.next_or(ParseError::AbruptEnd { + location: "time-numoffset", + })?; if !is_ascii_sign(sign) { return Err(ParseError::OffsetNeedsSign); } diff --git a/deps/crates/vendor/ixdtf-v0_6/src/records.rs b/deps/crates/vendor/ixdtf-v0_6/src/records.rs index 1ff1e796a11..19c7684aeef 100644 --- a/deps/crates/vendor/ixdtf-v0_6/src/records.rs +++ b/deps/crates/vendor/ixdtf-v0_6/src/records.rs @@ -6,7 +6,7 @@ use core::num::NonZeroU8; -use crate::core::EncodingType; +use crate::encoding::EncodingType; /// An `IxdtfParseRecord` is an intermediary record returned by `IxdtfParser`. #[non_exhaustive] @@ -16,9 +16,9 @@ pub struct IxdtfParseRecord<'a, T: EncodingType> { pub date: Option, /// Parsed `TimeRecord` pub time: Option, - /// Parsed UtcOffset + /// Parsed `UtcOffset` pub offset: Option, - /// Parsed `TimeZone` annotation with critical flag and data (UTCOffset | IANA name) + /// Parsed `TimeZone` annotation with critical flag and data (`UTCOffset` | IANA name) pub tz: Option>, /// The parsed calendar value. pub calendar: Option<&'a [T::CodeUnit]>, @@ -76,9 +76,9 @@ pub struct TimeZoneAnnotation<'a, T: EncodingType> { #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] pub enum TimeZoneRecord<'a, T: EncodingType> { - /// TimeZoneIANAName + /// `TimeZoneIANAName` Name(&'a [T::CodeUnit]), - /// TimeZoneOffset + /// `TimeZoneOffset` Offset(MinutePrecisionOffset), } @@ -356,6 +356,6 @@ impl Fraction { /// ``` pub fn to_truncated_nanoseconds(&self) -> u32 { self.to_nanoseconds() - .unwrap_or((self.value / 10u64.pow(u32::from(self.digits.get() - 9))) as u32) + .unwrap_or_else(|| (self.value / 10u64.pow(u32::from(self.digits.get() - 9))) as u32) } } diff --git a/deps/crates/vendor/litemap-v0_8/.cargo_vcs_info.json b/deps/crates/vendor/litemap-v0_8/.cargo_vcs_info.json index de7b36925b7..fbadd405644 100644 --- a/deps/crates/vendor/litemap-v0_8/.cargo_vcs_info.json +++ b/deps/crates/vendor/litemap-v0_8/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "29dfe2790b6cfdab94ca6a6b69f58ce54802dbf7" + "sha1": "c9fac4e625ccb2c6a7aa35079fff9709db4385ac" }, "path_in_vcs": "utils/litemap" } \ No newline at end of file diff --git a/deps/crates/vendor/litemap-v0_8/Cargo.lock b/deps/crates/vendor/litemap-v0_8/Cargo.lock index 08116836b6a..d5fd27c1e08 100644 --- a/deps/crates/vendor/litemap-v0_8/Cargo.lock +++ b/deps/crates/vendor/litemap-v0_8/Cargo.lock @@ -8,16 +8,16 @@ version = "0.7.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9" dependencies = [ - "getrandom 0.2.16", + "getrandom 0.2.17", "once_cell", "version_check", ] [[package]] name = "aho-corasick" -version = "1.1.3" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" dependencies = [ "memchr", ] @@ -30,9 +30,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" [[package]] name = "anstyle" -version = "1.0.13" +version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" [[package]] name = "autocfg" @@ -63,9 +63,9 @@ dependencies = [ [[package]] name = "bumpalo" -version = "3.19.0" +version = "3.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" +checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb" [[package]] name = "bytecheck" @@ -91,9 +91,9 @@ dependencies = [ [[package]] name = "bytes" -version = "1.10.1" +version = "1.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a" +checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" [[package]] name = "cast" @@ -237,9 +237,9 @@ checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" [[package]] name = "databake" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff6ee9e2d2afb173bcdeee45934c89ec341ab26f91c9933774fc15c2b58f83ef" +checksum = "74d4b1db5ca40636726f1f73daff0d626accbd49bcd8136fcade87d7cf1e6bbb" dependencies = [ "proc-macro2", "quote", @@ -271,9 +271,9 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" [[package]] name = "getrandom" -version = "0.2.16" +version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" dependencies = [ "cfg-if", "libc", @@ -339,15 +339,15 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.15" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" [[package]] name = "js-sys" -version = "0.3.81" +version = "0.3.91" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305" +checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c" dependencies = [ "once_cell", "wasm-bindgen", @@ -355,13 +355,13 @@ dependencies = [ [[package]] name = "libc" -version = "0.2.177" +version = "0.2.183" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976" +checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d" [[package]] name = "litemap" -version = "0.8.1" +version = "0.8.2" dependencies = [ "bincode", "criterion", @@ -374,17 +374,11 @@ dependencies = [ "yoke", ] -[[package]] -name = "log" -version = "0.4.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432" - [[package]] name = "memchr" -version = "2.7.6" +version = "2.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" [[package]] name = "num-traits" @@ -397,9 +391,9 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.21.3" +version = "1.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" [[package]] name = "oorandom" @@ -458,9 +452,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.103" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] @@ -487,9 +481,9 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.41" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] @@ -528,9 +522,9 @@ dependencies = [ [[package]] name = "rand_core" -version = "0.9.3" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" dependencies = [ "getrandom 0.3.4", ] @@ -557,9 +551,9 @@ dependencies = [ [[package]] name = "regex" -version = "1.12.2" +version = "1.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4" +checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276" dependencies = [ "aho-corasick", "memchr", @@ -569,9 +563,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.13" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" dependencies = [ "aho-corasick", "memchr", @@ -580,9 +574,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.8" +version = "0.8.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58" +checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a" [[package]] name = "rend" @@ -595,9 +589,9 @@ dependencies = [ [[package]] name = "rkyv" -version = "0.7.45" +version = "0.7.46" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9008cd6385b9e161d8229e1f6549dd23c3d022f132a2ea37ac3a10ac4935779b" +checksum = "2297bf9c81a3f0dc96bc9521370b88f054168c29826a75e89c55ff196e7ed6a1" dependencies = [ "bitvec", "bytecheck", @@ -613,9 +607,9 @@ dependencies = [ [[package]] name = "rkyv_derive" -version = "0.7.45" +version = "0.7.46" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "503d1d27590a2b0a3a4ca4c94755aa2875657196ecbf401a42eff41d7de532c0" +checksum = "84d7b42d4b8d06048d3ac8db0eb31bcb942cbeb709f0b5f2b2ebde398d3038f5" dependencies = [ "proc-macro2", "quote", @@ -628,12 +622,6 @@ version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" -[[package]] -name = "ryu" -version = "1.0.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" - [[package]] name = "same-file" version = "1.0.6" @@ -676,20 +664,20 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn 2.0.108", + "syn 2.0.117", ] [[package]] name = "serde_json" -version = "1.0.145" +version = "1.0.149" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" dependencies = [ "itoa", "memchr", - "ryu", "serde", "serde_core", + "zmij", ] [[package]] @@ -717,9 +705,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.108" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", @@ -734,7 +722,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.108", + "syn 2.0.117", ] [[package]] @@ -745,22 +733,22 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" [[package]] name = "thiserror" -version = "2.0.17" +version = "2.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8" +checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "2.0.17" +version = "2.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913" +checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" dependencies = [ "proc-macro2", "quote", - "syn 2.0.108", + "syn 2.0.117", ] [[package]] @@ -775,9 +763,9 @@ dependencies = [ [[package]] name = "tinyvec" -version = "1.10.0" +version = "1.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa" +checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3" dependencies = [ "tinyvec_macros", ] @@ -790,15 +778,15 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" [[package]] name = "unicode-ident" -version = "1.0.20" +version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "462eeb75aeb73aea900253ce739c8e18a67423fadf006037cd3ff27e82748a06" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" [[package]] name = "uuid" -version = "1.18.1" +version = "1.20.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2" +checksum = "ee48d38b119b0cd71fe4141b30f5ba9c7c5d9f4e7a3a8b4a674e4b6ef789976f" dependencies = [ "js-sys", "wasm-bindgen", @@ -837,9 +825,9 @@ dependencies = [ [[package]] name = "wasm-bindgen" -version = "0.2.104" +version = "0.2.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d" +checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e" dependencies = [ "cfg-if", "once_cell", @@ -848,25 +836,11 @@ dependencies = [ "wasm-bindgen-shared", ] -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.104" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19" -dependencies = [ - "bumpalo", - "log", - "proc-macro2", - "quote", - "syn 2.0.108", - "wasm-bindgen-shared", -] - [[package]] name = "wasm-bindgen-macro" -version = "0.2.104" +version = "0.2.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119" +checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -874,31 +848,31 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.104" +version = "0.2.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7" +checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3" dependencies = [ + "bumpalo", "proc-macro2", "quote", - "syn 2.0.108", - "wasm-bindgen-backend", + "syn 2.0.117", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.104" +version = "0.2.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1" +checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16" dependencies = [ "unicode-ident", ] [[package]] name = "web-sys" -version = "0.3.81" +version = "0.3.91" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120" +checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9" dependencies = [ "js-sys", "wasm-bindgen", @@ -945,9 +919,9 @@ dependencies = [ [[package]] name = "yoke" -version = "0.8.1" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954" +checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca" dependencies = [ "stable_deref_trait", "yoke-derive", @@ -956,53 +930,59 @@ dependencies = [ [[package]] name = "yoke-derive" -version = "0.8.1" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d" +checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e" dependencies = [ "proc-macro2", "quote", - "syn 2.0.108", + "syn 2.0.117", "synstructure", ] [[package]] name = "zerocopy" -version = "0.8.27" +version = "0.8.47" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c" +checksum = "efbb2a062be311f2ba113ce66f697a4dc589f85e78a4aea276200804cea0ed87" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.27" +version = "0.8.47" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831" +checksum = "0e8bc7269b54418e7aeeef514aa68f8690b8c0489a06b0136e5f57c4c5ccab89" dependencies = [ "proc-macro2", "quote", - "syn 2.0.108", + "syn 2.0.117", ] [[package]] name = "zerofrom" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df" dependencies = [ "zerofrom-derive", ] [[package]] name = "zerofrom-derive" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.108", + "syn 2.0.117", "synstructure", ] + +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" diff --git a/deps/crates/vendor/litemap-v0_8/Cargo.toml b/deps/crates/vendor/litemap-v0_8/Cargo.toml index 9280ee63ea9..a5d635d5952 100644 --- a/deps/crates/vendor/litemap-v0_8/Cargo.toml +++ b/deps/crates/vendor/litemap-v0_8/Cargo.toml @@ -13,7 +13,7 @@ edition = "2021" rust-version = "1.82" name = "litemap" -version = "0.8.1" +version = "0.8.2" authors = ["The ICU4X Project Developers"] build = false include = [ @@ -36,11 +36,11 @@ description = "A key-value Map implementation based on a flat, sorted Vec." documentation = "https://docs.rs/litemap" readme = "README.md" keywords = [ + "data-structures", + "memory-efficiency", "sorted", "vec", "map", - "hashmap", - "btreemap", ] license = "Unicode-3.0" repository = "https://github.com/unicode-org/icu4x" @@ -51,6 +51,9 @@ independent = true [package.metadata.docs.rs] all-features = true +[package.metadata.cargo-all-features] +max_combination_size = 3 + [features] alloc = [] databake = ["dep:databake"] @@ -117,7 +120,7 @@ optional = true default-features = false [dependencies.yoke] -version = "0.8.0" +version = "0.8.2" features = ["derive"] optional = true default-features = false @@ -146,3 +149,52 @@ version = "1.0.45" [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies.criterion] version = "0.5.0" + +[lints.clippy] +alloc-instead-of-core = "warn" +branches-sharing-code = "warn" +collection_is_never_read = "warn" +crosspointer_transmute = "warn" +dbg_macro = "warn" +debug_assert_with_mut_call = "warn" +doc_markdown = "warn" +exhaustive_enums = "deny" +exhaustive_structs = "deny" +fn_to_numeric_cast_any = "warn" +infinite_loop = "warn" +large_stack_arrays = "warn" +mismatching_type_param_order = "warn" +missing_fields_in_debug = "warn" +missing_transmute_annotations = "warn" +negative_feature_names = "warn" +or-fun-call = "warn" +same_functions_in_if_condition = "warn" +todo = "warn" +transmute_bytes_to_str = "warn" +transmute_int_to_bool = "warn" +transmute_int_to_non_zero = "warn" +transmute_ptr_to_ptr = "warn" +transmute_ptr_to_ref = "warn" +transmute_undefined_repr = "warn" +transmutes_expressible_as_ptr_casts = "warn" +trivially_copy_pass_by_ref = "deny" +unnecessary-wraps = "warn" +useless_transmute = "warn" +wildcard_dependencies = "warn" + +[lints.rust] +missing_debug_implementations = "deny" +trivial_numeric_casts = "deny" +unused_lifetimes = "warn" +unused_macro_rules = "warn" +unused_qualifications = "warn" + +[lints.rust.unexpected_cfgs] +level = "warn" +priority = 0 +check-cfg = [ + "cfg(icu4c_enable_renaming)", + "cfg(needs_alloc_error_handler)", + "cfg(icu4x_run_size_tests)", + "cfg(icu4x_unstable_fast_trie_only)", +] diff --git a/deps/crates/vendor/litemap-v0_8/Cargo.toml.orig b/deps/crates/vendor/litemap-v0_8/Cargo.toml.orig index 44a13187573..79c2ed61e52 100644 --- a/deps/crates/vendor/litemap-v0_8/Cargo.toml.orig +++ b/deps/crates/vendor/litemap-v0_8/Cargo.toml.orig @@ -4,8 +4,8 @@ [package] name = "litemap" -version = "0.8.1" -keywords = ["sorted", "vec", "map", "hashmap", "btreemap"] +version = "0.8.2" +keywords = ["data-structures", "memory-efficiency", "sorted", "vec", "map"] description = "A key-value Map implementation based on a flat, sorted Vec." documentation = "https://docs.rs/litemap" @@ -75,3 +75,9 @@ required-features = ["serde"] name = "litemap" harness = false required-features = ["serde"] + +[lints] +workspace = true + +[package.metadata.cargo-all-features] +max_combination_size = 3 diff --git a/deps/crates/vendor/litemap-v0_8/src/databake.rs b/deps/crates/vendor/litemap-v0_8/src/databake.rs index 018961a4c01..a3f54df8925 100644 --- a/deps/crates/vendor/litemap-v0_8/src/databake.rs +++ b/deps/crates/vendor/litemap-v0_8/src/databake.rs @@ -5,7 +5,7 @@ use crate::LiteMap; use databake::*; -/// Bakes a LiteMap into Rust code for fast runtime construction from data. Use this impl during +/// Bakes a [`LiteMap`] into Rust code for fast runtime construction from data. Use this impl during /// code generation, such as in a `build.rs` script. /// /// For the most efficient bake, bake the [`LiteMap`] with a slice store. Use functions such as diff --git a/deps/crates/vendor/litemap-v0_8/src/lib.rs b/deps/crates/vendor/litemap-v0_8/src/lib.rs index cd276311566..2477e3bee34 100644 --- a/deps/crates/vendor/litemap-v0_8/src/lib.rs +++ b/deps/crates/vendor/litemap-v0_8/src/lib.rs @@ -2,6 +2,19 @@ // called LICENSE at the top level of the ICU4X source tree // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ). +// https://github.com/unicode-org/icu4x/blob/main/documents/process/boilerplate.md#library-annotations +#![cfg_attr(not(any(test, doc)), no_std)] +#![cfg_attr( + not(test), + deny( + clippy::indexing_slicing, + clippy::unwrap_used, + clippy::expect_used, + clippy::panic, + ) +)] +// #![warn(missing_docs)] + //! # `litemap` //! //! `litemap` is a crate providing [`LiteMap`], a highly simplistic "flat" key-value map @@ -44,22 +57,6 @@ //! [`impl Bake for LiteMap`]: ./struct.LiteMap.html#impl-Bake-for-LiteMap //! [`Vec`]: alloc::vec::Vec -// https://github.com/unicode-org/icu4x/blob/main/documents/process/boilerplate.md#library-annotations -#![cfg_attr(not(any(test, doc)), no_std)] -#![cfg_attr( - not(test), - deny( - clippy::indexing_slicing, - clippy::unwrap_used, - clippy::expect_used, - clippy::panic, - clippy::exhaustive_structs, - clippy::exhaustive_enums, - clippy::trivially_copy_pass_by_ref, - missing_debug_implementations, - ) -)] - // for intra doc links #[cfg(doc)] extern crate std; diff --git a/deps/crates/vendor/litemap-v0_8/src/map.rs b/deps/crates/vendor/litemap-v0_8/src/map.rs index 266e11ba94f..52eec375721 100644 --- a/deps/crates/vendor/litemap-v0_8/src/map.rs +++ b/deps/crates/vendor/litemap-v0_8/src/map.rs @@ -35,7 +35,7 @@ macro_rules! litemap_impl( ); // You can't `cfg()` a default generic parameter, and we don't want to write this type twice // and keep them in sync so we use a small macro -litemap_impl!(feature = "alloc", S = alloc::vec::Vec<(K, V)>); +litemap_impl!(feature = "alloc", S = Vec<(K, V)>); litemap_impl!(not(feature = "alloc"), S); #[cfg(feature = "alloc")] @@ -45,7 +45,7 @@ impl LiteMap { /// ✨ *Enabled with the `alloc` Cargo feature.* pub const fn new_vec() -> Self { Self { - values: alloc::vec::Vec::new(), + values: Vec::new(), _key_type: PhantomData, _value_type: PhantomData, } diff --git a/deps/crates/vendor/litemap-v0_8/src/serde.rs b/deps/crates/vendor/litemap-v0_8/src/serde.rs index d885b4d7a5e..f090b62134e 100644 --- a/deps/crates/vendor/litemap-v0_8/src/serde.rs +++ b/deps/crates/vendor/litemap-v0_8/src/serde.rs @@ -59,7 +59,7 @@ where } } -/// Modified example from https://serde.rs/deserialize-map.html +/// Modified example from #[expect(clippy::type_complexity)] struct LiteMapVisitor { marker: PhantomData LiteMap>, @@ -224,7 +224,7 @@ mod test { assert_eq!(map, deserialized); } - /// Test that a LiteMap<_, _, Vec> is deserialized with an exact capacity + /// Test that a [`LiteMap<_, _, Vec>`] is deserialized with an exact capacity /// if the deserializer provides a size hint information, like postcard here. #[test] fn test_deserialize_capacity() { diff --git a/deps/crates/vendor/litemap-v0_8/src/store/mod.rs b/deps/crates/vendor/litemap-v0_8/src/store/mod.rs index 85cf8de2d44..e6c45714368 100644 --- a/deps/crates/vendor/litemap-v0_8/src/store/mod.rs +++ b/deps/crates/vendor/litemap-v0_8/src/store/mod.rs @@ -2,21 +2,21 @@ // called LICENSE at the top level of the ICU4X source tree // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ). -//! Traits for pluggable LiteMap backends. +//! Traits for pluggable [`LiteMap`] backends. //! -//! By default, LiteMap is backed by a `Vec`. However, in some environments, it may be desirable -//! to use a different data store while still using LiteMap to manage proper ordering of items. +//! By default, [`LiteMap`] is backed by a `Vec`. However, in some environments, it may be desirable +//! to use a different data store while still using [`LiteMap`] to manage proper ordering of items. //! //! The general guidelines for a performant data store are: //! //! 1. Must support efficient random access for binary search //! 2. Should support efficient append operations for deserialization //! -//! To plug a custom data store into LiteMap, implement: +//! To plug a custom data store into [`LiteMap`], implement: //! //! - [`Store`] for most of the methods //! - [`StoreIterable`] for methods that return iterators -//! - [`StoreFromIterator`] to enable `FromIterator` for LiteMap +//! - [`StoreFromIterator`] to enable `FromIterator` for [`LiteMap`] //! //! To test your implementation, enable the `"testing"` Cargo feature and use [`check_store()`]. //! @@ -26,6 +26,8 @@ mod slice_impl; #[cfg(feature = "alloc")] mod vec_impl; +#[cfg(doc)] +use crate::LiteMap; use core::cmp::Ordering; use core::iter::DoubleEndedIterator; use core::iter::FromIterator; @@ -38,7 +40,7 @@ pub trait StoreConstEmpty { const EMPTY: Self; } -/// Trait to enable pluggable backends for LiteMap. +/// Trait to enable pluggable backends for [`LiteMap`]. /// /// Some methods have default implementations provided for convenience; however, it is generally /// better to implement all methods that your data store supports. @@ -130,7 +132,7 @@ pub trait StoreBulkMut: StoreMut { I: IntoIterator; } -/// Iterator methods for the LiteMap store. +/// Iterator methods for the [`LiteMap`] store. pub trait StoreIterable<'a, K: 'a + ?Sized, V: 'a + ?Sized>: Store { type KeyValueIter: Iterator + DoubleEndedIterator + 'a; diff --git a/deps/crates/vendor/litemap-v0_8/src/store/vec_impl.rs b/deps/crates/vendor/litemap-v0_8/src/store/vec_impl.rs index d6c6b5f7dbf..d838a3e1a3c 100644 --- a/deps/crates/vendor/litemap-v0_8/src/store/vec_impl.rs +++ b/deps/crates/vendor/litemap-v0_8/src/store/vec_impl.rs @@ -163,7 +163,7 @@ impl StoreBulkMut for Vec<(K, V)> { /// Returns two slices. The first contains no consecutive repeated elements. /// The second contains all the duplicates in no specified order. /// -/// This is based on std::slice::partition_dedup_by (currently unstable) but retains the +/// This is based on `std::slice::partition_dedup_by` (currently unstable) but retains the /// _last_ element of the duplicate run in the first slice (instead of first). #[inline] #[expect(clippy::type_complexity)] diff --git a/deps/crates/vendor/litemap-v0_8/src/testing.rs b/deps/crates/vendor/litemap-v0_8/src/testing.rs index 08ad15c63e8..d8df6e245dc 100644 --- a/deps/crates/vendor/litemap-v0_8/src/testing.rs +++ b/deps/crates/vendor/litemap-v0_8/src/testing.rs @@ -2,7 +2,7 @@ // called LICENSE at the top level of the ICU4X source tree // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ). -//! Test utilities, primarily targeted to custom LiteMap stores. +//! Test utilities, primarily targeted to custom [`LiteMap`] stores. use crate::store::*; use crate::LiteMap; @@ -115,7 +115,7 @@ where /// Tests that a litemap that uses the given store as backend has behavior consistent with the /// reference impl. /// -/// Call this function in a test with the store impl to test as a valid backend for LiteMap. +/// Call this function in a test with the store impl to test as a valid backend for [`LiteMap`]. // Test code #[expect(clippy::expect_used)] pub fn check_store<'a, S>() diff --git a/deps/crates/vendor/litemap-v0_8/tests/store.rs b/deps/crates/vendor/litemap-v0_8/tests/store.rs index 212e31b67a1..2b544976150 100644 --- a/deps/crates/vendor/litemap-v0_8/tests/store.rs +++ b/deps/crates/vendor/litemap-v0_8/tests/store.rs @@ -128,7 +128,7 @@ impl StoreIntoIterator for VecWithDefaults<(K, V)> { // leave lm_extend_start as default } -impl std::iter::FromIterator for VecWithDefaults { +impl FromIterator for VecWithDefaults { fn from_iter>(iter: I) -> Self { Self(Vec::from_iter(iter)) } diff --git a/deps/crates/vendor/potential_utf-v0_1/.cargo_vcs_info.json b/deps/crates/vendor/potential_utf-v0_1/.cargo_vcs_info.json index 8b13bc0e852..1a55c82d646 100644 --- a/deps/crates/vendor/potential_utf-v0_1/.cargo_vcs_info.json +++ b/deps/crates/vendor/potential_utf-v0_1/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "29dfe2790b6cfdab94ca6a6b69f58ce54802dbf7" + "sha1": "c9fac4e625ccb2c6a7aa35079fff9709db4385ac" }, "path_in_vcs": "utils/potential_utf" } \ No newline at end of file diff --git a/deps/crates/vendor/potential_utf-v0_1/Cargo.lock b/deps/crates/vendor/potential_utf-v0_1/Cargo.lock index dac33641d25..5677c16ec4a 100644 --- a/deps/crates/vendor/potential_utf-v0_1/Cargo.lock +++ b/deps/crates/vendor/potential_utf-v0_1/Cargo.lock @@ -13,9 +13,9 @@ dependencies = [ [[package]] name = "databake" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff6ee9e2d2afb173bcdeee45934c89ec341ab26f91c9933774fc15c2b58f83ef" +checksum = "74d4b1db5ca40636726f1f73daff0d626accbd49bcd8136fcade87d7cf1e6bbb" dependencies = [ "proc-macro2", "quote", @@ -23,19 +23,19 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.15" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" [[package]] name = "memchr" -version = "2.7.6" +version = "2.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" [[package]] name = "potential_utf" -version = "0.1.4" +version = "0.1.5" dependencies = [ "bincode", "databake", @@ -47,28 +47,22 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.103" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.41" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] -[[package]] -name = "ryu" -version = "1.0.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" - [[package]] name = "serde" version = "1.0.228" @@ -101,22 +95,22 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.145" +version = "1.0.149" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" dependencies = [ "itoa", "memchr", - "ryu", "serde", "serde_core", + "zmij", ] [[package]] name = "syn" -version = "2.0.108" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", @@ -125,9 +119,9 @@ dependencies = [ [[package]] name = "unicode-ident" -version = "1.0.20" +version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "462eeb75aeb73aea900253ce739c8e18a67423fadf006037cd3ff27e82748a06" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" [[package]] name = "writeable" @@ -137,16 +131,22 @@ checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9" [[package]] name = "zerofrom" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df" [[package]] name = "zerovec" -version = "0.11.5" +version = "0.11.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002" +checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239" dependencies = [ "serde", "zerofrom", ] + +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" diff --git a/deps/crates/vendor/potential_utf-v0_1/Cargo.toml b/deps/crates/vendor/potential_utf-v0_1/Cargo.toml index 66c21c85bb5..99aa52f1184 100644 --- a/deps/crates/vendor/potential_utf-v0_1/Cargo.toml +++ b/deps/crates/vendor/potential_utf-v0_1/Cargo.toml @@ -13,7 +13,7 @@ edition = "2021" rust-version = "1.82" name = "potential_utf" -version = "0.1.4" +version = "0.1.5" authors = ["The ICU4X Project Developers"] build = false include = [ @@ -35,7 +35,16 @@ autobenches = false description = "Unvalidated string and character types" homepage = "https://icu4x.unicode.org" readme = "README.md" -categories = ["internationalization"] +keywords = [ + "text-processing", + "encoding", +] +categories = [ + "internationalization", + "localization", + "no-std", + "embedded", +] license = "Unicode-3.0" repository = "https://github.com/unicode-org/icu4x" @@ -66,12 +75,12 @@ optional = true default-features = false [dependencies.writeable] -version = "0.6.0" +version = "0.6.1" optional = true default-features = false [dependencies.zerovec] -version = "0.11.3" +version = "0.11.6" optional = true default-features = false @@ -80,3 +89,52 @@ version = "1.3.1" [dev-dependencies.serde_json] version = "1.0.45" + +[lints.clippy] +alloc-instead-of-core = "warn" +branches-sharing-code = "warn" +collection_is_never_read = "warn" +crosspointer_transmute = "warn" +dbg_macro = "warn" +debug_assert_with_mut_call = "warn" +doc_markdown = "warn" +exhaustive_enums = "deny" +exhaustive_structs = "deny" +fn_to_numeric_cast_any = "warn" +infinite_loop = "warn" +large_stack_arrays = "warn" +mismatching_type_param_order = "warn" +missing_fields_in_debug = "warn" +missing_transmute_annotations = "warn" +negative_feature_names = "warn" +or-fun-call = "warn" +same_functions_in_if_condition = "warn" +todo = "warn" +transmute_bytes_to_str = "warn" +transmute_int_to_bool = "warn" +transmute_int_to_non_zero = "warn" +transmute_ptr_to_ptr = "warn" +transmute_ptr_to_ref = "warn" +transmute_undefined_repr = "warn" +transmutes_expressible_as_ptr_casts = "warn" +trivially_copy_pass_by_ref = "deny" +unnecessary-wraps = "warn" +useless_transmute = "warn" +wildcard_dependencies = "warn" + +[lints.rust] +missing_debug_implementations = "deny" +trivial_numeric_casts = "deny" +unused_lifetimes = "warn" +unused_macro_rules = "warn" +unused_qualifications = "warn" + +[lints.rust.unexpected_cfgs] +level = "warn" +priority = 0 +check-cfg = [ + "cfg(icu4c_enable_renaming)", + "cfg(needs_alloc_error_handler)", + "cfg(icu4x_run_size_tests)", + "cfg(icu4x_unstable_fast_trie_only)", +] diff --git a/deps/crates/vendor/potential_utf-v0_1/Cargo.toml.orig b/deps/crates/vendor/potential_utf-v0_1/Cargo.toml.orig index bf7f825b029..578ecad0c67 100644 --- a/deps/crates/vendor/potential_utf-v0_1/Cargo.toml.orig +++ b/deps/crates/vendor/potential_utf-v0_1/Cargo.toml.orig @@ -5,7 +5,7 @@ [package] name = "potential_utf" description = "Unvalidated string and character types" -version = "0.1.4" +version = "0.1.5" rust-version = "1.82" authors.workspace = true edition.workspace = true @@ -13,6 +13,7 @@ repository.workspace = true homepage.workspace = true license.workspace = true categories.workspace = true +keywords = ["text-processing", "encoding"] include.workspace = true [dependencies] @@ -32,3 +33,6 @@ databake = ["dep:databake"] serde = ["dep:serde_core"] writeable = ["dep:writeable"] zerovec = ["dep:zerovec"] + +[lints] +workspace = true diff --git a/deps/crates/vendor/potential_utf-v0_1/src/lib.rs b/deps/crates/vendor/potential_utf-v0_1/src/lib.rs index 2b343c9cbce..6c3e230faab 100644 --- a/deps/crates/vendor/potential_utf-v0_1/src/lib.rs +++ b/deps/crates/vendor/potential_utf-v0_1/src/lib.rs @@ -2,6 +2,7 @@ // called LICENSE at the top level of the ICU4X source tree // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ). +// https://github.com/unicode-org/icu4x/blob/main/documents/process/boilerplate.md#library-annotations #![cfg_attr(not(any(test, doc)), no_std)] #![cfg_attr( not(test), @@ -10,12 +11,9 @@ clippy::unwrap_used, clippy::expect_used, clippy::panic, - clippy::exhaustive_structs, - clippy::exhaustive_enums, - clippy::trivially_copy_pass_by_ref, - missing_debug_implementations, ) )] +#![warn(missing_docs)] //! A crate providing unvalidated string and character types. diff --git a/deps/crates/vendor/potential_utf-v0_1/src/uchar.rs b/deps/crates/vendor/potential_utf-v0_1/src/uchar.rs index 0157aae69eb..fc607319ded 100644 --- a/deps/crates/vendor/potential_utf-v0_1/src/uchar.rs +++ b/deps/crates/vendor/potential_utf-v0_1/src/uchar.rs @@ -77,7 +77,7 @@ impl PotentialCodePoint { char::try_from(u32::from(self)) } - /// Convert a [`PotentialCodePoint`] to a `char', returning [`char::REPLACEMENT_CHARACTER`] + /// Convert a [`PotentialCodePoint`] to a [`char`], returning [`char::REPLACEMENT_CHARACTER`] /// if the `PotentialCodePoint` does not represent a valid Unicode scalar value. /// /// # Examples diff --git a/deps/crates/vendor/potential_utf-v0_1/src/ustr.rs b/deps/crates/vendor/potential_utf-v0_1/src/ustr.rs index 7e299c1b798..04afc812e51 100644 --- a/deps/crates/vendor/potential_utf-v0_1/src/ustr.rs +++ b/deps/crates/vendor/potential_utf-v0_1/src/ustr.rs @@ -61,7 +61,7 @@ impl PotentialUtf8 { #[inline] pub const fn from_bytes(other: &[u8]) -> &Self { // Safety: PotentialUtf8 is transparent over [u8] - unsafe { core::mem::transmute(other) } + unsafe { &*(other as *const [u8] as *const Self) } } /// Create a [`PotentialUtf8`] from a string slice. @@ -77,7 +77,7 @@ impl PotentialUtf8 { #[cfg(feature = "alloc")] pub fn from_boxed_bytes(other: Box<[u8]>) -> Box { // Safety: PotentialUtf8 is transparent over [u8] - unsafe { core::mem::transmute(other) } + unsafe { core::mem::transmute::, Box>(other) } } /// Create a [`PotentialUtf8`] from a boxed `str`. @@ -89,7 +89,7 @@ impl PotentialUtf8 { Self::from_boxed_bytes(other.into_boxed_bytes()) } - /// Get the bytes from a [`PotentialUtf8]. + /// Get the bytes from a [`PotentialUtf8`]. #[inline] pub const fn as_bytes(&self) -> &[u8] { &self.0 @@ -246,6 +246,9 @@ where } } +/// A `u16` slice that is expected to be a UTF-16 string but does not enforce that invariant. +/// +/// See [`PotentialUtf8`] for more info. #[repr(transparent)] #[derive(PartialEq, Eq, PartialOrd, Ord)] #[allow(clippy::exhaustive_structs)] // transparent newtype @@ -269,9 +272,12 @@ impl PotentialUtf16 { #[inline] pub const fn from_slice(other: &[u16]) -> &Self { // Safety: PotentialUtf16 is transparent over [u16] - unsafe { core::mem::transmute(other) } + unsafe { &*(other as *const [u16] as *const Self) } } + /// Iterates the characters of the string. + /// + /// Returns [`char::REPLACEMENT_CHARACTER`] if invalid surrogates are encountered. pub fn chars(&self) -> impl Iterator + '_ { char::decode_utf16(self.0.iter().copied()).map(|c| c.unwrap_or(char::REPLACEMENT_CHARACTER)) } diff --git a/deps/crates/vendor/quote-v1/.cargo_vcs_info.json b/deps/crates/vendor/quote-v1/.cargo_vcs_info.json index 47b82ff031e..ec14844c679 100644 --- a/deps/crates/vendor/quote-v1/.cargo_vcs_info.json +++ b/deps/crates/vendor/quote-v1/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "842ffde933fdd76cd1681a288bed136d8b95a97a" + "sha1": "bc4caf255fa9e58e025e5ff5a11ca948442c0f7a" }, "path_in_vcs": "" } \ No newline at end of file diff --git a/deps/crates/vendor/quote-v1/.github/workflows/ci.yml b/deps/crates/vendor/quote-v1/.github/workflows/ci.yml index 9cf199aae29..0fd6a9b6b7c 100644 --- a/deps/crates/vendor/quote-v1/.github/workflows/ci.yml +++ b/deps/crates/vendor/quote-v1/.github/workflows/ci.yml @@ -24,10 +24,10 @@ jobs: strategy: fail-fast: false matrix: - rust: [nightly, stable, beta, 1.83.0, 1.71.0] + rust: [nightly, stable, beta, 1.85.0, 1.71.0] timeout-minutes: 45 steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: dtolnay/rust-toolchain@master with: toolchain: ${{matrix.rust}} @@ -53,7 +53,7 @@ jobs: runs-on: ubuntu-latest timeout-minutes: 45 steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: dtolnay/rust-toolchain@nightly - run: cargo generate-lockfile -Z minimal-versions - run: cargo check --locked @@ -67,7 +67,7 @@ jobs: env: RUSTDOCFLAGS: -Dwarnings steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: dtolnay/rust-toolchain@nightly with: components: rust-src @@ -80,7 +80,7 @@ jobs: if: github.event_name != 'pull_request' timeout-minutes: 45 steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: dtolnay/rust-toolchain@nightly with: components: clippy, rust-src @@ -93,7 +93,7 @@ jobs: runs-on: ubuntu-latest timeout-minutes: 45 steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: dtolnay/rust-toolchain@miri - run: cargo miri setup - run: cargo miri test @@ -106,7 +106,7 @@ jobs: if: github.event_name != 'pull_request' timeout-minutes: 45 steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: dtolnay/rust-toolchain@stable - uses: dtolnay/install@cargo-outdated - run: cargo outdated --workspace --exit-code 1 diff --git a/deps/crates/vendor/quote-v1/Cargo.lock b/deps/crates/vendor/quote-v1/Cargo.lock index e1a3311be04..8b7a0ab3875 100644 --- a/deps/crates/vendor/quote-v1/Cargo.lock +++ b/deps/crates/vendor/quote-v1/Cargo.lock @@ -4,9 +4,9 @@ version = 3 [[package]] name = "dissimilar" -version = "1.0.10" +version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8975ffdaa0ef3661bfe02dbdcc06c9f829dfafe6a3c474de366a8d5e44276921" +checksum = "aeda16ab4059c5fd2a83f2b9c9e9c981327b18aa8e3b313f7e6563799d4f093e" [[package]] name = "equivalent" @@ -22,15 +22,15 @@ checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" [[package]] name = "hashbrown" -version = "0.16.1" +version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" [[package]] name = "indexmap" -version = "2.13.0" +version = "2.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" dependencies = [ "equivalent", "hashbrown", @@ -38,15 +38,15 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.17" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" [[package]] name = "memchr" -version = "2.8.0" +version = "2.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" +checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4" [[package]] name = "proc-macro2" @@ -59,16 +59,16 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.44" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] [[package]] name = "quote" -version = "1.0.45" +version = "1.0.46" dependencies = [ "proc-macro2", "rustversion", @@ -106,15 +106,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", - "quote 1.0.44", + "quote 1.0.45", "syn", ] [[package]] name = "serde_json" -version = "1.0.149" +version = "1.0.150" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" +checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9" dependencies = [ "itoa", "memchr", @@ -125,21 +125,21 @@ dependencies = [ [[package]] name = "serde_spanned" -version = "1.0.4" +version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776" +checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26" dependencies = [ "serde_core", ] [[package]] name = "syn" -version = "2.0.117" +version = "2.0.118" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422" dependencies = [ "proc-macro2", - "quote 1.0.44", + "quote 1.0.45", "unicode-ident", ] @@ -160,9 +160,9 @@ dependencies = [ [[package]] name = "toml" -version = "1.0.3+spec-1.1.0" +version = "1.1.2+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7614eaf19ad818347db24addfa201729cf2a9b6fdfd9eb0ab870fcacc606c0c" +checksum = "81f3d15e84cbcd896376e6730314d59fb5a87f31e4b038454184435cd57defee" dependencies = [ "indexmap", "serde_core", @@ -175,33 +175,33 @@ dependencies = [ [[package]] name = "toml_datetime" -version = "1.0.0+spec-1.1.0" +version = "1.1.1+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32c2555c699578a4f59f0cc68e5116c8d7cabbd45e1409b989d4be085b53f13e" +checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7" dependencies = [ "serde_core", ] [[package]] name = "toml_parser" -version = "1.0.9+spec-1.1.0" +version = "1.1.2+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "702d4415e08923e7e1ef96cd5727c0dfed80b4d2fa25db9647fe5eb6f7c5a4c4" +checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526" dependencies = [ "winnow", ] [[package]] name = "toml_writer" -version = "1.0.6+spec-1.1.0" +version = "1.1.1+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607" +checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db" [[package]] name = "trybuild" -version = "1.0.116" +version = "1.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47c635f0191bd3a2941013e5062667100969f8c4e9cd787c14f977265d73616e" +checksum = "0710d4dfbeae4f9c390baa784c49858a7468fa433f3fe5d0ec5ebef651cf59f9" dependencies = [ "dissimilar", "glob", @@ -245,9 +245,9 @@ dependencies = [ [[package]] name = "winnow" -version = "0.7.14" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829" +checksum = "0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1" [[package]] name = "zmij" diff --git a/deps/crates/vendor/quote-v1/Cargo.toml b/deps/crates/vendor/quote-v1/Cargo.toml index dcd4104c5d4..ec798b6d61f 100644 --- a/deps/crates/vendor/quote-v1/Cargo.toml +++ b/deps/crates/vendor/quote-v1/Cargo.toml @@ -13,7 +13,7 @@ edition = "2021" rust-version = "1.71" name = "quote" -version = "1.0.45" +version = "1.0.46" authors = ["David Tolnay "] build = "build.rs" autolib = false diff --git a/deps/crates/vendor/quote-v1/Cargo.toml.orig b/deps/crates/vendor/quote-v1/Cargo.toml.orig index ac1426a6c5f..37478a01978 100644 --- a/deps/crates/vendor/quote-v1/Cargo.toml.orig +++ b/deps/crates/vendor/quote-v1/Cargo.toml.orig @@ -1,6 +1,6 @@ [package] name = "quote" -version = "1.0.45" +version = "1.0.46" authors = ["David Tolnay "] autobenches = false categories = ["development-tools::procedural-macro-helpers"] diff --git a/deps/crates/vendor/quote-v1/src/lib.rs b/deps/crates/vendor/quote-v1/src/lib.rs index bdad175e2a6..fd83c97f5d2 100644 --- a/deps/crates/vendor/quote-v1/src/lib.rs +++ b/deps/crates/vendor/quote-v1/src/lib.rs @@ -89,7 +89,7 @@ //! [prettyplease]: https://github.com/dtolnay/prettyplease #![no_std] -#![doc(html_root_url = "https://docs.rs/quote/1.0.45")] +#![doc(html_root_url = "https://docs.rs/quote/1.0.46")] #![allow( clippy::doc_markdown, clippy::elidable_lifetime_names, @@ -525,157 +525,145 @@ __quote![ } ]; -macro_rules! __quote_spanned { - ($quote_spanned:item) => { - /// Same as `quote!`, but applies a given span to all tokens originating within - /// the macro invocation. - /// - ///
    - /// - /// # Syntax - /// - /// A span expression of type [`Span`], followed by `=>`, followed by the tokens - /// to quote. The span expression should be brief — use a variable for - /// anything more than a few characters. There should be no space before the - /// `=>` token. - /// - /// [`Span`]: proc_macro2::Span - /// - /// ``` - /// # use proc_macro2::Span; - /// # use quote::quote_spanned; - /// # - /// # const IGNORE_TOKENS: &'static str = stringify! { - /// let span = /* ... */; - /// # }; - /// # let span = Span::call_site(); - /// # let init = 0; - /// - /// // On one line, use parentheses. - /// let tokens = quote_spanned!(span=> Box::into_raw(Box::new(#init))); - /// - /// // On multiple lines, place the span at the top and use braces. - /// let tokens = quote_spanned! {span=> - /// Box::into_raw(Box::new(#init)) - /// }; - /// ``` - /// - /// The lack of space before the `=>` should look jarring to Rust programmers - /// and this is intentional. The formatting is designed to be visibly - /// off-balance and draw the eye a particular way, due to the span expression - /// being evaluated in the context of the procedural macro and the remaining - /// tokens being evaluated in the generated code. - /// - ///
    - /// - /// # Hygiene - /// - /// Any interpolated tokens preserve the `Span` information provided by their - /// `ToTokens` implementation. Tokens that originate within the `quote_spanned!` - /// invocation are spanned with the given span argument. - /// - ///
    - /// - /// # Example - /// - /// The following procedural macro code uses `quote_spanned!` to assert that a - /// particular Rust type implements the [`Sync`] trait so that references can be - /// safely shared between threads. - /// - /// ``` - /// # use quote::{quote_spanned, TokenStreamExt, ToTokens}; - /// # use proc_macro2::{Span, TokenStream}; - /// # - /// # struct Type; - /// # - /// # impl Type { - /// # fn span(&self) -> Span { - /// # Span::call_site() - /// # } - /// # } - /// # - /// # impl ToTokens for Type { - /// # fn to_tokens(&self, _tokens: &mut TokenStream) {} - /// # } - /// # - /// # let ty = Type; - /// # let call_site = Span::call_site(); - /// # - /// let ty_span = ty.span(); - /// let assert_sync = quote_spanned! {ty_span=> - /// struct _AssertSync where #ty: Sync; - /// }; - /// ``` - /// - /// If the assertion fails, the user will see an error like the following. The - /// input span of their type is highlighted in the error. - /// - /// ```text - /// error[E0277]: the trait bound `*const (): std::marker::Sync` is not satisfied - /// --> src/main.rs:10:21 - /// | - /// 10 | static ref PTR: *const () = &(); - /// | ^^^^^^^^^ `*const ()` cannot be shared between threads safely - /// ``` - /// - /// In this example it is important for the where-clause to be spanned with the - /// line/column information of the user's input type so that error messages are - /// placed appropriately by the compiler. - $quote_spanned - }; +/// Same as `quote!`, but applies a given span to all tokens originating within +/// the macro invocation. +/// +///
    +/// +/// # Syntax +/// +/// A span expression of type [`Span`], followed by `=>`, followed by the tokens +/// to quote. The span expression should be brief — use a variable for +/// anything more than a few characters. There should be no space before the +/// `=>` token. +/// +/// [`Span`]: proc_macro2::Span +/// +/// ``` +/// # use proc_macro2::Span; +/// # use quote::quote_spanned; +/// # +/// # const IGNORE_TOKENS: &'static str = stringify! { +/// let span = /* ... */; +/// # }; +/// # let span = Span::call_site(); +/// # let init = 0; +/// +/// // On one line, use parentheses. +/// let tokens = quote_spanned!(span=> Box::into_raw(Box::new(#init))); +/// +/// // On multiple lines, place the span at the top and use braces. +/// let tokens = quote_spanned! {span=> +/// Box::into_raw(Box::new(#init)) +/// }; +/// ``` +/// +/// The lack of space before the `=>` should look jarring to Rust programmers +/// and this is intentional. The formatting is designed to be visibly +/// off-balance and draw the eye a particular way, due to the span expression +/// being evaluated in the context of the procedural macro and the remaining +/// tokens being evaluated in the generated code. +/// +///
    +/// +/// # Hygiene +/// +/// Any interpolated tokens preserve the `Span` information provided by their +/// `ToTokens` implementation. Tokens that originate within the `quote_spanned!` +/// invocation are spanned with the given span argument. +/// +///
    +/// +/// # Example +/// +/// The following procedural macro code uses `quote_spanned!` to assert that a +/// particular Rust type implements the [`Sync`] trait so that references can be +/// safely shared between threads. +/// +/// ``` +/// # use quote::{quote_spanned, TokenStreamExt, ToTokens}; +/// # use proc_macro2::{Span, TokenStream}; +/// # +/// # struct Type; +/// # +/// # impl Type { +/// # fn span(&self) -> Span { +/// # Span::call_site() +/// # } +/// # } +/// # +/// # impl ToTokens for Type { +/// # fn to_tokens(&self, _tokens: &mut TokenStream) {} +/// # } +/// # +/// # let ty = Type; +/// # let call_site = Span::call_site(); +/// # +/// let ty_span = ty.span(); +/// let assert_sync = quote_spanned! {ty_span=> +/// struct _AssertSync where #ty: Sync; +/// }; +/// ``` +/// +/// If the assertion fails, the user will see an error like the following. The +/// input span of their type is highlighted in the error. +/// +/// ```text +/// error[E0277]: the trait bound `*const (): std::marker::Sync` is not satisfied +/// --> src/main.rs:10:21 +/// | +/// 10 | static ref PTR: *const () = &(); +/// | ^^^^^^^^^ `*const ()` cannot be shared between threads safely +/// ``` +/// +/// In this example it is important for the where-clause to be spanned with the +/// line/column information of the user's input type so that error messages are +/// placed appropriately by the compiler. +#[macro_export] +macro_rules! quote_spanned { + ($span:expr=> $($tt:tt)*) => {{ + let _span: $crate::__private::Span = $crate::__private::get_span($span).__into_span(); + $crate::quote_spanned_with_expanded_span!{_span $($tt)*} + }}; } -#[cfg(doc)] -__quote_spanned![ - #[macro_export] - macro_rules! quote_spanned { - ($span:expr=> $($tt:tt)*) => { - ... - }; - } -]; - -#[cfg(not(doc))] -__quote_spanned![ - #[macro_export] - macro_rules! quote_spanned { - ($span:expr=>) => {{ - let _: $crate::__private::Span = $crate::__private::get_span($span).__into_span(); - $crate::__private::TokenStream::new() - }}; +// We want to ensure that `get_span` only gets called for the actual user +// invocation and not for recursive calls from groups, which will call this +// inner macro instead. +#[macro_export] +#[doc(hidden)] +macro_rules! quote_spanned_with_expanded_span { + ($span:ident) => { + $crate::__private::TokenStream::new() + }; - // Special case rule for a single tt, for performance. - ($span:expr=> $tt:tt) => {{ - let mut _s = $crate::__private::TokenStream::new(); - let _span: $crate::__private::Span = $crate::__private::get_span($span).__into_span(); - $crate::quote_token_spanned!{$tt _s _span} - _s - }}; + // Special case rule for a single tt, for performance. + ($span:ident $tt:tt) => { + let mut _s = $crate::__private::TokenStream::new(); + $crate::quote_token_spanned!{$tt _s $span} + _s + }; - // Special case rules for two tts, for performance. - ($span:expr=> # $var:ident) => {{ - let mut _s = $crate::__private::TokenStream::new(); - let _: $crate::__private::Span = $crate::__private::get_span($span).__into_span(); - $crate::ToTokens::to_tokens(&$var, &mut _s); - _s - }}; - ($span:expr=> $tt1:tt $tt2:tt) => {{ - let mut _s = $crate::__private::TokenStream::new(); - let _span: $crate::__private::Span = $crate::__private::get_span($span).__into_span(); - $crate::quote_token_spanned!{$tt1 _s _span} - $crate::quote_token_spanned!{$tt2 _s _span} - _s - }}; + // Special case rules for two tts, for performance. + ($span:ident # $var:ident) => { + let mut _s = $crate::__private::TokenStream::new(); + $crate::ToTokens::to_tokens(&$var, &mut _s); + _s + }; + ($span:ident $tt1:tt $tt2:tt) => { + let mut _s = $crate::__private::TokenStream::new(); + $crate::quote_token_spanned!{$tt1 _s $span} + $crate::quote_token_spanned!{$tt2 _s $span} + _s + }; - // Rule for any other number of tokens. - ($span:expr=> $($tt:tt)*) => {{ - let mut _s = $crate::__private::TokenStream::new(); - let _span: $crate::__private::Span = $crate::__private::get_span($span).__into_span(); - $crate::quote_each_token_spanned!{_s _span $($tt)*} - _s - }}; - } -]; + // Rule for any other number of tokens. + ($span:ident $($tt:tt)*) => { + let mut _s = $crate::__private::TokenStream::new(); + $crate::quote_each_token_spanned!{_s $span $($tt)*} + _s + }; +} // Extract the names of all #metavariables and pass them to the $call macro. // @@ -1261,7 +1249,9 @@ macro_rules! quote_token_spanned { &mut $tokens, $span, $crate::__private::Delimiter::Parenthesis, - $crate::quote_spanned!($span=> $($inner)*), + { + $crate::quote_spanned_with_expanded_span!{$span $($inner)*} + }, ); }; @@ -1270,7 +1260,9 @@ macro_rules! quote_token_spanned { &mut $tokens, $span, $crate::__private::Delimiter::Bracket, - $crate::quote_spanned!($span=> $($inner)*), + { + $crate::quote_spanned_with_expanded_span!{$span $($inner)*} + }, ); }; @@ -1279,7 +1271,9 @@ macro_rules! quote_token_spanned { &mut $tokens, $span, $crate::__private::Delimiter::Brace, - $crate::quote_spanned!($span=> $($inner)*), + { + $crate::quote_spanned_with_expanded_span!{$span $($inner)*} + }, ); }; diff --git a/deps/crates/vendor/quote-v1/src/to_tokens.rs b/deps/crates/vendor/quote-v1/src/to_tokens.rs index b8eadf5b315..aff1a71bdb8 100644 --- a/deps/crates/vendor/quote-v1/src/to_tokens.rs +++ b/deps/crates/vendor/quote-v1/src/to_tokens.rs @@ -1,5 +1,4 @@ use super::TokenStreamExt; -use std::sync::Arc; use alloc::borrow::{Cow, ToOwned}; use alloc::boxed::Box; use alloc::ffi::CString; @@ -8,6 +7,7 @@ use alloc::string::String; use core::ffi::CStr; use core::iter; use proc_macro2::{Group, Ident, Literal, Punct, Span, TokenStream, TokenTree}; +use std::sync::Arc; /// Types that can be interpolated inside a `quote!` invocation. pub trait ToTokens { diff --git a/deps/crates/vendor/smallvec-v1/.cargo_vcs_info.json b/deps/crates/vendor/smallvec-v1/.cargo_vcs_info.json index 931891889f1..effc7e1db37 100644 --- a/deps/crates/vendor/smallvec-v1/.cargo_vcs_info.json +++ b/deps/crates/vendor/smallvec-v1/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "d0f47a3ea99296498ee940b5d99f59b403c498a2" + "sha1": "c469051a1ba05ef1a03dd69e14b4a5aa329e6f10" }, "path_in_vcs": "" } \ No newline at end of file diff --git a/deps/crates/vendor/smallvec-v1/.github/workflows/main.yml b/deps/crates/vendor/smallvec-v1/.github/workflows/main.yml deleted file mode 100644 index e2e83f1b28c..00000000000 --- a/deps/crates/vendor/smallvec-v1/.github/workflows/main.yml +++ /dev/null @@ -1,114 +0,0 @@ -name: CI - -on: - push: - branches: [v1] - pull_request: - workflow_dispatch: - merge_group: - types: [checks_requested] - -jobs: - ci: - name: Build/Test - strategy: - matrix: - toolchain: ["stable", "beta", "nightly", "1.36.0"] - os: [ubuntu-latest] - include: - - toolchain: stable - fuzz: 0 - - toolchain: beta - fuzz: 0 - - os: windows-latest - toolchain: nightly - - runs-on: ${{ matrix.os }} - - steps: - - uses: actions/checkout@v4 - - - name: Install packages for fuzzing - if: runner.os == 'Linux' && matrix.fuzz == 1 - run: sudo apt-get update -y && sudo apt-get install -y binutils-dev libunwind8-dev libcurl4-openssl-dev libelf-dev libdw-dev cmake gcc libiberty-dev - - - name: Install toolchain - uses: dtolnay/rust-toolchain@master - with: - toolchain: ${{ matrix.toolchain }} - - - name: Cargo build - run: cargo build --verbose - - - name: Cargo test - if: matrix.toolchain != '1.36.0' - run: cargo test --verbose - - - name: Cargo test w/ serde - if: matrix.toolchain != '1.36.0' - run: cargo test --verbose --features serde - - - name: Cargo test w/ malloc_size_of - if: matrix.toolchain != '1.36.0' - run: cargo test --verbose --features malloc_size_of - - - name: Cargo check w/o default features - if: matrix.toolchain == 'nightly' - run: cargo check --verbose --no-default-features - - - name: Cargo test w/ union - if: matrix.toolchain == 'beta' - run: cargo test --verbose --features union - - - name: Cargo test w/ debugger_visualizer - if: matrix.toolchain == 'nightly' - run: cargo test --test debugger_visualizer --verbose --features debugger_visualizer -- --test-threads=1 - - - name: Cargo test w/ debugger_visualizer and union - if: matrix.toolchain == 'nightly' - run: cargo test --test debugger_visualizer --verbose --features 'debugger_visualizer,union' -- --test-threads=1 - - - name: Cargo test all features - if: matrix.toolchain == 'nightly' - run: cargo test --verbose --all-features - - - name: Cargo bench - if: matrix.toolchain == 'nightly' - run: cargo bench --verbose bench - - - name: miri - if: matrix.toolchain == 'nightly' && matrix.os == 'ubuntu-latest' - run: bash ./scripts/run_miri.sh - - - name: fuzz - if: matrix.fuzz == 1 - working-directory: fuzz - run: ./travis-fuzz.sh - - no-std: - name: no_std - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - - name: Install toolchain - uses: dtolnay/rust-toolchain@master - with: - toolchain: stable - target: thumbv7m-none-eabi - - name: Cargo build - run: cargo build --verbose - - build_result: - name: Result - runs-on: ubuntu-latest - needs: - - "ci" - - "no-std" - - steps: - - name: Mark the job as successful - run: exit 0 - if: success() - - name: Mark the job as unsuccessful - run: exit 1 - if: "!success()" diff --git a/deps/crates/vendor/smallvec-v1/.gitignore b/deps/crates/vendor/smallvec-v1/.gitignore deleted file mode 100644 index 514974de698..00000000000 --- a/deps/crates/vendor/smallvec-v1/.gitignore +++ /dev/null @@ -1,4 +0,0 @@ -target -/Cargo.lock -/fuzz/hfuzz_target -/.vscode diff --git a/deps/crates/vendor/smallvec-v1/Cargo.lock b/deps/crates/vendor/smallvec-v1/Cargo.lock index 79606a4229c..800616ecaa5 100644 --- a/deps/crates/vendor/smallvec-v1/Cargo.lock +++ b/deps/crates/vendor/smallvec-v1/Cargo.lock @@ -4,24 +4,24 @@ version = 4 [[package]] name = "aho-corasick" -version = "1.1.3" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +checksum = "43f6cb1bf222025340178f382c426f13757b2960e89779dfcb319c32542a5a41" dependencies = [ "memchr", ] [[package]] name = "anyhow" -version = "1.0.98" +version = "1.0.71" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487" +checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8" [[package]] name = "arbitrary" -version = "1.4.1" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223" +checksum = "c38b6b6b79f671c25e1a3e785b7b82d7562ffc9cd3efdc98627e5668a2472490" [[package]] name = "bincode" @@ -50,7 +50,7 @@ dependencies = [ "anyhow", "log", "quote", - "syn 1.0.109", + "syn", ] [[package]] @@ -66,9 +66,9 @@ dependencies = [ [[package]] name = "log" -version = "0.4.27" +version = "0.4.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" +checksum = "b06a4cde4c0f271a446782e3eff8de789548ce57dbc8eca9292c27f4a42004b4" [[package]] name = "malloc_size_of" @@ -78,33 +78,33 @@ checksum = "e5d719de8b8f230028cf8192ae4c1b25267cd6b8a99d2747d345a70b8c81aa13" [[package]] name = "memchr" -version = "2.7.4" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" +checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d" [[package]] name = "proc-macro2" -version = "1.0.95" +version = "1.0.63" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778" +checksum = "7b368fba921b0dce7e60f5e04ec15e565b3303972b42bcfde1d0713b881959eb" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.40" +version = "1.0.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d" +checksum = "573015e8ab27661678357f27dc26460738fd2b6c86e46f386fde94cb5d913105" dependencies = [ "proc-macro2", ] [[package]] name = "regex" -version = "1.11.1" +version = "1.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" +checksum = "89089e897c013b3deb627116ae56a6955a72b8bed395c9526af31c9fe528b484" dependencies = [ "aho-corasick", "memchr", @@ -114,9 +114,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.9" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" +checksum = "fa250384981ea14565685dea16a9ccc4d1c541a13f82b9c168572264d1df8c56" dependencies = [ "aho-corasick", "memchr", @@ -125,33 +125,19 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.5" +version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" +checksum = "2ab07dc67230e4a4718e70fd5c20055a4334b121f1f9db8fe63ef39ce9b8c846" [[package]] name = "serde" -version = "1.0.219" +version = "1.0.137" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6" -dependencies = [ - "serde_derive", -] - -[[package]] -name = "serde_derive" -version = "1.0.219" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.101", -] +checksum = "61ea8d54c77f8315140a05f4c7237403bf38b72704d031543aa1d16abbf517d1" [[package]] name = "smallvec" -version = "1.15.1" +version = "1.15.2" dependencies = [ "arbitrary", "bincode 1.3.3", @@ -174,22 +160,11 @@ dependencies = [ "unicode-ident", ] -[[package]] -name = "syn" -version = "2.0.101" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - [[package]] name = "unicode-ident" -version = "1.0.18" +version = "1.0.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" +checksum = "22049a19f4a68748a168c0fc439f9516686aa045927ff767eca0a85101fb6e73" [[package]] name = "unty" diff --git a/deps/crates/vendor/smallvec-v1/Cargo.toml b/deps/crates/vendor/smallvec-v1/Cargo.toml index d9a4f3b2e06..dc72f6ef41e 100644 --- a/deps/crates/vendor/smallvec-v1/Cargo.toml +++ b/deps/crates/vendor/smallvec-v1/Cargo.toml @@ -12,9 +12,16 @@ [package] edition = "2018" name = "smallvec" -version = "1.15.1" +version = "1.15.2" authors = ["The Servo Project Developers"] build = false +include = [ + "Cargo.toml", + "LICENSE-MIT", + "LICENSE-APACHE", + "README.md", + "src/**/*.rs", +] autolib = false autobins = false autoexamples = false @@ -61,20 +68,6 @@ write = [] name = "smallvec" path = "src/lib.rs" -[[test]] -name = "debugger_visualizer" -path = "tests/debugger_visualizer.rs" -test = false -required-features = ["debugger_visualizer"] - -[[test]] -name = "macro" -path = "tests/macro.rs" - -[[bench]] -name = "bench" -path = "benches/bench.rs" - [dependencies.arbitrary] version = "1" optional = true diff --git a/deps/crates/vendor/smallvec-v1/Cargo.toml.orig b/deps/crates/vendor/smallvec-v1/Cargo.toml.orig index 81ea432ac6e..b411d44bc66 100644 --- a/deps/crates/vendor/smallvec-v1/Cargo.toml.orig +++ b/deps/crates/vendor/smallvec-v1/Cargo.toml.orig @@ -1,6 +1,6 @@ [package] name = "smallvec" -version = "1.15.1" +version = "1.15.2" edition = "2018" authors = ["The Servo Project Developers"] license = "MIT OR Apache-2.0" @@ -10,6 +10,7 @@ keywords = ["small", "vec", "vector", "stack", "no_std"] categories = ["data-structures"] readme = "README.md" documentation = "https://docs.rs/smallvec/" +include = ["Cargo.toml", "LICENSE-MIT", "LICENSE-APACHE", "README.md", "src/**/*.rs"] [features] const_generics = [] diff --git a/deps/crates/vendor/smallvec-v1/benches/bench.rs b/deps/crates/vendor/smallvec-v1/benches/bench.rs deleted file mode 100644 index b6a8b857d3e..00000000000 --- a/deps/crates/vendor/smallvec-v1/benches/bench.rs +++ /dev/null @@ -1,312 +0,0 @@ -#![feature(test)] -#![allow(deprecated)] - -extern crate test; - -use self::test::Bencher; -use smallvec::{ExtendFromSlice, smallvec, SmallVec}; - -const VEC_SIZE: usize = 16; -const SPILLED_SIZE: usize = 100; - -trait Vector: for<'a> From<&'a [T]> + Extend + ExtendFromSlice { - fn new() -> Self; - fn push(&mut self, val: T); - fn pop(&mut self) -> Option; - fn remove(&mut self, p: usize) -> T; - fn insert(&mut self, n: usize, val: T); - fn from_elem(val: T, n: usize) -> Self; - fn from_elems(val: &[T]) -> Self; -} - -impl Vector for Vec { - fn new() -> Self { - Self::with_capacity(VEC_SIZE) - } - - fn push(&mut self, val: T) { - self.push(val) - } - - fn pop(&mut self) -> Option { - self.pop() - } - - fn remove(&mut self, p: usize) -> T { - self.remove(p) - } - - fn insert(&mut self, n: usize, val: T) { - self.insert(n, val) - } - - fn from_elem(val: T, n: usize) -> Self { - vec![val; n] - } - - fn from_elems(val: &[T]) -> Self { - val.to_owned() - } -} - -impl Vector for SmallVec<[T; VEC_SIZE]> { - fn new() -> Self { - Self::new() - } - - fn push(&mut self, val: T) { - self.push(val) - } - - fn pop(&mut self) -> Option { - self.pop() - } - - fn remove(&mut self, p: usize) -> T { - self.remove(p) - } - - fn insert(&mut self, n: usize, val: T) { - self.insert(n, val) - } - - fn from_elem(val: T, n: usize) -> Self { - smallvec![val; n] - } - - fn from_elems(val: &[T]) -> Self { - SmallVec::from_slice(val) - } -} - -macro_rules! make_benches { - ($typ:ty { $($b_name:ident => $g_name:ident($($args:expr),*),)* }) => { - $( - #[bench] - fn $b_name(b: &mut Bencher) { - $g_name::<$typ>($($args,)* b) - } - )* - } -} - -make_benches! { - SmallVec<[u64; VEC_SIZE]> { - bench_push => gen_push(SPILLED_SIZE as _), - bench_push_small => gen_push(VEC_SIZE as _), - bench_insert_push => gen_insert_push(SPILLED_SIZE as _), - bench_insert_push_small => gen_insert_push(VEC_SIZE as _), - bench_insert => gen_insert(SPILLED_SIZE as _), - bench_insert_small => gen_insert(VEC_SIZE as _), - bench_remove => gen_remove(SPILLED_SIZE as _), - bench_remove_small => gen_remove(VEC_SIZE as _), - bench_extend => gen_extend(SPILLED_SIZE as _), - bench_extend_small => gen_extend(VEC_SIZE as _), - bench_from_iter => gen_from_iter(SPILLED_SIZE as _), - bench_from_iter_small => gen_from_iter(VEC_SIZE as _), - bench_from_slice => gen_from_slice(SPILLED_SIZE as _), - bench_from_slice_small => gen_from_slice(VEC_SIZE as _), - bench_extend_from_slice => gen_extend_from_slice(SPILLED_SIZE as _), - bench_extend_from_slice_small => gen_extend_from_slice(VEC_SIZE as _), - bench_macro_from_elem => gen_from_elem(SPILLED_SIZE as _), - bench_macro_from_elem_small => gen_from_elem(VEC_SIZE as _), - bench_pushpop => gen_pushpop(), - } -} - -make_benches! { - Vec { - bench_push_vec => gen_push(SPILLED_SIZE as _), - bench_push_vec_small => gen_push(VEC_SIZE as _), - bench_insert_push_vec => gen_insert_push(SPILLED_SIZE as _), - bench_insert_push_vec_small => gen_insert_push(VEC_SIZE as _), - bench_insert_vec => gen_insert(SPILLED_SIZE as _), - bench_insert_vec_small => gen_insert(VEC_SIZE as _), - bench_remove_vec => gen_remove(SPILLED_SIZE as _), - bench_remove_vec_small => gen_remove(VEC_SIZE as _), - bench_extend_vec => gen_extend(SPILLED_SIZE as _), - bench_extend_vec_small => gen_extend(VEC_SIZE as _), - bench_from_iter_vec => gen_from_iter(SPILLED_SIZE as _), - bench_from_iter_vec_small => gen_from_iter(VEC_SIZE as _), - bench_from_slice_vec => gen_from_slice(SPILLED_SIZE as _), - bench_from_slice_vec_small => gen_from_slice(VEC_SIZE as _), - bench_extend_from_slice_vec => gen_extend_from_slice(SPILLED_SIZE as _), - bench_extend_from_slice_vec_small => gen_extend_from_slice(VEC_SIZE as _), - bench_macro_from_elem_vec => gen_from_elem(SPILLED_SIZE as _), - bench_macro_from_elem_vec_small => gen_from_elem(VEC_SIZE as _), - bench_pushpop_vec => gen_pushpop(), - } -} - -fn gen_push>(n: u64, b: &mut Bencher) { - #[inline(never)] - fn push_noinline>(vec: &mut V, x: u64) { - vec.push(x); - } - - b.iter(|| { - let mut vec = V::new(); - for x in 0..n { - push_noinline(&mut vec, x); - } - vec - }); -} - -fn gen_insert_push>(n: u64, b: &mut Bencher) { - #[inline(never)] - fn insert_push_noinline>(vec: &mut V, x: u64) { - vec.insert(x as usize, x); - } - - b.iter(|| { - let mut vec = V::new(); - for x in 0..n { - insert_push_noinline(&mut vec, x); - } - vec - }); -} - -fn gen_insert>(n: u64, b: &mut Bencher) { - #[inline(never)] - fn insert_noinline>(vec: &mut V, p: usize, x: u64) { - vec.insert(p, x) - } - - b.iter(|| { - let mut vec = V::new(); - // Always insert at position 0 so that we are subject to shifts of - // many different lengths. - vec.push(0); - for x in 0..n { - insert_noinline(&mut vec, 0, x); - } - vec - }); -} - -fn gen_remove>(n: usize, b: &mut Bencher) { - #[inline(never)] - fn remove_noinline>(vec: &mut V, p: usize) -> u64 { - vec.remove(p) - } - - b.iter(|| { - let mut vec = V::from_elem(0, n as _); - - for _ in 0..n { - remove_noinline(&mut vec, 0); - } - }); -} - -fn gen_extend>(n: u64, b: &mut Bencher) { - b.iter(|| { - let mut vec = V::new(); - vec.extend(0..n); - vec - }); -} - -fn gen_from_iter>(n: u64, b: &mut Bencher) { - let v: Vec = (0..n).collect(); - b.iter(|| { - let vec = V::from(&v); - vec - }); -} - -fn gen_from_slice>(n: u64, b: &mut Bencher) { - let v: Vec = (0..n).collect(); - b.iter(|| { - let vec = V::from_elems(&v); - vec - }); -} - -fn gen_extend_from_slice>(n: u64, b: &mut Bencher) { - let v: Vec = (0..n).collect(); - b.iter(|| { - let mut vec = V::new(); - vec.extend_from_slice(&v); - vec - }); -} - -fn gen_pushpop>(b: &mut Bencher) { - #[inline(never)] - fn pushpop_noinline>(vec: &mut V, x: u64) -> Option { - vec.push(x); - vec.pop() - } - - b.iter(|| { - let mut vec = V::new(); - for x in 0..SPILLED_SIZE as _ { - pushpop_noinline(&mut vec, x); - } - vec - }); -} - -fn gen_from_elem>(n: usize, b: &mut Bencher) { - b.iter(|| { - let vec = V::from_elem(42, n); - vec - }); -} - -#[bench] -fn bench_insert_many(b: &mut Bencher) { - #[inline(never)] - fn insert_many_noinline>( - vec: &mut SmallVec<[u64; VEC_SIZE]>, - index: usize, - iterable: I, - ) { - vec.insert_many(index, iterable) - } - - b.iter(|| { - let mut vec = SmallVec::<[u64; VEC_SIZE]>::new(); - insert_many_noinline(&mut vec, 0, 0..SPILLED_SIZE as _); - insert_many_noinline(&mut vec, 0, 0..SPILLED_SIZE as _); - vec - }); -} - -#[bench] -fn bench_insert_from_slice(b: &mut Bencher) { - let v: Vec = (0..SPILLED_SIZE as _).collect(); - b.iter(|| { - let mut vec = SmallVec::<[u64; VEC_SIZE]>::new(); - vec.insert_from_slice(0, &v); - vec.insert_from_slice(0, &v); - vec - }); -} - -#[bench] -fn bench_macro_from_list(b: &mut Bencher) { - b.iter(|| { - let vec: SmallVec<[u64; 16]> = smallvec![ - 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 24, 32, 36, 0x40, 0x80, - 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000, 0x20000, 0x40000, - 0x80000, 0x100000, - ]; - vec - }); -} - -#[bench] -fn bench_macro_from_list_vec(b: &mut Bencher) { - b.iter(|| { - let vec: Vec = vec![ - 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 24, 32, 36, 0x40, 0x80, - 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000, 0x20000, 0x40000, - 0x80000, 0x100000, - ]; - vec - }); -} diff --git a/deps/crates/vendor/smallvec-v1/debug_metadata/smallvec.natvis b/deps/crates/vendor/smallvec-v1/debug_metadata/smallvec.natvis deleted file mode 100644 index 8731860f489..00000000000 --- a/deps/crates/vendor/smallvec-v1/debug_metadata/smallvec.natvis +++ /dev/null @@ -1,35 +0,0 @@ - - - - - - - {{ len={len()} is_inline={is_inline()} }} - - is_inline() ? $T2 : capacity - len() - data_ptr() - - - len() - data_ptr() - - - - - - - - - {{ len={len()} is_inline={is_inline()} }} - - is_inline() ? $T2 : capacity - len() - - - len() - data_ptr() - - - - \ No newline at end of file diff --git a/deps/crates/vendor/smallvec-v1/scripts/run_miri.sh b/deps/crates/vendor/smallvec-v1/scripts/run_miri.sh deleted file mode 100644 index 010ceb06ecb..00000000000 --- a/deps/crates/vendor/smallvec-v1/scripts/run_miri.sh +++ /dev/null @@ -1,24 +0,0 @@ -#!/usr/bin/bash - -set -ex - -# Clean out our target dir, which may have artifacts compiled by a version of -# rust different from the one we're about to download. -cargo clean - -# Install and run the latest version of nightly where miri built successfully. -# Taken from: https://github.com/rust-lang/miri#running-miri-on-ci - -MIRI_NIGHTLY=nightly-$(curl -s https://rust-lang.github.io/rustup-components-history/x86_64-unknown-linux-gnu/miri) -echo "Installing latest nightly with Miri: $MIRI_NIGHTLY" -rustup override unset -rustup default "$MIRI_NIGHTLY" - -rustup component add miri -cargo miri setup - -cargo miri test --verbose -cargo miri test --verbose --features union -cargo miri test --verbose --all-features - -rustup override set nightly diff --git a/deps/crates/vendor/smallvec-v1/src/lib.rs b/deps/crates/vendor/smallvec-v1/src/lib.rs index 3259774acad..8c50301b455 100644 --- a/deps/crates/vendor/smallvec-v1/src/lib.rs +++ b/deps/crates/vendor/smallvec-v1/src/lib.rs @@ -166,7 +166,7 @@ use core::mem::ManuallyDrop; /// ``` /// # use smallvec::{smallvec, SmallVec}; /// # fn main() { -/// let v: SmallVec<[_; 0x8000]> = smallvec![1; 3]; +/// let v: SmallVec<[_; 10]> = smallvec![1; 3]; /// assert_eq!(v, SmallVec::from_buf([1, 1, 1])); /// # } /// ``` @@ -602,7 +602,7 @@ where unsafe { // ZSTs have no identity, so we don't need to move them around. - let needs_move = mem::size_of::() != 0; + let needs_move = mem::size_of::() != 0; if needs_move && this.idx < this.old_len && this.del > 0 { let ptr = this.vec.as_mut_ptr(); @@ -651,6 +651,19 @@ impl SmallVecData
    { inline: core::mem::ManuallyDrop::new(inline), } } + // Workaround for https://github.com/rust-lang/rust/issues/157743: when from_inline is + // called with MaybeUninit::uninit(), rustc 1.93+ GVN propagates const into the + // ManuallyDrop::new() aggregate, causing LLVM to materialize a global constant that + // MemCpyOpt then collapses into a memset over the whole struct. Using assume_init() of a + // doubly-wrapped MaybeUninit produces Immediate::Uninit instead of const , which + // codegen handles as undef without emitting any global. This function also avoids + // introducing an intermediate local that would inflate stack frames in debug builds. + #[inline] + fn empty() -> SmallVecData { + // SAFETY: ManuallyDrop> is valid for any bit pattern including + // uninitialized bytes, so assume_init() on a MaybeUninit of that type is sound. + SmallVecData { inline: unsafe { MaybeUninit::uninit().assume_init() } } + } #[inline] unsafe fn into_inline(self) -> MaybeUninit { core::mem::ManuallyDrop::into_inner(self.inline) @@ -713,6 +726,13 @@ impl SmallVecData { fn from_inline(inline: MaybeUninit) -> SmallVecData { SmallVecData::Inline(inline) } + // See the comment on the union variant's empty() for why this exists. + #[inline] + fn empty() -> SmallVecData { + // SAFETY: MaybeUninit is valid for any bit pattern including uninitialized bytes, + // so assume_init() on a MaybeUninit of that type is sound. + SmallVecData::Inline(unsafe { MaybeUninit::uninit().assume_init() }) + } #[inline] unsafe fn into_inline(self) -> MaybeUninit { match self { @@ -789,7 +809,7 @@ impl SmallVec { ); SmallVec { capacity: 0, - data: SmallVecData::from_inline(MaybeUninit::uninit()), + data: SmallVecData::empty(), } } @@ -831,7 +851,7 @@ impl SmallVec { // Cannot use Vec with smaller capacity // because we use value of `Self::capacity` field as indicator. unsafe { - let mut data = SmallVecData::::from_inline(MaybeUninit::uninit()); + let mut data = SmallVecData::::empty(); let len = vec.len(); vec.set_len(0); ptr::copy_nonoverlapping(vec.as_ptr(), data.inline_mut().as_ptr(), len); @@ -1183,7 +1203,7 @@ impl SmallVec { if unspilled { return Ok(()); } - self.data = SmallVecData::from_inline(MaybeUninit::uninit()); + self.data = SmallVecData::empty(); ptr::copy_nonoverlapping(ptr.as_ptr(), self.data.inline_mut().as_ptr(), len); self.capacity = len; deallocate(ptr, cap); @@ -1283,7 +1303,7 @@ impl SmallVec { if self.inline_size() >= len { unsafe { let (ptr, len) = self.data.heap(); - self.data = SmallVecData::from_inline(MaybeUninit::uninit()); + self.data = SmallVecData::empty(); ptr::copy_nonoverlapping(ptr.as_ptr(), self.data.inline_mut().as_ptr(), len); deallocate(ptr.0, self.capacity); self.capacity = len; diff --git a/deps/crates/vendor/smallvec-v1/src/tests.rs b/deps/crates/vendor/smallvec-v1/src/tests.rs index 88c5f32b9a5..8907421ef7a 100644 --- a/deps/crates/vendor/smallvec-v1/src/tests.rs +++ b/deps/crates/vendor/smallvec-v1/src/tests.rs @@ -1040,6 +1040,29 @@ fn drain_keep_rest() { assert_eq!(a, SmallVec::<[i32; 3]>::from_slice(&[1i32, 3, 5, 6, 7, 8])); } +// Regression test: keep_rest on a SmallVec with zero inline capacity must +// still move tail elements to fill the gap left by drained items. +// Using Box so that Miri detects the use-after-move / double-drop +// caused by the missing backshift. +#[cfg(feature = "drain_keep_rest")] +#[test] +fn drain_keep_rest_zero_inline_capacity() { + let mut a: SmallVec<[Box; 0]> = SmallVec::new(); + for i in 1u8..=8 { + a.push(Box::new(i)); + } + + let mut df = a.drain_filter(|x| **x % 2 == 0); + + assert_eq!(*df.next().unwrap(), 2); + assert_eq!(*df.next().unwrap(), 4); + + df.keep_rest(); + + let values: Vec = a.iter().map(|b| **b).collect(); + assert_eq!(values, vec![1, 3, 5, 6, 7, 8]); +} + /// This assortment of tests, in combination with miri, verifies we handle UB on fishy arguments /// given to SmallVec. Draining and extending the allocation are fairly well-tested earlier, but /// `smallvec.insert(usize::MAX, val)` once slipped by! diff --git a/deps/crates/vendor/smallvec-v1/tests/debugger_visualizer.rs b/deps/crates/vendor/smallvec-v1/tests/debugger_visualizer.rs deleted file mode 100644 index b39aa9d9812..00000000000 --- a/deps/crates/vendor/smallvec-v1/tests/debugger_visualizer.rs +++ /dev/null @@ -1,68 +0,0 @@ -use debugger_test::debugger_test; -use smallvec::{smallvec, SmallVec}; - -#[inline(never)] -fn __break() {} - -#[debugger_test( - debugger = "cdb", - commands = r#" -.nvlist -dx sv - -g - -dx sv - -g - -dx sv -"#, - expected_statements = r#" -sv : { len=0x2 is_inline=true } [Type: smallvec::SmallVec >] - [] [Type: smallvec::SmallVec >] - [capacity] : 4 - [len] : 0x2 [Type: unsigned __int64] - [0] : 1 [Type: int] - [1] : 2 [Type: int] - -sv : { len=0x5 is_inline=false } [Type: smallvec::SmallVec >] - [] [Type: smallvec::SmallVec >] - [capacity] : 0x8 [Type: unsigned __int64] - [len] : 0x5 [Type: unsigned __int64] - [0] : 5 [Type: int] - [1] : 2 [Type: int] - [2] : 3 [Type: int] - [3] : 4 [Type: int] - [4] : 5 [Type: int] - -sv : { len=0x5 is_inline=false } [Type: smallvec::SmallVec >] - [] [Type: smallvec::SmallVec >] - [capacity] : 0x8 [Type: unsigned __int64] - [len] : 0x5 [Type: unsigned __int64] - [0] : 2 [Type: int] - [1] : 3 [Type: int] - [2] : 4 [Type: int] - [3] : 5 [Type: int] - [4] : 5 [Type: int] -"# -)] -#[inline(never)] -fn test_debugger_visualizer() { - // This SmallVec can hold up to 4 items on the stack: - let mut sv: SmallVec<[i32; 4]> = smallvec![1, 2]; - __break(); - - // Overfill the SmallVec to move its contents to the heap - for i in 3..6 { - sv.push(i); - } - - // Update the contents of the first value of the SmallVec. - sv[0] = sv[1] + sv[2]; - __break(); - - // Sort the SmallVec in place. - sv.sort(); - __break(); -} diff --git a/deps/crates/vendor/smallvec-v1/tests/macro.rs b/deps/crates/vendor/smallvec-v1/tests/macro.rs deleted file mode 100644 index fa52e79b9ed..00000000000 --- a/deps/crates/vendor/smallvec-v1/tests/macro.rs +++ /dev/null @@ -1,24 +0,0 @@ -/// This file tests `smallvec!` without actually having the macro in scope. -/// This forces any recursion to use a `$crate` prefix to reliably find itself. - -#[test] -fn smallvec() { - let mut vec: smallvec::SmallVec<[i32; 2]>; - - macro_rules! check { - ($init:tt) => { - vec = smallvec::smallvec! $init; - assert_eq!(*vec, *vec! $init); - } - } - - check!([0; 0]); - check!([1; 1]); - check!([2; 2]); - check!([3; 3]); - - check!([]); - check!([1]); - check!([1, 2]); - check!([1, 2, 3]); -} diff --git a/deps/crates/vendor/syn-v2/.cargo_vcs_info.json b/deps/crates/vendor/syn-v2/.cargo_vcs_info.json index 87594551d55..b02256c6e61 100644 --- a/deps/crates/vendor/syn-v2/.cargo_vcs_info.json +++ b/deps/crates/vendor/syn-v2/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "7bcb37cdb3399977658c8b52d2441d37e42e48f2" + "sha1": "f033ef1403b4dbd276d95c26ff05b51d758d7b14" }, "path_in_vcs": "" } \ No newline at end of file diff --git a/deps/crates/vendor/syn-v2/Cargo.lock b/deps/crates/vendor/syn-v2/Cargo.lock index 3680651acd1..8e8f8199c00 100644 --- a/deps/crates/vendor/syn-v2/Cargo.lock +++ b/deps/crates/vendor/syn-v2/Cargo.lock @@ -22,20 +22,20 @@ checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" [[package]] name = "automod" -version = "1.0.16" +version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8b5778837666541195063243828c5b6139221b47dc4ec3ba81738e532469ab1" +checksum = "a273e731a7fb8c2268fd2932c9e9a3469f4fd171d85d070d2687190229653bd3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.116", + "syn 2.0.117", ] [[package]] name = "aws-lc-rs" -version = "1.16.0" +version = "1.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9a7b350e3bb1767102698302bc37256cbd48422809984b98d292c40e2579aa9" +checksum = "5ec2f1fc3ec205783a5da9a7e6c1509cc69dedf09a1949e412c1e18469326d00" dependencies = [ "aws-lc-sys", "zeroize", @@ -43,9 +43,9 @@ dependencies = [ [[package]] name = "aws-lc-sys" -version = "0.37.1" +version = "0.41.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b092fe214090261288111db7a2b2c2118e5a7f30dc2569f1732c4069a6840549" +checksum = "1a2f9779ce85b93ab6170dd940ad0169b5766ff848247aff13bb788b832fe3f4" dependencies = [ "cc", "cmake", @@ -61,15 +61,15 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" [[package]] name = "bitflags" -version = "2.11.0" +version = "2.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af" +checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8" [[package]] name = "bumpalo" -version = "3.20.2" +version = "3.20.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" [[package]] name = "bytes" @@ -79,9 +79,9 @@ checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" [[package]] name = "cc" -version = "1.2.56" +version = "1.2.64" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2" +checksum = "dad887fd958be91b5098c0248def011f4523ab786cd411be668777e55063501f" dependencies = [ "find-msvc-tools", "jobserver", @@ -89,12 +89,6 @@ dependencies = [ "shlex", ] -[[package]] -name = "cesu8" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" - [[package]] name = "cfg-if" version = "1.0.4" @@ -109,9 +103,9 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" [[package]] name = "cmake" -version = "0.1.57" +version = "0.1.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75443c44cd6b379beb8c5b45d85d0773baf31cce901fe7bb252f4eff3008ef7d" +checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678" dependencies = [ "cc", ] @@ -128,14 +122,13 @@ dependencies = [ [[package]] name = "console" -version = "0.15.11" +version = "0.16.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8" +checksum = "d64e8af5551369d19cf50138de61f1c42074ab970f74e99be916646777f8fc87" dependencies = [ "encode_unicode", "libc", - "once_cell", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -200,13 +193,13 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" [[package]] name = "displaydoc" -version = "0.2.5" +version = "0.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +checksum = "1ac70aa55017e108007fbaf5aa0f54b021c98f92ff8af59d42eda9da96e3dd4f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.116", + "syn 2.0.117", ] [[package]] @@ -217,9 +210,9 @@ checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813" [[package]] name = "either" -version = "1.15.0" +version = "1.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" +checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e" [[package]] name = "encode_unicode" @@ -254,19 +247,18 @@ dependencies = [ [[package]] name = "fastrand" -version = "2.3.0" +version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" +checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6" [[package]] name = "filetime" -version = "0.2.27" +version = "0.2.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f98844151eee8917efc50bd9e8318cb963ae8b297431495d3f758616ea5c57db" +checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759" dependencies = [ "cfg-if", "libc", - "libredox", ] [[package]] @@ -383,29 +375,29 @@ dependencies = [ "cfg-if", "js-sys", "libc", - "r-efi", + "r-efi 5.3.0", "wasip2", "wasm-bindgen", ] [[package]] name = "getrandom" -version = "0.4.1" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec" +checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" dependencies = [ "cfg-if", "libc", - "r-efi", + "r-efi 6.0.0", "wasip2", "wasip3", ] [[package]] name = "h2" -version = "0.4.13" +version = "0.4.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54" +checksum = "6cb093c84e8bd9b188d4c4a8cb6579fc016968d14c99882163cd3ff402a4f155" dependencies = [ "atomic-waker", "bytes", @@ -431,9 +423,9 @@ dependencies = [ [[package]] name = "hashbrown" -version = "0.16.1" +version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" [[package]] name = "heck" @@ -443,9 +435,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" [[package]] name = "http" -version = "1.4.0" +version = "1.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a" +checksum = "6970f50e31d6fc17d3fa27329444bfa74e196cf62e95052a3f6fee181dba6425" dependencies = [ "bytes", "itoa", @@ -482,9 +474,9 @@ checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" [[package]] name = "hyper" -version = "1.8.1" +version = "1.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11" +checksum = "55281c53a1894c864990125767da440a4e630446785086f52523b20033b74498" dependencies = [ "atomic-waker", "bytes", @@ -496,7 +488,6 @@ dependencies = [ "httparse", "itoa", "pin-project-lite", - "pin-utils", "smallvec", "tokio", "want", @@ -504,15 +495,14 @@ dependencies = [ [[package]] name = "hyper-rustls" -version = "0.27.7" +version = "0.27.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58" +checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f" dependencies = [ "http", "hyper", "hyper-util", "rustls", - "rustls-pki-types", "tokio", "tokio-rustls", "tower-service", @@ -545,12 +535,13 @@ dependencies = [ [[package]] name = "icu_collections" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43" +checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c" dependencies = [ "displaydoc", "potential_utf", + "utf8_iter", "yoke", "zerofrom", "zerovec", @@ -558,9 +549,9 @@ dependencies = [ [[package]] name = "icu_locale_core" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6" +checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29" dependencies = [ "displaydoc", "litemap", @@ -571,9 +562,9 @@ dependencies = [ [[package]] name = "icu_normalizer" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599" +checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4" dependencies = [ "icu_collections", "icu_normalizer_data", @@ -585,15 +576,15 @@ dependencies = [ [[package]] name = "icu_normalizer_data" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a" +checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38" [[package]] name = "icu_properties" -version = "2.1.2" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec" +checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de" dependencies = [ "icu_collections", "icu_locale_core", @@ -605,15 +596,15 @@ dependencies = [ [[package]] name = "icu_properties_data" -version = "2.1.2" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af" +checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14" [[package]] name = "icu_provider" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614" +checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421" dependencies = [ "displaydoc", "icu_locale_core", @@ -643,9 +634,9 @@ dependencies = [ [[package]] name = "idna_adapter" -version = "1.2.1" +version = "1.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714" dependencies = [ "icu_normalizer", "icu_properties", @@ -653,21 +644,21 @@ dependencies = [ [[package]] name = "indexmap" -version = "2.13.0" +version = "2.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" dependencies = [ "equivalent", - "hashbrown 0.16.1", + "hashbrown 0.17.1", "serde", "serde_core", ] [[package]] name = "insta" -version = "1.46.3" +version = "1.48.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e82db8c87c7f1ccecb34ce0c24399b8a73081427f3c7c50a5d597925356115e4" +checksum = "86f0f8fee8c926415c58d6ae43a08523a26faccb2323f5e6b644fe7dd4ef6b82" dependencies = [ "console", "once_cell", @@ -677,47 +668,64 @@ dependencies = [ [[package]] name = "ipnet" -version = "2.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130" - -[[package]] -name = "iri-string" -version = "0.7.10" +version = "2.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a" -dependencies = [ - "memchr", - "serde", -] +checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2" [[package]] name = "itoa" -version = "1.0.17" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" [[package]] name = "jni" -version = "0.21.1" +version = "0.22.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97" +checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498" dependencies = [ - "cesu8", "cfg-if", "combine", + "jni-macros", "jni-sys", "log", - "thiserror 1.0.69", + "simd_cesu8", + "thiserror", "walkdir", - "windows-sys 0.45.0", + "windows-link", +] + +[[package]] +name = "jni-macros" +version = "0.22.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3" +dependencies = [ + "proc-macro2", + "quote", + "rustc_version", + "simd_cesu8", + "syn 2.0.117", ] [[package]] name = "jni-sys" -version = "0.3.0" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130" +checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2" +dependencies = [ + "jni-sys-macros", +] + +[[package]] +name = "jni-sys-macros" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264" +dependencies = [ + "quote", + "syn 2.0.117", +] [[package]] name = "jobserver" @@ -731,11 +739,12 @@ dependencies = [ [[package]] name = "js-sys" -version = "0.3.85" +version = "0.3.102" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3" +checksum = "03d04c30968dffe80775bd4d7fb676131cd04a1fb46d2686dbffbaec2d9dfd31" dependencies = [ - "once_cell", + "cfg-if", + "futures-util", "wasm-bindgen", ] @@ -747,38 +756,27 @@ checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" [[package]] name = "libc" -version = "0.2.182" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112" - -[[package]] -name = "libredox" -version = "0.1.12" +version = "0.2.186" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616" -dependencies = [ - "bitflags", - "libc", - "redox_syscall", -] +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" [[package]] name = "linux-raw-sys" -version = "0.11.0" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" [[package]] name = "litemap" -version = "0.8.1" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77" +checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0" [[package]] name = "log" -version = "0.4.29" +version = "0.4.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" +checksum = "953f07c43838f8e6f9758cab68bf5bed85465e7587ebe0b823f1bcd81978ad3a" [[package]] name = "lru-slab" @@ -788,9 +786,9 @@ checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154" [[package]] name = "memchr" -version = "2.8.0" +version = "2.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" +checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4" [[package]] name = "mime" @@ -810,9 +808,9 @@ dependencies = [ [[package]] name = "mio" -version = "1.1.1" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc" +checksum = "02bd0af71c67b473010cbbc60715ee815645a4dc942899111f494b4b737d6fda" dependencies = [ "libc", "wasi", @@ -821,9 +819,9 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.21.3" +version = "1.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" [[package]] name = "openssl-probe" @@ -839,21 +837,15 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" [[package]] name = "pin-project-lite" -version = "0.2.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" - -[[package]] -name = "pin-utils" -version = "0.1.0" +version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" [[package]] name = "potential_utf" -version = "0.1.4" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77" +checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564" dependencies = [ "zerovec", ] @@ -874,7 +866,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" dependencies = [ "proc-macro2", - "syn 2.0.116", + "syn 2.0.117", ] [[package]] @@ -900,7 +892,7 @@ dependencies = [ "rustc-hash", "rustls", "socket2", - "thiserror 2.0.18", + "thiserror", "tokio", "tracing", "web-time", @@ -908,9 +900,9 @@ dependencies = [ [[package]] name = "quinn-proto" -version = "0.11.13" +version = "0.11.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31" +checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098" dependencies = [ "aws-lc-rs", "bytes", @@ -922,7 +914,7 @@ dependencies = [ "rustls", "rustls-pki-types", "slab", - "thiserror 2.0.18", + "thiserror", "tinyvec", "tracing", "web-time", @@ -944,9 +936,9 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.44" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] @@ -957,11 +949,17 @@ version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + [[package]] name = "rand" -version = "0.9.2" +version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" +checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea" dependencies = [ "rand_chacha", "rand_core", @@ -988,9 +986,9 @@ dependencies = [ [[package]] name = "rayon" -version = "1.11.0" +version = "1.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f" +checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d" dependencies = [ "either", "rayon-core", @@ -1006,15 +1004,6 @@ dependencies = [ "crossbeam-utils", ] -[[package]] -name = "redox_syscall" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35985aa610addc02e24fc232012c86fd11f14111180f902b67e2d5331f8ebf2b" -dependencies = [ - "bitflags", -] - [[package]] name = "ref-cast" version = "1.0.25" @@ -1032,14 +1021,14 @@ checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da" dependencies = [ "proc-macro2", "quote", - "syn 2.0.116", + "syn 2.0.117", ] [[package]] name = "reqwest" -version = "0.13.2" +version = "0.13.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801" +checksum = "219c5811de6525e5416c7d5d53bb656d3afdbc6c5af816e0802bcfa42dbdc1c3" dependencies = [ "base64", "bytes", @@ -1091,15 +1080,24 @@ dependencies = [ [[package]] name = "rustc-hash" -version = "2.1.1" +version = "2.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" +checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe" + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] [[package]] name = "rustix" -version = "1.1.3" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" dependencies = [ "bitflags", "errno", @@ -1110,9 +1108,9 @@ dependencies = [ [[package]] name = "rustls" -version = "0.23.36" +version = "0.23.40" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b" +checksum = "ef86cd5876211988985292b91c96a8f2d298df24e75989a43a3c73f2d4d8168b" dependencies = [ "aws-lc-rs", "once_cell", @@ -1124,9 +1122,9 @@ dependencies = [ [[package]] name = "rustls-native-certs" -version = "0.8.3" +version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63" +checksum = "dab5152771c58876a2146916e53e35057e1a4dfa2b9df0f0305b07f611fdea4d" dependencies = [ "openssl-probe", "rustls-pki-types", @@ -1136,9 +1134,9 @@ dependencies = [ [[package]] name = "rustls-pki-types" -version = "1.14.0" +version = "1.14.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd" +checksum = "30a7197ae7eb376e574fe940d068c30fe0462554a3ddbe4eca7838e049c937a9" dependencies = [ "web-time", "zeroize", @@ -1146,9 +1144,9 @@ dependencies = [ [[package]] name = "rustls-platform-verifier" -version = "0.6.2" +version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784" +checksum = "26d1e2536ce4f35f4846aa13bff16bd0ff40157cdb14cc056c7b14ba41233ba0" dependencies = [ "core-foundation 0.10.1", "core-foundation-sys", @@ -1173,9 +1171,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f" [[package]] name = "rustls-webpki" -version = "0.103.9" +version = "0.103.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53" +checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e" dependencies = [ "aws-lc-rs", "ring", @@ -1200,9 +1198,9 @@ dependencies = [ [[package]] name = "schannel" -version = "0.1.28" +version = "0.1.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1" +checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939" dependencies = [ "windows-sys 0.61.2", ] @@ -1232,9 +1230,9 @@ dependencies = [ [[package]] name = "semver" -version = "1.0.27" +version = "1.0.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" [[package]] name = "serde" @@ -1243,7 +1241,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" dependencies = [ "serde_core", - "serde_derive", ] [[package]] @@ -1263,14 +1260,14 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn 2.0.116", + "syn 2.0.117", ] [[package]] name = "serde_json" -version = "1.0.149" +version = "1.0.150" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" +checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9" dependencies = [ "itoa", "memchr", @@ -1281,15 +1278,31 @@ dependencies = [ [[package]] name = "shlex" -version = "1.3.0" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" [[package]] name = "simd-adler32" -version = "0.3.8" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214" + +[[package]] +name = "simd_cesu8" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94f90157bb87cddf702797c5dadfa0be7d266cdf49e22da2fcaa32eff75b2c33" +dependencies = [ + "rustc_version", + "simdutf8", +] + +[[package]] +name = "simdutf8" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2" +checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" [[package]] name = "similar" @@ -1305,18 +1318,18 @@ checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" [[package]] name = "smallvec" -version = "1.15.1" +version = "1.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" +checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90" [[package]] name = "socket2" -version = "0.6.2" +version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0" +checksum = "52d1cfed4120b4d927bf7c0f86d2087a4a7d6027c906d9f9d525a80573b9be51" dependencies = [ "libc", - "windows-sys 0.60.2", + "windows-sys 0.61.2", ] [[package]] @@ -1333,9 +1346,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" [[package]] name = "syn" -version = "2.0.116" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3df424c70518695237746f84cede799c9c58fcb37450d7b23716568cc8bc69cb" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", @@ -1344,7 +1357,7 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.117" +version = "2.0.118" dependencies = [ "anyhow", "automod", @@ -1386,7 +1399,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.116", + "syn 2.0.117", ] [[package]] @@ -1412,9 +1425,9 @@ dependencies = [ [[package]] name = "tar" -version = "0.4.44" +version = "0.4.46" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d863878d212c87a19c1a610eb53bb01fe12951c0501cf5a0d65f724914a667a" +checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840" dependencies = [ "filetime", "libc", @@ -1423,12 +1436,12 @@ dependencies = [ [[package]] name = "tempfile" -version = "3.25.0" +version = "3.27.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0136791f7c95b1f6dd99f9cc786b91bb81c3800b639b3478e561ddb7be95e5f1" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" dependencies = [ "fastrand", - "getrandom 0.4.1", + "getrandom 0.4.2", "once_cell", "rustix", "windows-sys 0.61.2", @@ -1443,33 +1456,13 @@ dependencies = [ "winapi-util", ] -[[package]] -name = "thiserror" -version = "1.0.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" -dependencies = [ - "thiserror-impl 1.0.69", -] - [[package]] name = "thiserror" version = "2.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" dependencies = [ - "thiserror-impl 2.0.18", -] - -[[package]] -name = "thiserror-impl" -version = "1.0.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.116", + "thiserror-impl", ] [[package]] @@ -1480,14 +1473,14 @@ checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" dependencies = [ "proc-macro2", "quote", - "syn 2.0.116", + "syn 2.0.117", ] [[package]] name = "tinystr" -version = "0.8.2" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869" +checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d" dependencies = [ "displaydoc", "zerovec", @@ -1495,9 +1488,9 @@ dependencies = [ [[package]] name = "tinyvec" -version = "1.10.0" +version = "1.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa" +checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3" dependencies = [ "tinyvec_macros", ] @@ -1510,9 +1503,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" [[package]] name = "tokio" -version = "1.49.0" +version = "1.52.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86" +checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe" dependencies = [ "bytes", "libc", @@ -1562,20 +1555,20 @@ dependencies = [ [[package]] name = "tower-http" -version = "0.6.8" +version = "0.6.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8" +checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840" dependencies = [ "bitflags", "bytes", "futures-util", "http", "http-body", - "iri-string", "pin-project-lite", "tower", "tower-layer", "tower-service", + "url", ] [[package]] @@ -1678,11 +1671,11 @@ checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" [[package]] name = "wasip2" -version = "1.0.2+wasi-0.2.9" +version = "1.0.4+wasi-0.2.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" +checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487" dependencies = [ - "wit-bindgen", + "wit-bindgen 0.57.1", ] [[package]] @@ -1691,14 +1684,14 @@ version = "0.4.0+wasi-0.3.0-rc-2026-01-06" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" dependencies = [ - "wit-bindgen", + "wit-bindgen 0.51.0", ] [[package]] name = "wasm-bindgen" -version = "0.2.108" +version = "0.2.125" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566" +checksum = "8ddb3f79143bced6de84270411622a2699cee572fc0875aeaf1e7867cf9fca1a" dependencies = [ "cfg-if", "once_cell", @@ -1709,23 +1702,19 @@ dependencies = [ [[package]] name = "wasm-bindgen-futures" -version = "0.4.58" +version = "0.4.75" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f" +checksum = "503b14d284f2c8dac03b819967e155ea753f573586193b2b2c95990cb5d69280" dependencies = [ - "cfg-if", - "futures-util", "js-sys", - "once_cell", "wasm-bindgen", - "web-sys", ] [[package]] name = "wasm-bindgen-macro" -version = "0.2.108" +version = "0.2.125" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608" +checksum = "4e21a184b13fb19e157296e2c46056aec9092264fab83e4ba59e68c61b323c3d" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -1733,22 +1722,22 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.108" +version = "0.2.125" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55" +checksum = "fecefd9c35bd935a20fc3fc344b5f29138961e4f47fb03297d88f2587afb5ebd" dependencies = [ "bumpalo", "proc-macro2", "quote", - "syn 2.0.116", + "syn 2.0.117", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.108" +version = "0.2.125" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12" +checksum = "23939e44bb9a5d7576fa2b563dc2e136628f1224e88a8deed09e04858b77871f" dependencies = [ "unicode-ident", ] @@ -1789,9 +1778,9 @@ dependencies = [ [[package]] name = "web-sys" -version = "0.3.85" +version = "0.3.102" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598" +checksum = "a6430a72df5eb332242960fe84b3002a241163998241eb596d4f739b9757061d" dependencies = [ "js-sys", "wasm-bindgen", @@ -1809,9 +1798,9 @@ dependencies = [ [[package]] name = "webpki-root-certs" -version = "1.0.6" +version = "1.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "804f18a4ac2676ffb4e8b5b5fa9ae38af06df08162314f96a68d2a363e21a8ca" +checksum = "f31141ce3fc3e300ae89b78c0dd67f9708061d1d2eda54b8209346fd6be9a92c" dependencies = [ "rustls-pki-types", ] @@ -1860,15 +1849,6 @@ dependencies = [ "windows-link", ] -[[package]] -name = "windows-sys" -version = "0.45.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" -dependencies = [ - "windows-targets 0.42.2", -] - [[package]] name = "windows-sys" version = "0.52.0" @@ -1878,15 +1858,6 @@ dependencies = [ "windows-targets 0.52.6", ] -[[package]] -name = "windows-sys" -version = "0.59.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" -dependencies = [ - "windows-targets 0.52.6", -] - [[package]] name = "windows-sys" version = "0.60.2" @@ -1905,21 +1876,6 @@ dependencies = [ "windows-link", ] -[[package]] -name = "windows-targets" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" -dependencies = [ - "windows_aarch64_gnullvm 0.42.2", - "windows_aarch64_msvc 0.42.2", - "windows_i686_gnu 0.42.2", - "windows_i686_msvc 0.42.2", - "windows_x86_64_gnu 0.42.2", - "windows_x86_64_gnullvm 0.42.2", - "windows_x86_64_msvc 0.42.2", -] - [[package]] name = "windows-targets" version = "0.52.6" @@ -1953,12 +1909,6 @@ dependencies = [ "windows_x86_64_msvc 0.53.1", ] -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" - [[package]] name = "windows_aarch64_gnullvm" version = "0.52.6" @@ -1971,12 +1921,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" -[[package]] -name = "windows_aarch64_msvc" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" - [[package]] name = "windows_aarch64_msvc" version = "0.52.6" @@ -1989,12 +1933,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" -[[package]] -name = "windows_i686_gnu" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" - [[package]] name = "windows_i686_gnu" version = "0.52.6" @@ -2019,12 +1957,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" -[[package]] -name = "windows_i686_msvc" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" - [[package]] name = "windows_i686_msvc" version = "0.52.6" @@ -2037,12 +1969,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" -[[package]] -name = "windows_x86_64_gnu" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" - [[package]] name = "windows_x86_64_gnu" version = "0.52.6" @@ -2055,12 +1981,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" - [[package]] name = "windows_x86_64_gnullvm" version = "0.52.6" @@ -2073,12 +1993,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" -[[package]] -name = "windows_x86_64_msvc" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" - [[package]] name = "windows_x86_64_msvc" version = "0.52.6" @@ -2100,6 +2014,12 @@ dependencies = [ "wit-bindgen-rust-macro", ] +[[package]] +name = "wit-bindgen" +version = "0.57.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + [[package]] name = "wit-bindgen-core" version = "0.51.0" @@ -2121,7 +2041,7 @@ dependencies = [ "heck", "indexmap", "prettyplease", - "syn 2.0.116", + "syn 2.0.117", "wasm-metadata", "wit-bindgen-core", "wit-component", @@ -2137,7 +2057,7 @@ dependencies = [ "prettyplease", "proc-macro2", "quote", - "syn 2.0.116", + "syn 2.0.117", "wit-bindgen-core", "wit-bindgen-rust", ] @@ -2181,9 +2101,9 @@ dependencies = [ [[package]] name = "writeable" -version = "0.6.2" +version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9" +checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4" [[package]] name = "xattr" @@ -2197,9 +2117,9 @@ dependencies = [ [[package]] name = "yoke" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954" +checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5" dependencies = [ "stable_deref_trait", "yoke-derive", @@ -2208,68 +2128,68 @@ dependencies = [ [[package]] name = "yoke-derive" -version = "0.8.1" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d" +checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e" dependencies = [ "proc-macro2", "quote", - "syn 2.0.116", + "syn 2.0.117", "synstructure", ] [[package]] name = "zerocopy" -version = "0.8.39" +version = "0.8.52" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db6d35d663eadb6c932438e763b262fe1a70987f9ae936e60158176d710cae4a" +checksum = "ce1022995ff5ff5d841ad7d994facc23098cd40152f2c1d11cd607c6f530653f" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.39" +version = "0.8.52" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4122cd3169e94605190e77839c9a40d40ed048d305bfdc146e7df40ab0f3e517" +checksum = "1ae7f38b72ec2a254e2b87ef277cf2cd4fb97cbebf944faa6f33354da0867930" dependencies = [ "proc-macro2", "quote", - "syn 2.0.116", + "syn 2.0.117", ] [[package]] name = "zerofrom" -version = "0.1.6" +version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272" dependencies = [ "zerofrom-derive", ] [[package]] name = "zerofrom-derive" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.116", + "syn 2.0.117", "synstructure", ] [[package]] name = "zeroize" -version = "1.8.2" +version = "1.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" +checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e" [[package]] name = "zerotrie" -version = "0.2.3" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851" +checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf" dependencies = [ "displaydoc", "yoke", @@ -2278,9 +2198,9 @@ dependencies = [ [[package]] name = "zerovec" -version = "0.11.5" +version = "0.11.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002" +checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239" dependencies = [ "yoke", "zerofrom", @@ -2289,13 +2209,13 @@ dependencies = [ [[package]] name = "zerovec-derive" -version = "0.11.2" +version = "0.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3" +checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555" dependencies = [ "proc-macro2", "quote", - "syn 2.0.116", + "syn 2.0.117", ] [[package]] diff --git a/deps/crates/vendor/syn-v2/Cargo.toml b/deps/crates/vendor/syn-v2/Cargo.toml index 6254c0b010a..022f0e9294c 100644 --- a/deps/crates/vendor/syn-v2/Cargo.toml +++ b/deps/crates/vendor/syn-v2/Cargo.toml @@ -13,7 +13,7 @@ edition = "2021" rust-version = "1.71" name = "syn" -version = "2.0.117" +version = "2.0.118" authors = ["David Tolnay "] build = false include = [ diff --git a/deps/crates/vendor/syn-v2/Cargo.toml.orig b/deps/crates/vendor/syn-v2/Cargo.toml.orig index bd1c104d9bf..0341fafa99c 100644 --- a/deps/crates/vendor/syn-v2/Cargo.toml.orig +++ b/deps/crates/vendor/syn-v2/Cargo.toml.orig @@ -1,6 +1,6 @@ [package] name = "syn" -version = "2.0.117" +version = "2.0.118" authors = ["David Tolnay "] categories = ["development-tools::procedural-macro-helpers", "parser-implementations"] description = "Parser for Rust source code" diff --git a/deps/crates/vendor/syn-v2/README.md b/deps/crates/vendor/syn-v2/README.md index 9ae472ea669..7ac4b2dc3d8 100644 --- a/deps/crates/vendor/syn-v2/README.md +++ b/deps/crates/vendor/syn-v2/README.md @@ -205,7 +205,7 @@ longer trigger or be less helpful than it used to be. When developing a procedural macro it can be helpful to look at what the generated code looks like. Use `cargo rustc -- -Zunstable-options ---pretty=expanded` or the [`cargo expand`] subcommand. +-Zunpretty=expanded` or the [`cargo expand`] subcommand. [`cargo expand`]: https://github.com/dtolnay/cargo-expand diff --git a/deps/crates/vendor/syn-v2/benches/rust.rs b/deps/crates/vendor/syn-v2/benches/rust.rs index f6b61f3971c..c0e82c65c00 100644 --- a/deps/crates/vendor/syn-v2/benches/rust.rs +++ b/deps/crates/vendor/syn-v2/benches/rust.rs @@ -60,7 +60,6 @@ mod librustc_parse { use crate::repo; use rustc_errors::emitter::Emitter; - use rustc_errors::translation::Translator; use rustc_errors::{DiagCtxt, DiagInner}; use rustc_parse::lexer::StripTokens; use rustc_session::parse::ParseSess; @@ -77,9 +76,6 @@ mod librustc_parse { fn source_map(&self) -> Option<&SourceMap> { None } - fn translator(&self) -> &Translator { - panic!("silent emitter attempted to translate a diagnostic"); - } } let edition = repo::edition(path).parse().unwrap(); diff --git a/deps/crates/vendor/syn-v2/src/expr.rs b/deps/crates/vendor/syn-v2/src/expr.rs index 0f92701dca3..043c023f812 100644 --- a/deps/crates/vendor/syn-v2/src/expr.rs +++ b/deps/crates/vendor/syn-v2/src/expr.rs @@ -233,7 +233,7 @@ ast_enum_of_structs! { /// A tuple expression: `(a, b, c, d)`. Tuple(ExprTuple), - /// A unary operation: `!x`, `*x`. + /// A unary operation: `!x`, `*x`, `-x`. Unary(ExprUnary), /// An unsafe block: `unsafe { ... }`. @@ -674,7 +674,7 @@ ast_struct! { } ast_struct! { - /// A unary operation: `!x`, `*x`. + /// A unary operation: `!x`, `*x`, `-x`. #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))] pub struct ExprUnary { pub attrs: Vec, diff --git a/deps/crates/vendor/syn-v2/src/lib.rs b/deps/crates/vendor/syn-v2/src/lib.rs index d1dc0caaab8..6d3f5bb5aec 100644 --- a/deps/crates/vendor/syn-v2/src/lib.rs +++ b/deps/crates/vendor/syn-v2/src/lib.rs @@ -207,7 +207,7 @@ //! //! When developing a procedural macro it can be helpful to look at what the //! generated code looks like. Use `cargo rustc -- -Zunstable-options -//! --pretty=expanded` or the [`cargo expand`] subcommand. +//! -Zunpretty=expanded` or the [`cargo expand`] subcommand. //! //! [`cargo expand`]: https://github.com/dtolnay/cargo-expand //! @@ -249,7 +249,7 @@ //! dynamic library libproc_macro from rustc toolchain. #![no_std] -#![doc(html_root_url = "https://docs.rs/syn/2.0.117")] +#![doc(html_root_url = "https://docs.rs/syn/2.0.118")] #![cfg_attr(docsrs, feature(doc_cfg), doc(auto_cfg = false))] #![deny(unsafe_op_in_unsafe_fn)] #![allow(non_camel_case_types)] diff --git a/deps/crates/vendor/syn-v2/src/lit.rs b/deps/crates/vendor/syn-v2/src/lit.rs index a77b3cd3e8f..403d8bac3e6 100644 --- a/deps/crates/vendor/syn-v2/src/lit.rs +++ b/deps/crates/vendor/syn-v2/src/lit.rs @@ -1236,13 +1236,11 @@ mod value { } } // true, false - b't' | b'f' => { - if repr == "true" || repr == "false" { - return Lit::Bool(LitBool { - value: repr == "true", - span: token.span(), - }); - } + b't' | b'f' if repr == "true" || repr == "false" => { + return Lit::Bool(LitBool { + value: repr == "true", + span: token.span(), + }); } b'(' if repr == "(/*ERROR*/)" => return Lit::Verbatim(token), _ => {} diff --git a/deps/crates/vendor/syn-v2/src/token.rs b/deps/crates/vendor/syn-v2/src/token.rs index 8d63a4111b3..32c5a013e74 100644 --- a/deps/crates/vendor/syn-v2/src/token.rs +++ b/deps/crates/vendor/syn-v2/src/token.rs @@ -143,7 +143,12 @@ pub(crate) mod private { /// Support writing `token.span` rather than `token.spans[0]` on tokens that /// hold a single span. #[repr(transparent)] - #[allow(unknown_lints, repr_transparent_non_zst_fields)] // False positive: https://github.com/rust-lang/rust/issues/115922 + #[allow( + unknown_lints, + renamed_and_removed_lints, + // False positive: https://github.com/rust-lang/rust/issues/115922 + repr_transparent_non_zst_fields, + )] pub struct WithSpan { pub span: Span, } @@ -324,7 +329,12 @@ macro_rules! define_punctuation_structs { ($($token:literal pub struct $name:ident/$len:tt #[doc = $usage:literal])*) => { $( #[cfg_attr(not(doc), repr(transparent))] - #[allow(unknown_lints, repr_transparent_non_zst_fields)] // False positive: https://github.com/rust-lang/rust/issues/115922 + #[allow( + unknown_lints, + renamed_and_removed_lints, + // False positive: https://github.com/rust-lang/rust/issues/115922 + repr_transparent_non_zst_fields, + )] #[doc = concat!('`', $token, '`')] /// /// Usage: diff --git a/deps/crates/vendor/syn-v2/tests/common/eq.rs b/deps/crates/vendor/syn-v2/tests/common/eq.rs index d9440ab3942..f59943cd9b7 100644 --- a/deps/crates/vendor/syn-v2/tests/common/eq.rs +++ b/deps/crates/vendor/syn-v2/tests/common/eq.rs @@ -43,6 +43,8 @@ use rustc_ast::ast::Crate; use rustc_ast::ast::Defaultness; use rustc_ast::ast::Delegation; use rustc_ast::ast::DelegationMac; +use rustc_ast::ast::DelegationSource; +use rustc_ast::ast::DelegationSuffixes; use rustc_ast::ast::DelimArgs; use rustc_ast::ast::EarlyParsedAttribute; use rustc_ast::ast::EiiDecl; @@ -85,8 +87,10 @@ use rustc_ast::ast::GenericBound; use rustc_ast::ast::GenericParam; use rustc_ast::ast::GenericParamKind; use rustc_ast::ast::Generics; +use rustc_ast::ast::Guard; use rustc_ast::ast::Impl; use rustc_ast::ast::ImplPolarity; +use rustc_ast::ast::ImplRestriction; use rustc_ast::ast::Inline; use rustc_ast::ast::InlineAsm; use rustc_ast::ast::InlineAsmOperand; @@ -119,6 +123,7 @@ use rustc_ast::ast::MgcaDisambiguation; use rustc_ast::ast::ModKind; use rustc_ast::ast::ModSpans; use rustc_ast::ast::Movability; +use rustc_ast::ast::MutRestriction; use rustc_ast::ast::MutTy; use rustc_ast::ast::Mutability; use rustc_ast::ast::NodeId; @@ -140,6 +145,7 @@ use rustc_ast::ast::RangeEnd; use rustc_ast::ast::RangeLimits; use rustc_ast::ast::RangeSyntax; use rustc_ast::ast::Recovered; +use rustc_ast::ast::RestrictionKind; use rustc_ast::ast::Safety; use rustc_ast::ast::StaticItem; use rustc_ast::ast::Stmt; @@ -185,9 +191,8 @@ use rustc_ast::tokenstream::{ Spacing, TokenStream, TokenTree, }; use rustc_data_structures::packed::Pu128; -use rustc_span::source_map::Spanned; use rustc_span::symbol::{sym, ByteSymbol, Ident, Symbol}; -use rustc_span::{ErrorGuaranteed, Span, SyntaxContext, DUMMY_SP}; +use rustc_span::{ErrorGuaranteed, LocalExpnId, Span, Spanned, SyntaxContext, DUMMY_SP}; use std::borrow::Cow; use std::collections::HashMap; use std::hash::{BuildHasher, Hash}; @@ -305,6 +310,7 @@ spanless_eq_true!(AttrId); spanless_eq_true!(NodeId); spanless_eq_true!(SyntaxContext); spanless_eq_true!(Spacing); +spanless_eq_true!(LocalExpnId); macro_rules! spanless_eq_partial_eq { ($name:ty) => { @@ -497,7 +503,7 @@ spanless_eq_struct!(Closure; binder capture_clause constness coroutine_kind mova spanless_eq_struct!(ConstBlockItem; id span block); spanless_eq_struct!(ConstItem; defaultness ident generics ty rhs_kind define_opaque); spanless_eq_struct!(Crate; attrs items spans id is_placeholder); -spanless_eq_struct!(Delegation; id qself path ident rename body from_glob); +spanless_eq_struct!(Delegation; id qself path ident rename body source); spanless_eq_struct!(DelegationMac; qself prefix suffixes body); spanless_eq_struct!(DelimArgs; dspan delim tokens); spanless_eq_struct!(DelimSpacing; open close); @@ -506,7 +512,7 @@ spanless_eq_struct!(EiiImpl; node_id eii_macro_path known_eii_macro_resolution i spanless_eq_struct!(EnumDef; variants); spanless_eq_struct!(Expr; id kind span attrs !tokens); spanless_eq_struct!(ExprField; attrs id span ident expr is_shorthand is_placeholder); -spanless_eq_struct!(FieldDef; attrs id span vis safety ident ty default is_placeholder); +spanless_eq_struct!(FieldDef; attrs id span vis mut_restriction safety ident ty default is_placeholder); spanless_eq_struct!(Fn; defaultness ident generics sig contract define_opaque body eii_impls); spanless_eq_struct!(FnContract; declarations requires ensures); spanless_eq_struct!(FnDecl; inputs output); @@ -521,7 +527,9 @@ spanless_eq_struct!(FormatOptions; width precision alignment fill sign alternate spanless_eq_struct!(FormatPlaceholder; argument span format_trait format_options); spanless_eq_struct!(GenericParam; id ident attrs bounds is_placeholder kind !colon_span); spanless_eq_struct!(Generics; params where_clause span); +spanless_eq_struct!(Guard; cond span_with_leading_if); spanless_eq_struct!(Impl; generics constness of_trait self_ty items); +spanless_eq_struct!(ImplRestriction; kind span tokens); spanless_eq_struct!(InlineAsm; asm_macro template template_strs operands clobber_abis options line_spans); spanless_eq_struct!(InlineAsmSym; id qself path); spanless_eq_struct!(Item; attrs id span vis kind !tokens); @@ -536,6 +544,7 @@ spanless_eq_struct!(MetaItem; unsafety path kind span); spanless_eq_struct!(MetaItemLit; symbol suffix kind span); spanless_eq_struct!(MethodCall; seg receiver args !span); spanless_eq_struct!(ModSpans; !inner_span !inject_use_span); +spanless_eq_struct!(MutRestriction; kind span tokens); spanless_eq_struct!(MutTy; ty mutbl); spanless_eq_struct!(NormalAttr; item tokens); spanless_eq_struct!(ParenthesizedArgs; span inputs inputs_span output); @@ -545,12 +554,12 @@ spanless_eq_struct!(Path; span segments tokens); spanless_eq_struct!(PathSegment; ident id args); spanless_eq_struct!(PolyTraitRef; bound_generic_params modifiers trait_ref span parens); spanless_eq_struct!(QSelf; ty path_span position); -spanless_eq_struct!(StaticItem; ident ty safety mutability expr define_opaque); +spanless_eq_struct!(StaticItem; ident ty safety mutability expr define_opaque eii_impls); spanless_eq_struct!(Stmt; id kind span); spanless_eq_struct!(StrLit; symbol suffix symbol_unescaped style span); spanless_eq_struct!(StructExpr; qself path fields rest); spanless_eq_struct!(Token; kind span); -spanless_eq_struct!(Trait; constness safety is_auto ident generics bounds items); +spanless_eq_struct!(Trait; constness safety is_auto impl_restriction ident generics bounds items); spanless_eq_struct!(TraitAlias; constness ident generics bounds); spanless_eq_struct!(TraitBoundModifiers; constness asyncness polarity); spanless_eq_struct!(TraitImplHeader; defaultness safety polarity trait_ref); @@ -559,7 +568,7 @@ spanless_eq_struct!(Ty; id kind span tokens); spanless_eq_struct!(TyAlias; defaultness ident generics after_where_clause bounds ty); spanless_eq_struct!(TyPat; id kind span tokens); spanless_eq_struct!(UnsafeBinderTy; generic_params inner_ty); -spanless_eq_struct!(UseTree; prefix kind span); +spanless_eq_struct!(UseTree; prefix kind); spanless_eq_struct!(Variant; attrs id span !vis ident data disr_expr is_placeholder); spanless_eq_struct!(Visibility; kind span tokens); spanless_eq_struct!(WhereBoundPredicate; bound_generic_params bounded_ty bounds); @@ -587,6 +596,8 @@ spanless_eq_enum!(ClosureBinder; NotPresent For(span generic_params)); spanless_eq_enum!(Const; Yes(0) No); spanless_eq_enum!(ConstItemRhsKind; Body(rhs) TypeConst(rhs)); spanless_eq_enum!(Defaultness; Implicit Default(0) Final(0)); +spanless_eq_enum!(DelegationSource; Single List(0) Glob); +spanless_eq_enum!(DelegationSuffixes; List(0) Glob(0)); spanless_eq_enum!(EarlyParsedAttribute; CfgTrace(0) CfgAttrTrace); spanless_eq_enum!(Extern; None Implicit(0) Explicit(0 1)); spanless_eq_enum!(FloatTy; F16 F32 F64 F128); @@ -630,10 +641,11 @@ spanless_eq_enum!(PreciseCapturingArg; Lifetime(0) Arg(0 1)); spanless_eq_enum!(RangeEnd; Included(0) Excluded); spanless_eq_enum!(RangeLimits; HalfOpen Closed); spanless_eq_enum!(Recovered; No Yes(0)); +spanless_eq_enum!(RestrictionKind; Unrestricted Restricted(path id shorthand)); spanless_eq_enum!(Safety; Unsafe(0) Safe(0) Default); spanless_eq_enum!(StmtKind; Let(0) Item(0) Expr(0) Semi(0) Empty MacCall(0)); spanless_eq_enum!(StrStyle; Cooked Raw(0)); -spanless_eq_enum!(StructRest; Base(0) Rest(0) None); +spanless_eq_enum!(StructRest; Base(0) Rest(0) None NoneWithError(0)); spanless_eq_enum!(Term; Ty(0) Const(0)); spanless_eq_enum!(TokenTree; Token(0 1) Delimited(0 1 2 3)); spanless_eq_enum!(TraitObjectSyntax; Dyn None); @@ -642,10 +654,10 @@ spanless_eq_enum!(UintTy; Usize U8 U16 U32 U64 U128); spanless_eq_enum!(UnOp; Deref Not Neg); spanless_eq_enum!(UnsafeBinderCastKind; Wrap Unwrap); spanless_eq_enum!(UnsafeSource; CompilerGenerated UserProvided); -spanless_eq_enum!(UseTreeKind; Simple(0) Nested(items span) Glob); +spanless_eq_enum!(UseTreeKind; Simple(0) Nested(items span) Glob(0)); spanless_eq_enum!(VariantData; Struct(fields recovered) Tuple(0 1) Unit(0)); spanless_eq_enum!(VisibilityKind; Public Restricted(path id shorthand) Inherited); -spanless_eq_enum!(WherePredicateKind; BoundPredicate(0) RegionPredicate(0) EqPredicate(0)); +spanless_eq_enum!(WherePredicateKind; BoundPredicate(0) RegionPredicate(0)); spanless_eq_enum!(YieldKind; Prefix(0) Postfix(0)); spanless_eq_enum!(AssignOpKind; AddAssign SubAssign MulAssign DivAssign RemAssign BitXorAssign BitAndAssign BitOrAssign ShlAssign ShrAssign); @@ -653,10 +665,10 @@ spanless_eq_enum!(CoroutineKind; Async(span closure_id return_impl_trait_id) Gen(span closure_id return_impl_trait_id) AsyncGen(span closure_id return_impl_trait_id)); spanless_eq_enum!(ExprKind; Array(0) ConstBlock(0) Call(0 1) MethodCall(0) - Tup(0) Binary(0 1 2) Unary(0 1) Lit(0) Cast(0 1) Type(0 1) Let(0 1 2 3) - If(0 1 2) While(0 1 2) ForLoop(pat iter body label kind) Loop(0 1 2) - Match(0 1 2) Closure(0) Block(0 1) Gen(0 1 2 3) Await(0 1) Use(0 1) - TryBlock(0 1) Assign(0 1 2) AssignOp(0 1 2) Field(0 1) Index(0 1 2) + Tup(0) Binary(0 1 2) Unary(0 1) Move(0 1) Lit(0) Cast(0 1) Type(0 1) + Let(0 1 2 3) If(0 1 2) While(0 1 2) ForLoop(pat iter body label kind) + Loop(0 1 2) Match(0 1 2) Closure(0) Block(0 1) Gen(0 1 2 3) Await(0 1) + Use(0 1) TryBlock(0 1) Assign(0 1 2) AssignOp(0 1 2) Field(0 1) Index(0 1 2) Underscore Range(0 1 2) Path(0 1) AddrOf(0 1 2) Break(0 1) Continue(0) Ret(0) InlineAsm(0) OffsetOf(0 1) MacCall(0) Struct(0) Repeat(0 1) Paren(0) Try(0) Yield(0) Yeet(0) Become(0) IncludedBytes(0) FormatArgs(0) @@ -677,7 +689,7 @@ spanless_eq_enum!(PatKind; Missing Wild Ident(0 1 2) Struct(0 1 2 3) spanless_eq_enum!(TyKind; Slice(0) Array(0 1) Ptr(0) Ref(0 1) PinnedRef(0 1) FnPtr(0) UnsafeBinder(0) Never Tup(0) Path(0 1) TraitObject(0 1) ImplTrait(0 1) Paren(0) Infer ImplicitSelf MacCall(0) CVarArgs Pat(0 1) - Dummy Err(0)); + FieldOf(0 1 2) Dummy Err(0)); impl SpanlessEq for Ident { fn eq(&self, other: &Self) -> bool { diff --git a/deps/crates/vendor/syn-v2/tests/debug/gen.rs b/deps/crates/vendor/syn-v2/tests/debug/gen.rs index c0d37b791d6..b74d3a6d86f 100644 --- a/deps/crates/vendor/syn-v2/tests/debug/gen.rs +++ b/deps/crates/vendor/syn-v2/tests/debug/gen.rs @@ -1,7 +1,6 @@ // This file is @generated by syn-internal-codegen. // It is not intended for manual editing. -#![allow(repr_transparent_non_zst_fields)] #![allow(clippy::match_wildcard_for_single_variants)] use super::{Lite, Present}; use core::fmt::{self, Debug, Display}; @@ -2955,12 +2954,12 @@ impl Debug for Lite { } impl Debug for Lite { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - write!(formatter, "{}", & self.value) + write!(formatter, "{}", self.value) } } impl Debug for Lite { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - write!(formatter, "{}", & self.value) + write!(formatter, "{}", self.value) } } impl Debug for Lite { diff --git a/deps/crates/vendor/syn-v2/tests/test_item.rs b/deps/crates/vendor/syn-v2/tests/test_item.rs index 2840f91af03..cb63ad4c69f 100644 --- a/deps/crates/vendor/syn-v2/tests/test_item.rs +++ b/deps/crates/vendor/syn-v2/tests/test_item.rs @@ -1,4 +1,5 @@ #![recursion_limit = "256"] +#![feature(negative_impls)] #![allow( clippy::elidable_lifetime_names, clippy::needless_lifetimes, diff --git a/deps/crates/vendor/temporal_capi-v0_2/.cargo_vcs_info.json b/deps/crates/vendor/temporal_capi-v0_2/.cargo_vcs_info.json index 5bead886949..e5fa93fbbbc 100644 --- a/deps/crates/vendor/temporal_capi-v0_2/.cargo_vcs_info.json +++ b/deps/crates/vendor/temporal_capi-v0_2/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "c003cc92325e19b26f8ee2f85e4a47d98cbcc781" + "sha1": "a5cebbcce231552bf6ed985d7ea13b0c7b195f02" }, "path_in_vcs": "temporal_capi" } \ No newline at end of file diff --git a/deps/crates/vendor/temporal_capi-v0_2/Cargo.lock b/deps/crates/vendor/temporal_capi-v0_2/Cargo.lock index 12f2d3ade35..5df3626fcbe 100644 --- a/deps/crates/vendor/temporal_capi-v0_2/Cargo.lock +++ b/deps/crates/vendor/temporal_capi-v0_2/Cargo.lock @@ -253,9 +253,9 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.225" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fd6c24dee235d0da097043389623fb913daddf92c76e9f5a1db88607a0bcbd1d" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" dependencies = [ "serde_core", "serde_derive", @@ -263,18 +263,18 @@ dependencies = [ [[package]] name = "serde_core" -version = "1.0.225" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "659356f9a0cb1e529b24c01e43ad2bdf520ec4ceaf83047b83ddcc2251f96383" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.225" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ea936adf78b1f766949a4977b91d2f5595825bd6ec079aa9543ad2685fc4516" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", @@ -304,9 +304,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.106" +version = "2.0.118" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6" +checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422" dependencies = [ "proc-macro2", "quote", @@ -326,7 +326,7 @@ dependencies = [ [[package]] name = "temporal_capi" -version = "0.2.3" +version = "0.2.4" dependencies = [ "diplomat", "diplomat-runtime", @@ -341,9 +341,9 @@ dependencies = [ [[package]] name = "temporal_rs" -version = "0.2.3" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a902a45282e5175186b21d355efc92564601efe6e2d92818dc9e333d50bd4de" +checksum = "b1afc06e45b0d63943c777d0233523fa2e23a12431a73c37b1c0366777b31717" dependencies = [ "calendrical_calculations", "core_maths", @@ -358,9 +358,9 @@ dependencies = [ [[package]] name = "timezone_provider" -version = "0.2.3" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c48f9b04628a2b813051e4dfe97c65281e49625eabd09ec343190e31e399a8c2" +checksum = "48738555f588bc05b58cb55206843cde9875bb1fde50101dd1a7c50ac6535cd5" dependencies = [ "combine", "jiff-tzdb", diff --git a/deps/crates/vendor/temporal_capi-v0_2/Cargo.toml b/deps/crates/vendor/temporal_capi-v0_2/Cargo.toml index 51450e447f0..a2a00a7eda4 100644 --- a/deps/crates/vendor/temporal_capi-v0_2/Cargo.toml +++ b/deps/crates/vendor/temporal_capi-v0_2/Cargo.toml @@ -13,7 +13,7 @@ edition = "2021" rust-version = "1.86.0" name = "temporal_capi" -version = "0.2.3" +version = "0.2.4" authors = ["boa-dev"] build = false include = [ diff --git a/deps/crates/vendor/temporal_rs-v0_2/.cargo_vcs_info.json b/deps/crates/vendor/temporal_rs-v0_2/.cargo_vcs_info.json index 083d95e45c0..1bba5740ef5 100644 --- a/deps/crates/vendor/temporal_rs-v0_2/.cargo_vcs_info.json +++ b/deps/crates/vendor/temporal_rs-v0_2/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "c003cc92325e19b26f8ee2f85e4a47d98cbcc781", + "sha1": "a5cebbcce231552bf6ed985d7ea13b0c7b195f02", "dirty": true }, "path_in_vcs": "" diff --git a/deps/crates/vendor/temporal_rs-v0_2/CHANGELOG.md b/deps/crates/vendor/temporal_rs-v0_2/CHANGELOG.md index b14b555cb92..59ff0b8a857 100644 --- a/deps/crates/vendor/temporal_rs-v0_2/CHANGELOG.md +++ b/deps/crates/vendor/temporal_rs-v0_2/CHANGELOG.md @@ -2,6 +2,12 @@ All notable changes to this project will be documented in this file. +## What's Changed in v0.2.4 +* ZonedDateTime backward shift spec change by @Manishearth in [#725](https://github.com/boa-dev/temporal/pull/725) +* Fix ComputeNudgeWindow startEpochNs computation to check full startDateDuration sign by @Manishearth in [#723](https://github.com/boa-dev/temporal/pull/723) + +**Full Changelog**: https://github.com/boa-dev/temporal/compare/v0.2.3...v0.2.4 + ## What's Changed in v0.2.3 * Update zoneinfo64 and Diplomat by @Manishearth in [#713](https://github.com/boa-dev/temporal/pull/713) * Update icu_calendar to fix `with()` regression by @Manishearth in [#716](https://github.com/boa-dev/temporal/pull/716) diff --git a/deps/crates/vendor/temporal_rs-v0_2/Cargo.lock b/deps/crates/vendor/temporal_rs-v0_2/Cargo.lock index 8ca26406cff..ec56807220d 100644 --- a/deps/crates/vendor/temporal_rs-v0_2/Cargo.lock +++ b/deps/crates/vendor/temporal_rs-v0_2/Cargo.lock @@ -92,9 +92,9 @@ dependencies = [ [[package]] name = "iana-time-zone" -version = "0.1.64" +version = "0.1.65" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" dependencies = [ "android_system_properties", "core-foundation-sys", @@ -244,9 +244,9 @@ checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" [[package]] name = "log" -version = "0.4.28" +version = "0.4.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432" +checksum = "953f07c43838f8e6f9758cab68bf5bed85465e7587ebe0b823f1bcd81978ad3a" [[package]] name = "memchr" @@ -305,9 +305,9 @@ checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d" [[package]] name = "serde" -version = "1.0.225" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fd6c24dee235d0da097043389623fb913daddf92c76e9f5a1db88607a0bcbd1d" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" dependencies = [ "serde_core", "serde_derive", @@ -315,18 +315,18 @@ dependencies = [ [[package]] name = "serde_core" -version = "1.0.225" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "659356f9a0cb1e529b24c01e43ad2bdf520ec4ceaf83047b83ddcc2251f96383" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.225" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ea936adf78b1f766949a4977b91d2f5595825bd6ec079aa9543ad2685fc4516" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", @@ -347,9 +347,9 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" [[package]] name = "syn" -version = "2.0.106" +version = "2.0.118" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6" +checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422" dependencies = [ "proc-macro2", "quote", @@ -369,7 +369,7 @@ dependencies = [ [[package]] name = "temporal_rs" -version = "0.2.3" +version = "0.2.4" dependencies = [ "calendrical_calculations", "core_maths", @@ -387,9 +387,9 @@ dependencies = [ [[package]] name = "timezone_provider" -version = "0.2.3" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c48f9b04628a2b813051e4dfe97c65281e49625eabd09ec343190e31e399a8c2" +checksum = "48738555f588bc05b58cb55206843cde9875bb1fde50101dd1a7c50ac6535cd5" dependencies = [ "combine", "jiff-tzdb", diff --git a/deps/crates/vendor/temporal_rs-v0_2/Cargo.toml b/deps/crates/vendor/temporal_rs-v0_2/Cargo.toml index 0d1f26e6148..a7c358338e7 100644 --- a/deps/crates/vendor/temporal_rs-v0_2/Cargo.toml +++ b/deps/crates/vendor/temporal_rs-v0_2/Cargo.toml @@ -13,7 +13,7 @@ edition = "2021" rust-version = "1.86.0" name = "temporal_rs" -version = "0.2.3" +version = "0.2.4" authors = ["boa-dev"] build = false exclude = [ diff --git a/deps/crates/vendor/temporal_rs-v0_2/Cargo.toml.orig b/deps/crates/vendor/temporal_rs-v0_2/Cargo.toml.orig index 2bd1acb7cb9..f359d7c2cad 100644 --- a/deps/crates/vendor/temporal_rs-v0_2/Cargo.toml.orig +++ b/deps/crates/vendor/temporal_rs-v0_2/Cargo.toml.orig @@ -11,7 +11,7 @@ members = [ [workspace.package] edition = "2021" -version = "0.2.3" +version = "0.2.4" rust-version = "1.86.0" authors = ["boa-dev"] license = "MIT OR Apache-2.0" diff --git a/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/duration/normalized.rs b/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/duration/normalized.rs index 60c366aec64..9def7f7e086 100644 --- a/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/duration/normalized.rs +++ b/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/duration/normalized.rs @@ -707,7 +707,7 @@ impl InternalDurationRecord { || (sign == NonZeroSign::Negative && r1 <= 0 && r1 > r2) ); - let start_epoch_ns = if r1 == 0 { + let start_epoch_ns = if start_duration.sign() == Sign::Zero { origin_epoch_ns } else { // 7. Let start be ? CalendarDateAdd(calendar, isoDateTime.[[ISODate]], startDuration, constrain). diff --git a/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/duration/tests.rs b/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/duration/tests.rs index 113d56802c2..2c1f448c57a 100644 --- a/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/duration/tests.rs +++ b/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/duration/tests.rs @@ -605,3 +605,41 @@ fn out_of_bounds_duration_no_crash() { assert!(duration.is_err()); } + +// https://github.com/tc39/test262/commit/a70493eb104948583a7928d50eac28b6c81114bf +// https://github.com/tc39/proposal-temporal/issues/3316 +#[test] +#[cfg(feature = "compiled_data")] +fn test_exact_multiple_of_larger_unit_plaindate() { + use crate::options::RoundingMode; + use crate::PlainDate; + + let relative_to = PlainDate::try_new_iso(2012, 1, 1).unwrap(); + + // Temporal.Duration(0, 0, 0, 31).round({ smallestUnit: "weeks", largestUnit: "months", roundingMode, relativeTo }) + // should be 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 + let d1 = Duration::new(0, 0, 0, 31, 0, 0, 0, 0, 0, 0).unwrap(); + + for mode in [ + RoundingMode::Ceil, + RoundingMode::Floor, + RoundingMode::Expand, + RoundingMode::HalfCeil, + RoundingMode::HalfFloor, + RoundingMode::HalfEven, + RoundingMode::HalfExpand, + RoundingMode::HalfTrunc, + RoundingMode::Trunc, + ] { + let options = RoundingOptions { + smallest_unit: Some(Unit::Week), + largest_unit: Some(Unit::Month), + rounding_mode: Some(mode), + ..Default::default() + }; + let res = d1.round(options, Some(relative_to.clone().into())).unwrap(); + assert_eq!(res.months(), 1, "P31D weeks..months {mode:?}"); + assert_eq!(res.weeks(), 0, "P31D weeks..months {mode:?}"); + assert_eq!(res.days(), 0, "P31D weeks..months {mode:?}"); + } +} diff --git a/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/zoned_date_time.rs b/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/zoned_date_time.rs index ff4e3204182..a5b1199d9df 100644 --- a/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/zoned_date_time.rs +++ b/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/zoned_date_time.rs @@ -1301,17 +1301,20 @@ impl ZonedDateTime { // c. Let startNs be ? GetStartOfDay(timeZone, dateStart). // d. Assert: thisNs ≥ startNs. // e. Let endNs be ? GetStartOfDay(timeZone, dateEnd). - // f. Assert: thisNs < endNs. + // f. [Struck out in spec] Assert: thisNs < endNs. let start = self.time_zone.get_start_of_day(&iso_start.date, provider)?; let end = self.time_zone.get_start_of_day(&iso_end, provider)?; - if !(this_ns.0 >= start.ns.0 && this_ns.0 < end.ns.0) { + if this_ns.0 < start.ns.0 { return Err(TemporalError::range().with_enum(ErrorMessage::ZDTOutOfDayBounds)); } - // g. Let dayLengthNs be ℝ(endNs - startNs). - // h. Let dayProgressNs be TimeDurationFromEpochNanosecondsDifference(thisNs, startNs). + // g. Set thisNs to min(thisNs, endNs - 1). + let this_ns_val = this_ns.0.min(end.ns.0 - 1); + // h. Let dayLengthNs be ℝ(endNs - startNs). + // i. Let dayProgressNs be TimeDurationFromEpochNanosecondsDifference(thisNs, startNs). let day_len_ns = TimeDuration::from_nanosecond_difference(end.ns.0, start.ns.0)?; - let day_progress_ns = TimeDuration::from_nanosecond_difference(this_ns.0, start.ns.0)?; - // i. Let roundedDayNs be ! RoundTimeDurationToIncrement(dayProgressNs, dayLengthNs, roundingMode). + let day_progress_ns = + TimeDuration::from_nanosecond_difference(this_ns_val, start.ns.0)?; + // j. Let roundedDayNs be ! RoundTimeDurationToIncrement(dayProgressNs, dayLengthNs, roundingMode). let rounded = if let Some(increment) = NonZeroU128::new(day_len_ns.0.unsigned_abs()) { IncrementRounder::::from_signed_num(day_progress_ns.0, increment)? .round(resolved.rounding_mode) @@ -1326,7 +1329,7 @@ impl ZonedDateTime { end.offset }; - // j. Let epochNanoseconds be AddTimeDurationToEpochNanoseconds(roundedDayNs, startNs). + // k. Let epochNanoseconds be AddTimeDurationToEpochNanoseconds(roundedDayNs, startNs). let candidate = start.ns.0 + rounded; Instant::try_new(candidate)?; // 20. Return ! CreateTemporalZonedDateTime(epochNanoseconds, timeZone, calendar). diff --git a/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/zoned_date_time/tests.rs b/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/zoned_date_time/tests.rs index e56df724b4e..0efc5426122 100644 --- a/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/zoned_date_time/tests.rs +++ b/deps/crates/vendor/temporal_rs-v0_2/src/builtins/core/zoned_date_time/tests.rs @@ -1278,3 +1278,104 @@ fn hours_in_day_dst_changes() { assert_eq!(spring.hours_in_day_with_provider(provider), Ok(23.0)); }) } + +// Case where midnight occurs twice (e.g., Antarctica/Casey on 2010-03-05). +// Upstream tests: https://github.com/tc39/test262/pull/5047 +#[test] +fn test_same_date_starts_twice() { + test_all_providers!(provider: { + let zdt1 = ZonedDateTime::from_utf8_with_provider( + b"2010-03-04T23:10:00+11:00[Antarctica/Casey]", + Disambiguation::Compatible, + OffsetDisambiguation::Use, + provider, + ); + if zdt1.is_err() { + std::println!("Antarctica/Casey not supported by provider, skipping test."); + return; + } + let zdt1 = zdt1.unwrap(); + + let zdt2 = ZonedDateTime::from_utf8_with_provider( + b"2010-03-05T00:45:00+11:00[Antarctica/Casey]", + Disambiguation::Compatible, + OffsetDisambiguation::Use, + provider, + ).unwrap(); + + let zdt3 = ZonedDateTime::from_utf8_with_provider( + b"2010-03-04T23:10:00+08:00[Antarctica/Casey]", + Disambiguation::Compatible, + OffsetDisambiguation::Use, + provider, + ).unwrap(); + + let zdt4 = ZonedDateTime::from_utf8_with_provider( + b"2010-03-05T00:45:00+08:00[Antarctica/Casey]", + Disambiguation::Compatible, + OffsetDisambiguation::Use, + provider, + ).unwrap(); + + let start_of_march4 = "2010-03-04T00:00:00+11:00[Antarctica/Casey]"; + let start_of_march5 = "2010-03-05T00:00:00+11:00[Antarctica/Casey]"; + let start_of_march6 = "2010-03-06T00:00:00+08:00[Antarctica/Casey]"; + + // Hours in day + assert_eq!(zdt1.hours_in_day_with_provider(provider).unwrap(), 24.0); + assert_eq!(zdt2.hours_in_day_with_provider(provider).unwrap(), 27.0); + assert_eq!(zdt3.hours_in_day_with_provider(provider).unwrap(), 24.0); + assert_eq!(zdt4.hours_in_day_with_provider(provider).unwrap(), 27.0); + + // Start of day + assert_eq!(zdt1.start_of_day_with_provider(provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march4); + assert_eq!(zdt2.start_of_day_with_provider(provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march5); + assert_eq!(zdt3.start_of_day_with_provider(provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march4); + assert_eq!(zdt4.start_of_day_with_provider(provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march5); + + // Rounding down + for rounding_mode in [RoundingMode::Floor, RoundingMode::Trunc] { + let options = RoundingOptions { + smallest_unit: Some(Unit::Day), + rounding_mode: Some(rounding_mode), + ..Default::default() + }; + assert_eq!(zdt1.round_with_provider(options, provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march4); + assert_eq!(zdt2.round_with_provider(options, provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march5); + assert_eq!(zdt3.round_with_provider(options, provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march4); + assert_eq!(zdt4.round_with_provider(options, provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march5); + } + + // Rounding to nearest + for rounding_mode in [ + RoundingMode::HalfCeil, + RoundingMode::HalfEven, + RoundingMode::HalfExpand, + RoundingMode::HalfFloor, + RoundingMode::HalfTrunc, + ] { + let options = RoundingOptions { + smallest_unit: Some(Unit::Day), + rounding_mode: Some(rounding_mode), + ..Default::default() + }; + assert_eq!(zdt1.round_with_provider(options, provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march5); + assert_eq!(zdt2.round_with_provider(options, provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march5); + assert_eq!(zdt3.round_with_provider(options, provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march5); + assert_eq!(zdt4.round_with_provider(options, provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march5); + } + + // Rounding up + for rounding_mode in [RoundingMode::Ceil, RoundingMode::Expand] { + let options = RoundingOptions { + smallest_unit: Some(Unit::Day), + rounding_mode: Some(rounding_mode), + ..Default::default() + }; + assert_eq!(zdt1.round_with_provider(options, provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march5); + assert_eq!(zdt2.round_with_provider(options, provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march6); + assert_eq!(zdt3.round_with_provider(options, provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march5); + assert_eq!(zdt4.round_with_provider(options, provider).unwrap().to_string_with_provider(provider).unwrap(), start_of_march6); + } + }) +} diff --git a/deps/crates/vendor/temporal_rs-v0_2/src/iso.rs b/deps/crates/vendor/temporal_rs-v0_2/src/iso.rs index 1771a7b3494..833f141c73c 100644 --- a/deps/crates/vendor/temporal_rs-v0_2/src/iso.rs +++ b/deps/crates/vendor/temporal_rs-v0_2/src/iso.rs @@ -452,7 +452,7 @@ impl IsoDate { // c. Repeat, while ISODateSurpasses(sign, intermediate.[[Year]], intermediate.[[Month]], d1, y2, m2, d2) is false, // Safety: balance_iso_year_month should always return a month value from 1..=12 while !iso_date_surpasses( - &IsoDate::new_unchecked(intermediate.0, intermediate.1 as u8, self.day), + &IsoDate::new_unchecked(intermediate.0, intermediate.1, self.day), other, sign, ) { diff --git a/deps/crates/vendor/writeable-v0_6/.cargo_vcs_info.json b/deps/crates/vendor/writeable-v0_6/.cargo_vcs_info.json index e42a7e55721..4a3e3b8e887 100644 --- a/deps/crates/vendor/writeable-v0_6/.cargo_vcs_info.json +++ b/deps/crates/vendor/writeable-v0_6/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "29dfe2790b6cfdab94ca6a6b69f58ce54802dbf7" + "sha1": "e8d5b7561cf6cc4bee35286f5d5e569100dfa79d" }, "path_in_vcs": "utils/writeable" } \ No newline at end of file diff --git a/deps/crates/vendor/writeable-v0_6/Cargo.lock b/deps/crates/vendor/writeable-v0_6/Cargo.lock index 90f63c6846e..d8987e3c934 100644 --- a/deps/crates/vendor/writeable-v0_6/Cargo.lock +++ b/deps/crates/vendor/writeable-v0_6/Cargo.lock @@ -4,9 +4,9 @@ version = 3 [[package]] name = "aho-corasick" -version = "1.1.3" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" dependencies = [ "memchr", ] @@ -19,9 +19,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" [[package]] name = "anstyle" -version = "1.0.13" +version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" [[package]] name = "autocfg" @@ -31,9 +31,9 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" [[package]] name = "bumpalo" -version = "3.19.0" +version = "3.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" +checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb" [[package]] name = "cast" @@ -222,15 +222,15 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.15" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" [[package]] name = "js-sys" -version = "0.3.81" +version = "0.3.91" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305" +checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c" dependencies = [ "once_cell", "wasm-bindgen", @@ -238,21 +238,15 @@ dependencies = [ [[package]] name = "libc" -version = "0.2.177" +version = "0.2.183" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976" - -[[package]] -name = "log" -version = "0.4.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432" +checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d" [[package]] name = "memchr" -version = "2.7.6" +version = "2.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" [[package]] name = "num-traits" @@ -265,9 +259,9 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.21.3" +version = "1.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" [[package]] name = "oorandom" @@ -314,18 +308,18 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.103" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.41" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] @@ -358,9 +352,9 @@ dependencies = [ [[package]] name = "rand_core" -version = "0.9.3" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" dependencies = [ "getrandom", ] @@ -387,9 +381,9 @@ dependencies = [ [[package]] name = "regex" -version = "1.12.2" +version = "1.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4" +checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276" dependencies = [ "aho-corasick", "memchr", @@ -399,9 +393,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.13" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" dependencies = [ "aho-corasick", "memchr", @@ -410,9 +404,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.8" +version = "0.8.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58" +checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a" [[package]] name = "rustversion" @@ -420,12 +414,6 @@ version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" -[[package]] -name = "ryu" -version = "1.0.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" - [[package]] name = "same-file" version = "1.0.6" @@ -467,22 +455,22 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.145" +version = "1.0.149" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" dependencies = [ "itoa", "memchr", - "ryu", "serde", "serde_core", + "zmij", ] [[package]] name = "syn" -version = "2.0.108" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", @@ -501,9 +489,9 @@ dependencies = [ [[package]] name = "unicode-ident" -version = "1.0.20" +version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "462eeb75aeb73aea900253ce739c8e18a67423fadf006037cd3ff27e82748a06" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" [[package]] name = "walkdir" @@ -526,9 +514,9 @@ dependencies = [ [[package]] name = "wasm-bindgen" -version = "0.2.104" +version = "0.2.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d" +checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e" dependencies = [ "cfg-if", "once_cell", @@ -537,25 +525,11 @@ dependencies = [ "wasm-bindgen-shared", ] -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.104" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19" -dependencies = [ - "bumpalo", - "log", - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-shared", -] - [[package]] name = "wasm-bindgen-macro" -version = "0.2.104" +version = "0.2.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119" +checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -563,31 +537,31 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.104" +version = "0.2.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7" +checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3" dependencies = [ + "bumpalo", "proc-macro2", "quote", "syn", - "wasm-bindgen-backend", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.104" +version = "0.2.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1" +checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16" dependencies = [ "unicode-ident", ] [[package]] name = "web-sys" -version = "0.3.81" +version = "0.3.91" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120" +checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9" dependencies = [ "js-sys", "wasm-bindgen", @@ -625,7 +599,7 @@ checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59" [[package]] name = "writeable" -version = "0.6.2" +version = "0.6.3" dependencies = [ "criterion", "either", @@ -634,20 +608,26 @@ dependencies = [ [[package]] name = "zerocopy" -version = "0.8.27" +version = "0.8.47" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c" +checksum = "efbb2a062be311f2ba113ce66f697a4dc589f85e78a4aea276200804cea0ed87" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.27" +version = "0.8.47" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831" +checksum = "0e8bc7269b54418e7aeeef514aa68f8690b8c0489a06b0136e5f57c4c5ccab89" dependencies = [ "proc-macro2", "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" diff --git a/deps/crates/vendor/writeable-v0_6/Cargo.toml b/deps/crates/vendor/writeable-v0_6/Cargo.toml index 5b7ad9faae4..b829b63e0ff 100644 --- a/deps/crates/vendor/writeable-v0_6/Cargo.toml +++ b/deps/crates/vendor/writeable-v0_6/Cargo.toml @@ -13,7 +13,7 @@ edition = "2021" rust-version = "1.82" name = "writeable" -version = "0.6.2" +version = "0.6.3" authors = ["The ICU4X Project Developers"] build = false include = [ @@ -34,6 +34,12 @@ autotests = false autobenches = false description = "A more efficient alternative to fmt::Display" readme = "README.md" +keywords = [ + "formatting", + "write", + "string", + "no-std", +] license = "Unicode-3.0" repository = "https://github.com/unicode-org/icu4x" @@ -77,3 +83,52 @@ features = ["small_rng"] [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies.criterion] version = "0.5.0" + +[lints.clippy] +alloc-instead-of-core = "warn" +branches-sharing-code = "warn" +collection_is_never_read = "warn" +crosspointer_transmute = "warn" +dbg_macro = "warn" +debug_assert_with_mut_call = "warn" +doc_markdown = "warn" +exhaustive_enums = "deny" +exhaustive_structs = "deny" +fn_to_numeric_cast_any = "warn" +infinite_loop = "warn" +large_stack_arrays = "warn" +mismatching_type_param_order = "warn" +missing_fields_in_debug = "warn" +missing_transmute_annotations = "warn" +negative_feature_names = "warn" +or-fun-call = "warn" +same_functions_in_if_condition = "warn" +todo = "warn" +transmute_bytes_to_str = "warn" +transmute_int_to_bool = "warn" +transmute_int_to_non_zero = "warn" +transmute_ptr_to_ptr = "warn" +transmute_ptr_to_ref = "warn" +transmute_undefined_repr = "warn" +transmutes_expressible_as_ptr_casts = "warn" +trivially_copy_pass_by_ref = "deny" +unnecessary-wraps = "warn" +useless_transmute = "warn" +wildcard_dependencies = "warn" + +[lints.rust] +missing_debug_implementations = "deny" +trivial_numeric_casts = "deny" +unused_lifetimes = "warn" +unused_macro_rules = "warn" +unused_qualifications = "warn" + +[lints.rust.unexpected_cfgs] +level = "warn" +priority = 0 +check-cfg = [ + "cfg(icu4c_enable_renaming)", + "cfg(needs_alloc_error_handler)", + "cfg(icu4x_run_size_tests)", + "cfg(icu4x_unstable_fast_trie_only)", +] diff --git a/deps/crates/vendor/writeable-v0_6/Cargo.toml.orig b/deps/crates/vendor/writeable-v0_6/Cargo.toml.orig index ae98f79b88f..c03b12f3d41 100644 --- a/deps/crates/vendor/writeable-v0_6/Cargo.toml.orig +++ b/deps/crates/vendor/writeable-v0_6/Cargo.toml.orig @@ -5,7 +5,8 @@ [package] name = "writeable" description = "A more efficient alternative to fmt::Display" -version = "0.6.2" +version = "0.6.3" +keywords = ["formatting", "write", "string", "no-std"] authors.workspace = true edition.workspace = true @@ -14,6 +15,7 @@ license.workspace = true repository.workspace = true rust-version = "1.82" + [package.metadata.workspaces] independent = true @@ -41,3 +43,6 @@ bench = false # This option is required for Benchmark CI [[bench]] name = "writeable" harness = false + +[lints] +workspace = true diff --git a/deps/crates/vendor/writeable-v0_6/benches/writeable.rs b/deps/crates/vendor/writeable-v0_6/benches/writeable.rs index 07b731762f9..de79aa00c59 100644 --- a/deps/crates/vendor/writeable-v0_6/benches/writeable.rs +++ b/deps/crates/vendor/writeable-v0_6/benches/writeable.rs @@ -204,21 +204,21 @@ fn writeable_dyn_benches(c: &mut Criterion) { fn display_benches(c: &mut Criterion) { c.bench_function("display/to_string/short", |b| { b.iter(|| { - std::string::ToString::to_string(&DisplayMessage { + ToString::to_string(&DisplayMessage { message: black_box(SHORT_STR), }) }); }); c.bench_function("display/to_string/medium", |b| { b.iter(|| { - std::string::ToString::to_string(&DisplayMessage { + ToString::to_string(&DisplayMessage { message: black_box(MEDIUM_STR), }) }); }); c.bench_function("display/to_string/long", |b| { b.iter(|| { - std::string::ToString::to_string(&DisplayMessage { + ToString::to_string(&DisplayMessage { message: black_box(LONG_STR), }) }); @@ -280,7 +280,7 @@ fn complex_benches(c: &mut Criterion) { }); }); c.bench_function("complex/display_to_string/medium", |b| { - b.iter(|| std::string::ToString::to_string(&black_box(COMPLEX_WRITEABLE_MEDIUM))); + b.iter(|| ToString::to_string(&black_box(COMPLEX_WRITEABLE_MEDIUM))); }); const REFERENCE_STRS: [&str; 6] = [ "There are 55 apples and 8124 oranges", diff --git a/deps/crates/vendor/writeable-v0_6/examples/writeable_message.rs b/deps/crates/vendor/writeable-v0_6/examples/writeable_message.rs index ca7c773d7ee..ff6cc0e86f3 100644 --- a/deps/crates/vendor/writeable-v0_6/examples/writeable_message.rs +++ b/deps/crates/vendor/writeable-v0_6/examples/writeable_message.rs @@ -47,8 +47,7 @@ impl fmt::Display for WriteableMessage { } fn main() { - let (string, parts) = - writeable::_internal::writeable_to_parts_for_test(&WriteableMessage("world")); + let (string, parts) = _internal::writeable_to_parts_for_test(&WriteableMessage("world")); assert_eq!(string, "Hello world 😅"); diff --git a/deps/crates/vendor/writeable-v0_6/src/cmp.rs b/deps/crates/vendor/writeable-v0_6/src/cmp.rs index 5f0050e2684..1f8814b164e 100644 --- a/deps/crates/vendor/writeable-v0_6/src/cmp.rs +++ b/deps/crates/vendor/writeable-v0_6/src/cmp.rs @@ -97,6 +97,26 @@ pub fn cmp_utf8(writeable: &impl Writeable, other: &[u8]) -> Ordering { /// assert_eq!(Ordering::Less, writeable::cmp_str(&message, "Hello, Bob!")); /// assert_eq!(Ordering::Less, (*message_str).cmp("Hello, Bob!")); /// ``` +/// +/// This function can be combined with `writeable::concat_writeable!` to make an efficient +/// comparison between a string and a sequence of substrings: +/// +/// ``` +/// use core::cmp::Ordering; +/// +/// assert_eq!( +/// Ordering::Less, +/// writeable::cmp_str(&writeable::concat_writeable!("loop", 1), "loop12") +/// ); +/// assert_eq!( +/// Ordering::Equal, +/// writeable::cmp_str(&writeable::concat_writeable!("loop", 12), "loop12") +/// ); +/// assert_eq!( +/// Ordering::Greater, +/// writeable::cmp_str(&writeable::concat_writeable!("loop", 2), "loop12") +/// ); +/// ``` #[inline] pub fn cmp_str(writeable: &impl Writeable, other: &str) -> Ordering { cmp_utf8(writeable, other.as_bytes()) diff --git a/deps/crates/vendor/writeable-v0_6/src/concat.rs b/deps/crates/vendor/writeable-v0_6/src/concat.rs new file mode 100644 index 00000000000..703199688bc --- /dev/null +++ b/deps/crates/vendor/writeable-v0_6/src/concat.rs @@ -0,0 +1,146 @@ +// This file is part of ICU4X. For terms of use, please see the file +// called LICENSE at the top level of the ICU4X source tree +// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ). + +use crate::TryWriteable; +use crate::Writeable; +use core::fmt; + +/// A [`Writeable`] that efficiently concatenates two other [`Writeable`]s. +/// +/// See the [`concat_writeable!`] macro for a convenient way to make one of these. +/// +/// # Examples +/// +/// ``` +/// use writeable::adapters::Concat; +/// use writeable::assert_writeable_eq; +/// +/// assert_writeable_eq!(Concat("Number: ", 25), "Number: 25"); +/// ``` +/// +/// With [`TryWriteable`]: +/// +/// ``` +/// use writeable::adapters::Concat; +/// use writeable::assert_try_writeable_eq; +/// use writeable::TryWriteable; +/// +/// struct AlwaysPanic; +/// +/// impl TryWriteable for AlwaysPanic { +/// type Error = &'static str; +/// fn try_write_to_parts( +/// &self, +/// _sink: &mut W, +/// ) -> Result, core::fmt::Error> { +/// // Unreachable panic: the first Writeable errors, +/// // so the second Writeable is not evaluated. +/// panic!("this is a test to demonstrate unreachable code") +/// } +/// } +/// +/// let writeable0: Result<&str, &str> = Err("error message"); +/// let writeable1 = AlwaysPanic; +/// +/// assert_try_writeable_eq!( +/// Concat(writeable0, writeable1), +/// "error message", +/// Err("error message"), +/// ) +/// ``` +#[derive(Debug)] +#[allow(clippy::exhaustive_structs)] // designed for nesting +pub struct Concat(pub A, pub B); + +impl Writeable for Concat +where + A: Writeable, + B: Writeable, +{ + #[inline] + fn write_to(&self, sink: &mut W) -> fmt::Result { + self.0.write_to(sink)?; + self.1.write_to(sink) + } + #[inline] + fn write_to_parts(&self, sink: &mut S) -> fmt::Result { + self.0.write_to_parts(sink)?; + self.1.write_to_parts(sink) + } + #[inline] + fn writeable_length_hint(&self) -> crate::LengthHint { + self.0.writeable_length_hint() + self.1.writeable_length_hint() + } +} + +impl TryWriteable for Concat +where + A: TryWriteable, + B: TryWriteable, +{ + type Error = E; + #[inline] + fn try_write_to( + &self, + sink: &mut W, + ) -> Result, fmt::Error> { + if let Err(e) = self.0.try_write_to(sink)? { + return Ok(Err(e)); + } + self.1.try_write_to(sink) + } + #[inline] + fn try_write_to_parts( + &self, + sink: &mut S, + ) -> Result, fmt::Error> { + if let Err(e) = self.0.try_write_to_parts(sink)? { + return Ok(Err(e)); + } + self.1.try_write_to_parts(sink) + } + #[inline] + fn writeable_length_hint(&self) -> crate::LengthHint { + self.0.writeable_length_hint() + self.1.writeable_length_hint() + } +} + +impl fmt::Display for Concat +where + A: Writeable, + B: Writeable, +{ + #[inline] + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.write_to(f)?; + self.1.write_to(f) + } +} + +/// Returns a [`Writeable`] concatenating any number of [`Writeable`]s. +/// +/// The macro resolves to a nested [`Concat`]. +/// +/// # Examples +/// +/// ``` +/// use writeable::assert_writeable_eq; +/// +/// let concatenated = writeable::concat_writeable!("Health: ", 5, '/', 8); +/// +/// assert_writeable_eq!(concatenated, "Health: 5/8"); +/// ``` +#[macro_export] +#[doc(hidden)] // macro +macro_rules! __concat_writeable { + // Base case: + ($x:expr) => ($x); + // `$x` followed by at least one `$y,` + ($x:expr, $($y:expr),+) => ( + // Call `concat_writeable!` recursively on the tail `$y` + $crate::adapters::Concat($x, $crate::concat_writeable!($($y),+)) + ) +} +#[doc(inline)] +pub use __concat_writeable as concat_writeable; diff --git a/deps/crates/vendor/writeable-v0_6/src/impls.rs b/deps/crates/vendor/writeable-v0_6/src/impls.rs index 4e648375fe9..0f1c038b8b0 100644 --- a/deps/crates/vendor/writeable-v0_6/src/impls.rs +++ b/deps/crates/vendor/writeable-v0_6/src/impls.rs @@ -15,6 +15,7 @@ macro_rules! impl_write_num { let mut n = *self; let mut i = MAX_LEN; #[expect(clippy::indexing_slicing)] // n < 10^i + #[allow(trivial_numeric_casts)] while n != 0 { i -= 1; buf[i] = b'0' + (n % 10) as u8; @@ -49,6 +50,7 @@ macro_rules! impl_write_num { } #[test] + #[allow(trivial_numeric_casts)] fn $test() { use $crate::assert_writeable_eq; assert_writeable_eq!(&(0 as $u), "0"); @@ -179,7 +181,8 @@ impl Writeable for &T { #[cfg(feature = "alloc")] macro_rules! impl_write_smart_pointer { ($ty:path, T: $extra_bound:path) => { - impl<'a, T: ?Sized + Writeable + $extra_bound> Writeable for $ty { + #[allow(unused_qualifications)] + impl Writeable for $ty { #[inline] fn write_to(&self, sink: &mut W) -> fmt::Result { core::borrow::Borrow::::borrow(self).write_to(sink) @@ -209,7 +212,7 @@ macro_rules! impl_write_smart_pointer { } #[cfg(feature = "alloc")] -impl_write_smart_pointer!(Cow<'a, T>, T: alloc::borrow::ToOwned); +impl_write_smart_pointer!(Cow<'_, T>, T: alloc::borrow::ToOwned); #[cfg(feature = "alloc")] impl_write_smart_pointer!(alloc::boxed::Box); #[cfg(feature = "alloc")] @@ -241,7 +244,7 @@ fn test_string_impls() { assert_writeable_eq!(&chars[i], s); for j in 0..chars.len() { assert_eq!( - crate::cmp_str(&chars[j], &s), + cmp_str(&chars[j], &s), chars[j].cmp(&chars[i]), "{:?} vs {:?}", chars[j], diff --git a/deps/crates/vendor/writeable-v0_6/src/lib.rs b/deps/crates/vendor/writeable-v0_6/src/lib.rs index e0ba054292a..c5fd523f75d 100644 --- a/deps/crates/vendor/writeable-v0_6/src/lib.rs +++ b/deps/crates/vendor/writeable-v0_6/src/lib.rs @@ -11,12 +11,9 @@ clippy::unwrap_used, clippy::expect_used, clippy::panic, - clippy::exhaustive_structs, - clippy::exhaustive_enums, - clippy::trivially_copy_pass_by_ref, - missing_debug_implementations, ) )] +#![warn(missing_docs)] //! This crate defines [`Writeable`], a trait representing an object that can be written to a //! sink implementing `std::fmt::Write`. It is an alternative to `std::fmt::Display` with the @@ -80,6 +77,7 @@ extern crate alloc; mod cmp; +mod concat; #[cfg(feature = "either")] mod either; mod impls; @@ -99,6 +97,7 @@ use alloc::string::String; use core::fmt; pub use cmp::{cmp_str, cmp_utf8}; +pub use concat::concat_writeable; #[cfg(feature = "alloc")] pub use to_string_or_borrow::to_string_or_borrow; pub use try_writeable::TryWriteable; @@ -107,11 +106,14 @@ pub use try_writeable::TryWriteable; pub mod adapters { use super::*; + pub use concat::Concat; pub use parts_write_adapter::CoreWriteAsPartsWrite; pub use parts_write_adapter::WithPart; pub use try_writeable::TryWriteableInfallibleAsWriteable; pub use try_writeable::WriteableAsTryWriteableInfallible; + /// A lossy wrapper for a [`TryWriteable`] that implements [`Writeable`] + /// and ignores any errors. #[derive(Debug)] #[allow(clippy::exhaustive_structs)] // newtype pub struct LossyWrap(pub T); @@ -160,6 +162,7 @@ pub mod _internal { pub struct LengthHint(pub usize, pub Option); impl LengthHint { + /// Unknown pub fn undefined() -> Self { Self(0, None) } @@ -233,6 +236,7 @@ impl LengthHint { /// formatters should expose the `Part`s they produces as constants. #[derive(Clone, Copy, Debug, PartialEq)] #[allow(clippy::exhaustive_structs)] // stable +#[allow(missing_docs)] // behavior not defined, explained in type docs pub struct Part { pub category: &'static str, pub value: &'static str, @@ -250,6 +254,7 @@ impl Part { /// A sink that supports annotating parts of the string with [`Part`]s. pub trait PartsWrite: fmt::Write { + /// The recursive sink type SubPartsWrite: PartsWrite + ?Sized; /// Annotates all strings written by the closure with the given [`Part`]. @@ -371,7 +376,7 @@ pub trait Writeable { #[macro_export] macro_rules! impl_display_with_writeable { (@display, $type:ty) => { - /// This trait is implemented for compatibility with [`fmt!`](alloc::fmt). + /// This trait is implemented for compatibility with [`fmt!`](core::fmt). /// To create a string, [`Writeable::write_to_string`] is usually more efficient. impl core::fmt::Display for $type { #[inline] diff --git a/deps/crates/vendor/writeable-v0_6/src/parts_write_adapter.rs b/deps/crates/vendor/writeable-v0_6/src/parts_write_adapter.rs index 4b6d37e3e58..1c589934f13 100644 --- a/deps/crates/vendor/writeable-v0_6/src/parts_write_adapter.rs +++ b/deps/crates/vendor/writeable-v0_6/src/parts_write_adapter.rs @@ -81,7 +81,9 @@ impl PartsWrite for CoreWriteAsPartsWrite { #[derive(Debug)] #[allow(clippy::exhaustive_structs)] // public adapter pub struct WithPart { + /// The [`Part`] pub part: Part, + /// The value pub writeable: T, } diff --git a/deps/crates/vendor/writeable-v0_6/src/testing.rs b/deps/crates/vendor/writeable-v0_6/src/testing.rs index 2e48860516f..958c10e2951 100644 --- a/deps/crates/vendor/writeable-v0_6/src/testing.rs +++ b/deps/crates/vendor/writeable-v0_6/src/testing.rs @@ -46,6 +46,7 @@ impl PartsWrite for TestWriter { } } +#[doc(hidden)] pub fn writeable_to_parts_for_test( writeable: &W, ) -> (String, Vec<(usize, usize, Part)>) { @@ -61,6 +62,7 @@ pub fn writeable_to_parts_for_test( } #[expect(clippy::type_complexity)] +#[doc(hidden)] pub fn try_writeable_to_parts_for_test( writeable: &W, ) -> (String, Vec<(usize, usize, Part)>, Option) { diff --git a/deps/crates/vendor/writeable-v0_6/src/try_writeable.rs b/deps/crates/vendor/writeable-v0_6/src/try_writeable.rs index c90dca901b5..fd8c0477f4e 100644 --- a/deps/crates/vendor/writeable-v0_6/src/try_writeable.rs +++ b/deps/crates/vendor/writeable-v0_6/src/try_writeable.rs @@ -93,6 +93,7 @@ use core::convert::Infallible; /// ); /// ``` pub trait TryWriteable { + /// The error type type Error; /// Writes the content of this writeable to a sink. diff --git a/deps/crates/vendor/yoke-v0_8/.cargo_vcs_info.json b/deps/crates/vendor/yoke-v0_8/.cargo_vcs_info.json index 37b40d0ae1d..337747e19e5 100644 --- a/deps/crates/vendor/yoke-v0_8/.cargo_vcs_info.json +++ b/deps/crates/vendor/yoke-v0_8/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "c9fac4e625ccb2c6a7aa35079fff9709db4385ac" + "sha1": "a954ec29392c0225453404cb1f6a77f0ded27089" }, "path_in_vcs": "utils/yoke" } \ No newline at end of file diff --git a/deps/crates/vendor/yoke-v0_8/Cargo.lock b/deps/crates/vendor/yoke-v0_8/Cargo.lock index 71945cbe305..f68d17e841a 100644 --- a/deps/crates/vendor/yoke-v0_8/Cargo.lock +++ b/deps/crates/vendor/yoke-v0_8/Cargo.lock @@ -134,7 +134,7 @@ checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" [[package]] name = "yoke" -version = "0.8.2" +version = "0.8.3" dependencies = [ "bincode", "postcard", @@ -158,9 +158,9 @@ dependencies = [ [[package]] name = "zerofrom" -version = "0.1.7" +version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df" +checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272" dependencies = [ "zerofrom-derive", ] diff --git a/deps/crates/vendor/yoke-v0_8/Cargo.toml b/deps/crates/vendor/yoke-v0_8/Cargo.toml index adb5fb2b43a..eeafbf1378e 100644 --- a/deps/crates/vendor/yoke-v0_8/Cargo.toml +++ b/deps/crates/vendor/yoke-v0_8/Cargo.toml @@ -13,7 +13,7 @@ edition = "2021" rust-version = "1.82" name = "yoke" -version = "0.8.2" +version = "0.8.3" authors = ["Manish Goregaokar "] build = false include = [ @@ -113,6 +113,7 @@ default-features = false [lints.clippy] alloc-instead-of-core = "warn" +bool-assert-comparison = "allow" branches-sharing-code = "warn" collection_is_never_read = "warn" crosspointer_transmute = "warn" diff --git a/deps/crates/vendor/yoke-v0_8/Cargo.toml.orig b/deps/crates/vendor/yoke-v0_8/Cargo.toml.orig index 8a3e28eb953..bc644c8c39a 100644 --- a/deps/crates/vendor/yoke-v0_8/Cargo.toml.orig +++ b/deps/crates/vendor/yoke-v0_8/Cargo.toml.orig @@ -5,12 +5,12 @@ [package] name = "yoke" description = "Abstraction allowing borrowed data to be carried along with the backing data it borrows from" -version = "0.8.2" +version = "0.8.3" authors = ["Manish Goregaokar "] categories = ["data-structures", "memory-management", "caching", "no-std"] keywords = ["zero-copy", "serialization", "memory-efficiency", "self-referential"] -edition.workspace = true +edition = "2021" include.workspace = true license.workspace = true repository.workspace = true diff --git a/deps/crates/vendor/yoke-v0_8/src/cartable_ptr.rs b/deps/crates/vendor/yoke-v0_8/src/cartable_ptr.rs index 59bb0b16565..f220329ed42 100644 --- a/deps/crates/vendor/yoke-v0_8/src/cartable_ptr.rs +++ b/deps/crates/vendor/yoke-v0_8/src/cartable_ptr.rs @@ -370,10 +370,10 @@ unsafe impl CloneableCart for CartableOptionPointer where } // Safety: logically an Option. Has same bounds as Option -unsafe impl Send for CartableOptionPointer where C: Sync + CartablePointerLike {} +unsafe impl Send for CartableOptionPointer where C: Send + CartablePointerLike {} // Safety: logically an Option. Has same bounds as Option -unsafe impl Sync for CartableOptionPointer where C: Send + CartablePointerLike {} +unsafe impl Sync for CartableOptionPointer where C: Sync + CartablePointerLike {} #[cfg(test)] mod tests { @@ -441,4 +441,33 @@ mod tests { } assert_eq!(start + 1, DROP_INVOCATIONS.with(Cell::get)); } + + // Miri test for CartableOptionPointer Send/Sync soundness. + // + // Verifies that a CartableOptionPointer wrapping a Send + !Sync cart can be + // safely sent to another thread and dropped, which compiles under the corrected + // bounds but would fail under the old (backwards) bounds. + #[test] + fn test_send_drops_on_another_thread() { + use std::marker::PhantomData; + + // ThreadDrop is Send but !Sync + struct ThreadDrop { + _not_sync: PhantomData>, + } + + let yoke = Yoke::>::attach_to_cart( + Box::new(ThreadDrop { + _not_sync: PhantomData, + }), + |_| 0, + ) + .wrap_cart_in_option() + .convert_cart_into_option_pointer(); + + // This requires CartableOptionPointer to be Send. + // It is Send because Box is Send. + // It would NOT be Send under the old bounds because Box is !Sync. + std::thread::spawn(move || drop(yoke)).join().unwrap(); + } } diff --git a/deps/crates/vendor/zerofrom-derive-v0_1/.cargo_vcs_info.json b/deps/crates/vendor/zerofrom-derive-v0_1/.cargo_vcs_info.json index 322ac502043..58f5a56738d 100644 --- a/deps/crates/vendor/zerofrom-derive-v0_1/.cargo_vcs_info.json +++ b/deps/crates/vendor/zerofrom-derive-v0_1/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "f4290a877dfcb0f87cad6de4abdd65f0cbb33c9c" + "sha1": "c9fac4e625ccb2c6a7aa35079fff9709db4385ac" }, "path_in_vcs": "utils/zerofrom/derive" } \ No newline at end of file diff --git a/deps/crates/vendor/zerofrom-derive-v0_1/Cargo.lock b/deps/crates/vendor/zerofrom-derive-v0_1/Cargo.lock index f36a10c6ed0..c784667bac7 100644 --- a/deps/crates/vendor/zerofrom-derive-v0_1/Cargo.lock +++ b/deps/crates/vendor/zerofrom-derive-v0_1/Cargo.lock @@ -4,27 +4,27 @@ version = 3 [[package]] name = "proc-macro2" -version = "1.0.93" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.38" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] [[package]] name = "syn" -version = "2.0.98" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", @@ -33,9 +33,9 @@ dependencies = [ [[package]] name = "synstructure" -version = "0.13.1" +version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", @@ -44,13 +44,13 @@ dependencies = [ [[package]] name = "unicode-ident" -version = "1.0.17" +version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00e2473a93778eb0bad35909dff6a10d28e63f792f16ed15e404fca9d5eeedbe" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" [[package]] name = "zerofrom-derive" -version = "0.1.6" +version = "0.1.7" dependencies = [ "proc-macro2", "quote", diff --git a/deps/crates/vendor/zerofrom-derive-v0_1/Cargo.toml b/deps/crates/vendor/zerofrom-derive-v0_1/Cargo.toml index 3bf262afdf2..d550ded8c1c 100644 --- a/deps/crates/vendor/zerofrom-derive-v0_1/Cargo.toml +++ b/deps/crates/vendor/zerofrom-derive-v0_1/Cargo.toml @@ -11,8 +11,9 @@ [package] edition = "2021" +rust-version = "1.71.1" name = "zerofrom-derive" -version = "0.1.6" +version = "0.1.7" authors = ["Manish Goregaokar "] build = false autolib = false @@ -23,10 +24,10 @@ autobenches = false description = "Custom derive for the zerofrom crate" readme = "README.md" keywords = [ - "zerocopy", + "macros", + "derive", + "zero-copy", "serialization", - "lifetime", - "borrow", ] categories = [ "data-structures", @@ -53,7 +54,7 @@ path = "examples/zf_derive.rs" version = "1.0.61" [dependencies.quote] -version = "1.0.28" +version = "1.0.44" [dependencies.syn] version = "2.0.21" @@ -63,3 +64,52 @@ features = ["fold"] version = "0.13.0" [dev-dependencies] + +[lints.clippy] +alloc-instead-of-core = "warn" +branches-sharing-code = "warn" +collection_is_never_read = "warn" +crosspointer_transmute = "warn" +dbg_macro = "warn" +debug_assert_with_mut_call = "warn" +doc_markdown = "warn" +exhaustive_enums = "deny" +exhaustive_structs = "deny" +fn_to_numeric_cast_any = "warn" +infinite_loop = "warn" +large_stack_arrays = "warn" +mismatching_type_param_order = "warn" +missing_fields_in_debug = "warn" +missing_transmute_annotations = "warn" +negative_feature_names = "warn" +or-fun-call = "warn" +same_functions_in_if_condition = "warn" +todo = "warn" +transmute_bytes_to_str = "warn" +transmute_int_to_bool = "warn" +transmute_int_to_non_zero = "warn" +transmute_ptr_to_ptr = "warn" +transmute_ptr_to_ref = "warn" +transmute_undefined_repr = "warn" +transmutes_expressible_as_ptr_casts = "warn" +trivially_copy_pass_by_ref = "deny" +unnecessary-wraps = "warn" +useless_transmute = "warn" +wildcard_dependencies = "warn" + +[lints.rust] +missing_debug_implementations = "deny" +trivial_numeric_casts = "deny" +unused_lifetimes = "warn" +unused_macro_rules = "warn" +unused_qualifications = "warn" + +[lints.rust.unexpected_cfgs] +level = "warn" +priority = 0 +check-cfg = [ + "cfg(icu4c_enable_renaming)", + "cfg(needs_alloc_error_handler)", + "cfg(icu4x_run_size_tests)", + "cfg(icu4x_unstable_fast_trie_only)", +] diff --git a/deps/crates/vendor/zerofrom-derive-v0_1/Cargo.toml.orig b/deps/crates/vendor/zerofrom-derive-v0_1/Cargo.toml.orig index ba5aadf1ae4..fa89857ff06 100644 --- a/deps/crates/vendor/zerofrom-derive-v0_1/Cargo.toml.orig +++ b/deps/crates/vendor/zerofrom-derive-v0_1/Cargo.toml.orig @@ -5,14 +5,15 @@ [package] name = "zerofrom-derive" description = "Custom derive for the zerofrom crate" -version = "0.1.6" +version = "0.1.7" authors = ["Manish Goregaokar "] categories = ["data-structures", "memory-management", "caching", "no-std"] -keywords = ["zerocopy", "serialization", "lifetime", "borrow"] +keywords = ["macros", "derive", "zero-copy", "serialization"] edition.workspace = true license.workspace = true repository.workspace = true +rust-version = "1.71.1" [package.metadata.workspaces] independent = true @@ -31,3 +32,5 @@ synstructure = { workspace = true } zerofrom = { path = "..", features = ["derive"]} zerovec = { path = "../../../utils/zerovec", features = ["yoke"] } +[lints] +workspace = true diff --git a/deps/crates/vendor/zerofrom-derive-v0_1/examples/zf_derive.rs b/deps/crates/vendor/zerofrom-derive-v0_1/examples/zf_derive.rs index d3eb2a6fb65..2c89b84c297 100644 --- a/deps/crates/vendor/zerofrom-derive-v0_1/examples/zf_derive.rs +++ b/deps/crates/vendor/zerofrom-derive-v0_1/examples/zf_derive.rs @@ -9,24 +9,24 @@ use zerofrom::ZeroFrom; use zerovec::{maps::ZeroMapKV, ule::AsULE, VarZeroVec, ZeroMap, ZeroVec}; #[derive(ZeroFrom, Copy, Clone)] -pub struct IntExample { +struct IntExample { x: u32, } #[derive(ZeroFrom, Copy, Clone)] -pub struct GenericsExample { +struct GenericsExample { x: u32, y: T, } #[derive(ZeroFrom, Copy, Clone)] -pub struct GenericsExampleWithDefault { +struct GenericsExampleWithDefault { x: T, y: U, } #[derive(ZeroFrom)] -pub struct CowExample<'a> { +struct CowExample<'a> { x: u8, y: &'a str, z: Cow<'a, str>, @@ -34,81 +34,81 @@ pub struct CowExample<'a> { } #[derive(ZeroFrom)] -pub struct ZeroVecExample<'a> { +struct ZeroVecExample<'a> { var: VarZeroVec<'a, str>, vec: ZeroVec<'a, u16>, } #[derive(ZeroFrom)] -pub struct ZeroVecExampleWithGenerics<'a, T: AsULE> { +struct ZeroVecExampleWithGenerics<'a, T: AsULE> { gen: ZeroVec<'a, T>, vec: ZeroVec<'a, u16>, bare: T, } #[derive(ZeroFrom)] -pub struct HasTuples<'data> { +struct HasTuples<'data> { pub bar: (&'data str, &'data str), } -pub fn assert_zf_tuples<'b>(x: &'b HasTuples) -> HasTuples<'b> { +fn assert_zf_tuples<'b>(x: &'b HasTuples) -> HasTuples<'b> { HasTuples::zero_from(x) } -pub fn assert_zf_generics<'a, 'b>( +fn assert_zf_generics<'a, 'b>( x: &'b ZeroVecExampleWithGenerics<'a, u8>, ) -> ZeroVecExampleWithGenerics<'b, u8> { ZeroVecExampleWithGenerics::<'b, u8>::zero_from(x) } #[derive(ZeroFrom)] -pub struct ZeroMapGenericExample<'a, T: for<'b> ZeroMapKV<'b> + ?Sized> { +struct ZeroMapGenericExample<'a, T: for<'b> ZeroMapKV<'b> + ?Sized> { map: ZeroMap<'a, str, T>, } -pub fn assert_zf_map<'b>(x: &'b ZeroMapGenericExample) -> ZeroMapGenericExample<'b, str> { +fn assert_zf_map<'b>(x: &'b ZeroMapGenericExample) -> ZeroMapGenericExample<'b, str> { ZeroMapGenericExample::zero_from(x) } #[derive(Clone, ZeroFrom)] -pub struct CloningZF1 { +struct CloningZF1 { #[zerofrom(clone)] // Vec is not ZeroFrom, so it needs to be cloned vec: Vec, } #[derive(Clone, ZeroFrom)] -pub struct CloningZF2<'data> { +struct CloningZF2<'data> { #[zerofrom(clone)] // Cow is ZeroFrom, but we force a clone cow: Cow<'data, str>, } #[derive(ZeroFrom)] -pub enum CloningZF3<'data> { +enum CloningZF3<'data> { Cow(#[zerofrom(clone)] Cow<'data, str>), } #[derive(ZeroFrom)] #[zerofrom(may_borrow(T, Q))] // instead of treating T as a copy type, we want to allow zerofromming T too -pub struct GenericsThatAreAlsoZf { +struct GenericsThatAreAlsoZf { x: T, y: Option, ignored: PhantomData, q: Q, } -pub fn assert_zf_generics_may_borrow<'a, 'b>( +fn assert_zf_generics_may_borrow<'a, 'b>( x: &'b GenericsThatAreAlsoZf<&'a str, usize, str>, ) -> GenericsThatAreAlsoZf<&'b str, usize, str> { GenericsThatAreAlsoZf::<&'b str, usize, str>::zero_from(x) } #[derive(ZeroFrom)] -pub struct UsesGenericsThatAreAlsoZf<'a> { +struct UsesGenericsThatAreAlsoZf<'a> { x: GenericsThatAreAlsoZf<&'a str, usize, str>, } // Ensure it works with invariant types too #[derive(ZeroFrom)] -pub struct UsesGenericsThatAreAlsoZfWithMap<'a> { +struct UsesGenericsThatAreAlsoZfWithMap<'a> { x: GenericsThatAreAlsoZf, usize, str>, } diff --git a/deps/crates/vendor/zerofrom-derive-v0_1/src/lib.rs b/deps/crates/vendor/zerofrom-derive-v0_1/src/lib.rs index f2c43b344d9..060b961c8ca 100644 --- a/deps/crates/vendor/zerofrom-derive-v0_1/src/lib.rs +++ b/deps/crates/vendor/zerofrom-derive-v0_1/src/lib.rs @@ -2,9 +2,8 @@ // called LICENSE at the top level of the ICU4X source tree // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ). -//! Custom derives for `ZeroFrom` from the `zerofrom` crate. - // https://github.com/unicode-org/icu4x/blob/main/documents/process/boilerplate.md#library-annotations +// #![cfg_attr(not(any(test, doc)), no_std)] #![cfg_attr( not(test), deny( @@ -12,14 +11,12 @@ clippy::unwrap_used, clippy::expect_used, clippy::panic, - clippy::exhaustive_structs, - clippy::exhaustive_enums, - clippy::trivially_copy_pass_by_ref, - missing_debug_implementations, ) )] +#![warn(missing_docs)] + +//! Custom derives for `ZeroFrom` from the `zerofrom` crate. -use core::mem; use proc_macro::TokenStream; use proc_macro2::{Span, TokenStream as TokenStream2}; use quote::quote; @@ -41,7 +38,7 @@ mod visitor; /// for types with a lifetime parameter. /// /// Apply the `#[zerofrom(clone)]` attribute to a field if it doesn't implement -/// Copy or ZeroFrom; this data will be cloned when the struct is zero_from'ed. +/// [`Copy`] or [`ZeroFrom`]; this data will be cloned when the struct is zero-from'ed. /// /// Apply the `#[zerofrom(maybe_borrow(T, U, V))]` attribute to the struct to indicate /// that certain type parameters may themselves contain borrows (by default @@ -245,7 +242,7 @@ fn zf_derive_impl(input: &DeriveInput) -> TokenStream2 { for typaram_c in &mut typarams_c { if let Some(Some(replacement)) = generics_env.get(typaram_c) { // we use mem::replace here so we can be really clear about the C vs the T type - let typaram_t = mem::replace(typaram_c, replacement.clone()); + let typaram_t = core::mem::replace(typaram_c, replacement.clone()); zf_bounds .push(parse_quote!(#typaram_c: zerofrom::ZeroFrom<'zf_inner, #typaram_t>)); tybounds.push(parse_quote!(#typaram_c)); diff --git a/deps/crates/vendor/zerofrom-derive-v0_1/src/visitor.rs b/deps/crates/vendor/zerofrom-derive-v0_1/src/visitor.rs index 0cc44e9d646..01a91e61082 100644 --- a/deps/crates/vendor/zerofrom-derive-v0_1/src/visitor.rs +++ b/deps/crates/vendor/zerofrom-derive-v0_1/src/visitor.rs @@ -43,7 +43,7 @@ impl<'ast> Visit<'ast> for TypeVisitor<'_> { } /// Checks if a type has type or lifetime parameters, given the local context of -/// named type parameters. Returns (has_type_params, has_lifetime_params) +/// named type parameters. Returns `(has_type_params, has_lifetime_params)` pub fn check_type_for_parameters( ty: &Type, typarams: &HashMap>, diff --git a/deps/crates/vendor/zerofrom-v0_1/.cargo_vcs_info.json b/deps/crates/vendor/zerofrom-v0_1/.cargo_vcs_info.json index bd821252129..ac0ea88d4f1 100644 --- a/deps/crates/vendor/zerofrom-v0_1/.cargo_vcs_info.json +++ b/deps/crates/vendor/zerofrom-v0_1/.cargo_vcs_info.json @@ -1,6 +1,6 @@ { "git": { - "sha1": "f4290a877dfcb0f87cad6de4abdd65f0cbb33c9c" + "sha1": "e9575f7e4b5aeddfeeb87ada5d3e715950e8233e" }, "path_in_vcs": "utils/zerofrom" } \ No newline at end of file diff --git a/deps/crates/vendor/zerofrom-v0_1/Cargo.lock b/deps/crates/vendor/zerofrom-v0_1/Cargo.lock index 230c18fa796..a5b5375ff80 100644 --- a/deps/crates/vendor/zerofrom-v0_1/Cargo.lock +++ b/deps/crates/vendor/zerofrom-v0_1/Cargo.lock @@ -4,27 +4,27 @@ version = 3 [[package]] name = "proc-macro2" -version = "1.0.93" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.38" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] [[package]] name = "syn" -version = "2.0.98" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", @@ -33,9 +33,9 @@ dependencies = [ [[package]] name = "synstructure" -version = "0.13.1" +version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", @@ -44,22 +44,22 @@ dependencies = [ [[package]] name = "unicode-ident" -version = "1.0.17" +version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00e2473a93778eb0bad35909dff6a10d28e63f792f16ed15e404fca9d5eeedbe" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" [[package]] name = "zerofrom" -version = "0.1.6" +version = "0.1.8" dependencies = [ "zerofrom-derive", ] [[package]] name = "zerofrom-derive" -version = "0.1.5" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "595eed982f7d355beb85837f651fa22e90b3c044842dc7f2c2842c086f295808" +checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1" dependencies = [ "proc-macro2", "quote", diff --git a/deps/crates/vendor/zerofrom-v0_1/Cargo.toml b/deps/crates/vendor/zerofrom-v0_1/Cargo.toml index eb66cad5805..1e05f9a9955 100644 --- a/deps/crates/vendor/zerofrom-v0_1/Cargo.toml +++ b/deps/crates/vendor/zerofrom-v0_1/Cargo.toml @@ -11,10 +11,10 @@ [package] edition = "2021" -rust-version = "1.81" +rust-version = "1.71.1" name = "zerofrom" -version = "0.1.6" -authors = ["Manish Goregaokar "] +version = "0.1.8" +authors = ["The ICU4X Project Developers"] build = false include = [ "data/**/*", @@ -25,6 +25,7 @@ include = [ "Cargo.toml", "LICENSE", "README.md", + "build.rs", ] autolib = false autobins = false @@ -34,10 +35,9 @@ autobenches = false description = "ZeroFrom trait for constructing" readme = "README.md" keywords = [ - "zerocopy", + "zero-copy", "serialization", - "lifetime", - "borrow", + "memory-efficiency", ] categories = [ "data-structures", @@ -47,11 +47,14 @@ categories = [ license = "Unicode-3.0" repository = "https://github.com/unicode-org/icu4x" +[package.metadata.workspaces] +independent = true + [package.metadata.docs.rs] all-features = true -[package.metadata.workspaces] -independent = true +[package.metadata.playground] +all-features = true [features] alloc = [] @@ -63,6 +66,56 @@ name = "zerofrom" path = "src/lib.rs" [dependencies.zerofrom-derive] -version = "0.1.3" +version = "0.1.6" optional = true default-features = false + +[lints.clippy] +alloc-instead-of-core = "warn" +bool-assert-comparison = "allow" +branches-sharing-code = "warn" +collection_is_never_read = "warn" +crosspointer_transmute = "warn" +dbg_macro = "warn" +debug_assert_with_mut_call = "warn" +doc_markdown = "warn" +exhaustive_enums = "deny" +exhaustive_structs = "deny" +fn_to_numeric_cast_any = "warn" +infinite_loop = "warn" +large_stack_arrays = "warn" +mismatching_type_param_order = "warn" +missing_fields_in_debug = "warn" +missing_transmute_annotations = "warn" +negative_feature_names = "warn" +or-fun-call = "warn" +same_functions_in_if_condition = "warn" +todo = "warn" +transmute_bytes_to_str = "warn" +transmute_int_to_bool = "warn" +transmute_int_to_non_zero = "warn" +transmute_ptr_to_ptr = "warn" +transmute_ptr_to_ref = "warn" +transmute_undefined_repr = "warn" +transmutes_expressible_as_ptr_casts = "warn" +trivially_copy_pass_by_ref = "deny" +unnecessary-wraps = "warn" +useless_transmute = "warn" +wildcard_dependencies = "warn" + +[lints.rust] +missing_debug_implementations = "deny" +trivial_numeric_casts = "deny" +unused_lifetimes = "warn" +unused_macro_rules = "warn" +unused_qualifications = "warn" + +[lints.rust.unexpected_cfgs] +level = "warn" +priority = 0 +check-cfg = [ + "cfg(icu4c_enable_renaming)", + "cfg(needs_alloc_error_handler)", + "cfg(icu4x_run_size_tests)", + "cfg(icu4x_unstable_fast_trie_only)", +] diff --git a/deps/crates/vendor/zerofrom-v0_1/Cargo.toml.orig b/deps/crates/vendor/zerofrom-v0_1/Cargo.toml.orig index f61029924e3..89da87534ce 100644 --- a/deps/crates/vendor/zerofrom-v0_1/Cargo.toml.orig +++ b/deps/crates/vendor/zerofrom-v0_1/Cargo.toml.orig @@ -5,16 +5,16 @@ [package] name = "zerofrom" description = "ZeroFrom trait for constructing" -version = "0.1.6" -authors = ["Manish Goregaokar "] +version = "0.1.8" categories = ["data-structures", "caching", "no-std"] -keywords = ["zerocopy", "serialization", "lifetime", "borrow"] +keywords = ["zero-copy", "serialization", "memory-efficiency"] -edition.workspace = true +authors.workspace = true +edition = "2021" include.workspace = true license.workspace = true repository.workspace = true -rust-version.workspace = true +rust-version = "1.71.1" [package.metadata.workspaces] independent = true @@ -22,6 +22,9 @@ independent = true [package.metadata.docs.rs] all-features = true +[package.metadata.playground] +all-features = true + [features] alloc = [] derive = ["dep:zerofrom-derive"] @@ -29,3 +32,6 @@ default = ["alloc"] [dependencies] zerofrom-derive = { workspace = true, optional = true} + +[lints] +workspace = true diff --git a/deps/crates/vendor/zerofrom-v0_1/src/lib.rs b/deps/crates/vendor/zerofrom-v0_1/src/lib.rs index 911d7e78077..680a64f3fc0 100644 --- a/deps/crates/vendor/zerofrom-v0_1/src/lib.rs +++ b/deps/crates/vendor/zerofrom-v0_1/src/lib.rs @@ -2,10 +2,6 @@ // called LICENSE at the top level of the ICU4X source tree // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ). -//! This crate provides [`ZeroFrom`], a trait for converting types in a zero-copy way. -//! -//! See the documentation of [`ZeroFrom`] for more details. - // https://github.com/unicode-org/icu4x/blob/main/documents/process/boilerplate.md#library-annotations #![cfg_attr(not(any(test, doc)), no_std)] #![cfg_attr( @@ -15,12 +11,14 @@ clippy::unwrap_used, clippy::expect_used, clippy::panic, - clippy::exhaustive_structs, - clippy::exhaustive_enums, - clippy::trivially_copy_pass_by_ref, - missing_debug_implementations, ) )] +#![warn(missing_docs)] + +//! This crate provides [`ZeroFrom`], a trait for converting types in a zero-copy way. +//! +//! See the documentation of [`ZeroFrom`] for more details. + // The lifetimes here are important for safety and explicitly writing // them out is good even when redundant #![allow(clippy::needless_lifetimes)] From 7a0bf5da0619667dd6830e064d70ef38dad11fe4 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Thu, 19 Nov 2026 16:12:04 +0100 Subject: [PATCH 316/331] tools: sort OpenSSL releases numerically MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Select 3.5.10 over 3.5.9 when GitHub returns matching tags in lexicographic order. Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/67441 Reviewed-By: Antoine du Hamel Reviewed-By: Gürgün Dayıoğlu Reviewed-By: Richard Lau --- tools/dep_updaters/update-openssl.sh | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/dep_updaters/update-openssl.sh b/tools/dep_updaters/update-openssl.sh index 29d72e8700e..6c0dee5903a 100755 --- a/tools/dep_updaters/update-openssl.sh +++ b/tools/dep_updaters/update-openssl.sh @@ -13,7 +13,8 @@ download() { LATEST_TAG_NAME="$("$NODE" --input-type=module <<'EOF' const res = await fetch('https://api.github.com/repos/openssl/openssl/git/matching-refs/tags/openssl-3.5'); if (!res.ok) throw new Error(`FetchError: ${res.status} ${res.statusText}`, { cause: res }); -const releases = await res.json() +const releases = (await res.json()) + .sort(({ ref: a }, { ref: b }) => a.localeCompare(b, 'en', { numeric: true })); const latest = releases.at(-1); if(!latest) throw new Error(`Could not find latest release`); console.log(latest.ref.replace('refs/tags/','')); From c74438ce608109d5d7b256973218d92151f4e0ca Mon Sep 17 00:00:00 2001 From: fatih Date: Wed, 4 Nov 2026 05:23:42 +0300 Subject: [PATCH 317/331] test: extend http2 cancellation coverage MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cover session reuse after canceling queued uploads, including partial sends and destruction from a write callback. Verify that another stream remains usable after cancellation. Signed-off-by: Fatih Güzel PR-URL: https://github.com/nodejs/node/pull/66784 Backport-PR-URL: https://github.com/nodejs/node/pull/67563 Fixes: https://github.com/nodejs/node/issues/66742 Reviewed-By: Antoine du Hamel --- .../test-http2-session-memory-after-cancel.js | 104 ++++++++++++++++++ 1 file changed, 104 insertions(+) create mode 100644 test/parallel/test-http2-session-memory-after-cancel.js diff --git a/test/parallel/test-http2-session-memory-after-cancel.js b/test/parallel/test-http2-session-memory-after-cancel.js new file mode 100644 index 00000000000..04ae407461e --- /dev/null +++ b/test/parallel/test-http2-session-memory-after-cancel.js @@ -0,0 +1,104 @@ +'use strict'; +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('assert'); +const { once } = require('events'); +const http2 = require('http2'); +const { setImmediate } = require('timers/promises'); + +const { NGHTTP2_CANCEL, NGHTTP2_NO_ERROR } = http2.constants; + +// Canceling a queued upload must release its remaining session memory credit, +// without disrupting another stream or preventing new requests. +async function test(initialWindowSize, destroyInWriteCallback = false) { + const server = http2.createServer({ settings: { initialWindowSize } }); + const sessions = new Set(); + let survivingStream; + let received = 0; + server.on('session', (session) => sessions.add(session)); + server.on('stream', common.mustCall((stream, headers) => { + if (headers[':method'] === 'POST') { + if (destroyInWriteCallback) { + stream.on('error', common.mustNotCall()); + } else if (initialWindowSize === 0) { + stream.close(NGHTTP2_CANCEL); + } else { + stream.once('data', common.mustCall((chunk) => { + received += chunk.length; + stream.close(NGHTTP2_CANCEL); + })); + } + return; + } + stream.respond({ ':status': 200 }); + if (headers[':path'] === '/survivor') { + survivingStream = stream; + } else { + stream.end(); + survivingStream.end('still alive'); + } + }, 3)); + + let client; + try { + server.listen(0, '127.0.0.1'); + await once(server, 'listening'); + client = http2.connect(`http://127.0.0.1:${server.address().port}`, { + maxSessionMemory: 1, + }); + const [settings] = await once(client, 'remoteSettings'); + assert.strictEqual(settings.initialWindowSize, initialWindowSize); + + const survivor = client.request({ ':path': '/survivor' }); + let body = ''; + survivor.setEncoding('utf8'); + survivor.on('data', (chunk) => { body += chunk; }); + const survived = once(survivor, 'end'); + const [headers] = await once(survivor, 'response'); + assert.strictEqual(headers[':status'], 200); + + const upload = client.request({ ':method': 'POST' }); + upload.on('error', common.mustNotCall()); + if (destroyInWriteCallback) { + // Completing this empty native write dispatches the buffered body before + // its user callback destroys the stream, while DATA is being gathered. + upload.write('', common.mustCall(() => upload.destroy())); + } + const closed = new Promise((resolve) => upload.once('close', resolve)); + upload.write(Buffer.alloc(4 * 1024 * 1024), common.mustCall()); + await closed; + assert.strictEqual(upload.rstCode, + destroyInWriteCallback ? NGHTTP2_NO_ERROR : NGHTTP2_CANCEL); + if (initialWindowSize === 0) { + assert.strictEqual(received, 0); + } else if (!destroyInWriteCallback) { + assert(received > 0); + assert(received < 4 * 1024 * 1024); + } + + // Native stream destruction frees the queued write in an immediate. + await setImmediate(); + const request = client.request(); + const completed = Promise.all([ + once(request, 'response'), + once(request, 'end'), + ]); + request.resume(); + const [[responseHeaders]] = await completed; + assert.strictEqual(responseHeaders[':status'], 200); + await survived; + assert.strictEqual(body, 'still alive'); + } finally { + client?.destroy(); + for (const session of sessions) session.destroy(); + server.close(); + } +} + +(async () => { + await test(0); + await test(64 * 1024); + await test(64 * 1024, true); +})().then(common.mustCall()); From ef65ffdd93b773facd8f875f52dd85c61ca18a05 Mon Sep 17 00:00:00 2001 From: Jakob Linke Date: Thu, 17 Sep 2026 07:33:56 +0200 Subject: [PATCH 318/331] deps: V8: cherry-pick 53588faba3ed MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Original commit message: [regexp] Use simple case folding for /iu backreferences Backreference comparison in unicode mode went through icu::UnicodeString::caseCompare, which applies full case folding to the whole string. Canonicalize (ECMA-262 22.2.2.9.2) instead applies the simple case folding of each code point separately, so e.g. U+00DF must not fold to "ss". As a result /^(..)\1$/iu matched "ßSsß", since both halves full-fold to "sss". The rest of the engine already closes character ranges over USET_SIMPLE_CASE_INSENSITIVE, so only backreferences were affected, and only for two-byte subjects: the one-byte matcher compares code units inline. Replace caseCompare with a per-code-point loop over u_foldCase. This also drops the icu::UnicodeString construction from the matcher's hot path. Fixed: 562108903 Change-Id: I277040a7d8c310bf7833f8fbcce2f005f823047c Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8423859 Commit-Queue: Patrick Thier Auto-Submit: Jakob Linke Reviewed-by: Patrick Thier Cr-Commit-Position: refs/heads/main@{#109970} Refs: https://github.com/v8/v8/commit/53588faba3ed165c7e713d077d6b90fadf795887 PR-URL: https://github.com/nodejs/node/pull/67527 Reviewed-By: Antoine du Hamel --- common.gypi | 2 +- deps/v8/src/regexp/regexp-macro-assembler.cc | 26 +++++++--- .../regress/regress-crbug-562108903.js | 47 +++++++++++++++++++ 3 files changed, 68 insertions(+), 7 deletions(-) create mode 100644 deps/v8/test/mjsunit/regress/regress-crbug-562108903.js diff --git a/common.gypi b/common.gypi index ee85f6a1d40..6779a2e2fa8 100644 --- a/common.gypi +++ b/common.gypi @@ -50,7 +50,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.52', + 'v8_embedder_string': '-node.53', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/regexp/regexp-macro-assembler.cc b/deps/v8/src/regexp/regexp-macro-assembler.cc index e884491fe09..e6158c45540 100644 --- a/deps/v8/src/regexp/regexp-macro-assembler.cc +++ b/deps/v8/src/regexp/regexp-macro-assembler.cc @@ -14,7 +14,7 @@ #ifdef V8_INTL_SUPPORT #include "unicode/uchar.h" -#include "unicode/unistr.h" +#include "unicode/utf16.h" #endif // V8_INTL_SUPPORT namespace v8 { @@ -83,11 +83,25 @@ int RegExpMacroAssembler::CaseInsensitiveCompareUnicode(Address byte_offset1, DCHECK_EQ(0, byte_length % 2); #ifdef V8_INTL_SUPPORT - int32_t length = static_cast(byte_length >> 1); - icu::UnicodeString uni_str_1(reinterpret_cast(byte_offset1), - length); - return uni_str_1.caseCompare(reinterpret_cast(byte_offset2), - length, U_FOLD_CASE_DEFAULT) == 0; + // Canonicalize (ECMA-262 22.2.2.9.2) applies the simple case folding of + // each code point separately. + const int32_t length = static_cast(byte_length >> 1); + const char16_t* str1 = reinterpret_cast(byte_offset1); + const char16_t* str2 = reinterpret_cast(byte_offset2); + int32_t i1 = 0; + int32_t i2 = 0; + while (i1 < length) { + UChar32 c1, c2; + U16_NEXT(str1, i1, length, c1); + U16_NEXT(str2, i2, length, c2); + if (i1 != i2) return 0; + if (c1 == c2) continue; + if (u_foldCase(c1, U_FOLD_CASE_DEFAULT) != + u_foldCase(c2, U_FOLD_CASE_DEFAULT)) { + return 0; + } + } + return 1; #else base::uc16* substring1 = reinterpret_cast(byte_offset1); base::uc16* substring2 = reinterpret_cast(byte_offset2); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-562108903.js b/deps/v8/test/mjsunit/regress/regress-crbug-562108903.js new file mode 100644 index 00000000000..bbb4e0317da --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-562108903.js @@ -0,0 +1,47 @@ +// Copyright 2026 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Canonicalize for /iu and /iv applies simple case folding to each code point +// separately. Backreference comparison must not use full case folding, under +// which e.g. U+00DF folds to "ss". +// +// Every case is spelled twice: once with literal characters, once with escapes. + +// A leading non-Latin1 character forces the two-byte matcher. +const prefix = 'Ā'; + +function assertBackrefMismatch(pattern, subject) { + assertFalse(new RegExp(pattern, 'iu').test(subject)); + assertFalse(new RegExp(pattern, 'iv').test(subject)); +} + +function assertBackrefMatch(pattern, subject) { + assertTrue(new RegExp(pattern, 'iu').test(subject)); + assertTrue(new RegExp(pattern, 'iv').test(subject)); +} + +// U+00DF SHARP S has a full folding to "ss" but no simple folding. +assertBackrefMismatch(`^${prefix}(..)\\1$`, `${prefix}ßSsß`); +assertBackrefMismatch(`^${prefix}(..)\\1$`, `${prefix}\u00DFSs\u00DF`); + +// U+FB00 LIGATURE FF has a full folding to "ff" but no simple folding. +assertBackrefMismatch(`^${prefix}(..)\\1$`, `${prefix}ffFfff`); +assertBackrefMismatch(`^${prefix}(..)\\1$`, `${prefix}\uFB00Ff\uFB00`); + +// Simple foldings still match. +assertBackrefMatch(`^${prefix}(..)\\1$`, `${prefix}AbaB`); + +assertBackrefMatch(`^${prefix}(.)\\1$`, `${prefix}ßß`); +assertBackrefMatch(`^${prefix}(.)\\1$`, `${prefix}\u00DF\u00DF`); + +// Folding across distinct code points needs the case mapping ICU provides. +if (typeof Intl !== 'undefined') { + // U+1E9E CAPITAL SHARP S folds to U+00DF. + assertBackrefMatch(`^${prefix}(.)\\1$`, `${prefix}ẞß`); + assertBackrefMatch(`^${prefix}(.)\\1$`, `${prefix}\u1E9E\u00DF`); + + // U+212A KELVIN SIGN folds to "k". + assertBackrefMatch(`^${prefix}(.)\\1$`, `${prefix}Kk`); + assertBackrefMatch(`^${prefix}(.)\\1$`, `${prefix}\u212Ak`); +} From df0291d31d378a7cdda52ee1707bcf1dc4203854 Mon Sep 17 00:00:00 2001 From: Jakob Linke Date: Fri, 25 Sep 2026 09:31:20 +0200 Subject: [PATCH 319/331] deps: V8: backport ee1c92f63568 Original commit message: [regexp] Share matcher case equivalence when factoring alternatives Alternative sorting and prefix factoring used full case folding, which can merge characters that the matcher treats as distinct in legacy /i mode, such as U+017F and s. Use shared CaseFolding::EquivalenceKey and CloseOver operations for comparisons and character expansion. Preserve UTF-16 code-unit handling in non-unicode mode and code-point decoding in Unicode backreferences. Remove the generated SpecialAddSet while retaining exact Canonicalize for IgnoreSet generation. Add exhaustive release-only BMP equivalence and closure checks, plus coverage for alternatives, literals, ranges, and backreferences. Restore the real assertEquals in regress-10573. Change-Id: Idbf3866ca99c5446aeab15fd21f841d2f77d4243 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8456723 Commit-Queue: Patrick Thier Reviewed-by: Patrick Thier Auto-Submit: Jakob Linke Cr-Commit-Position: refs/heads/main@{#110082} Refs: https://github.com/v8/v8/commit/ee1c92f63568592d2362127ff9981e2fc75e9e6d Co-authored-by: Renegade334 PR-URL: https://github.com/nodejs/node/pull/67527 Reviewed-By: Antoine du Hamel --- common.gypi | 2 +- deps/v8/src/regexp/gen-regexp-special-case.cc | 56 +++++++-- deps/v8/src/regexp/regexp-compiler-tonode.cc | 80 ++++++------- deps/v8/src/regexp/regexp-compiler.cc | 27 +---- deps/v8/src/regexp/regexp-macro-assembler.cc | 18 ++- deps/v8/src/regexp/special-case.h | 110 ++++++++---------- deps/v8/test/intl/regexp-case-equivalence.js | 55 +++++++++ .../intl/regexp-ignore-case-alternatives.js | 57 +++++++++ deps/v8/test/intl/regress-10248.js | 2 +- deps/v8/test/intl/regress-10573.js | 6 +- .../test/unittests/regexp/regexp-unittest.cc | 71 +++++++++++ 11 files changed, 333 insertions(+), 151 deletions(-) create mode 100644 deps/v8/test/intl/regexp-case-equivalence.js create mode 100644 deps/v8/test/intl/regexp-ignore-case-alternatives.js diff --git a/common.gypi b/common.gypi index 6779a2e2fa8..4b41641c1f3 100644 --- a/common.gypi +++ b/common.gypi @@ -50,7 +50,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.53', + 'v8_embedder_string': '-node.54', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/regexp/gen-regexp-special-case.cc b/deps/v8/src/regexp/gen-regexp-special-case.cc index 86f6b212c93..53b2c1327fb 100644 --- a/deps/v8/src/regexp/gen-regexp-special-case.cc +++ b/deps/v8/src/regexp/gen-regexp-special-case.cc @@ -9,6 +9,7 @@ #include "src/base/strings.h" #include "src/regexp/special-case.h" +#include "unicode/unistr.h" namespace v8 { namespace internal { @@ -17,6 +18,38 @@ static const base::uc32 kSurrogateStart = 0xd800; static const base::uc32 kSurrogateEnd = 0xdfff; static const base::uc32 kNonBmpStart = 0x10000; +// This implements ECMAScript 2020 21.2.2.8.2 (Runtime Semantics: +// Canonicalize) step 3, which is used to determine whether +// characters match when ignoreCase is true and unicode is false. +UChar32 Canonicalize(UChar32 ch) { + // a. Assert: ch is a UTF-16 code unit. + CHECK_LE(ch, 0xffff); + + // b. Let s be the String value consisting of the single code unit ch. + icu::UnicodeString s(ch); + + // c. Let u be the same result produced as if by performing the algorithm + // for String.prototype.toUpperCase using s as the this value. + // d. Assert: Type(u) is String. + icu::UnicodeString& u = s.toUpper(); + + // e. If u does not consist of a single code unit, return ch. + if (u.length() != 1) { + return ch; + } + + // f. Let cu be u's single code unit element. + UChar32 cu = u.char32At(0); + + // g. If the value of ch >= 128 and the value of cu < 128, return ch. + if (ch >= 128 && cu < 128) { + return ch; + } + + // h. Return cu. + return cu; +} + // The following code generates "src/regexp/special-case.cc". void PrintSet(std::ofstream& out, const char* name, const icu::UnicodeSet& set) { @@ -62,12 +95,12 @@ void PrintSpecial(std::ofstream& out) { continue; // Ignore surrogate range } current.set(i, i); - current.closeOver(USET_CASE_INSENSITIVE); + current.closeOver(USET_SIMPLE_CASE_INSENSITIVE); // Check to see if all characters in the case-folding equivalence // class as defined by UnicodeSet::closeOver all map to the same // canonical value. - UChar32 canonical = RegExpCaseFolding::Canonicalize(i); + UChar32 canonical = Canonicalize(i); bool class_has_matching_canonical_char = false; bool class_has_non_matching_canonical_char = false; for (int32_t j = 0; j < current.getRangeCount(); j++) { @@ -76,7 +109,7 @@ void PrintSpecial(std::ofstream& out) { if (c == i) { continue; } - UChar32 other_canonical = RegExpCaseFolding::Canonicalize(c); + UChar32 other_canonical = Canonicalize(c); if (canonical == other_canonical) { class_has_matching_canonical_char = true; } else { @@ -100,30 +133,29 @@ void PrintSpecial(std::ofstream& out) { } // Verify that no Unicode equivalence class contains two non-trivial - // JS equivalence classes. Every character in SpecialAddSet has the + // JS equivalence classes. Every character in special_add has the // same canonical value as every other non-IgnoreSet character in // its Unicode equivalence class. Therefore, if we call closeOver on // a set containing no IgnoreSet characters, the only characters // that must be removed from the result are in IgnoreSet. This fact - // is used in CharacterRange::AddCaseEquivalents. + // is used in RegExpCaseFolding::CloseOver. for (int32_t i = 0; i < special_add.getRangeCount(); i++) { for (UChar32 c = special_add.getRangeStart(i); c <= special_add.getRangeEnd(i); c++) { - UChar32 canonical = RegExpCaseFolding::Canonicalize(c); + UChar32 canonical = Canonicalize(c); current.set(c, c); - current.closeOver(USET_CASE_INSENSITIVE); + current.closeOver(USET_SIMPLE_CASE_INSENSITIVE); current.removeAll(ignore); for (int32_t j = 0; j < current.getRangeCount(); j++) { for (UChar32 c2 = current.getRangeStart(j); c2 <= current.getRangeEnd(j); c2++) { - CHECK_EQ(canonical, RegExpCaseFolding::Canonicalize(c2)); + CHECK_EQ(canonical, Canonicalize(c2)); } } } } PrintSet(out, "IgnoreSet", ignore); - PrintSet(out, "SpecialAddSet", special_add); } void WriteHeader(const char* header_filename) { @@ -135,9 +167,9 @@ void WriteHeader(const char* header_filename) { << "// Automatically generated by regexp/gen-regexp-special-case.cc\n\n" << "// The following functions are used to build UnicodeSets\n" << "// for special cases where the case-folding algorithm used by\n" - << "// UnicodeSet::closeOver(USET_CASE_INSENSITIVE) does not match\n" - << "// the algorithm defined in ECMAScript 2020 21.2.2.8.2 (Runtime\n" - << "// Semantics: Canonicalize) step 3.\n\n" + << "// UnicodeSet::closeOver(USET_SIMPLE_CASE_INSENSITIVE) does\n" + << "// not match the algorithm defined in ECMAScript 2020 21.2.2.8.2\n" + << "// (Runtime Semantics: Canonicalize) step 3.\n\n" << "#ifdef V8_INTL_SUPPORT\n" << "#include \"src/base/lazy-instance.h\"\n\n" << "#include \"src/regexp/special-case.h\"\n\n" diff --git a/deps/v8/src/regexp/regexp-compiler-tonode.cc b/deps/v8/src/regexp/regexp-compiler-tonode.cc index a129e5865fd..ea559ab6bc5 100644 --- a/deps/v8/src/regexp/regexp-compiler-tonode.cc +++ b/deps/v8/src/regexp/regexp-compiler-tonode.cc @@ -539,7 +539,7 @@ void CharacterRange::AddUnicodeCaseEquivalents(ZoneList* ranges, } // Clear the ranges list without freeing the backing store. ranges->Rewind(0); - set.closeOver(USET_SIMPLE_CASE_INSENSITIVE); + RegExpCaseFolding::CloseOver(set, RegExpCaseFolding::Mode::kUnicode); for (int i = 0; i < set.getRangeCount(); i++) { ranges->Add(Range(set.getRangeStart(i), set.getRangeEnd(i)), zone); } @@ -830,29 +830,39 @@ int CompareFirstChar(RegExpTree* const* a, RegExpTree* const* b) { #ifdef V8_INTL_SUPPORT -int CompareCaseInsensitive(const icu::UnicodeString& a, - const icu::UnicodeString& b) { - return a.caseCompare(b, U_FOLD_CASE_DEFAULT); +RegExpCaseFolding::Mode CaseFoldingMode(RegExpFlags flags) { + return IsEitherUnicode(flags) ? RegExpCaseFolding::Mode::kUnicode + : RegExpCaseFolding::Mode::kNonUnicode; } -int CompareFirstCharCaseInsensitive(RegExpTree* const* a, +// Use the matcher's case equivalence (see +// TextNode::GetCaseIndependentLetters). Full case folding would, for example, +// conflate U+017F and 's' under /i. +int CompareCaseInsensitive(RegExpCaseFolding::Mode mode, base::uc16 a, + base::uc16 b) { + if (a == b) return 0; + return RegExpCaseFolding::EquivalenceKey(a, mode) - + RegExpCaseFolding::EquivalenceKey(b, mode); +} + +int CompareFirstCharCaseInsensitive(RegExpCaseFolding::Mode mode, + RegExpTree* const* a, RegExpTree* const* b) { RegExpAtom* atom1 = FirstAtom(*a); RegExpAtom* atom2 = FirstAtom(*b); - return CompareCaseInsensitive(icu::UnicodeString{atom1->data().at(0)}, - icu::UnicodeString{atom2->data().at(0)}); + return CompareCaseInsensitive(mode, atom1->data().at(0), atom2->data().at(0)); } -bool Equals(bool ignore_case, const icu::UnicodeString& a, - const icu::UnicodeString& b) { +bool Equals(bool ignore_case, RegExpCaseFolding::Mode mode, base::uc16 a, + base::uc16 b) { if (a == b) return true; - if (ignore_case) return CompareCaseInsensitive(a, b) == 0; + if (ignore_case) return CompareCaseInsensitive(mode, a, b) == 0; return false; // Case-sensitive equality already checked above. } -bool CharAtEquals(bool ignore_case, int index, const RegExpAtom* a, - const RegExpAtom* b) { - return Equals(ignore_case, a->data().at(index), b->data().at(index)); +bool CharAtEquals(bool ignore_case, RegExpCaseFolding::Mode mode, int index, + const RegExpAtom* a, const RegExpAtom* b) { + return Equals(ignore_case, mode, a->data().at(index), b->data().at(index)); } #else @@ -931,19 +941,20 @@ bool RegExpDisjunction::SortConsecutiveAtoms(RegExpCompiler* compiler) { if (!StartsWithAtom(alternative)) break; i++; } - // Sort atoms to get ones with common prefixes together. - // This step is more tricky if we are in a case-independent regexp, - // because it would change /is|I/ to /I|is/, and order matters when - // the regexp parts don't match only disjoint starting points. To fix - // this we have a version of CompareFirstChar that uses case- - // independent character classes for comparison. + // Sort atoms to bring common prefixes together. A case-insensitive sort + // must preserve the order of alternatives whose first characters are + // equivalent: changing /is|I/ to /I|is/ would change the match result. DCHECK_LT(first_atom, alternatives->length()); DCHECK_LE(i, alternatives->length()); DCHECK_LE(first_atom, i); if (IsIgnoreCase(compiler->flags())) { #ifdef V8_INTL_SUPPORT - alternatives->StableSort(CompareFirstCharCaseInsensitive, first_atom, - i - first_atom); + const RegExpCaseFolding::Mode mode = CaseFoldingMode(compiler->flags()); + auto compare_closure = [mode](RegExpTree* const* a, + RegExpTree* const* b) { + return CompareFirstCharCaseInsensitive(mode, a, b); + }; + alternatives->StableSort(compare_closure, first_atom, i - first_atom); #else unibrow::Mapping* canonicalize = compiler->isolate()->regexp_macro_assembler_canonicalize(); @@ -967,6 +978,9 @@ void RegExpDisjunction::RationalizeConsecutiveAtoms(RegExpCompiler* compiler) { ZoneList* alternatives = this->alternatives(); int length = alternatives->length(); const bool ignore_case = IsIgnoreCase(compiler->flags()); +#ifdef V8_INTL_SUPPORT + const RegExpCaseFolding::Mode mode = CaseFoldingMode(compiler->flags()); +#endif // V8_INTL_SUPPORT int write_posn = 0; int i = 0; @@ -980,7 +994,7 @@ void RegExpDisjunction::RationalizeConsecutiveAtoms(RegExpCompiler* compiler) { RegExpAtom* const atom = FirstAtom(alternative); #ifdef V8_INTL_SUPPORT - icu::UnicodeString common_prefix(atom->data().at(0)); + base::uc16 common_prefix = atom->data().at(0); #else unibrow::Mapping* const canonicalize = compiler->isolate()->regexp_macro_assembler_canonicalize(); @@ -997,8 +1011,8 @@ void RegExpDisjunction::RationalizeConsecutiveAtoms(RegExpCompiler* compiler) { if (!StartsWithAtom(alternative)) break; RegExpAtom* const alt_atom = FirstAtom(alternative); #ifdef V8_INTL_SUPPORT - icu::UnicodeString new_prefix(alt_atom->data().at(0)); - if (!Equals(ignore_case, new_prefix, common_prefix)) break; + base::uc16 new_prefix = alt_atom->data().at(0); + if (!Equals(ignore_case, mode, new_prefix, common_prefix)) break; #else unibrow::uchar new_prefix = alt_atom->data().at(0); if (!Equals(ignore_case, canonicalize, new_prefix, common_prefix)) break; @@ -1021,7 +1035,7 @@ void RegExpDisjunction::RationalizeConsecutiveAtoms(RegExpCompiler* compiler) { FirstAtom(alternatives->at(j + first_with_prefix)); for (int k = 1; k < prefix_length; k++) { #ifdef V8_INTL_SUPPORT - if (!CharAtEquals(ignore_case, k, alt_atom, old_atom)) { + if (!CharAtEquals(ignore_case, mode, k, alt_atom, old_atom)) { #else if (!CharAtEquals(ignore_case, canonicalize, k, alt_atom, old_atom)) { #endif // V8_INTL_SUPPORT @@ -1690,22 +1704,8 @@ void CharacterRange::AddCaseEquivalents(Isolate* isolate, Zone* zone, others.add(from, to); } - // Compute the set of additional characters that should be added, - // using UnicodeSet::closeOver. ECMA 262 defines slightly different - // case-folding rules than Unicode, so some characters that are - // added by closeOver do not match anything other than themselves in - // JS. For example, 'ſ' (U+017F LATIN SMALL LETTER LONG S) is the - // same case-insensitive character as 's' or 'S' according to - // Unicode, but does not match any other character in JS. To handle - // this case, we add such characters to the IgnoreSet and filter - // them out. We filter twice: once before calling closeOver (to - // prevent 'ſ' from adding 's'), and once after calling closeOver - // (to prevent 's' from adding 'ſ'). See regexp/special-case.h for - // more information. icu::UnicodeSet already_added(others); - others.removeAll(RegExpCaseFolding::IgnoreSet()); - others.closeOver(USET_CASE_INSENSITIVE); - others.removeAll(RegExpCaseFolding::IgnoreSet()); + RegExpCaseFolding::CloseOver(others, RegExpCaseFolding::Mode::kNonUnicode); others.removeAll(already_added); // Add others to the ranges diff --git a/deps/v8/src/regexp/regexp-compiler.cc b/deps/v8/src/regexp/regexp-compiler.cc index ba1452be9fc..7a9d7aead90 100644 --- a/deps/v8/src/regexp/regexp-compiler.cc +++ b/deps/v8/src/regexp/regexp-compiler.cc @@ -903,28 +903,11 @@ int GetCaseIndependentLetters(Isolate* isolate, base::uc16 character, } #ifdef V8_INTL_SUPPORT - if (!unicode && RegExpCaseFolding::IgnoreSet().contains(character)) { - if (one_byte_subject && character > String::kMaxOneByteCharCode) { - // This function promises not to return a character that is impossible - // for the subject encoding. - return 0; - } - letters[0] = character; - DCHECK(ContainsOnlyUtf16CodeUnits(letters, 1)); - return 1; - } - bool in_special_add_set = - RegExpCaseFolding::SpecialAddSet().contains(character); - icu::UnicodeSet set; set.add(character); - set = set.closeOver(unicode ? USET_SIMPLE_CASE_INSENSITIVE - : USET_CASE_INSENSITIVE); - - UChar32 canon = 0; - if (in_special_add_set && !unicode) { - canon = RegExpCaseFolding::Canonicalize(character); - } + RegExpCaseFolding::CloseOver(set, + unicode ? RegExpCaseFolding::Mode::kUnicode + : RegExpCaseFolding::Mode::kNonUnicode); int32_t range_count = set.getRangeCount(); int items = 0; @@ -934,10 +917,6 @@ int GetCaseIndependentLetters(Isolate* isolate, base::uc16 character, CHECK(end - start + items <= letter_length); for (UChar32 cu = start; cu <= end; cu++) { if (one_byte_subject && cu > String::kMaxOneByteCharCode) continue; - if (!unicode && in_special_add_set && - RegExpCaseFolding::Canonicalize(cu) != canon) { - continue; - } letters[items++] = static_cast(cu); } } diff --git a/deps/v8/src/regexp/regexp-macro-assembler.cc b/deps/v8/src/regexp/regexp-macro-assembler.cc index e6158c45540..67ece5f387c 100644 --- a/deps/v8/src/regexp/regexp-macro-assembler.cc +++ b/deps/v8/src/regexp/regexp-macro-assembler.cc @@ -58,9 +58,14 @@ int RegExpMacroAssembler::CaseInsensitiveCompareNonUnicode(Address byte_offset1, base::uc16* substring2 = reinterpret_cast(byte_offset2); for (size_t i = 0; i < length; i++) { - UChar32 c1 = RegExpCaseFolding::Canonicalize(substring1[i]); - UChar32 c2 = RegExpCaseFolding::Canonicalize(substring2[i]); - if (c1 != c2) { + UChar32 c1 = substring1[i]; + UChar32 c2 = substring2[i]; + if (c1 == c2) continue; + if ( + RegExpCaseFolding::EquivalenceKey( + c1, RegExpCaseFolding::Mode::kNonUnicode) != + RegExpCaseFolding::EquivalenceKey( + c2, RegExpCaseFolding::Mode::kNonUnicode)) { return 0; } } @@ -96,8 +101,11 @@ int RegExpMacroAssembler::CaseInsensitiveCompareUnicode(Address byte_offset1, U16_NEXT(str2, i2, length, c2); if (i1 != i2) return 0; if (c1 == c2) continue; - if (u_foldCase(c1, U_FOLD_CASE_DEFAULT) != - u_foldCase(c2, U_FOLD_CASE_DEFAULT)) { + if ( + RegExpCaseFolding::EquivalenceKey( + c1, RegExpCaseFolding::Mode::kUnicode) != + RegExpCaseFolding::EquivalenceKey( + c2, RegExpCaseFolding::Mode::kUnicode)) { return 0; } } diff --git a/deps/v8/src/regexp/special-case.h b/deps/v8/src/regexp/special-case.h index 753c9231ede..3d7cf1e162f 100644 --- a/deps/v8/src/regexp/special-case.h +++ b/deps/v8/src/regexp/special-case.h @@ -11,12 +11,11 @@ #include "unicode/uchar.h" #include "unicode/uniset.h" -#include "unicode/unistr.h" namespace v8 { namespace internal { -// Sets of Unicode characters that need special handling under "i" mode +// Case equivalence for ignoreCase matching. // For non-unicode ignoreCase matches (aka "i", not "iu"), ECMA 262 // defines slightly different case-folding rules than Unicode. An @@ -33,81 +32,66 @@ namespace internal { // set of characters that should match a given input character. (See // GetCaseIndependentLetters and CharacterRange::AddCaseEquivalents.) // For almost all characters, this can be efficiently computed using -// UnicodeSet::closeOver(USET_CASE_INSENSITIVE). These sets represent -// the remaining special cases. +// UnicodeSet::closeOver(USET_SIMPLE_CASE_INSENSITIVE). IgnoreSet represents +// the remaining exceptions: characters that must match only themselves. // -// For a character c, the rules are as follows: +// If c is in IgnoreSet, it should match only itself. For example, +// U+00DF LATIN SMALL LETTER SHARP S uppercases to "SS", so it +// canonicalizes to itself and must not match U+1E9E LATIN CAPITAL +// LETTER SHARP S, even though Unicode case closure connects them. // -// 1. If c is in neither IgnoreSet nor SpecialAddSet, then calling -// UnicodeSet::closeOver(USET_CASE_INSENSITIVE) on a UnicodeSet -// containing c will produce the set of characters that should -// match /c/i (or /[c]/i), and only those characters. +// Otherwise, closeOver produces the correct characters after removing +// IgnoreSet. For example, closing over 'k' adds U+212A KELVIN SIGN, +// which is in IgnoreSet and must not match 'k' in non-unicode mode. // -// 2. If c is in IgnoreSet, then the only character it should match is -// itself. However, closeOver will add additional incorrect -// matches. For example, consider SHARP S: 'ß' (U+00DF) and 'ẞ' -// (U+1E9E). Although closeOver('ß') = "ßẞ", uppercase('ß') is -// "SS". Step 3.e therefore requires that 'ß' canonicalizes to -// itself, and should not match 'ẞ'. In these cases, we can skip -// the closeOver entirely, because it will never add an equivalent -// character. -// -// 3. If c is in SpecialAddSet, then it should match at least one -// character other than itself. However, closeOver will add at -// least one additional incorrect match. For example, consider the -// letter 'k'. Closing over 'k' gives "kKK" (lowercase k, uppercase -// K, U+212A KELVIN SIGN). However, because of step 3.g, KELVIN -// SIGN should not match either of the other two characters. As a -// result, "k" and "K" are in SpecialAddSet (and KELVIN SIGN is in -// IgnoreSet). To find the correct matches for characters in -// SpecialAddSet, we closeOver the original character, but filter -// out the results that do not have the same canonical value. -// -// The contents of these sets are calculated at build time by +// The contents of IgnoreSet are calculated at build time by // src/regexp/gen-regexp-special-case.cc, which generates // gen/src/regexp/special-case.cc. This is done by iterating over the // result of closeOver for each BMP character, and finding sets for // which at least one character has a different canonical value than // another character. Characters that match no other characters in -// their equivalence class are added to IgnoreSet. Characters that -// match at least one other character are added to SpecialAddSet. +// their equivalence class are added to IgnoreSet. The generator verifies +// that each Unicode class has at most one non-trivial JS class. -class RegExpCaseFolding final : public AllStatic { +class V8_EXPORT_PRIVATE RegExpCaseFolding final : public AllStatic { public: - static const icu::UnicodeSet& IgnoreSet(); - static const icu::UnicodeSet& SpecialAddSet(); - - // This implements ECMAScript 2020 21.2.2.8.2 (Runtime Semantics: - // Canonicalize) step 3, which is used to determine whether - // characters match when ignoreCase is true and unicode is false. - static UChar32 Canonicalize(UChar32 ch) { - // a. Assert: ch is a UTF-16 code unit. - CHECK_LE(ch, 0xffff); - - // b. Let s be the String value consisting of the single code unit ch. - icu::UnicodeString s(ch); - - // c. Let u be the same result produced as if by performing the algorithm - // for String.prototype.toUpperCase using s as the this value. - // d. Assert: Type(u) is String. - icu::UnicodeString& u = s.toUpper(); + enum class Mode { kNonUnicode, kUnicode }; + + // Equal keys denote matching characters, but can diverge from the + // specification's Canonicalize operation. Non-unicode inputs are UTF-16 code + // units; Unicode inputs are code points. + static UChar32 EquivalenceKey(UChar32 c, Mode mode) { + DCHECK_GE(c, 0); + DCHECK_LE(c, mode == Mode::kNonUnicode ? 0xffff : 0x10ffff); + if (mode == Mode::kNonUnicode && IgnoreSet().contains(c)) return c; + return u_foldCase(c, U_FOLD_CASE_DEFAULT); + } - // e. If u does not consist of a single code unit, return ch. - if (u.length() != 1) { - return ch; + // Close a set of characters under case equivalence, preserving its + // original members. Non-unicode inputs must be UTF-16 code units. + static void CloseOver(icu::UnicodeSet& set, Mode mode) { + if (mode == Mode::kUnicode) { + set.closeOver(USET_SIMPLE_CASE_INSENSITIVE); + return; } - - // f. Let cu be u's single code unit element. - UChar32 cu = u.char32At(0); - - // g. If the value of ch >= 128 and the value of cu < 128, return ch. - if (ch >= 128 && cu < 128) { - return ch; + if (IgnoreSet().containsNone(set)) { + set.closeOver(USET_SIMPLE_CASE_INSENSITIVE); + set.removeAll(IgnoreSet()); + return; } - - // h. Return cu. - return cu; + if (IgnoreSet().containsAll(set)) return; + // Ignored characters neither contribute nor acquire equivalents, but + // must remain in the result if they were explicitly present. + icu::UnicodeSet ignored(set); + ignored.retainAll(IgnoreSet()); + set.removeAll(IgnoreSet()); + set.closeOver(USET_SIMPLE_CASE_INSENSITIVE); + set.removeAll(IgnoreSet()); + set.addAll(ignored); } + + private: + static const icu::UnicodeSet& IgnoreSet(); }; } // namespace internal diff --git a/deps/v8/test/intl/regexp-case-equivalence.js b/deps/v8/test/intl/regexp-case-equivalence.js new file mode 100644 index 00000000000..33da7140c52 --- /dev/null +++ b/deps/v8/test/intl/regexp-case-equivalence.js @@ -0,0 +1,55 @@ +// Copyright 2026 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Exercise literals, ranges, and backreferences with the same case pairs. +const pairs = [ + ['a', 'A', true, true], + ['k', '\u212a', false, true], + ['s', '\u017f', false, true], + ['\u00df', '\u1e9e', false, true], + ['\u00b5', '\u03bc', true, true], + ['i', '\u0130', false, false], + ['I', '\u0131', false, false], + ['\u{10400}', '\u{10428}', false, true], + ['\ud800', '\ud800', true, true], + ['\ud800', '\ud801', false, false], +]; + +for (const [a, b, legacy, unicode] of pairs) { + for (const [c1, c2] of [[a, b], [b, a]]) { + for (const flags of ['i', 'iu', 'iv']) { + const expected = flags === 'i' ? legacy : unicode; + // Force two-byte subjects even when the pair is entirely Latin1. + for (const prefix of ['', '\u2603']) { + const literal = new RegExp('^' + prefix + c1 + '$', flags); + const backref = new RegExp('^' + prefix + '(' + c1 + ')\\1$', flags); + // A legacy character class cannot represent an astral character. + const range = flags !== 'i' || c1.length === 1 + ? new RegExp('^' + prefix + '[' + c1 + '-' + c1 + ']$', flags) + : null; + assertEquals(expected, literal.test(prefix + c2), literal.toString()); + assertEquals(expected, backref.test(prefix + c1 + c2), + backref.toString()); + if (range !== null) { + assertEquals(expected, range.test(prefix + c2), range.toString()); + } + } + } + } +} + +for (const flags of ['i', 'iu', 'iv']) { + const re = new RegExp('^[a-c\u017f\u00df]$', flags); + for (const c of ['a', 'B', 'c', '\u017f', '\u00df']) { + assertTrue(re.test(c)); + } + for (const c of ['s', 'S', '\u1e9e']) { + assertEquals(flags !== 'i', re.test(c)); + } +} + +// Sorting must preserve the preference between equivalent alternatives. +for (const flags of ['i', 'iu', 'iv']) { + assertEquals('is', new RegExp('is|I|ix|z', flags).exec('is')[0]); +} diff --git a/deps/v8/test/intl/regexp-ignore-case-alternatives.js b/deps/v8/test/intl/regexp-ignore-case-alternatives.js new file mode 100644 index 00000000000..aefdbd7f288 --- /dev/null +++ b/deps/v8/test/intl/regexp-ignore-case-alternatives.js @@ -0,0 +1,57 @@ +// Copyright 2026 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Factoring /i alternatives by common prefix must not equate U+017F and 's'. + +assertTrue(/^(?:\u017fa|sb|\u017fc|sd)$/i.test('sb')); +assertFalse(/^(?:\u017fa|sb|\u017fc|sd)$/i.test('\u017fb')); +assertTrue(/^(?:\u212aa|kb|\u212ac|kd)$/i.test('Kb')); +assertFalse(/^(?:\u212aa|kb|\u212ac|kd)$/i.test('\u212ab')); +assertTrue(/^(?:\u017fa|sb|\u017fc|sd)$/iu.test('\u017fb')); + +// A disjunction must match exactly what its alternatives match individually. +function TestAlternatives(c1, c2, flags) { + for (const prefix of ['', 'q']) { + const alternatives = + [c1 + 'a', c2 + 'b', c1 + 'c', c2 + 'd'].map(a => prefix + a); + const re = new RegExp('^(?:' + alternatives.join('|') + ')$', flags); + const singles = alternatives.map(a => new RegExp('^' + a + '$', flags)); + for (const c of [c1, c2]) { + for (const suffix of 'abcd') { + const s = prefix + c + suffix; + assertEquals(singles.some(r => r.test(s)), re.test(s), re + ' ' + s); + } + } + } +} + +// Interesting case-folding equivalence classes, see intl/regress-10248.js. +const equivalence_classes = [ + '\u0041\u0061', // Aa (sanity check) + '\u004b\u006b\u212a', // KkK + '\u0053\u0073\u017f', // Ssſ + '\u00b5\u039c\u03bc', // µΜμ + '\u00c5\u00e5\u212b', // ÅåÅ + '\u00df\u1e9e', // ßẞ + '\u03a9\u03c9\u2126', // ΩωΩ + '\u0390\u1fd3', // ΐΐ + '\u0398\u03b8\u03d1\u03f4', // Θθϑϴ + '\u03b0\u1fe3', // ΰΰ + '\u1f80\u1f88', // ᾀᾈ + '\u1fb3\u1fbc', // ᾳᾼ + '\u1fc3\u1fcc', // ῃῌ + '\u1ff3\u1ffc', // ῳῼ + '\ufb05\ufb06', // ſtst +]; + +for (const eclass of equivalence_classes) { + for (const c1 of eclass) { + for (const c2 of eclass) { + if (c1 === c2) continue; + for (const flags of ['i', 'iu', 'iv']) { + TestAlternatives(c1, c2, flags); + } + } + } +} diff --git a/deps/v8/test/intl/regress-10248.js b/deps/v8/test/intl/regress-10248.js index c1cdc7b42a2..01802afdcd1 100644 --- a/deps/v8/test/intl/regress-10248.js +++ b/deps/v8/test/intl/regress-10248.js @@ -37,7 +37,7 @@ function TestAll() { // Interesting case-folding equivalence classes (as determined by // ICU's UnicodeSet::closeOver). A class is interesting if it contains // more than two characters, or if it contains any characters in -// IgnoreSet or SpecialAddSet as defined in src/regexp/special-case.h. +// IgnoreSet as defined in src/regexp/special-case.h. var equivalence_classes = [ '\u0041\u0061', // Aa (sanity check) '\u004b\u006b\u212a', // KkK diff --git a/deps/v8/test/intl/regress-10573.js b/deps/v8/test/intl/regress-10573.js index 4804df004c7..8cfbf7ab671 100644 --- a/deps/v8/test/intl/regress-10573.js +++ b/deps/v8/test/intl/regress-10573.js @@ -2,8 +2,6 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -function assertEquals(a,b) { if (a !== b) print("BLAH"); } - // See https://tc39.es/ecma262/#sec-runtime-semantics-canonicalize-ch function Canonicalize(ch) { var u = ch.toUpperCase(); @@ -27,8 +25,6 @@ function TestEquivalenceClass(eclass) { assertEquals(backref.test(cc), shouldMatch); - //TODO(v8:10591): Update expectations for ΐΐ, ΰΰ, and ſtst once - //case folding is fixed. assertEquals(backrefUnicode.test(cc), true); } } @@ -43,7 +39,7 @@ function TestAll() { // Interesting case-folding equivalence classes (as determined by // ICU's UnicodeSet::closeOver). A class is interesting if it contains // more than two characters, or if it contains any characters in -// IgnoreSet or SpecialAddSet as defined in src/regexp/special-case.h. +// IgnoreSet as defined in src/regexp/special-case.h. var equivalence_classes = [ '\u0041\u0061', // Aa (sanity check) '\u004b\u006b\u212a', // KkK diff --git a/deps/v8/test/unittests/regexp/regexp-unittest.cc b/deps/v8/test/unittests/regexp/regexp-unittest.cc index af2b2b45e7d..802d860597d 100644 --- a/deps/v8/test/unittests/regexp/regexp-unittest.cc +++ b/deps/v8/test/unittests/regexp/regexp-unittest.cc @@ -6,6 +6,7 @@ #include #include #include +#include #include "include/v8-context.h" #include "include/v8-initialization.h" @@ -34,6 +35,12 @@ #include "test/common/flag-utils.h" #include "test/unittests/test-utils.h" +#ifdef V8_INTL_SUPPORT +#include "src/regexp/special-case.h" +#include "unicode/locid.h" +#include "unicode/unistr.h" +#endif + namespace v8 { namespace internal { @@ -1343,6 +1350,70 @@ TEST_F(RegExpTest, MacroAssembler) { } } +#ifdef V8_INTL_SUPPORT +#ifndef DEBUG +namespace { + +UChar32 CanonicalizeNonUnicodeForTest(UChar32 c) { + icu::UnicodeString upper(c); + upper.toUpper(icu::Locale::getRoot()); + if (upper.length() != 1) return c; + UChar32 result = upper.charAt(0); + return c >= 128 && result < 128 ? c : result; +} + +} // namespace + +TEST_F(RegExpTest, NonUnicodeCaseEquivalence) { + std::vector canonical(0x10000); + std::vector> classes(0x10000); + for (UChar32 c = 0; c <= 0xffff; ++c) { + canonical[c] = CanonicalizeNonUnicodeForTest(c); + classes[canonical[c]].push_back(c); + } + std::vector canonical_to_key(0x10000, -1); + std::vector key_to_canonical(0x10000, -1); + for (UChar32 c = 0; c <= 0xffff; ++c) { + UChar32 key = RegExpCaseFolding::EquivalenceKey( + c, RegExpCaseFolding::Mode::kNonUnicode); + ASSERT_GE(key, 0); + ASSERT_LE(key, 0xffff); + if (canonical_to_key[canonical[c]] == -1) { + canonical_to_key[canonical[c]] = key; + } + if (key_to_canonical[key] == -1) key_to_canonical[key] = canonical[c]; + ASSERT_EQ(canonical_to_key[canonical[c]], key) << c; + ASSERT_EQ(key_to_canonical[key], canonical[c]) << c; + + icu::UnicodeSet expected; + for (UChar32 member : classes[canonical[c]]) expected.add(member); + icu::UnicodeSet actual(c, c); + RegExpCaseFolding::CloseOver(actual, RegExpCaseFolding::Mode::kNonUnicode); + ASSERT_TRUE(expected == actual) << c; + } +} +#endif // !DEBUG + +TEST_F(RegExpTest, CaseClosureMixedSets) { + for (auto mode : {RegExpCaseFolding::Mode::kNonUnicode, + RegExpCaseFolding::Mode::kUnicode}) { + icu::UnicodeSet actual; + actual.add('a', 'c').add('k').add(0x017f).add(0x00df); + icu::UnicodeSet expected(actual); + expected.add('A', 'C').add('K'); + if (mode == RegExpCaseFolding::Mode::kUnicode) { + expected.add('s').add('S').add(0x212a).add(0x1e9e); + actual.add(0x10400); + expected.add(0x10400).add(0x10428); + } + RegExpCaseFolding::CloseOver(actual, mode); + EXPECT_TRUE(expected == actual); + RegExpCaseFolding::CloseOver(actual, mode); + EXPECT_TRUE(expected == actual); + } +} +#endif // V8_INTL_SUPPORT + #ifndef V8_INTL_SUPPORT static base::uc32 canonicalize(base::uc32 c) { unibrow::uchar canon[unibrow::Ecma262Canonicalize::kMaxWidth]; From db1fa03a9831f8d44f53c446e58c69bb8c38be49 Mon Sep 17 00:00:00 2001 From: Jakob Linke Date: Fri, 25 Sep 2026 11:01:32 +0200 Subject: [PATCH 320/331] deps: V8: cherry-pick bb0e798c09e3 Original commit message: [regexp] Make generated IgnoreSet independent of the build locale gen-regexp-special-case implements Canonicalize (ECMA-262 22.2.2.9.3) for non-unicode /i, which is defined in terms of the locale-independent String.prototype.toUpperCase. It called icu::UnicodeString::toUpper() without a locale, which uses the ICU default locale of the build host. Under tr and az, 'i' uppercases to U+0130, so 'i' and 'I' were added to IgnoreSet and /i/i no longer matched "I". Uppercase in the root locale. The generated tables are unchanged for non-tr/az build hosts. Change-Id: I49c62a41e8e47abc2e6c84ac091a4533f917ed97 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8459863 Auto-Submit: Jakob Linke Commit-Queue: Patrick Thier Commit-Queue: Jakob Linke Reviewed-by: Patrick Thier Cr-Commit-Position: refs/heads/main@{#110086} Refs: https://github.com/v8/v8/commit/bb0e798c09e30594496fbca013a7d6ebd5e15e4c PR-URL: https://github.com/nodejs/node/pull/67527 Reviewed-By: Antoine du Hamel --- common.gypi | 2 +- deps/v8/src/regexp/gen-regexp-special-case.cc | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/common.gypi b/common.gypi index 4b41641c1f3..115b53ff658 100644 --- a/common.gypi +++ b/common.gypi @@ -50,7 +50,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.54', + 'v8_embedder_string': '-node.55', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/regexp/gen-regexp-special-case.cc b/deps/v8/src/regexp/gen-regexp-special-case.cc index 53b2c1327fb..92aa1049781 100644 --- a/deps/v8/src/regexp/gen-regexp-special-case.cc +++ b/deps/v8/src/regexp/gen-regexp-special-case.cc @@ -9,6 +9,7 @@ #include "src/base/strings.h" #include "src/regexp/special-case.h" +#include "unicode/locid.h" #include "unicode/unistr.h" namespace v8 { @@ -31,7 +32,7 @@ UChar32 Canonicalize(UChar32 ch) { // c. Let u be the same result produced as if by performing the algorithm // for String.prototype.toUpperCase using s as the this value. // d. Assert: Type(u) is String. - icu::UnicodeString& u = s.toUpper(); + icu::UnicodeString& u = s.toUpper(icu::Locale::getRoot()); // e. If u does not consist of a single code unit, return ch. if (u.length() != 1) { From 008eec6b3d7e26a9f53461a7d7dc6a1ef9d189b0 Mon Sep 17 00:00:00 2001 From: pthier Date: Wed, 7 Oct 2026 11:23:21 +0200 Subject: [PATCH 321/331] deps: V8: backport 35423c16d252 Original commit message: [regexp] Do not combine lone surrogates in TextBuilder In Unicode mode (/u and /v), valid surrogate pairs are already combined into single uc32 code points (> 0xFFFF) by the scanner (ReadNext), escape parser (ParseUnicodeEscape), or ICU string iterator (U16_NEXT) before TextBuilder is called. Remove the obsolete pending_surrogate_ state and AddEscapedUnicodeCharacter workaround from TextBuilder/Builder so that separate lone lead and trail surrogates (such as in \q{} class strings) are never falsely combined into a surrogate pair. Fixed: 569770971 Change-Id: Ic4c45bbd565171dc24c49c60d1c6d25ce6f4c256 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8529770 Reviewed-by: Jakob Linke Commit-Queue: Patrick Thier Cr-Commit-Position: refs/heads/main@{#110442} Refs: https://github.com/v8/v8/commit/35423c16d252663c4b8fad252a6f2aded5d51482 Co-authored-by: Renegade334 PR-URL: https://github.com/nodejs/node/pull/67527 Reviewed-By: Antoine du Hamel --- common.gypi | 2 +- deps/v8/src/regexp/regexp-parser.cc | 111 ++++---------------- deps/v8/test/mjsunit/regexp-unicode-sets.js | 14 +++ 3 files changed, 35 insertions(+), 92 deletions(-) diff --git a/common.gypi b/common.gypi index 115b53ff658..5248535af9d 100644 --- a/common.gypi +++ b/common.gypi @@ -50,7 +50,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.55', + 'v8_embedder_string': '-node.56', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/regexp/regexp-parser.cc b/deps/v8/src/regexp/regexp-parser.cc index 0c9bbad8497..991074cf6c6 100644 --- a/deps/v8/src/regexp/regexp-parser.cc +++ b/deps/v8/src/regexp/regexp-parser.cc @@ -54,20 +54,14 @@ class RegExpTextBuilder { : zone_(zone), flags_(flags), terms_(terms_storage), text_(zone) {} void AddCharacter(base::uc16 character); void AddUnicodeCharacter(base::uc32 character); - void AddEscapedUnicodeCharacter(base::uc32 character); void AddAtom(RegExpTree* atom); void AddTerm(RegExpTree* term); void AddClassRanges(RegExpClassRanges* cc); - void FlushPendingSurrogate(); void FlushText(); RegExpTree* PopLastAtom(); RegExpTree* ToRegExp(); private: - static const base::uc16 kNoPendingSurrogate = 0; - - void AddLeadSurrogate(base::uc16 lead_surrogate); - void AddTrailSurrogate(base::uc16 trail_surrogate); void FlushCharacters(); bool NeedsDesugaringForUnicode(RegExpClassRanges* cc); bool NeedsDesugaringForIgnoreCase(base::uc32 c); @@ -83,53 +77,11 @@ class RegExpTextBuilder { Zone* const zone_; const RegExpFlags flags_; ZoneList* characters_ = nullptr; - base::uc16 pending_surrogate_ = kNoPendingSurrogate; SmallRegExpTreeVector* terms_; SmallRegExpTreeVector text_; }; -void RegExpTextBuilder::AddLeadSurrogate(base::uc16 lead_surrogate) { - DCHECK(unibrow::Utf16::IsLeadSurrogate(lead_surrogate)); - FlushPendingSurrogate(); - // Hold onto the lead surrogate, waiting for a trail surrogate to follow. - pending_surrogate_ = lead_surrogate; -} - -void RegExpTextBuilder::AddTrailSurrogate(base::uc16 trail_surrogate) { - DCHECK(unibrow::Utf16::IsTrailSurrogate(trail_surrogate)); - if (pending_surrogate_ != kNoPendingSurrogate) { - base::uc16 lead_surrogate = pending_surrogate_; - pending_surrogate_ = kNoPendingSurrogate; - DCHECK(unibrow::Utf16::IsLeadSurrogate(lead_surrogate)); - base::uc32 combined = - unibrow::Utf16::CombineSurrogatePair(lead_surrogate, trail_surrogate); - if (NeedsDesugaringForIgnoreCase(combined)) { - AddClassRangesForDesugaring(combined); - } else { - ZoneList surrogate_pair(2, zone()); - surrogate_pair.Add(lead_surrogate, zone()); - surrogate_pair.Add(trail_surrogate, zone()); - RegExpAtom* atom = - zone()->New(surrogate_pair.ToConstVector()); - AddAtom(atom); - } - } else { - pending_surrogate_ = trail_surrogate; - FlushPendingSurrogate(); - } -} - -void RegExpTextBuilder::FlushPendingSurrogate() { - if (pending_surrogate_ != kNoPendingSurrogate) { - DCHECK(IsUnicodeMode()); - base::uc32 c = pending_surrogate_; - pending_surrogate_ = kNoPendingSurrogate; - AddClassRangesForDesugaring(c); - } -} - void RegExpTextBuilder::FlushCharacters() { - FlushPendingSurrogate(); if (characters_ != nullptr) { RegExpTree* atom = zone()->New(characters_->ToConstVector()); characters_ = nullptr; @@ -155,7 +107,6 @@ void RegExpTextBuilder::FlushText() { } void RegExpTextBuilder::AddCharacter(base::uc16 c) { - FlushPendingSurrogate(); if (characters_ == nullptr) { characters_ = zone()->New>(4, zone()); } @@ -165,25 +116,24 @@ void RegExpTextBuilder::AddCharacter(base::uc16 c) { void RegExpTextBuilder::AddUnicodeCharacter(base::uc32 c) { if (c > static_cast(unibrow::Utf16::kMaxNonSurrogateCharCode)) { DCHECK(IsUnicodeMode()); - AddLeadSurrogate(unibrow::Utf16::LeadSurrogate(c)); - AddTrailSurrogate(unibrow::Utf16::TrailSurrogate(c)); - } else if (IsUnicodeMode() && unibrow::Utf16::IsLeadSurrogate(c)) { - AddLeadSurrogate(c); - } else if (IsUnicodeMode() && unibrow::Utf16::IsTrailSurrogate(c)) { - AddTrailSurrogate(c); + if (NeedsDesugaringForIgnoreCase(c)) { + AddClassRangesForDesugaring(c); + } else { + ZoneList surrogate_pair(2, zone()); + surrogate_pair.Add(unibrow::Utf16::LeadSurrogate(c), zone()); + surrogate_pair.Add(unibrow::Utf16::TrailSurrogate(c), zone()); + RegExpAtom* atom = + zone()->template New(surrogate_pair.ToConstVector()); + AddAtom(atom); + } + } else if (IsUnicodeMode() && (unibrow::Utf16::IsLeadSurrogate(c) || + unibrow::Utf16::IsTrailSurrogate(c))) { + AddClassRangesForDesugaring(c); } else { AddCharacter(static_cast(c)); } } -void RegExpTextBuilder::AddEscapedUnicodeCharacter(base::uc32 character) { - // A lead or trail surrogate parsed via escape sequence will not - // pair up with any preceding lead or following trail surrogate. - FlushPendingSurrogate(); - AddUnicodeCharacter(character); - FlushPendingSurrogate(); -} - void RegExpTextBuilder::AddClassRanges(RegExpClassRanges* cr) { if (NeedsDesugaringForUnicode(cr)) { // With /u or /v, character class needs to be desugared, so it @@ -256,7 +206,6 @@ bool RegExpTextBuilder::NeedsDesugaringForIgnoreCase(base::uc32 c) { } RegExpTree* RegExpTextBuilder::PopLastAtom() { - FlushPendingSurrogate(); RegExpTree* atom; if (characters_ != nullptr) { base::Vector char_vector = characters_->ToConstVector(); @@ -298,7 +247,6 @@ class RegExpBuilder { text_builder_(RegExpTextBuilder{zone, &terms_, flags}) {} void AddCharacter(base::uc16 character); void AddUnicodeCharacter(base::uc32 character); - void AddEscapedUnicodeCharacter(base::uc32 character); // "Adds" an empty expression. Does nothing except consume a // following quantifier void AddEmpty(); @@ -510,8 +458,7 @@ class RegExpParserImpl final { base::uc32* character); base::uc32 ParseClassSetCharacter(); // Parses and returns a single escaped character. - base::uc32 ParseCharacterEscape(InClassEscapeState in_class_escape_state, - bool* is_escaped_unicode_character); + base::uc32 ParseCharacterEscape(InClassEscapeState in_class_escape_state); void AddMaybeSimpleCaseFoldedRange(ZoneList* ranges, CharacterRange new_range); @@ -1218,15 +1165,9 @@ RegExpTree* RegExpParserImpl::ParseDisjunction() { // AtomEscape :: // CharacterEscape default: { - bool is_escaped_unicode_character = false; base::uc32 c = ParseCharacterEscape( - InClassEscapeState::kNotInClass, - &is_escaped_unicode_character CHECK_FAILED); - if (is_escaped_unicode_character) { - builder->AddEscapedUnicodeCharacter(c); - } else { - builder->AddCharacter(c); - } + InClassEscapeState::kNotInClass CHECK_FAILED); + builder->AddUnicodeCharacter(c); break; } } @@ -2346,8 +2287,7 @@ bool RegExpParserImpl::ParseUnlimitedLengthHexNumber(int max_value, // https://tc39.es/ecma262/#prod-CharacterEscape template base::uc32 RegExpParserImpl::ParseCharacterEscape( - InClassEscapeState in_class_escape_state, - bool* is_escaped_unicode_character) { + InClassEscapeState in_class_escape_state) { DCHECK_EQ('\\', current()); DCHECK(has_next()); @@ -2451,10 +2391,7 @@ base::uc32 RegExpParserImpl::ParseCharacterEscape( case 'u': { Advance(); base::uc32 value; - if (ParseUnicodeEscape(&value)) { - *is_escaped_unicode_character = true; - return value; - } + if (ParseUnicodeEscape(&value)) return value; if (IsUnicodeMode()) { // With /u or /v, invalid escapes are not treated as identity escapes. ReportError(RegExpError::kInvalidUnicodeEscape); @@ -2596,8 +2533,7 @@ void RegExpParserImpl::ParseClassEscape( add_unicode_case_equivalents); if (*is_class_escape) return; - bool dummy = false; // Unused. - *char_out = ParseCharacterEscape(kInClassEscape, &dummy); + *char_out = ParseCharacterEscape(kInClassEscape); } // https://tc39.es/ecma262/#prod-CharacterClassEscape @@ -2807,8 +2743,7 @@ base::uc32 RegExpParserImpl::ParseClassSetCharacter() { static constexpr InClassEscapeState kInClassEscape = InClassEscapeState::kInClass; - bool dummy = false; // Unused. - return ParseCharacterEscape(kInClassEscape, &dummy); + return ParseCharacterEscape(kInClassEscape); } if (IsClassSetSyntaxCharacter(c)) { ReportError(RegExpError::kInvalidCharacterInClass); @@ -3176,13 +3111,7 @@ void RegExpBuilder::AddUnicodeCharacter(base::uc32 c) { text_builder().AddUnicodeCharacter(c); } -void RegExpBuilder::AddEscapedUnicodeCharacter(base::uc32 character) { - pending_empty_ = false; - text_builder().AddEscapedUnicodeCharacter(character); -} - void RegExpBuilder::AddEmpty() { - text_builder().FlushPendingSurrogate(); pending_empty_ = true; } diff --git a/deps/v8/test/mjsunit/regexp-unicode-sets.js b/deps/v8/test/mjsunit/regexp-unicode-sets.js index ac66355f588..fe166d4f80a 100644 --- a/deps/v8/test/mjsunit/regexp-unicode-sets.js +++ b/deps/v8/test/mjsunit/regexp-unicode-sets.js @@ -231,6 +231,20 @@ assertEquals(['xyz'], /[\q{W|xyz|xy}a-c]/v.exec('xyzabc')); // Empty string is last. assertEquals(['a'], /[\q{W|}a-c]/v.exec('abc')); +// Lone lead and trail surrogates in \q{} should not combine into a surrogate +// pair unless written as a literal surrogate pair or \uXXXX\uYYYY. +assertFalse(/^[\q{\uD83D\u{DE00}}]$/v.test('\u{1F600}')); +assertFalse(/^[\q{\u{D83D}\u{DE00}}]$/v.test('\u{1F600}')); +assertFalse(/^[\q{\u{D83D}\uDE00}]$/v.test('\u{1F600}')); +assertFalse(/^[\q{\uD83D\u{DE00}x}]$/v.test('\u{1F600}x')); +assertFalse(/^[\q{\uD83D\u{DE00}}]$/iv.test('\u{1F600}')); +assertFalse(new RegExp('^[\\q{\uD83D\\uDE00}]$', 'v').test('\u{1F600}')); +assertFalse(new RegExp('^[\\q{\\uD83D\uDE00}]$', 'v').test('\u{1F600}')); +assertTrue(/^[\q{\uD83D\uDE00}]$/v.test('\u{1F600}')); +assertTrue(/^[\q{😀}]$/v.test('\u{1F600}')); +assertTrue(/^[\q{\u{1F600}}]$/v.test('\u{1F600}')); +assertTrue(new RegExp('^[\\q{\uD83D\uDE00}]$', 'v').test('\u{1F600}')); + // Some more sophisticated tests taken from // https://v8.dev/features/regexp-v-flag assertTrue(/^\p{RGI_Emoji}$/v.test('⚽')); From 3a9819f3e3f7b3b7d2542da44038d2af4f9ff3d1 Mon Sep 17 00:00:00 2001 From: Jakob Linke Date: Fri, 9 Oct 2026 12:41:30 +0200 Subject: [PATCH 322/331] deps: V8: backport f607706154ea Original commit message: [regexp] Handle supplementary case equivalents of BMP characters Unicode 18 adds U+1DF95, which simple-folds to U+00DF. This creates the first case-equivalence class spanning BMP and supplementary characters: {U+00DF, U+1E9E, U+1DF95}. Discard supplementary characters from the generator's non-unicode closures before calling Canonicalize, which requires UTF-16 code units and otherwise CHECK-fails with ICU 79. Apply the same filtering in runtime non-unicode closure. Generate SupplementaryEquivalentsSet and desugar its BMP characters into character classes under /iu and /iv, allowing literals to match surrogate pairs. Backreferences with differing UTF-16 character widths remain unsupported and are tracked in crbug.com/571793821. IgnoreSet is unchanged with ICU 78 and with ICU 78.2 patched to upstream Unicode 18 case data. With the patched data, the generator succeeds, SupplementaryEquivalentsSet is {U+00DF, U+1E9E}, and regexp tests pass in release and debug. Bug: 571232615, 571668686 Change-Id: I9eacb273a74c66e17f0cfb1b256e863f2718c130 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8548134 Reviewed-by: Patrick Thier Commit-Queue: Jakob Linke Cr-Commit-Position: refs/heads/main@{#110522} Refs: https://github.com/v8/v8/commit/f607706154eabc4a949628a88b38dbe95cd2274c Co-authored-by: Renegade334 PR-URL: https://github.com/nodejs/node/pull/67527 Reviewed-By: Antoine du Hamel --- common.gypi | 2 +- deps/v8/src/regexp/gen-regexp-special-case.cc | 18 ++++++ deps/v8/src/regexp/regexp-parser.cc | 18 ++++-- deps/v8/src/regexp/special-case.h | 28 +++++++-- deps/v8/test/intl/regexp-case-equivalence.js | 63 ++++++++++++++++++- .../test/unittests/regexp/regexp-unittest.cc | 29 +++++++++ 6 files changed, 144 insertions(+), 14 deletions(-) diff --git a/common.gypi b/common.gypi index 5248535af9d..b92d7fd19a2 100644 --- a/common.gypi +++ b/common.gypi @@ -50,7 +50,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.56', + 'v8_embedder_string': '-node.57', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/regexp/gen-regexp-special-case.cc b/deps/v8/src/regexp/gen-regexp-special-case.cc index 92aa1049781..8205cdf6fda 100644 --- a/deps/v8/src/regexp/gen-regexp-special-case.cc +++ b/deps/v8/src/regexp/gen-regexp-special-case.cc @@ -10,6 +10,7 @@ #include "src/base/strings.h" #include "src/regexp/special-case.h" #include "unicode/locid.h" +#include "unicode/uchar.h" #include "unicode/unistr.h" namespace v8 { @@ -51,6 +52,19 @@ UChar32 Canonicalize(UChar32 ch) { return cu; } +// Removes supplementary code points from |set| and returns whether any were +// present. Since Unicode 18, the case closure of a BMP character can contain +// supplementary code points (U+1DF95 LATIN SMALL LIGATURE LONG S WITH +// DESCENDER S case-folds to U+00DF LATIN SMALL LETTER SHARP S). Non-unicode +// ignoreCase matching compares UTF-16 code units, so a supplementary code +// point never matches a BMP character and does not take part in Canonicalize. +bool RemoveSupplementary(icu::UnicodeSet& set) { + constexpr UChar32 kFirstSupplementary = static_cast(kNonBmpStart); + if (!set.containsSome(kFirstSupplementary, UCHAR_MAX_VALUE)) return false; + set.remove(kFirstSupplementary, UCHAR_MAX_VALUE); + return true; +} + // The following code generates "src/regexp/special-case.cc". void PrintSet(std::ofstream& out, const char* name, const icu::UnicodeSet& set) { @@ -85,6 +99,7 @@ void PrintSpecial(std::ofstream& out) { icu::UnicodeSet current; icu::UnicodeSet special_add; icu::UnicodeSet ignore; + icu::UnicodeSet supplementary_equivalents; UErrorCode status = U_ZERO_ERROR; icu::UnicodeSet upper("[\\p{Lu}]", status); CHECK(U_SUCCESS(status)); @@ -97,6 +112,7 @@ void PrintSpecial(std::ofstream& out) { } current.set(i, i); current.closeOver(USET_SIMPLE_CASE_INSENSITIVE); + if (RemoveSupplementary(current)) supplementary_equivalents.add(i); // Check to see if all characters in the case-folding equivalence // class as defined by UnicodeSet::closeOver all map to the same @@ -146,6 +162,7 @@ void PrintSpecial(std::ofstream& out) { UChar32 canonical = Canonicalize(c); current.set(c, c); current.closeOver(USET_SIMPLE_CASE_INSENSITIVE); + RemoveSupplementary(current); current.removeAll(ignore); for (int32_t j = 0; j < current.getRangeCount(); j++) { for (UChar32 c2 = current.getRangeStart(j); @@ -157,6 +174,7 @@ void PrintSpecial(std::ofstream& out) { } PrintSet(out, "IgnoreSet", ignore); + PrintSet(out, "SupplementaryEquivalentsSet", supplementary_equivalents); } void WriteHeader(const char* header_filename) { diff --git a/deps/v8/src/regexp/regexp-parser.cc b/deps/v8/src/regexp/regexp-parser.cc index 991074cf6c6..d62191cab2b 100644 --- a/deps/v8/src/regexp/regexp-parser.cc +++ b/deps/v8/src/regexp/regexp-parser.cc @@ -10,6 +10,7 @@ #include "src/regexp/regexp-ast.h" #include "src/regexp/regexp-macro-assembler.h" #include "src/regexp/regexp.h" +#include "src/regexp/special-case.h" #include "src/strings/char-predicates-inl.h" #include "src/utils/ostreams.h" #include "src/utils/utils.h" @@ -107,6 +108,10 @@ void RegExpTextBuilder::FlushText() { } void RegExpTextBuilder::AddCharacter(base::uc16 c) { + if (NeedsDesugaringForIgnoreCase(c)) { + AddClassRangesForDesugaring(c); + return; + } if (characters_ == nullptr) { characters_ = zone()->New>(4, zone()); } @@ -188,15 +193,18 @@ bool RegExpTextBuilder::NeedsDesugaringForUnicode(RegExpClassRanges* cc) { return false; } -// We only use this for characters made of surrogate pairs. All other -// characters outside of character classes are made case independent in the -// code generation. +// Desugar supplementary characters with case equivalents and BMP characters +// with supplementary equivalents. Other atoms are folded during code +// generation. bool RegExpTextBuilder::NeedsDesugaringForIgnoreCase(base::uc32 c) { #ifdef V8_INTL_SUPPORT if (IsUnicodeMode() && ignore_case()) { + if (c <= unibrow::Utf16::kMaxNonSurrogateCharCode) { + return RegExpCaseFolding::HasSupplementaryEquivalents( + static_cast(c)); + } icu::UnicodeSet set(c, c); - set.closeOver(USET_CASE_INSENSITIVE); - set.removeAllStrings(); + RegExpCaseFolding::CloseOver(set, RegExpCaseFolding::Mode::kUnicode); return set.size() > 1; } // In the case where ICU is not included, we act as if the unicode flag is diff --git a/deps/v8/src/regexp/special-case.h b/deps/v8/src/regexp/special-case.h index 3d7cf1e162f..e646fd489b1 100644 --- a/deps/v8/src/regexp/special-case.h +++ b/deps/v8/src/regexp/special-case.h @@ -7,8 +7,8 @@ #ifdef V8_INTL_SUPPORT #include "src/base/logging.h" +#include "src/base/strings.h" #include "src/common/globals.h" - #include "unicode/uchar.h" #include "unicode/uniset.h" @@ -52,6 +52,12 @@ namespace internal { // another character. Characters that match no other characters in // their equivalence class are added to IgnoreSet. The generator verifies // that each Unicode class has at most one non-trivial JS class. +// Supplementary code points are ignored throughout: non-unicode matching +// compares UTF-16 code units, so they can never match a BMP character. +// +// The generator additionally emits SupplementaryEquivalentsSet, the BMP +// characters whose Unicode case closure contains supplementary code points. +// This set is used for unicode-mode matching, see HasSupplementaryEquivalents. class V8_EXPORT_PRIVATE RegExpCaseFolding final : public AllStatic { public: @@ -74,9 +80,9 @@ class V8_EXPORT_PRIVATE RegExpCaseFolding final : public AllStatic { set.closeOver(USET_SIMPLE_CASE_INSENSITIVE); return; } + DCHECK(!set.containsSome(0x10000, 0x10ffff)); if (IgnoreSet().containsNone(set)) { - set.closeOver(USET_SIMPLE_CASE_INSENSITIVE); - set.removeAll(IgnoreSet()); + CloseOverNonUnicode(set); return; } if (IgnoreSet().containsAll(set)) return; @@ -85,13 +91,25 @@ class V8_EXPORT_PRIVATE RegExpCaseFolding final : public AllStatic { icu::UnicodeSet ignored(set); ignored.retainAll(IgnoreSet()); set.removeAll(IgnoreSet()); - set.closeOver(USET_SIMPLE_CASE_INSENSITIVE); - set.removeAll(IgnoreSet()); + CloseOverNonUnicode(set); set.addAll(ignored); } + // Whether c has supplementary Unicode case equivalents. + static bool HasSupplementaryEquivalents(base::uc16 c) { + return SupplementaryEquivalentsSet().contains(c); + } + private: static const icu::UnicodeSet& IgnoreSet(); + static const icu::UnicodeSet& SupplementaryEquivalentsSet(); + + // Requires a set containing no IgnoreSet characters. + static void CloseOverNonUnicode(icu::UnicodeSet& set) { + set.closeOver(USET_SIMPLE_CASE_INSENSITIVE); + set.removeAll(IgnoreSet()); + set.remove(0x10000, 0x10ffff); + } }; } // namespace internal diff --git a/deps/v8/test/intl/regexp-case-equivalence.js b/deps/v8/test/intl/regexp-case-equivalence.js index 33da7140c52..b21926d2752 100644 --- a/deps/v8/test/intl/regexp-case-equivalence.js +++ b/deps/v8/test/intl/regexp-case-equivalence.js @@ -2,7 +2,14 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Exercise literals, ranges, and backreferences with the same case pairs. +// Unicode 18 assigns U+1DF95 LATIN SMALL LIGATURE LONG S WITH DESCENDER S, +// the first supplementary character that case-folds to a BMP character +// (U+00DF). It is thus case-equivalent to U+00DF and U+1E9E under /iu and +// /iv, but never under /i, which compares UTF-16 code units. +const hasUnicode18 = '\u{1DF95}'.toUpperCase() === 'SS'; + +// Exercise literals, ranges, backreferences, lookbehinds, and class strings +// with the same case pairs. const pairs = [ ['a', 'A', true, true], ['k', '\u212a', false, true], @@ -12,6 +19,8 @@ const pairs = [ ['i', '\u0130', false, false], ['I', '\u0131', false, false], ['\u{10400}', '\u{10428}', false, true], + ['\u00df', '\u{1DF95}', false, hasUnicode18], + ['\u1e9e', '\u{1DF95}', false, hasUnicode18], ['\ud800', '\ud800', true, true], ['\ud800', '\ud801', false, false], ]; @@ -29,16 +38,64 @@ for (const [a, b, legacy, unicode] of pairs) { ? new RegExp('^' + prefix + '[' + c1 + '-' + c1 + ']$', flags) : null; assertEquals(expected, literal.test(prefix + c2), literal.toString()); - assertEquals(expected, backref.test(prefix + c1 + c2), - backref.toString()); + // TODO(crbug.com/571793821): Case-insensitive backreferences do not + // yet match captures of a different UTF-16 length (U+00DF vs U+1DF95). + if (c1.length === c2.length) { + assertEquals(expected, backref.test(prefix + c1 + c2), + backref.toString()); + } if (range !== null) { assertEquals(expected, range.test(prefix + c2), range.toString()); } + const lookbehind = new RegExp('(?<=^' + prefix + c1 + ')x$', flags); + assertEquals(expected, lookbehind.test(prefix + c2 + 'x'), + lookbehind.toString()); + if (flags === 'iv') { + const classString = new RegExp( + '^' + prefix + '[\\q{' + c1 + 'x}]$', flags); + assertEquals(expected, classString.test(prefix + c2 + 'x'), + classString.toString()); + } } } } } +// Supplementary case equivalents of BMP characters must be matched in +// unicode mode both as plain pattern characters and inside character +// classes, but never in legacy mode. +if (hasUnicode18) { + const S = '\u{1DF95}'; + const cases = [ + // [pattern, subject, expected] + ['^\u00df$', S, true], + ['^\u1e9e$', S, true], + ['^' + S + '$', '\u00df', true], + ['^' + S + '$', '\u1e9e', true], + ['^\\u00df$', S, true], + ['^\\u{df}$', S, true], + ['^a\u00dfb$', 'A' + S + 'B', true], + ['^(?:\u00df)+$', S + '\u00df\u1e9e' + S, true], + ['^\u00df{2}$', S + '\u1e9e', true], + ['^\u00df{2}$', S, false], + ['^(?:x|\u00df)$', S, true], + ['^[\u00df]$', S, true], + ['^[^\u00df]$', S, false], + ['^(\u00df)$', S, true], + ]; + for (const [pattern, subject, expected] of cases) { + for (const flags of ['iu', 'iv']) { + const re = new RegExp(pattern, flags); + assertEquals(expected, re.test(subject), re.toString() + ' ' + subject); + } + // In legacy mode, the astral character consists of two code units, + // neither of which has case equivalents. + const re = new RegExp(pattern, 'i'); + assertFalse(re.test(subject), re.toString() + ' ' + subject); + } + assertEquals([S, S], /(\u00df)/iu.exec(S)); +} + for (const flags of ['i', 'iu', 'iv']) { const re = new RegExp('^[a-c\u017f\u00df]$', flags); for (const c of ['a', 'B', 'c', '\u017f', '\u00df']) { diff --git a/deps/v8/test/unittests/regexp/regexp-unittest.cc b/deps/v8/test/unittests/regexp/regexp-unittest.cc index 802d860597d..a8fbf8d265a 100644 --- a/deps/v8/test/unittests/regexp/regexp-unittest.cc +++ b/deps/v8/test/unittests/regexp/regexp-unittest.cc @@ -1392,6 +1392,31 @@ TEST_F(RegExpTest, NonUnicodeCaseEquivalence) { ASSERT_TRUE(expected == actual) << c; } } + +TEST_F(RegExpTest, SupplementaryCaseEquivalents) { + icu::UnicodeSet expected; + for (UChar32 c = 0; c <= 0xffff; ++c) { + icu::UnicodeSet closure(c, c); + closure.closeOver(USET_SIMPLE_CASE_INSENSITIVE); + const bool has_supplementary = closure.containsSome(0x10000, 0x10ffff); + if (has_supplementary) expected.add(c); + const bool actual = RegExpCaseFolding::HasSupplementaryEquivalents( + static_cast(c)); + ASSERT_EQ(has_supplementary, actual) << c; + + // Non-unicode closure must never yield supplementary code points. + icu::UnicodeSet non_unicode(c, c); + RegExpCaseFolding::CloseOver(non_unicode, + RegExpCaseFolding::Mode::kNonUnicode); + ASSERT_FALSE(non_unicode.containsSome(0x10000, 0x10ffff)) << c; + } + // U+1DF95 LATIN SMALL LIGATURE LONG S WITH DESCENDER S (Unicode 18) + // case-folds to U+00DF LATIN SMALL LETTER SHARP S. + if (u_foldCase(0x1df95, U_FOLD_CASE_DEFAULT) == 0xdf) { + EXPECT_TRUE(expected.contains(0xdf)); + EXPECT_TRUE(expected.contains(0x1e9e)); + } +} #endif // !DEBUG TEST_F(RegExpTest, CaseClosureMixedSets) { @@ -1403,6 +1428,10 @@ TEST_F(RegExpTest, CaseClosureMixedSets) { expected.add('A', 'C').add('K'); if (mode == RegExpCaseFolding::Mode::kUnicode) { expected.add('s').add('S').add(0x212a).add(0x1e9e); + // Since Unicode 18, U+1DF95 case-folds to U+00DF. + if (u_foldCase(0x1df95, U_FOLD_CASE_DEFAULT) == 0xdf) { + expected.add(0x1df95); + } actual.add(0x10400); expected.add(0x10400).add(0x10428); } From c88471d0ed3fd096d9ab59438be64747cb218059 Mon Sep 17 00:00:00 2001 From: Igor Sheludko Date: Wed, 11 Mar 2026 14:36:45 +0100 Subject: [PATCH 323/331] deps: V8: cherry-pick be84cdeee94e Original commit message: [d8] Handle termination exception in async modules ... instead of failing a CHECK. Fixed: 488754141 Change-Id: If97aea17887b731434a776bbac3ffba47b422417 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/7653802 Reviewed-by: Patrick Thier Auto-Submit: Igor Sheludko Commit-Queue: Igor Sheludko Commit-Queue: Patrick Thier Cr-Commit-Position: refs/heads/main@{#105734} Refs: https://github.com/v8/v8/commit/be84cdeee94ee2574352cd6527d9a2f0bc0bea54 PR-URL: https://github.com/nodejs/node/pull/67570 Reviewed-By: Robert Nagy Reviewed-By: James M Snell --- common.gypi | 2 +- deps/v8/src/objects/source-text-module.cc | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/common.gypi b/common.gypi index b92d7fd19a2..71840b13acd 100644 --- a/common.gypi +++ b/common.gypi @@ -50,7 +50,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.57', + 'v8_embedder_string': '-node.58', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/src/objects/source-text-module.cc b/deps/v8/src/objects/source-text-module.cc index 101373b83c6..127892250ae 100644 --- a/deps/v8/src/objects/source-text-module.cc +++ b/deps/v8/src/objects/source-text-module.cc @@ -1021,6 +1021,9 @@ Maybe SourceTextModule::AsyncModuleExecutionFulfilled( MaybeDirectHandle exception; // ii. If result is an abrupt completion, then if (!ExecuteModule(isolate, m, &exception).ToHandle(&unused_result)) { + DCHECK_IMPLIES(exception.IsEmpty(), + isolate->is_execution_terminating()); + if (isolate->is_execution_terminating()) return {}; // 1. Perform AsyncModuleExecutionRejected(m, result.[[Value]]). AsyncModuleExecutionRejected(isolate, m, exception.ToHandleChecked()); } else { // iii. Else, From aafda1a7e30640b715f6e078c5b7c2b3382fd061 Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Wed, 18 Nov 2026 08:11:29 +0000 Subject: [PATCH 324/331] test: add regression test for worker terminate during TLA parent evaluation Terminating a worker while it evaluates the parent module of a top-level-await module used to abort the whole process with a V8 CHECK failure (Check failed: !is_null()). Add a regression test that reproduces the scenario from https://github.com/nodejs/node/issues/67550. Refs: https://github.com/nodejs/node/issues/67550 PR-URL: https://github.com/nodejs/node/pull/67570 Refs: https://github.com/v8/v8/commit/be84cdeee94ee2574352cd6527d9a2f0bc0bea54 Reviewed-By: Robert Nagy Reviewed-By: James M Snell --- .../es-modules/tla/terminate-worker-tla.mjs | 1 + .../es-modules/tla/terminate-worker.mjs | 6 +++++ test/parallel/test-worker-terminate-tla.mjs | 25 +++++++++++++++++++ 3 files changed, 32 insertions(+) create mode 100644 test/fixtures/es-modules/tla/terminate-worker-tla.mjs create mode 100644 test/fixtures/es-modules/tla/terminate-worker.mjs create mode 100644 test/parallel/test-worker-terminate-tla.mjs diff --git a/test/fixtures/es-modules/tla/terminate-worker-tla.mjs b/test/fixtures/es-modules/tla/terminate-worker-tla.mjs new file mode 100644 index 00000000000..0a5e432fc91 --- /dev/null +++ b/test/fixtures/es-modules/tla/terminate-worker-tla.mjs @@ -0,0 +1 @@ +await 0; diff --git a/test/fixtures/es-modules/tla/terminate-worker.mjs b/test/fixtures/es-modules/tla/terminate-worker.mjs new file mode 100644 index 00000000000..183207f227a --- /dev/null +++ b/test/fixtures/es-modules/tla/terminate-worker.mjs @@ -0,0 +1,6 @@ +import { parentPort } from 'node:worker_threads'; +import './terminate-worker-tla.mjs'; + +parentPort.postMessage('running'); +const end = Date.now() + 5000; +while (Date.now() < end); diff --git a/test/parallel/test-worker-terminate-tla.mjs b/test/parallel/test-worker-terminate-tla.mjs new file mode 100644 index 00000000000..a676039b4c9 --- /dev/null +++ b/test/parallel/test-worker-terminate-tla.mjs @@ -0,0 +1,25 @@ +// Test: terminating a worker thread while it evaluates the parent module of a +// top-level-await module. +// +// worker.terminate() used to abort the whole process with a V8 CHECK failure +// (`Check failed: !is_null().`). See https://github.com/nodejs/node/issues/67550 +// and the V8 cherry-pick be84cdeee94e. + +import { mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import { Worker } from 'node:worker_threads'; + +const worker = new Worker( + new URL('../fixtures/es-modules/tla/terminate-worker.mjs', import.meta.url), +); + +worker.on('error', (err) => assert.fail(err)); + +// The worker posts 'running' at the top of the parent module body and then +// busy-waits. Terminating at that point used to abort the entire process via a +// V8 CHECK failure in `AsyncModuleExecutionFulfilled`; after the fix it +// terminates cleanly with exit code 1. +worker.on('message', mustCall(async (message) => { + assert.strictEqual(message, 'running'); + assert.strictEqual(await worker.terminate(), 1); +})); From cd03433eadf2e17501fcaaef04633c5ad87b39a7 Mon Sep 17 00:00:00 2001 From: Yuya Inoue <65857152+inoway46@users.noreply.github.com> Date: Fri, 20 Nov 2026 17:42:31 +0900 Subject: [PATCH 325/331] build: enable V8 undefined double support V8 14.6 enables v8_enable_undefined_double by default in its GN build, but the GYP configuration never set V8_ENABLE_UNDEFINED_DOUBLE, so the default build ran V8 in a non-default configuration. Enabling it eliminates the repeated wrong-map deoptimizations in big.js reported in #66717. Align the GYP configuration with V8's default, matching the change made on main in 8394db37d800. Refs: https://github.com/nodejs/node/commit/8394db37d8004219fa30985675d5e6a4cac63556 Fixes: https://github.com/nodejs/node/issues/66717 Signed-off-by: inoway46 Assisted-by: Codex Assisted-by: Claude Code PR-URL: https://github.com/nodejs/node/pull/66733 Reviewed-By: Chengzhong Wu --- tools/v8_gypfiles/features.gypi | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tools/v8_gypfiles/features.gypi b/tools/v8_gypfiles/features.gypi index 550709b5635..cc8a5f49a33 100644 --- a/tools/v8_gypfiles/features.gypi +++ b/tools/v8_gypfiles/features.gypi @@ -294,6 +294,9 @@ # ReadOnlySpace. 'v8_enable_extensible_ro_snapshot%': 1, + # Use the encoding of undefined in double values. + 'v8_enable_undefined_double%': 1, + # Variables from v8.gni # Enable ECMAScript Internationalization API. Enabling this feature will @@ -524,6 +527,9 @@ ['v8_enable_extensible_ro_snapshot==1', { 'defines': ['V8_ENABLE_EXTENSIBLE_RO_SNAPSHOT',], }], + ['v8_enable_undefined_double==1', { + 'defines': ['V8_ENABLE_UNDEFINED_DOUBLE',], + }], ['v8_enable_leaptiering==1', { 'defines': ['V8_ENABLE_LEAPTIERING',], }], From 3fac84c03420035ef03f2c06c40af6da6d07777e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fatih=20G=C3=BCzel?= Date: Fri, 20 Nov 2026 12:48:42 +0300 Subject: [PATCH 326/331] =?UTF-8?q?meta:=20add=20Fatih=20G=C3=BCzel=20to?= =?UTF-8?q?=20.mailmap?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Fatih Güzel PR-URL: https://github.com/nodejs/node/pull/67622 Reviewed-By: René Reviewed-By: Yagiz Nizipli Reviewed-By: Luigi Pinca Reviewed-By: Christian Aurich Zanettini Martins --- .mailmap | 1 + 1 file changed, 1 insertion(+) diff --git a/.mailmap b/.mailmap index 73c585d1a6e..53be22e27b0 100644 --- a/.mailmap +++ b/.mailmap @@ -180,6 +180,7 @@ FangDun Cai Fangshi He Farid Neshat Fatah N +Fatih Güzel Fedor Indutny Felix Böhm Felix Geisendörfer From a8ad67e8fdb2ae92684051c2e7d4c70704b455e6 Mon Sep 17 00:00:00 2001 From: npm CLI robot Date: Thu, 19 Nov 2026 22:12:53 +0000 Subject: [PATCH 327/331] deps: upgrade npm to 11.21.3 PR-URL: https://github.com/nodejs/node/pull/67628 Reviewed-By: Antoine du Hamel --- deps/npm/docs/content/commands/npm-ci.md | 5 + deps/npm/docs/content/commands/npm-exec.md | 5 + .../content/commands/npm-install-ci-test.md | 5 + .../content/commands/npm-install-scripts.md | 6 + .../docs/content/commands/npm-install-test.md | 5 + deps/npm/docs/content/commands/npm-install.md | 5 + deps/npm/docs/content/commands/npm-ls.md | 2 +- deps/npm/docs/content/commands/npm-rebuild.md | 5 + deps/npm/docs/content/commands/npm-update.md | 5 + deps/npm/docs/content/commands/npm.md | 2 +- deps/npm/docs/content/using-npm/config.md | 5 + deps/npm/docs/output/commands/npm-access.html | 4 +- .../npm/docs/output/commands/npm-adduser.html | 4 +- .../output/commands/npm-approve-scripts.html | 4 +- deps/npm/docs/output/commands/npm-audit.html | 4 +- deps/npm/docs/output/commands/npm-bugs.html | 4 +- deps/npm/docs/output/commands/npm-cache.html | 4 +- deps/npm/docs/output/commands/npm-ci.html | 8 +- .../docs/output/commands/npm-completion.html | 4 +- deps/npm/docs/output/commands/npm-config.html | 4 +- deps/npm/docs/output/commands/npm-dedupe.html | 4 +- .../output/commands/npm-deny-scripts.html | 4 +- .../docs/output/commands/npm-deprecate.html | 4 +- deps/npm/docs/output/commands/npm-diff.html | 4 +- .../docs/output/commands/npm-dist-tag.html | 4 +- deps/npm/docs/output/commands/npm-docs.html | 4 +- deps/npm/docs/output/commands/npm-doctor.html | 4 +- deps/npm/docs/output/commands/npm-edit.html | 4 +- deps/npm/docs/output/commands/npm-exec.html | 8 +- .../npm/docs/output/commands/npm-explain.html | 4 +- .../npm/docs/output/commands/npm-explore.html | 4 +- .../docs/output/commands/npm-find-dupes.html | 4 +- deps/npm/docs/output/commands/npm-fund.html | 4 +- deps/npm/docs/output/commands/npm-get.html | 4 +- .../docs/output/commands/npm-help-search.html | 4 +- deps/npm/docs/output/commands/npm-help.html | 4 +- deps/npm/docs/output/commands/npm-init.html | 4 +- .../output/commands/npm-install-ci-test.html | 8 +- .../output/commands/npm-install-scripts.html | 14 +- .../output/commands/npm-install-test.html | 8 +- .../npm/docs/output/commands/npm-install.html | 8 +- deps/npm/docs/output/commands/npm-link.html | 4 +- deps/npm/docs/output/commands/npm-ll.html | 4 +- deps/npm/docs/output/commands/npm-login.html | 4 +- deps/npm/docs/output/commands/npm-logout.html | 4 +- deps/npm/docs/output/commands/npm-ls.html | 6 +- deps/npm/docs/output/commands/npm-org.html | 4 +- .../docs/output/commands/npm-outdated.html | 4 +- deps/npm/docs/output/commands/npm-owner.html | 4 +- deps/npm/docs/output/commands/npm-pack.html | 4 +- deps/npm/docs/output/commands/npm-ping.html | 4 +- deps/npm/docs/output/commands/npm-pkg.html | 4 +- deps/npm/docs/output/commands/npm-prefix.html | 4 +- .../npm/docs/output/commands/npm-profile.html | 4 +- deps/npm/docs/output/commands/npm-prune.html | 4 +- .../npm/docs/output/commands/npm-publish.html | 4 +- deps/npm/docs/output/commands/npm-query.html | 4 +- .../npm/docs/output/commands/npm-rebuild.html | 8 +- deps/npm/docs/output/commands/npm-repo.html | 4 +- .../npm/docs/output/commands/npm-restart.html | 4 +- deps/npm/docs/output/commands/npm-root.html | 4 +- deps/npm/docs/output/commands/npm-run.html | 4 +- deps/npm/docs/output/commands/npm-sbom.html | 4 +- deps/npm/docs/output/commands/npm-search.html | 4 +- deps/npm/docs/output/commands/npm-set.html | 4 +- .../docs/output/commands/npm-shrinkwrap.html | 4 +- deps/npm/docs/output/commands/npm-stage.html | 4 +- deps/npm/docs/output/commands/npm-star.html | 4 +- deps/npm/docs/output/commands/npm-stars.html | 4 +- deps/npm/docs/output/commands/npm-start.html | 4 +- deps/npm/docs/output/commands/npm-stop.html | 4 +- deps/npm/docs/output/commands/npm-team.html | 4 +- deps/npm/docs/output/commands/npm-test.html | 4 +- deps/npm/docs/output/commands/npm-token.html | 4 +- deps/npm/docs/output/commands/npm-trust.html | 4 +- .../docs/output/commands/npm-undeprecate.html | 4 +- .../docs/output/commands/npm-uninstall.html | 4 +- .../docs/output/commands/npm-unpublish.html | 4 +- deps/npm/docs/output/commands/npm-unstar.html | 4 +- deps/npm/docs/output/commands/npm-update.html | 8 +- .../npm/docs/output/commands/npm-version.html | 4 +- deps/npm/docs/output/commands/npm-view.html | 4 +- deps/npm/docs/output/commands/npm-whoami.html | 4 +- deps/npm/docs/output/commands/npm.html | 6 +- deps/npm/docs/output/commands/npx.html | 4 +- .../docs/output/configuring-npm/folders.html | 4 +- .../docs/output/configuring-npm/install.html | 4 +- .../output/configuring-npm/npm-global.html | 4 +- .../docs/output/configuring-npm/npm-json.html | 4 +- .../configuring-npm/npm-shrinkwrap-json.html | 4 +- .../docs/output/configuring-npm/npmrc.html | 4 +- .../output/configuring-npm/package-json.html | 4 +- .../configuring-npm/package-lock-json.html | 4 +- deps/npm/docs/output/using-npm/config.html | 8 +- .../using-npm/dependency-selectors.html | 4 +- .../npm/docs/output/using-npm/developers.html | 4 +- deps/npm/docs/output/using-npm/logging.html | 4 +- deps/npm/docs/output/using-npm/orgs.html | 4 +- .../docs/output/using-npm/package-spec.html | 4 +- deps/npm/docs/output/using-npm/registry.html | 4 +- deps/npm/docs/output/using-npm/removal.html | 4 +- deps/npm/docs/output/using-npm/scope.html | 4 +- deps/npm/docs/output/using-npm/scripts.html | 4 +- .../npm/docs/output/using-npm/workspaces.html | 4 +- deps/npm/lib/utils/check-allow-scripts.js | 9 +- deps/npm/lib/utils/is-windows.js | 6 +- deps/npm/lib/utils/reify-finish.js | 2 +- .../utils/strict-allow-scripts-preflight.js | 7 +- deps/npm/man/man1/npm-access.1 | 2 +- deps/npm/man/man1/npm-adduser.1 | 2 +- deps/npm/man/man1/npm-approve-scripts.1 | 2 +- deps/npm/man/man1/npm-audit.1 | 2 +- deps/npm/man/man1/npm-bugs.1 | 2 +- deps/npm/man/man1/npm-cache.1 | 2 +- deps/npm/man/man1/npm-ci.1 | 4 +- deps/npm/man/man1/npm-completion.1 | 2 +- deps/npm/man/man1/npm-config.1 | 2 +- deps/npm/man/man1/npm-dedupe.1 | 2 +- deps/npm/man/man1/npm-deny-scripts.1 | 2 +- deps/npm/man/man1/npm-deprecate.1 | 2 +- deps/npm/man/man1/npm-diff.1 | 2 +- deps/npm/man/man1/npm-dist-tag.1 | 2 +- deps/npm/man/man1/npm-docs.1 | 2 +- deps/npm/man/man1/npm-doctor.1 | 2 +- deps/npm/man/man1/npm-edit.1 | 2 +- deps/npm/man/man1/npm-exec.1 | 4 +- deps/npm/man/man1/npm-explain.1 | 2 +- deps/npm/man/man1/npm-explore.1 | 2 +- deps/npm/man/man1/npm-find-dupes.1 | 2 +- deps/npm/man/man1/npm-fund.1 | 2 +- deps/npm/man/man1/npm-get.1 | 2 +- deps/npm/man/man1/npm-help-search.1 | 2 +- deps/npm/man/man1/npm-help.1 | 2 +- deps/npm/man/man1/npm-init.1 | 2 +- deps/npm/man/man1/npm-install-ci-test.1 | 4 +- deps/npm/man/man1/npm-install-scripts.1 | 6 +- deps/npm/man/man1/npm-install-test.1 | 4 +- deps/npm/man/man1/npm-install.1 | 4 +- deps/npm/man/man1/npm-link.1 | 2 +- deps/npm/man/man1/npm-ll.1 | 2 +- deps/npm/man/man1/npm-login.1 | 2 +- deps/npm/man/man1/npm-logout.1 | 2 +- deps/npm/man/man1/npm-ls.1 | 4 +- deps/npm/man/man1/npm-org.1 | 2 +- deps/npm/man/man1/npm-outdated.1 | 2 +- deps/npm/man/man1/npm-owner.1 | 2 +- deps/npm/man/man1/npm-pack.1 | 2 +- deps/npm/man/man1/npm-ping.1 | 2 +- deps/npm/man/man1/npm-pkg.1 | 2 +- deps/npm/man/man1/npm-prefix.1 | 2 +- deps/npm/man/man1/npm-profile.1 | 2 +- deps/npm/man/man1/npm-prune.1 | 2 +- deps/npm/man/man1/npm-publish.1 | 2 +- deps/npm/man/man1/npm-query.1 | 2 +- deps/npm/man/man1/npm-rebuild.1 | 4 +- deps/npm/man/man1/npm-repo.1 | 2 +- deps/npm/man/man1/npm-restart.1 | 2 +- deps/npm/man/man1/npm-root.1 | 2 +- deps/npm/man/man1/npm-run.1 | 2 +- deps/npm/man/man1/npm-sbom.1 | 2 +- deps/npm/man/man1/npm-search.1 | 2 +- deps/npm/man/man1/npm-set.1 | 2 +- deps/npm/man/man1/npm-shrinkwrap.1 | 2 +- deps/npm/man/man1/npm-stage.1 | 2 +- deps/npm/man/man1/npm-star.1 | 2 +- deps/npm/man/man1/npm-stars.1 | 2 +- deps/npm/man/man1/npm-start.1 | 2 +- deps/npm/man/man1/npm-stop.1 | 2 +- deps/npm/man/man1/npm-team.1 | 2 +- deps/npm/man/man1/npm-test.1 | 2 +- deps/npm/man/man1/npm-token.1 | 2 +- deps/npm/man/man1/npm-trust.1 | 2 +- deps/npm/man/man1/npm-undeprecate.1 | 2 +- deps/npm/man/man1/npm-uninstall.1 | 2 +- deps/npm/man/man1/npm-unpublish.1 | 2 +- deps/npm/man/man1/npm-unstar.1 | 2 +- deps/npm/man/man1/npm-update.1 | 4 +- deps/npm/man/man1/npm-version.1 | 2 +- deps/npm/man/man1/npm-view.1 | 2 +- deps/npm/man/man1/npm-whoami.1 | 2 +- deps/npm/man/man1/npm.1 | 4 +- deps/npm/man/man1/npx.1 | 2 +- deps/npm/man/man5/folders.5 | 2 +- deps/npm/man/man5/install.5 | 2 +- deps/npm/man/man5/npm-global.5 | 2 +- deps/npm/man/man5/npm-json.5 | 2 +- deps/npm/man/man5/npm-shrinkwrap-json.5 | 2 +- deps/npm/man/man5/npmrc.5 | 2 +- deps/npm/man/man5/package-json.5 | 2 +- deps/npm/man/man5/package-lock-json.5 | 2 +- deps/npm/man/man7/config.7 | 4 +- deps/npm/man/man7/dependency-selectors.7 | 2 +- deps/npm/man/man7/developers.7 | 2 +- deps/npm/man/man7/logging.7 | 2 +- deps/npm/man/man7/orgs.7 | 2 +- deps/npm/man/man7/package-spec.7 | 2 +- deps/npm/man/man7/registry.7 | 2 +- deps/npm/man/man7/removal.7 | 2 +- deps/npm/man/man7/scope.7 | 2 +- deps/npm/man/man7/scripts.7 | 2 +- deps/npm/man/man7/workspaces.7 | 2 +- .../arborist/lib/arborist/isolated-reifier.js | 12 +- .../arborist/lib/case-insensitive-map.js | 5 +- .../node_modules/@npmcli/arborist/lib/edge.js | 10 +- .../node_modules/@npmcli/arborist/lib/node.js | 20 ++- .../arborist/lib/unreviewed-scripts.js | 5 + .../@npmcli/arborist/package.json | 2 +- .../config/lib/definitions/definitions.js | 5 + .../node_modules/@npmcli/config/package.json | 2 +- deps/npm/node_modules/libnpmdiff/package.json | 4 +- .../lib/strict-allow-scripts-preflight.js | 1 + deps/npm/node_modules/libnpmexec/package.json | 4 +- deps/npm/node_modules/libnpmfund/package.json | 4 +- deps/npm/node_modules/libnpmpack/package.json | 4 +- deps/npm/package.json | 14 +- .../tap-snapshots/test/lib/docs.js.test.cjs | 5 + deps/npm/test/bin/windows-shims.js | 12 +- .../npm/test/fixtures/allow-scripts-orphan.js | 32 +++++ deps/npm/test/lib/commands/ci.js | 65 +++++++++ deps/npm/test/lib/commands/install-scripts.js | 33 ++++- deps/npm/test/lib/commands/install.js | 129 ++++++++++++++++++ deps/npm/test/lib/commands/rebuild.js | 27 ++++ .../npm/test/lib/utils/check-allow-scripts.js | 23 ++++ deps/npm/test/lib/utils/is-windows.js | 65 +++++++++ deps/npm/test/lib/utils/reify-finish.js | 31 ++++- .../utils/strict-allow-scripts-preflight.js | 110 ++++++++++++++- 226 files changed, 992 insertions(+), 334 deletions(-) create mode 100644 deps/npm/test/fixtures/allow-scripts-orphan.js create mode 100644 deps/npm/test/lib/utils/is-windows.js diff --git a/deps/npm/docs/content/commands/npm-ci.md b/deps/npm/docs/content/commands/npm-ci.md index 8cf6a42690b..6251a2204cc 100644 --- a/deps/npm/docs/content/commands/npm-ci.md +++ b/deps/npm/docs/content/commands/npm-ci.md @@ -310,6 +310,11 @@ Optional dependencies that cannot be installed on the current platform or engine (a non-matching `os`, `cpu`, or `libc`) are not flagged, because their install scripts never run. +Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. `npm rebuild` and `npm install-scripts ls` still check unused +packages on disk. + #### `dangerously-allow-all-scripts` diff --git a/deps/npm/docs/content/commands/npm-exec.md b/deps/npm/docs/content/commands/npm-exec.md index 87be6dbfd67..bb350961a61 100644 --- a/deps/npm/docs/content/commands/npm-exec.md +++ b/deps/npm/docs/content/commands/npm-exec.md @@ -198,6 +198,11 @@ Optional dependencies that cannot be installed on the current platform or engine (a non-matching `os`, `cpu`, or `libc`) are not flagged, because their install scripts never run. +Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. `npm rebuild` and `npm install-scripts ls` still check unused +packages on disk. + #### `dangerously-allow-all-scripts` diff --git a/deps/npm/docs/content/commands/npm-install-ci-test.md b/deps/npm/docs/content/commands/npm-install-ci-test.md index 66774863573..2bfcaaac2d8 100644 --- a/deps/npm/docs/content/commands/npm-install-ci-test.md +++ b/deps/npm/docs/content/commands/npm-install-ci-test.md @@ -263,6 +263,11 @@ Optional dependencies that cannot be installed on the current platform or engine (a non-matching `os`, `cpu`, or `libc`) are not flagged, because their install scripts never run. +Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. `npm rebuild` and `npm install-scripts ls` still check unused +packages on disk. + #### `dangerously-allow-all-scripts` diff --git a/deps/npm/docs/content/commands/npm-install-scripts.md b/deps/npm/docs/content/commands/npm-install-scripts.md index 4182392c9a3..1dbfa4ecc4d 100644 --- a/deps/npm/docs/content/commands/npm-install-scripts.md +++ b/deps/npm/docs/content/commands/npm-install-scripts.md @@ -28,6 +28,9 @@ Dependency install scripts are blocked by default. Install commands silently skip lifecycle scripts for any dependency that does not have a matching entry in `allowScripts`, and end with a list of the packages whose scripts were skipped so you can review them here. +These warnings omit disconnected unused entries that installation cannot +build. Local link targets that can still be rebuilt remain subject to the +policy. This command only works inside a project that has a `package.json`. Running it with `--global` (`-g`) fails with an `EGLOBAL` error, since global @@ -62,6 +65,9 @@ unreviewed install scripts. `ls` is read-only: it lists every package whose install scripts are not yet covered by `allowScripts`, without modifying `package.json`. +This includes unreviewed extraneous packages, which are installed but not +required by any dependency. These packages can still cause +`npm rebuild --strict-allow-scripts` to fail. `prune` removes `allowScripts` entries that no longer match an installed package with an install script, either because the package is no longer diff --git a/deps/npm/docs/content/commands/npm-install-test.md b/deps/npm/docs/content/commands/npm-install-test.md index 4311f80279d..d538bfa09d1 100644 --- a/deps/npm/docs/content/commands/npm-install-test.md +++ b/deps/npm/docs/content/commands/npm-install-test.md @@ -340,6 +340,11 @@ Optional dependencies that cannot be installed on the current platform or engine (a non-matching `os`, `cpu`, or `libc`) are not flagged, because their install scripts never run. +Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. `npm rebuild` and `npm install-scripts ls` still check unused +packages on disk. + #### `dangerously-allow-all-scripts` diff --git a/deps/npm/docs/content/commands/npm-install.md b/deps/npm/docs/content/commands/npm-install.md index efc07bc7598..d08da1353d2 100644 --- a/deps/npm/docs/content/commands/npm-install.md +++ b/deps/npm/docs/content/commands/npm-install.md @@ -682,6 +682,11 @@ Optional dependencies that cannot be installed on the current platform or engine (a non-matching `os`, `cpu`, or `libc`) are not flagged, because their install scripts never run. +Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. `npm rebuild` and `npm install-scripts ls` still check unused +packages on disk. + #### `dangerously-allow-all-scripts` diff --git a/deps/npm/docs/content/commands/npm-ls.md b/deps/npm/docs/content/commands/npm-ls.md index 3e01552722c..e352f37d8d5 100644 --- a/deps/npm/docs/content/commands/npm-ls.md +++ b/deps/npm/docs/content/commands/npm-ls.md @@ -23,7 +23,7 @@ Note that nested packages will *also* show the paths to the specified packages. For example, running `npm ls promzard` in npm's source tree will show: ```bash -npm@11.21.2 /path/to/npm +npm@11.21.3 /path/to/npm └─┬ init-package-json@0.0.4 └── promzard@0.1.5 ``` diff --git a/deps/npm/docs/content/commands/npm-rebuild.md b/deps/npm/docs/content/commands/npm-rebuild.md index 6b3095ff9d1..771b61414be 100644 --- a/deps/npm/docs/content/commands/npm-rebuild.md +++ b/deps/npm/docs/content/commands/npm-rebuild.md @@ -140,6 +140,11 @@ Optional dependencies that cannot be installed on the current platform or engine (a non-matching `os`, `cpu`, or `libc`) are not flagged, because their install scripts never run. +Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. `npm rebuild` and `npm install-scripts ls` still check unused +packages on disk. + #### `dangerously-allow-all-scripts` diff --git a/deps/npm/docs/content/commands/npm-update.md b/deps/npm/docs/content/commands/npm-update.md index 6da8ef5ac0e..6eb7b3b12d7 100644 --- a/deps/npm/docs/content/commands/npm-update.md +++ b/deps/npm/docs/content/commands/npm-update.md @@ -350,6 +350,11 @@ Optional dependencies that cannot be installed on the current platform or engine (a non-matching `os`, `cpu`, or `libc`) are not flagged, because their install scripts never run. +Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. `npm rebuild` and `npm install-scripts ls` still check unused +packages on disk. + #### `dangerously-allow-all-scripts` diff --git a/deps/npm/docs/content/commands/npm.md b/deps/npm/docs/content/commands/npm.md index 0206d6aa087..58464a66d39 100644 --- a/deps/npm/docs/content/commands/npm.md +++ b/deps/npm/docs/content/commands/npm.md @@ -14,7 +14,7 @@ Note: This command is unaware of workspaces. ### Version -11.21.2 +11.21.3 ### Description diff --git a/deps/npm/docs/content/using-npm/config.md b/deps/npm/docs/content/using-npm/config.md index 71743e7fea3..b7c8e78610d 100644 --- a/deps/npm/docs/content/using-npm/config.md +++ b/deps/npm/docs/content/using-npm/config.md @@ -1915,6 +1915,11 @@ Optional dependencies that cannot be installed on the current platform or engine (a non-matching `os`, `cpu`, or `libc`) are not flagged, because their install scripts never run. +Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. `npm rebuild` and `npm install-scripts ls` still check unused +packages on disk. + #### `strict-peer-deps` diff --git a/deps/npm/docs/output/commands/npm-access.html b/deps/npm/docs/output/commands/npm-access.html index 3feec9298ef..ce22d943ee9 100644 --- a/deps/npm/docs/output/commands/npm-access.html +++ b/deps/npm/docs/output/commands/npm-access.html @@ -186,9 +186,9 @@
    -

    +

    npm-access - @11.21.2 + @11.21.3

    Set access level on published packages
    diff --git a/deps/npm/docs/output/commands/npm-adduser.html b/deps/npm/docs/output/commands/npm-adduser.html index af06b3609bc..17f9ff260c1 100644 --- a/deps/npm/docs/output/commands/npm-adduser.html +++ b/deps/npm/docs/output/commands/npm-adduser.html @@ -186,9 +186,9 @@
    -

    +

    npm-adduser - @11.21.2 + @11.21.3

    Add a registry user account
    diff --git a/deps/npm/docs/output/commands/npm-approve-scripts.html b/deps/npm/docs/output/commands/npm-approve-scripts.html index 9324166c7b9..8c291ae02fb 100644 --- a/deps/npm/docs/output/commands/npm-approve-scripts.html +++ b/deps/npm/docs/output/commands/npm-approve-scripts.html @@ -186,9 +186,9 @@
    -

    +

    npm-approve-scripts - @11.21.2 + @11.21.3

    Approve install scripts for specific dependencies
    diff --git a/deps/npm/docs/output/commands/npm-audit.html b/deps/npm/docs/output/commands/npm-audit.html index fec2c0eeec4..0cc8e97b83e 100644 --- a/deps/npm/docs/output/commands/npm-audit.html +++ b/deps/npm/docs/output/commands/npm-audit.html @@ -186,9 +186,9 @@
    -

    +

    npm-audit - @11.21.2 + @11.21.3

    Run a security audit
    diff --git a/deps/npm/docs/output/commands/npm-bugs.html b/deps/npm/docs/output/commands/npm-bugs.html index 6bc1b9c4f26..aaed8e8edfb 100644 --- a/deps/npm/docs/output/commands/npm-bugs.html +++ b/deps/npm/docs/output/commands/npm-bugs.html @@ -186,9 +186,9 @@
    -

    +

    npm-bugs - @11.21.2 + @11.21.3

    Report bugs for a package in a web browser
    diff --git a/deps/npm/docs/output/commands/npm-cache.html b/deps/npm/docs/output/commands/npm-cache.html index 831035e343f..2b7b784a621 100644 --- a/deps/npm/docs/output/commands/npm-cache.html +++ b/deps/npm/docs/output/commands/npm-cache.html @@ -186,9 +186,9 @@
    -

    +

    npm-cache - @11.21.2 + @11.21.3

    Manipulates packages cache
    diff --git a/deps/npm/docs/output/commands/npm-ci.html b/deps/npm/docs/output/commands/npm-ci.html index 2f2900c3eae..913544f13c4 100644 --- a/deps/npm/docs/output/commands/npm-ci.html +++ b/deps/npm/docs/output/commands/npm-ci.html @@ -186,9 +186,9 @@
    -

    +

    npm-ci - @11.21.2 + @11.21.3

    Clean install a project
    @@ -430,6 +430,10 @@

    strict-allow-scripts

    Optional dependencies that cannot be installed on the current platform or engine (a non-matching os, cpu, or libc) are not flagged, because their install scripts never run.

    +

    Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. npm rebuild and npm install-scripts ls still check unused +packages on disk.

    dangerously-allow-all-scripts

    • Default: false
    • diff --git a/deps/npm/docs/output/commands/npm-completion.html b/deps/npm/docs/output/commands/npm-completion.html index a89ad0fa110..53ee1c723a0 100644 --- a/deps/npm/docs/output/commands/npm-completion.html +++ b/deps/npm/docs/output/commands/npm-completion.html @@ -186,9 +186,9 @@
      -

      +

      npm-completion - @11.21.2 + @11.21.3

      Tab Completion for npm
      diff --git a/deps/npm/docs/output/commands/npm-config.html b/deps/npm/docs/output/commands/npm-config.html index c08848fb8e1..683f555ca12 100644 --- a/deps/npm/docs/output/commands/npm-config.html +++ b/deps/npm/docs/output/commands/npm-config.html @@ -186,9 +186,9 @@
      -

      +

      npm-config - @11.21.2 + @11.21.3

      Manage the npm configuration files
      diff --git a/deps/npm/docs/output/commands/npm-dedupe.html b/deps/npm/docs/output/commands/npm-dedupe.html index 6f33135ca9a..06be1de4b4f 100644 --- a/deps/npm/docs/output/commands/npm-dedupe.html +++ b/deps/npm/docs/output/commands/npm-dedupe.html @@ -186,9 +186,9 @@
      -

      +

      npm-dedupe - @11.21.2 + @11.21.3

      Reduce duplication in the package tree
      diff --git a/deps/npm/docs/output/commands/npm-deny-scripts.html b/deps/npm/docs/output/commands/npm-deny-scripts.html index f844e396844..597547b8267 100644 --- a/deps/npm/docs/output/commands/npm-deny-scripts.html +++ b/deps/npm/docs/output/commands/npm-deny-scripts.html @@ -186,9 +186,9 @@
      -

      +

      npm-deny-scripts - @11.21.2 + @11.21.3

      Deny install scripts for specific dependencies
      diff --git a/deps/npm/docs/output/commands/npm-deprecate.html b/deps/npm/docs/output/commands/npm-deprecate.html index 9bc0fc612a5..071aa398c2b 100644 --- a/deps/npm/docs/output/commands/npm-deprecate.html +++ b/deps/npm/docs/output/commands/npm-deprecate.html @@ -186,9 +186,9 @@
      -

      +

      npm-deprecate - @11.21.2 + @11.21.3

      Deprecate a version of a package
      diff --git a/deps/npm/docs/output/commands/npm-diff.html b/deps/npm/docs/output/commands/npm-diff.html index 4b41ca886c2..f7882878ec1 100644 --- a/deps/npm/docs/output/commands/npm-diff.html +++ b/deps/npm/docs/output/commands/npm-diff.html @@ -186,9 +186,9 @@
      -

      +

      npm-diff - @11.21.2 + @11.21.3

      The registry diff command
      diff --git a/deps/npm/docs/output/commands/npm-dist-tag.html b/deps/npm/docs/output/commands/npm-dist-tag.html index 032b78e75f4..a576999ec12 100644 --- a/deps/npm/docs/output/commands/npm-dist-tag.html +++ b/deps/npm/docs/output/commands/npm-dist-tag.html @@ -186,9 +186,9 @@
      -

      +

      npm-dist-tag - @11.21.2 + @11.21.3

      Modify package distribution tags
      diff --git a/deps/npm/docs/output/commands/npm-docs.html b/deps/npm/docs/output/commands/npm-docs.html index e39ea14464d..8b840f95d1c 100644 --- a/deps/npm/docs/output/commands/npm-docs.html +++ b/deps/npm/docs/output/commands/npm-docs.html @@ -186,9 +186,9 @@
      -

      +

      npm-docs - @11.21.2 + @11.21.3

      Open documentation for a package in a web browser
      diff --git a/deps/npm/docs/output/commands/npm-doctor.html b/deps/npm/docs/output/commands/npm-doctor.html index 30492a8f038..0a6fe81bffa 100644 --- a/deps/npm/docs/output/commands/npm-doctor.html +++ b/deps/npm/docs/output/commands/npm-doctor.html @@ -186,9 +186,9 @@
      -

      +

      npm-doctor - @11.21.2 + @11.21.3

      Check the health of your npm environment
      diff --git a/deps/npm/docs/output/commands/npm-edit.html b/deps/npm/docs/output/commands/npm-edit.html index aed37190cef..a7d1aded7bf 100644 --- a/deps/npm/docs/output/commands/npm-edit.html +++ b/deps/npm/docs/output/commands/npm-edit.html @@ -186,9 +186,9 @@
      -

      +

      npm-edit - @11.21.2 + @11.21.3

      Edit an installed package
      diff --git a/deps/npm/docs/output/commands/npm-exec.html b/deps/npm/docs/output/commands/npm-exec.html index 0dd426d8d27..d96eec84adc 100644 --- a/deps/npm/docs/output/commands/npm-exec.html +++ b/deps/npm/docs/output/commands/npm-exec.html @@ -186,9 +186,9 @@
      -

      +

      npm-exec - @11.21.2 + @11.21.3

      Run a command from a local or remote npm package
      @@ -340,6 +340,10 @@

      strict-allow-scripts

      Optional dependencies that cannot be installed on the current platform or engine (a non-matching os, cpu, or libc) are not flagged, because their install scripts never run.

      +

      Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. npm rebuild and npm install-scripts ls still check unused +packages on disk.

      dangerously-allow-all-scripts

      • Default: false
      • diff --git a/deps/npm/docs/output/commands/npm-explain.html b/deps/npm/docs/output/commands/npm-explain.html index fe176731c99..dc2bfa56706 100644 --- a/deps/npm/docs/output/commands/npm-explain.html +++ b/deps/npm/docs/output/commands/npm-explain.html @@ -186,9 +186,9 @@
        -

        +

        npm-explain - @11.21.2 + @11.21.3

        Explain installed packages
        diff --git a/deps/npm/docs/output/commands/npm-explore.html b/deps/npm/docs/output/commands/npm-explore.html index 1e4ff4af713..a228fe09cfe 100644 --- a/deps/npm/docs/output/commands/npm-explore.html +++ b/deps/npm/docs/output/commands/npm-explore.html @@ -186,9 +186,9 @@
        -

        +

        npm-explore - @11.21.2 + @11.21.3

        Browse an installed package
        diff --git a/deps/npm/docs/output/commands/npm-find-dupes.html b/deps/npm/docs/output/commands/npm-find-dupes.html index fd42595f230..42e8bf0fc3b 100644 --- a/deps/npm/docs/output/commands/npm-find-dupes.html +++ b/deps/npm/docs/output/commands/npm-find-dupes.html @@ -186,9 +186,9 @@
        -

        +

        npm-find-dupes - @11.21.2 + @11.21.3

        Find duplication in the package tree
        diff --git a/deps/npm/docs/output/commands/npm-fund.html b/deps/npm/docs/output/commands/npm-fund.html index 180479da8c0..c2646c93700 100644 --- a/deps/npm/docs/output/commands/npm-fund.html +++ b/deps/npm/docs/output/commands/npm-fund.html @@ -186,9 +186,9 @@
        -

        +

        npm-fund - @11.21.2 + @11.21.3

        Retrieve funding information
        diff --git a/deps/npm/docs/output/commands/npm-get.html b/deps/npm/docs/output/commands/npm-get.html index 03cd64c2413..ef1b9e3fd7a 100644 --- a/deps/npm/docs/output/commands/npm-get.html +++ b/deps/npm/docs/output/commands/npm-get.html @@ -186,9 +186,9 @@
        -

        +

        npm-get - @11.21.2 + @11.21.3

        Get a value from the npm configuration
        diff --git a/deps/npm/docs/output/commands/npm-help-search.html b/deps/npm/docs/output/commands/npm-help-search.html index 51925baf1aa..d18396addd4 100644 --- a/deps/npm/docs/output/commands/npm-help-search.html +++ b/deps/npm/docs/output/commands/npm-help-search.html @@ -186,9 +186,9 @@
        -

        +

        npm-help-search - @11.21.2 + @11.21.3

        Search npm help documentation
        diff --git a/deps/npm/docs/output/commands/npm-help.html b/deps/npm/docs/output/commands/npm-help.html index 69383c4ea7a..81f20a0de1e 100644 --- a/deps/npm/docs/output/commands/npm-help.html +++ b/deps/npm/docs/output/commands/npm-help.html @@ -186,9 +186,9 @@
        -

        +

        npm-help - @11.21.2 + @11.21.3

        Get help on npm
        diff --git a/deps/npm/docs/output/commands/npm-init.html b/deps/npm/docs/output/commands/npm-init.html index 6b9f1fb1f30..89c491b9343 100644 --- a/deps/npm/docs/output/commands/npm-init.html +++ b/deps/npm/docs/output/commands/npm-init.html @@ -186,9 +186,9 @@
        -

        +

        npm-init - @11.21.2 + @11.21.3

        Create a package.json file
        diff --git a/deps/npm/docs/output/commands/npm-install-ci-test.html b/deps/npm/docs/output/commands/npm-install-ci-test.html index 506ef87743d..72891927a26 100644 --- a/deps/npm/docs/output/commands/npm-install-ci-test.html +++ b/deps/npm/docs/output/commands/npm-install-ci-test.html @@ -186,9 +186,9 @@
        -

        +

        npm-install-ci-test - @11.21.2 + @11.21.3

        Install a project with a clean slate and run tests
        @@ -394,6 +394,10 @@

        strict-allow-scripts

        Optional dependencies that cannot be installed on the current platform or engine (a non-matching os, cpu, or libc) are not flagged, because their install scripts never run.

        +

        Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. npm rebuild and npm install-scripts ls still check unused +packages on disk.

        dangerously-allow-all-scripts

        • Default: false
        • diff --git a/deps/npm/docs/output/commands/npm-install-scripts.html b/deps/npm/docs/output/commands/npm-install-scripts.html index 494a80c7806..8d58a23d3d6 100644 --- a/deps/npm/docs/output/commands/npm-install-scripts.html +++ b/deps/npm/docs/output/commands/npm-install-scripts.html @@ -186,9 +186,9 @@
          -

          +

          npm-install-scripts - @11.21.2 + @11.21.3

          Manage install-script approvals for dependencies
          @@ -215,7 +215,10 @@

          Description

          Dependency install scripts are blocked by default. Install commands silently skip lifecycle scripts for any dependency that does not have a matching entry in allowScripts, and end with a list of the packages -whose scripts were skipped so you can review them here.

          +whose scripts were skipped so you can review them here. +These warnings omit disconnected unused entries that installation cannot +build. Local link targets that can still be rebuilt remain subject to the +policy.

          This command only works inside a project that has a package.json. Running it with --global (-g) fails with an EGLOBAL error, since global installs (npm install -g) and one-off executions (npm exec / npx) have @@ -242,7 +245,10 @@

          Description

          package from any future blanket approval. --all denies every package with unreviewed install scripts.

          ls is read-only: it lists every package whose install scripts are not yet -covered by allowScripts, without modifying package.json.

          +covered by allowScripts, without modifying package.json. +This includes unreviewed extraneous packages, which are installed but not +required by any dependency. These packages can still cause +npm rebuild --strict-allow-scripts to fail.

          prune removes allowScripts entries that no longer match an installed package with an install script, either because the package is no longer installed (a transitive dependency changed, or a pinned pkg@1.2.3 was diff --git a/deps/npm/docs/output/commands/npm-install-test.html b/deps/npm/docs/output/commands/npm-install-test.html index 9c567c396c9..3b0a0a370a8 100644 --- a/deps/npm/docs/output/commands/npm-install-test.html +++ b/deps/npm/docs/output/commands/npm-install-test.html @@ -186,9 +186,9 @@

          -

          +

          npm-install-test - @11.21.2 + @11.21.3

          Install package(s) and run tests
          @@ -450,6 +450,10 @@

          strict-allow-scripts

          Optional dependencies that cannot be installed on the current platform or engine (a non-matching os, cpu, or libc) are not flagged, because their install scripts never run.

          +

          Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. npm rebuild and npm install-scripts ls still check unused +packages on disk.

          dangerously-allow-all-scripts

          • Default: false
          • diff --git a/deps/npm/docs/output/commands/npm-install.html b/deps/npm/docs/output/commands/npm-install.html index 5954c822193..211f3f6ec69 100644 --- a/deps/npm/docs/output/commands/npm-install.html +++ b/deps/npm/docs/output/commands/npm-install.html @@ -186,9 +186,9 @@
            -

            +

            npm-install - @11.21.2 + @11.21.3

            Install a package
            @@ -725,6 +725,10 @@

            strict-allow-scripts

            Optional dependencies that cannot be installed on the current platform or engine (a non-matching os, cpu, or libc) are not flagged, because their install scripts never run.

            +

            Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. npm rebuild and npm install-scripts ls still check unused +packages on disk.

            dangerously-allow-all-scripts

            • Default: false
            • diff --git a/deps/npm/docs/output/commands/npm-link.html b/deps/npm/docs/output/commands/npm-link.html index 49656649d22..49d80e7985e 100644 --- a/deps/npm/docs/output/commands/npm-link.html +++ b/deps/npm/docs/output/commands/npm-link.html @@ -186,9 +186,9 @@
              -

              +

              npm-link - @11.21.2 + @11.21.3

              Symlink a package folder
              diff --git a/deps/npm/docs/output/commands/npm-ll.html b/deps/npm/docs/output/commands/npm-ll.html index e56f1fcf0f1..f7e026c0e5c 100644 --- a/deps/npm/docs/output/commands/npm-ll.html +++ b/deps/npm/docs/output/commands/npm-ll.html @@ -186,9 +186,9 @@
              -

              +

              npm-ll - @11.21.2 + @11.21.3

              List installed packages
              diff --git a/deps/npm/docs/output/commands/npm-login.html b/deps/npm/docs/output/commands/npm-login.html index efa0880e352..f15b26e222c 100644 --- a/deps/npm/docs/output/commands/npm-login.html +++ b/deps/npm/docs/output/commands/npm-login.html @@ -186,9 +186,9 @@
              -

              +

              npm-login - @11.21.2 + @11.21.3

              Login to a registry user account
              diff --git a/deps/npm/docs/output/commands/npm-logout.html b/deps/npm/docs/output/commands/npm-logout.html index 1d365feb30a..1b5f8f41a3c 100644 --- a/deps/npm/docs/output/commands/npm-logout.html +++ b/deps/npm/docs/output/commands/npm-logout.html @@ -186,9 +186,9 @@
              -

              +

              npm-logout - @11.21.2 + @11.21.3

              Log out of the registry
              diff --git a/deps/npm/docs/output/commands/npm-ls.html b/deps/npm/docs/output/commands/npm-ls.html index b78078a3366..02e77a07e1c 100644 --- a/deps/npm/docs/output/commands/npm-ls.html +++ b/deps/npm/docs/output/commands/npm-ls.html @@ -186,9 +186,9 @@
              -

              +

              npm-ls - @11.21.2 + @11.21.3

              List installed packages
              @@ -209,7 +209,7 @@

              Description

              Positional arguments are name@version-range identifiers, which will limit the results to only the paths to the packages named. Note that nested packages will also show the paths to the specified packages. For example, running npm ls promzard in npm's source tree will show:

              -
              npm@11.21.2 /path/to/npm
              +
              npm@11.21.3 /path/to/npm
               └─┬ init-package-json@0.0.4
                 └── promzard@0.1.5
               
              diff --git a/deps/npm/docs/output/commands/npm-org.html b/deps/npm/docs/output/commands/npm-org.html index ec6986644d9..6f3b7a4074a 100644 --- a/deps/npm/docs/output/commands/npm-org.html +++ b/deps/npm/docs/output/commands/npm-org.html @@ -186,9 +186,9 @@
              -

              +

              npm-org - @11.21.2 + @11.21.3

              Manage orgs
              diff --git a/deps/npm/docs/output/commands/npm-outdated.html b/deps/npm/docs/output/commands/npm-outdated.html index a8285b18ce3..970dd74e3ed 100644 --- a/deps/npm/docs/output/commands/npm-outdated.html +++ b/deps/npm/docs/output/commands/npm-outdated.html @@ -186,9 +186,9 @@
              -

              +

              npm-outdated - @11.21.2 + @11.21.3

              Check for outdated packages
              diff --git a/deps/npm/docs/output/commands/npm-owner.html b/deps/npm/docs/output/commands/npm-owner.html index 114fcd7ff58..58154397dbf 100644 --- a/deps/npm/docs/output/commands/npm-owner.html +++ b/deps/npm/docs/output/commands/npm-owner.html @@ -186,9 +186,9 @@
              -

              +

              npm-owner - @11.21.2 + @11.21.3

              Manage package owners
              diff --git a/deps/npm/docs/output/commands/npm-pack.html b/deps/npm/docs/output/commands/npm-pack.html index d5c2bc9ecc3..e654b5cb6d5 100644 --- a/deps/npm/docs/output/commands/npm-pack.html +++ b/deps/npm/docs/output/commands/npm-pack.html @@ -186,9 +186,9 @@
              -

              +

              npm-pack - @11.21.2 + @11.21.3

              Create a tarball from a package
              diff --git a/deps/npm/docs/output/commands/npm-ping.html b/deps/npm/docs/output/commands/npm-ping.html index 0ae2afe0521..430b2672058 100644 --- a/deps/npm/docs/output/commands/npm-ping.html +++ b/deps/npm/docs/output/commands/npm-ping.html @@ -186,9 +186,9 @@
              -

              +

              npm-ping - @11.21.2 + @11.21.3

              Ping npm registry
              diff --git a/deps/npm/docs/output/commands/npm-pkg.html b/deps/npm/docs/output/commands/npm-pkg.html index 5ad85163e90..9a0a1e0b38c 100644 --- a/deps/npm/docs/output/commands/npm-pkg.html +++ b/deps/npm/docs/output/commands/npm-pkg.html @@ -186,9 +186,9 @@
              -

              +

              npm-pkg - @11.21.2 + @11.21.3

              Manages your package.json
              diff --git a/deps/npm/docs/output/commands/npm-prefix.html b/deps/npm/docs/output/commands/npm-prefix.html index 60db61a48dc..829ebd483c9 100644 --- a/deps/npm/docs/output/commands/npm-prefix.html +++ b/deps/npm/docs/output/commands/npm-prefix.html @@ -186,9 +186,9 @@
              -

              +

              npm-prefix - @11.21.2 + @11.21.3

              Display prefix
              diff --git a/deps/npm/docs/output/commands/npm-profile.html b/deps/npm/docs/output/commands/npm-profile.html index 663552d02e7..1dc726acf61 100644 --- a/deps/npm/docs/output/commands/npm-profile.html +++ b/deps/npm/docs/output/commands/npm-profile.html @@ -186,9 +186,9 @@
              -

              +

              npm-profile - @11.21.2 + @11.21.3

              Change settings on your registry profile
              diff --git a/deps/npm/docs/output/commands/npm-prune.html b/deps/npm/docs/output/commands/npm-prune.html index f6a02b96841..bded491e654 100644 --- a/deps/npm/docs/output/commands/npm-prune.html +++ b/deps/npm/docs/output/commands/npm-prune.html @@ -186,9 +186,9 @@
              -

              +

              npm-prune - @11.21.2 + @11.21.3

              Remove extraneous packages
              diff --git a/deps/npm/docs/output/commands/npm-publish.html b/deps/npm/docs/output/commands/npm-publish.html index 8b6334352a9..088cff8ff4a 100644 --- a/deps/npm/docs/output/commands/npm-publish.html +++ b/deps/npm/docs/output/commands/npm-publish.html @@ -186,9 +186,9 @@
              -

              +

              npm-publish - @11.21.2 + @11.21.3

              Publish a package
              diff --git a/deps/npm/docs/output/commands/npm-query.html b/deps/npm/docs/output/commands/npm-query.html index c58709f7c5b..92d236d4444 100644 --- a/deps/npm/docs/output/commands/npm-query.html +++ b/deps/npm/docs/output/commands/npm-query.html @@ -186,9 +186,9 @@
              -

              +

              npm-query - @11.21.2 + @11.21.3

              Dependency selector query
              diff --git a/deps/npm/docs/output/commands/npm-rebuild.html b/deps/npm/docs/output/commands/npm-rebuild.html index 012f165685d..d22481d325f 100644 --- a/deps/npm/docs/output/commands/npm-rebuild.html +++ b/deps/npm/docs/output/commands/npm-rebuild.html @@ -186,9 +186,9 @@
              -

              +

              npm-rebuild - @11.21.2 + @11.21.3

              Rebuild a package
              @@ -302,6 +302,10 @@

              strict-allow-scripts

              Optional dependencies that cannot be installed on the current platform or engine (a non-matching os, cpu, or libc) are not flagged, because their install scripts never run.

              +

              Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. npm rebuild and npm install-scripts ls still check unused +packages on disk.

              dangerously-allow-all-scripts

              • Default: false
              • diff --git a/deps/npm/docs/output/commands/npm-repo.html b/deps/npm/docs/output/commands/npm-repo.html index eb9f27e5bb9..763e61cd92c 100644 --- a/deps/npm/docs/output/commands/npm-repo.html +++ b/deps/npm/docs/output/commands/npm-repo.html @@ -186,9 +186,9 @@
                -

                +

                npm-repo - @11.21.2 + @11.21.3

                Open package repository page in the browser
                diff --git a/deps/npm/docs/output/commands/npm-restart.html b/deps/npm/docs/output/commands/npm-restart.html index f64c839eef1..5765bdce841 100644 --- a/deps/npm/docs/output/commands/npm-restart.html +++ b/deps/npm/docs/output/commands/npm-restart.html @@ -186,9 +186,9 @@
                -

                +

                npm-restart - @11.21.2 + @11.21.3

                Restart a package
                diff --git a/deps/npm/docs/output/commands/npm-root.html b/deps/npm/docs/output/commands/npm-root.html index 1c72502851b..ff10c805c9a 100644 --- a/deps/npm/docs/output/commands/npm-root.html +++ b/deps/npm/docs/output/commands/npm-root.html @@ -186,9 +186,9 @@
                -

                +

                npm-root - @11.21.2 + @11.21.3

                Display npm root
                diff --git a/deps/npm/docs/output/commands/npm-run.html b/deps/npm/docs/output/commands/npm-run.html index f5fc445afc2..8a2708a2570 100644 --- a/deps/npm/docs/output/commands/npm-run.html +++ b/deps/npm/docs/output/commands/npm-run.html @@ -186,9 +186,9 @@
                -

                +

                npm-run - @11.21.2 + @11.21.3

                Run arbitrary package scripts
                diff --git a/deps/npm/docs/output/commands/npm-sbom.html b/deps/npm/docs/output/commands/npm-sbom.html index 16117732078..787ea92d51d 100644 --- a/deps/npm/docs/output/commands/npm-sbom.html +++ b/deps/npm/docs/output/commands/npm-sbom.html @@ -186,9 +186,9 @@
                -

                +

                npm-sbom - @11.21.2 + @11.21.3

                Generate a Software Bill of Materials (SBOM)
                diff --git a/deps/npm/docs/output/commands/npm-search.html b/deps/npm/docs/output/commands/npm-search.html index b81f53e7706..e69a1bb1825 100644 --- a/deps/npm/docs/output/commands/npm-search.html +++ b/deps/npm/docs/output/commands/npm-search.html @@ -186,9 +186,9 @@
                -

                +

                npm-search - @11.21.2 + @11.21.3

                Search for packages
                diff --git a/deps/npm/docs/output/commands/npm-set.html b/deps/npm/docs/output/commands/npm-set.html index 51dbbbeed71..df1211e6bfc 100644 --- a/deps/npm/docs/output/commands/npm-set.html +++ b/deps/npm/docs/output/commands/npm-set.html @@ -186,9 +186,9 @@
                -

                +

                npm-set - @11.21.2 + @11.21.3

                Set a value in the npm configuration
                diff --git a/deps/npm/docs/output/commands/npm-shrinkwrap.html b/deps/npm/docs/output/commands/npm-shrinkwrap.html index 41c7ef2bbf2..68f8a97d0b5 100644 --- a/deps/npm/docs/output/commands/npm-shrinkwrap.html +++ b/deps/npm/docs/output/commands/npm-shrinkwrap.html @@ -186,9 +186,9 @@
                -

                +

                npm-shrinkwrap - @11.21.2 + @11.21.3

                Lock down dependency versions for publication
                diff --git a/deps/npm/docs/output/commands/npm-stage.html b/deps/npm/docs/output/commands/npm-stage.html index 6cf400f9621..f9e945b626c 100644 --- a/deps/npm/docs/output/commands/npm-stage.html +++ b/deps/npm/docs/output/commands/npm-stage.html @@ -186,9 +186,9 @@
                -

                +

                npm-stage - @11.21.2 + @11.21.3

                Stage packages for publishing
                diff --git a/deps/npm/docs/output/commands/npm-star.html b/deps/npm/docs/output/commands/npm-star.html index de2c5e677c2..765af7de992 100644 --- a/deps/npm/docs/output/commands/npm-star.html +++ b/deps/npm/docs/output/commands/npm-star.html @@ -186,9 +186,9 @@
                -

                +

                npm-star - @11.21.2 + @11.21.3

                Mark your favorite packages
                diff --git a/deps/npm/docs/output/commands/npm-stars.html b/deps/npm/docs/output/commands/npm-stars.html index 39cad8e82e7..4785be2711d 100644 --- a/deps/npm/docs/output/commands/npm-stars.html +++ b/deps/npm/docs/output/commands/npm-stars.html @@ -186,9 +186,9 @@
                -

                +

                npm-stars - @11.21.2 + @11.21.3

                View packages marked as favorites
                diff --git a/deps/npm/docs/output/commands/npm-start.html b/deps/npm/docs/output/commands/npm-start.html index 08a76f247d8..64a04d6d74a 100644 --- a/deps/npm/docs/output/commands/npm-start.html +++ b/deps/npm/docs/output/commands/npm-start.html @@ -186,9 +186,9 @@
                -

                +

                npm-start - @11.21.2 + @11.21.3

                Start a package
                diff --git a/deps/npm/docs/output/commands/npm-stop.html b/deps/npm/docs/output/commands/npm-stop.html index ec42d3fe2d1..6a3744eb3b4 100644 --- a/deps/npm/docs/output/commands/npm-stop.html +++ b/deps/npm/docs/output/commands/npm-stop.html @@ -186,9 +186,9 @@
                -

                +

                npm-stop - @11.21.2 + @11.21.3

                Stop a package
                diff --git a/deps/npm/docs/output/commands/npm-team.html b/deps/npm/docs/output/commands/npm-team.html index 61767122694..7835bfbd2ba 100644 --- a/deps/npm/docs/output/commands/npm-team.html +++ b/deps/npm/docs/output/commands/npm-team.html @@ -186,9 +186,9 @@
                -

                +

                npm-team - @11.21.2 + @11.21.3

                Manage organization teams and team memberships
                diff --git a/deps/npm/docs/output/commands/npm-test.html b/deps/npm/docs/output/commands/npm-test.html index 137f2279d0a..abce2776f2b 100644 --- a/deps/npm/docs/output/commands/npm-test.html +++ b/deps/npm/docs/output/commands/npm-test.html @@ -186,9 +186,9 @@
                -

                +

                npm-test - @11.21.2 + @11.21.3

                Test a package
                diff --git a/deps/npm/docs/output/commands/npm-token.html b/deps/npm/docs/output/commands/npm-token.html index b499c363b12..4705c449395 100644 --- a/deps/npm/docs/output/commands/npm-token.html +++ b/deps/npm/docs/output/commands/npm-token.html @@ -186,9 +186,9 @@
                -

                +

                npm-token - @11.21.2 + @11.21.3

                Manage your authentication tokens
                diff --git a/deps/npm/docs/output/commands/npm-trust.html b/deps/npm/docs/output/commands/npm-trust.html index c86b8052fc9..0c0de1c5aaa 100644 --- a/deps/npm/docs/output/commands/npm-trust.html +++ b/deps/npm/docs/output/commands/npm-trust.html @@ -186,9 +186,9 @@
                -

                +

                npm-trust - @11.21.2 + @11.21.3

                Manage trusted publishing relationships between packages and CI/CD providers
                diff --git a/deps/npm/docs/output/commands/npm-undeprecate.html b/deps/npm/docs/output/commands/npm-undeprecate.html index 7d5033e57bb..3261538cd63 100644 --- a/deps/npm/docs/output/commands/npm-undeprecate.html +++ b/deps/npm/docs/output/commands/npm-undeprecate.html @@ -186,9 +186,9 @@
                -

                +

                npm-undeprecate - @11.21.2 + @11.21.3

                Undeprecate a version of a package
                diff --git a/deps/npm/docs/output/commands/npm-uninstall.html b/deps/npm/docs/output/commands/npm-uninstall.html index c01ed879ceb..d15bcedb8f4 100644 --- a/deps/npm/docs/output/commands/npm-uninstall.html +++ b/deps/npm/docs/output/commands/npm-uninstall.html @@ -186,9 +186,9 @@
                -

                +

                npm-uninstall - @11.21.2 + @11.21.3

                Remove a package
                diff --git a/deps/npm/docs/output/commands/npm-unpublish.html b/deps/npm/docs/output/commands/npm-unpublish.html index 35143300873..10e7a2dc7cb 100644 --- a/deps/npm/docs/output/commands/npm-unpublish.html +++ b/deps/npm/docs/output/commands/npm-unpublish.html @@ -186,9 +186,9 @@
                -

                +

                npm-unpublish - @11.21.2 + @11.21.3

                Remove a package from the registry
                diff --git a/deps/npm/docs/output/commands/npm-unstar.html b/deps/npm/docs/output/commands/npm-unstar.html index 7143910a99e..b157b9c86a0 100644 --- a/deps/npm/docs/output/commands/npm-unstar.html +++ b/deps/npm/docs/output/commands/npm-unstar.html @@ -186,9 +186,9 @@
                -

                +

                npm-unstar - @11.21.2 + @11.21.3

                Remove an item from your favorite packages
                diff --git a/deps/npm/docs/output/commands/npm-update.html b/deps/npm/docs/output/commands/npm-update.html index c0ed8d2107c..85e25f86dfa 100644 --- a/deps/npm/docs/output/commands/npm-update.html +++ b/deps/npm/docs/output/commands/npm-update.html @@ -186,9 +186,9 @@
                -

                +

                npm-update - @11.21.2 + @11.21.3

                Update packages
                @@ -446,6 +446,10 @@

                strict-allow-scripts

                Optional dependencies that cannot be installed on the current platform or engine (a non-matching os, cpu, or libc) are not flagged, because their install scripts never run.

                +

                Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. npm rebuild and npm install-scripts ls still check unused +packages on disk.

                dangerously-allow-all-scripts

                • Default: false
                • diff --git a/deps/npm/docs/output/commands/npm-version.html b/deps/npm/docs/output/commands/npm-version.html index 58cfc01644c..350a2f53189 100644 --- a/deps/npm/docs/output/commands/npm-version.html +++ b/deps/npm/docs/output/commands/npm-version.html @@ -186,9 +186,9 @@
                  -

                  +

                  npm-version - @11.21.2 + @11.21.3

                  Bump a package version
                  diff --git a/deps/npm/docs/output/commands/npm-view.html b/deps/npm/docs/output/commands/npm-view.html index 510ffb92a0e..0fbc9d05e2b 100644 --- a/deps/npm/docs/output/commands/npm-view.html +++ b/deps/npm/docs/output/commands/npm-view.html @@ -186,9 +186,9 @@
                  -

                  +

                  npm-view - @11.21.2 + @11.21.3

                  View registry info
                  diff --git a/deps/npm/docs/output/commands/npm-whoami.html b/deps/npm/docs/output/commands/npm-whoami.html index 102c605edce..63d00f931a6 100644 --- a/deps/npm/docs/output/commands/npm-whoami.html +++ b/deps/npm/docs/output/commands/npm-whoami.html @@ -186,9 +186,9 @@
                  -

                  +

                  npm-whoami - @11.21.2 + @11.21.3

                  Display npm username
                  diff --git a/deps/npm/docs/output/commands/npm.html b/deps/npm/docs/output/commands/npm.html index 7f63a2be16d..f2211038663 100644 --- a/deps/npm/docs/output/commands/npm.html +++ b/deps/npm/docs/output/commands/npm.html @@ -186,9 +186,9 @@
                  -

                  +

                  npm - @11.21.2 + @11.21.3

                  javascript package manager
                  @@ -203,7 +203,7 @@

                  Table of contents

              Note: This command is unaware of workspaces.

              Version

              -

              11.21.2

              +

              11.21.3

              Description

              npm is the package manager for the Node JavaScript platform. It puts modules in place so that node can find them, and manages dependency conflicts intelligently.

              diff --git a/deps/npm/docs/output/commands/npx.html b/deps/npm/docs/output/commands/npx.html index b3b0e89ed19..1ab65e625c2 100644 --- a/deps/npm/docs/output/commands/npx.html +++ b/deps/npm/docs/output/commands/npx.html @@ -186,9 +186,9 @@
              -

              +

              npx - @11.21.2 + @11.21.3

              Run a command from a local or remote npm package
              diff --git a/deps/npm/docs/output/configuring-npm/folders.html b/deps/npm/docs/output/configuring-npm/folders.html index c5a561062e5..f9d792e05ed 100644 --- a/deps/npm/docs/output/configuring-npm/folders.html +++ b/deps/npm/docs/output/configuring-npm/folders.html @@ -186,9 +186,9 @@
              -

              +

              Folders - @11.21.2 + @11.21.3

              Folder structures used by npm
              diff --git a/deps/npm/docs/output/configuring-npm/install.html b/deps/npm/docs/output/configuring-npm/install.html index e3d7cf17d6a..23d3877ad07 100644 --- a/deps/npm/docs/output/configuring-npm/install.html +++ b/deps/npm/docs/output/configuring-npm/install.html @@ -186,9 +186,9 @@
              -

              +

              Install - @11.21.2 + @11.21.3

              Download and install node and npm
              diff --git a/deps/npm/docs/output/configuring-npm/npm-global.html b/deps/npm/docs/output/configuring-npm/npm-global.html index c5a561062e5..f9d792e05ed 100644 --- a/deps/npm/docs/output/configuring-npm/npm-global.html +++ b/deps/npm/docs/output/configuring-npm/npm-global.html @@ -186,9 +186,9 @@
              -

              +

              Folders - @11.21.2 + @11.21.3

              Folder structures used by npm
              diff --git a/deps/npm/docs/output/configuring-npm/npm-json.html b/deps/npm/docs/output/configuring-npm/npm-json.html index 517bbe8a44a..db298818a8b 100644 --- a/deps/npm/docs/output/configuring-npm/npm-json.html +++ b/deps/npm/docs/output/configuring-npm/npm-json.html @@ -186,9 +186,9 @@
              -

              +

              package.json - @11.21.2 + @11.21.3

              Specifics of npm's package.json handling
              diff --git a/deps/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html b/deps/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html index ba197a3ed14..8fc700dd563 100644 --- a/deps/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html +++ b/deps/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html @@ -186,9 +186,9 @@
              -

              +

              npm-shrinkwrap.json - @11.21.2 + @11.21.3

              A publishable lockfile
              diff --git a/deps/npm/docs/output/configuring-npm/npmrc.html b/deps/npm/docs/output/configuring-npm/npmrc.html index ac82e59af63..b9a6e43ba04 100644 --- a/deps/npm/docs/output/configuring-npm/npmrc.html +++ b/deps/npm/docs/output/configuring-npm/npmrc.html @@ -186,9 +186,9 @@
              -

              +

              .npmrc - @11.21.2 + @11.21.3

              The npm config files
              diff --git a/deps/npm/docs/output/configuring-npm/package-json.html b/deps/npm/docs/output/configuring-npm/package-json.html index 517bbe8a44a..db298818a8b 100644 --- a/deps/npm/docs/output/configuring-npm/package-json.html +++ b/deps/npm/docs/output/configuring-npm/package-json.html @@ -186,9 +186,9 @@
              -

              +

              package.json - @11.21.2 + @11.21.3

              Specifics of npm's package.json handling
              diff --git a/deps/npm/docs/output/configuring-npm/package-lock-json.html b/deps/npm/docs/output/configuring-npm/package-lock-json.html index 0cb259d286a..107b9bc9ec6 100644 --- a/deps/npm/docs/output/configuring-npm/package-lock-json.html +++ b/deps/npm/docs/output/configuring-npm/package-lock-json.html @@ -186,9 +186,9 @@
              -

              +

              package-lock.json - @11.21.2 + @11.21.3

              A manifestation of the manifest
              diff --git a/deps/npm/docs/output/using-npm/config.html b/deps/npm/docs/output/using-npm/config.html index 0d6ec849317..35a9eae02a1 100644 --- a/deps/npm/docs/output/using-npm/config.html +++ b/deps/npm/docs/output/using-npm/config.html @@ -186,9 +186,9 @@
              -

              +

              Config - @11.21.2 + @11.21.3

              About npm configuration
              @@ -1582,6 +1582,10 @@

              strict-allow-scripts

              Optional dependencies that cannot be installed on the current platform or engine (a non-matching os, cpu, or libc) are not flagged, because their install scripts never run.

              +

              Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. npm rebuild and npm install-scripts ls still check unused +packages on disk.

              strict-peer-deps

              • Default: false
              • diff --git a/deps/npm/docs/output/using-npm/dependency-selectors.html b/deps/npm/docs/output/using-npm/dependency-selectors.html index 94dbed94836..23b45295cd0 100644 --- a/deps/npm/docs/output/using-npm/dependency-selectors.html +++ b/deps/npm/docs/output/using-npm/dependency-selectors.html @@ -186,9 +186,9 @@
                -

                +

                Dependency Selectors - @11.21.2 + @11.21.3

                Dependency Selector Syntax & Querying
                diff --git a/deps/npm/docs/output/using-npm/developers.html b/deps/npm/docs/output/using-npm/developers.html index d9774e68bff..30197d0ef26 100644 --- a/deps/npm/docs/output/using-npm/developers.html +++ b/deps/npm/docs/output/using-npm/developers.html @@ -186,9 +186,9 @@
                -

                +

                Developers - @11.21.2 + @11.21.3

                Developer guide
                diff --git a/deps/npm/docs/output/using-npm/logging.html b/deps/npm/docs/output/using-npm/logging.html index 0d191c03717..3a9e23095e9 100644 --- a/deps/npm/docs/output/using-npm/logging.html +++ b/deps/npm/docs/output/using-npm/logging.html @@ -186,9 +186,9 @@
                -

                +

                Logging - @11.21.2 + @11.21.3

                Why, What & How we Log
                diff --git a/deps/npm/docs/output/using-npm/orgs.html b/deps/npm/docs/output/using-npm/orgs.html index 20f2cb67cd0..514e7e82b92 100644 --- a/deps/npm/docs/output/using-npm/orgs.html +++ b/deps/npm/docs/output/using-npm/orgs.html @@ -186,9 +186,9 @@
                -

                +

                Organizations - @11.21.2 + @11.21.3

                Working with teams & organizations
                diff --git a/deps/npm/docs/output/using-npm/package-spec.html b/deps/npm/docs/output/using-npm/package-spec.html index 0ba71462d0f..cee3f3627d0 100644 --- a/deps/npm/docs/output/using-npm/package-spec.html +++ b/deps/npm/docs/output/using-npm/package-spec.html @@ -186,9 +186,9 @@
                -

                +

                Package spec - @11.21.2 + @11.21.3

                Package name specifier
                diff --git a/deps/npm/docs/output/using-npm/registry.html b/deps/npm/docs/output/using-npm/registry.html index 54d4f433e72..9eb1e6e14c6 100644 --- a/deps/npm/docs/output/using-npm/registry.html +++ b/deps/npm/docs/output/using-npm/registry.html @@ -186,9 +186,9 @@
                -

                +

                Registry - @11.21.2 + @11.21.3

                The JavaScript Package Registry
                diff --git a/deps/npm/docs/output/using-npm/removal.html b/deps/npm/docs/output/using-npm/removal.html index b058622923a..957e04a6b71 100644 --- a/deps/npm/docs/output/using-npm/removal.html +++ b/deps/npm/docs/output/using-npm/removal.html @@ -186,9 +186,9 @@
                -

                +

                Removal - @11.21.2 + @11.21.3

                Cleaning the slate
                diff --git a/deps/npm/docs/output/using-npm/scope.html b/deps/npm/docs/output/using-npm/scope.html index 81dcafdb276..53302fce17c 100644 --- a/deps/npm/docs/output/using-npm/scope.html +++ b/deps/npm/docs/output/using-npm/scope.html @@ -186,9 +186,9 @@
                -

                +

                Scope - @11.21.2 + @11.21.3

                Scoped packages
                diff --git a/deps/npm/docs/output/using-npm/scripts.html b/deps/npm/docs/output/using-npm/scripts.html index c0d35eceb43..57f8c539900 100644 --- a/deps/npm/docs/output/using-npm/scripts.html +++ b/deps/npm/docs/output/using-npm/scripts.html @@ -186,9 +186,9 @@
                -

                +

                Scripts - @11.21.2 + @11.21.3

                How npm handles the "scripts" field
                diff --git a/deps/npm/docs/output/using-npm/workspaces.html b/deps/npm/docs/output/using-npm/workspaces.html index c5ce10d261a..c0e2b77c622 100644 --- a/deps/npm/docs/output/using-npm/workspaces.html +++ b/deps/npm/docs/output/using-npm/workspaces.html @@ -186,9 +186,9 @@
                -

                +

                Workspaces - @11.21.2 + @11.21.3

                Working with workspaces
                diff --git a/deps/npm/lib/utils/check-allow-scripts.js b/deps/npm/lib/utils/check-allow-scripts.js index 47984803cde..352f8e7cb9b 100644 --- a/deps/npm/lib/utils/check-allow-scripts.js +++ b/deps/npm/lib/utils/check-allow-scripts.js @@ -15,13 +15,20 @@ const { collectUnreviewedScripts } = require('@npmcli/arborist/lib/unreviewed-sc // `includeWhenIgnored` keeps listing unreviewed packages even when // ignore-scripts is set, so approve/deny can show what you'd move from a // blanket ignore-scripts to an allowlist. Execution callers leave it false. -const checkAllowScripts = async ({ arb, npm, tree, includeWhenIgnored = false }) => +const checkAllowScripts = async ({ + arb, + npm, + tree, + includeWhenIgnored = false, + skipExtraneous = false, +}) => collectUnreviewedScripts({ tree: tree || arb.actualTree, policy: arb.options?.allowScripts || null, ignoreScripts: !!arb.options?.ignoreScripts, dangerouslyAllowAllScripts: !!npm?.flatOptions?.dangerouslyAllowAllScripts, includeWhenIgnored, + skipExtraneous, }) module.exports = checkAllowScripts diff --git a/deps/npm/lib/utils/is-windows.js b/deps/npm/lib/utils/is-windows.js index 63c5671d840..d4513e3e98e 100644 --- a/deps/npm/lib/utils/is-windows.js +++ b/deps/npm/lib/utils/is-windows.js @@ -1,4 +1,8 @@ +const isGitBashMsystem = (msystem) => + /^(MINGW(32|64)|UCRT64|CLANG(32|64|ARM64))$/.test(msystem || '') + const isWindowsShell = (process.platform === 'win32') && - !/^MINGW(32|64)$/.test(process.env.MSYSTEM) && process.env.TERM !== 'cygwin' + !isGitBashMsystem(process.env.MSYSTEM) && process.env.TERM !== 'cygwin' exports.isWindowsShell = isWindowsShell +exports.isGitBashMsystem = isGitBashMsystem diff --git a/deps/npm/lib/utils/reify-finish.js b/deps/npm/lib/utils/reify-finish.js index 1041c53fdb9..0278f9b5919 100644 --- a/deps/npm/lib/utils/reify-finish.js +++ b/deps/npm/lib/utils/reify-finish.js @@ -18,7 +18,7 @@ const reifyFinish = async (npm, arb) => { } } warnWorkspaceAllowScripts(arb.actualTree) - const unreviewedScripts = await checkAllowScripts({ arb, npm }) + const unreviewedScripts = await checkAllowScripts({ arb, npm, skipExtraneous: true }) reifyOutput(npm, arb, { unreviewedScripts }) } diff --git a/deps/npm/lib/utils/strict-allow-scripts-preflight.js b/deps/npm/lib/utils/strict-allow-scripts-preflight.js index 0c500018184..2bb5ceb6d9d 100644 --- a/deps/npm/lib/utils/strict-allow-scripts-preflight.js +++ b/deps/npm/lib/utils/strict-allow-scripts-preflight.js @@ -33,7 +33,12 @@ const strictAllowScriptsPreflight = async ({ arb, npm, idealTreeOpts }) => { tree = arb.actualTree } - const unreviewed = await checkAllowScripts({ arb, npm, tree }) + const unreviewed = await checkAllowScripts({ + arb, + npm, + tree, + skipExtraneous: idealTreeOpts !== undefined, + }) if (unreviewed.length === 0) { return } diff --git a/deps/npm/man/man1/npm-access.1 b/deps/npm/man/man1/npm-access.1 index ceb3f6c17fa..34cac3a2225 100644 --- a/deps/npm/man/man1/npm-access.1 +++ b/deps/npm/man/man1/npm-access.1 @@ -1,4 +1,4 @@ -.TH "NPM-ACCESS" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-ACCESS" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-access\fR - Set access level on published packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-adduser.1 b/deps/npm/man/man1/npm-adduser.1 index cf798639583..112d3b2cbeb 100644 --- a/deps/npm/man/man1/npm-adduser.1 +++ b/deps/npm/man/man1/npm-adduser.1 @@ -1,4 +1,4 @@ -.TH "NPM-ADDUSER" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-ADDUSER" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-adduser\fR - Add a registry user account .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-approve-scripts.1 b/deps/npm/man/man1/npm-approve-scripts.1 index dedc97ea43f..061f9bc8e44 100644 --- a/deps/npm/man/man1/npm-approve-scripts.1 +++ b/deps/npm/man/man1/npm-approve-scripts.1 @@ -1,4 +1,4 @@ -.TH "NPM-APPROVE-SCRIPTS" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-APPROVE-SCRIPTS" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-approve-scripts\fR - Approve install scripts for specific dependencies .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-audit.1 b/deps/npm/man/man1/npm-audit.1 index f849ab67df2..f54c1395a0f 100644 --- a/deps/npm/man/man1/npm-audit.1 +++ b/deps/npm/man/man1/npm-audit.1 @@ -1,4 +1,4 @@ -.TH "NPM-AUDIT" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-AUDIT" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-audit\fR - Run a security audit .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-bugs.1 b/deps/npm/man/man1/npm-bugs.1 index 666d56f830a..ed3d0ed68d9 100644 --- a/deps/npm/man/man1/npm-bugs.1 +++ b/deps/npm/man/man1/npm-bugs.1 @@ -1,4 +1,4 @@ -.TH "NPM-BUGS" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-BUGS" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-bugs\fR - Report bugs for a package in a web browser .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-cache.1 b/deps/npm/man/man1/npm-cache.1 index e31c02d0197..e0151029882 100644 --- a/deps/npm/man/man1/npm-cache.1 +++ b/deps/npm/man/man1/npm-cache.1 @@ -1,4 +1,4 @@ -.TH "NPM-CACHE" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-CACHE" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-cache\fR - Manipulates packages cache .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-ci.1 b/deps/npm/man/man1/npm-ci.1 index 9c9d0a3fb1a..1a431b75de9 100644 --- a/deps/npm/man/man1/npm-ci.1 +++ b/deps/npm/man/man1/npm-ci.1 @@ -1,4 +1,4 @@ -.TH "NPM-CI" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-CI" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-ci\fR - Clean install a project .SS "Synopsis" @@ -248,6 +248,8 @@ If \fBtrue\fR, turn the install-script policy from a warning into a hard error: Dependencies explicitly denied with \fBfalse\fR in \fBallowScripts\fR are always silently skipped; this setting only affects unreviewed entries. \fB--ignore-scripts\fR and \fB--dangerously-allow-all-scripts\fR both override this setting. .P Optional dependencies that cannot be installed on the current platform or engine (a non-matching \fBos\fR, \fBcpu\fR, or \fBlibc\fR) are not flagged, because their install scripts never run. +.P +Installation checks skip unused entries with no package parent or incoming links. Local link targets that installation can still rebuild remain subject to this check. \fBnpm rebuild\fR and \fBnpm install-scripts ls\fR still check unused packages on disk. .SS "\fBdangerously-allow-all-scripts\fR" .RS 0 .IP \(bu 4 diff --git a/deps/npm/man/man1/npm-completion.1 b/deps/npm/man/man1/npm-completion.1 index efd483b409d..f3e1f52511e 100644 --- a/deps/npm/man/man1/npm-completion.1 +++ b/deps/npm/man/man1/npm-completion.1 @@ -1,4 +1,4 @@ -.TH "NPM-COMPLETION" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-COMPLETION" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-completion\fR - Tab Completion for npm .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-config.1 b/deps/npm/man/man1/npm-config.1 index 976fc2f6d8b..ac70b0574a5 100644 --- a/deps/npm/man/man1/npm-config.1 +++ b/deps/npm/man/man1/npm-config.1 @@ -1,4 +1,4 @@ -.TH "NPM-CONFIG" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-CONFIG" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-config\fR - Manage the npm configuration files .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-dedupe.1 b/deps/npm/man/man1/npm-dedupe.1 index a49b48681de..43bc3be38e2 100644 --- a/deps/npm/man/man1/npm-dedupe.1 +++ b/deps/npm/man/man1/npm-dedupe.1 @@ -1,4 +1,4 @@ -.TH "NPM-DEDUPE" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-DEDUPE" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-dedupe\fR - Reduce duplication in the package tree .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-deny-scripts.1 b/deps/npm/man/man1/npm-deny-scripts.1 index 826b8ca1333..e49b468b6b3 100644 --- a/deps/npm/man/man1/npm-deny-scripts.1 +++ b/deps/npm/man/man1/npm-deny-scripts.1 @@ -1,4 +1,4 @@ -.TH "NPM-DENY-SCRIPTS" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-DENY-SCRIPTS" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-deny-scripts\fR - Deny install scripts for specific dependencies .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-deprecate.1 b/deps/npm/man/man1/npm-deprecate.1 index 0aa94ec5898..028ea812a80 100644 --- a/deps/npm/man/man1/npm-deprecate.1 +++ b/deps/npm/man/man1/npm-deprecate.1 @@ -1,4 +1,4 @@ -.TH "NPM-DEPRECATE" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-DEPRECATE" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-deprecate\fR - Deprecate a version of a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-diff.1 b/deps/npm/man/man1/npm-diff.1 index 777fe47a026..82cf087543b 100644 --- a/deps/npm/man/man1/npm-diff.1 +++ b/deps/npm/man/man1/npm-diff.1 @@ -1,4 +1,4 @@ -.TH "NPM-DIFF" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-DIFF" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-diff\fR - The registry diff command .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-dist-tag.1 b/deps/npm/man/man1/npm-dist-tag.1 index 37c86f432d9..b3ef496f6d1 100644 --- a/deps/npm/man/man1/npm-dist-tag.1 +++ b/deps/npm/man/man1/npm-dist-tag.1 @@ -1,4 +1,4 @@ -.TH "NPM-DIST-TAG" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-DIST-TAG" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-dist-tag\fR - Modify package distribution tags .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-docs.1 b/deps/npm/man/man1/npm-docs.1 index 50e31e8735a..b086a8860c1 100644 --- a/deps/npm/man/man1/npm-docs.1 +++ b/deps/npm/man/man1/npm-docs.1 @@ -1,4 +1,4 @@ -.TH "NPM-DOCS" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-DOCS" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-docs\fR - Open documentation for a package in a web browser .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-doctor.1 b/deps/npm/man/man1/npm-doctor.1 index 8ef2fa2ad59..b302a7498d5 100644 --- a/deps/npm/man/man1/npm-doctor.1 +++ b/deps/npm/man/man1/npm-doctor.1 @@ -1,4 +1,4 @@ -.TH "NPM-DOCTOR" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-DOCTOR" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-doctor\fR - Check the health of your npm environment .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-edit.1 b/deps/npm/man/man1/npm-edit.1 index 8f1a7dfcb89..87fa7f57cef 100644 --- a/deps/npm/man/man1/npm-edit.1 +++ b/deps/npm/man/man1/npm-edit.1 @@ -1,4 +1,4 @@ -.TH "NPM-EDIT" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-EDIT" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-edit\fR - Edit an installed package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-exec.1 b/deps/npm/man/man1/npm-exec.1 index dc36459b4d5..e424dbf7782 100644 --- a/deps/npm/man/man1/npm-exec.1 +++ b/deps/npm/man/man1/npm-exec.1 @@ -1,4 +1,4 @@ -.TH "NPM-EXEC" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-EXEC" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-exec\fR - Run a command from a local or remote npm package .SS "Synopsis" @@ -197,6 +197,8 @@ If \fBtrue\fR, turn the install-script policy from a warning into a hard error: Dependencies explicitly denied with \fBfalse\fR in \fBallowScripts\fR are always silently skipped; this setting only affects unreviewed entries. \fB--ignore-scripts\fR and \fB--dangerously-allow-all-scripts\fR both override this setting. .P Optional dependencies that cannot be installed on the current platform or engine (a non-matching \fBos\fR, \fBcpu\fR, or \fBlibc\fR) are not flagged, because their install scripts never run. +.P +Installation checks skip unused entries with no package parent or incoming links. Local link targets that installation can still rebuild remain subject to this check. \fBnpm rebuild\fR and \fBnpm install-scripts ls\fR still check unused packages on disk. .SS "\fBdangerously-allow-all-scripts\fR" .RS 0 .IP \(bu 4 diff --git a/deps/npm/man/man1/npm-explain.1 b/deps/npm/man/man1/npm-explain.1 index 069fcd70580..59f47d75022 100644 --- a/deps/npm/man/man1/npm-explain.1 +++ b/deps/npm/man/man1/npm-explain.1 @@ -1,4 +1,4 @@ -.TH "NPM-EXPLAIN" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-EXPLAIN" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-explain\fR - Explain installed packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-explore.1 b/deps/npm/man/man1/npm-explore.1 index 341994714fa..c8351dbba46 100644 --- a/deps/npm/man/man1/npm-explore.1 +++ b/deps/npm/man/man1/npm-explore.1 @@ -1,4 +1,4 @@ -.TH "NPM-EXPLORE" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-EXPLORE" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-explore\fR - Browse an installed package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-find-dupes.1 b/deps/npm/man/man1/npm-find-dupes.1 index bafc5d9f549..8302bd62613 100644 --- a/deps/npm/man/man1/npm-find-dupes.1 +++ b/deps/npm/man/man1/npm-find-dupes.1 @@ -1,4 +1,4 @@ -.TH "NPM-FIND-DUPES" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-FIND-DUPES" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-find-dupes\fR - Find duplication in the package tree .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-fund.1 b/deps/npm/man/man1/npm-fund.1 index a3c47fad3b8..bdd805c55c9 100644 --- a/deps/npm/man/man1/npm-fund.1 +++ b/deps/npm/man/man1/npm-fund.1 @@ -1,4 +1,4 @@ -.TH "NPM-FUND" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-FUND" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-fund\fR - Retrieve funding information .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-get.1 b/deps/npm/man/man1/npm-get.1 index 1e3cb0119c9..85db5b5ce84 100644 --- a/deps/npm/man/man1/npm-get.1 +++ b/deps/npm/man/man1/npm-get.1 @@ -1,4 +1,4 @@ -.TH "NPM-GET" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-GET" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-get\fR - Get a value from the npm configuration .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-help-search.1 b/deps/npm/man/man1/npm-help-search.1 index 10eac50e9bb..4120405d386 100644 --- a/deps/npm/man/man1/npm-help-search.1 +++ b/deps/npm/man/man1/npm-help-search.1 @@ -1,4 +1,4 @@ -.TH "NPM-HELP-SEARCH" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-HELP-SEARCH" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-help-search\fR - Search npm help documentation .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-help.1 b/deps/npm/man/man1/npm-help.1 index 221b0526e37..5d96c0a0eb8 100644 --- a/deps/npm/man/man1/npm-help.1 +++ b/deps/npm/man/man1/npm-help.1 @@ -1,4 +1,4 @@ -.TH "NPM-HELP" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-HELP" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-help\fR - Get help on npm .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-init.1 b/deps/npm/man/man1/npm-init.1 index 73ebb727ff5..b8148f84929 100644 --- a/deps/npm/man/man1/npm-init.1 +++ b/deps/npm/man/man1/npm-init.1 @@ -1,4 +1,4 @@ -.TH "NPM-INIT" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-INIT" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-init\fR - Create a package.json file .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-install-ci-test.1 b/deps/npm/man/man1/npm-install-ci-test.1 index 01ea550da99..be5e595cef8 100644 --- a/deps/npm/man/man1/npm-install-ci-test.1 +++ b/deps/npm/man/man1/npm-install-ci-test.1 @@ -1,4 +1,4 @@ -.TH "NPM-INSTALL-CI-TEST" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-INSTALL-CI-TEST" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-install-ci-test\fR - Install a project with a clean slate and run tests .SS "Synopsis" @@ -196,6 +196,8 @@ If \fBtrue\fR, turn the install-script policy from a warning into a hard error: Dependencies explicitly denied with \fBfalse\fR in \fBallowScripts\fR are always silently skipped; this setting only affects unreviewed entries. \fB--ignore-scripts\fR and \fB--dangerously-allow-all-scripts\fR both override this setting. .P Optional dependencies that cannot be installed on the current platform or engine (a non-matching \fBos\fR, \fBcpu\fR, or \fBlibc\fR) are not flagged, because their install scripts never run. +.P +Installation checks skip unused entries with no package parent or incoming links. Local link targets that installation can still rebuild remain subject to this check. \fBnpm rebuild\fR and \fBnpm install-scripts ls\fR still check unused packages on disk. .SS "\fBdangerously-allow-all-scripts\fR" .RS 0 .IP \(bu 4 diff --git a/deps/npm/man/man1/npm-install-scripts.1 b/deps/npm/man/man1/npm-install-scripts.1 index 1de6e2c71ef..48b71d548b2 100644 --- a/deps/npm/man/man1/npm-install-scripts.1 +++ b/deps/npm/man/man1/npm-install-scripts.1 @@ -1,4 +1,4 @@ -.TH "NPM-INSTALL-SCRIPTS" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-INSTALL-SCRIPTS" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-install-scripts\fR - Manage install-script approvals for dependencies .SS "Synopsis" @@ -19,7 +19,7 @@ Note: This command is unaware of workspaces. .P Manages the \fBallowScripts\fR field in your project's \fBpackage.json\fR, which records which of your dependencies are permitted to run install scripts (\fBpreinstall\fR, \fBinstall\fR, \fBpostinstall\fR, and \fBprepare\fR for non-registry sources). This is the recommended way to maintain that field. .P -Dependency install scripts are blocked by default. Install commands silently skip lifecycle scripts for any dependency that does not have a matching entry in \fBallowScripts\fR, and end with a list of the packages whose scripts were skipped so you can review them here. +Dependency install scripts are blocked by default. Install commands silently skip lifecycle scripts for any dependency that does not have a matching entry in \fBallowScripts\fR, and end with a list of the packages whose scripts were skipped so you can review them here. These warnings omit disconnected unused entries that installation cannot build. Local link targets that can still be rebuilt remain subject to the policy. .P This command only works inside a project that has a \fBpackage.json\fR. Running it with \fB--global\fR (\fB-g\fR) fails with an \fBEGLOBAL\fR error, since global installs (\fBnpm install -g\fR) and one-off executions (\fBnpm exec\fR / \fBnpx\fR) have no project \fBpackage.json\fR to write to. To allow install scripts in those contexts, use the \fB--allow-scripts\fR flag at install time (for example \fBnpm install -g --allow-scripts=canvas,sharp\fR) or persist the setting with \fBnpm config set allow-scripts=canvas,sharp --location=user\fR. .P @@ -40,7 +40,7 @@ npm install-scripts prune .P \fBdeny\fR records an explicit denial for the named packages (a name-only \fBfalse\fR entry), which survives \fBnpm install-scripts approve --all\fR and excludes the package from any future blanket approval. \fB--all\fR denies every package with unreviewed install scripts. .P -\fBls\fR is read-only: it lists every package whose install scripts are not yet covered by \fBallowScripts\fR, without modifying \fBpackage.json\fR. +\fBls\fR is read-only: it lists every package whose install scripts are not yet covered by \fBallowScripts\fR, without modifying \fBpackage.json\fR. This includes unreviewed extraneous packages, which are installed but not required by any dependency. These packages can still cause \fBnpm rebuild --strict-allow-scripts\fR to fail. .P \fBprune\fR removes \fBallowScripts\fR entries that no longer match an installed package with an install script, either because the package is no longer installed (a transitive dependency changed, or a pinned \fBpkg@1.2.3\fR was upgraded) or because it no longer has an install script. Both approvals (\fBtrue\fR) and denials (\fBfalse\fR) are removed. It edits only the \fBallowScripts\fR field in \fBpackage.json\fR, never \fB.npmrc\fR or \fB--allow-scripts\fR. Pass \fB--dry-run\fR to preview without writing. Unparseable keys are left alone. .P diff --git a/deps/npm/man/man1/npm-install-test.1 b/deps/npm/man/man1/npm-install-test.1 index fb7f6ad652d..442dcadb4a3 100644 --- a/deps/npm/man/man1/npm-install-test.1 +++ b/deps/npm/man/man1/npm-install-test.1 @@ -1,4 +1,4 @@ -.TH "NPM-INSTALL-TEST" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-INSTALL-TEST" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-install-test\fR - Install package(s) and run tests .SS "Synopsis" @@ -273,6 +273,8 @@ If \fBtrue\fR, turn the install-script policy from a warning into a hard error: Dependencies explicitly denied with \fBfalse\fR in \fBallowScripts\fR are always silently skipped; this setting only affects unreviewed entries. \fB--ignore-scripts\fR and \fB--dangerously-allow-all-scripts\fR both override this setting. .P Optional dependencies that cannot be installed on the current platform or engine (a non-matching \fBos\fR, \fBcpu\fR, or \fBlibc\fR) are not flagged, because their install scripts never run. +.P +Installation checks skip unused entries with no package parent or incoming links. Local link targets that installation can still rebuild remain subject to this check. \fBnpm rebuild\fR and \fBnpm install-scripts ls\fR still check unused packages on disk. .SS "\fBdangerously-allow-all-scripts\fR" .RS 0 .IP \(bu 4 diff --git a/deps/npm/man/man1/npm-install.1 b/deps/npm/man/man1/npm-install.1 index 6e6b595c5bb..5653ca59854 100644 --- a/deps/npm/man/man1/npm-install.1 +++ b/deps/npm/man/man1/npm-install.1 @@ -1,4 +1,4 @@ -.TH "NPM-INSTALL" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-INSTALL" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-install\fR - Install a package .SS "Synopsis" @@ -663,6 +663,8 @@ If \fBtrue\fR, turn the install-script policy from a warning into a hard error: Dependencies explicitly denied with \fBfalse\fR in \fBallowScripts\fR are always silently skipped; this setting only affects unreviewed entries. \fB--ignore-scripts\fR and \fB--dangerously-allow-all-scripts\fR both override this setting. .P Optional dependencies that cannot be installed on the current platform or engine (a non-matching \fBos\fR, \fBcpu\fR, or \fBlibc\fR) are not flagged, because their install scripts never run. +.P +Installation checks skip unused entries with no package parent or incoming links. Local link targets that installation can still rebuild remain subject to this check. \fBnpm rebuild\fR and \fBnpm install-scripts ls\fR still check unused packages on disk. .SS "\fBdangerously-allow-all-scripts\fR" .RS 0 .IP \(bu 4 diff --git a/deps/npm/man/man1/npm-link.1 b/deps/npm/man/man1/npm-link.1 index 9c884b32fbf..69f4d0b23b4 100644 --- a/deps/npm/man/man1/npm-link.1 +++ b/deps/npm/man/man1/npm-link.1 @@ -1,4 +1,4 @@ -.TH "NPM-LINK" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-LINK" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-link\fR - Symlink a package folder .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-ll.1 b/deps/npm/man/man1/npm-ll.1 index a5794eeb02d..aa12f0678b6 100644 --- a/deps/npm/man/man1/npm-ll.1 +++ b/deps/npm/man/man1/npm-ll.1 @@ -1,4 +1,4 @@ -.TH "NPM-LL" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-LL" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-ll\fR - List installed packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-login.1 b/deps/npm/man/man1/npm-login.1 index 00f30771b59..ada893d5467 100644 --- a/deps/npm/man/man1/npm-login.1 +++ b/deps/npm/man/man1/npm-login.1 @@ -1,4 +1,4 @@ -.TH "NPM-LOGIN" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-LOGIN" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-login\fR - Login to a registry user account .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-logout.1 b/deps/npm/man/man1/npm-logout.1 index 3e7200cc1e9..621a83f1912 100644 --- a/deps/npm/man/man1/npm-logout.1 +++ b/deps/npm/man/man1/npm-logout.1 @@ -1,4 +1,4 @@ -.TH "NPM-LOGOUT" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-LOGOUT" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-logout\fR - Log out of the registry .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-ls.1 b/deps/npm/man/man1/npm-ls.1 index dc12c29f1a0..885580fea61 100644 --- a/deps/npm/man/man1/npm-ls.1 +++ b/deps/npm/man/man1/npm-ls.1 @@ -1,4 +1,4 @@ -.TH "NPM-LS" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-LS" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-ls\fR - List installed packages .SS "Synopsis" @@ -20,7 +20,7 @@ Positional arguments are \fBname@version-range\fR identifiers, which will limit .P .RS 2 .nf -npm@11.21.2 /path/to/npm +npm@11.21.3 /path/to/npm └─┬ init-package-json@0.0.4 └── promzard@0.1.5 .fi diff --git a/deps/npm/man/man1/npm-org.1 b/deps/npm/man/man1/npm-org.1 index 58bea33b5e2..4d56be5d8fb 100644 --- a/deps/npm/man/man1/npm-org.1 +++ b/deps/npm/man/man1/npm-org.1 @@ -1,4 +1,4 @@ -.TH "NPM-ORG" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-ORG" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-org\fR - Manage orgs .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-outdated.1 b/deps/npm/man/man1/npm-outdated.1 index d34c347088f..ac4df353413 100644 --- a/deps/npm/man/man1/npm-outdated.1 +++ b/deps/npm/man/man1/npm-outdated.1 @@ -1,4 +1,4 @@ -.TH "NPM-OUTDATED" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-OUTDATED" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-outdated\fR - Check for outdated packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-owner.1 b/deps/npm/man/man1/npm-owner.1 index d5d234979a8..0324c00f4ae 100644 --- a/deps/npm/man/man1/npm-owner.1 +++ b/deps/npm/man/man1/npm-owner.1 @@ -1,4 +1,4 @@ -.TH "NPM-OWNER" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-OWNER" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-owner\fR - Manage package owners .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-pack.1 b/deps/npm/man/man1/npm-pack.1 index f3a7f77cced..6512293754a 100644 --- a/deps/npm/man/man1/npm-pack.1 +++ b/deps/npm/man/man1/npm-pack.1 @@ -1,4 +1,4 @@ -.TH "NPM-PACK" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-PACK" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-pack\fR - Create a tarball from a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-ping.1 b/deps/npm/man/man1/npm-ping.1 index c6a347a93bb..55e63df73b2 100644 --- a/deps/npm/man/man1/npm-ping.1 +++ b/deps/npm/man/man1/npm-ping.1 @@ -1,4 +1,4 @@ -.TH "NPM-PING" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-PING" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-ping\fR - Ping npm registry .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-pkg.1 b/deps/npm/man/man1/npm-pkg.1 index 05ca067c19c..3ba546d6e69 100644 --- a/deps/npm/man/man1/npm-pkg.1 +++ b/deps/npm/man/man1/npm-pkg.1 @@ -1,4 +1,4 @@ -.TH "NPM-PKG" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-PKG" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-pkg\fR - Manages your package.json .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-prefix.1 b/deps/npm/man/man1/npm-prefix.1 index d257e9ba0aa..f65ff4dc6c9 100644 --- a/deps/npm/man/man1/npm-prefix.1 +++ b/deps/npm/man/man1/npm-prefix.1 @@ -1,4 +1,4 @@ -.TH "NPM-PREFIX" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-PREFIX" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-prefix\fR - Display prefix .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-profile.1 b/deps/npm/man/man1/npm-profile.1 index e60248cdfe2..652683d0295 100644 --- a/deps/npm/man/man1/npm-profile.1 +++ b/deps/npm/man/man1/npm-profile.1 @@ -1,4 +1,4 @@ -.TH "NPM-PROFILE" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-PROFILE" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-profile\fR - Change settings on your registry profile .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-prune.1 b/deps/npm/man/man1/npm-prune.1 index f7f4bf2d695..df30433ad33 100644 --- a/deps/npm/man/man1/npm-prune.1 +++ b/deps/npm/man/man1/npm-prune.1 @@ -1,4 +1,4 @@ -.TH "NPM-PRUNE" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-PRUNE" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-prune\fR - Remove extraneous packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-publish.1 b/deps/npm/man/man1/npm-publish.1 index aad3180fee8..cff3ffabb56 100644 --- a/deps/npm/man/man1/npm-publish.1 +++ b/deps/npm/man/man1/npm-publish.1 @@ -1,4 +1,4 @@ -.TH "NPM-PUBLISH" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-PUBLISH" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-publish\fR - Publish a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-query.1 b/deps/npm/man/man1/npm-query.1 index 62d17dc5dbf..a53dd0bd87d 100644 --- a/deps/npm/man/man1/npm-query.1 +++ b/deps/npm/man/man1/npm-query.1 @@ -1,4 +1,4 @@ -.TH "NPM-QUERY" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-QUERY" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-query\fR - Dependency selector query .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-rebuild.1 b/deps/npm/man/man1/npm-rebuild.1 index e4c818dcff9..75ecff8fd98 100644 --- a/deps/npm/man/man1/npm-rebuild.1 +++ b/deps/npm/man/man1/npm-rebuild.1 @@ -1,4 +1,4 @@ -.TH "NPM-REBUILD" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-REBUILD" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-rebuild\fR - Rebuild a package .SS "Synopsis" @@ -131,6 +131,8 @@ If \fBtrue\fR, turn the install-script policy from a warning into a hard error: Dependencies explicitly denied with \fBfalse\fR in \fBallowScripts\fR are always silently skipped; this setting only affects unreviewed entries. \fB--ignore-scripts\fR and \fB--dangerously-allow-all-scripts\fR both override this setting. .P Optional dependencies that cannot be installed on the current platform or engine (a non-matching \fBos\fR, \fBcpu\fR, or \fBlibc\fR) are not flagged, because their install scripts never run. +.P +Installation checks skip unused entries with no package parent or incoming links. Local link targets that installation can still rebuild remain subject to this check. \fBnpm rebuild\fR and \fBnpm install-scripts ls\fR still check unused packages on disk. .SS "\fBdangerously-allow-all-scripts\fR" .RS 0 .IP \(bu 4 diff --git a/deps/npm/man/man1/npm-repo.1 b/deps/npm/man/man1/npm-repo.1 index 64fb13ad727..e73d0c8b621 100644 --- a/deps/npm/man/man1/npm-repo.1 +++ b/deps/npm/man/man1/npm-repo.1 @@ -1,4 +1,4 @@ -.TH "NPM-REPO" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-REPO" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-repo\fR - Open package repository page in the browser .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-restart.1 b/deps/npm/man/man1/npm-restart.1 index 6b7333de08e..7048a770622 100644 --- a/deps/npm/man/man1/npm-restart.1 +++ b/deps/npm/man/man1/npm-restart.1 @@ -1,4 +1,4 @@ -.TH "NPM-RESTART" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-RESTART" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-restart\fR - Restart a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-root.1 b/deps/npm/man/man1/npm-root.1 index e43130a5de0..77f88c86666 100644 --- a/deps/npm/man/man1/npm-root.1 +++ b/deps/npm/man/man1/npm-root.1 @@ -1,4 +1,4 @@ -.TH "NPM-ROOT" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-ROOT" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-root\fR - Display npm root .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-run.1 b/deps/npm/man/man1/npm-run.1 index 44a0a413945..c1f3e43ff1b 100644 --- a/deps/npm/man/man1/npm-run.1 +++ b/deps/npm/man/man1/npm-run.1 @@ -1,4 +1,4 @@ -.TH "NPM-RUN" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-RUN" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-run\fR - Run arbitrary package scripts .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-sbom.1 b/deps/npm/man/man1/npm-sbom.1 index 977e99d3680..278fa508500 100644 --- a/deps/npm/man/man1/npm-sbom.1 +++ b/deps/npm/man/man1/npm-sbom.1 @@ -1,4 +1,4 @@ -.TH "NPM-SBOM" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-SBOM" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-sbom\fR - Generate a Software Bill of Materials (SBOM) .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-search.1 b/deps/npm/man/man1/npm-search.1 index fdf8b0d9d4b..df6e7af559c 100644 --- a/deps/npm/man/man1/npm-search.1 +++ b/deps/npm/man/man1/npm-search.1 @@ -1,4 +1,4 @@ -.TH "NPM-SEARCH" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-SEARCH" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-search\fR - Search for packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-set.1 b/deps/npm/man/man1/npm-set.1 index 98aa226928e..3df624a19b8 100644 --- a/deps/npm/man/man1/npm-set.1 +++ b/deps/npm/man/man1/npm-set.1 @@ -1,4 +1,4 @@ -.TH "NPM-SET" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-SET" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-set\fR - Set a value in the npm configuration .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-shrinkwrap.1 b/deps/npm/man/man1/npm-shrinkwrap.1 index 10b329ad53f..cc16d262f34 100644 --- a/deps/npm/man/man1/npm-shrinkwrap.1 +++ b/deps/npm/man/man1/npm-shrinkwrap.1 @@ -1,4 +1,4 @@ -.TH "NPM-SHRINKWRAP" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-SHRINKWRAP" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-shrinkwrap\fR - Lock down dependency versions for publication .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-stage.1 b/deps/npm/man/man1/npm-stage.1 index e7f5ee6dabd..a898f6eca68 100644 --- a/deps/npm/man/man1/npm-stage.1 +++ b/deps/npm/man/man1/npm-stage.1 @@ -1,4 +1,4 @@ -.TH "NPM-STAGE" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-STAGE" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-stage\fR - Stage packages for publishing .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-star.1 b/deps/npm/man/man1/npm-star.1 index cfe66082f5d..5c91e1f9d26 100644 --- a/deps/npm/man/man1/npm-star.1 +++ b/deps/npm/man/man1/npm-star.1 @@ -1,4 +1,4 @@ -.TH "NPM-STAR" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-STAR" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-star\fR - Mark your favorite packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-stars.1 b/deps/npm/man/man1/npm-stars.1 index 3edd9394710..23eb0d326c1 100644 --- a/deps/npm/man/man1/npm-stars.1 +++ b/deps/npm/man/man1/npm-stars.1 @@ -1,4 +1,4 @@ -.TH "NPM-STARS" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-STARS" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-stars\fR - View packages marked as favorites .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-start.1 b/deps/npm/man/man1/npm-start.1 index 482e12f920b..e0c230d73c9 100644 --- a/deps/npm/man/man1/npm-start.1 +++ b/deps/npm/man/man1/npm-start.1 @@ -1,4 +1,4 @@ -.TH "NPM-START" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-START" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-start\fR - Start a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-stop.1 b/deps/npm/man/man1/npm-stop.1 index 28b9dcca489..dc3a4b6cca1 100644 --- a/deps/npm/man/man1/npm-stop.1 +++ b/deps/npm/man/man1/npm-stop.1 @@ -1,4 +1,4 @@ -.TH "NPM-STOP" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-STOP" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-stop\fR - Stop a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-team.1 b/deps/npm/man/man1/npm-team.1 index 0fbcab4e8cf..90abddd6c66 100644 --- a/deps/npm/man/man1/npm-team.1 +++ b/deps/npm/man/man1/npm-team.1 @@ -1,4 +1,4 @@ -.TH "NPM-TEAM" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-TEAM" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-team\fR - Manage organization teams and team memberships .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-test.1 b/deps/npm/man/man1/npm-test.1 index 5d7fce9ea53..c0ce3827d06 100644 --- a/deps/npm/man/man1/npm-test.1 +++ b/deps/npm/man/man1/npm-test.1 @@ -1,4 +1,4 @@ -.TH "NPM-TEST" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-TEST" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-test\fR - Test a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-token.1 b/deps/npm/man/man1/npm-token.1 index 6b8b7f1432b..a3a6e5da7c2 100644 --- a/deps/npm/man/man1/npm-token.1 +++ b/deps/npm/man/man1/npm-token.1 @@ -1,4 +1,4 @@ -.TH "NPM-TOKEN" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-TOKEN" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-token\fR - Manage your authentication tokens .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-trust.1 b/deps/npm/man/man1/npm-trust.1 index 49b9493aed9..56ec053e39a 100644 --- a/deps/npm/man/man1/npm-trust.1 +++ b/deps/npm/man/man1/npm-trust.1 @@ -1,4 +1,4 @@ -.TH "NPM-TRUST" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-TRUST" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-trust\fR - Manage trusted publishing relationships between packages and CI/CD providers .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-undeprecate.1 b/deps/npm/man/man1/npm-undeprecate.1 index dcede198e83..d95e13c61a7 100644 --- a/deps/npm/man/man1/npm-undeprecate.1 +++ b/deps/npm/man/man1/npm-undeprecate.1 @@ -1,4 +1,4 @@ -.TH "NPM-UNDEPRECATE" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-UNDEPRECATE" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-undeprecate\fR - Undeprecate a version of a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-uninstall.1 b/deps/npm/man/man1/npm-uninstall.1 index 5be1016a76e..4e0d712b514 100644 --- a/deps/npm/man/man1/npm-uninstall.1 +++ b/deps/npm/man/man1/npm-uninstall.1 @@ -1,4 +1,4 @@ -.TH "NPM-UNINSTALL" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-UNINSTALL" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-uninstall\fR - Remove a package .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-unpublish.1 b/deps/npm/man/man1/npm-unpublish.1 index f60f2629ebd..355354c6713 100644 --- a/deps/npm/man/man1/npm-unpublish.1 +++ b/deps/npm/man/man1/npm-unpublish.1 @@ -1,4 +1,4 @@ -.TH "NPM-UNPUBLISH" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-UNPUBLISH" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-unpublish\fR - Remove a package from the registry .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-unstar.1 b/deps/npm/man/man1/npm-unstar.1 index 14c130030cf..fd8fc028a72 100644 --- a/deps/npm/man/man1/npm-unstar.1 +++ b/deps/npm/man/man1/npm-unstar.1 @@ -1,4 +1,4 @@ -.TH "NPM-UNSTAR" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-UNSTAR" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-unstar\fR - Remove an item from your favorite packages .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-update.1 b/deps/npm/man/man1/npm-update.1 index 09149b799a3..f40a209c603 100644 --- a/deps/npm/man/man1/npm-update.1 +++ b/deps/npm/man/man1/npm-update.1 @@ -1,4 +1,4 @@ -.TH "NPM-UPDATE" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-UPDATE" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-update\fR - Update packages .SS "Synopsis" @@ -309,6 +309,8 @@ If \fBtrue\fR, turn the install-script policy from a warning into a hard error: Dependencies explicitly denied with \fBfalse\fR in \fBallowScripts\fR are always silently skipped; this setting only affects unreviewed entries. \fB--ignore-scripts\fR and \fB--dangerously-allow-all-scripts\fR both override this setting. .P Optional dependencies that cannot be installed on the current platform or engine (a non-matching \fBos\fR, \fBcpu\fR, or \fBlibc\fR) are not flagged, because their install scripts never run. +.P +Installation checks skip unused entries with no package parent or incoming links. Local link targets that installation can still rebuild remain subject to this check. \fBnpm rebuild\fR and \fBnpm install-scripts ls\fR still check unused packages on disk. .SS "\fBdangerously-allow-all-scripts\fR" .RS 0 .IP \(bu 4 diff --git a/deps/npm/man/man1/npm-version.1 b/deps/npm/man/man1/npm-version.1 index 099e09b920f..fd16a3e9437 100644 --- a/deps/npm/man/man1/npm-version.1 +++ b/deps/npm/man/man1/npm-version.1 @@ -1,4 +1,4 @@ -.TH "NPM-VERSION" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-VERSION" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-version\fR - Bump a package version .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-view.1 b/deps/npm/man/man1/npm-view.1 index d3ae4185cd1..34bf4231663 100644 --- a/deps/npm/man/man1/npm-view.1 +++ b/deps/npm/man/man1/npm-view.1 @@ -1,4 +1,4 @@ -.TH "NPM-VIEW" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-VIEW" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-view\fR - View registry info .SS "Synopsis" diff --git a/deps/npm/man/man1/npm-whoami.1 b/deps/npm/man/man1/npm-whoami.1 index c3ce1bc97b3..eb4c83c92f8 100644 --- a/deps/npm/man/man1/npm-whoami.1 +++ b/deps/npm/man/man1/npm-whoami.1 @@ -1,4 +1,4 @@ -.TH "NPM-WHOAMI" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM-WHOAMI" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-whoami\fR - Display npm username .SS "Synopsis" diff --git a/deps/npm/man/man1/npm.1 b/deps/npm/man/man1/npm.1 index c8ea8a2cc74..1213da9c6f9 100644 --- a/deps/npm/man/man1/npm.1 +++ b/deps/npm/man/man1/npm.1 @@ -1,4 +1,4 @@ -.TH "NPM" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPM" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm\fR - javascript package manager .SS "Synopsis" @@ -12,7 +12,7 @@ npm Note: This command is unaware of workspaces. .SS "Version" .P -11.21.2 +11.21.3 .SS "Description" .P npm is the package manager for the Node JavaScript platform. It puts modules in place so that node can find them, and manages dependency conflicts intelligently. diff --git a/deps/npm/man/man1/npx.1 b/deps/npm/man/man1/npx.1 index c99e9692469..0ce317b2bee 100644 --- a/deps/npm/man/man1/npx.1 +++ b/deps/npm/man/man1/npx.1 @@ -1,4 +1,4 @@ -.TH "NPX" "1" "November 2026" "NPM@11.21.2" "" +.TH "NPX" "1" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpx\fR - Run a command from a local or remote npm package .SS "Synopsis" diff --git a/deps/npm/man/man5/folders.5 b/deps/npm/man/man5/folders.5 index ecca3409f8d..7ab27ed60a1 100644 --- a/deps/npm/man/man5/folders.5 +++ b/deps/npm/man/man5/folders.5 @@ -1,4 +1,4 @@ -.TH "FOLDERS" "5" "November 2026" "NPM@11.21.2" "" +.TH "FOLDERS" "5" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBFolders\fR - Folder structures used by npm .SS "Description" diff --git a/deps/npm/man/man5/install.5 b/deps/npm/man/man5/install.5 index 9687aa67026..7e7f7262b35 100644 --- a/deps/npm/man/man5/install.5 +++ b/deps/npm/man/man5/install.5 @@ -1,4 +1,4 @@ -.TH "INSTALL" "5" "November 2026" "NPM@11.21.2" "" +.TH "INSTALL" "5" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBInstall\fR - Download and install node and npm .SS "Description" diff --git a/deps/npm/man/man5/npm-global.5 b/deps/npm/man/man5/npm-global.5 index ecca3409f8d..7ab27ed60a1 100644 --- a/deps/npm/man/man5/npm-global.5 +++ b/deps/npm/man/man5/npm-global.5 @@ -1,4 +1,4 @@ -.TH "FOLDERS" "5" "November 2026" "NPM@11.21.2" "" +.TH "FOLDERS" "5" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBFolders\fR - Folder structures used by npm .SS "Description" diff --git a/deps/npm/man/man5/npm-json.5 b/deps/npm/man/man5/npm-json.5 index 639e431c897..68256d7a5a3 100644 --- a/deps/npm/man/man5/npm-json.5 +++ b/deps/npm/man/man5/npm-json.5 @@ -1,4 +1,4 @@ -.TH "PACKAGE.JSON" "5" "November 2026" "NPM@11.21.2" "" +.TH "PACKAGE.JSON" "5" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBpackage.json\fR - Specifics of npm's package.json handling .SS "Description" diff --git a/deps/npm/man/man5/npm-shrinkwrap-json.5 b/deps/npm/man/man5/npm-shrinkwrap-json.5 index d8fae509e4a..9796cfb0a2d 100644 --- a/deps/npm/man/man5/npm-shrinkwrap-json.5 +++ b/deps/npm/man/man5/npm-shrinkwrap-json.5 @@ -1,4 +1,4 @@ -.TH "NPM-SHRINKWRAP.JSON" "5" "November 2026" "NPM@11.21.2" "" +.TH "NPM-SHRINKWRAP.JSON" "5" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBnpm-shrinkwrap.json\fR - A publishable lockfile .SS "Description" diff --git a/deps/npm/man/man5/npmrc.5 b/deps/npm/man/man5/npmrc.5 index 03557880a5e..396c5e23c7f 100644 --- a/deps/npm/man/man5/npmrc.5 +++ b/deps/npm/man/man5/npmrc.5 @@ -1,4 +1,4 @@ -.TH ".NPMRC" "5" "November 2026" "NPM@11.21.2" "" +.TH ".NPMRC" "5" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fB.npmrc\fR - The npm config files .SS "Description" diff --git a/deps/npm/man/man5/package-json.5 b/deps/npm/man/man5/package-json.5 index 639e431c897..68256d7a5a3 100644 --- a/deps/npm/man/man5/package-json.5 +++ b/deps/npm/man/man5/package-json.5 @@ -1,4 +1,4 @@ -.TH "PACKAGE.JSON" "5" "November 2026" "NPM@11.21.2" "" +.TH "PACKAGE.JSON" "5" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBpackage.json\fR - Specifics of npm's package.json handling .SS "Description" diff --git a/deps/npm/man/man5/package-lock-json.5 b/deps/npm/man/man5/package-lock-json.5 index 960fef79eb2..23bf2de201d 100644 --- a/deps/npm/man/man5/package-lock-json.5 +++ b/deps/npm/man/man5/package-lock-json.5 @@ -1,4 +1,4 @@ -.TH "PACKAGE-LOCK.JSON" "5" "November 2026" "NPM@11.21.2" "" +.TH "PACKAGE-LOCK.JSON" "5" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBpackage-lock.json\fR - A manifestation of the manifest .SS "Description" diff --git a/deps/npm/man/man7/config.7 b/deps/npm/man/man7/config.7 index bd5661545e4..154e0bfe349 100644 --- a/deps/npm/man/man7/config.7 +++ b/deps/npm/man/man7/config.7 @@ -1,4 +1,4 @@ -.TH "CONFIG" "7" "November 2026" "NPM@11.21.2" "" +.TH "CONFIG" "7" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBConfig\fR - About npm configuration .SS "Description" @@ -1864,6 +1864,8 @@ If \fBtrue\fR, turn the install-script policy from a warning into a hard error: Dependencies explicitly denied with \fBfalse\fR in \fBallowScripts\fR are always silently skipped; this setting only affects unreviewed entries. \fB--ignore-scripts\fR and \fB--dangerously-allow-all-scripts\fR both override this setting. .P Optional dependencies that cannot be installed on the current platform or engine (a non-matching \fBos\fR, \fBcpu\fR, or \fBlibc\fR) are not flagged, because their install scripts never run. +.P +Installation checks skip unused entries with no package parent or incoming links. Local link targets that installation can still rebuild remain subject to this check. \fBnpm rebuild\fR and \fBnpm install-scripts ls\fR still check unused packages on disk. .SS "\fBstrict-peer-deps\fR" .RS 0 .IP \(bu 4 diff --git a/deps/npm/man/man7/dependency-selectors.7 b/deps/npm/man/man7/dependency-selectors.7 index 5884af196f7..5260f2146dd 100644 --- a/deps/npm/man/man7/dependency-selectors.7 +++ b/deps/npm/man/man7/dependency-selectors.7 @@ -1,4 +1,4 @@ -.TH "SELECTORS" "7" "November 2026" "NPM@11.21.2" "" +.TH "SELECTORS" "7" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBSelectors\fR - Dependency Selector Syntax & Querying .SS "Description" diff --git a/deps/npm/man/man7/developers.7 b/deps/npm/man/man7/developers.7 index 89a7b8e8647..7df710e5d26 100644 --- a/deps/npm/man/man7/developers.7 +++ b/deps/npm/man/man7/developers.7 @@ -1,4 +1,4 @@ -.TH "DEVELOPERS" "7" "November 2026" "NPM@11.21.2" "" +.TH "DEVELOPERS" "7" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBDevelopers\fR - Developer guide .SS "Description" diff --git a/deps/npm/man/man7/logging.7 b/deps/npm/man/man7/logging.7 index a20bb662ed0..e4f095898f6 100644 --- a/deps/npm/man/man7/logging.7 +++ b/deps/npm/man/man7/logging.7 @@ -1,4 +1,4 @@ -.TH "LOGGING" "7" "November 2026" "NPM@11.21.2" "" +.TH "LOGGING" "7" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBLogging\fR - Why, What & How we Log .SS "Description" diff --git a/deps/npm/man/man7/orgs.7 b/deps/npm/man/man7/orgs.7 index 58ad4741081..2ca7cc03d9d 100644 --- a/deps/npm/man/man7/orgs.7 +++ b/deps/npm/man/man7/orgs.7 @@ -1,4 +1,4 @@ -.TH "ORGANIZATIONS" "7" "November 2026" "NPM@11.21.2" "" +.TH "ORGANIZATIONS" "7" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBOrganizations\fR - Working with teams & organizations .SS "Description" diff --git a/deps/npm/man/man7/package-spec.7 b/deps/npm/man/man7/package-spec.7 index 1eda237ed7a..95d275f9973 100644 --- a/deps/npm/man/man7/package-spec.7 +++ b/deps/npm/man/man7/package-spec.7 @@ -1,4 +1,4 @@ -.TH "SPEC" "7" "November 2026" "NPM@11.21.2" "" +.TH "SPEC" "7" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBspec\fR - Package name specifier .SS "Description" diff --git a/deps/npm/man/man7/registry.7 b/deps/npm/man/man7/registry.7 index 1e0ac20aa4a..f19f751e75f 100644 --- a/deps/npm/man/man7/registry.7 +++ b/deps/npm/man/man7/registry.7 @@ -1,4 +1,4 @@ -.TH "REGISTRY" "7" "November 2026" "NPM@11.21.2" "" +.TH "REGISTRY" "7" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBRegistry\fR - The JavaScript Package Registry .SS "Description" diff --git a/deps/npm/man/man7/removal.7 b/deps/npm/man/man7/removal.7 index fa1a46000a0..066ca90db07 100644 --- a/deps/npm/man/man7/removal.7 +++ b/deps/npm/man/man7/removal.7 @@ -1,4 +1,4 @@ -.TH "REMOVAL" "7" "November 2026" "NPM@11.21.2" "" +.TH "REMOVAL" "7" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBRemoval\fR - Cleaning the slate .SS "Synopsis" diff --git a/deps/npm/man/man7/scope.7 b/deps/npm/man/man7/scope.7 index 914ea789118..209b5f0246e 100644 --- a/deps/npm/man/man7/scope.7 +++ b/deps/npm/man/man7/scope.7 @@ -1,4 +1,4 @@ -.TH "SCOPE" "7" "November 2026" "NPM@11.21.2" "" +.TH "SCOPE" "7" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBScope\fR - Scoped packages .SS "Description" diff --git a/deps/npm/man/man7/scripts.7 b/deps/npm/man/man7/scripts.7 index b1b268cc8d1..d69f6decc20 100644 --- a/deps/npm/man/man7/scripts.7 +++ b/deps/npm/man/man7/scripts.7 @@ -1,4 +1,4 @@ -.TH "SCRIPTS" "7" "November 2026" "NPM@11.21.2" "" +.TH "SCRIPTS" "7" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBScripts\fR - How npm handles the "scripts" field .SS "Description" diff --git a/deps/npm/man/man7/workspaces.7 b/deps/npm/man/man7/workspaces.7 index b866bab8d2f..0b138975a32 100644 --- a/deps/npm/man/man7/workspaces.7 +++ b/deps/npm/man/man7/workspaces.7 @@ -1,4 +1,4 @@ -.TH "WORKSPACES" "7" "November 2026" "NPM@11.21.2" "" +.TH "WORKSPACES" "7" "November 2026" "NPM@11.21.3" "" .SH "NAME" \fBWorkspaces\fR - Working with workspaces .SS "Description" diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/arborist/isolated-reifier.js b/deps/npm/node_modules/@npmcli/arborist/lib/arborist/isolated-reifier.js index a07c55e3f28..d919d32bf6d 100644 --- a/deps/npm/node_modules/@npmcli/arborist/lib/arborist/isolated-reifier.js +++ b/deps/npm/node_modules/@npmcli/arborist/lib/arborist/isolated-reifier.js @@ -2,6 +2,7 @@ const { mkdirSync } = require('node:fs') const pacote = require('pacote') const { join } = require('node:path') const { depth } = require('treeverse') +const { getPaths: getBinPaths } = require('bin-links') const crypto = require('node:crypto') const { IsolatedNode, IsolatedLink } = require('../isolated-classes.js') const nameFromFolder = require('@npmcli/name-from-folder') @@ -473,11 +474,12 @@ module.exports = cls => class IsolatedReifier extends cls { return } - if (dep.package.bin) { - for (const bn in dep.package.bin) { - target.binPaths.push(join(dep.root.localPath, nmFolder, '.bin', bn)) - } - } + target.binPaths.push(...getBinPaths({ + pkg: dep.package, + path: join(dep.root.localPath, nmFolder, dep.name), + global: false, + top: false, + })) const pkg = { _id: dep.package._id, diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/case-insensitive-map.js b/deps/npm/node_modules/@npmcli/arborist/lib/case-insensitive-map.js index afc6afbe0f9..63badcecd86 100644 --- a/deps/npm/node_modules/@npmcli/arborist/lib/case-insensitive-map.js +++ b/deps/npm/node_modules/@npmcli/arborist/lib/case-insensitive-map.js @@ -2,6 +2,9 @@ // are case-insensitive and unicode-normalizing, so we need to treat // node.children.get('FOO') and node.children.get('foo') as the same thing. +// ASCII keys without uppercase letters are already normalized. +const needsNormalization = /[A-Z\u0080-\uffff]/ + module.exports = class CIMap extends Map { #keys = new Map() @@ -13,7 +16,7 @@ module.exports = class CIMap extends Map { } #normKey (key) { - if (typeof key !== 'string') { + if (typeof key !== 'string' || !needsNormalization.test(key)) { return key } return key.normalize('NFKD').toLowerCase() diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/edge.js b/deps/npm/node_modules/@npmcli/arborist/lib/edge.js index 83a9c18cb6a..5d6e7d2f83c 100644 --- a/deps/npm/node_modules/@npmcli/arborist/lib/edge.js +++ b/deps/npm/node_modules/@npmcli/arborist/lib/edge.js @@ -108,16 +108,16 @@ class Edge { return false } + // If there's no override we just use the spec. + if (!this.overrides?.keySpec) { + return depValid(node, this.spec, this.#accept, this.#from) + } + // NOTE: this condition means we explicitly do not support overriding // bundled or shrinkwrapped dependencies if (node.hasShrinkwrap || node.inShrinkwrap || node.inBundle) { return depValid(node, this.rawSpec, this.#accept, this.#from) } - - // If there's no override we just use the spec. - if (!this.overrides?.keySpec) { - return depValid(node, this.spec, this.#accept, this.#from) - } // There's some override. If the target node satisfies the overriding spec // then it's okay. if (depValid(node, this.spec, this.#accept, this.#from)) { diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/node.js b/deps/npm/node_modules/@npmcli/arborist/lib/node.js index 87b0ac41740..ee0df01cf4b 100644 --- a/deps/npm/node_modules/@npmcli/arborist/lib/node.js +++ b/deps/npm/node_modules/@npmcli/arborist/lib/node.js @@ -514,20 +514,25 @@ class Node { ) } - getBundler (path = []) { + getBundler (seen = new Set()) { + const isArray = Array.isArray(seen) // made a cycle, definitely not bundled! - if (path.includes(this)) { + if (isArray ? seen.includes(this) : seen.has(this)) { return null } - path.push(this) + if (isArray) { + seen.push(this) + } else { + seen.add(this) + } const parent = this[_parent] if (!parent) { return null } - const pBundler = parent.getBundler(path) + const pBundler = parent.getBundler(seen) if (pBundler) { return pBundler } @@ -544,7 +549,7 @@ class Node { // then they are not bundled. Ie, installing a package with // unmet bundled deps will not cause your deps to be bundled. for (const edge of this.edgesIn) { - const eBundler = edge.from.getBundler(path) + const eBundler = edge.from.getBundler(seen) if (!eBundler) { continue } @@ -1501,6 +1506,11 @@ class Node { } [_reloadNamedEdges] (name, rootLoc = this.location) { + if (!this.edgesOut.size && !this.children.size && !this.fsChildren.size) { + // With no outgoing edges or descendants, there is nothing to refresh or traverse. + return + } + const edge = this.edgesOut.get(name) // if we don't have an edge, do nothing, but keep descending const rootLocResolved = edge && edge.to && diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/unreviewed-scripts.js b/deps/npm/node_modules/@npmcli/arborist/lib/unreviewed-scripts.js index f7bed387845..e30a4540834 100644 --- a/deps/npm/node_modules/@npmcli/arborist/lib/unreviewed-scripts.js +++ b/deps/npm/node_modules/@npmcli/arborist/lib/unreviewed-scripts.js @@ -18,6 +18,7 @@ const collectUnreviewedScripts = async ({ ignoreScripts = false, dangerouslyAllowAllScripts = false, includeWhenIgnored = false, + skipExtraneous = false, } = {}) => { // With ignore-scripts set, no scripts run, so execution callers bail out // here. approve/deny pass includeWhenIgnored so they keep listing @@ -57,6 +58,10 @@ const collectUnreviewedScripts = async ({ // must not be flagged (npm/cli#9562). continue } + if (skipExtraneous && node.extraneous && !node.parent && node.linksIn?.size === 0) { + // Reify never installs disconnected extraneous nodes, so their scripts cannot run. + continue + } const verdict = isScriptAllowed(node, resolvedPolicy) if (verdict === true || verdict === false) { diff --git a/deps/npm/node_modules/@npmcli/arborist/package.json b/deps/npm/node_modules/@npmcli/arborist/package.json index feb07ad86ff..52fcde67069 100644 --- a/deps/npm/node_modules/@npmcli/arborist/package.json +++ b/deps/npm/node_modules/@npmcli/arborist/package.json @@ -1,6 +1,6 @@ { "name": "@npmcli/arborist", - "version": "9.9.3", + "version": "9.9.4", "description": "Manage node_modules trees", "dependencies": { "@gar/promise-retry": "^1.0.0", diff --git a/deps/npm/node_modules/@npmcli/config/lib/definitions/definitions.js b/deps/npm/node_modules/@npmcli/config/lib/definitions/definitions.js index 28be4cbd587..eb20294073a 100644 --- a/deps/npm/node_modules/@npmcli/config/lib/definitions/definitions.js +++ b/deps/npm/node_modules/@npmcli/config/lib/definitions/definitions.js @@ -2399,6 +2399,11 @@ const definitions = { Optional dependencies that cannot be installed on the current platform or engine (a non-matching \`os\`, \`cpu\`, or \`libc\`) are not flagged, because their install scripts never run. + + Installation checks skip unused entries with no package parent or + incoming links. Local link targets that installation can still rebuild + remain subject to this check. \`npm rebuild\` and \`npm install-scripts ls\` + still check unused packages on disk. `, flatten, }), diff --git a/deps/npm/node_modules/@npmcli/config/package.json b/deps/npm/node_modules/@npmcli/config/package.json index 546f7696afa..eaf731c9087 100644 --- a/deps/npm/node_modules/@npmcli/config/package.json +++ b/deps/npm/node_modules/@npmcli/config/package.json @@ -1,6 +1,6 @@ { "name": "@npmcli/config", - "version": "10.14.0", + "version": "10.14.1", "files": [ "bin/", "lib/" diff --git a/deps/npm/node_modules/libnpmdiff/package.json b/deps/npm/node_modules/libnpmdiff/package.json index c94bf2cfd54..b2bf371d4ee 100644 --- a/deps/npm/node_modules/libnpmdiff/package.json +++ b/deps/npm/node_modules/libnpmdiff/package.json @@ -1,6 +1,6 @@ { "name": "libnpmdiff", - "version": "8.1.14", + "version": "8.1.15", "description": "The registry diff", "repository": { "type": "git", @@ -47,7 +47,7 @@ "tap": "^16.3.8" }, "dependencies": { - "@npmcli/arborist": "^9.9.3", + "@npmcli/arborist": "^9.9.4", "@npmcli/installed-package-contents": "^4.0.0", "binary-extensions": "^3.0.0", "diff": "^8.0.2", diff --git a/deps/npm/node_modules/libnpmexec/lib/strict-allow-scripts-preflight.js b/deps/npm/node_modules/libnpmexec/lib/strict-allow-scripts-preflight.js index 579fd0c0fdd..383521fab8f 100644 --- a/deps/npm/node_modules/libnpmexec/lib/strict-allow-scripts-preflight.js +++ b/deps/npm/node_modules/libnpmexec/lib/strict-allow-scripts-preflight.js @@ -24,6 +24,7 @@ const strictAllowScriptsPreflight = async (arb, opts) => { policy: opts.allowScripts || null, ignoreScripts: opts.ignoreScripts, dangerouslyAllowAllScripts: opts.dangerouslyAllowAllScripts, + skipExtraneous: true, }) if (unreviewed.length === 0) { diff --git a/deps/npm/node_modules/libnpmexec/package.json b/deps/npm/node_modules/libnpmexec/package.json index 4a050f2e609..129044a6d92 100644 --- a/deps/npm/node_modules/libnpmexec/package.json +++ b/deps/npm/node_modules/libnpmexec/package.json @@ -1,6 +1,6 @@ { "name": "libnpmexec", - "version": "10.3.5", + "version": "10.3.6", "files": [ "bin/", "lib/" @@ -61,7 +61,7 @@ }, "dependencies": { "@gar/promise-retry": "^1.0.0", - "@npmcli/arborist": "^9.9.3", + "@npmcli/arborist": "^9.9.4", "@npmcli/package-json": "^7.0.0", "@npmcli/run-script": "^10.0.0", "ci-info": "^4.0.0", diff --git a/deps/npm/node_modules/libnpmfund/package.json b/deps/npm/node_modules/libnpmfund/package.json index a11ee6d5b98..b1fadf96153 100644 --- a/deps/npm/node_modules/libnpmfund/package.json +++ b/deps/npm/node_modules/libnpmfund/package.json @@ -1,6 +1,6 @@ { "name": "libnpmfund", - "version": "7.0.28", + "version": "7.0.29", "main": "lib/index.js", "files": [ "bin/", @@ -46,7 +46,7 @@ "tap": "^16.3.8" }, "dependencies": { - "@npmcli/arborist": "^9.9.3" + "@npmcli/arborist": "^9.9.4" }, "engines": { "node": "^20.17.0 || >=22.9.0" diff --git a/deps/npm/node_modules/libnpmpack/package.json b/deps/npm/node_modules/libnpmpack/package.json index e77a05ef6a1..571f1c1a776 100644 --- a/deps/npm/node_modules/libnpmpack/package.json +++ b/deps/npm/node_modules/libnpmpack/package.json @@ -1,6 +1,6 @@ { "name": "libnpmpack", - "version": "9.1.15", + "version": "9.1.16", "description": "Programmatic API for the bits behind npm pack", "author": "GitHub Inc.", "main": "lib/index.js", @@ -37,7 +37,7 @@ "bugs": "https://github.com/npm/libnpmpack/issues", "homepage": "https://npmjs.com/package/libnpmpack", "dependencies": { - "@npmcli/arborist": "^9.9.3", + "@npmcli/arborist": "^9.9.4", "@npmcli/run-script": "^10.0.0", "npm-package-arg": "^13.0.0", "pacote": "^21.0.2" diff --git a/deps/npm/package.json b/deps/npm/package.json index 49b1151d17d..be2e81b600a 100644 --- a/deps/npm/package.json +++ b/deps/npm/package.json @@ -1,5 +1,5 @@ { - "version": "11.21.2", + "version": "11.21.3", "name": "npm", "description": "a package manager for JavaScript", "workspaces": [ @@ -52,8 +52,8 @@ }, "dependencies": { "@isaacs/string-locale-compare": "^1.1.0", - "@npmcli/arborist": "^9.9.3", - "@npmcli/config": "^10.14.0", + "@npmcli/arborist": "^9.9.4", + "@npmcli/config": "^10.14.1", "@npmcli/fs": "^5.0.0", "@npmcli/map-workspaces": "^5.0.3", "@npmcli/metavuln-calculator": "^9.0.3", @@ -77,11 +77,11 @@ "is-cidr": "^6.0.4", "json-parse-even-better-errors": "^5.0.0", "libnpmaccess": "^10.0.3", - "libnpmdiff": "^8.1.14", - "libnpmexec": "^10.3.5", - "libnpmfund": "^7.0.28", + "libnpmdiff": "^8.1.15", + "libnpmexec": "^10.3.6", + "libnpmfund": "^7.0.29", "libnpmorg": "^8.0.1", - "libnpmpack": "^9.1.15", + "libnpmpack": "^9.1.16", "libnpmpublish": "^11.2.1", "libnpmsearch": "^9.0.1", "libnpmteam": "^8.0.2", diff --git a/deps/npm/tap-snapshots/test/lib/docs.js.test.cjs b/deps/npm/tap-snapshots/test/lib/docs.js.test.cjs index 25c42722d94..755f1307325 100644 --- a/deps/npm/tap-snapshots/test/lib/docs.js.test.cjs +++ b/deps/npm/tap-snapshots/test/lib/docs.js.test.cjs @@ -1971,6 +1971,11 @@ Optional dependencies that cannot be installed on the current platform or engine (a non-matching \`os\`, \`cpu\`, or \`libc\`) are not flagged, because their install scripts never run. +Installation checks skip unused entries with no package parent or incoming +links. Local link targets that installation can still rebuild remain subject +to this check. \`npm rebuild\` and \`npm install-scripts ls\` still check unused +packages on disk. + #### \`strict-peer-deps\` diff --git a/deps/npm/test/bin/windows-shims.js b/deps/npm/test/bin/windows-shims.js index a97caf7a7c8..5f9d224955d 100644 --- a/deps/npm/test/bin/windows-shims.js +++ b/deps/npm/test/bin/windows-shims.js @@ -177,7 +177,9 @@ t.test('run shims', t => { chmodSync(join(path, shim), 0o755) } - const { ProgramFiles = '/', SystemRoot = '/', NYC_CONFIG, WINDOWS_SHIMS_TEST } = process.env + const { + ProgramFiles = '/', SystemRoot = '/', NYC_CONFIG, WINDOWS_SHIMS_TEST, CYGWIN_ROOT, + } = process.env const skipDefault = WINDOWS_SHIMS_TEST || process.platform === 'win32' ? null : 'test not relevant on platform' @@ -188,13 +190,17 @@ t.test('run shims', t => { git: join(ProgramFiles, 'Git', 'bin', 'bash.exe'), 'user git': join(ProgramFiles, 'Git', 'usr', 'bin', 'bash.exe'), wsl: join(SystemRoot, 'System32', 'bash.exe'), - cygwin: resolve(SystemRoot, '/', 'cygwin64', 'bin', 'bash.exe'), + cygwin: CYGWIN_ROOT && join(CYGWIN_ROOT, 'bin', 'bash.exe'), }).map(([name, cmd]) => { let match = {} const skip = { reason: skipDefault, fail: WINDOWS_SHIMS_TEST } - const isBash = cmd.endsWith('bash.exe') + const isBash = name === 'cygwin' || cmd.endsWith('bash.exe') const testName = `${name} ${isBash ? 'bash' : ''}`.trim() + if (!skip.reason && name === 'cygwin' && !CYGWIN_ROOT) { + skip.reason = 'CYGWIN_ROOT is not set' + } + if (!skip.reason) { if (isBash) { try { diff --git a/deps/npm/test/fixtures/allow-scripts-orphan.js b/deps/npm/test/fixtures/allow-scripts-orphan.js new file mode 100644 index 00000000000..9276c573f4e --- /dev/null +++ b/deps/npm/test/fixtures/allow-scripts-orphan.js @@ -0,0 +1,32 @@ +const { workspaceMock } = require('./mock-npm.js') + +module.exports = (t, { workspace = true, allowScripts, requiredScripts = false } = {}) => { + const fixture = workspaceMock(t, { + workspaces: { app: { 'abbrev@1.0.0': {} } }, + }) + const pkg = JSON.parse(fixture['package.json']) + const lock = JSON.parse(fixture['package-lock.json']) + + if (!workspace) { + delete pkg.workspaces + pkg.dependencies = { app: 'file:app' } + lock.packages[''] = { ...pkg } + } + pkg.allowScripts = allowScripts + + // The missing intermediate directory leaves this orphan in the ideal-tree inventory. + lock.packages['app/node_modules/abbrev/node_modules/orphan'] = { + version: '1.0.0', + resolved: 'https://registry.npmjs.org/orphan/-/orphan-1.0.0.tgz', + hasInstallScript: true, + extraneous: true, + } + if (requiredScripts) { + lock.packages['node_modules/abbrev'].hasInstallScript = true + } + + delete fixture.node_modules + fixture['package.json'] = JSON.stringify(pkg) + fixture['package-lock.json'] = JSON.stringify(lock) + return fixture +} diff --git a/deps/npm/test/lib/commands/ci.js b/deps/npm/test/lib/commands/ci.js index bc645c5cc40..6f93a49bdda 100644 --- a/deps/npm/test/lib/commands/ci.js +++ b/deps/npm/test/lib/commands/ci.js @@ -6,6 +6,8 @@ const { loadNpmWithRegistry: loadMockNpm, workspaceMock, } = require('../../fixtures/mock-npm') +const orphanFixture = require('../../fixtures/allow-scripts-orphan.js') +const tspawk = require('../../fixtures/tspawk.js') // t.cleanSnapshot = str => str.replace(/ in [0-9ms]+/g, ' in {TIME}') @@ -258,6 +260,69 @@ t.test('should throw error when ideal inventory mismatches virtual', async t => t.equal(fs.existsSync(nmTestFile), true, 'does not remove node_modules') }) +t.test('ci with lockfile-only orphans', async t => { + tspawk(t) + const testOrphan = async (t, { + workspace = true, + allowScripts, + strict = true, + json = false, + } = {}) => { + const prefixDir = orphanFixture(t, { workspace, allowScripts }) + const { npm, registry, assert, logs, clearOutput, joinedOutput } = await loadMockNpm(t, { + config: { audit: false, fund: false, 'strict-allow-scripts': strict, json }, + prefixDir, + }) + const manifest = registry.manifest({ name: 'abbrev' }) + await registry.tarball({ + manifest: manifest.versions['1.0.0'], + tarball: path.join(npm.prefix, 'tarballs/abbrev@1.0.0'), + }) + + await npm.exec('ci', []) + + assert.packageInstalled('node_modules/abbrev@1.0.0') + assert.fileShouldNotExist('app/node_modules/abbrev/node_modules/orphan') + t.equal( + fs.readFileSync(path.join(npm.prefix, 'package-lock.json'), 'utf8'), + prefixDir['package-lock.json'], + 'does not change the lockfile' + ) + t.strictSame(logs.warn.byTitle('install-scripts'), [], 'no orphan warning') + if (json) { + t.notOk(Object.hasOwn(JSON.parse(joinedOutput()), 'unreviewedScripts'), 'no orphan entry') + } else { + clearOutput() + await npm.exec('install-scripts', ['ls']) + t.match(joinedOutput(), /No packages with unreviewed install scripts/) + } + } + + for (const workspace of [true, false]) { + for (const allowScripts of [undefined, { orphan: false }]) { + const source = workspace ? 'workspace' : 'file link' + const policy = allowScripts ? 'denied' : 'unreviewed' + for (const strict of [false, true]) { + await t.test(`${source}, ${policy} orphan, strict=${strict}`, + t => testOrphan(t, { workspace, allowScripts, strict })) + } + } + } + + await t.test('JSON excludes the orphan', t => testOrphan(t, { json: true })) + + await t.test('still rejects a required unreviewed package', async t => { + const { npm } = await loadMockNpm(t, { + config: { audit: false, 'strict-allow-scripts': true }, + prefixDir: orphanFixture(t, { requiredScripts: true }), + }) + await t.rejects(npm.exec('ci', []), { + code: 'ESTRICTALLOWSCRIPTS', + message: /1 package\(s\) have install scripts not covered by allowScripts:\n {2}abbrev@1\.0\.0/, + }) + }) +}) + t.test('should remove dirty node_modules with unhoisted workspace module', async t => { const { npm, registry, assert } = await loadMockNpm(t, { prefixDir: workspaceMock(t, { diff --git a/deps/npm/test/lib/commands/install-scripts.js b/deps/npm/test/lib/commands/install-scripts.js index e3c42ac2485..65e893c49bc 100644 --- a/deps/npm/test/lib/commands/install-scripts.js +++ b/deps/npm/test/lib/commands/install-scripts.js @@ -8,11 +8,17 @@ const mockNpm = async (t, opts = {}) => { return _mockNpm(t, opts) } -const setupProject = ({ allowScripts, withScripts = ['canvas'], noScripts = [] } = {}) => { +const setupProject = ({ + allowScripts, + withScripts = ['canvas'], + noScripts = [], + extraneous = false, +} = {}) => { const pkg = { name: 'host', version: '1.0.0', - dependencies: Object.fromEntries([...withScripts, ...noScripts].map((n) => [n, '*'])), + dependencies: extraneous ? {} + : Object.fromEntries([...withScripts, ...noScripts].map((n) => [n, '*'])), } if (allowScripts !== undefined) { pkg.allowScripts = allowScripts @@ -140,6 +146,29 @@ t.test('install-scripts ls lists unreviewed packages', async t => { t.match(out, /sharp@1\.0\.0/) }) +t.test('install-scripts ls lists extraneous packages on disk', async t => { + for (const json of [false, true]) { + await t.test(json ? 'json' : 'text', async t => { + const { npm, joinedOutput } = await mockNpm(t, { + prefixDir: setupProject({ extraneous: true }), + config: { json }, + }) + await npm.exec('install-scripts', ['ls']) + if (json) { + t.strictSame(JSON.parse(joinedOutput()), { + allowScripts: [{ + name: 'canvas', + changes: [{ key: 'canvas@1.0.0', change: 'pending' }], + }], + }) + } else { + t.match(joinedOutput(), /1 package has install scripts not yet covered by allowScripts/) + t.match(joinedOutput(), /canvas@1\.0\.0/) + } + }) + } +}) + t.test('install-scripts ls with no unreviewed says so', async t => { const { npm, joinedOutput } = await mockNpm(t, { prefixDir: setupProject({ allowScripts: { canvas: true }, withScripts: ['canvas'] }), diff --git a/deps/npm/test/lib/commands/install.js b/deps/npm/test/lib/commands/install.js index 2aa56a3dcd1..8d3f84fa440 100644 --- a/deps/npm/test/lib/commands/install.js +++ b/deps/npm/test/lib/commands/install.js @@ -16,6 +16,7 @@ const { loadNpmWithRegistry: loadMockNpm, workspaceMock, } = require('../../fixtures/mock-npm') +const orphanFixture = require('../../fixtures/allow-scripts-orphan.js') // tspawk calls preventUnmatched which assures that no scripts run if we don't mock any const spawk = tspawk(t) @@ -453,6 +454,134 @@ t.test('completion', async t => { }) }) +t.test('install with an extraneous local link', async t => { + const setup = (t, config = {}) => loadMockNpm(t, { + config: { audit: false, fund: false, 'package-lock': false, ...config }, + prefixDir: { + 'package.json': JSON.stringify({ name: 'host', version: '1.0.0' }), + foo: { + 'package.json': JSON.stringify({ + name: 'foo', + version: '1.0.0', + scripts: { install: 'echo linked-install' }, + }), + }, + node_modules: { foo: t.fixture('symlink', '../foo') }, + }, + }) + + await t.test('strict mode rejects a retained link target', async t => { + const { npm, assert } = await setup(t, { 'strict-allow-scripts': true }) + await t.rejects(npm.exec('install', []), { + code: 'ESTRICTALLOWSCRIPTS', + message: /foo@1\.0\.0/, + }) + assert.fileShouldExist('node_modules/foo/package.json') + }) + + await t.test('normal mode keeps the unreviewed-script warning', async t => { + const { npm, logs } = await setup(t) + spawk.spawn(/.*/, args => args.includes('echo linked-install')) + await npm.exec('install', []) + const warnings = logs.warn.byTitle('install-scripts').join('\n') + t.match(warnings, /1 package has install scripts not yet covered by allowScripts/) + t.match(warnings, /foo@1\.0\.0/) + }) + + await t.test('JSON keeps the unreviewed-script entry', async t => { + const { npm, joinedOutput } = await setup(t, { json: true }) + spawk.spawn(/.*/, args => args.includes('echo linked-install')) + await npm.exec('install', []) + t.strictSame(JSON.parse(joinedOutput()).unreviewedScripts, [{ + name: 'foo', + version: '1.0.0', + path: path.join(npm.prefix, 'foo'), + scripts: { install: 'echo linked-install' }, + }]) + }) + + await t.test('the bypass still rebuilds the retained link', async t => { + const { npm } = await setup(t, { + 'strict-allow-scripts': true, + 'dangerously-allow-all-scripts': true, + }) + let calls = 0 + spawk.spawn(/.*/, args => { + calls++ + return args.includes('echo linked-install') + }) + await npm.exec('install', []) + t.equal(calls, 1, 'ran the linked package install script') + }) + + await t.test('pruning the link does not reject or warn about its detached target', async t => { + const { npm, logs, assert } = await setup(t, { + 'strict-allow-scripts': true, + 'package-lock': true, + }) + await npm.exec('install', []) + assert.fileShouldNotExist('node_modules/foo') + assert.fileShouldExist('foo/package.json') + t.strictSame(logs.warn.byTitle('install-scripts'), []) + }) +}) + +t.test('install with lockfile-only orphans', async t => { + const testOrphan = async (t, { + workspace = true, + allowScripts, + strict = true, + json = false, + } = {}) => { + const { npm, registry, assert, logs, clearOutput, joinedOutput } = await loadMockNpm(t, { + config: { audit: false, fund: false, 'strict-allow-scripts': strict, json }, + prefixDir: orphanFixture(t, { workspace, allowScripts }), + }) + const manifest = registry.manifest({ name: 'abbrev' }) + await registry.tarball({ + manifest: manifest.versions['1.0.0'], + tarball: path.join(npm.prefix, 'tarballs/abbrev@1.0.0'), + }) + + await npm.exec('install', []) + + assert.packageInstalled('node_modules/abbrev@1.0.0') + assert.fileShouldNotExist('app/node_modules/abbrev/node_modules/orphan') + t.strictSame(logs.warn.byTitle('install-scripts'), [], 'no orphan warning') + if (json) { + t.notOk(Object.hasOwn(JSON.parse(joinedOutput()), 'unreviewedScripts'), 'no orphan entry') + } else { + clearOutput() + await npm.exec('install-scripts', ['ls']) + t.match(joinedOutput(), /No packages with unreviewed install scripts/) + } + } + + for (const workspace of [true, false]) { + for (const allowScripts of [undefined, { orphan: false }]) { + const source = workspace ? 'workspace' : 'file link' + const policy = allowScripts ? 'denied' : 'unreviewed' + for (const strict of [false, true]) { + await t.test(`${source}, ${policy} orphan, strict=${strict}`, + t => testOrphan(t, { workspace, allowScripts, strict })) + } + } + } + + await t.test('JSON excludes the orphan', t => testOrphan(t, { json: true })) + + await t.test('still rejects a required unreviewed package', async t => { + const { npm } = await loadMockNpm(t, { + config: { audit: false, 'strict-allow-scripts': true }, + prefixDir: orphanFixture(t, { requiredScripts: true }), + }) + await t.rejects(npm.exec('install', []), { + code: 'ESTRICTALLOWSCRIPTS', + message: /1 package\(s\) have install scripts not covered by allowScripts:\n {2}abbrev@1\.0\.0/, + }) + }) +}) + t.test('should install in workspace with unhoisted module', async t => { const { npm, registry, assert } = await loadMockNpm(t, { prefixDir: workspaceMock(t, { diff --git a/deps/npm/test/lib/commands/rebuild.js b/deps/npm/test/lib/commands/rebuild.js index 1336fa1e7f2..5f3037db4fd 100644 --- a/deps/npm/test/lib/commands/rebuild.js +++ b/deps/npm/test/lib/commands/rebuild.js @@ -244,6 +244,33 @@ t.test('emits Phase 1 advisory warning for unreviewed install scripts', async t ) }) +t.test('strict rebuild rejects extraneous packages on disk', async t => { + for (const args of [[], ['canvas']]) { + await t.test(args.length ? 'named package' : 'all packages', async t => { + const { npm, prefix } = await setupMockNpm(t, { + config: { 'strict-allow-scripts': true }, + prefixDir: { + 'package.json': JSON.stringify({ name: 'host', version: '1.0.0' }), + node_modules: { + canvas: { + 'package.json': JSON.stringify({ + name: 'canvas', + version: '1.0.0', + scripts: { install: "node -e \"require('fs').writeFileSync('ran', '')\"" }, + }), + }, + }, + }, + }) + await t.rejects(npm.exec('rebuild', args), { + code: 'ESTRICTALLOWSCRIPTS', + message: /canvas@1\.0\.0/, + }) + t.notOk(fs.existsSync(resolve(prefix, 'node_modules/canvas/ran')), 'script did not run') + }) + } +}) + t.test('global advisory warning points at npm config set, not approve-scripts', async t => { const { npm, logs } = await setupMockNpm(t, { config: { diff --git a/deps/npm/test/lib/utils/check-allow-scripts.js b/deps/npm/test/lib/utils/check-allow-scripts.js index c67ec2a7cd7..f7fe9c6367c 100644 --- a/deps/npm/test/lib/utils/check-allow-scripts.js +++ b/deps/npm/test/lib/utils/check-allow-scripts.js @@ -95,6 +95,29 @@ t.test('skips project root, workspace, and linked nodes', async t => { t.strictSame(result, []) }) +t.test('only skips extraneous nodes when requested', async t => { + const checkAllowScripts = mockCheck(t) + const orphan = { + ...node({ name: 'orphan', scripts: { install: 'x' }, isRegistryDependency: false }), + extraneous: true, + edgesIn: new Set(), + parent: null, + linksIn: new Set(), + } + for (const skipExtraneous of [undefined, false, true]) { + const result = await checkAllowScripts({ + arb: arb({ nodes: [orphan], allowScripts: { orphan: false } }), + npm: { flatOptions: {} }, + skipExtraneous, + }) + t.strictSame( + result.map(({ node: entry }) => entry), + skipExtraneous ? [] : [orphan], + `skipExtraneous=${skipExtraneous}` + ) + } +}) + t.test('skips nodes with no install-relevant scripts', async t => { const checkAllowScripts = mockCheck(t) const result = await checkAllowScripts({ diff --git a/deps/npm/test/lib/utils/is-windows.js b/deps/npm/test/lib/utils/is-windows.js new file mode 100644 index 00000000000..a8606da3a78 --- /dev/null +++ b/deps/npm/test/lib/utils/is-windows.js @@ -0,0 +1,65 @@ +const t = require('tap') +const { isGitBashMsystem } = require('../../../lib/utils/is-windows.js') + +t.test('isGitBashMsystem recognizes Git Bash / MSYS2 shells', t => { + t.equal(isGitBashMsystem('MINGW64'), true) + t.equal(isGitBashMsystem('MINGW32'), true) + t.equal(isGitBashMsystem('UCRT64'), true, 'Git for Windows 2.56+ default') + t.equal(isGitBashMsystem('CLANG64'), true) + t.equal(isGitBashMsystem('CLANG32'), true) + t.equal(isGitBashMsystem('CLANGARM64'), true) + t.equal(isGitBashMsystem('MSYS'), false) + t.equal(isGitBashMsystem('nogmingw'), false) + t.equal(isGitBashMsystem(undefined), false) + t.equal(isGitBashMsystem(''), false) + t.end() +}) + +t.test('isWindowsShell respects UCRT64 via fresh require', t => { + const path = require.resolve('../../../lib/utils/is-windows.js') + const origPlatform = Object.getOwnPropertyDescriptor(process, 'platform') + const origMsystem = process.env.MSYSTEM + const origTerm = process.env.TERM + + const load = (platform, msystem, term) => { + delete require.cache[path] + Object.defineProperty(process, 'platform', { value: platform, configurable: true }) + if (msystem === undefined) { + delete process.env.MSYSTEM + } else { + process.env.MSYSTEM = msystem + } + if (term === undefined) { + delete process.env.TERM + } else { + process.env.TERM = term + } + return require(path).isWindowsShell + } + + t.teardown(() => { + delete require.cache[path] + if (origPlatform) { + Object.defineProperty(process, 'platform', origPlatform) + } + if (origMsystem === undefined) { + delete process.env.MSYSTEM + } else { + process.env.MSYSTEM = origMsystem + } + if (origTerm === undefined) { + delete process.env.TERM + } else { + process.env.TERM = origTerm + } + }) + + t.equal(load('linux', undefined, undefined), false) + t.equal(load('win32', undefined, undefined), true) + t.equal(load('win32', 'MINGW64', undefined), false) + t.equal(load('win32', 'UCRT64', undefined), false, 'UCRT64 Git Bash is not cmd.exe') + t.equal(load('win32', 'CLANG64', undefined), false) + t.equal(load('win32', undefined, 'cygwin'), false) + t.equal(load('win32', 'nogmingw', undefined), true) + t.end() +}) diff --git a/deps/npm/test/lib/utils/reify-finish.js b/deps/npm/test/lib/utils/reify-finish.js index a1dd165034a..56ef51d75ab 100644 --- a/deps/npm/test/lib/utils/reify-finish.js +++ b/deps/npm/test/lib/utils/reify-finish.js @@ -23,8 +23,11 @@ const mockReififyFinish = async (t, { actualTree = {}, otherDirs = {}, ...config config, }) + let reportedScripts const reifyFinish = tmock(t, '{LIB}/utils/reify-finish.js', { - '{LIB}/utils/reify-output.js': () => {}, + '{LIB}/utils/reify-output.js': (_npm, _arb, { unreviewedScripts }) => { + reportedScripts = unreviewedScripts + }, }) await reifyFinish(mock.npm, { @@ -39,6 +42,7 @@ const mockReififyFinish = async (t, { actualTree = {}, otherDirs = {}, ...config return { builtinRc, + reportedScripts, ...mock, } } @@ -51,6 +55,31 @@ t.test('ok by default', async t => { t.strictSame(mock.builtinRc.data, { key: 'value' }) }) +t.test('only omits disconnected orphans from post-install reporting', async t => { + for (const strict of [false, true]) { + await t.test(`strict=${strict}`, async t => { + const candidate = (name, properties = {}) => ({ + name, + package: { name, version: '1.0.0', scripts: { install: `echo ${name}` } }, + extraneous: true, + parent: null, + linksIn: new Set(), + ...properties, + }) + const orphan = candidate('orphan') + const attached = candidate('attached', { parent: {} }) + const linked = candidate('linked', { linksIn: new Set([{}]) }) + const { reportedScripts } = await mockReififyFinish(t, { + 'strict-allow-scripts': strict, + actualTree: { + inventory: new Map([orphan, attached, linked].map(n => [n.name, n])), + }, + }) + t.strictSame(reportedScripts.map(({ node }) => node), [attached, linked]) + }) + } +}) + t.test('should not write if no global npm module', async t => { const mock = await mockReififyFinish(t, { global: true, diff --git a/deps/npm/test/lib/utils/strict-allow-scripts-preflight.js b/deps/npm/test/lib/utils/strict-allow-scripts-preflight.js index c67a6e4853a..d8115857b64 100644 --- a/deps/npm/test/lib/utils/strict-allow-scripts-preflight.js +++ b/deps/npm/test/lib/utils/strict-allow-scripts-preflight.js @@ -1,4 +1,8 @@ const t = require('tap') +const { join } = require('node:path') +const Arborist = require('@npmcli/arborist') +const { loadNpmWithRegistry } = require('../../fixtures/mock-npm.js') +const orphanFixture = require('../../fixtures/allow-scripts-orphan.js') const preflight = require('../../../lib/utils/strict-allow-scripts-preflight.js') @@ -24,9 +28,18 @@ const tree = (nodes) => ({ inventory: new Map(nodes.map((n, i) => [`node_modules/${n.name}-${i}`, n])), }) -const makeArb = ({ ideal, actual, allowScripts = null } = {}) => { +const orphan = () => ({ + ...node({ name: 'orphan' }), + extraneous: true, + isRegistryDependency: false, + edgesIn: new Set(), + parent: null, + linksIn: new Set(), +}) + +const makeArb = ({ ideal, actual, allowScripts = null, options = {} } = {}) => { const arb = { - options: { allowScripts, ignoreScripts: false }, + options: { allowScripts, ignoreScripts: false, ...options }, idealTree: ideal ?? null, actualTree: actual ?? null, } @@ -89,6 +102,99 @@ t.test('passes when the only unreviewed node is inert (platform-incompatible opt t.pass('no error thrown for inert node') }) +t.test('skips disconnected orphans when pruning is disabled', async t => { + for (const installStrategy of ['hoisted', 'linked']) { + await t.test(installStrategy, async t => { + const { npm, prefix, registry, assert } = await loadNpmWithRegistry(t, { + config: { + audit: false, + 'strict-allow-scripts': true, + 'install-strategy': installStrategy, + }, + prefixDir: orphanFixture(t, { allowScripts: { orphan: false } }), + }) + const opts = { + ...npm.flatOptions, + path: prefix, + prune: false, + allowScripts: { orphan: false }, + } + const arb = new Arborist(opts) + await arb.buildIdealTree(opts) + const location = 'app/node_modules/abbrev/node_modules/orphan' + const unused = arb.idealTree.inventory.get(location) + t.match(unused, { extraneous: true, parent: null }) + t.equal(unused.linksIn.size, 0, 'the orphan has no incoming links') + + await preflight({ arb, npm, idealTreeOpts: opts }) + + const manifest = registry.manifest({ name: 'abbrev' }) + await registry.tarball({ + manifest: manifest.versions['1.0.0'], + tarball: join(prefix, 'tarballs/abbrev@1.0.0'), + }) + await arb.reify(opts) + const installedPath = installStrategy === 'linked' ? 'app/node_modules' : 'node_modules' + assert.packageInstalled(`${installedPath}/abbrev@1.0.0`) + assert.fileShouldNotExist(location) + t.equal(arb.scriptsRun.size, 0, 'no install scripts ran') + const actual = await new Arborist(opts).loadActual() + t.notOk([...actual.inventory.values()].some(n => n.name === 'orphan'), + 'the installed tree has no orphan') + }) + } +}) + +t.test('skips orphans in a newly built ideal tree', async t => { + const arb = makeArb() + arb.buildIdealTree = async () => { + arb.idealTree = tree([orphan()]) + } + await t.resolves(preflight({ + arb, + npm: { flatOptions: { strictAllowScripts: true } }, + idealTreeOpts: {}, + })) + t.ok(arb.idealTree, 'built the ideal tree') +}) + +t.test('does not skip an extraneous target with an incoming link', async t => { + const target = { ...orphan(), linksIn: new Set([{}]) } + const arb = makeArb({ + ideal: tree([target]), + allowScripts: { orphan: false }, + options: { prune: false }, + }) + await t.rejects(preflight({ + arb, + npm: { flatOptions: { strictAllowScripts: true } }, + idealTreeOpts: { prune: false }, + }), { code: 'ESTRICTALLOWSCRIPTS', message: /orphan@1\.0\.0/ }) +}) + +t.test('skipping an orphan does not skip a required unreviewed package', async t => { + const arb = makeArb({ ideal: tree([orphan(), node({ name: 'required' })]) }) + await t.rejects(preflight({ + arb, + npm: { flatOptions: { strictAllowScripts: true } }, + idealTreeOpts: {}, + }), { + code: 'ESTRICTALLOWSCRIPTS', + message: /1 package\(s\) have install scripts not covered by allowScripts:\n {2}required@1\.0\.0/, + }) +}) + +t.test('does not skip actual-tree orphans even with an ideal tree', async t => { + const arb = makeArb({ + ideal: tree([]), + actual: tree([orphan()]), + }) + await t.rejects(preflight({ + arb, + npm: { flatOptions: { strictAllowScripts: true } }, + }), { code: 'ESTRICTALLOWSCRIPTS', message: /orphan@1\.0\.0/ }) +}) + t.test('passes when all install-script nodes are explicitly approved', async t => { const arb = makeArb({ ideal: tree([node({ name: 'canvas' })]), From 29cdb9df56203e5922b5f8b91e26e7edfebc1fc7 Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Wed, 18 Nov 2026 07:45:33 +0100 Subject: [PATCH 328/331] stream: keep async context of the pipeTo pump The pipeTo() pump re-enters from the destination's ready hook, which writableStreamUpdateBackpressure invokes synchronously, and from the chunk steps of its read request. Both run in the async context of the code that cleared the backpressure or enqueued the chunk, so the source's pull() and the writes issued after a resumption observed that context instead of the one of the pipeTo() call, as they did with the promise-based pump. Capture the async context frame when the pipe starts and run the pump in it. Refs: https://github.com/nodejs/node/issues/66906 Refs: https://github.com/nodejs/node/pull/65138 Signed-off-by: Matteo Collina PR-URL: https://github.com/nodejs/node/pull/67054 Refs: https://github.com/nodejs/node/pull/67052 Reviewed-By: Antoine du Hamel Reviewed-By: Paolo Insogna --- lib/internal/webstreams/readablestream.js | 28 ++++ ...twg-readablestream-pipeto-async-context.js | 157 ++++++++++++++++++ 2 files changed, 185 insertions(+) create mode 100644 test/parallel/test-whatwg-readablestream-pipeto-async-context.js diff --git a/lib/internal/webstreams/readablestream.js b/lib/internal/webstreams/readablestream.js index 3181355959b..70d2309e282 100644 --- a/lib/internal/webstreams/readablestream.js +++ b/lib/internal/webstreams/readablestream.js @@ -49,6 +49,14 @@ const { const AsyncContextFrame = require('internal/async_context_frame'); +// The pipe checks the async context frame on every pump step; the +// intrinsics reduce to a field access in optimized code, which the +// AsyncContextFrame wrappers would put behind another inlining level. +const { + getContinuationPreservedEmbedderData: currentContextFrame, + setContinuationPreservedEmbedderData: setContextFrame, +} = internalBinding('async_context_frame'); + const { isArrayBufferView, isDataView, @@ -1766,6 +1774,20 @@ function readableStreamPipeTo( let readRequest; let readyHook; + // The pump re-enters from the ready hook and from the chunk steps, which + // run in the async context of whoever cleared the backpressure or + // enqueued the chunk. Resume it in the context of the pipeTo() call, as + // the promise-based pump did. + const pipeContextFrame = currentContextFrame(); + function pumpInPipeContext(prior) { + setContextFrame(pipeContextFrame); + try { + pump(); + } finally { + setContextFrame(prior); + } + } + // Ready promise rejection is handled by the destination-errored // watcher. function ignoreReadyRejection() {} @@ -1800,6 +1822,12 @@ function readableStreamPipeTo( function pump() { if (shuttingDown) return; + const contextFrame = currentContextFrame(); + if (contextFrame !== pipeContextFrame) { + pumpInPipeContext(contextFrame); + return; + } + if (dest[kState].backpressure) { parkOnReady(); return; diff --git a/test/parallel/test-whatwg-readablestream-pipeto-async-context.js b/test/parallel/test-whatwg-readablestream-pipeto-async-context.js new file mode 100644 index 00000000000..5a096e3097a --- /dev/null +++ b/test/parallel/test-whatwg-readablestream-pipeto-async-context.js @@ -0,0 +1,157 @@ +'use strict'; + +// The pipeTo() pump must keep running in the async context of the +// pipeTo() call when it resumes after backpressure or after a chunk +// arrives, instead of taking the context of the code that cleared the +// backpressure or enqueued the chunk. The source pulls and the writes the +// pump issues are checked. + +const common = require('../common'); +const assert = require('assert'); +const { AsyncLocalStorage } = require('async_hooks'); +const { setImmediate: tick } = require('timers/promises'); + +const als = new AsyncLocalStorage(); + +function store() { + return als.getStore() ?? 'none'; +} + +// Settles the pending callbacks from the given context until `promise` +// settles. +async function settleUntil(promise, ctx, pending) { + let finished = false; + promise.then(common.mustCall(() => { finished = true; })); + while (!finished) { + await tick(); + while (pending.length > 0) als.run(ctx, pending.shift()); + } + await promise; +} + +const tests = []; +function test(name, expected, fn) { + tests.push({ name, expected, fn }); +} + +test('sink writes resolved from another context', [ + // The first pull and write follow the source's start step. + 'pull:creator', 'write-1:creator', + 'pull:piper', 'write-2:piper', + 'pull:piper', 'write-3:piper', + 'pull:piper', +], async (seen) => { + let n = 0; + const pending = []; + const rs = als.run('creator', () => new ReadableStream({ + pull(c) { + seen.push(`pull:${store()}`); + if (++n > 3) c.close(); else c.enqueue(n); + }, + }, { highWaterMark: 0 })); + const ws = als.run('creator', () => new WritableStream({ + write(chunk) { + seen.push(`write-${chunk}:${store()}`); + const { promise, resolve } = Promise.withResolvers(); + pending.push(resolve); + return promise; + }, + }, { highWaterMark: 1 })); + await settleUntil(als.run('piper', () => rs.pipeTo(ws)), 'releaser', pending); +}); + +test('push source under backpressure', [ + 'write-a:pusher-a', 'write-b:piper', 'write-c:piper', 'write-d:piper', +], async (seen) => { + let controller; + const pending = []; + const rs = als.run('creator', () => new ReadableStream({ + start(c) { controller = c; }, + }, { highWaterMark: 0 })); + const ws = als.run('creator', () => new WritableStream({ + write(chunk) { + seen.push(`write-${chunk}:${store()}`); + const { promise, resolve } = Promise.withResolvers(); + pending.push(resolve); + return promise; + }, + }, { highWaterMark: 1 })); + const piped = als.run('piper', () => rs.pipeTo(ws)); + await tick(); + for (const chunk of 'abcd') + als.run(`pusher-${chunk}`, () => controller.enqueue(chunk)); + als.run('closer', () => controller.close()); + await settleUntil(piped, 'releaser', pending); +}); + +test('pipeThrough() with pulls resolved from another context', [ + 'pull:piper', 'transform-1:resolver', + 'pull:piper', 'transform-2:resolver', + 'pull:piper', 'transform-3:resolver', + 'pull:piper', +], async (seen) => { + let n = 0; + const pending = []; + const readable = als.run('piper', () => new ReadableStream({ + pull(c) { + seen.push(`pull:${store()}`); + const { promise, resolve } = Promise.withResolvers(); + pending.push(() => { + if (++n > 3) c.close(); else c.enqueue(n); + resolve(); + }); + return promise; + }, + }, { highWaterMark: 0 }).pipeThrough(new TransformStream({ + transform(chunk, c) { + seen.push(`transform-${chunk}:${store()}`); + c.enqueue(chunk); + }, + }))); + const consumed = als.run('reader', async () => { + // eslint-disable-next-line no-unused-vars + for await (const _ of readable); + }); + await settleUntil(consumed, 'resolver', pending); +}); + +test('pipeThrough() chain into a slow sink', [ + 'pull:creator', 't1-1:piper', 't2-1:piper', 'write-1:piper', + 'pull:piper', 't1-2:piper', 't2-2:piper', 'write-2:piper', + 'pull:piper', 't1-3:piper', 't2-3:piper', 'write-3:piper', + 'pull:piper', +], async (seen) => { + let n = 0; + function transform(name) { + return new TransformStream({ + transform(chunk, c) { + seen.push(`${name}-${chunk}:${store()}`); + c.enqueue(chunk); + }, + }); + } + const rs = als.run('creator', () => new ReadableStream({ + pull(c) { + seen.push(`pull:${store()}`); + if (++n > 3) c.close(); else c.enqueue(n); + }, + }, { highWaterMark: 0 })); + const ws = als.run('creator', () => new WritableStream({ + async write(chunk) { + seen.push(`write-${chunk}:${store()}`); + await tick(); + }, + }, { highWaterMark: 1 })); + await als.run('piper', () => rs.pipeThrough(transform('t1')) + .pipeThrough(transform('t2')).pipeTo(ws)); +}); + +(async () => { + for (const { name, expected, fn } of tests) { + const seen = []; + await fn(seen); + // Only the context of each callback is checked, not how the callbacks + // of different streams interleave. + assert.deepStrictEqual(seen.sort(), expected.toSorted(), name); + } +})().then(common.mustCall()); From cad1ec93bf2e9d154dd458c1e4ee359ccee0d958 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Wed, 18 Nov 2026 10:29:57 +0100 Subject: [PATCH 329/331] tools: remove duplicate variables MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit All our script already define a `BASE_DIR` variable, needed to load `utils.sh`; computing a similar `ROOT` variable in `utils.sh` is pure overhead and needlessly complicates reading the source files. Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/67511 Reviewed-By: James M Snell Reviewed-By: René Reviewed-By: Luigi Pinca --- tools/dep_updaters/update-amaro.sh | 2 +- tools/dep_updaters/update-c-ares.sh | 2 +- tools/dep_updaters/utils.sh | 3 --- 3 files changed, 2 insertions(+), 5 deletions(-) diff --git a/tools/dep_updaters/update-amaro.sh b/tools/dep_updaters/update-amaro.sh index 0169e9304bc..f257497b7e5 100755 --- a/tools/dep_updaters/update-amaro.sh +++ b/tools/dep_updaters/update-amaro.sh @@ -60,7 +60,7 @@ rm -rf node_modules mv ./* "$DEPS_DIR/amaro" # update version information in src/undici_version.h -cat > "$ROOT/src/amaro_version.h" < "$BASE_DIR/src/amaro_version.h" < Date: Wed, 18 Nov 2026 12:43:12 +0100 Subject: [PATCH 330/331] test: fix on zfs build host Signed-off-by: Marcel PR-URL: https://github.com/nodejs/node/pull/67517 Reviewed-By: Antoine du Hamel Reviewed-By: Luigi Pinca --- test/parallel/test-fileurltopathbuffer.js | 10 +++++++++- test/parallel/test-fs-readdir-ucs2.js | 3 ++- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/test/parallel/test-fileurltopathbuffer.js b/test/parallel/test-fileurltopathbuffer.js index 11a78b76c0e..db6bdc532a0 100644 --- a/test/parallel/test-fileurltopathbuffer.js +++ b/test/parallel/test-fileurltopathbuffer.js @@ -55,7 +55,15 @@ assert.throws(() => writeFileSync(testPath, 'test'), { name: 'URIError', }); -writeFileSync(testPathBuffer, 'test'); + +try { + writeFileSync(testPathBuffer, 'test'); +} catch (e) { + // ZFS with utf8only=on (default) rejects non-UTF-8 file names + if (e.code === 'EILSEQ') + common.skip('test requires filesystem that accepts non-UTF-8 names'); + throw e; +} assert.ok(existsSync(testPathBuffer)); // Using fileURLToPath fails because the URL contains non-Unicode diff --git a/test/parallel/test-fs-readdir-ucs2.js b/test/parallel/test-fs-readdir-ucs2.js index 264858ec6ae..b541ecd32f5 100644 --- a/test/parallel/test-fs-readdir-ucs2.js +++ b/test/parallel/test-fs-readdir-ucs2.js @@ -18,7 +18,8 @@ const fullpath = Buffer.concat([root, filebuff]); try { fs.closeSync(fs.openSync(fullpath, 'w+')); } catch (e) { - if (e.code === 'EINVAL') + // EILSEQ: ZFS with utf8only=on (default) rejects non-UTF-8 file names + if (e.code === 'EINVAL' || e.code === 'EILSEQ') common.skip('test requires filesystem that supports UCS2'); throw e; } From 7692ae4be1b2030d55191ac38ead8eda2885279b Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Fri, 20 Nov 2026 11:57:51 -0500 Subject: [PATCH 331/331] 2026-11-30, Version 26.14.0 'Lithium' (LTS) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Notable changes: child_process: * (SEMVER-MINOR) add subprocess.timedOut (Marco) https://github.com/nodejs/node/pull/66639 doc: * add efekrskl to collaborators (Efe Karasakal) https://github.com/nodejs/node/pull/67376 * add Philipp Dunkel to contributors (Philipp Dunkel) https://github.com/nodejs/node/pull/67378 * add christianaurichzm to collaborators (Christian Aurich Zanettini Martins) https://github.com/nodejs/node/pull/67377 fs: * (SEMVER-MINOR) add mkstemp() (Marco) https://github.com/nodejs/node/pull/66484 http: * (SEMVER-MINOR) batch body spans per parser execute (Guilherme Araújo) https://github.com/nodejs/node/pull/67187 lib: * (SEMVER-MINOR) speed up AbortSignal (Robert Nagy) https://github.com/nodejs/node/pull/66789 module: * (SEMVER-MINOR) add --experimental-strip-private-modules (Marco Ippolito) https://github.com/nodejs/node/pull/63869 process: * (SEMVER-MINOR) return unregister fn from finalization (Matteo Collina) https://github.com/nodejs/node/pull/66482 test_runner: * use AsyncLocalStorage instead of async_hooks (Matteo Collina) https://github.com/nodejs/node/pull/66795 * (SEMVER-MINOR) add mockReturnValue and promise helpers (Guilherme Araújo) https://github.com/nodejs/node/pull/66631 worker: * (SEMVER-MINOR) preload streams into startup snapshot (Matteo Collina) https://github.com/nodejs/node/pull/66311 zlib: * (SEMVER-MINOR) add crc32c (Philipp Dunkel) https://github.com/nodejs/node/pull/66828 PR-URL: https://github.com/nodejs/node/pull/67664 --- CHANGELOG.md | 3 +- doc/api/child_process.md | 2 +- doc/api/cli.md | 4 +- doc/api/crypto.md | 12 +- doc/api/errors.md | 2 +- doc/api/fs.md | 6 +- doc/api/packages.md | 2 +- doc/api/process.md | 4 +- doc/api/test.md | 12 +- doc/api/tls.md | 2 +- doc/api/zlib.md | 6 +- doc/changelogs/CHANGELOG_V26.md | 354 ++++++++++++++++++++++++++++++++ src/node_version.h | 6 +- 13 files changed, 385 insertions(+), 30 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c70659cefa5..b83ee5f8378 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -41,7 +41,8 @@ release. -26.13.1
                +26.14.0
                +26.13.1
                26.13.0
                26.12.1
                26.12.0
                diff --git a/doc/api/child_process.md b/doc/api/child_process.md index 912e33840d6..809eac95118 100644 --- a/doc/api/child_process.md +++ b/doc/api/child_process.md @@ -2318,7 +2318,7 @@ if the child process could not be successfully spawned. ### `subprocess.timedOut` * Type: {boolean} Set to `true` when the child process is killed because the diff --git a/doc/api/cli.md b/doc/api/cli.md index 879b71d1b74..3ac4bd38970 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -1589,7 +1589,7 @@ Enable the experimental [`node:stream/iter`][] module. ### `--experimental-strip-private-modules` > Stability: 1 - Experimental @@ -3217,7 +3217,7 @@ the threshold specified, the process will exit with code `1`. ### `--test-forbid-only` Fails the test run if a test or suite is declared with `only: true`, including diff --git a/doc/api/crypto.md b/doc/api/crypto.md index ccfcdd48ba9..2fc7d685d59 100644 --- a/doc/api/crypto.md +++ b/doc/api/crypto.md @@ -3137,7 +3137,7 @@ the given private key. ### `x509.extensions` * Type: {Object\[]} @@ -3269,7 +3269,7 @@ available. ### `x509.issuerName` * Type: {Object} @@ -3395,7 +3395,7 @@ to handle both possible entry formats. ### `x509.subjectName` * Type: {Object} @@ -3440,7 +3440,7 @@ subject name cannot be inspected. ### `x509.tbs` * Type: {Buffer} @@ -3562,7 +3562,7 @@ reject certificates with invalid dates. ### `x509.signature` * Type: {Object} @@ -3626,7 +3626,7 @@ The OID of the algorithm used to sign the certificate. ### `x509.version` * Type: {number} diff --git a/doc/api/errors.md b/doc/api/errors.md index 5f08745cf78..aefa4970753 100644 --- a/doc/api/errors.md +++ b/doc/api/errors.md @@ -1129,7 +1129,7 @@ An invalid authentication tag length was provided. ### `ERR_CRYPTO_INVALID_X509_CERTIFICATE` An X.509 certificate field could not be inspected. diff --git a/doc/api/fs.md b/doc/api/fs.md index 8ed01ee5f20..6b224961297 100644 --- a/doc/api/fs.md +++ b/doc/api/fs.md @@ -1714,7 +1714,7 @@ object with an `encoding` property specifying the character encoding to use. ### `fsPromises.mkstemp(prefix[, options])` > Stability: 1 - Experimental @@ -4119,7 +4119,7 @@ mkdtemp(`${tmpDir}${sep}`, (err, directory) => { ### `fs.mkstemp(prefix[, options], callback)` > Stability: 1 - Experimental @@ -6647,7 +6647,7 @@ object with an `encoding` property specifying the character encoding to use. ### `fs.mkstempSync(prefix[, options])` > Stability: 1 - Experimental diff --git a/doc/api/packages.md b/doc/api/packages.md index f6b6c60d0d2..c45df312da0 100644 --- a/doc/api/packages.md +++ b/doc/api/packages.md @@ -1391,7 +1391,7 @@ This field defines [subpath imports][] for the current package. ### `"private"` * Type: {boolean} diff --git a/doc/api/process.md b/doc/api/process.md index ec1500eaed4..4fe1fe8f647 100644 --- a/doc/api/process.md +++ b/doc/api/process.md @@ -2062,7 +2062,7 @@ Since it's not possible to build Node.js without libuv, this value is always `tr @@ -1714,7 +1714,7 @@ added: - v18.9.0 - v16.19.0 changes: - - version: REPLACEME + - version: v26.14.0 pr-url: https://github.com/nodejs/node/pull/66578 description: Added the `forbidOnly` option. - version: v26.2.0 @@ -2479,7 +2479,7 @@ test('changes a mock behavior once', (t) => { ### `ctx.mockRejectedValue(reason)` * `reason` {any} The value the returned promise rejects with. @@ -2500,7 +2500,7 @@ test('mocks a rejected value', async (t) => { ### `ctx.mockResolvedValue(value)` * `value` {any} The value the returned promise resolves with. @@ -2521,7 +2521,7 @@ test('mocks a resolved value', async (t) => { ### `ctx.mockReturnValue(value)` * `value` {any} The value returned by the mock. @@ -2542,7 +2542,7 @@ test('mocks a return value', (t) => { ### `ctx.mockThrownValue(value)` * `value` {any} The value thrown by the mock. diff --git a/doc/api/tls.md b/doc/api/tls.md index ba558cf45db..1305d640bed 100644 --- a/doc/api/tls.md +++ b/doc/api/tls.md @@ -1671,7 +1671,7 @@ decrease overall server throughput. ### `tlsSocket.socket` * Type: {net.Socket|stream.Duplex|null} diff --git a/doc/api/zlib.md b/doc/api/zlib.md index 713a28133ff..22846bb883d 100644 --- a/doc/api/zlib.md +++ b/doc/api/zlib.md @@ -1689,7 +1689,7 @@ exceeds `maxSize`, and an [`ERR_INVALID_STATE`][] error for a streaming entry ### `zipEntry.rawContentSync([options])` * `options` {Object} See [`zipEntry.rawContent()`][]. @@ -1700,7 +1700,7 @@ The synchronous version of [`zipEntry.rawContent()`][]. ### `zipEntry.rawContentIterator([options])` * `options` {Object} @@ -2405,7 +2405,7 @@ crc = zlib.crc32(Buffer.from('world', 'utf16le'), crc); // 4150509955 ## `zlib.crc32c(data[, value])` * `data` {string|Buffer|TypedArray|DataView} When `data` is a string, diff --git a/doc/changelogs/CHANGELOG_V26.md b/doc/changelogs/CHANGELOG_V26.md index 4fc008623e5..7c87e99d1be 100644 --- a/doc/changelogs/CHANGELOG_V26.md +++ b/doc/changelogs/CHANGELOG_V26.md @@ -9,6 +9,7 @@ +26.14.0
                26.13.1
                26.13.0
                @@ -64,6 +65,359 @@ * [io.js](CHANGELOG_IOJS.md) * [Archive](CHANGELOG_ARCHIVE.md) + + +## 2026-11-30, Version 26.14.0 'Lithium' (LTS), @aduh95 + +### Notable Changes + +* \[[`c1b8f0e971`](https://github.com/nodejs/node/commit/c1b8f0e971)] - **(SEMVER-MINOR)** **child\_process**: add subprocess.timedOut (Marco) [#66639](https://github.com/nodejs/node/pull/66639) +* \[[`f00c4f6430`](https://github.com/nodejs/node/commit/f00c4f6430)] - **doc**: add efekrskl to collaborators (Efe Karasakal) [#67376](https://github.com/nodejs/node/pull/67376) +* \[[`293fbcc0cd`](https://github.com/nodejs/node/commit/293fbcc0cd)] - **doc**: add Philipp Dunkel to contributors (Philipp Dunkel) [#67378](https://github.com/nodejs/node/pull/67378) +* \[[`d8db12ede8`](https://github.com/nodejs/node/commit/d8db12ede8)] - **doc**: add christianaurichzm to collaborators (Christian Aurich Zanettini Martins) [#67377](https://github.com/nodejs/node/pull/67377) +* \[[`a2f43ceb19`](https://github.com/nodejs/node/commit/a2f43ceb19)] - **(SEMVER-MINOR)** **fs**: add mkstemp() (Marco) [#66484](https://github.com/nodejs/node/pull/66484) +* \[[`22717d1d8f`](https://github.com/nodejs/node/commit/22717d1d8f)] - **(SEMVER-MINOR)** **http**: batch body spans per parser execute (Guilherme Araújo) [#67187](https://github.com/nodejs/node/pull/67187) +* \[[`6fef75c41f`](https://github.com/nodejs/node/commit/6fef75c41f)] - **(SEMVER-MINOR)** **lib**: speed up AbortSignal (Robert Nagy) [#66789](https://github.com/nodejs/node/pull/66789) +* \[[`900ec5791a`](https://github.com/nodejs/node/commit/900ec5791a)] - **(SEMVER-MINOR)** **module**: add --experimental-strip-private-modules (Marco Ippolito) [#63869](https://github.com/nodejs/node/pull/63869) +* \[[`1f5d6a6fcc`](https://github.com/nodejs/node/commit/1f5d6a6fcc)] - **(SEMVER-MINOR)** **process**: return unregister fn from finalization (Matteo Collina) [#66482](https://github.com/nodejs/node/pull/66482) +* \[[`972da90d42`](https://github.com/nodejs/node/commit/972da90d42)] - **test\_runner**: use AsyncLocalStorage instead of async\_hooks (Matteo Collina) [#66795](https://github.com/nodejs/node/pull/66795) +* \[[`7bdf3cb1d1`](https://github.com/nodejs/node/commit/7bdf3cb1d1)] - **(SEMVER-MINOR)** **test\_runner**: add mockReturnValue and promise helpers (Guilherme Araújo) [#66631](https://github.com/nodejs/node/pull/66631) +* \[[`632576930e`](https://github.com/nodejs/node/commit/632576930e)] - **(SEMVER-MINOR)** **worker**: preload streams into startup snapshot (Matteo Collina) [#66311](https://github.com/nodejs/node/pull/66311) +* \[[`36b1de5ebd`](https://github.com/nodejs/node/commit/36b1de5ebd)] - **(SEMVER-MINOR)** **zlib**: add crc32c (Philipp Dunkel) [#66828](https://github.com/nodejs/node/pull/66828) + +### Commits + +* \[[`a5709be4e4`](https://github.com/nodejs/node/commit/a5709be4e4)] - Reapply "module: synchronously load most ES modules" (Antoine du Hamel) [#66786](https://github.com/nodejs/node/pull/66786) +* \[[`1ab60fd1df`](https://github.com/nodejs/node/commit/1ab60fd1df)] - **benchmark**: add URLSearchParams iterator consumers benchmark (Kevin Gibbons) [#66837](https://github.com/nodejs/node/pull/66837) +* \[[`53828e73e6`](https://github.com/nodejs/node/commit/53828e73e6)] - _**Revert**_ "**benchmark**: add URLSearchParams iterator consumers benchmark" (Antoine du Hamel) [#66837](https://github.com/nodejs/node/pull/66837) +* \[[`b4afb79d69`](https://github.com/nodejs/node/commit/b4afb79d69)] - **benchmark**: add URLSearchParams iterator consumers benchmark (Kevin Gibbons) [#66837](https://github.com/nodejs/node/pull/66837) +* \[[`6f3282bf2f`](https://github.com/nodejs/node/commit/6f3282bf2f)] - **benchmark**: merge crc32c into crc32 zlib benchmark (Trivikram Kamat) [#67004](https://github.com/nodejs/node/pull/67004) +* \[[`4a5081a41e`](https://github.com/nodejs/node/commit/4a5081a41e)] - **benchmark**: honor n in perf\_hooks usertiming (Rafael Gonzaga) [#66746](https://github.com/nodejs/node/pull/66746) +* \[[`803cc10528`](https://github.com/nodejs/node/commit/803cc10528)] - **benchmark**: use process.execPath when pinning CPUs in run.js (Rafael Gonzaga) [#66724](https://github.com/nodejs/node/pull/66724) +* \[[`bfeb3900a4`](https://github.com/nodejs/node/commit/bfeb3900a4)] - **benchmark**: fix hideStackFrames error benchmarks (Rafael Gonzaga) [#66723](https://github.com/nodejs/node/pull/66723) +* \[[`ba50acec27`](https://github.com/nodejs/node/commit/ba50acec27)] - **buffer**: limit UTF-8 fast calls to safe one-byte strings (Robert Nagy) [#67136](https://github.com/nodejs/node/pull/67136) +* \[[`cd03433ead`](https://github.com/nodejs/node/commit/cd03433ead)] - **build**: enable V8 undefined double support (Yuya Inoue) [#66733](https://github.com/nodejs/node/pull/66733) +* \[[`5cdbf45e6c`](https://github.com/nodejs/node/commit/5cdbf45e6c)] - **build**: do not pass vendored headers when building against shared libs (Antoine du Hamel) [#66844](https://github.com/nodejs/node/pull/66844) +* \[[`e315417e09`](https://github.com/nodejs/node/commit/e315417e09)] - **build**: do not include vendored simdutf with `--shared-simdutf` (Yao Zi) [#67410](https://github.com/nodejs/node/pull/67410) +* \[[`acc312ffd0`](https://github.com/nodejs/node/commit/acc312ffd0)] - **build**: enable pie on linux (Chengzhong Wu) [#67386](https://github.com/nodejs/node/pull/67386) +* \[[`1d8f0e0930`](https://github.com/nodejs/node/commit/1d8f0e0930)] - **build**: separate host and target Rust artifacts in cross builds (Yuya Inoue) [#66823](https://github.com/nodejs/node/pull/66823) +* \[[`8d0b5894fd`](https://github.com/nodejs/node/commit/8d0b5894fd)] - **build**: refresh markdown lint dependencies on lockfile changes (Yuya Inoue) [#67185](https://github.com/nodejs/node/pull/67185) +* \[[`fd581886b0`](https://github.com/nodejs/node/commit/fd581886b0)] - **build**: use a single producer for shared generated files (Yuya Inoue) [#66804](https://github.com/nodejs/node/pull/66804) +* \[[`4c8cece947`](https://github.com/nodejs/node/commit/4c8cece947)] - **build**: sort the ICU source lists (Shelley Vohr) [#67206](https://github.com/nodejs/node/pull/67206) +* \[[`4d73c14454`](https://github.com/nodejs/node/commit/4d73c14454)] - **build**: fix overriding node\_path in GN build (David Babenko-Sanders) [#66805](https://github.com/nodejs/node/pull/66805) +* \[[`5b6ac38549`](https://github.com/nodejs/node/commit/5b6ac38549)] - **build**: warn on incompatible dtls configure flags (Antoine du Hamel) [#66892](https://github.com/nodejs/node/pull/66892) +* \[[`e1d02f7cdc`](https://github.com/nodejs/node/commit/e1d02f7cdc)] - **build**: include v8\_debug\_helper sources in the tarball (Chengzhong Wu) [#66763](https://github.com/nodejs/node/pull/66763) +* \[[`fac766f7b2`](https://github.com/nodejs/node/commit/fac766f7b2)] - **build**: warn on incompatible quic configure flags (Antoine du Hamel) [#66754](https://github.com/nodejs/node/pull/66754) +* \[[`d9e59ede58`](https://github.com/nodejs/node/commit/d9e59ede58)] - **build**: fail Windows CI on missing GYP sources (Yuya Inoue) [#66787](https://github.com/nodejs/node/pull/66787) +* \[[`f0a74d23b6`](https://github.com/nodejs/node/commit/f0a74d23b6)] - **build**: fix gtest integration (Antoine du Hamel) [#66735](https://github.com/nodejs/node/pull/66735) +* \[[`8664e708ca`](https://github.com/nodejs/node/commit/8664e708ca)] - **build,test**: setup perfetto tests on windows build (Chengzhong Wu) [#66731](https://github.com/nodejs/node/pull/66731) +* \[[`621b99d2e4`](https://github.com/nodejs/node/commit/621b99d2e4)] - **build,win**: minify pgo training build (Stefan Stojanovic) [#67214](https://github.com/nodejs/node/pull/67214) +* \[[`114bc1c73f`](https://github.com/nodejs/node/commit/114bc1c73f)] - **build,win**: fix Perfetto (StefanStojanovic) [#66876](https://github.com/nodejs/node/pull/66876) +* \[[`84636ed5af`](https://github.com/nodejs/node/commit/84636ed5af)] - **build,win**: fail fast in vcbuild without cargo (Ved Chaudhari) [#66858](https://github.com/nodejs/node/pull/66858) +* \[[`b0c030c3d1`](https://github.com/nodejs/node/commit/b0c030c3d1)] - **child\_process**: inherit a reassigned process.env (Caleb Everett) [#66883](https://github.com/nodejs/node/pull/66883) +* \[[`c1b8f0e971`](https://github.com/nodejs/node/commit/c1b8f0e971)] - **(SEMVER-MINOR)** **child\_process**: add subprocess.timedOut (Marco) [#66639](https://github.com/nodejs/node/pull/66639) +* \[[`e7c0957ffc`](https://github.com/nodejs/node/commit/e7c0957ffc)] - **crypto**: remove the FIPS provider name check (Filip Skokan) [#67358](https://github.com/nodejs/node/pull/67358) +* \[[`7265f62f95`](https://github.com/nodejs/node/commit/7265f62f95)] - **crypto**: fix ncrypto provider behavior (Brad Anderson) [#67039](https://github.com/nodejs/node/pull/67039) +* \[[`9216dbe5c1`](https://github.com/nodejs/node/commit/9216dbe5c1)] - **crypto**: prevent stale OpenSSL errors (Matteo Collina) [#67225](https://github.com/nodejs/node/pull/67225) +* \[[`e24a2c5069`](https://github.com/nodejs/node/commit/e24a2c5069)] - **crypto**: reuse HMAC contexts in createHmac() (Yagiz Nizipli) [#67109](https://github.com/nodejs/node/pull/67109) +* \[[`d5f2e3da8e`](https://github.com/nodejs/node/commit/d5f2e3da8e)] - **crypto**: cache digests for synchronous operations (Yagiz Nizipli) [#67109](https://github.com/nodejs/node/pull/67109) +* \[[`a2605a07b6`](https://github.com/nodejs/node/commit/a2605a07b6)] - **crypto**: skip DH checks for recognized groups (Filip Skokan) [#67071](https://github.com/nodejs/node/pull/67071) +* \[[`92f61d001f`](https://github.com/nodejs/node/commit/92f61d001f)] - **crypto**: add X509Certificate inspection getters (Filip Skokan) [#67082](https://github.com/nodejs/node/pull/67082) +* \[[`e76a35c134`](https://github.com/nodejs/node/commit/e76a35c134)] - **crypto**: preserve errors during X.509 issuer checks (Filip Skokan) [#66898](https://github.com/nodejs/node/pull/66898) +* \[[`7e7d6cfbcd`](https://github.com/nodejs/node/commit/7e7d6cfbcd)] - **crypto**: skip clearing empty OpenSSL error queues (Yagiz Nizipli) [#67109](https://github.com/nodejs/node/pull/67109) +* \[[`4a92e8a862`](https://github.com/nodejs/node/commit/4a92e8a862)] - **crypto**: reject immutable random fill buffers (Filip Skokan) [#66944](https://github.com/nodejs/node/pull/66944) +* \[[`12f0e03b22`](https://github.com/nodejs/node/commit/12f0e03b22)] - **crypto**: wire up SHA-3 with BoringSSL (Filip Skokan) [#66922](https://github.com/nodejs/node/pull/66922) +* \[[`015034140e`](https://github.com/nodejs/node/commit/015034140e)] - **crypto**: fix BoringSSL RSA-PSS macro redefinitions (Filip Skokan) [#66900](https://github.com/nodejs/node/pull/66900) +* \[[`92d3939f6c`](https://github.com/nodejs/node/commit/92d3939f6c)] - **crypto**: use `OPENSSL_SIZE_T` instead of hard coding `int` (Antoine du Hamel) [#66889](https://github.com/nodejs/node/pull/66889) +* \[[`1441eae2bf`](https://github.com/nodejs/node/commit/1441eae2bf)] - **crypto**: do not leak scrypt param check errors (Lazizbek Ergashev) [#66671](https://github.com/nodejs/node/pull/66671) +* \[[`3f012c21f8`](https://github.com/nodejs/node/commit/3f012c21f8)] - **crypto**: use `OPENSSL_SIZE_T` instead of hard coding `int` (Antoine du Hamel) [#66752](https://github.com/nodejs/node/pull/66752) +* \[[`ca5de65787`](https://github.com/nodejs/node/commit/ca5de65787)] - **crypto**: avoid reusing randomInt() cache bytes (Jiawen Geng) [#66597](https://github.com/nodejs/node/pull/66597) +* \[[`04e5a39ebf`](https://github.com/nodejs/node/commit/04e5a39ebf)] - **crypto,tls**: clone X.509 chains across isolates (Filip Skokan) [#66898](https://github.com/nodejs/node/pull/66898) +* \[[`a8ad67e8fd`](https://github.com/nodejs/node/commit/a8ad67e8fd)] - **deps**: upgrade npm to 11.21.3 (npm team) [#67628](https://github.com/nodejs/node/pull/67628) +* \[[`c88471d0ed`](https://github.com/nodejs/node/commit/c88471d0ed)] - **deps**: V8: cherry-pick be84cdeee94e (Igor Sheludko) [#67570](https://github.com/nodejs/node/pull/67570) +* \[[`3a9819f3e3`](https://github.com/nodejs/node/commit/3a9819f3e3)] - **deps**: V8: backport f607706154ea (Jakob Linke) [#67527](https://github.com/nodejs/node/pull/67527) +* \[[`008eec6b3d`](https://github.com/nodejs/node/commit/008eec6b3d)] - **deps**: V8: backport 35423c16d252 (pthier) [#67527](https://github.com/nodejs/node/pull/67527) +* \[[`db1fa03a98`](https://github.com/nodejs/node/commit/db1fa03a98)] - **deps**: V8: cherry-pick bb0e798c09e3 (Jakob Linke) [#67527](https://github.com/nodejs/node/pull/67527) +* \[[`df0291d31d`](https://github.com/nodejs/node/commit/df0291d31d)] - **deps**: V8: backport ee1c92f63568 (Jakob Linke) [#67527](https://github.com/nodejs/node/pull/67527) +* \[[`ef65ffdd93`](https://github.com/nodejs/node/commit/ef65ffdd93)] - **deps**: V8: cherry-pick 53588faba3ed (Jakob Linke) [#67527](https://github.com/nodejs/node/pull/67527) +* \[[`b4325270e5`](https://github.com/nodejs/node/commit/b4325270e5)] - **deps**: update Rust crates for V8 14.6.202.34-node.40 (Renegade334) [#67474](https://github.com/nodejs/node/pull/67474) +* \[[`408a64d072`](https://github.com/nodejs/node/commit/408a64d072)] - **deps**: V8: cherry-pick third\_party/rust update from cce7146a7a2a (v8-ci-autoroll-builder) [#67474](https://github.com/nodejs/node/pull/67474) +* \[[`c60d0725f9`](https://github.com/nodejs/node/commit/c60d0725f9)] - **deps**: V8: backport a05177279022 (René) [#67416](https://github.com/nodejs/node/pull/67416) +* \[[`aa42a0bdfc`](https://github.com/nodejs/node/commit/aa42a0bdfc)] - **deps**: update nghttp3 to 1.19.0 (Node.js GitHub Bot) [#67333](https://github.com/nodejs/node/pull/67333) +* \[[`448169cdf0`](https://github.com/nodejs/node/commit/448169cdf0)] - **deps**: V8: cherry-pick 785a2ea88a90 (Antoine du Hamel) [#66876](https://github.com/nodejs/node/pull/66876) +* \[[`8e95e486d2`](https://github.com/nodejs/node/commit/8e95e486d2)] - **deps**: V8: backport 2444c109f4f8 (Austin Burdine) [#66736](https://github.com/nodejs/node/pull/66736) +* \[[`7e9d8a7fc5`](https://github.com/nodejs/node/commit/7e9d8a7fc5)] - **deps**: V8: backport 8521e2e77535 (LuYahan) [#65898](https://github.com/nodejs/node/pull/65898) +* \[[`df1b8db2a2`](https://github.com/nodejs/node/commit/df1b8db2a2)] - **deps**: V8: backport 1e7ee91de775 (Jakob Linke) [#67207](https://github.com/nodejs/node/pull/67207) +* \[[`42e3a14f1f`](https://github.com/nodejs/node/commit/42e3a14f1f)] - **deps**: V8: backport d315af3d83cf (pthier) [#67207](https://github.com/nodejs/node/pull/67207) +* \[[`9adc368ed3`](https://github.com/nodejs/node/commit/9adc368ed3)] - **deps**: V8: backport b69a1a1d8613 (Jakob Linke) [#67207](https://github.com/nodejs/node/pull/67207) +* \[[`c54a21b132`](https://github.com/nodejs/node/commit/c54a21b132)] - **deps**: V8: cherry-pick 19e7a57bce3e (pthier) [#67207](https://github.com/nodejs/node/pull/67207) +* \[[`bca95eb331`](https://github.com/nodejs/node/commit/bca95eb331)] - **deps**: V8: backport e540e1161b02 (pthier) [#67207](https://github.com/nodejs/node/pull/67207) +* \[[`190faa4932`](https://github.com/nodejs/node/commit/190faa4932)] - **deps**: V8: cherry-pick f331137d5968 (Milad Fa) [#67261](https://github.com/nodejs/node/pull/67261) +* \[[`7c7371d039`](https://github.com/nodejs/node/commit/7c7371d039)] - **deps**: V8: cherry-pick c21a93ec80d5 (Olivier Flückiger) [#66729](https://github.com/nodejs/node/pull/66729) +* \[[`5baf2e0d69`](https://github.com/nodejs/node/commit/5baf2e0d69)] - **deps**: V8: cherry-pick 497c2e6a2434 (Dominik Inführ) [#66728](https://github.com/nodejs/node/pull/66728) +* \[[`61f750e875`](https://github.com/nodejs/node/commit/61f750e875)] - **deps**: upgrade npm to 11.21.2 (npm team) [#67264](https://github.com/nodejs/node/pull/67264) +* \[[`16fd46d775`](https://github.com/nodejs/node/commit/16fd46d775)] - **deps**: update nghttp2 to 1.71.0 (Node.js GitHub Bot) [#67331](https://github.com/nodejs/node/pull/67331) +* \[[`c9221de87d`](https://github.com/nodejs/node/commit/c9221de87d)] - **deps**: update ngtcp2 to 1.26.0 (Node.js GitHub Bot) [#67257](https://github.com/nodejs/node/pull/67257) +* \[[`0bd4e80001`](https://github.com/nodejs/node/commit/0bd4e80001)] - **deps**: update simdjson to 5.1.1 (Node.js GitHub Bot) [#67332](https://github.com/nodejs/node/pull/67332) +* \[[`65670b858d`](https://github.com/nodejs/node/commit/65670b858d)] - **deps**: load amaro from dist/internal.js (Geoffrey Booth) [#66144](https://github.com/nodejs/node/pull/66144) +* \[[`273d0fabbe`](https://github.com/nodejs/node/commit/273d0fabbe)] - **deps**: update amaro to 1.3.0 (Node.js GitHub Bot) [#66144](https://github.com/nodejs/node/pull/66144) +* \[[`92441a0216`](https://github.com/nodejs/node/commit/92441a0216)] - **deps**: update perfetto to 59.1 (Node.js GitHub Bot) [#67171](https://github.com/nodejs/node/pull/67171) +* \[[`e491c695e1`](https://github.com/nodejs/node/commit/e491c695e1)] - **deps**: update simdjson to 5.1.0 (Node.js GitHub Bot) [#67172](https://github.com/nodejs/node/pull/67172) +* \[[`c55e6091eb`](https://github.com/nodejs/node/commit/c55e6091eb)] - **deps**: update zlib to 1.3.2.1-motley-9f9f52c (Node.js GitHub Bot) [#66989](https://github.com/nodejs/node/pull/66989) +* \[[`c08a79da41`](https://github.com/nodejs/node/commit/c08a79da41)] - **deps**: update googletest to cd8e73f067129f8489e35c7b51c7a68552b289d2 (Node.js GitHub Bot) [#66814](https://github.com/nodejs/node/pull/66814) +* \[[`dbe7d0e346`](https://github.com/nodejs/node/commit/dbe7d0e346)] - **deps**: update simdjson to 5.0.5 (Node.js GitHub Bot) [#66817](https://github.com/nodejs/node/pull/66817) +* \[[`bae10aa822`](https://github.com/nodejs/node/commit/bae10aa822)] - **diagnostics\_channel**: fix dangling binding pointer (Trevor Burnham) [#65860](https://github.com/nodejs/node/pull/65860) +* \[[`de266b2d14`](https://github.com/nodejs/node/commit/de266b2d14)] - **doc**: fix typo in releases.md (Ultron) [#67463](https://github.com/nodejs/node/pull/67463) +* \[[`8571516808`](https://github.com/nodejs/node/commit/8571516808)] - **doc**: add aduh95 as last security release stewards (Antoine du Hamel) [#67434](https://github.com/nodejs/node/pull/67434) +* \[[`1151d515a7`](https://github.com/nodejs/node/commit/1151d515a7)] - **doc**: explain how sqlite binds numbers and BigInts (Trevor Burnham) [#67424](https://github.com/nodejs/node/pull/67424) +* \[[`590048b15d`](https://github.com/nodejs/node/commit/590048b15d)] - **doc**: document invalid X509Certificate validity times (Sarthak Ahuja) [#67406](https://github.com/nodejs/node/pull/67406) +* \[[`c6e2cc45ee`](https://github.com/nodejs/node/commit/c6e2cc45ee)] - **doc**: explain fallback arrays in package exports targets (Manjeet Singh) [#67393](https://github.com/nodejs/node/pull/67393) +* \[[`4979be93ae`](https://github.com/nodejs/node/commit/4979be93ae)] - **doc**: document `this` binding in TLS callbacks (Robert I Nilsson) [#66682](https://github.com/nodejs/node/pull/66682) +* \[[`648e3ed0c7`](https://github.com/nodejs/node/commit/648e3ed0c7)] - **doc**: document --allow-fs-vfs in the permission model page (Rafael Gonzaga) [#66793](https://github.com/nodejs/node/pull/66793) +* \[[`dec658010d`](https://github.com/nodejs/node/commit/dec658010d)] - **doc**: list openssl-store channel and drop field in permissions (Rafael Gonzaga) [#66558](https://github.com/nodejs/node/pull/66558) +* \[[`6e90b7ca31`](https://github.com/nodejs/node/commit/6e90b7ca31)] - **doc**: update readable.read() for v26 one-chunk behaviour (Fuma) [#67341](https://github.com/nodejs/node/pull/67341) +* \[[`f00c4f6430`](https://github.com/nodejs/node/commit/f00c4f6430)] - **doc**: add efekrskl to collaborators (Efe Karasakal) [#67376](https://github.com/nodejs/node/pull/67376) +* \[[`293fbcc0cd`](https://github.com/nodejs/node/commit/293fbcc0cd)] - **doc**: add Philipp Dunkel to contributors (Philipp Dunkel) [#67378](https://github.com/nodejs/node/pull/67378) +* \[[`d8db12ede8`](https://github.com/nodejs/node/commit/d8db12ede8)] - **doc**: add christianaurichzm to collaborators (Christian Aurich Zanettini Martins) [#67377](https://github.com/nodejs/node/pull/67377) +* \[[`cf2a3eb1f3`](https://github.com/nodejs/node/commit/cf2a3eb1f3)] - **doc**: fix process import in test runner workerId example (Daijiro Wachi) [#67316](https://github.com/nodejs/node/pull/67316) +* \[[`ae48779d97`](https://github.com/nodejs/node/commit/ae48779d97)] - **doc**: clarify process.loadEnvFile variable precedence (manjit singh) [#67276](https://github.com/nodejs/node/pull/67276) +* \[[`f1c005497f`](https://github.com/nodejs/node/commit/f1c005497f)] - **doc**: fix security pre-alert template (Antoine du Hamel) [#67240](https://github.com/nodejs/node/pull/67240) +* \[[`65d4f1cfad`](https://github.com/nodejs/node/commit/65d4f1cfad)] - **doc**: fix execFile/execFileSync shell option docs (Paul Bouchon) [#64437](https://github.com/nodejs/node/pull/64437) +* \[[`139507aaf0`](https://github.com/nodejs/node/commit/139507aaf0)] - **doc**: document C++ formatting in the pull request guide (Yuya Inoue) [#67205](https://github.com/nodejs/node/pull/67205) +* \[[`97dfaed090`](https://github.com/nodejs/node/commit/97dfaed090)] - **doc**: describe how the permission model grants the entrypoint (Rafael Gonzaga) [#67038](https://github.com/nodejs/node/pull/67038) +* \[[`e099865024`](https://github.com/nodejs/node/commit/e099865024)] - **doc**: add LIEF to the dependency list (Yuya Inoue) [#67165](https://github.com/nodejs/node/pull/67165) +* \[[`b0e7aef4db`](https://github.com/nodejs/node/commit/b0e7aef4db)] - **doc**: ffi rename OS/400 -> IBM i (Abdirahim Musse) [#67144](https://github.com/nodejs/node/pull/67144) +* \[[`a43f9a1f8d`](https://github.com/nodejs/node/commit/a43f9a1f8d)] - **doc**: remove CI lockdown steps from security releases (Ulises Gascón) [#67116](https://github.com/nodejs/node/pull/67116) +* \[[`546277a806`](https://github.com/nodejs/node/commit/546277a806)] - **doc**: clarify that V8 major upgrade uses stable release (Joyee Cheung) [#67106](https://github.com/nodejs/node/pull/67106) +* \[[`c89f5391f7`](https://github.com/nodejs/node/commit/c89f5391f7)] - **doc**: note linear history rule on branch-off (Rafael Gonzaga) [#67057](https://github.com/nodejs/node/pull/67057) +* \[[`5816401bcd`](https://github.com/nodejs/node/commit/5816401bcd)] - **doc**: remove outdated platform note for --watch-path (yuki motokane) [#66749](https://github.com/nodejs/node/pull/66749) +* \[[`f69426a7c5`](https://github.com/nodejs/node/commit/f69426a7c5)] - **doc**: fix sqlite tagged template examples (Donghoon Kang) [#66920](https://github.com/nodejs/node/pull/66920) +* \[[`f87b1d5637`](https://github.com/nodejs/node/commit/f87b1d5637)] - **doc**: document the alpha release process (Rafael Gonzaga) [#66796](https://github.com/nodejs/node/pull/66796) +* \[[`a2858eaaee`](https://github.com/nodejs/node/commit/a2858eaaee)] - **doc**: fix grammar and phrasing in typescript.md (Ravi Arnan Irianto) [#66977](https://github.com/nodejs/node/pull/66977) +* \[[`a066b2cf04`](https://github.com/nodejs/node/commit/a066b2cf04)] - **doc**: add rafael and antoine as last security release stewards (Rafael Gonzaga) [#66909](https://github.com/nodejs/node/pull/66909) +* \[[`6390e0ee67`](https://github.com/nodejs/node/commit/6390e0ee67)] - **doc**: update config schema for test-forbid-only (Filip Skokan) [#66945](https://github.com/nodejs/node/pull/66945) +* \[[`5374634610`](https://github.com/nodejs/node/commit/5374634610)] - **doc**: mark test runner watch mode as stable (Guilherme Araújo) [#66708](https://github.com/nodejs/node/pull/66708) +* \[[`5f984385ee`](https://github.com/nodejs/node/commit/5f984385ee)] - **doc**: update node-config-schema.json (Marco Ippolito) [#66827](https://github.com/nodejs/node/pull/66827) +* \[[`214d5e77dd`](https://github.com/nodejs/node/commit/214d5e77dd)] - **doc**: update V8 ABI release policy (Rafael Gonzaga) [#64196](https://github.com/nodejs/node/pull/64196) +* \[[`3e8eb44660`](https://github.com/nodejs/node/commit/3e8eb44660)] - **doc**: add doc on when to backport V8 patches to main (Chengzhong Wu) [#66710](https://github.com/nodejs/node/pull/66710) +* \[[`0f93f4a75c`](https://github.com/nodejs/node/commit/0f93f4a75c)] - **doc**: add hoondongkang as triager (Donghoon Kang) [#66427](https://github.com/nodejs/node/pull/66427) +* \[[`f534a4c31f`](https://github.com/nodejs/node/commit/f534a4c31f)] - **doc**: warn against awaiting replies in module hooks (Paul Bouchon) [#65590](https://github.com/nodejs/node/pull/65590) +* \[[`1a6d5e0365`](https://github.com/nodejs/node/commit/1a6d5e0365)] - **doc**: correct QuicStream direction and id types (Kisnner Obando) [#66687](https://github.com/nodejs/node/pull/66687) +* \[[`9ef0b7ad92`](https://github.com/nodejs/node/commit/9ef0b7ad92)] - **doc**: clarify hex code usage in styleText docs (Chris Swithinbank) [#66539](https://github.com/nodejs/node/pull/66539) +* \[[`281d50af7b`](https://github.com/nodejs/node/commit/281d50af7b)] - **doc,crypto**: mark raw key formats as stable (Filip Skokan) [#66829](https://github.com/nodejs/node/pull/66829) +* \[[`53a5bd6560`](https://github.com/nodejs/node/commit/53a5bd6560)] - **events**: report original once() listener on removal (Ved Chaudhari) [#66621](https://github.com/nodejs/node/pull/66621) +* \[[`831d5a12da`](https://github.com/nodejs/node/commit/831d5a12da)] - **ffi**: reject multi-argument buffer fast trampolines (Trivikram Kamat) [#67046](https://github.com/nodejs/node/pull/67046) +* \[[`59943ca000`](https://github.com/nodejs/node/commit/59943ca000)] - **ffi**: reject signature conflicts from getFunctions getters (Trivikram Kamat) [#67194](https://github.com/nodejs/node/pull/67194) +* \[[`d69c446bd6`](https://github.com/nodejs/node/commit/d69c446bd6)] - **ffi**: support function calls from pointers (Damiano Mazzella) [#66458](https://github.com/nodejs/node/pull/66458) +* \[[`237fd0d169`](https://github.com/nodejs/node/commit/237fd0d169)] - **ffi**: make Fast API functions collectable (Trivikram Kamat) [#67177](https://github.com/nodejs/node/pull/67177) +* \[[`4f1597c4de`](https://github.com/nodejs/node/commit/4f1597c4de)] - **ffi**: define function pointer property as own data property (Trivikram Kamat) [#67170](https://github.com/nodejs/node/pull/67170) +* \[[`a613c18f06`](https://github.com/nodejs/node/commit/a613c18f06)] - **ffi**: keep DynamicLibrary alive while callbacks are registered (Trivikram Kamat) [#66842](https://github.com/nodejs/node/pull/66842) +* \[[`e4879ef5fe`](https://github.com/nodejs/node/commit/e4879ef5fe)] - **ffi**: reject arguments after callback in registerCallback (Trivikram Kamat) [#66997](https://github.com/nodejs/node/pull/66997) +* \[[`c9dddad6df`](https://github.com/nodejs/node/commit/c9dddad6df)] - **ffi**: accept -0 for int32 and uint32 arguments (Trivikram Kamat) [#67035](https://github.com/nodejs/node/pull/67035) +* \[[`7145dcb47c`](https://github.com/nodejs/node/commit/7145dcb47c)] - **ffi**: free libuv error message on failed dlopen (Trivikram Kamat) [#67007](https://github.com/nodejs/node/pull/67007) +* \[[`53570d28da`](https://github.com/nodejs/node/commit/53570d28da)] - **ffi**: drain task queues after event loop callbacks (Trivikram Kamat) [#66918](https://github.com/nodejs/node/pull/66918) +* \[[`1103d3f48c`](https://github.com/nodejs/node/commit/1103d3f48c)] - **ffi**: fix handle leak in fast buffer arguments (Trivikram Kamat) [#66867](https://github.com/nodejs/node/pull/66867) +* \[[`eb17705099`](https://github.com/nodejs/node/commit/eb17705099)] - **ffi**: add getFunction cache-miss benchmark (Donghoon Kang) [#66456](https://github.com/nodejs/node/pull/66456) +* \[[`30dbe1487a`](https://github.com/nodejs/node/commit/30dbe1487a)] - **ffi**: add binary parameter to internal binding type (Donghoon Kang) [#66502](https://github.com/nodejs/node/pull/66502) +* \[[`d59e71d80f`](https://github.com/nodejs/node/commit/d59e71d80f)] - **fs**: keep readFile abortable on non-regular files (Christian Aurich Zanettini Martins) [#66940](https://github.com/nodejs/node/pull/66940) +* \[[`9960109e99`](https://github.com/nodejs/node/commit/9960109e99)] - **fs**: resolve symlinks before parent components (Jason Zhang) [#65457](https://github.com/nodejs/node/pull/65457) +* \[[`942fd1b903`](https://github.com/nodejs/node/commit/942fd1b903)] - **fs**: fix cpSync() abort when dest is a dangling symlink (Yohannes Desta) [#67142](https://github.com/nodejs/node/pull/67142) +* \[[`19cae95c1e`](https://github.com/nodejs/node/commit/19cae95c1e)] - **fs**: fix readFileSync utf8 overflow on short reads (Christian Aurich Zanettini Martins) [#66939](https://github.com/nodejs/node/pull/66939) +* \[[`117f2ecc52`](https://github.com/nodejs/node/commit/117f2ecc52)] - **fs**: do not swallow exceptions thrown by completion callbacks (Marco) [#66308](https://github.com/nodejs/node/pull/66308) +* \[[`a2f43ceb19`](https://github.com/nodejs/node/commit/a2f43ceb19)] - **(SEMVER-MINOR)** **fs**: add mkstemp() (Marco) [#66484](https://github.com/nodejs/node/pull/66484) +* \[[`094ca1f741`](https://github.com/nodejs/node/commit/094ca1f741)] - **http**: emit 'drain' after flushing coalesced chunks (junyup0503) [#66782](https://github.com/nodejs/node/pull/66782) +* \[[`22717d1d8f`](https://github.com/nodejs/node/commit/22717d1d8f)] - **(SEMVER-MINOR)** **http**: batch body spans per parser execute (Guilherme Araújo) [#67187](https://github.com/nodejs/node/pull/67187) +* \[[`46ff0d9310`](https://github.com/nodejs/node/commit/46ff0d9310)] - **http2**: exclude queued data from response memory checks (Yuya Inoue) [#67114](https://github.com/nodejs/node/pull/67114) +* \[[`9f5ec47ce3`](https://github.com/nodejs/node/commit/9f5ec47ce3)] - **http2**: do not reset stream before END\_STREAM is sent (Barath Raj) [#66672](https://github.com/nodejs/node/pull/66672) +* \[[`4c9f87877c`](https://github.com/nodejs/node/commit/4c9f87877c)] - **http2**: preserve multiple content-encoding values (Yuya Inoue) [#67184](https://github.com/nodejs/node/pull/67184) +* \[[`19957e3521`](https://github.com/nodejs/node/commit/19957e3521)] - **http2**: release queued data memory on stream cancellation (Yuya Inoue) [#67113](https://github.com/nodejs/node/pull/67113) +* \[[`8d169a89cc`](https://github.com/nodejs/node/commit/8d169a89cc)] - **http2**: clear the session timeout before marking it destroyed (Huang-404-Q) [#66886](https://github.com/nodejs/node/pull/66886) +* \[[`b8bfb2a05b`](https://github.com/nodejs/node/commit/b8bfb2a05b)] - **inspector**: fix out-of-bounds read in ws frame decoding (nashit hayat) [#64618](https://github.com/nodejs/node/pull/64618) +* \[[`cc3a434a98`](https://github.com/nodejs/node/commit/cc3a434a98)] - **lib**: reintroduce `_http_` aliases (Antoine du Hamel) [#67546](https://github.com/nodejs/node/pull/67546) +* \[[`2bd2c2950d`](https://github.com/nodejs/node/commit/2bd2c2950d)] - **lib**: lib: move `_http_*` to `internal/http` (Antoine du Hamel) [#67546](https://github.com/nodejs/node/pull/67546) +* \[[`b2347deb85`](https://github.com/nodejs/node/commit/b2347deb85)] - **lib**: place `value` before `done` in iterator results (Kevin Gibbons) [#66837](https://github.com/nodejs/node/pull/66837) +* \[[`6fef75c41f`](https://github.com/nodejs/node/commit/6fef75c41f)] - **(SEMVER-MINOR)** **lib**: speed up AbortSignal (Robert Nagy) [#66789](https://github.com/nodejs/node/pull/66789) +* \[[`1a8c999b02`](https://github.com/nodejs/node/commit/1a8c999b02)] - **lib**: optimize TextEncoder.encode for short strings (Mert Can Altin) [#66831](https://github.com/nodejs/node/pull/66831) +* \[[`3fac84c034`](https://github.com/nodejs/node/commit/3fac84c034)] - **meta**: add Fatih Güzel to .mailmap (Fatih Güzel) [#67622](https://github.com/nodejs/node/pull/67622) +* \[[`e747f54caa`](https://github.com/nodejs/node/commit/e747f54caa)] - **meta**: update Trevor Burnham's email in `.mailmap` (Trevor Burnham) [#67425](https://github.com/nodejs/node/pull/67425) +* \[[`487cfb3f37`](https://github.com/nodejs/node/commit/487cfb3f37)] - **meta**: bump rtCamp/action-slack-notify from 2.4.0 to 2.4.1 (dependabot\[bot]) [#67190](https://github.com/nodejs/node/pull/67190) +* \[[`afc2418140`](https://github.com/nodejs/node/commit/afc2418140)] - **meta**: bump step-security/harden-runner from 2.21.1 to 2.22.3 (dependabot\[bot]) [#67191](https://github.com/nodejs/node/pull/67191) +* \[[`82addc3612`](https://github.com/nodejs/node/commit/82addc3612)] - **meta**: bump cachix/install-nix-action from 31.11.1 to 31.11.3 (dependabot\[bot]) [#67019](https://github.com/nodejs/node/pull/67019) +* \[[`af7b97d574`](https://github.com/nodejs/node/commit/af7b97d574)] - **meta**: bump ossf/scorecard-action from 2.4.4 to 2.5.0 (dependabot\[bot]) [#67020](https://github.com/nodejs/node/pull/67020) +* \[[`d2446118fe`](https://github.com/nodejs/node/commit/d2446118fe)] - **meta**: bump actions/setup-python from 7.0.0 to 7.1.0 (dependabot\[bot]) [#67021](https://github.com/nodejs/node/pull/67021) +* \[[`0805564c46`](https://github.com/nodejs/node/commit/0805564c46)] - **meta**: bump actions/setup-node from 7.0.0 to 7.1.0 (dependabot\[bot]) [#67032](https://github.com/nodejs/node/pull/67032) +* \[[`e233b55e0d`](https://github.com/nodejs/node/commit/e233b55e0d)] - **meta**: bump actions/download-artifact from 8.0.1 to 8.0.2 (dependabot\[bot]) [#67018](https://github.com/nodejs/node/pull/67018) +* \[[`52ad018f3c`](https://github.com/nodejs/node/commit/52ad018f3c)] - **meta**: bump actions/upload-artifact from 7.0.1 to 7.0.2 (dependabot\[bot]) [#67024](https://github.com/nodejs/node/pull/67024) +* \[[`1ab11281a7`](https://github.com/nodejs/node/commit/1ab11281a7)] - **meta**: bump github/codeql-action/init from 4.38.2 to 4.39.1 (dependabot\[bot]) [#67028](https://github.com/nodejs/node/pull/67028) +* \[[`c994c7fe02`](https://github.com/nodejs/node/commit/c994c7fe02)] - **meta**: label top-level GN build files (Yuya Inoue) [#66808](https://github.com/nodejs/node/pull/66808) +* \[[`47768fba23`](https://github.com/nodejs/node/commit/47768fba23)] - **meta**: ignore AGENTS.override.md (Matteo Collina) [#66629](https://github.com/nodejs/node/pull/66629) +* \[[`fc80c6c1c8`](https://github.com/nodejs/node/commit/fc80c6c1c8)] - **module**: avoid reparsing package.json in esm format detection (Gürgün Dayıoğlu) [#66982](https://github.com/nodejs/node/pull/66982) +* \[[`bb6de74919`](https://github.com/nodejs/node/commit/bb6de74919)] - **module**: add "worker" condition for Web Worker threads (Guy Bedford) [#66635](https://github.com/nodejs/node/pull/66635) +* \[[`900ec5791a`](https://github.com/nodejs/node/commit/900ec5791a)] - **(SEMVER-MINOR)** **module**: add --experimental-strip-private-modules (Marco Ippolito) [#63869](https://github.com/nodejs/node/pull/63869) +* \[[`473173ca88`](https://github.com/nodejs/node/commit/473173ca88)] - **module**: fix require(esm) on the module.register() hooks thread (Matteo Collina) [#66770](https://github.com/nodejs/node/pull/66770) +* \[[`a12ec11d7b`](https://github.com/nodejs/node/commit/a12ec11d7b)] - **net**: fail closed when BlockList peer address is unavailable (Matteo Collina) [#66640](https://github.com/nodejs/node/pull/66640) +* \[[`6a9db450cb`](https://github.com/nodejs/node/commit/6a9db450cb)] - **net,tls**: fix session reuse with provided sockets (Harjoth Khara) [#64430](https://github.com/nodejs/node/pull/64430) +* \[[`ae36323cf8`](https://github.com/nodejs/node/commit/ae36323cf8)] - **node-api**: fix crash on TSFN finalization reentrance at shutdown (Chengzhong Wu) [#65967](https://github.com/nodejs/node/pull/65967) +* \[[`1f5d6a6fcc`](https://github.com/nodejs/node/commit/1f5d6a6fcc)] - **(SEMVER-MINOR)** **process**: return unregister fn from finalization (Matteo Collina) [#66482](https://github.com/nodejs/node/pull/66482) +* \[[`bd6f51c5b2`](https://github.com/nodejs/node/commit/bd6f51c5b2)] - **querystring**: precompute Latin-1 escapes (Roberto Bianchi) [#66756](https://github.com/nodejs/node/pull/66756) +* \[[`47de18cc61`](https://github.com/nodejs/node/commit/47de18cc61)] - **quic**: retain readers for readable streams (Dustin) [#66407](https://github.com/nodejs/node/pull/66407) +* \[[`4b9a0b7bb2`](https://github.com/nodejs/node/commit/4b9a0b7bb2)] - **quic**: fix crypto error classification (Efe Karasakal) [#66968](https://github.com/nodejs/node/pull/66968) +* \[[`27e67c9be7`](https://github.com/nodejs/node/commit/27e67c9be7)] - **quic**: fix internal error code conversion (Efe Karasakal) [#66967](https://github.com/nodejs/node/pull/66967) +* \[[`066e03d402`](https://github.com/nodejs/node/commit/066e03d402)] - **quic**: remove obsolete setOutbound() (Efe Karasakal) [#66646](https://github.com/nodejs/node/pull/66646) +* \[[`37b4435191`](https://github.com/nodejs/node/commit/37b4435191)] - **quic**: truncate CONNECTION\_CLOSE frame reason field (Efe Karasakal) [#66644](https://github.com/nodejs/node/pull/66644) +* \[[`4a37d08ceb`](https://github.com/nodejs/node/commit/4a37d08ceb)] - **quic**: allow null body when opening streams (Efe Karasakal) [#66690](https://github.com/nodejs/node/pull/66690) +* \[[`613b8b61f9`](https://github.com/nodejs/node/commit/613b8b61f9)] - **quic**: reuse header support assertion (Efe Karasakal) [#66777](https://github.com/nodejs/node/pull/66777) +* \[[`a05ff481f9`](https://github.com/nodejs/node/commit/a05ff481f9)] - **quic**: validate stream error codes (Efe Karasakal) [#66650](https://github.com/nodejs/node/pull/66650) +* \[[`5becd96658`](https://github.com/nodejs/node/commit/5becd96658)] - **sqlite**: add ReadOptionalString helper (Guilherme Araújo) [#67042](https://github.com/nodejs/node/pull/67042) +* \[[`f168543aaa`](https://github.com/nodejs/node/commit/f168543aaa)] - **sqlite**: use 64-bit result APIs for UDF return values (Guilherme Araújo) [#67089](https://github.com/nodejs/node/pull/67089) +* \[[`1dd9dbef18`](https://github.com/nodejs/node/commit/1dd9dbef18)] - **sqlite**: cache the SQLTagStore constructor template (Guilherme Araújo) [#66912](https://github.com/nodejs/node/pull/66912) +* \[[`2ae36bda76`](https://github.com/nodejs/node/commit/2ae36bda76)] - **sqlite**: settle BackupJob through a single exit point (Guilherme Araújo) [#66912](https://github.com/nodejs/node/pull/66912) +* \[[`8e9fef5321`](https://github.com/nodejs/node/commit/8e9fef5321)] - **sqlite**: use DeleteFnPtr for all SQLite handles (Guilherme Araújo) [#66912](https://github.com/nodejs/node/pull/66912) +* \[[`1fb58b93fc`](https://github.com/nodejs/node/commit/1fb58b93fc)] - **sqlite**: track statements in the Statement constructor (Guilherme Araújo) [#66912](https://github.com/nodejs/node/pull/66912) +* \[[`f033c5aa2c`](https://github.com/nodejs/node/commit/f033c5aa2c)] - **sqlite**: avoid sqlite3\_clear\_bindings() before every run (Michał Fox) [#66983](https://github.com/nodejs/node/pull/66983) +* \[[`fd7dc863d0`](https://github.com/nodejs/node/commit/fd7dc863d0)] - **sqlite**: retry busy or locked backup steps (Lazizbek Ergashev) [#66769](https://github.com/nodejs/node/pull/66769) +* \[[`6360b8ab53`](https://github.com/nodejs/node/commit/6360b8ab53)] - **sqlite**: validate backup() source is a Database (Guilherme Araújo) [#66797](https://github.com/nodejs/node/pull/66797) +* \[[`fbbacb939d`](https://github.com/nodejs/node/commit/fbbacb939d)] - **sqlite**: skip return() on exhausted virtual table iterators (Trivikram Kamat) [#66519](https://github.com/nodejs/node/pull/66519) +* \[[`558bc8ebb8`](https://github.com/nodejs/node/commit/558bc8ebb8)] - **sqlite**: propagate errors from Database option getters (Guilherme Araújo) [#66748](https://github.com/nodejs/node/pull/66748) +* \[[`8da7c4f4c6`](https://github.com/nodejs/node/commit/8da7c4f4c6)] - **sqlite**: use shared-shape objects for result rows (Guilherme Araújo) [#66385](https://github.com/nodejs/node/pull/66385) +* \[[`00839e2d84`](https://github.com/nodejs/node/commit/00839e2d84)] - **src**: do not enable the inspector during snapshot building (Joyee Cheung) [#67154](https://github.com/nodejs/node/pull/67154) +* \[[`c558d85160`](https://github.com/nodejs/node/commit/c558d85160)] - _**Revert**_ "**src**: seed V8 from the OS CSPRNG instead of OpenSSL's DRBG" (Filip Skokan) [#66903](https://github.com/nodejs/node/pull/66903) +* \[[`d47af538e3`](https://github.com/nodejs/node/commit/d47af538e3)] - **src**: fix build with `--shared-brotli` (Lazizbek Ergashev) [#66895](https://github.com/nodejs/node/pull/66895) +* \[[`08ea9a1ab7`](https://github.com/nodejs/node/commit/08ea9a1ab7)] - **src**: avoid truncating Blob sizes to 32 bits (Christian Aurich Zanettini Martins) [#66207](https://github.com/nodejs/node/pull/66207) +* \[[`14cb1f52a4`](https://github.com/nodejs/node/commit/14cb1f52a4)] - **src**: cut small costs in node::MakeCallback (Nigro Simone) [#66395](https://github.com/nodejs/node/pull/66395) +* \[[`bde88e106a`](https://github.com/nodejs/node/commit/bde88e106a)] - **src**: keep ALS store in AsyncResource::MakeCallback (Nigro Simone) [#66326](https://github.com/nodejs/node/pull/66326) +* \[[`0529e7853c`](https://github.com/nodejs/node/commit/0529e7853c)] - **src,permission**: do not grant cwd read access without entrypoint (Rafael Gonzaga) [#66645](https://github.com/nodejs/node/pull/66645) +* \[[`29cdb9df56`](https://github.com/nodejs/node/commit/29cdb9df56)] - **stream**: keep async context of the pipeTo pump (Matteo Collina) [#67054](https://github.com/nodejs/node/pull/67054) +* \[[`3c334ad92d`](https://github.com/nodejs/node/commit/3c334ad92d)] - **stream**: trim webstreams sink wrappers and BYOB transfers (Matteo Collina) [#66702](https://github.com/nodejs/node/pull/66702) +* \[[`1d82e0ff74`](https://github.com/nodejs/node/commit/1d82e0ff74)] - **stream**: fix pipeTo assert when writer is released during microtask (Qingyu Wang) [#63733](https://github.com/nodejs/node/pull/63733) +* \[[`a330e6f66c`](https://github.com/nodejs/node/commit/a330e6f66c)] - **stream**: reject writes during WritableStream close (Matteo Collina) [#67058](https://github.com/nodejs/node/pull/67058) +* \[[`c9dc9dcb45`](https://github.com/nodejs/node/commit/c9dc9dcb45)] - **stream**: keep async context of fromWeb writes (Matteo Collina) [#67055](https://github.com/nodejs/node/pull/67055) +* \[[`4f2e200e1b`](https://github.com/nodejs/node/commit/4f2e200e1b)] - **stream**: keep async context of pipeTo watchers (Matteo Collina) [#67052](https://github.com/nodejs/node/pull/67052) +* \[[`6563ba17aa`](https://github.com/nodejs/node/commit/6563ba17aa)] - **stream**: trim TransformStream construction costs (Matteo Collina) [#66643](https://github.com/nodejs/node/pull/66643) +* \[[`3b6a489cf3`](https://github.com/nodejs/node/commit/3b6a489cf3)] - **stream**: make stream/iter from() cancellation waits cheaper (James M Snell) [#66648](https://github.com/nodejs/node/pull/66648) +* \[[`efa7bb55b1`](https://github.com/nodejs/node/commit/efa7bb55b1)] - **stream**: share the once option for stream/iter abort listeners (James M Snell) [#66648](https://github.com/nodejs/node/pull/66648) +* \[[`d99c0416df`](https://github.com/nodejs/node/commit/d99c0416df)] - **stream**: do not miss 'drain' in fromWritable() (James M Snell) [#66648](https://github.com/nodejs/node/pull/66648) +* \[[`bd793f1313`](https://github.com/nodejs/node/commit/bd793f1313)] - **stream**: construct the options passed to stream/iter transforms (James M Snell) [#66648](https://github.com/nodejs/node/pull/66648) +* \[[`80c84f9ac7`](https://github.com/nodejs/node/commit/80c84f9ac7)] - **stream**: construct stream/iter wait and merge records (James M Snell) [#66648](https://github.com/nodejs/node/pull/66648) +* \[[`d164ecd7ff`](https://github.com/nodejs/node/commit/d164ecd7ff)] - **stream**: construct stream/iter byte view snapshots and batch entries (James M Snell) [#66648](https://github.com/nodejs/node/pull/66648) +* \[[`b58e5b64b5`](https://github.com/nodejs/node/commit/b58e5b64b5)] - **stream**: avoid per-write allocations in stream/iter writers (James M Snell) [#66648](https://github.com/nodejs/node/pull/66648) +* \[[`ee8d377e50`](https://github.com/nodejs/node/commit/ee8d377e50)] - **stream**: create stream/iter iterator results with a constructor (James M Snell) [#66648](https://github.com/nodejs/node/pull/66648) +* \[[`05d9793857`](https://github.com/nodejs/node/commit/05d9793857)] - **stream**: make endSync() optional in pipeToSync() (James M Snell) [#66648](https://github.com/nodejs/node/pull/66648) +* \[[`a20322182b`](https://github.com/nodejs/node/commit/a20322182b)] - **stream**: keep long-lived stream/iter objects in fast mode (James M Snell) [#66648](https://github.com/nodejs/node/pull/66648) +* \[[`a5bbc7b880`](https://github.com/nodejs/node/commit/a5bbc7b880)] - **stream**: keep async context of parked writes (Matteo Collina) [#66907](https://github.com/nodejs/node/pull/66907) +* \[[`22b722b24e`](https://github.com/nodejs/node/commit/22b722b24e)] - **test**: fix on zfs build host (Marcel) [#67517](https://github.com/nodejs/node/pull/67517) +* \[[`aafda1a7e3`](https://github.com/nodejs/node/commit/aafda1a7e3)] - **test**: add regression test for worker terminate during TLA parent evaluation (Matteo Collina) [#67570](https://github.com/nodejs/node/pull/67570) +* \[[`c74438ce60`](https://github.com/nodejs/node/commit/c74438ce60)] - **test**: extend http2 cancellation coverage (Fatih Güzel) [#66784](https://github.com/nodejs/node/pull/66784) +* \[[`b4924dd2cf`](https://github.com/nodejs/node/commit/b4924dd2cf)] - **test**: use relative paths within test directory in `test-watch-mode.mjs` (Livia Medeiros) [#67343](https://github.com/nodejs/node/pull/67343) +* \[[`cb321b615e`](https://github.com/nodejs/node/commit/cb321b615e)] - **test**: deflake test-tls-resume-servername (Christian Aurich Zanettini Martins) [#67450](https://github.com/nodejs/node/pull/67450) +* \[[`574be6346b`](https://github.com/nodejs/node/commit/574be6346b)] - **test**: deflake test-fs-stat-cancel-inflight under FIPS (Christian Aurich Zanettini Martins) [#67449](https://github.com/nodejs/node/pull/67449) +* \[[`ee5a6d81fe`](https://github.com/nodejs/node/commit/ee5a6d81fe)] - **test**: deflake test-watch-mode-files\_watcher (Yuya Inoue) [#67298](https://github.com/nodejs/node/pull/67298) +* \[[`2361b800f5`](https://github.com/nodejs/node/commit/2361b800f5)] - **test**: deflake watch mode test for missing env file (Farid Zakaria) [#67041](https://github.com/nodejs/node/pull/67041) +* \[[`81f4c14831`](https://github.com/nodejs/node/commit/81f4c14831)] - **test**: increase iterations on histogram test after snapshot changes (Stewart X Addison) [#67379](https://github.com/nodejs/node/pull/67379) +* \[[`4db6f865e7`](https://github.com/nodejs/node/commit/4db6f865e7)] - **test**: update WPT for WebCryptoAPI to e87deca336 (Node.js GitHub Bot) [#67330](https://github.com/nodejs/node/pull/67330) +* \[[`cd4e1417db`](https://github.com/nodejs/node/commit/cd4e1417db)] - **test**: deflake test-runner-mock-timers-scheduler (Yuya Inoue) [#67296](https://github.com/nodejs/node/pull/67296) +* \[[`8554feb650`](https://github.com/nodejs/node/commit/8554feb650)] - **test**: deflake test-worker-eventlooputil (Matteo Collina) [#67260](https://github.com/nodejs/node/pull/67260) +* \[[`730c582463`](https://github.com/nodejs/node/commit/730c582463)] - **test**: skip readFileSync pipe test without proc io (Jay) [#67242](https://github.com/nodejs/node/pull/67242) +* \[[`c824e7cd1b`](https://github.com/nodejs/node/commit/c824e7cd1b)] - **test**: use experimental flags in wpt tests (Aviv Keller) [#67258](https://github.com/nodejs/node/pull/67258) +* \[[`20d6055008`](https://github.com/nodejs/node/commit/20d6055008)] - **test**: use valid PBKDF2 inputs in domain test (Filip Skokan) [#67250](https://github.com/nodejs/node/pull/67250) +* \[[`d0c7be40f1`](https://github.com/nodejs/node/commit/d0c7be40f1)] - **test**: cover crypto digest and HMAC caches (Yagiz Nizipli) [#67109](https://github.com/nodejs/node/pull/67109) +* \[[`b92e0f6669`](https://github.com/nodejs/node/commit/b92e0f6669)] - **test**: fix cluster dgram 1 test on macos (gegham1) [#66986](https://github.com/nodejs/node/pull/66986) +* \[[`64d75bc661`](https://github.com/nodejs/node/commit/64d75bc661)] - **test**: convert forEach to for of test-buffer-inheritance file (Antonio Duran) [#67121](https://github.com/nodejs/node/pull/67121) +* \[[`41e8612056`](https://github.com/nodejs/node/commit/41e8612056)] - **test**: replace for each with for of (Sergio Calderon) [#67122](https://github.com/nodejs/node/pull/67122) +* \[[`9f214f5f58`](https://github.com/nodejs/node/commit/9f214f5f58)] - **test**: use spawnSyncAndAssert in nested async stack overflow test (Antonio Duran) [#67123](https://github.com/nodejs/node/pull/67123) +* \[[`59d390fba6`](https://github.com/nodejs/node/commit/59d390fba6)] - **test**: convert .forEach to for...of (Jan Peer Stöcklmair) [#67124](https://github.com/nodejs/node/pull/67124) +* \[[`16d1cfd187`](https://github.com/nodejs/node/commit/16d1cfd187)] - **test**: convert .forEach to for...of in test-net-write-arguments.js (Emmanuel Florencio Trujillo) [#67125](https://github.com/nodejs/node/pull/67125) +* \[[`d08d94384f`](https://github.com/nodejs/node/commit/d08d94384f)] - **test**: convert for each to for of in test/parallel/test-net-server-close (Raymundo Lopez Santiago) [#67127](https://github.com/nodejs/node/pull/67127) +* \[[`8bd2acdf53`](https://github.com/nodejs/node/commit/8bd2acdf53)] - **test**: use for...of in test-require-resolve-invalid-paths (Raul Garcia) [#67128](https://github.com/nodejs/node/pull/67128) +* \[[`43b993d4f9`](https://github.com/nodejs/node/commit/43b993d4f9)] - **test**: deflake test-worker-message-port-transfer-filehandle-fd0 (Christian Aurich Zanettini Martins) [#66980](https://github.com/nodejs/node/pull/66980) +* \[[`9c7b282076`](https://github.com/nodejs/node/commit/9c7b282076)] - **test**: remove duplicate `common` imports (Livia Medeiros) [#67088](https://github.com/nodejs/node/pull/67088) +* \[[`45d622c014`](https://github.com/nodejs/node/commit/45d622c014)] - **test**: add test for concurrent first use of OpenSSL (Christian Aurich Zanettini Martins) [#66966](https://github.com/nodejs/node/pull/66966) +* \[[`75ad54c48b`](https://github.com/nodejs/node/commit/75ad54c48b)] - **test**: use registerHooks() over module.register() (Geoffrey Booth) [#67074](https://github.com/nodejs/node/pull/67074) +* \[[`62f8c7485e`](https://github.com/nodejs/node/commit/62f8c7485e)] - **test**: update test426-fixtures to fae1fa49815813088c433e8486e330e8d953a44 (Node.js GitHub Bot) [#66815](https://github.com/nodejs/node/pull/66815) +* \[[`a8ae8e6bd7`](https://github.com/nodejs/node/commit/a8ae8e6bd7)] - **test**: check html and json doc files are generated (Richard Lau) [#66613](https://github.com/nodejs/node/pull/66613) +* \[[`ac1666a023`](https://github.com/nodejs/node/commit/ac1666a023)] - **test**: adapt `test-blocklist` to libuv 1.53+ (Antoine du Hamel) [#67002](https://github.com/nodejs/node/pull/67002) +* \[[`4cd1a7fd76`](https://github.com/nodejs/node/commit/4cd1a7fd76)] - **test**: remove obsolete BoringSSL skips (Filip Skokan) [#66922](https://github.com/nodejs/node/pull/66922) +* \[[`fdadf15323`](https://github.com/nodejs/node/commit/fdadf15323)] - **test**: fix TLS coalescing test for OpenSSL 4.1 (Filip Skokan) [#66962](https://github.com/nodejs/node/pull/66962) +* \[[`7d9d18ea1c`](https://github.com/nodejs/node/commit/7d9d18ea1c)] - _**Revert**_ "**test**: mark worker init failure flaky on SmartOS" (Filip Skokan) [#66903](https://github.com/nodejs/node/pull/66903) +* \[[`08428bebf4`](https://github.com/nodejs/node/commit/08428bebf4)] - **test**: handle stringbytes allocation failures (Filip Skokan) [#66887](https://github.com/nodejs/node/pull/66887) +* \[[`5fd81baf19`](https://github.com/nodejs/node/commit/5fd81baf19)] - **test**: deflake test-http-agent-keepalive (Filip Skokan) [#66887](https://github.com/nodejs/node/pull/66887) +* \[[`f293b86c9b`](https://github.com/nodejs/node/commit/f293b86c9b)] - **test**: send SNI in CA certificate test (Tamir Duberstein) [#66835](https://github.com/nodejs/node/pull/66835) +* \[[`674fc34195`](https://github.com/nodejs/node/commit/674fc34195)] - **test**: keep objects alive in finalization fixtures (Matteo Collina) [#66869](https://github.com/nodejs/node/pull/66869) +* \[[`2d72918af3`](https://github.com/nodejs/node/commit/2d72918af3)] - **test**: update WPT for WebCryptoAPI to e15690d276 (Node.js GitHub Bot) [#66813](https://github.com/nodejs/node/pull/66813) +* \[[`a251f737b9`](https://github.com/nodejs/node/commit/a251f737b9)] - **test**: skip openssl config test under BoringSSL (David Babenko-Sanders) [#66780](https://github.com/nodejs/node/pull/66780) +* \[[`47437d98ac`](https://github.com/nodejs/node/commit/47437d98ac)] - **test**: account for OpenSSL 4.x changes (Filip Skokan) [#66775](https://github.com/nodejs/node/pull/66775) +* \[[`5a615b0272`](https://github.com/nodejs/node/commit/5a615b0272)] - **test**: deflake test-filehandle-close (Filip Skokan) [#66750](https://github.com/nodejs/node/pull/66750) +* \[[`9c2b2ade76`](https://github.com/nodejs/node/commit/9c2b2ade76)] - **test**: wait for shared-isolate Worker exit (Filip Skokan) [#66722](https://github.com/nodejs/node/pull/66722) +* \[[`44c7188a26`](https://github.com/nodejs/node/commit/44c7188a26)] - **test**: move large SQLite string cases to pummel (Filip Skokan) [#66722](https://github.com/nodejs/node/pull/66722) +* \[[`8189a563ba`](https://github.com/nodejs/node/commit/8189a563ba)] - **test**: allow periodic flush to finish under load (Filip Skokan) [#66722](https://github.com/nodejs/node/pull/66722) +* \[[`c01f8dfe17`](https://github.com/nodejs/node/commit/c01f8dfe17)] - **test**: wait for inspector restart before exit (Filip Skokan) [#66722](https://github.com/nodejs/node/pull/66722) +* \[[`2f39614d27`](https://github.com/nodejs/node/commit/2f39614d27)] - **test**: retry unready process timeout reports (Filip Skokan) [#66722](https://github.com/nodejs/node/pull/66722) +* \[[`f5eb0d89f5`](https://github.com/nodejs/node/commit/f5eb0d89f5)] - **test**: cover source-specific membership on closed sockets (Rich Trott) [#66624](https://github.com/nodejs/node/pull/66624) +* \[[`57231f2c7c`](https://github.com/nodejs/node/commit/57231f2c7c)] - **test**: update WPT for WebCryptoAPI to b638c093cd (Node.js GitHub Bot) [#66689](https://github.com/nodejs/node/pull/66689) +* \[[`9fc002efd4`](https://github.com/nodejs/node/commit/9fc002efd4)] - **test**: skip test failing when run under root (Livia Medeiros) [#66666](https://github.com/nodejs/node/pull/66666) +* \[[`02342352f2`](https://github.com/nodejs/node/commit/02342352f2)] - **test\_runner**: add option to forbid exclusive tests (joao-oliveira-softtor) [#66578](https://github.com/nodejs/node/pull/66578) +* \[[`972da90d42`](https://github.com/nodejs/node/commit/972da90d42)] - **test\_runner**: use AsyncLocalStorage instead of async\_hooks (Matteo Collina) [#66795](https://github.com/nodejs/node/pull/66795) +* \[[`7bdf3cb1d1`](https://github.com/nodejs/node/commit/7bdf3cb1d1)] - **(SEMVER-MINOR)** **test\_runner**: add mockReturnValue and promise helpers (Guilherme Araújo) [#66631](https://github.com/nodejs/node/pull/66631) +* \[[`3a85380c63`](https://github.com/nodejs/node/commit/3a85380c63)] - **tls**: reject hostnames with forbidden code points (Matteo Collina) [#67254](https://github.com/nodejs/node/pull/67254) +* \[[`03d24b0f4d`](https://github.com/nodejs/node/commit/03d24b0f4d)] - **tls**: test the SPKI blocklist with a fixture key (Ulises Gascón) [#66949](https://github.com/nodejs/node/pull/66949) +* \[[`0504aab04e`](https://github.com/nodejs/node/commit/0504aab04e)] - **tls**: configure TLS 1.3 ciphers with BoringSSL (Filip Skokan) [#66922](https://github.com/nodejs/node/pull/66922) +* \[[`fc502dde5e`](https://github.com/nodejs/node/commit/fc502dde5e)] - **tls**: coalesce buffered records into one read (Robert Nagy) [#66698](https://github.com/nodejs/node/pull/66698) +* \[[`ad94073ae7`](https://github.com/nodejs/node/commit/ad94073ae7)] - **tls**: add tlsSocket.socket, to access the raw stream beneath TLS (Tim Perry) [#66598](https://github.com/nodejs/node/pull/66598) +* \[[`ecbd6f7879`](https://github.com/nodejs/node/commit/ecbd6f7879)] - **tls,tools**: update BoringSSL pin and TLS errors (Filip Skokan) [#66922](https://github.com/nodejs/node/pull/66922) +* \[[`cad1ec93bf`](https://github.com/nodejs/node/commit/cad1ec93bf)] - **tools**: remove duplicate variables (Antoine du Hamel) [#67511](https://github.com/nodejs/node/pull/67511) +* \[[`7a0bf5da06`](https://github.com/nodejs/node/commit/7a0bf5da06)] - **tools**: sort OpenSSL releases numerically (Filip Skokan) [#67441](https://github.com/nodejs/node/pull/67441) +* \[[`ffd895cf20`](https://github.com/nodejs/node/commit/ffd895cf20)] - **tools**: check notarization status when verifying macOS binaries (Ulises Gascon) [#67541](https://github.com/nodejs/node/pull/67541) +* \[[`386805c788`](https://github.com/nodejs/node/commit/386805c788)] - **tools**: add support for multiple-commit PRs in `review_backport.sh` (Antoine du Hamel) [#67108](https://github.com/nodejs/node/pull/67108) +* \[[`eff99c1826`](https://github.com/nodejs/node/commit/eff99c1826)] - **tools**: notarize bin/node in the darwin tarballs (Ulises Gascón) [#67143](https://github.com/nodejs/node/pull/67143) +* \[[`8d4b832c93`](https://github.com/nodejs/node/commit/8d4b832c93)] - **tools**: update mk-ca-bundle to 1.35 (René) [#67403](https://github.com/nodejs/node/pull/67403) +* \[[`e572a5a285`](https://github.com/nodejs/node/commit/e572a5a285)] - **tools**: enable strict mode for yamllint (Antoine du Hamel) [#67380](https://github.com/nodejs/node/pull/67380) +* \[[`6e292ec34a`](https://github.com/nodejs/node/commit/6e292ec34a)] - **tools**: aggregate Nix changes in a table (Antoine du Hamel) [#67348](https://github.com/nodejs/node/pull/67348) +* \[[`86d5cd6ec9`](https://github.com/nodejs/node/commit/86d5cd6ec9)] - **tools**: use ubuntu-latest for public lint-js-and-md jobs (Yuya Inoue) [#66409](https://github.com/nodejs/node/pull/66409) +* \[[`1e8274169f`](https://github.com/nodejs/node/commit/1e8274169f)] - **tools**: warn when undici WPT report is missing (Filip Skokan) [#67229](https://github.com/nodejs/node/pull/67229) +* \[[`f94f25db87`](https://github.com/nodejs/node/commit/f94f25db87)] - **tools**: require `value` before `done` in iterator results (Kevin Gibbons) [#66837](https://github.com/nodejs/node/pull/66837) +* \[[`73b47ca18c`](https://github.com/nodejs/node/commit/73b47ca18c)] - **tools**: bump the eslint group in /tools/eslint with 2 updates (dependabot\[bot]) [#67189](https://github.com/nodejs/node/pull/67189) +* \[[`d919a87cdc`](https://github.com/nodejs/node/commit/d919a87cdc)] - **tools**: remove `node.gyp` and `node.gypi` from `v8.nix` requisites (Antoine du Hamel) [#66955](https://github.com/nodejs/node/pull/66955) +* \[[`c085cec88e`](https://github.com/nodejs/node/commit/c085cec88e)] - **tools**: fix number comparison if Nix diff viewer (Antoine du Hamel) [#66904](https://github.com/nodejs/node/pull/66904) +* \[[`755d919ae7`](https://github.com/nodejs/node/commit/755d919ae7)] - **tools**: bump the eslint group in /tools/eslint with 5 updates (dependabot\[bot]) [#67025](https://github.com/nodejs/node/pull/67025) +* \[[`5dcb9b1d22`](https://github.com/nodejs/node/commit/5dcb9b1d22)] - **tools**: bump piscina from 5.2.0 to 5.3.2 in /tools/doc (dependabot\[bot]) [#67026](https://github.com/nodejs/node/pull/67026) +* \[[`c77f2e339b`](https://github.com/nodejs/node/commit/c77f2e339b)] - **tools**: bump undici from 6.28.0 to 6.29.1 in /tools/doc (dependabot\[bot]) [#67027](https://github.com/nodejs/node/pull/67027) +* \[[`d14f217a90`](https://github.com/nodejs/node/commit/d14f217a90)] - **tools**: update gyp-next to 0.22.4 (Node.js GitHub Bot) [#66988](https://github.com/nodejs/node/pull/66988) +* \[[`e68efadc33`](https://github.com/nodejs/node/commit/e68efadc33)] - **tools**: do not lint GYP JS files (Antoine du Hamel) [#66988](https://github.com/nodejs/node/pull/66988) +* \[[`92b6c09ed7`](https://github.com/nodejs/node/commit/92b6c09ed7)] - **tools**: bump remark-preset-lint-node (dependabot\[bot]) [#67023](https://github.com/nodejs/node/pull/67023) +* \[[`f07e33fc17`](https://github.com/nodejs/node/commit/f07e33fc17)] - **tools**: grant CI workflows Actions read permission (Filip Skokan) [#66919](https://github.com/nodejs/node/pull/66919) +* \[[`aab3384b4c`](https://github.com/nodejs/node/commit/aab3384b4c)] - **tools**: limit checkout for lint-addon-docs (Yuya Inoue) [#66505](https://github.com/nodejs/node/pull/66505) +* \[[`ab6f045ebd`](https://github.com/nodejs/node/commit/ab6f045ebd)] - **tools**: add lint rule for unread benchmark `n` (Murat Kirazkaya) [#66807](https://github.com/nodejs/node/pull/66807) +* \[[`5276445f09`](https://github.com/nodejs/node/commit/5276445f09)] - **tools**: skip dependency update if PR has non-bot commits (Marco Ippolito) [#66503](https://github.com/nodejs/node/pull/66503) +* \[[`7f9f5d5d6c`](https://github.com/nodejs/node/commit/7f9f5d5d6c)] - **tools**: tolerate non-UTF-8 test output (Filip Skokan) [#66783](https://github.com/nodejs/node/pull/66783) +* \[[`763587a280`](https://github.com/nodejs/node/commit/763587a280)] - **tools**: update OpenSSL on the selected branch (Filip Skokan) [#66704](https://github.com/nodejs/node/pull/66704) +* \[[`e4f931249d`](https://github.com/nodejs/node/commit/e4f931249d)] - **tools**: add read-only access in `nix-changes.yml` (Antoine du Hamel) [#66691](https://github.com/nodejs/node/pull/66691) +* \[[`60649e5300`](https://github.com/nodejs/node/commit/60649e5300)] - **typings**: fix internal type resolution (Seongeun Lee) [#66512](https://github.com/nodejs/node/pull/66512) +* \[[`04f072c9b1`](https://github.com/nodejs/node/commit/04f072c9b1)] - **typings**: share Sign and Verify handle methods (Seongeun Lee) [#66499](https://github.com/nodejs/node/pull/66499) +* \[[`92bfe9ae4f`](https://github.com/nodejs/node/commit/92bfe9ae4f)] - **url**: use indexed appends in search params getAll (Roberto Bianchi) [#66872](https://github.com/nodejs/node/pull/66872) +* \[[`1540dfd21e`](https://github.com/nodejs/node/commit/1540dfd21e)] - **url**: skip plain prefixes in percent-escape checks (Roberto Bianchi) [#66696](https://github.com/nodejs/node/pull/66696) +* \[[`be145b610b`](https://github.com/nodejs/node/commit/be145b610b)] - **url**: reduce search params sort buffering (Roberto Bianchi) [#66665](https://github.com/nodejs/node/pull/66665) +* \[[`1d2be62b5e`](https://github.com/nodejs/node/commit/1d2be62b5e)] - **util**: use internal `hexSlice` directly in `util.inspect()` (Livia Medeiros) [#66974](https://github.com/nodejs/node/pull/66974) +* \[[`3f5f257a60`](https://github.com/nodejs/node/commit/3f5f257a60)] - **util**: fix inspecting URL subclass prototypes (Donghoon Kang) [#66822](https://github.com/nodejs/node/pull/66822) +* \[[`43b8f56a57`](https://github.com/nodejs/node/commit/43b8f56a57)] - **v8**: support X509Certificate serialization (Filip Skokan) [#67083](https://github.com/nodejs/node/pull/67083) +* \[[`422149fd7b`](https://github.com/nodejs/node/commit/422149fd7b)] - **vfs**: do not reuse the path of a loaded memfd image (Philipp Dunkel) [#67068](https://github.com/nodejs/node/pull/67068) +* \[[`de4fc5400d`](https://github.com/nodejs/node/commit/de4fc5400d)] - **vfs**: place `value` before `done` in iterator result (LiviaMedeiros) [#67231](https://github.com/nodejs/node/pull/67231) +* \[[`e4e5d1c5cb`](https://github.com/nodejs/node/commit/e4e5d1c5cb)] - **vfs**: forward the watchFile listener through RealFSProvider (Trivikram Kamat) [#66224](https://github.com/nodejs/node/pull/66224) +* \[[`4c5cc142c5`](https://github.com/nodejs/node/commit/4c5cc142c5)] - **vfs**: fix readlink, realpath and mkdtemp encoding (Christian Aurich Zanettini Martins) [#66352](https://github.com/nodejs/node/pull/66352) +* \[[`4956a1f053`](https://github.com/nodejs/node/commit/4956a1f053)] - **vfs**: fix promises.watch() with an already-aborted signal (Trivikram Kamat) [#66254](https://github.com/nodejs/node/pull/66254) +* \[[`fc5d0b3aec`](https://github.com/nodejs/node/commit/fc5d0b3aec)] - **vfs**: keep open memory handles in sync with file (Trivikram Kamat) [#66356](https://github.com/nodejs/node/pull/66356) +* \[[`7eb0f7a90f`](https://github.com/nodejs/node/commit/7eb0f7a90f)] - **vfs**: enforce readonly state on open handles (Harjoth Khara) [#64403](https://github.com/nodejs/node/pull/64403) +* \[[`2906fede22`](https://github.com/nodejs/node/commit/2906fede22)] - **vfs**: allow mounting in permission audit mode (Rafael Gonzaga) [#66745](https://github.com/nodejs/node/pull/66745) +* \[[`817eee082a`](https://github.com/nodejs/node/commit/817eee082a)] - **wasi**: accept wasm i32 pointers with high bit set (Guy Bedford) [#66636](https://github.com/nodejs/node/pull/66636) +* \[[`54626ad322`](https://github.com/nodejs/node/commit/54626ad322)] - **watch**: track all dependencies of an owner (Christian Aurich Zanettini Martins) [#66139](https://github.com/nodejs/node/pull/66139) +* \[[`632576930e`](https://github.com/nodejs/node/commit/632576930e)] - **(SEMVER-MINOR)** **worker**: preload streams into startup snapshot (Matteo Collina) [#66311](https://github.com/nodejs/node/pull/66311) +* \[[`3791c7b075`](https://github.com/nodejs/node/commit/3791c7b075)] - **zlib**: avoid an extra empty zstd frame (Marco) [#66161](https://github.com/nodejs/node/pull/66161) +* \[[`594525ae67`](https://github.com/nodejs/node/commit/594525ae67)] - **zlib**: restart format detection when resetting Unzip (Marco) [#66169](https://github.com/nodejs/node/pull/66169) +* \[[`ba673eb18b`](https://github.com/nodejs/node/commit/ba673eb18b)] - **zlib**: grow the output buffer of large async one-shot calls (Yagiz Nizipli) [#66863](https://github.com/nodejs/node/pull/66863) +* \[[`34134917a3`](https://github.com/nodejs/node/commit/34134917a3)] - **zlib**: finish async convenience calls in one write (Yagiz Nizipli) [#66863](https://github.com/nodejs/node/pull/66863) +* \[[`2d64e56faa`](https://github.com/nodejs/node/commit/2d64e56faa)] - **zlib**: skip the stream in sync convenience calls without options (Yagiz Nizipli) [#66864](https://github.com/nodejs/node/pull/66864) +* \[[`91cd10a868`](https://github.com/nodejs/node/commit/91cd10a868)] - **zlib**: add raw content read methods to ZipEntry (Philipp Dunkel) [#66801](https://github.com/nodejs/node/pull/66801) +* \[[`36b1de5ebd`](https://github.com/nodejs/node/commit/36b1de5ebd)] - **(SEMVER-MINOR)** **zlib**: add crc32c (Philipp Dunkel) [#66828](https://github.com/nodejs/node/pull/66828) + ## 2026-11-11, Version 26.13.1 'Lithium' (LTS), @aduh95 diff --git a/src/node_version.h b/src/node_version.h index b0949cd0767..5f9591b0873 100644 --- a/src/node_version.h +++ b/src/node_version.h @@ -23,13 +23,13 @@ #define SRC_NODE_VERSION_H_ #define NODE_MAJOR_VERSION 26 -#define NODE_MINOR_VERSION 13 -#define NODE_PATCH_VERSION 2 +#define NODE_MINOR_VERSION 14 +#define NODE_PATCH_VERSION 0 #define NODE_VERSION_IS_LTS 1 #define NODE_VERSION_LTS_CODENAME "Lithium" -#define NODE_VERSION_IS_RELEASE 0 +#define NODE_VERSION_IS_RELEASE 1 #ifndef NODE_STRINGIFY #define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n)