From 766b5646598054efd6a5f312e416728dffad8317 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 14 Oct 2026 15:17:21 -0500 Subject: [PATCH 1/7] Inline Map/Set iteration steps and skip deleted leading entries --- packages/compiler/src/backend/llvm/emitter.ts | 63 +++++++++- .../src/backend/llvm/expr-containers.ts | 39 +++--- .../backend/llvm/map-number-lookup.test.ts | 119 ++++++++++++++++++ .../src/backend/llvm/map-number-lookup.ts | 86 +++++++++++++ .../src/backend/llvm/map-read-lifetimes.ts | 1 + packages/compiler/src/contracts/check.ts | 2 + .../frontend/lowering/containers/for-of.ts | 8 +- packages/compiler/src/ir/ir.ts | 4 + packages/compiler/src/ir/validate.ts | 4 +- ...15-map-iterate-after-front-deletes.ts.json | 6 + .../corpus/5316-map-lru-eviction.ts.json | 6 + .../5317-map-iterate-while-mutating.ts.json | 6 + .../5318-set-iterate-after-deletes.ts.json | 6 + .../corpus/5319-map-iteration-values.ts.json | 6 + ...5320-map-iterate-across-compaction.ts.json | 6 + packages/runtime/src/scr_json.c | 2 +- packages/runtime/src/scr_map.c | 20 +++ packages/runtime/src/scr_map.test.c | 63 ++++++++++ packages/runtime/src/scr_runtime.h | 15 +++ .../5315-map-iterate-after-front-deletes.ts | 38 ++++++ tests/corpus/5316-map-lru-eviction.ts | 55 ++++++++ .../corpus/5317-map-iterate-while-mutating.ts | 52 ++++++++ .../corpus/5318-set-iterate-after-deletes.ts | 35 ++++++ tests/corpus/5319-map-iteration-values.ts | 47 +++++++ .../5320-map-iterate-across-compaction.ts | 47 +++++++ tests/harness/wasi-differential.test.ts | 5 + 26 files changed, 716 insertions(+), 25 deletions(-) create mode 100644 packages/compiler/src/backend/llvm/map-number-lookup.test.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5315-map-iterate-after-front-deletes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5316-map-lru-eviction.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5317-map-iterate-while-mutating.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5318-set-iterate-after-deletes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5319-map-iteration-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5320-map-iterate-across-compaction.ts.json create mode 100644 tests/corpus/5315-map-iterate-after-front-deletes.ts create mode 100644 tests/corpus/5316-map-lru-eviction.ts create mode 100644 tests/corpus/5317-map-iterate-while-mutating.ts create mode 100644 tests/corpus/5318-set-iterate-after-deletes.ts create mode 100644 tests/corpus/5319-map-iteration-values.ts create mode 100644 tests/corpus/5320-map-iterate-across-compaction.ts diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index d0b0623f24..6fd58f56a6 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -310,7 +310,11 @@ import { LlWalkers } from "./walkers.js"; import { isObjectArm, NULLABLE_ABSENT, NULLABLE_NULL, NullableUnions } from "./nullable-unions.js"; import { emitNullablePresent, emitUnionPeek, emitUnionTag } from "./union-repr.js"; import { literalCapWord, literalCapWord32 } from "./string-key-hash.js"; -import { NUMBER_MAP_ENTRY_DECL, STRING_MAP_ENTRY_DECL } from "./map-number-lookup.js"; +import { + MAP_ITER_DECL, + NUMBER_MAP_ENTRY_DECL, + STRING_MAP_ENTRY_DECL, +} from "./map-number-lookup.js"; import { STRING_READ_HELPERS, stringScanDecl } from "./string-reads.js"; import { emitConcatInputs, @@ -2019,17 +2023,22 @@ export class LlEmitter { ? [] : [`%ScrMapRc = type { ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr }`]), // The complete ScrMap and its { key, val, hash } entry, read by the - // inline number-key lookup (sc_map_entry_f64): field 11 is the i64 - // absent-key filter, entries is field 13, the direct index and its - // length fields 19 and 20. - ...(this.decls.has(NUMBER_MAP_ENTRY_DECL) || this.decls.has(STRING_MAP_ENTRY_DECL) + // inline number-key lookup (sc_map_entry_f64) and the inline + // iteration steps (sc_map_iter_entry): field 9 is the entry count, + // field 11 the i64 absent-key filter, entries is field 13, the direct + // index and its length fields 19 and 20. + ...(this.decls.has(NUMBER_MAP_ENTRY_DECL) || + this.decls.has(STRING_MAP_ENTRY_DECL) || + this.decls.has(MAP_ITER_DECL) ? [ `%ScrMapIx = type { ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr, ${this.sizeType}, ${this.sizeType}, i64, ${this.sizeType}, ptr, ${this.sizeType}, ptr, ${this.sizeType}, ptr, ptr, ptr, ${this.sizeType} }`, ] : []), // String-keyed reference reads load the value slot of the entry // scr_map_entry_str returns (map-number-lookup.ts). - ...(this.decls.has(NUMBER_MAP_ENTRY_DECL) || this.decls.has(STRING_MAP_ENTRY_DECL) + ...(this.decls.has(NUMBER_MAP_ENTRY_DECL) || + this.decls.has(STRING_MAP_ENTRY_DECL) || + this.decls.has(MAP_ITER_DECL) ? [`%ScrMapEntry = type { i64, i64, i64 }`] : []), // The runtime error prefix { rc, vt, name, message, code, cause } and the @@ -2940,6 +2949,48 @@ export class LlEmitter { ``, ); } + // Map/Set iteration steps read the entries array inline: an index is + // live when it is below the entry count and its entry's cached hash is + // nonzero (a tombstone's is zero), as scr_map_iter_live decides. The + // entry count is read again at every step, so entries appended during + // the iteration are visited. + if (this.decls.has(MAP_ITER_DECL)) { + const sz = this.sizeType; + defs.push( + `define internal ptr @sc_map_iter_entry(ptr %m, double %i) ${FN_ATTRS} {`, + `entry:`, + ` %np = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 9`, + ` %n = load ${sz}, ptr %np`, + ` %nf = uitofp ${sz} %n to double`, + ` %lo = fcmp oge double %i, 0.0`, + ` %hi = fcmp olt double %i, %nf`, + ` %in = and i1 %lo, %hi`, + ` br i1 %in, label %load, label %none`, + `load:`, + ` %ix = fptoui double %i to ${sz}`, + ` %ep = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 13`, + ` %entries = load ptr, ptr %ep`, + ` %e = getelementptr inbounds %ScrMapEntry, ptr %entries, ${sz} %ix`, + ` %hp = getelementptr inbounds %ScrMapEntry, ptr %e, i32 0, i32 2`, + ` %h = load i64, ptr %hp`, + ` %live = icmp ne i64 %h, 0`, + ` br i1 %live, label %yes, label %none`, + `yes:`, + ` ret ptr %e`, + `none:`, + ` ret ptr null`, + `}`, + ``, + `define internal double @sc_map_iter_count(ptr %m) ${FN_ATTRS} {`, + `entry:`, + ` %np = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 9`, + ` %n = load ${sz}, ptr %np`, + ` %nf = uitofp ${sz} %n to double`, + ` ret double %nf`, + `}`, + ``, + ); + } // String-key Map/Set lookups test the map's absent-key filter inline // (scr_map.c scr_map_filter_bits): a key whose two filter bits are not // both set is absent, so most misses on small and medium maps return diff --git a/packages/compiler/src/backend/llvm/expr-containers.ts b/packages/compiler/src/backend/llvm/expr-containers.ts index 3c4cf4ff52..17c2a42857 100644 --- a/packages/compiler/src/backend/llvm/expr-containers.ts +++ b/packages/compiler/src/backend/llvm/expr-containers.ts @@ -27,6 +27,10 @@ import { entryStringKey, } from "./map-read-lifetimes.js"; import { + emitMapIterCount, + emitMapIterEntry, + emitMapIterSlot, + emitMapIterStart, emitNumberMapGetRef, emitNumberMapGetScalar, emitNumberMapHas, @@ -1325,23 +1329,30 @@ export function emitMapLikeIntrinsic( host.declare(`declare void @scr_map_clear(ptr)`); B.line(`call void @scr_map_clear(ptr ${r.name})`); return { name: "", type: e.type }; - case "iterCount": { - host.declare(`declare double @scr_map_iter_count(ptr)`); - const t = B.tmp(); - B.line(`${t} = call double @scr_map_iter_count(ptr ${r.name})`); - return { name: t, type: e.type }; - } + case "iterCount": + return { name: emitMapIterCount(host, r.name), type: e.type }; + case "iterStart": + return { name: emitMapIterStart(host, r.name), type: e.type }; case "iterLive": { const i = host.emitExpr(e.args[0]!); - host.declare(`declare zeroext i1 @scr_map_iter_live(ptr, double)`); + const entry = emitMapIterEntry(host, r.name, i.name); const t = B.tmp(); - B.line(`${t} = call zeroext i1 @scr_map_iter_live(ptr ${r.name}, double ${i.name})`); + B.line(`${t} = icmp ne ptr ${entry}, null`); return { name: t, type: e.type }; } case "iterKey": { // String/ref keys come back +1 (own registers the owned temp). const i = host.emitExpr(e.args[0]!); - const retTy = kAcc === "f64" ? "double" : kAcc === "bool" ? "zeroext i1" : "ptr"; + if (kAcc !== "ref") { + const retTy = kAcc === "f64" ? "double" : kAcc === "bool" ? "zeroext i1" : "ptr"; + const symbol = `scr_map_iter_key_${kAcc}`; + const t = emitMapIterSlot(host, r.name, i.name, 0, kAcc === "str" ? "ref" : kAcc, key, { + decl: `declare ${retTy} @${symbol}(ptr, double)`, + symbol, + }); + return host.own({ name: t, type: e.type }); + } + const retTy = "ptr"; host.declare(`declare ${retTy} @scr_map_iter_key_${kAcc}(ptr, double)`); const t = B.tmp(); B.line(`${t} = call ${retTy} @scr_map_iter_key_${kAcc}(ptr ${r.name}, double ${i.name})`); @@ -1352,11 +1363,11 @@ export function emitMapLikeIntrinsic( const vAcc = elemAccess(receiverType.value); const i = host.emitExpr(e.args[0]!); const retTy = vAcc === "f64" ? "double" : vAcc === "bool" ? "i1" : "ptr"; - host.declare( - `declare ${vAcc === "bool" ? "zeroext i1" : retTy} @scr_map_iter_val_${vAcc}(ptr, double)`, - ); - const t = B.tmp(); - B.line(`${t} = call ${retTy} @scr_map_iter_val_${vAcc}(ptr ${r.name}, double ${i.name})`); + const symbol = `scr_map_iter_val_${vAcc}`; + const t = emitMapIterSlot(host, r.name, i.name, 1, vAcc, receiverType.value, { + decl: `declare ${vAcc === "bool" ? "zeroext i1" : retTy} @${symbol}(ptr, double)`, + symbol, + }); return host.own({ name: t, type: e.type }); } case "iterEnter": diff --git a/packages/compiler/src/backend/llvm/map-number-lookup.test.ts b/packages/compiler/src/backend/llvm/map-number-lookup.test.ts new file mode 100644 index 0000000000..dbaf66fedb --- /dev/null +++ b/packages/compiler/src/backend/llvm/map-number-lookup.test.ts @@ -0,0 +1,119 @@ +import { expect, test } from "vitest"; +import { + BOOL, + F64, + STRING, + VOID, + type IrExpr, + type IrFunction, + type IrModule, + type IrStmt, + type IrType, +} from "../../ir/ir.js"; +import { validateModule } from "../../ir/validate.js"; +import { emitLlvmModule } from "./emitter.js"; + +const loc = { file: "map-iteration.ts", start: 0, end: 1 }; +const ref = (localId: string, type: IrType): IrExpr => ({ kind: "varRef", localId, type, loc }); + +/** work(map, i): the key (or, for `read: "value"`, the value) at a live + * index, after the walk's start and count reads the for-of desugar makes. */ +function fixture(key: IrType, value: IrType, read: "key" | "value"): IrModule { + const map: IrType = { kind: "map", key, value }; + const step = (method: string, args: IrExpr[], type: IrType): IrExpr => + ({ kind: "mapIntrinsic", method, receiver: ref("map", map), args, type, loc }) as IrExpr; + const result = read === "key" ? key : value; + const body: IrStmt[] = [ + { kind: "varDecl", localId: "start", init: step("iterStart", [], F64), loc }, + { kind: "varDecl", localId: "count", init: step("iterCount", [], F64), loc }, + { + kind: "if", + cond: step("iterLive", [ref("i", F64)], BOOL), + then: [ + { + kind: "return", + value: step(read === "key" ? "iterKey" : "iterValue", [ref("i", F64)], result), + loc, + }, + ], + else_: null, + loc, + }, + { + kind: "return", + value: step(read === "key" ? "iterKey" : "iterValue", [ref("start", F64)], result), + loc, + }, + ]; + const params = [ + { localId: "map", name: "map", type: map }, + { localId: "i", name: "i", type: F64 }, + ]; + const work: IrFunction = { + name: "work", + params, + returnType: result, + loc, + locals: [ + ...params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: true })), + { id: "start", name: "start", type: F64, mutable: false }, + { id: "count", name: "count", type: F64, mutable: false }, + ], + body, + }; + return { + irVersion: 16, + sourceFile: loc.file, + entry: "main", + records: [], + unions: [], + functions: [{ name: "main", params: [], locals: [], returnType: VOID, body: [], loc }, work], + }; +} + +function emitted(mod: IrModule, bits: 32 | 64): { work: string; module: string } { + expect(validateModule(mod)).toEqual([]); + const module = emitLlvmModule(mod, { pointerBits: bits }); + const work = /^define internal [^\n]*@sc_(?:b)?f_work(?:\.i32)?\([^]*?^}/m.exec(module)![0]; + return { work, module }; +} + +test("iteration steps read the entries array inline on both ABIs", () => { + for (const bits of [32, 64] as const) { + const sz = bits === 64 ? "i64" : "i32"; + const { work, module } = emitted(fixture(STRING, F64, "value"), bits); + // Field 9 is the entry count and 13 the entries array; a zero hash + // (entry field 2) marks a tombstone. + expect(module).toMatch(/^define internal ptr @sc_map_iter_entry\(ptr %m, double %i\)/m); + expect(module).toContain(`getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 9`); + expect(module).toContain(`getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 13`); + expect(module).toContain(`getelementptr inbounds %ScrMapEntry, ptr %e, i32 0, i32 2`); + expect(module).toContain(`%n = load ${sz}, ptr %np`); + // The walk's start comes from the runtime, which skips a deleted prefix. + expect(work).toContain("call double @scr_map_iter_start("); + expect(work).toContain("call double @sc_map_iter_count("); + expect(work).toContain("call ptr @sc_map_iter_entry("); + expect(work).not.toContain("@scr_map_iter_live"); + expect(work).not.toContain("@scr_map_iter_count"); + // The value loads from field 1 of a live entry; the runtime accessor is + // only the fallback for an index the guard excludes. + expect(work).toContain("getelementptr inbounds %ScrMapEntry, ptr"); + expect(work).toMatch(/i32 0, i32 1\n\s+%t\d+ = load double/); + expect(work).toContain("call double @scr_map_iter_val_f64("); + } +}); + +test("string keys and reference values are retained inline, boolean slots compare against zero", () => { + const key = emitted(fixture(STRING, F64, "key"), 64).work; + expect(key).toMatch(/i32 0, i32 0\n\s+%t\d+ = load ptr/); + expect(key).toContain("@scr_str_retain"); + expect(key).toContain("call ptr @scr_map_iter_key_str("); + + const flag = emitted(fixture(F64, BOOL, "value"), 64).work; + expect(flag).toMatch(/load i64, ptr %t\d+\n\s+%t\d+ = icmp ne i64 %t\d+, 0/); + expect(flag).toContain("call i1 @scr_map_iter_val_bool("); + + const text = emitted(fixture(F64, STRING, "value"), 64).work; + expect(text).toContain("@scr_str_retain"); + expect(text).toContain("call ptr @scr_map_iter_val_ref("); +}); diff --git a/packages/compiler/src/backend/llvm/map-number-lookup.ts b/packages/compiler/src/backend/llvm/map-number-lookup.ts index 3fbdd8f9a4..abee9c0071 100644 --- a/packages/compiler/src/backend/llvm/map-number-lookup.ts +++ b/packages/compiler/src/backend/llvm/map-number-lookup.ts @@ -12,6 +12,13 @@ * filter inline and defers to scr_map_entry_str otherwise: reference reads * retain inline rather than through the runtime's indirect adapter call, * and scalar reads and has() share the one lookup. + * + * The iteration steps behind for-of, forEach and the other entry walks read + * the entries array through the internal sc_map_iter_entry and + * sc_map_iter_count helpers: a live entry's key or value loads in place, + * and the runtime accessor runs only for an index the walk's liveness + * guard excludes. for-of starts at scr_map_iter_start, past a deleted + * prefix. */ import type { IrType } from "../../ir/ir.js"; import type { LlvmEmitterContext } from "./expr-context.js"; @@ -146,3 +153,82 @@ export function emitNumberMapHas(host: LlvmEmitterContext, map: string, key: str host.B.line(`${found} = icmp ne ptr ${entry}, null`); return found; } + +/** Declared by the inline Map/Set iteration steps; its presence makes the + * emitter define sc_map_iter_entry and sc_map_iter_count (emitter.ts). */ +export const MAP_ITER_DECL = "declare zeroext i1 @scr_map_iter_live(ptr, double)"; + +/** The entry at an iteration index, or null for a tombstone or an index at + * or past the entry count (the scr_map_iter_live test). */ +export function emitMapIterEntry(host: LlvmEmitterContext, map: string, index: string): string { + host.declare(MAP_ITER_DECL); + const entry = host.B.tmp(); + host.B.line(`${entry} = call ptr @sc_map_iter_entry(ptr ${map}, double ${index})`); + return entry; +} + +/** The first live index (scr_map_iter_start), where for-of starts: the + * runtime walks the deleted prefix once and remembers where it ends. */ +export function emitMapIterStart(host: LlvmEmitterContext, map: string): string { + host.declare("declare double @scr_map_iter_start(ptr)"); + const start = host.B.tmp(); + host.B.line(`${start} = call double @scr_map_iter_start(ptr ${map})`); + return start; +} + +/** The entry count, tombstones included (scr_map_iter_count). */ +export function emitMapIterCount(host: LlvmEmitterContext, map: string): string { + host.declare(MAP_ITER_DECL); + const count = host.B.tmp(); + host.B.line(`${count} = call double @sc_map_iter_count(ptr ${map})`); + return count; +} + +/** The key (field 0) or value (field 1) of the live entry at an iteration + * index, read inline: a number as double, a boolean as i1, and a string or + * reference retained with `type`'s retain (+1), the adapter the collection + * stores it with. An index that is not live calls `runtime`, the runtime + * accessor, which reports the internal error the iteration guard rules out. */ +export function emitMapIterSlot( + host: LlvmEmitterContext, + map: string, + index: string, + field: 0 | 1, + access: "f64" | "bool" | "ref", + type: IrType, + runtime: { decl: string; symbol: string }, +): string { + const B = host.B; + const entry = emitMapIterEntry(host, map, index); + const found = B.tmp(); + B.line(`${found} = icmp ne ptr ${entry}, null`); + const hit = B.newLabel("mapit.hit"), + miss = B.newLabel("mapit.miss"), + join = B.newLabel("mapit.join"); + B.condBr(found, hit, miss); + B.startBlock(hit); + const slot = B.tmp(); + B.line(`${slot} = getelementptr inbounds %ScrMapEntry, ptr ${entry}, i32 0, i32 ${field}`); + const llTy = access === "f64" ? "double" : access === "bool" ? "i1" : "ptr"; + let loaded = B.tmp(); + if (access === "bool") { + const bits = loaded; + B.line(`${bits} = load i64, ptr ${slot}`); + loaded = B.tmp(); + B.line(`${loaded} = icmp ne i64 ${bits}, 0`); + } else { + B.line(`${loaded} = load ${llTy}, ptr ${slot}`); + if (access === "ref") loaded = host.retainValue(loaded, type); + } + const hitEnd = B.currentLabel(); + B.br(join); + B.startBlock(miss); + host.declare(runtime.decl); + const fallback = B.tmp(); + B.line(`${fallback} = call ${llTy} @${runtime.symbol}(ptr ${map}, double ${index})`); + B.br(join); + B.startBlock(join); + const result = B.tmp(); + B.line(`${result} = phi ${llTy} [ ${loaded}, %${hitEnd} ], [ ${fallback}, %${miss} ]`); + return result; +} diff --git a/packages/compiler/src/backend/llvm/map-read-lifetimes.ts b/packages/compiler/src/backend/llvm/map-read-lifetimes.ts index cf95a5db4e..6efcd0230e 100644 --- a/packages/compiler/src/backend/llvm/map-read-lifetimes.ts +++ b/packages/compiler/src/backend/llvm/map-read-lifetimes.ts @@ -39,6 +39,7 @@ export function borrowsMapReadInputs(expr: IrExpr): boolean { case "has": case "size": case "iterCount": + case "iterStart": case "iterLive": case "iterKey": case "iterValue": diff --git a/packages/compiler/src/contracts/check.ts b/packages/compiler/src/contracts/check.ts index 0b78e9ba16..a2e6287cf8 100644 --- a/packages/compiler/src/contracts/check.ts +++ b/packages/compiler/src/contracts/check.ts @@ -958,6 +958,7 @@ const MAP_READS = new Set([ "has", "size", "iterCount", + "iterStart", "iterLive", "iterKey", "iterValue", @@ -971,6 +972,7 @@ const SET_READS = new Set([ "has", "size", "iterCount", + "iterStart", "iterLive", "iterKey", "iterEnter", diff --git a/packages/compiler/src/frontend/lowering/containers/for-of.ts b/packages/compiler/src/frontend/lowering/containers/for-of.ts index 09ae055af0..4aa24b0b3a 100644 --- a/packages/compiler/src/frontend/lowering/containers/for-of.ts +++ b/packages/compiler/src/frontend/lowering/containers/for-of.ts @@ -28,7 +28,7 @@ import { arrayValueRead, arrayValueType } from "../array-values.js"; * * %m = ; %m.iterEnter(); * try { - * for (%i = 0; %i < %m.iterCount; %i++) { + * for (%i = %m.iterStart; %i < %m.iterCount; %i++) { * if (%m.iterLive(%i)) { ; } * } * } catch (%c) { %m.iterExit(); rethrow %c; } @@ -680,9 +680,13 @@ function lowerForOfMapOrSet( } const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement)); const exitStmt = (): IrStmt => ({ kind: "exprStmt", expr: iter("iterExit", [], VOID), loc }); + // iterStart is the first live index: a map that removes its oldest + // entries skips its deleted prefix once (the walk would skip those + // entries anyway), so a body that breaks after the first live entry + // does not walk it again on every loop. const loop: IrStmt = { kind: "for", - init: { kind: "varDecl", localId: i.id, init: numLit(0, loc), loc }, + init: { kind: "varDecl", localId: i.id, init: iter("iterStart", [], F64), loc }, cond: { kind: "bin", op: "<", diff --git a/packages/compiler/src/ir/ir.ts b/packages/compiler/src/ir/ir.ts index 87a2af2c5c..3eeba87028 100644 --- a/packages/compiler/src/ir/ir.ts +++ b/packages/compiler/src/ir/ir.ts @@ -1937,6 +1937,9 @@ export type IrMapIntrinsicMethod = | "size" | "clear" | "iterCount" + /** The first live index, or iterCount when none is live + * (scr_map_iter_start). for-of starts its index there. */ + | "iterStart" | "iterLive" | "iterKey" | "iterValue" @@ -1956,6 +1959,7 @@ export type IrSetIntrinsicMethod = | "size" | "clear" | "iterCount" + | "iterStart" | "iterLive" | "iterKey" | "iterEnter" diff --git a/packages/compiler/src/ir/validate.ts b/packages/compiler/src/ir/validate.ts index 56e39f3a16..04c7812052 100644 --- a/packages/compiler/src/ir/validate.ts +++ b/packages/compiler/src/ir/validate.ts @@ -2601,7 +2601,7 @@ function validateFunction( ? { argTypes: [F64], result: key } : e.method === "iterValue" ? { argTypes: [F64], result: value } - : { argTypes: [], result: F64 }; // size / iterCount + : { argTypes: [], result: F64 }; // size / iterCount / iterStart if (e.args.length !== sig.argTypes.length) { err( `mapIntrinsic ${e.method}: ${e.args.length} args, expected ${sig.argTypes.length}`, @@ -2660,7 +2660,7 @@ function validateFunction( ? { argTypes: [F64], result: elem } : e.method === "toArray" ? { argTypes: [], result: arrayOf(elem) } - : { argTypes: [], result: F64 }; // size / iterCount + : { argTypes: [], result: F64 }; // size / iterCount / iterStart if (e.args.length !== sig.argTypes.length) { err( `setIntrinsic ${e.method}: ${e.args.length} args, expected ${sig.argTypes.length}`, diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5315-map-iterate-after-front-deletes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5315-map-iterate-after-front-deletes.ts.json new file mode 100644 index 0000000000..c799eb879f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5315-map-iterate-after-front-deletes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5315-map-iterate-after-front-deletes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5316-map-lru-eviction.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5316-map-lru-eviction.ts.json new file mode 100644 index 0000000000..5875f0623a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5316-map-lru-eviction.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5316-map-lru-eviction.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5317-map-iterate-while-mutating.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5317-map-iterate-while-mutating.ts.json new file mode 100644 index 0000000000..54252b7255 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5317-map-iterate-while-mutating.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5317-map-iterate-while-mutating.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5318-set-iterate-after-deletes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5318-set-iterate-after-deletes.ts.json new file mode 100644 index 0000000000..3c40321668 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5318-set-iterate-after-deletes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5318-set-iterate-after-deletes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5319-map-iteration-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5319-map-iteration-values.ts.json new file mode 100644 index 0000000000..509fdce11b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5319-map-iteration-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5319-map-iteration-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5320-map-iterate-across-compaction.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5320-map-iterate-across-compaction.ts.json new file mode 100644 index 0000000000..9ba9277820 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5320-map-iterate-across-compaction.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5320-map-iterate-across-compaction.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index 715d0701b4..930f1010a2 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -3711,7 +3711,7 @@ static ScrDyn *scr_native_iterator_value(ScrNativeIterator *iterator, bool *done if (scr_exc_pending()) { scr_dyn_release(view); scr_dyn_release(source); return NULL; } ScrDyn *items = view ? view : source; ScrMap *map = source && (iterator->kind == 2 || iterator->kind == 3) ? source->v.handle.ptr : NULL; - if (map) while (iterator->index < scr_map_iter_count(map) && !scr_map_iter_live(map, iterator->index)) iterator->index++; + if (map) iterator->index = scr_map_iter_skip(map, iterator->index); double length = !items ? 0 : iterator->array_like ? iterator->limit : map ? scr_map_iter_count(map) : items->kind == SCR_DYN_ARR ? (double)items->v.arr.len : items->kind == SCR_DYN_BYTES ? (double)items->v.bytes->len : scr_str_utf16_len(items->v.str); bool done = !source || iterator->index >= length; diff --git a/packages/runtime/src/scr_map.c b/packages/runtime/src/scr_map.c index 58dd506c86..463024a28c 100644 --- a/packages/runtime/src/scr_map.c +++ b/packages/runtime/src/scr_map.c @@ -580,6 +580,7 @@ static void scr_map_compact(ScrMap *m, bool reindex) { } m->nentries = w; m->filter = filter; + m->head = 0; if (m->nbuckets > 0) { size_t want = 16; while (want < 2 * (w + 1)) want *= 2; @@ -812,11 +813,13 @@ void scr_map_clear(ScrMap *m) { } m->nlive = 0; m->filter = 0; + m->head = walked; if (m->iter_depth == 0) { /* Full reset; an active iteration instead keeps the (now all-dead) * entries so its indices stay stable — entries added by the callback * after the clear append past them and ARE visited (Node-exact). */ m->nentries = 0; + m->head = 0; if (m->ecap > SCR_MAP_CLEAR_KEEP && m->ecap / 8 > walked) { scr_mem_free(m->entries); m->entries = NULL; @@ -1267,6 +1270,23 @@ bool scr_map_iter_live(const ScrMap *m, double i) { return m->entries[(size_t)i].hash; } +/* A walk that starts at or below head moves head to the live entry it + * finds, so the deleted prefix is walked once however many iterations + * start there. A published map is read by other threads and keeps its + * header unchanged. */ +double scr_map_iter_skip(ScrMap *m, double i) { + if (!(i < (double)m->nentries)) return i; + bool from_head = !(i > (double)m->head); + size_t e = from_head ? m->head : (size_t)i; + while (e < m->nentries && !m->entries[e].hash) e++; + if (from_head && m->rc != SIZE_MAX) m->head = e; + return e == (size_t)i ? i : (double)e; +} + +double scr_map_iter_start(ScrMap *m) { + return scr_map_iter_skip(m, 0); +} + static const ScrMapEntry *scr_map_iter_at(const ScrMap *m, double i) { if (!(i >= 0) || i >= (double)m->nentries || !m->entries[(size_t)i].hash) { scr_trap("scriptc: internal error: map iteration index out of range\n"); diff --git a/packages/runtime/src/scr_map.test.c b/packages/runtime/src/scr_map.test.c index 6c6e22e01f..6bbf9282c5 100644 --- a/packages/runtime/src/scr_map.test.c +++ b/packages/runtime/src/scr_map.test.c @@ -59,7 +59,21 @@ static double odd_key(void) { return r == 8 ? NAN : odd[r]; } +/* Every entry below head is a tombstone, and scr_map_iter_skip answers the + * first live index at or after each index (the entry count when none is + * left). */ +static void check_skip(ScrMap *map) { + size_t count = (size_t)scr_map_iter_count(map); + for (size_t i = 0; i < map->head && i < count; i++) assert(!scr_map_iter_live(map, (double)i)); + double next_live = (double)count; + for (size_t i = count + 1; i-- > 0;) { + if (i < count && scr_map_iter_live(map, (double)i)) next_live = (double)i; + assert(scr_map_iter_skip(map, (double)i) == next_live); + } +} + static void check_same(const ScrMap *map, const Model *model) { + check_skip((ScrMap *)map); assert((size_t)scr_map_size(map) == model->n); size_t j = 0; size_t count = (size_t)scr_map_iter_count(map); @@ -466,8 +480,57 @@ static void fuzz_drain(unsigned flavor) { scr_map_release(map); } +/* A queue that deletes its oldest entry: each walk from the start finds the + * first live entry, inside and outside an iteration and after clear(). */ +static void front_deletes(void) { + ScrMap *map = scr_map_new(SCR_MAP_KEY_F64, SCR_MAP_VAL_F64, NULL, NULL, NULL); + double oldest = 0, next_key = 0; + for (int round = 0; round < 3000; round++) { + for (int j = 0; j < 3; j++) scr_map_set_f64_f64(map, next_key * 7, next_key), next_key++; + for (int j = 0; j < 2; j++) assert(scr_map_delete_f64(map, oldest * 7)), oldest++; + double first = scr_map_iter_skip(map, 0); + assert(scr_map_iter_live(map, first) && scr_map_iter_key_f64(map, first) == oldest * 7); + if (round % 97 == 0) check_skip(map); + } + scr_map_iter_enter(map); + for (int j = 0; j < 100; j++) assert(scr_map_delete_f64(map, oldest * 7)), oldest++; + check_skip(map); + assert(scr_map_iter_key_f64(map, scr_map_iter_skip(map, 0)) == oldest * 7); + scr_map_clear(map); /* inside the iteration: the entries stay, all dead */ + check_skip(map); + assert(scr_map_iter_skip(map, 0) == scr_map_iter_count(map)); + scr_map_set_f64_f64(map, -1, 1); + assert(scr_map_iter_key_f64(map, scr_map_iter_skip(map, 0)) == -1); + scr_map_iter_exit(map); + scr_map_clear(map); + assert(map->head == 0 && scr_map_iter_count(map) == 0 && scr_map_iter_skip(map, 0) == 0); + scr_map_release(map); + + ScrMap *names = scr_map_new(SCR_MAP_KEY_STR, SCR_MAP_VAL_F64, NULL, NULL, NULL); + char text[32]; + for (int i = 0; i < 500; i++) { + snprintf(text, sizeof text, "key%d", i); + ScrStr *key = scr_str_new(text, strlen(text)); + scr_map_set_str_f64(names, key, i); + scr_str_release(key); + } + for (int i = 0; i < 400; i++) { + snprintf(text, sizeof text, "key%d", i); + ScrStr *key = scr_str_new(text, strlen(text)); + assert(scr_map_delete_str(names, key)); + scr_str_release(key); + if (i % 50 == 0) check_skip(names); + } + check_skip(names); + ScrStr *first = scr_map_iter_key_str(names, scr_map_iter_skip(names, 0)); + assert(first->len == 6 && memcmp(first->data, "key400", 6) == 0); + scr_str_release(first); + scr_map_release(names); +} + int main(void) { modes(); + front_deletes(); iterate_while_mutating(); for (unsigned flavor = 0; flavor < 5; flavor++) fuzz(flavor); clear_cost_numbers(0); diff --git a/packages/runtime/src/scr_runtime.h b/packages/runtime/src/scr_runtime.h index 3e58171779..8fcb8d1dfd 100644 --- a/packages/runtime/src/scr_runtime.h +++ b/packages/runtime/src/scr_runtime.h @@ -2310,6 +2310,12 @@ typedef struct ScrMap { * always the entries array's. */ uint32_t *dense; size_t ndense; + /* Every entry below this index is a tombstone. A walk that starts at or + * below it advances it to the first live entry (scr_map_iter_skip); + * compaction and clear reset it. A map that deletes from the front (a + * queue, an LRU cache) then finds its first live entry without walking + * the whole deleted prefix again. */ + size_t head; } ScrMap; /* The LLVM backend's inline retain/release read both trace slots through * its %ScrMapRc prefix type (fields 5 and 8), mirroring scr_map_retain and @@ -2327,6 +2333,11 @@ _Static_assert(offsetof(ScrMap, filter) == "%ScrMapIx field 11 is ScrMap.filter, directly after nlive"); _Static_assert(offsetof(ScrMap, nlive) == sizeof(size_t) + 2 * sizeof(uint32_t) + 6 * sizeof(void *) + sizeof(size_t), "%ScrMapIx field 10 is ScrMap.nlive"); +/* The inline iteration steps (sc_map_iter_entry) read the entry count as + * %ScrMapIx field 9 and test each entry's hash, the third field. */ +_Static_assert(offsetof(ScrMap, nentries) + sizeof(size_t) == offsetof(ScrMap, nlive), + "%ScrMapIx field 9 is ScrMap.nentries, directly before nlive"); +_Static_assert(offsetof(ScrMapEntry, hash) == 16, "inline iteration reads ScrMapEntry.hash at byte 16"); _Static_assert(offsetof(ScrMap, entries) == offsetof(ScrMap, filter) + sizeof(uint64_t) + sizeof(size_t), "inline number-key lookups read ScrMap.entries as %ScrMapIx field 13"); _Static_assert(offsetof(ScrMap, dense) == offsetof(ScrMap, entries) + 6 * sizeof(void *), @@ -2437,6 +2448,10 @@ void *scr_map_get_ref_ref(const ScrMap *m, const void *key); * guards with iter_live first — reaching one is a compiler bug). */ double scr_map_iter_count(const ScrMap *m); /* entries incl. tombstones */ bool scr_map_iter_live(const ScrMap *m, double i); +/* The first live index at or after i, or iter_count when none is left. + * iter_start is the first live index of the map (for-of starts there). */ +double scr_map_iter_skip(ScrMap *m, double i); +double scr_map_iter_start(ScrMap *m); double scr_map_iter_key_f64(const ScrMap *m, double i); bool scr_map_iter_key_bool(const ScrMap *m, double i); ScrStr *scr_map_iter_key_str(const ScrMap *m, double i); /* +1 */ diff --git a/tests/corpus/5315-map-iterate-after-front-deletes.ts b/tests/corpus/5315-map-iterate-after-front-deletes.ts new file mode 100644 index 0000000000..dd5a611954 --- /dev/null +++ b/tests/corpus/5315-map-iterate-after-front-deletes.ts @@ -0,0 +1,38 @@ +// Iteration over a Map whose oldest entries were deleted: for-of, a +// for-of that breaks at the first entry, keys().next(), forEach and +// spread all start at the first live entry, in insertion order. +const m = new Map(); +for (let i = 0; i < 40; i++) m.set(i, "v" + i); +for (let i = 0; i < 30; i++) m.delete(i); +console.log(m.size, [...m.keys()].join(",")); + +let first = -1; +for (const k of m.keys()) { + first = k; + break; +} +console.log("first", first, m.keys().next().value, m.values().next().value); + +const seen: string[] = []; +m.forEach((v, k) => seen.push(k + "=" + v)); +console.log(seen.join(" ")); + +// Delete from the middle, then the new front. +m.delete(35); +m.delete(30); +m.delete(31); +console.log([...m.entries()].map(([k, v]) => k + ":" + v).join(" ")); +for (const [k, v] of m) { + console.log("first entry", k, v); + break; +} + +// Re-adding a deleted key appends it at the end. +m.set(0, "again"); +console.log([...m.keys()].join(","), m.keys().next().value); + +// Delete everything, then add. +for (const k of [...m.keys()]) m.delete(k); +console.log("empty", m.size, [...m].length, m.keys().next().done); +m.set(100, "new"); +console.log([...m].map(([k, v]) => k + "=" + v).join(";"), m.keys().next().value); diff --git a/tests/corpus/5316-map-lru-eviction.ts b/tests/corpus/5316-map-lru-eviction.ts new file mode 100644 index 0000000000..1f89ec4be0 --- /dev/null +++ b/tests/corpus/5316-map-lru-eviction.ts @@ -0,0 +1,55 @@ +// A least-recently-used cache over Map insertion order: a hit moves the +// key to the end (delete + set) and eviction removes the oldest key, +// taken both through keys().next() and through a for-of that breaks. +class Lru { + private readonly items = new Map(); + private readonly limit: number; + constructor(limit: number) { + this.limit = limit; + } + get(key: string): number | undefined { + const value = this.items.get(key); + if (value !== undefined) { + this.items.delete(key); + this.items.set(key, value); + } + return value; + } + put(key: string, value: number, viaLoop: boolean): string | undefined { + if (this.items.has(key)) this.items.delete(key); + this.items.set(key, value); + if (this.items.size <= this.limit) return undefined; + let oldest: string | undefined; + if (viaLoop) { + for (const k of this.items.keys()) { + oldest = k; + break; + } + } else { + oldest = this.items.keys().next().value; + } + if (oldest !== undefined) this.items.delete(oldest); + return oldest; + } + keys(): string { + return [...this.items.keys()].join(","); + } +} + +let seed = 17; +function next(): number { + seed = (Math.imul(seed, 1103515245) + 12345) >>> 0; + return seed % 23; +} +for (const viaLoop of [false, true]) { + const cache = new Lru(5); + const evicted: string[] = []; + let hits = 0; + for (let i = 0; i < 2000; i++) { + const key = "k" + next(); + if (cache.get(key) !== undefined) hits++; + const gone = cache.put(key, i, viaLoop); + if (gone !== undefined && evicted.length < 12) evicted.push(gone); + } + console.log(viaLoop ? "loop" : "next", hits, cache.keys(), evicted.join(" ")); +} diff --git a/tests/corpus/5317-map-iterate-while-mutating.ts b/tests/corpus/5317-map-iterate-while-mutating.ts new file mode 100644 index 0000000000..4d3f20bcf4 --- /dev/null +++ b/tests/corpus/5317-map-iterate-while-mutating.ts @@ -0,0 +1,52 @@ +// Mutation during iteration: entries deleted ahead of the walk are not +// visited, entries appended are, deleting the current or front entry +// does not skip the next one, and clear() ends the walk unless the +// body appends again. +const m = new Map(); +for (let i = 0; i < 8; i++) m.set("k" + i, i); +const visited: string[] = []; +for (const [k, v] of m) { + visited.push(k); + if (v === 1) m.delete("k3"); + if (v === 2) m.delete("k0"); // already visited: the front entry + if (v === 4) m.delete(k); // the current entry + if (v === 5) m.set("late", 50); +} +console.log(visited.join(","), "|", [...m.keys()].join(",")); + +const n = new Map(); +for (let i = 0; i < 6; i++) n.set(i, i * i); +const order: number[] = []; +for (const k of n.keys()) { + order.push(k); + n.delete(k); // delete each entry as it is visited + if (k === 2) n.set(99, 0); +} +console.log(order.join(","), n.size, [...n.keys()].join(",")); + +const c = new Map([ + [1, "a"], + [2, "b"], + [3, "c"], +]); +const cleared: string[] = []; +for (const [k, v] of c) { + cleared.push(k + v); + if (k === 1) { + c.clear(); + c.set(7, "z"); + } +} +console.log(cleared.join(","), c.size, [...c].map(([k, v]) => k + v).join(";")); + +// Nested walks over one map, with deletes from the inner loop. +const nested = new Map(); +for (let i = 0; i < 5; i++) nested.set(i, i); +const pairs: string[] = []; +for (const a of nested.keys()) { + for (const b of nested.keys()) { + if (b < a) nested.delete(b); + else pairs.push(a + "" + b); + } +} +console.log(pairs.join(" "), [...nested.keys()].join(",")); diff --git a/tests/corpus/5318-set-iterate-after-deletes.ts b/tests/corpus/5318-set-iterate-after-deletes.ts new file mode 100644 index 0000000000..1b63efa2c3 --- /dev/null +++ b/tests/corpus/5318-set-iterate-after-deletes.ts @@ -0,0 +1,35 @@ +// Set iteration after deletes from the front and the middle: for-of, +// a breaking for-of, values().next(), forEach and spread see the live +// elements in insertion order, including elements re-added later. +const s = new Set(); +for (let i = 0; i < 50; i++) s.add("e" + i); +for (let i = 0; i < 45; i++) if (i % 9 !== 4) s.delete("e" + i); +console.log(s.size, [...s].join(",")); + +let head = ""; +for (const e of s) { + head = e; + break; +} +console.log("head", head, s.values().next().value, s.keys().next().value); + +const viaForEach: string[] = []; +s.forEach((value, key) => viaForEach.push(value === key ? value : "?")); +console.log(viaForEach.join(",")); + +s.delete("e4"); +s.add("e0"); +console.log([...s].join(",")); +for (const e of s) { + if (e === "e13") s.delete("e22"); + if (e === "e46") s.add("tail"); + process.stdout.write(e + " "); +} +console.log(); + +const nums = new Set(); +for (let i = 0; i < 100; i++) nums.add(i * 3); +for (let i = 0; i < 99; i++) nums.delete(i * 3); +console.log(nums.size, [...nums].join(","), nums.values().next().value); +nums.delete(297); +console.log(nums.size, nums.values().next().done, [...nums].length); diff --git a/tests/corpus/5319-map-iteration-values.ts b/tests/corpus/5319-map-iteration-values.ts new file mode 100644 index 0000000000..5b3a024901 --- /dev/null +++ b/tests/corpus/5319-map-iteration-values.ts @@ -0,0 +1,47 @@ +// Iteration reads every key and value kind the static walk loads inline: +// number, string and boolean keys; number, boolean, string and object +// values; and object keys, which keep their identity. +interface Item { + name: string; + count: number; +} +const byName = new Map(); +for (const name of ["pear", "fig", "apple", "kiwi"]) byName.set(name, { name, count: name.length }); +byName.delete("fig"); +let total = 0; +for (const [name, item] of byName) { + item.count++; + total += item.count; + console.log(name, item.name, item.count); +} +console.log("total", total, byName.get("pear")!.count); + +const flags = new Map([ + [true, 1], + [false, 0], +]); +for (const [k, v] of flags) console.log(typeof k, k, v); + +const marks = new Map(); +for (let i = 0; i < 6; i++) marks.set(i * 0.5, i % 2 === 0); +marks.delete(0); +for (const [k, v] of marks) console.log(k, v); + +const labels = new Map([ + [-0, "zero"], + [NaN, "nan"], + [2 ** 40, "big"], +]); +for (const [k, v] of labels) console.log(Object.is(k, -0), k, v); + +const owners = new Map(); +const items: Item[] = [ + { name: "a", count: 1 }, + { name: "b", count: 2 }, + { name: "c", count: 3 }, +]; +for (const item of items) owners.set(item, item.name.toUpperCase()); +owners.delete(items[0]!); +for (const [item, owner] of owners) console.log(item === items[1] || item === items[2], item.name, owner); +const keys = [...owners.keys()]; +console.log(keys[0] === items[1], keys[1] === items[2]); diff --git a/tests/corpus/5320-map-iterate-across-compaction.ts b/tests/corpus/5320-map-iterate-across-compaction.ts new file mode 100644 index 0000000000..57f319ae02 --- /dev/null +++ b/tests/corpus/5320-map-iterate-across-compaction.ts @@ -0,0 +1,47 @@ +// Front deletes combined with the storage changes that renumber entries: +// compaction after many deletes, regrowth, clear(), and dense integer +// keys. Each walk starts at the first live entry, also through an +// iterator taken from a Map reached as an unknown value. +const m = new Map(); +for (let i = 0; i < 200; i++) m.set(i, i); +for (let i = 0; i < 190; i++) m.delete(i); // compacts once few entries are live +console.log(m.size, [...m.keys()].join(","), m.keys().next().value); +for (let i = 200; i < 260; i++) m.set(i, i); // grows again +for (let i = 190; i < 250; i++) m.delete(i); +let firstKey = -1; +for (const k of m.keys()) { + firstKey = k; + break; +} +console.log(m.size, firstKey, [...m.values()].join(",")); + +m.clear(); +console.log(m.size, m.keys().next().done); +m.set(5, 50); +m.set(1, 10); +m.delete(5); +const entry = m.entries().next().value; +console.log([...m].map(([k, v]) => k + "=" + v).join(";"), entry === undefined ? "none" : entry[0] + "=" + entry[1]); + +// String keys across many delete/insert rounds. +const queue = new Map(); +let produced = 0; +let consumed = ""; +for (let round = 0; round < 50; round++) { + for (let j = 0; j < 7; j++) queue.set("job" + produced, produced++); + for (let j = 0; j < 5; j++) { + const oldest = queue.keys().next().value; + if (oldest === undefined) break; + if (round === 49) consumed += oldest + " "; + queue.delete(oldest); + } +} +console.log(queue.size, consumed.trim(), queue.keys().next().value); + +const opaque: unknown = queue; +if (opaque instanceof Map) { + const it = opaque.keys(); + console.log(it.next().value, it.next().value); + for (const k of [...opaque.keys()].slice(0, 95)) opaque.delete(k); + console.log(opaque.size, opaque.keys().next().value); +} diff --git a/tests/harness/wasi-differential.test.ts b/tests/harness/wasi-differential.test.ts index 74dedf89c4..5b7c1669f2 100644 --- a/tests/harness/wasi-differential.test.ts +++ b/tests/harness/wasi-differential.test.ts @@ -233,6 +233,11 @@ describe.skipIf(!zigOnPath())("wasm32-wasi differential", () => { "4905-bigint-fixed-width-fusion.ts", "4906-bigint-small-value-trees.ts", "4907-bigint-random-trees.ts", + // Map/Set iteration reads ScrMap through size_t-width fields. + "5315-map-iterate-after-front-deletes.ts", + "5317-map-iterate-while-mutating.ts", + "5318-set-iterate-after-deletes.ts", + "5319-map-iteration-values.ts", ])("the LLVM target runs %s byte-identically to Node", async (fixture) => { const entry = join(repoRoot, "tests/corpus", fixture); const outDir = await mkdtemp("/tmp/scriptc-wasi-"); From 30e291a341366e7c64635d49e6f1b2d9036d9d28 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 14 Oct 2026 17:18:04 -0500 Subject: [PATCH 2/7] Support subclassing EventTarget and Event Typed and JavaScript classes can extend the global EventTarget and Event. %EventTarget and %Event are runtime-provided hierarchy roots like the EventEmitter: a subclass instance embeds a prefix pointing at the engine state that super() creates (the target's listener core, the event's state), and the backend's emitter prefix handling becomes a table of runtime prefixes that covers all three bases. The instances' checked-dynamic capsules use the runtime RC adapters, so the engine recognizes them: a target instance is its listeners' `this` and its events' target, and an Event subclass instance is the event its listeners receive, with its own fields and methods. The inherited methods and accessors lower directly on typed receivers (including super.dispatchEvent) and answer through the class property dispatch and the runtime's capsule hooks for checked-dynamic values, with Node's util.inspect output, @@toStringTag and leak-warning class name. Members read as values are the prototype's functions, also for plain handles. A target keeps its own capsule in its state, so repeated dispatches reuse it; the state and an event's target are traced, so the collector reclaims targets whose listeners capture them. Subclass members that spell an inherited member are refused, since the engine would never call or read them. Listener objects that are class instances now work: when a program can register EventTarget listeners and declares a class with a handleEvent method, %main installs a compiled `listener.handleEvent` reader that the engine uses at every dispatch, so the class's own, inherited or overridden method runs with the instance as `this`, as in Node. An unannotated arrow in an object literal whose contextual type maps to a checked-dynamic slot or to no lowered type (an EventTarget subclass's listener union) no longer adopts the void callback slot's return type, so `{ handleEvent: (e) => n++ }` passed as a listener keeps the result its record field promises. --- .../generated/node-v24-backlog.json | 62 ++- .../generated/node-v24-internal.json | 72 +++- internal/compatibility/static-support.json | 4 +- .../compiler/src/backend/cycle-analysis.ts | 8 + packages/compiler/src/backend/llvm/classes.ts | 107 +++-- packages/compiler/src/backend/llvm/dyn.ts | 4 +- packages/compiler/src/backend/llvm/emitter.ts | 17 +- .../compiler/src/backend/llvm/lib-shared.ts | 12 + packages/compiler/src/backend/llvm/shapes.ts | 31 +- .../src/frontend/lowering/call-signatures.ts | 23 +- .../lowering/class-dynamic-dispatch.ts | 52 ++- .../src/frontend/lowering/lower-calls.ts | 6 + .../src/frontend/lowering/lower-classes.ts | 52 ++- .../frontend/lowering/lower-event-target.ts | 385 +++++++++++++++++ .../src/frontend/lowering/lower-exprs.ts | 2 + .../src/frontend/lowering/lower-inspect.ts | 13 + .../src/frontend/lowering/lower-modules.ts | 6 +- .../src/frontend/lowering/lower-stdlib.ts | 7 +- .../src/frontend/lowering/lower-stmts.ts | 8 +- .../compiler/src/frontend/lowering/lowerer.ts | 10 + packages/compiler/src/ir/builtin-effects.ts | 4 + .../compiler/src/ir/builtin-signatures.ts | 19 + packages/compiler/src/ir/ir.ts | 15 + packages/compiler/src/ir/runtime-features.ts | 13 +- .../corpus/5240-event-target-subclass.ts.json | 6 + .../tests/corpus/5241-event-subclass.ts.json | 6 + ...42-event-target-subclass-hierarchy.ts.json | 6 + ...5243-event-target-subclass-dynamic.ts.json | 6 + .../corpus/5244-event-target-subclass.js.json | 6 + ...5245-event-target-subclass-signals.ts.json | 6 + ...ent-target-subclass-listener-throw.ts.json | 6 + ...47-event-target-subclass-lifetimes.ts.json | 6 + ...248-event-target-subclass-warnings.ts.json | 6 + ...vent-target-subclass-unconstructed.ts.json | 6 + .../event-target-subclass-fences.ts.json | 6 + packages/runtime/src/scr_dyn_invoke.c | 3 + packages/runtime/src/scr_event_target.c | 394 +++++++++++++++++- packages/runtime/src/scr_inspect.c | 17 + packages/runtime/src/scr_json.c | 22 +- packages/runtime/src/scr_runtime.h | 92 ++++ tests/corpus/5240-event-target-subclass.ts | 92 ++++ tests/corpus/5241-event-subclass.ts | 66 +++ .../5242-event-target-subclass-hierarchy.ts | 54 +++ .../5243-event-target-subclass-dynamic.ts | 62 +++ tests/corpus/5244-event-target-subclass.js | 85 ++++ .../5245-event-target-subclass-signals.ts | 61 +++ ...46-event-target-subclass-listener-throw.ts | 18 + .../5247-event-target-subclass-lifetimes.ts | 75 ++++ .../5248-event-target-subclass-warnings.ts | 19 + ...249-event-target-subclass-unconstructed.ts | 19 + .../event-target-subclass-fences.ts | 19 + .../event-target-subclass-fences.ts.txt | 27 ++ tests/harness/self-hosting-emission-cases.ts | 14 + tests/harness/wasi-differential.test.ts | 10 + 54 files changed, 2069 insertions(+), 78 deletions(-) create mode 100644 packages/compiler/src/frontend/lowering/lower-event-target.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5240-event-target-subclass.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5241-event-subclass.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5242-event-target-subclass-hierarchy.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5243-event-target-subclass-dynamic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5244-event-target-subclass.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5245-event-target-subclass-signals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5246-event-target-subclass-listener-throw.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5247-event-target-subclass-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5248-event-target-subclass-warnings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5249-event-target-subclass-unconstructed.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/event-target-subclass-fences.ts.json create mode 100644 tests/corpus/5240-event-target-subclass.ts create mode 100644 tests/corpus/5241-event-subclass.ts create mode 100644 tests/corpus/5242-event-target-subclass-hierarchy.ts create mode 100644 tests/corpus/5243-event-target-subclass-dynamic.ts create mode 100644 tests/corpus/5244-event-target-subclass.js create mode 100644 tests/corpus/5245-event-target-subclass-signals.ts create mode 100644 tests/corpus/5246-event-target-subclass-listener-throw.ts create mode 100644 tests/corpus/5247-event-target-subclass-lifetimes.ts create mode 100644 tests/corpus/5248-event-target-subclass-warnings.ts create mode 100644 tests/corpus/5249-event-target-subclass-unconstructed.ts create mode 100644 tests/diagnostics/event-target-subclass-fences.ts create mode 100644 tests/harness/__snapshots__/event-target-subclass-fences.ts.txt diff --git a/internal/compatibility/generated/node-v24-backlog.json b/internal/compatibility/generated/node-v24-backlog.json index c745613fe6..8a8fd4104a 100644 --- a/internal/compatibility/generated/node-v24-backlog.json +++ b/internal/compatibility/generated/node-v24-backlog.json @@ -23009,7 +23009,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] } } @@ -23040,7 +23046,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] } } @@ -23096,7 +23108,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] } } @@ -23124,7 +23142,11 @@ "source": "compiler-feature:events.Event", "tests": [ "tests/corpus/5130-event-target-dispatch.js", - "tests/corpus/5132-event-target-typed.ts" + "tests/corpus/5132-event-target-typed.ts", + "tests/corpus/5241-event-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5247-event-target-subclass-lifetimes.ts" ] } } @@ -23155,7 +23177,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] } } @@ -23186,7 +23214,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] } } @@ -23217,7 +23251,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] } } @@ -23248,7 +23288,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] } } diff --git a/internal/compatibility/generated/node-v24-internal.json b/internal/compatibility/generated/node-v24-internal.json index 64ab183f78..5d83a1e08f 100644 --- a/internal/compatibility/generated/node-v24-internal.json +++ b/internal/compatibility/generated/node-v24-internal.json @@ -40024,7 +40024,15 @@ "tests/corpus/5135-event-target-warnings.js", "tests/corpus/5136-events-error-monitor-string-name.ts", "tests/corpus/5137-events-error-monitor-computed-name.js", - "tests/corpus/5138-events-error-monitor-shared-listener.ts" + "tests/corpus/5138-events-error-monitor-shared-listener.ts", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5241-event-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5247-event-target-subclass-lifetimes.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] }, "anchorSource": "chapter" @@ -40169,7 +40177,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] }, "anchorSource": "exact" @@ -40199,7 +40213,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] }, "anchorSource": "exact" @@ -40275,7 +40295,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] }, "anchorSource": "exact" @@ -40302,7 +40328,11 @@ "evidence": "compiler-feature:events.Event", "tests": [ "tests/corpus/5130-event-target-dispatch.js", - "tests/corpus/5132-event-target-typed.ts" + "tests/corpus/5132-event-target-typed.ts", + "tests/corpus/5241-event-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5247-event-target-subclass-lifetimes.ts" ] }, "anchorSource": "exact" @@ -40836,7 +40866,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] }, "anchorSource": "exact" @@ -40866,7 +40902,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] }, "anchorSource": "exact" @@ -40896,7 +40938,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] }, "anchorSource": "exact" @@ -40926,7 +40974,13 @@ "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", - "tests/corpus/5135-event-target-warnings.js" + "tests/corpus/5135-event-target-warnings.js", + "tests/corpus/5240-event-target-subclass.ts", + "tests/corpus/5242-event-target-subclass-hierarchy.ts", + "tests/corpus/5243-event-target-subclass-dynamic.ts", + "tests/corpus/5244-event-target-subclass.js", + "tests/corpus/5245-event-target-subclass-signals.ts", + "tests/corpus/5248-event-target-subclass-warnings.ts" ] }, "anchorSource": "exact" diff --git a/internal/compatibility/static-support.json b/internal/compatibility/static-support.json index 6776b362a7..a07735b34c 100644 --- a/internal/compatibility/static-support.json +++ b/internal/compatibility/static-support.json @@ -164,8 +164,8 @@ }, "features": [ { "chapter": "errors", "parent": "Class: `SystemError`", "symbols": ["code", "errno", "syscall", "path", "dest"], "status": "partial", "evidence": ["tests/corpus/caught-system-error-fields.ts", "tests/fixtures/node-types/terminal-error-fields.ts", "tests/harness/project-config.test.ts"] }, - {"chapter": "events", "symbols": ["EventTarget", "eventTarget.addEventListener", "eventTarget.removeEventListener", "eventTarget.dispatchEvent"], "status": "partial", "evidence": ["tests/corpus/5130-event-target-dispatch.js", "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", "tests/corpus/5135-event-target-warnings.js"]}, - {"chapter": "events", "symbols": ["Event"], "status": "partial", "evidence": ["tests/corpus/5130-event-target-dispatch.js", "tests/corpus/5132-event-target-typed.ts"]}, + {"chapter": "events", "symbols": ["EventTarget", "eventTarget.addEventListener", "eventTarget.removeEventListener", "eventTarget.dispatchEvent"], "status": "partial", "evidence": ["tests/corpus/5130-event-target-dispatch.js", "tests/corpus/5131-event-target-listener-errors.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts", "tests/corpus/5135-event-target-warnings.js", "tests/corpus/5240-event-target-subclass.ts", "tests/corpus/5242-event-target-subclass-hierarchy.ts", "tests/corpus/5243-event-target-subclass-dynamic.ts", "tests/corpus/5244-event-target-subclass.js", "tests/corpus/5245-event-target-subclass-signals.ts", "tests/corpus/5248-event-target-subclass-warnings.ts"]}, + {"chapter": "events", "symbols": ["Event"], "status": "partial", "evidence": ["tests/corpus/5130-event-target-dispatch.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5241-event-subclass.ts", "tests/corpus/5242-event-target-subclass-hierarchy.ts", "tests/corpus/5244-event-target-subclass.js", "tests/corpus/5247-event-target-subclass-lifetimes.ts"]}, {"chapter": "events", "symbols": ["event.composedPath", "event.preventDefault", "event.stopImmediatePropagation", "event.stopPropagation", "event.initEvent", "bubbles", "cancelable", "cancelBubble", "composed", "currentTarget", "defaultPrevented", "eventPhase", "isTrusted", "returnValue", "srcElement", "target", "timeStamp", "type"], "status": "supported", "evidence": ["tests/corpus/5130-event-target-dispatch.js", "tests/corpus/5132-event-target-typed.ts", "tests/corpus/5133-abort-signal-event-target.ts"]}, {"chapter": "events", "symbols": ["CustomEvent", "detail"], "status": "partial", "evidence": ["tests/corpus/5130-event-target-dispatch.js", "tests/corpus/5132-event-target-typed.ts"]}, {"chapter": "events", "symbols": ["events.errorMonitor"], "status": "partial", "evidence": ["tests/corpus/5134-events-error-monitor.ts", "tests/corpus/5136-events-error-monitor-string-name.ts", "tests/corpus/5137-events-error-monitor-computed-name.js", "tests/corpus/5138-events-error-monitor-shared-listener.ts"]}, diff --git a/packages/compiler/src/backend/cycle-analysis.ts b/packages/compiler/src/backend/cycle-analysis.ts index 3b5d1ca218..22eb4c6583 100644 --- a/packages/compiler/src/backend/cycle-analysis.ts +++ b/packages/compiler/src/backend/cycle-analysis.ts @@ -1,9 +1,12 @@ import type { IrModule, IrType } from "../ir/ir.js"; import { + DYN, DYN_CLASS_PROPERTIES, funcOf, mapOf, RUNTIME_EMITTER_CLASS, + RUNTIME_EVENT_CLASS, + RUNTIME_EVENT_TARGET_CLASS, STRING, VOID, } from "../ir/ir.js"; @@ -127,6 +130,11 @@ function analyzeCycles( ...(c.name === RUNTIME_EMITTER_CLASS ? [{ name: "", type: funcOf([], VOID) }] : []), + // The EventTarget state owns listener values and the target's own + // capsule; an Event owns its target and detail. + ...(c.name === RUNTIME_EVENT_TARGET_CLASS || c.name === RUNTIME_EVENT_CLASS + ? [{ name: "", type: DYN }] + : []), ...(c.localCaptures !== undefined ? [{ name: "", type: { kind: "classval" as const, className: c.name } }] : []), diff --git a/packages/compiler/src/backend/llvm/classes.ts b/packages/compiler/src/backend/llvm/classes.ts index 0745c95319..8a13d83ad5 100644 --- a/packages/compiler/src/backend/llvm/classes.ts +++ b/packages/compiler/src/backend/llvm/classes.ts @@ -7,6 +7,8 @@ import type { IrClassDef, IrFunction, IrModule, IrType, IrUnionDef } from "../.. import { isRefCounted, RUNTIME_EMITTER_CLASS, + RUNTIME_EVENT_CLASS, + RUNTIME_EVENT_TARGET_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, } from "../../ir/ir.js"; @@ -261,26 +263,74 @@ export function vtEntriesFor(meta: LlClassMeta): { slot: LlVtSlot; impl: LlClass export function classStructSym(className: string): string { if (RUNTIME_ERROR_CLASSES.has(className)) return "ScrError"; if (className === RUNTIME_EMITTER_CLASS) return "ScrEmitter"; + if (className === RUNTIME_EVENT_TARGET_CLASS) return "ScrEventTargetObj"; + if (className === RUNTIME_EVENT_CLASS) return "ScrEventObj"; if (RUNTIME_STREAM_CLASSES.has(className)) return "ScrStream"; return mangleClassStruct(className); } -/** True when the class descends from the runtime emitter class: its - * struct embeds ScrEmitter's remaining prefix (the registry pointer and - * the display-name slot) after the vtable word, so an upcast to - * ScrEmitter* is the usual pointer reinterpret (shapes.ts's rule). */ -function emitterRooted(meta: LlClassMeta): boolean { - return meta.root.def.name === RUNTIME_EMITTER_CLASS; +/** A runtime base whose prefix emitted subclasses embed after the vtable + * word: the state pointer at 2 (NULL in a fresh allocation) and the + * display-name slot at 3, then the subclass fields. The entries are the + * runtime's helpers for the state pointer: the teardown's drop, the + * collector's trace and its gcFree. */ +interface RuntimePrefix { + struct: string; + what: string; + drop: string; + trace: string; + gcFree: string; +} + +const RUNTIME_PREFIXES: ReadonlyMap = new Map([ + [ + RUNTIME_EMITTER_CLASS, + { + struct: "ScrEmitter", + what: "EventEmitter prefix", + drop: "scr_emitter_reg_drop", + trace: "scr_emitter_reg_trace", + gcFree: "scr_emitter_reg_gcfree", + }, + ], + [ + RUNTIME_EVENT_TARGET_CLASS, + { + struct: "ScrEventTargetObj", + what: "EventTarget prefix", + drop: "scr_event_target_state_drop", + trace: "scr_event_target_state_trace", + gcFree: "scr_event_target_state_gcfree", + }, + ], + [ + RUNTIME_EVENT_CLASS, + { + struct: "ScrEventObj", + what: "Event prefix", + drop: "scr_event_state_drop", + trace: "scr_event_state_trace", + gcFree: "scr_event_state_gcfree", + }, + ], +]); + +/** The runtime prefix a class's struct embeds (its hierarchy root is the + * emitter, EventTarget or Event), so an upcast to the runtime struct is + * the usual pointer reinterpret (shapes.ts's rule); null otherwise. */ +function runtimePrefixOf(meta: LlClassMeta): RuntimePrefix | null { + if (!meta.hierarchy) return null; + return RUNTIME_PREFIXES.get(meta.root.def.name) ?? null; } /** The GEP index where a class's own fields start: rc at 0, the vtable - * word at 1 on hierarchy members, then the emitter prefix (registry + - * display name) on emitter-rooted classes, then the stream-state slot on - * stream-rooted ones. */ + * word at 1 on hierarchy members, then a runtime prefix (state + display + * name) on classes rooted at a runtime base, then the stream-state slot + * on stream-rooted ones. */ function fieldBase(meta: LlClassMeta): number { if (!meta.hierarchy) return 1; if (streamRooted(meta)) return 5; - return emitterRooted(meta) ? 4 : 2; + return runtimePrefixOf(meta) ? 4 : 2; } /** Append the lexical environment after inherited fields to preserve base layouts. */ @@ -420,21 +470,23 @@ export function emitClassShapes( ? "i32" : llFieldType(f.type, host.inlineUnions.classField(cls.name, f.name)), ); - // Emitter subclasses embed ScrEmitter's remaining prefix (the registry + // Subclasses of a runtime base embed its remaining prefix (the state // and display-name slots) between the vtable word and the field list; - // stream subclasses add the state pointer — upcasts to ScrEmitter* / - // ScrStream* are the usual pointer reinterprets. + // stream subclasses add the stream-state pointer — upcasts to + // ScrEmitter* / ScrStream* / ScrEventTargetObj* / ScrEventObj* are the + // usual pointer reinterprets. + const runtimePrefix = runtimePrefixOf(meta); const prefix = meta.hierarchy ? streamRooted(meta) ? ["ptr", "ptr", "ptr", "ptr"] - : emitterRooted(meta) + : runtimePrefix ? ["ptr", "ptr", "ptr"] : ["ptr"] : []; const members = [...prefix, ...fieldTys]; typeDefs.push( `%${mangleClassStruct(cls.name)} = type { ${host.sizeType}${members.length ? ", " + members.join(", ") : ""} } ` + - `; class ${cls.name}${meta.hierarchy ? " (vt at 1)" : ""}${streamRooted(meta) ? " (ScrStream prefix at 2)" : emitterRooted(meta) ? " (ScrEmitter prefix at 2)" : ""} { ${cls.fields.map((f) => llvmCommentText(f.name)).join("; ")} }`, + `; class ${cls.name}${meta.hierarchy ? " (vt at 1)" : ""}${streamRooted(meta) ? " (ScrStream prefix at 2)" : runtimePrefix ? ` (${runtimePrefix.struct} prefix at 2)` : ""} { ${cls.fields.map((f) => llvmCommentText(f.name)).join("; ")} }`, ); } @@ -515,7 +567,7 @@ export function emitClassShapes( const struct = mangleClassStruct(cls.name); const lifetime = programLifetimeClass(host, meta); const traced = host.tracedShapes.has(`object:${cls.name}`); - const isEmitterRooted = emitterRooted(meta); + const runtimePrefix = runtimePrefixOf(meta); const isStreamRooted = streamRooted(meta); const fieldIndex = (i: number): number => fieldBase(meta) + i; // Teardown, trace and gcFree see each slot's storage type: a nullable @@ -530,11 +582,11 @@ export function emitClassShapes( ]; const refFields = indexedFields.filter((f) => isRefCounted(f.type)); const bounded = - isEmitterRooted || + runtimePrefix !== null || isStreamRooted || refFields.some((field) => needsBoundedRelease(field.type)); const sizeOf = `ptrtoint (ptr getelementptr (%${struct}, ptr null, i32 1) to ${host.sizeType})`; - // An embedded prefix slot (the emitter registry at 2, the stream + // An embedded prefix slot (the runtime base's state at 2, the stream // state at 4) handed to one of the runtime's prefix helpers — // teardown/trace/collector. const prefixCall = ( @@ -552,7 +604,7 @@ export function emitClassShapes( ]; }; const regCall = (tag: string, entry: string, tail: string): string[] => - prefixCall(tag, 2, entry, tail, "EventEmitter prefix"); + prefixCall(tag, 2, entry, tail, runtimePrefix?.what ?? ""); const stCall = (tag: string, entry: string, tail: string): string[] => prefixCall(tag, 4, entry, tail, "stream state (ScrStream prefix)"); @@ -586,7 +638,7 @@ export function emitClassShapes( ` call void ${releaseSym(host, f.type)}(ptr %v${t}) ; ${llvmCommentText(f.name)}`, ); }); - if (isEmitterRooted) lines.push(...regCall("td", "scr_emitter_reg_drop", "")); + if (runtimePrefix) lines.push(...regCall("td", runtimePrefix.drop, "")); if (isStreamRooted) lines.push(...stCall("tds", "scr_stream_st_release", "")); lines.push(...emitObjectFree(host, traced)); }; @@ -738,16 +790,16 @@ export function emitClassShapes( ` store ptr @${mangleVtInstance(cls.name)}, ptr %vtp, !invariant.group !{}`, ); } - if (isEmitterRooted) { - // The ScrEmitter prefix: registry stays NULL (zeroed allocation); - // the display name Node's leak warning prints ([My]) is the source - // class name, without the module qualifier (shapes.ts's rule). + if (runtimePrefix) { + // The runtime prefix: the state stays NULL (zeroed allocation); the + // display name Node's leak warnings and inspectors print is the + // source class name, without the module qualifier (shapes.ts's rule). const displayName = cls.name.includes(".") ? cls.name.slice(cls.name.lastIndexOf(".") + 1) : cls.name; nw.push( ` %clsp = getelementptr inbounds %${struct}, ptr %o, i64 0, i32 3`, - ` store ptr ${host.cstr(displayName)}, ptr %clsp ; EventEmitter prefix display name`, + ` store ptr ${host.cstr(displayName)}, ptr %clsp ; ${runtimePrefix.what} display name`, ); } nw.push(...undefFieldInits(host, meta, nullable)); @@ -767,8 +819,7 @@ export function emitClassShapes( `define internal void @${mangleClassTrace(cls.name)}(ptr %o, ptr %visit, ptr %ctx) ${FN_ATTRS} { ; trace ${cls.name}`, `entry:`, ]; - if (isEmitterRooted) - tr.push(...regCall("tr", "scr_emitter_reg_trace", ", ptr %visit, ptr %ctx")); + if (runtimePrefix) tr.push(...regCall("tr", runtimePrefix.trace, ", ptr %visit, ptr %ctx")); if (isStreamRooted) tr.push(...stCall("trs", "scr_stream_st_trace", ", ptr %visit, ptr %ctx")); tracedFields.forEach((f, i) => { @@ -781,7 +832,7 @@ export function emitClassShapes( `define internal void @${mangleClassGcFree(cls.name)}(ptr %o) ${FN_ATTRS} { ; gcFree ${cls.name}`, `entry:`, ]; - if (isEmitterRooted) gf.push(...regCall("gf", "scr_emitter_reg_gcfree", "")); + if (runtimePrefix) gf.push(...regCall("gf", runtimePrefix.gcFree, "")); if (isStreamRooted) gf.push(...stCall("gfs", "scr_stream_st_gcfree", "")); untracedRefFields.forEach((f, i) => { gf.push( diff --git a/packages/compiler/src/backend/llvm/dyn.ts b/packages/compiler/src/backend/llvm/dyn.ts index ed08e276af..51e6c9063b 100644 --- a/packages/compiler/src/backend/llvm/dyn.ts +++ b/packages/compiler/src/backend/llvm/dyn.ts @@ -2718,10 +2718,10 @@ export class LlDyn { B.br(done); B.startBlock(labels.get(DYN_KIND.TYPED_REF)!); { - host.declare(`declare ptr @scr_dyn_typed_ref_materialize(ptr)`); + host.declare(`declare ptr @scr_dyn_typed_ref_string_view(ptr)`); host.declare(`declare void @scr_dyn_release_v(ptr)`); const materialized = B.tmp(); - B.line(`${materialized} = call ptr @scr_dyn_typed_ref_materialize(ptr %d)`); + B.line(`${materialized} = call ptr @scr_dyn_typed_ref_string_view(ptr %d)`); B.line(`call void @sc_ds_buf(ptr %b, ptr ${materialized})`); B.line(`call void @scr_dyn_release_v(ptr ${materialized})`); B.br(done); diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index 6fd58f56a6..77ac024137 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -36,6 +36,8 @@ import { isUnitType, POINTER_KINDS, RUNTIME_EMITTER_CLASS, + RUNTIME_EVENT_CLASS, + RUNTIME_EVENT_TARGET_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeEquals, @@ -1152,6 +1154,7 @@ export class LlEmitter { liveDynUnionRefAdapter: (type) => this.liveDynUnionRefAdapter(type), dynPromiseAdapter: (type) => this.dynPromiseAdapter(type), isErrorClass: (name) => this.classMeta.get(name)?.root.def.name === "%Error", + classRootOf: (name) => this.classMeta.get(name)?.root.def.name, classSubtypes: (name) => { const target = this.classMetaOf(name); const intervals = classMembershipIntervals(this.classMeta, target.def.name); @@ -1185,14 +1188,17 @@ export class LlEmitter { if (g.tdz) this.tdzGlobals.set(g.id, g.name); } this.stableGlobals = stableGlobals(mod); - // Runtime error, EventEmitter, and stream classes have known layouts. - // Subclasses embed the ScrEmitter/ScrStream prefixes from classes.ts. + // Runtime error, EventEmitter, stream, EventTarget and Event classes + // have known layouts. Subclasses embed the runtime prefixes from + // classes.ts. const classes = mod.classes ?? []; for (const cls of classes) { if ( cls.runtime && !RUNTIME_ERROR_CLASSES.has(cls.name) && cls.name !== RUNTIME_EMITTER_CLASS && + cls.name !== RUNTIME_EVENT_TARGET_CLASS && + cls.name !== RUNTIME_EVENT_CLASS && !RUNTIME_STREAM_CLASSES.has(cls.name) ) { throw new LlvmUnsupportedError(`classDef:${cls.name}`, cls.loc); @@ -2052,6 +2058,13 @@ export class LlEmitter { // The runtime stream layout { rc, vt, reg, cls, st } — one struct // for all five stream classes; stream subclasses embed it. `%ScrStream = type { ${this.sizeType}, ptr, ptr, ptr, ptr }`, + // The EventTarget and Event subclass prefixes { rc, vt, state, cls }. + ...(this.classMeta.has(RUNTIME_EVENT_TARGET_CLASS) + ? [`%ScrEventTargetObj = type { ${this.sizeType}, ptr, ptr, ptr }`] + : []), + ...(this.classMeta.has(RUNTIME_EVENT_CLASS) + ? [`%ScrEventObj = type { ${this.sizeType}, ptr, ptr, ptr }`] + : []), // The catch-binding snapshot box { rc, kind, f64, b, payload, // retain_fn, release_fn, trace_fn } — caughtTest kind reads and // caughtNarrow payload extraction GEP through it (offsets match diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index b36b8ebfd3..55197ad8dc 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -705,6 +705,15 @@ export const LIB_FN_SYMS: Record = { "event.new": "scr_event_new", "event.customNew": "scr_custom_event_new", "event.is": "scr_event_is", + "event.targetInit": "scr_event_target_obj_init", + "event.init": "scr_event_obj_init", + "event.initType": "scr_event_obj_init_type", + "event.handleEventReader": "scr_event_handle_event_reader", + "event.targetDispatch": "scr_event_target_obj_dispatch", + "event.targetCall": "scr_event_target_obj_call", + "event.call": "scr_event_obj_call", + "event.get": "scr_event_obj_get", + "event.set": "scr_event_obj_set", "events.addAbortListener": "scr_events_add_abort_listener", "abort.timeout": "scr_fetch_abort_timeout", "abort.now": "scr_fetch_abort_now", @@ -1213,6 +1222,9 @@ export const USES_TIMERS_LIB_FNS = new Set([ "duplex.initDyn", "transform.initDyn", "passthrough.initDyn", + // EventTarget subclass instances report listener exceptions from a + // nextTick. + "event.targetInit", "readable.push", "readable.pushStr", "readable.pushStrEnc", diff --git a/packages/compiler/src/backend/llvm/shapes.ts b/packages/compiler/src/backend/llvm/shapes.ts index c5e812470d..f662be088d 100644 --- a/packages/compiler/src/backend/llvm/shapes.ts +++ b/packages/compiler/src/backend/llvm/shapes.ts @@ -10,6 +10,8 @@ import { POINTER_KINDS, runtimeRcStem, RUNTIME_EMITTER_CLASS, + RUNTIME_EVENT_CLASS, + RUNTIME_EVENT_TARGET_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, @@ -42,6 +44,9 @@ import { LlvmUnsupportedError } from "./unsupported.js"; * and the module-wide cycle/shape indexes. */ export interface ShapeHost { declare(decl: string): void; + /** The hierarchy root of a class (a program class or a runtime base), + * or undefined for classes outside the class graph. */ + classRootOf?(className: string): string | undefined; /** Request the shared OOM abort helper (@sc_oom) — emitted once. */ needOom(): void; /** The target C ABI's `size_t` / refcount integer type. */ @@ -137,13 +142,30 @@ export function vAdapters(host: ShapeHost, t: IrType): { retain: string; release retain: `@${mangleRecordRetain(t.shapeId)}`, release: `@${mangleRecordRelease(t.shapeId)}`, }; - case "object": + case "object": { + // Subclasses of the runtime EventTarget and Event bases share the + // runtime's adapters (the same rc word and vtable dispatch as the + // emitted helpers): the engine recognizes their checked-dynamic + // capsules by the release adapter. + const root = host.classRootOf?.(t.className); + const runtime = + root === RUNTIME_EVENT_TARGET_CLASS + ? { retain: "scr_event_target_obj_retain_v", release: "scr_event_target_obj_release_v" } + : root === RUNTIME_EVENT_CLASS + ? { retain: "scr_event_obj_retain_v", release: "scr_event_obj_release_v" } + : null; + if (runtime !== null) { + host.declare(`declare ptr @${runtime.retain}(ptr)`); + host.declare(`declare void @${runtime.release}(ptr)`); + return { retain: `@${runtime.retain}`, release: `@${runtime.release}` }; + } // Emitted per-class helpers are already `_v`-shaped (ptr → ptr / // ptr → void), so the same symbols serve as container entry points. return { retain: `@${mangleClassRetain(t.className)}`, release: `@${mangleClassRelease(t.className)}`, }; + } default: throw new LlvmUnsupportedError(`rc:${t.kind}`); } @@ -159,6 +181,9 @@ export function retainSym(host: ShapeHost, t: IrType): string { if (host.rcHelpers !== null && stem !== null && inlineRcFamily(stem, "retain") !== null) { return inlineRcSym(host, stem, "retain"); } + // Direct retains keep the emitted helper (vAdapters' runtime adapters + // are for capsule and container entry points). + if (t.kind === "object" && stem === null) return `@${mangleClassRetain(t.className)}`; return vAdapters(host, t).retain; } @@ -522,6 +547,10 @@ export function traceAdapter(host: ShapeHost, t: IrType): string | null { host.declare(`declare void @scr_stream_trace(ptr, ptr, ptr)`); return "@scr_stream_trace"; } + // The EventTarget and Event bases have no instances of their own: + // values of subclasses trace through their own classes' entries. + if (t.className === RUNTIME_EVENT_TARGET_CLASS || t.className === RUNTIME_EVENT_CLASS) + return null; return `@${mangleClassTrace(t.className)}`; case "map": if (traceAdapter(host, t.key) === null && traceAdapter(host, t.value) === null) return null; diff --git a/packages/compiler/src/frontend/lowering/call-signatures.ts b/packages/compiler/src/frontend/lowering/call-signatures.ts index 55e58c2cf3..f246750611 100644 --- a/packages/compiler/src/frontend/lowering/call-signatures.ts +++ b/packages/compiler/src/frontend/lowering/call-signatures.ts @@ -834,10 +834,31 @@ export function lambdaSignature( // slots included: no intrinsic lowering inspects an inferred // return where its own declared slot is void. Async lambdas stay // out (the spawn-wrapper ABI must still return a promise), and an - // explicit return annotation keeps its word. + // explicit return annotation keeps its word. So does the property + // value of an object literal whose contextual type maps to a + // checked-dynamic slot or to no lowered type (such as an EventTarget + // listener union): that literal's record is typed by its own inferred + // properties, so the field keeps the inferred return and can be read + // back and called (`{ handleEvent: (e) => count++ }` passed as a + // listener still returns the count from `.handleEvent(e)`). A literal + // lowered against a declared record type takes that type's void field. + const literal = + ts.isPropertyAssignment(node.parent) && + node.parent.initializer === node && + ts.isObjectLiteralExpression(node.parent.parent) + ? node.parent.parent + : null; + const literalSlot = literal ? lowerer.checker.getContextualType(literal) : undefined; + const literalType = + literalSlot !== undefined + ? lowerer.mapTypeOf(lowerer.checker.getNonNullableType(literalSlot)) + : null; + const inferredLiteral = + literalSlot !== undefined && (literalType === null || literalType.kind === "dyn"); if ( !isAsyncLike && !node.type && + !inferredLiteral && ret.kind !== "void" && ctxSigs.length === 1 && !!(lowerer.checker.getReturnTypeOfSignature(ctxSigs[0]!).flags & ts.TypeFlags.Void) diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts index cc2f2d7cbf..e76104da02 100644 --- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts +++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts @@ -1,4 +1,5 @@ import { dynUndefinedExpr, varRef } from "../../ir/build.js"; +import { eventTargetApiMembers, eventTargetInheritedMember } from "./lower-event-target.js"; import { BOOL, DYN, @@ -2344,6 +2345,7 @@ export class ClassDynamicDispatch { if ( !isClassOwnEnumerableFieldName(dispatch.name) || (!(info.builtinStream !== undefined && streamProperty(dispatch.name)) && + !eventTargetInheritedMember(info, dispatch.name) && !findMethodOn(lowerer, info, dispatch.name) && !findGenericMethodOn(lowerer, info, dispatch.name) && dispatch.name !== "constructor" && @@ -2449,7 +2451,11 @@ export class ClassDynamicDispatch { loc, }, ]; - if (info.builtinStream !== undefined && streamProperty(name) && dispatch.probe) + if ( + ((info.builtinStream !== undefined && streamProperty(name)) || + eventTargetInheritedMember(info, name)) && + dispatch.probe + ) return [ { kind: "return", @@ -2665,6 +2671,8 @@ export class ClassDynamicDispatch { const names = new Set([...info.fields.keys()].filter(isClassOwnEnumerableFieldName)); if (info.builtinStream) for (const name of [...STREAM_BOOL_PROPERTIES, ...STREAM_NUM_PROPERTIES]) names.add(name); + const inherited = eventTargetApiMembers(info); + if (inherited) for (const name of inherited) names.add(name); for (let owner: ClassInfo | null = info; owner; owner = owner.base) { const methodNames = [...owner.methods.keys()]; @@ -3422,6 +3430,48 @@ export class ClassDynamicDispatch { ): IrStmt[] { const { name, write } = dispatch; const loc = dispatch.fn.loc; + // The inherited EventTarget/Event members of a subclass instance: the + // runtime's capsule view answers the accessors and method values. + if (eventTargetInheritedMember(info, name)) { + const key: IrExpr = { kind: "strLit", value: name, type: STRING, loc }; + if (!write) + return [ + { + kind: "return", + value: { + kind: "dynKeyGet", + value: lowerer.coerceToExpected(receiver, DYN), + key, + type: DYN, + loc, + }, + loc, + }, + ]; + if (name !== "returnValue" && name !== "cancelBubble") + return [ + { + kind: "runtimeFence", + code: "SC2020", + message: `writing the inherited member '${name}' through an untyped value is not supported`, + loc, + }, + ]; + return [ + { + kind: "exprStmt", + expr: { + kind: "libCall", + fn: "event.set", + args: [receiver, key, varRef("p.1", DYN, loc)], + type: VOID, + loc, + }, + loc, + }, + { kind: "return", value: null, loc }, + ]; + } if (info.builtinStream !== undefined && streamProperty(name)) { if (write) return [ diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index e92aabe4b3..11a59f70b2 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -134,6 +134,7 @@ import { } from "./lower-classes.js"; import { classCallbackCall, isClassCallback } from "./class-callbacks.js"; import { emitterRooted, lowerEmitterMethodCall } from "./lower-event-emitter.js"; +import { eventTargetApiMethod, lowerEventTargetMethodCall } from "./lower-event-target.js"; import { lowerConsoleInstanceCall, lowerConsoleMethodCall, @@ -8499,6 +8500,11 @@ export function lowerObjectMethodCall( if (info && !found && EMITTER_API_MEMBERS.has(access.name.text) && emitterRooted(lowerer, info)) { return lowerEmitterMethodCall(lowerer, call, access, info); } + // The inherited EventTarget/Event methods of a class rooted at those + // runtime bases (subclass members with these names are fenced). + if (info && !found && eventTargetApiMethod(info, access.name.text)) { + return lowerEventTargetMethodCall(lowerer, call, access, info, lowerReceiver()); + } // GENERIC methods (own type parameters) never enter the methods table: // they monomorphize per call site and dispatch statically // (lowerClassGenericMethodCall has the exactness rules). diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 38b244de99..c843f3a1c3 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -88,6 +88,14 @@ import { lowerStreamSuperCall, streamCtorShape, } from "./lower-stream.js"; +import { + builtinEventTargetBaseOf, + eventTargetApiMembers, + eventTargetApiMethod, + eventTargetRootOf, + eventTargetSuperCall, + lowerEventTargetMethodCall, +} from "./lower-event-target.js"; import { emitOverrideShapeReason, emitSpecSuperForward, @@ -466,6 +474,12 @@ export interface ClassInfo { * the base chain. The value names which SIDES the class carries. User * `extends` of these classes is fenced at the declaration (phase 1). */ builtinStream?: "r" | "w" | "rw"; + /** Runtime-provided EventTarget ("target") or Event ("event") base of + * compiled subclasses (lower-event-target.ts): no bodies lower, super() + * becomes an event.* libCall, and the inherited members lower through + * lower-event-target.ts over any class rooted here. Subclass structs + * embed the runtime prefix. */ + builtinEventTarget?: "target" | "event"; /** The synthetic LifetimeRegion class (@scriptc/experimental, * lifetime-regions.ts): its constructor is synthesized with the class, * and its methods lower at their call sites. */ @@ -2005,6 +2019,7 @@ export function collectClassShapeInner( lowerer.builtinErrorInfoOf(symbol) ?? lowerer.builtinEmitterInfoOf(symbol) ?? builtinStreamInfoOf(lowerer, symbol) ?? + builtinEventTargetBaseOf(lowerer, t.expression) ?? // A const BINDING holding exactly one class (`const B = Animal`, // `const B = class {…}`): the base is that class — extends // through the alias is the declaration story (a general class @@ -2064,7 +2079,11 @@ export function collectClassShapeInner( } if (lowerer.collectingExprClasses.has(decl)) { for (let parent = base; parent; parent = parent.base) { - if (parent.builtinEmitter || parent.builtinStream !== undefined) { + if ( + parent.builtinEmitter || + parent.builtinStream !== undefined || + parent.builtinEventTarget !== undefined + ) { lowerer.unsupported( "SC1090", decl, @@ -2460,6 +2479,21 @@ export function collectClassShapeInner( `overriding the EventEmitter member '${memberName.text}' (the runtime owns the emitter surface)`, ); } + // The inherited EventTarget/Event members read the engine's own + // state: dispatch never calls a subclass override, and the engine + // never reads an own field that shadows an accessor (`type`). + if ( + memberName && + ts.isIdentifier(memberName) && + !(ts.getCombinedModifierFlags(member as ts.Declaration) & ts.ModifierFlags.Static) && + eventTargetApiMembers(base)?.has(memberName.text) + ) { + lowerer.unsupported( + "SC1090", + memberName, + `overriding the ${eventTargetRootOf(base) === "target" ? "EventTarget" : "Event"} member '${memberName.text}' (the runtime owns the inherited surface)`, + ); + } // The stream surface is likewise runtime-provided on stream-rooted // subclasses: API members (push/read/write/...) and the property // family (readableEnded/destroyed/...) dispatch into the runtime @@ -4789,6 +4823,7 @@ export function classValueRef(lowerer: Lowerer, info: ClassInfo, blame: ts.Node) if ( lowerer.inheritsBuiltinEmitterCtor(info) || inheritsBuiltinStreamCtor(lowerer, info) || + eventTargetRootOf(info) !== null || (() => { for (let c = info.base; c; c = c.base) if (c.builtinEmitter || c.builtinStream !== undefined) return true; @@ -7631,6 +7666,7 @@ export function superCallStmt( loc, }; } + if (base.builtinEventTarget) return eventTargetSuperCall(lowerer, base, thisRef, args, loc); if (base.builtinStream) { // The SYNTHESIZED constructor of a ctor-less stream subclass: // super() with default options (underscore methods still bind; a @@ -7710,6 +7746,20 @@ export function lowerSuperMethodCall( const viaEmitter = lowerEmitterSuperCall(lowerer, call, access, cls); if (viaEmitter) return viaEmitter; } + // `super.dispatchEvent(e)`, `super.preventDefault()`: the inherited + // runtime members over this method's own `this` (subclasses cannot + // override them, so the static answer is the runtime's). + if (eventTargetApiMethod(cls.base, access.name.text)) { + const thisL = lowerer.resolveThis(); + if (!thisL) lowerer.unsupported("SC1080", access); + const thisRef: IrExpr = { + kind: "varRef", + localId: thisL.id, + type: thisL.type, + loc: locOf(call), + }; + return lowerEventTargetMethodCall(lowerer, call, access, cls.base, thisRef); + } lowerer.unsupported( "SC1090", access, diff --git a/packages/compiler/src/frontend/lowering/lower-event-target.ts b/packages/compiler/src/frontend/lowering/lower-event-target.ts new file mode 100644 index 0000000000..8088e690d5 --- /dev/null +++ b/packages/compiler/src/frontend/lowering/lower-event-target.ts @@ -0,0 +1,385 @@ +/* Compiled subclasses of EventTarget and Event (`class Bus extends + * EventTarget`, `class Ping extends Event`). + * + * Plain `new EventTarget()` / `new Event()` values are checked-dynamic + * handles over the runtime engine (scr_event_target.c). A program class + * extending either one roots at a runtime base class (%EventTarget / + * %Event) whose instance prefix points at the same engine state: super() + * creates it, and the backend embeds the prefix like the emitter's. The + * inherited members lower here for typed receivers. Checked-dynamic + * capsules of the instances are recognized by the runtime, so the + * engine's own values are the instances themselves: a target's capsule is + * its listeners' `this` and its events' target, and an Event subclass + * instance is what its listeners receive. Property reads, writes and + * method calls on those capsules reach the inherited members through the + * class property dispatch (class-dynamic-dispatch.ts) and the runtime's + * capsule hooks. + * + * Subclass members spelling an inherited member are fenced: the engine + * reads its own state (the event's type, the target's listener lists) + * and never calls an override. + */ +import * as ts from "../ts7/adapter.js"; +import type { Lowerer } from "./lowerer.js"; +import type { ClassInfo } from "./lower-classes.js"; +import { locOf } from "../program.js"; +import { strLit } from "../../ir/build.js"; +import { + BOOL, + DYN, + RUNTIME_EVENT_CLASS, + RUNTIME_EVENT_TARGET_CLASS, + type IrExpr, + type IrStmt, + type IrType, + type SrcLoc, + VOID, +} from "../../ir/ir.js"; + +const HANDLE_EVENT_READER = "%event.handleEventOf"; + +/** A program that can register EventTarget listeners and declares a class + * with a handleEvent method lifts `%event.handleEventOf(listener) = + * listener.handleEvent`, a checked-dynamic read the class property + * dispatch resolves through each class's compiled members (overrides and + * own properties included). %main installs it for the engine, which reads + * a capsule listener's handleEvent through it at every dispatch, as Node + * does; class views alone carry fields, not methods. Called by the + * EventTarget lowerings. */ +export function noteEventListeners(lowerer: Lowerer, loc: SrcLoc): void { + if (lowerer.handleEventReader) return; + const declares = [...lowerer.classes.values()].some( + (info) => !info.def.runtime && lowerer.findMethodOn(info, "handleEvent") !== null, + ); + if (!declares) return; + lowerer.handleEventReader = true; + lowerer.liftedFns.push({ + name: HANDLE_EVENT_READER, + params: [{ localId: "listener", name: "listener", type: DYN }], + returnType: DYN, + locals: [{ id: "listener", name: "listener", type: DYN, mutable: false }], + body: [ + { + kind: "return", + value: { + kind: "dynKeyGet", + value: { kind: "varRef", localId: "listener", type: DYN, loc }, + key: strLit("handleEvent", loc), + type: DYN, + loc, + }, + loc, + }, + ], + loc, + }); +} + +/** %main's installation of the handleEvent reader, when one was lifted. */ +export function handleEventReaderPrelude(lowerer: Lowerer, loc: SrcLoc): IrStmt[] { + if (!lowerer.handleEventReader) return []; + const reader: IrExpr = { + kind: "dynFrom", + value: { + kind: "closure", + fnName: HANDLE_EVENT_READER, + captures: [], + type: { kind: "func", params: [DYN], ret: DYN }, + loc, + }, + type: DYN, + loc, + }; + return [ + { + kind: "exprStmt", + expr: { kind: "libCall", fn: "event.handleEventReader", args: [reader], type: VOID, loc }, + loc, + }, + ]; +} + +/** The EventTarget methods compiled subclasses inherit. */ +export const EVENT_TARGET_API_MEMBERS: ReadonlySet = new Set([ + "addEventListener", + "removeEventListener", + "dispatchEvent", +]); + +/** The Event methods compiled subclasses inherit. */ +const EVENT_API_METHODS: ReadonlySet = new Set([ + "preventDefault", + "stopPropagation", + "stopImmediatePropagation", + "composedPath", + "initEvent", +]); + +/** The Event accessors compiled subclasses inherit (Event.prototype's). */ +const EVENT_API_PROPERTIES: ReadonlySet = new Set([ + "type", + "target", + "srcElement", + "currentTarget", + "eventPhase", + "bubbles", + "cancelable", + "composed", + "defaultPrevented", + "returnValue", + "cancelBubble", + "timeStamp", + "isTrusted", +]); + +/** Whether `name` is an inherited member (accessor or method) of + * `info`'s instances. */ +export function eventTargetInheritedMember( + info: ClassInfo | null | undefined, + name: string, +): boolean { + return eventTargetApiMembers(info)?.has(name) ?? false; +} + +/** Every inherited Event member name (the subclass-member fence). */ +export const EVENT_API_MEMBERS: ReadonlySet = new Set([ + ...EVENT_API_METHODS, + ...EVENT_API_PROPERTIES, +]); + +/** Registers the runtime bases as ClassInfos (the emitter story): no + * decl and no lowerable bodies; super() reaches them through event.* + * libCalls. `new EventTarget()` takes no arguments; `new Event(type, + * options)` takes the argument vector as one dyn array, which the runtime + * validates like Node's constructor. */ +export function registerBuiltinEventTargetClasses(lowerer: Lowerer): void { + const loc = { file: "", start: 0, end: 0 }; + const classes: [string, "target" | "event"][] = [ + [RUNTIME_EVENT_TARGET_CLASS, "target"], + [RUNTIME_EVENT_CLASS, "event"], + ]; + for (const [name, kind] of classes) { + lowerer.classes.set(name, { + def: { name, runtime: true, fields: [], loc }, + fields: new Map(), + fieldOrder: [], + methods: new Map(), + decl: null, + builtinEventTarget: kind, + ctor: null, + ctorParams: kind === "event" ? [{ type: DYN, mode: "dynRest" }] : [], + base: null, + subclasses: [], + throwingSetters: [], + staticFields: [], + }); + } +} + +/** The runtime base an `extends` expression names (the global EventTarget + * or Event), or null. */ +export function builtinEventTargetBaseOf(lowerer: Lowerer, expr: ts.Expression): ClassInfo | null { + if (lowerer.isStdlibGlobal(expr, "EventTarget")) + return lowerer.classes.get(RUNTIME_EVENT_TARGET_CLASS) ?? null; + if (lowerer.isStdlibGlobal(expr, "Event")) + return lowerer.classes.get(RUNTIME_EVENT_CLASS) ?? null; + return null; +} + +/** Which runtime base a class roots at, or null. */ +export function eventTargetRootOf(info: ClassInfo | null | undefined): "target" | "event" | null { + for (let c = info ?? null; c; c = c.base) if (c.builtinEventTarget) return c.builtinEventTarget; + return null; +} + +/** The inherited member names of a class rooted at a runtime base. */ +export function eventTargetApiMembers( + info: ClassInfo | null | undefined, +): ReadonlySet | null { + const root = eventTargetRootOf(info); + return root === "target" ? EVENT_TARGET_API_MEMBERS : root === "event" ? EVENT_API_MEMBERS : null; +} + +/** Whether `name` is an inherited method of a class rooted at a runtime + * base. */ +export function eventTargetApiMethod(info: ClassInfo | null | undefined, name: string): boolean { + const root = eventTargetRootOf(info); + return root === "target" + ? EVENT_TARGET_API_MEMBERS.has(name) + : root === "event" && EVENT_API_METHODS.has(name); +} + +/** super() / super(type, options) into a runtime base. `args` is the + * completed argument list: nothing for EventTarget, the dyn argument + * vector for Event. */ +export function eventTargetSuperCall( + lowerer: Lowerer, + base: ClassInfo, + thisRef: IrExpr, + args: IrExpr[], + loc: SrcLoc, +): IrStmt { + noteEventListeners(lowerer, loc); + const receiver = lowerer.upcastTo(thisRef, base.def.name); + const vector = args[0] ?? { kind: "dynArrLit", elems: [], type: DYN, loc }; + // super(type) with a string needs no argument vector. + const only = vector.kind === "dynArrLit" && vector.elems.length === 1 ? vector.elems[0]! : null; + const expr: IrExpr = + base.builtinEventTarget === "target" + ? { kind: "libCall", fn: "event.targetInit", args: [receiver], type: VOID, loc } + : only?.kind === "dynFrom" && only.value.type.kind === "string" + ? { kind: "libCall", fn: "event.initType", args: [receiver, only.value], type: VOID, loc } + : { kind: "libCall", fn: "event.init", args: [receiver, vector], type: VOID, loc }; + return { kind: "exprStmt", expr, loc }; +} + +/** The receiver lowered once: a local or `this` is used as is; anything + * else evaluates into a hidden local first. */ +function singleReceiver( + lowerer: Lowerer, + receiver: IrExpr, + loc: SrcLoc, +): { stmts: IrStmt[]; ref: IrExpr } { + if (receiver.kind === "varRef") return { stmts: [], ref: receiver }; + const local = lowerer.declareHiddenLocal("%eventReceiver", receiver.type); + return { + stmts: [{ kind: "varDecl", localId: local.id, init: receiver, loc }], + ref: { kind: "varRef", localId: local.id, type: receiver.type, loc }, + }; +} + +function withReceiver(stmts: IrStmt[], result: IrExpr, loc: SrcLoc): IrExpr { + if (stmts.length === 0) return result; + return { kind: "seqExpr", stmts, result, type: result.type, loc }; +} + +/** The dyn result of an inherited member, converted to the type the + * checker gives the expression (void and checked-dynamic stay as is). */ +function typedResult(lowerer: Lowerer, node: ts.Expression, value: IrExpr): IrExpr { + const expected: IrType | null = lowerer.mapTypeOf(lowerer.typeOf(node)); + if (!expected || expected.kind === "void" || expected.kind === "dyn") return value; + return lowerer.coerceToExpected(value, expected); +} + +/** A call of an inherited EventTarget or Event method on a typed receiver + * of a class rooted at a runtime base. Listener arguments cross as live + * values (typed `handleEvent` records keep their identity), the rest as + * checked-dynamic values. */ +export function lowerEventTargetMethodCall( + lowerer: Lowerer, + call: ts.CallExpression, + access: ts.PropertyAccessExpression, + info: ClassInfo, + receiverExpr: IrExpr, +): IrExpr { + const member = access.name.text; + const loc = locOf(call); + if (call.arguments.some(ts.isSpreadElement)) { + lowerer.noLowering(`${member} with spread arguments`, call); + } + const target = eventTargetRootOf(info) === "target"; + if (target) noteEventListeners(lowerer, loc); + const { stmts, ref } = singleReceiver(lowerer, receiverExpr, loc); + const args = call.arguments.map((arg, index) => + target && index === 1 && member !== "dispatchEvent" + ? lowerer.lowerLiveWebValue(arg) + : lowerer.lowerExprExpecting(arg, DYN), + ); + const self = (): IrExpr => lowerer.coerceToExpected(ref, DYN); + if (target && member === "dispatchEvent" && args.length === 1) { + const dispatched: IrExpr = { + kind: "libCall", + fn: "event.targetDispatch", + args: [ref, self(), args[0]!], + type: BOOL, + loc, + }; + return withReceiver(stmts, dispatched, loc); + } + const vector: IrExpr = { kind: "dynArrLit", elems: args, type: DYN, loc }; + const value: IrExpr = target + ? { + kind: "libCall", + fn: "event.targetCall", + args: [ref, self(), strLit(member, loc), vector], + type: DYN, + loc, + } + : { + kind: "libCall", + fn: "event.call", + args: [ref, strLit(member, loc), vector], + type: DYN, + loc, + }; + return typedResult(lowerer, call, withReceiver(stmts, value, loc)); +} + +/** A read of an inherited member on a typed receiver (an Event accessor, + * or a method read as a value), or null when the access is not one. */ +export function lowerEventObjectProperty( + lowerer: Lowerer, + expr: ts.PropertyAccessExpression, +): IrExpr | null { + if (expr.questionDotToken && !lowerer.chainHandled.has(expr)) return null; + const name = expr.name.text; + const recvT = lowerer.mapTypeOf(lowerer.typeOf(expr.expression)); + if (recvT?.kind !== "object") return null; + const info = lowerer.classes.get(recvT.className); + if (!eventTargetApiMembers(info)?.has(name)) return null; + const loc = locOf(expr); + const receiver = lowerer.lowerExpr(expr.expression); + if (receiver.type.kind !== "object") return null; + // Accessors read the event directly; method values come from the + // capsule view (the prototype's function, run on its `this`). + const value: IrExpr = EVENT_API_PROPERTIES.has(name) + ? { kind: "libCall", fn: "event.get", args: [receiver, strLit(name, loc)], type: DYN, loc } + : { + kind: "dynKeyGet", + value: lowerer.coerceToExpected(receiver, DYN), + key: strLit(name, loc), + type: DYN, + loc, + }; + return typedResult(lowerer, expr, value); +} + +/** `event.returnValue = v` / `event.cancelBubble = v` on a typed receiver + * (the two writable accessors), or null when the target is not one. */ +export function lowerEventObjectPropertyWrite( + lowerer: Lowerer, + target: ts.PropertyAccessExpression, + value: ts.Expression, +): IrExpr | null { + const name = target.name.text; + if (name !== "returnValue" && name !== "cancelBubble") return null; + const recvT = lowerer.mapTypeOf(lowerer.typeOf(target.expression)); + if (recvT?.kind !== "object") return null; + if (eventTargetRootOf(lowerer.classes.get(recvT.className)) !== "event") return null; + const loc = locOf(target); + const receiver = lowerer.lowerExpr(target.expression); + const assigned = lowerer.lowerExprExpecting(value, DYN); + // The assignment's value is the assigned one, whatever the setter does. + const local = lowerer.declareHiddenLocal("%eventAssigned", DYN); + const ref: IrExpr = { kind: "varRef", localId: local.id, type: DYN, loc }; + return { + kind: "seqExpr", + stmts: [ + { kind: "varDecl", localId: local.id, init: assigned, loc }, + { + kind: "exprStmt", + expr: { + kind: "libCall", + fn: "event.set", + args: [receiver, strLit(name, loc), ref], + type: VOID, + loc, + }, + loc, + }, + ], + result: ref, + type: DYN, + loc, + }; +} diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index 74d5d723d4..730fa46edf 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -1,4 +1,5 @@ import { generatorDrain } from "./iterator-adapters.js"; +import { lowerEventObjectProperty } from "./lower-event-target.js"; import { lowerEventStaticProperty } from "./builtins/numbers.js"; import { lowerUnionEquality, tagEqualityMayMissAlias } from "./strict-equality.js"; import { isOptionalProcessStreamProperty } from "./builtins/process.js"; @@ -2158,6 +2159,7 @@ function lowerExprInner(lowerer: Lowerer, expr: ts.Expression): IrExpr { // the inner access maps no type of its own. lowerStreamStateProperty(lowerer, expr) ?? lowerStreamObjectProperty(lowerer, expr) ?? + lowerEventObjectProperty(lowerer, expr) ?? lowerer.lowerUnionProperty(expr) ?? lowerer.lowerFieldRead(expr); // A union-typed field read narrows like an identifier when the diff --git a/packages/compiler/src/frontend/lowering/lower-inspect.ts b/packages/compiler/src/frontend/lowering/lower-inspect.ts index 8d592fdca3..f8d807f80f 100644 --- a/packages/compiler/src/frontend/lowering/lower-inspect.ts +++ b/packages/compiler/src/frontend/lowering/lower-inspect.ts @@ -26,6 +26,7 @@ import { import type { ClassInfo } from "./lower-classes.js"; import { isSafeToRepeat } from "./expressions/evaluation-safety.js"; import { symbolFieldDisplayName } from "./symbol-fields.js"; +import { eventTargetRootOf } from "./lower-event-target.js"; import { lowerSystemErrorMap } from "./lower-system-errors.js"; import { isPerfEntryType, perfEntryJson } from "./builtins/performance.js"; @@ -201,6 +202,9 @@ function inspectSupport( case "object": { const info = lowerer.classes.get(t.className); if (!info) return `class '${t.className}' has no inspect lowering`; + // EventTarget and Event subclasses render through Node's inspectors + // for those classes (the runtime's capsule view). + if (eventTargetRootOf(info) !== null) return null; if (isErrorClass(lowerer, t.className)) { return errorRenderable(info) ? null @@ -288,6 +292,15 @@ export function inspectExpr( case "dyn": return { kind: "libCall", fn: "insp.dyn", args: [value, recurse, depth], type: STRING, loc }; case "object": + if (eventTargetRootOf(lowerer.classes.get(t.className)) !== null) { + return { + kind: "libCall", + fn: "insp.dyn", + args: [lowerer.coerceToExpected(value, DYN), recurse, depth], + type: STRING, + loc, + }; + } if (isErrorClass(lowerer, t.className)) { return { kind: "libCall", diff --git a/packages/compiler/src/frontend/lowering/lower-modules.ts b/packages/compiler/src/frontend/lowering/lower-modules.ts index 29798bd61f..5780f69dad 100644 --- a/packages/compiler/src/frontend/lowering/lower-modules.ts +++ b/packages/compiler/src/frontend/lowering/lower-modules.ts @@ -127,6 +127,7 @@ import { cjsModuleRef, cjsModuleRegistryPrelude } from "./lower-node-module.js"; import { forkTargetPaths } from "../fork-target.js"; import { workerTargetPaths } from "../worker-target.js"; import { isNativeProxyInitializer } from "./expressions/native-proxy.js"; +import { handleEventReaderPrelude } from "./lower-event-target.js"; /** One file's declarations, split for collection and init-body lowering. */ export interface FileParts { @@ -2971,7 +2972,10 @@ function rememberEvaluationError( * re-imports, re-requires) into a cache hit. */ export function buildMain(lowerer: Lowerer): IrFunction { const loc: SrcLoc = { file: lowerer.entry.fileName, start: 0, end: 0 }; - const body: IrStmt[] = [...cjsModuleRegistryPrelude(lowerer, loc)]; + const body: IrStmt[] = [ + ...cjsModuleRegistryPrelude(lowerer, loc), + ...handleEventReaderPrelude(lowerer, loc), + ]; const roots = [lowerer.entry, ...lowerer.forkTargets, ...lowerer.workerTargets]; const isAsync = roots.some((root) => lowerer.asyncInitFiles.has(root)); const callRoot = (root: ts.SourceFile): IrStmt[] => { diff --git a/packages/compiler/src/frontend/lowering/lower-stdlib.ts b/packages/compiler/src/frontend/lowering/lower-stdlib.ts index dc6595ec5f..20caf184b9 100644 --- a/packages/compiler/src/frontend/lowering/lower-stdlib.ts +++ b/packages/compiler/src/frontend/lowering/lower-stdlib.ts @@ -31,6 +31,7 @@ import { } from "../../diagnostics/diagnostic.js"; import { esmNamedImportLinkCrash, isCjsJsFile, locOf, npmPackageNameOf } from "../program.js"; import { foldedStringKeyOf, lowerDynObjectLiteral } from "./expressions/object-literals.js"; +import { noteEventListeners } from "./lower-event-target.js"; import { PoisonError, newFnCtx, own } from "./lowerer.js"; import { NODE24_FETCH_COMPAT_PROFILE, @@ -874,7 +875,7 @@ function hasLiveWebMutableArm(lowerer: Lowerer, type: IrType): boolean { * this capsule is deliberately limited to records/arrays/bytes (including * those selected at runtime from a union) that the live materializer can * snapshot and commit. */ -function lowerLiveWebValue(lowerer: Lowerer, node: ts.Expression, lowered?: IrExpr): IrExpr { +export function lowerLiveWebValue(lowerer: Lowerer, node: ts.Expression, lowered?: IrExpr): IrExpr { const value = lowered ?? lowerer.lowerExpr(node); if ( hasLiveWebMutableArm(lowerer, value.type) && @@ -1467,6 +1468,7 @@ export function lowerStaticFetchCompanionCall( if (!symbol || !lowerer.isStdlibSymbol(symbol)) return null; const loc = locOf(call); if (root.text === "AbortSignal") { + noteEventListeners(lowerer, loc); switch (call.expression.name.text) { case "timeout": if (call.arguments[0] && ts.isSpreadElement(call.arguments[0])) { @@ -1782,6 +1784,7 @@ export function lowerStaticAbortSignalListenerCall( const recv = lowerer.lowerExpr(access.expression); if (recv.type.kind !== "dyn") return null; const loc = locOf(call); + noteEventListeners(lowerer, loc); const args = call.arguments.map((arg, index) => index === 1 ? lowerLiveWebValue(lowerer, arg) : lowerer.lowerExprExpecting(arg, DYN), ); @@ -1813,6 +1816,7 @@ export function lowerEventTargetNew(lowerer: Lowerer, expr: ts.NewExpression): I const args = expr.arguments ?? []; if (args.some(ts.isSpreadElement)) return null; const loc = locOf(expr); + if (name === "EventTarget") noteEventListeners(lowerer, loc); const values = args.map((arg) => ts.isObjectLiteralExpression(arg) ? lowerDynObjectLiteral(lowerer, arg) @@ -1847,6 +1851,7 @@ export function lowerAbortControllerNew(lowerer: Lowerer, expr: ts.NewExpression const args = expr.arguments ?? []; if (args.some((argument) => ts.isSpreadElement(argument))) return null; const loc = locOf(expr); + noteEventListeners(lowerer, loc); const result: IrExpr = { kind: "libCall", diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index 333272835a..182793d0c6 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -1,4 +1,5 @@ import { dynUndefinedExpr, numLit, varRef } from "../../ir/build.js"; +import { lowerEventObjectPropertyWrite } from "./lower-event-target.js"; import { lowerDynObjectLiteral } from "./expressions/object-literals.js"; import { importMetaBindingSource } from "./import-meta.js"; import { iteratorCanStep, iteratorValue } from "./iterator-consumption.js"; @@ -3627,7 +3628,7 @@ function classInstanceRestValue( ); } for (let c: ClassInfo | null = info; c; c = c.base) { - if (c.builtinError || c.builtinEmitter || c.builtinStream) { + if (c.builtinError || c.builtinEmitter || c.builtinStream || c.builtinEventTarget) { lowerer.unsupported( "SC1031", blame, @@ -6071,6 +6072,11 @@ export function lowerExprStatement(lowerer: Lowerer, expr: ts.Expression): IrStm if (ts.isElementAccessExpression(expr.left)) return lowerer.lowerElementWrite(expr); if (ts.isPropertyAccessExpression(expr.left)) { fenceNodeModuleMutation(lowerer, expr.left, "assignment"); + // The writable Event accessors on Event subclass instances. + { + const eventWrite = lowerEventObjectPropertyWrite(lowerer, expr.left, expr.right); + if (eventWrite) return { kind: "exprStmt", expr: eventWrite, loc: locOf(expr) }; + } // Native arrays have a writable length property. The runtime grows // by creating holes and truncates with RC-aware removal; keep this // as a statement operation so invalid lengths can use the normal diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index 4175dc8866..9f16280239 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -257,6 +257,7 @@ import { appendWorkerModules, } from "./lower-modules.js"; import { prepareCjsModuleGraph } from "./lower-node-module.js"; +import { registerBuiltinEventTargetClasses } from "./lower-event-target.js"; import { type ClassInfo, type ClassMethodSignature, @@ -445,6 +446,7 @@ import { stdlibGlobalFnOf, lowerAbortControllerNew, lowerEventTargetNew, + lowerLiveWebValue, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, @@ -1740,6 +1742,9 @@ export class Lowerer { requestInitPropMutatedSyms: Set | null = null; emitterEventTable: Map | null = null; emitterComputedPatterns: ComputedEventPattern[] = []; + /** The EventTarget engine's handleEvent reader was lifted + * (lower-event-target.ts noteEventListeners). */ + handleEventReader = false; /** Locals widened beyond the checker's type because an inferred indexed * read can be absent at runtime. Bare reads preserve that union until a * surrounding JavaScript guard/default consumes it. */ @@ -2737,6 +2742,7 @@ export class Lowerer { this.registerBuiltinErrorClasses(); registerBuiltinEmitterClass(this); registerBuiltinStreamClasses(this); + registerBuiltinEventTargetClasses(this); } registerBuiltinErrorClasses(): void { @@ -10297,6 +10303,10 @@ export class Lowerer { return lowerElementWrite(this, expr); } + lowerLiveWebValue(node: ts.Expression): IrExpr { + return lowerLiveWebValue(this, node); + } + ensureString(e: IrExpr, node: ts.Node): IrExpr { return ensureString(this, e, node); } diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index f086c1cebd..a6d169cf81 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -90,6 +90,10 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "abort.any", "event.new", "event.customNew", + "event.init", + "event.targetCall", + "event.targetDispatch", + "event.call", "events.addAbortListener", "fetch.streamNew", "fetch.streamFrom", diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index 371dbbbc71..23a8a9df2b 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -73,6 +73,25 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ "event.new": { argTypes: [DYN], result: DYN }, "event.customNew": { argTypes: [DYN], result: DYN }, "event.is": { argTypes: [DYN, F64], result: BOOL }, + /** Compiled EventTarget and Event subclasses: the receiver is the + * instance (an object rooted at %EventTarget / %Event). targetInit and + * init are super() (init takes the argument vector as one dyn array + * and throws the constructor's validation errors; initType is the + * super(type) form with a string); targetCall runs an EventTarget method + * with the instance's own capsule as `self` (targetDispatch is its + * dispatchEvent(event) form, answering the bool); call, get and set + * reach the Event members. */ + "event.targetInit": { argTypes: [null], result: VOID }, + "event.init": { argTypes: [null, DYN], result: VOID }, + "event.initType": { argTypes: [null, STRING], result: VOID }, + /** %main hands the engine the compiled `listener.handleEvent` reader + * (lower-event-target.ts noteEventListeners). */ + "event.handleEventReader": { argTypes: [DYN], result: VOID }, + "event.targetDispatch": { argTypes: [null, DYN, DYN], result: BOOL }, + "event.targetCall": { argTypes: [null, DYN, STRING, DYN], result: DYN }, + "event.call": { argTypes: [null, STRING, DYN], result: DYN }, + "event.get": { argTypes: [null, STRING], result: DYN }, + "event.set": { argTypes: [null, STRING, DYN], result: VOID }, "events.addAbortListener": { argTypes: [DYN, DYN], result: DYN }, "abort.timeout": { argTypes: [DYN], result: DYN }, "abort.now": { argTypes: [DYN], result: DYN }, diff --git a/packages/compiler/src/ir/ir.ts b/packages/compiler/src/ir/ir.ts index 3eeba87028..179acc019a 100644 --- a/packages/compiler/src/ir/ir.ts +++ b/packages/compiler/src/ir/ir.ts @@ -486,6 +486,8 @@ export function runtimeRcStem(t: IrType): string | null { if (RUNTIME_ERROR_CLASSES.has(t.className)) return "scr_error"; if (t.className === RUNTIME_EMITTER_CLASS) return "scr_emitter"; if (RUNTIME_STREAM_CLASSES.has(t.className)) return "scr_stream"; + if (t.className === RUNTIME_EVENT_TARGET_CLASS) return "scr_event_target_obj"; + if (t.className === RUNTIME_EVENT_CLASS) return "scr_event_obj"; return null; } const stem = RUNTIME_RC_STEMS[t.kind]; @@ -1412,6 +1414,19 @@ export const RUNTIME_STREAM_CLASSES: ReadonlyMap< ["%PassThrough", { lib: "PassThrough", base: "%Transform", sides: "rw" }], ]); +/** The runtime-provided EventTarget and Event bases of compiled + * subclasses (`class Bus extends EventTarget`, `class Ping extends + * Event`; scr_event_target.c, link-gated with the rest of the EventTarget + * surface). Plain `new EventTarget()` / `new Event()` values stay + * checked-dynamic handles; these classes exist only as roots of program + * hierarchies. Like the emitter, backends emit no struct/RC/vtable for + * them: subclass structs embed the runtime prefix (the engine-state + * pointer created by super() and the display-name slot stamped by the + * emitted allocation), and the instances' checked-dynamic capsules use + * the runtime RC adapters, which is how the engine recognizes them. */ +export const RUNTIME_EVENT_TARGET_CLASS = "%EventTarget"; +export const RUNTIME_EVENT_CLASS = "%Event"; + export interface IrRecordShape { /** Frontend-assigned shape id (`r0`, `r1`, ...). */ id: string; diff --git a/packages/compiler/src/ir/runtime-features.ts b/packages/compiler/src/ir/runtime-features.ts index e610fc5062..a0bb5b761f 100644 --- a/packages/compiler/src/ir/runtime-features.ts +++ b/packages/compiler/src/ir/runtime-features.ts @@ -1,6 +1,11 @@ import type { IrExpr, IrModule, IrType } from "./ir.js"; import type { IrLibFn } from "./builtin-signatures.js"; -import { RUNTIME_EMITTER_CLASS, RUNTIME_STREAM_CLASSES } from "./ir.js"; +import { + RUNTIME_EMITTER_CLASS, + RUNTIME_EVENT_CLASS, + RUNTIME_EVENT_TARGET_CLASS, + RUNTIME_STREAM_CLASSES, +} from "./ir.js"; import { everyModuleNode } from "./traverse.js"; export interface RuntimeFeatures { @@ -114,7 +119,11 @@ function scanRuntimeFeatures(mod: IrModule, stopAt?: keyof RuntimeFeatures): Run legacyTextDecoder: false, fileHandle: false, fetch: false, - eventTarget: false, + // Subclasses of the runtime EventTarget/Event bases tear down and box + // through the EventTarget unit even when no event.* libCall survives. + eventTarget: (mod.classes ?? []).some( + (c) => c.name === RUNTIME_EVENT_TARGET_CLASS || c.name === RUNTIME_EVENT_CLASS, + ), processEvents: false, emitter: mod.workers === true || (mod.classes ?? []).some((c) => c.name === RUNTIME_EMITTER_CLASS), diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5240-event-target-subclass.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5240-event-target-subclass.ts.json new file mode 100644 index 0000000000..85dda61a61 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5240-event-target-subclass.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5240-event-target-subclass.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5241-event-subclass.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5241-event-subclass.ts.json new file mode 100644 index 0000000000..db8c3c224c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5241-event-subclass.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5241-event-subclass.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5242-event-target-subclass-hierarchy.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5242-event-target-subclass-hierarchy.ts.json new file mode 100644 index 0000000000..ec2b7b883b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5242-event-target-subclass-hierarchy.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5242-event-target-subclass-hierarchy.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5243-event-target-subclass-dynamic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5243-event-target-subclass-dynamic.ts.json new file mode 100644 index 0000000000..70726d59c5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5243-event-target-subclass-dynamic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5243-event-target-subclass-dynamic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5244-event-target-subclass.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5244-event-target-subclass.js.json new file mode 100644 index 0000000000..791baa5064 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5244-event-target-subclass.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5244-event-target-subclass.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5245-event-target-subclass-signals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5245-event-target-subclass-signals.ts.json new file mode 100644 index 0000000000..9d33cd596e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5245-event-target-subclass-signals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5245-event-target-subclass-signals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5246-event-target-subclass-listener-throw.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5246-event-target-subclass-listener-throw.ts.json new file mode 100644 index 0000000000..82bff1bb78 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5246-event-target-subclass-listener-throw.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5246-event-target-subclass-listener-throw.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5247-event-target-subclass-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5247-event-target-subclass-lifetimes.ts.json new file mode 100644 index 0000000000..99168b305c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5247-event-target-subclass-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5247-event-target-subclass-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5248-event-target-subclass-warnings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5248-event-target-subclass-warnings.ts.json new file mode 100644 index 0000000000..83fd33bf08 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5248-event-target-subclass-warnings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5248-event-target-subclass-warnings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5249-event-target-subclass-unconstructed.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5249-event-target-subclass-unconstructed.ts.json new file mode 100644 index 0000000000..344d12e156 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5249-event-target-subclass-unconstructed.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5249-event-target-subclass-unconstructed.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/event-target-subclass-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/event-target-subclass-fences.ts.json new file mode 100644 index 0000000000..9482a3b8dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/event-target-subclass-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/event-target-subclass-fences.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_dyn_invoke.c b/packages/runtime/src/scr_dyn_invoke.c index a2e9854fdf..17a964312f 100644 --- a/packages/runtime/src/scr_dyn_invoke.c +++ b/packages/runtime/src/scr_dyn_invoke.c @@ -830,6 +830,9 @@ static ScrDyn *scr_dyn_invoke_impl( bool handled = false; ScrDyn *fast = dyn_live_array_method(recv, method, args, argc, what, &handled); if (handled) return fast; + if (scr_event_ref_hooks && + scr_event_ref_hooks->invoke(recv, method, args, argc, what, &fast)) + return fast; ScrDyn *materialized = scr_dyn_typed_ref_materialize(recv); if (scr_exc_pending()) { scr_dyn_release(materialized); diff --git a/packages/runtime/src/scr_event_target.c b/packages/runtime/src/scr_event_target.c index f269294170..722d7e5bff 100644 --- a/packages/runtime/src/scr_event_target.c +++ b/packages/runtime/src/scr_event_target.c @@ -355,6 +355,9 @@ void scr_et_core_init(ScrEventTargetCore *core, double max_listeners, const char void scr_et_core_drop(ScrEventTargetCore *core) { scr_et_core_untrack(core); + /* Released last: it may hold the instance that owns this core. */ + ScrDyn *self = core->self; + core->self = NULL; ScrEtRoot *roots = core->roots; ScrEtHandler *handlers = core->handlers; core->roots = NULL; @@ -390,6 +393,7 @@ void scr_et_core_drop(ScrEventTargetCore *core) { } handlers = next; } + scr_dyn_release(self); } /* Appends a listener node to the type's list (Node's addEventListener @@ -680,6 +684,15 @@ static void scr_et_reject_through_catch(ScrCaught *caught /* moves */) { /* Calls one listener with `this` = the target (functions) or the listener * object (handleEvent). */ +static SCR_TL ScrDyn *scr_et_handle_event_reader; + +void scr_event_handle_event_reader(ScrDyn *reader) { + ScrDyn *old = scr_et_handle_event_reader; + scr_et_handle_event_reader = scr_dyn_retain(reader); + scr_dyn_release(old); + scr_et_register_teardown(); +} + static void scr_et_invoke(ScrEtListener *l, ScrDyn *self, ScrDyn *event) { if (l->native) { l->native(l->ctx, self, event); @@ -710,7 +723,11 @@ static void scr_et_invoke(ScrEtListener *l, ScrDyn *self, ScrDyn *event) { ScrDyn *handle = NULL; if (current->kind == SCR_DYN_OBJ || current->kind == SCR_DYN_PROXY || current->kind == SCR_DYN_TYPED_REF) { - if (current->kind == SCR_DYN_TYPED_REF) { + if (current->kind == SCR_DYN_TYPED_REF && scr_et_handle_event_reader) { + /* A class instance's handleEvent is a compiled method. */ + ScrDyn *reader_args[1] = {current}; + handle = scr_dyn_call(scr_et_handle_event_reader, reader_args, 1, "handleEvent"); + } else if (current->kind == SCR_DYN_TYPED_REF) { ScrDyn *view = scr_dyn_typed_ref_materialize(current); handle = view ? scr_dyn_obj_read(view, "handleEvent", 11) : NULL; scr_dyn_release(view); @@ -764,12 +781,15 @@ static void scr_et_invoke(ScrEtListener *l, ScrDyn *self, ScrDyn *event) { /* ── dispatch (kHybridDispatch) ────────────────────────────────────── */ +static ScrEventObj *scr_event_obj_of(const ScrDyn *d); + static ScrEvent *scr_event_of(const ScrDyn *d) { if (d && d->kind == SCR_DYN_HANDLE && (d->v.handle.tag == SCR_DYNH_EVENT || d->v.handle.tag == SCR_DYNH_CUSTOM_EVENT)) { return (ScrEvent *)d->v.handle.ptr; } - return NULL; + ScrEventObj *obj = scr_event_obj_of(d); + return obj ? obj->ev : NULL; } static void scr_event_set_target(ScrEvent *ev, ScrDyn *target) { @@ -958,6 +978,83 @@ static bool scr_et_key(const char *key, size_t len, const char *want) { return strlen(want) == len && memcmp(key, want, len) == 0; } +/* ── method values ────────────────────────────────────────────────── + * A member read as a value (`event.preventDefault`, `target[name]`) is + * the prototype's function: it runs the member on its `this`, and any + * other receiver throws Node's ERR_INVALID_THIS. One function per member, + * so repeated reads compare equal. */ +static const char *const scr_et_method_names[] = { + "addEventListener", "removeEventListener", "dispatchEvent", "preventDefault", + "stopPropagation", "stopImmediatePropagation", "composedPath", "initEvent", +}; +static const uint32_t scr_et_method_lengths[] = {2, 2, 1, 0, 0, 0, 0, 1}; +enum { SCR_ET_TARGET_METHODS = 3, SCR_ET_METHODS = 8 }; +static SCR_TL ScrDyn *scr_et_method_values[SCR_ET_METHODS]; + +static ScrEventTargetObj *scr_event_target_obj_of(const ScrDyn *d); + +typedef struct ScrEventTarget { + size_t rc; + ScrEventTargetCore core; +} ScrEventTarget; + +static bool scr_et_target_method(ScrEventTargetCore *core, ScrDyn *self, const char *method, + ScrDyn *const *args, size_t argc, ScrDyn **out); +static ScrDyn *scr_event_invoke(void *ptr, ScrDyn *self, const char *method, ScrDyn *const *args, + size_t argc, const char *what); + +/* The listener core of an EventTarget value: a plain target, an + * AbortSignal, or a subclass instance; NULL for anything else. */ +static ScrEventTargetCore *scr_et_core_of(const ScrDyn *d) { + ScrEventTargetObj *obj = scr_event_target_obj_of(d); + if (obj) return obj->core; + if (d->kind == SCR_DYN_HANDLE && d->v.handle.tag == SCR_DYNH_EVENT_TARGET) + return &((ScrEventTarget *)d->v.handle.ptr)->core; + bool aborted; + return scr_et_signal_core_fn ? scr_et_signal_core_fn(d, &aborted) : NULL; +} + +static ScrDyn *scr_et_method_call(ScrClosure *clo, ScrDyn *const *args, size_t argc) { + size_t index = (size_t)scr_box_get_f64(clo->caps[0]); + const char *method = scr_et_method_names[index]; + ScrDyn *self = scr_dyn_this_get(); + bool target = index < SCR_ET_TARGET_METHODS; + ScrEventTargetCore *core = target ? scr_et_core_of(self) : NULL; + ScrEvent *ev = target ? NULL : scr_event_of(self); + if (!core && !ev) { + scr_dyn_release(self); + char message[64]; + snprintf(message, sizeof message, "Value of \"this\" must be of type %s", + target ? "EventTarget" : "Event"); + scr_throw_error_msg_code(SCR_ERR_TYPE, message, strlen(message), "ERR_INVALID_THIS"); + return NULL; + } + ScrDyn *out = NULL; + if (core) scr_et_target_method(core, self, method, args, argc, &out); + else out = scr_event_invoke(ev, self, method, args, argc, method); + scr_dyn_release(self); + return out; +} + +/* The function of member `key` (+1), or NULL when `key` names none. */ +static ScrDyn *scr_et_method_value(const char *key, size_t len, bool target) { + size_t from = target ? 0 : SCR_ET_TARGET_METHODS; + size_t to = target ? SCR_ET_TARGET_METHODS : SCR_ET_METHODS; + for (size_t i = from; i < to; i++) { + const char *name = scr_et_method_names[i]; + if (strlen(name) != len || memcmp(name, key, len) != 0) continue; + if (!scr_et_method_values[i]) { + ScrClosure *clo = scr_closure_new(NULL, 1); + clo->caps[0] = scr_box_new(SCR_BOX_F64); + scr_box_set_f64(clo->caps[0], (double)i); + scr_et_method_values[i] = + scr_dyn_new_func(clo, scr_et_method_call, scr_et_method_lengths[i], "", name); + } + return scr_dyn_retain(scr_et_method_values[i]); + } + return NULL; +} + static ScrDyn *scr_event_target_value(const ScrEvent *ev) { return ev->target ? scr_dyn_retain(ev->target) : scr_dyn_new_null(); } @@ -982,7 +1079,7 @@ static ScrDyn *scr_event_get(void *ptr, const char *key, size_t len) { if (scr_et_key(key, len, "isTrusted")) return scr_dyn_new_bool(ev->trusted); if (ev->custom && scr_et_key(key, len, "detail")) return ev->detail ? scr_dyn_retain(ev->detail) : scr_dyn_new_null(); - return NULL; + return scr_et_method_value(key, len, false); } static bool scr_event_set(void *ptr, const char *key, size_t len, const ScrDyn *value) { @@ -1004,6 +1101,15 @@ static void scr_et_not_function(const char *what) { scr_throw_error_msg(SCR_ERR_TYPE, message, strlen(message)); } +static bool scr_event_method_is(const char *method) { + static const char *const names[] = {"preventDefault", "stopPropagation", + "stopImmediatePropagation", "composedPath", "initEvent"}; + for (size_t i = 0; i < sizeof names / sizeof names[0]; i++) { + if (strcmp(method, names[i]) == 0) return true; + } + return false; +} + static ScrDyn *scr_event_invoke(void *ptr, ScrDyn *self, const char *method, ScrDyn *const *args, size_t argc, const char *what) { ScrEvent *ev = ptr; @@ -1078,11 +1184,6 @@ static const ScrDynHandleOps scr_custom_event_ops = { /* ── EventTarget handles ───────────────────────────────────────────── */ -typedef struct ScrEventTarget { - size_t rc; - ScrEventTargetCore core; -} ScrEventTarget; - static void *scr_event_target_retain_v(void *p) { ((ScrEventTarget *)p)->rc++; return p; @@ -1095,23 +1196,33 @@ static void scr_event_target_release_v(void *p) { free(t); } +/* The EventTarget methods over a core; false when `method` is not one. */ +static bool scr_et_target_method(ScrEventTargetCore *core, ScrDyn *self, const char *method, + ScrDyn *const *args, size_t argc, ScrDyn **out) { + if (strcmp(method, "addEventListener") == 0) { + *out = scr_et_add_listener(core, args, argc); + } else if (strcmp(method, "removeEventListener") == 0) { + *out = scr_et_remove_listener(core, args, argc); + } else if (strcmp(method, "dispatchEvent") == 0) { + *out = scr_et_dispatch_event(core, self, args, argc); + } else { + return false; + } + return true; +} + static ScrDyn *scr_event_target_invoke(void *ptr, ScrDyn *self, const char *method, ScrDyn *const *args, size_t argc, const char *what) { ScrEventTarget *t = ptr; - if (strcmp(method, "addEventListener") == 0) return scr_et_add_listener(&t->core, args, argc); - if (strcmp(method, "removeEventListener") == 0) - return scr_et_remove_listener(&t->core, args, argc); - if (strcmp(method, "dispatchEvent") == 0) - return scr_et_dispatch_event(&t->core, self, args, argc); + ScrDyn *out; + if (scr_et_target_method(&t->core, self, method, args, argc, &out)) return out; scr_et_not_function(what); return NULL; } static ScrDyn *scr_event_target_get(void *ptr, const char *key, size_t len) { (void)ptr; - (void)key; - (void)len; - return NULL; + return scr_et_method_value(key, len, true); } static bool scr_event_target_set(void *ptr, const char *key, size_t len, const ScrDyn *value) { @@ -1137,6 +1248,245 @@ static const ScrDynHandleOps scr_event_target_ops = { .inspect_view = scr_event_target_inspect_view, }; +/* ── compiled subclasses (`class Bus extends EventTarget`) ───────────── + * Instances are compiler-emitted hierarchy objects whose prefix points at + * the engine state (scr_runtime.h). Their checked-dynamic capsules carry + * the RC adapters below, so a capsule's release adapter identifies the + * family: such a capsule is a target's `self`, the event a listener + * receives, and what event.target answers. */ + +void *scr_event_target_obj_retain_v(void *o) { + ScrEventTargetObj *t = o; + if (t && t->rc != SIZE_MAX) t->rc++; + return o; +} + +void scr_event_target_obj_release_v(void *o) { + ScrEventTargetObj *t = o; + if (!t || t->rc == SIZE_MAX) return; + t->vt->release(t); /* the dynamic class's teardown */ +} + +void *scr_event_obj_retain_v(void *o) { + ScrEventObj *e = o; + if (e && e->rc != SIZE_MAX) e->rc++; + return o; +} + +void scr_event_obj_release_v(void *o) { + ScrEventObj *e = o; + if (!e || e->rc == SIZE_MAX) return; + e->vt->release(e); +} + +void *scr_event_target_obj_retain(void *o) { return scr_event_target_obj_retain_v(o); } +void scr_event_target_obj_release(void *o) { scr_event_target_obj_release_v(o); } +void *scr_event_obj_retain(void *o) { return scr_event_obj_retain_v(o); } +void scr_event_obj_release(void *o) { scr_event_obj_release_v(o); } + +static ScrEventTargetObj *scr_event_target_obj_of(const ScrDyn *d) { + return d && d->kind == SCR_DYN_TYPED_REF && + d->v.typed_ref.release == &scr_event_target_obj_release_v + ? (ScrEventTargetObj *)d->v.typed_ref.ptr + : NULL; +} + +static ScrEventObj *scr_event_obj_of(const ScrDyn *d) { + return d && d->kind == SCR_DYN_TYPED_REF && d->v.typed_ref.release == &scr_event_obj_release_v + ? (ScrEventObj *)d->v.typed_ref.ptr + : NULL; +} + +static void scr_et_install(void); +static ScrEvent *scr_event_construct(ScrDyn *args, bool custom); + +void scr_event_target_obj_init(void *obj) { + scr_et_install(); + ScrEventTargetObj *t = obj; + t->core = scr_et_calloc(sizeof *t->core); + scr_et_core_init(t->core, 10, t->cls); +} + +/* The instance's rc reached zero, so its cached capsule (which holds the + * instance) is already gone. */ +void scr_event_target_state_drop(ScrEventTargetCore *core) { + if (!core) return; + scr_et_core_drop(core); + free(core); +} + +void scr_event_target_state_trace(ScrEventTargetCore *core, ScrTraceVisit visit, void *ctx) { + if (!core) return; + if (core->self) visit(core->self, ctx); + for (ScrEtRoot *root = core->roots; root; root = root->map_next) { + for (ScrEtListener *l = root->head; l; l = l->next) { + if (l->listener) visit(l->listener, ctx); + } + } + for (ScrEtHandler *h = core->handlers; h; h = h->next) { + if (h->handler) visit(h->handler, ctx); + } +} + +/* The collector's teardown: the traced values are the collector's to + * account, so they leave the state unreleased; the rest drops as usual. */ +void scr_event_target_state_gcfree(ScrEventTargetCore *core) { + if (!core) return; + core->self = NULL; + for (ScrEtRoot *root = core->roots; root; root = root->map_next) { + for (ScrEtListener *l = root->head; l; l = l->next) l->listener = NULL; + } + for (ScrEtHandler *h = core->handlers; h; h = h->next) h->handler = NULL; + scr_et_core_drop(core); + free(core); +} + +/* The first method call through a capsule of the instance keeps it. */ +static void scr_et_keep_self(ScrEventTargetObj *t, ScrDyn *self) { + if (!t->core->self && self && scr_event_target_obj_of(self) == t) + t->core->self = scr_dyn_retain(self); +} + +void scr_event_obj_init(void *obj, ScrDyn *args) { + ScrEventObj *e = obj; + e->ev = scr_event_construct(args, false); +} + +/* super(type) with a string: nothing to validate or convert. */ +void scr_event_obj_init_type(void *obj, ScrStr *type) { + scr_et_install(); + ScrEventObj *e = obj; + e->ev = scr_event_alloc(scr_str_retain(type), false); +} + +void scr_event_state_drop(ScrEvent *ev) { + if (ev) scr_event_release_v(ev); +} + +void scr_event_state_trace(ScrEvent *ev, ScrTraceVisit visit, void *ctx) { + if (!ev) return; + if (ev->target) visit(ev->target, ctx); + if (ev->detail) visit(ev->detail, ctx); +} + +void scr_event_state_gcfree(ScrEvent *ev) { + if (!ev) return; + ev->target = NULL; + ev->detail = NULL; + scr_event_release_v(ev); +} + +/* The typed-receiver entry points: `method` is the member's name literal + * (string data is NUL-terminated), `args` the argument vector as one dyn + * array. */ +ScrDyn *scr_event_target_obj_call(void *obj, ScrDyn *self, ScrStr *method, ScrDyn *args) { + ScrEventTargetObj *t = obj; + scr_et_keep_self(t, self); + ScrDyn *out = NULL; + scr_et_target_method(t->core, self, method->data, args->v.arr.items, args->v.arr.len, &out); + return out; +} + +/* dispatchEvent(event) on a typed receiver: the result as a bool (false + * with the exception pending). */ +bool scr_event_target_obj_dispatch(void *obj, ScrDyn *self, ScrDyn *event) { + ScrEventTargetObj *t = obj; + scr_et_keep_self(t, self); + ScrDyn *args[1] = {event}; + ScrDyn *out = scr_et_dispatch_event(t->core, self, args, 1); + if (!out) return false; + bool accepted = out->v.b; + scr_dyn_release(out); + return accepted; +} + +ScrDyn *scr_event_obj_get(void *obj, ScrStr *key) { + ScrEventObj *e = obj; + ScrDyn *value = scr_event_get(e->ev, key->data, key->len); + return value ? value : scr_dyn_retain(scr_dyn_undefined()); +} + +void scr_event_obj_set(void *obj, ScrStr *key, ScrDyn *value) { + ScrEventObj *e = obj; + scr_event_set(e->ev, key->data, key->len, value); +} + +ScrDyn *scr_event_obj_call(void *obj, ScrStr *method, ScrDyn *args) { + ScrEventObj *e = obj; + return scr_event_invoke(e->ev, NULL, method->data, args->v.arr.items, args->v.arr.len, + method->data); +} + +/* Checked-dynamic access to the inherited members (the handle ops' twins + * over the capsule; members of the subclass itself answer through the + * capsule's ordinary view). */ +static ScrDyn *scr_event_ref_get(const ScrDyn *d, const ScrStr *key) { + if (scr_event_target_obj_of(d)) return scr_et_method_value(key->data, key->len, true); + ScrEventObj *e = scr_event_obj_of(d); + return e && e->ev ? scr_event_get(e->ev, key->data, key->len) : NULL; +} + +static bool scr_event_ref_set(ScrDyn *d, const ScrStr *key, const ScrDyn *value) { + ScrEventTargetObj *t = scr_event_target_obj_of(d); + ScrEventObj *e = scr_event_obj_of(d); + if (!t && !(e && e->ev)) return false; + if (e && scr_event_set(e->ev, key->data, key->len, value)) return true; + /* The other inherited members are getters and prototype methods; a + * write would shadow them with an own property the engine never + * reads. */ + ScrDyn *inherited = t ? scr_et_method_value(key->data, key->len, true) + : scr_event_get(e->ev, key->data, key->len); + if (!inherited) return false; + scr_dyn_release(inherited); + char message[128]; + snprintf(message, sizeof message, + "writing the inherited member '%.*s' through an untyped value is not supported", + (int)key->len, key->data); + scr_throw_error_msg_code(SCR_ERR_ERROR, message, strlen(message), "SC2020"); + return true; +} + +static bool scr_event_ref_invoke(ScrDyn *d, const char *method, ScrDyn *const *args, size_t argc, + const char *what, ScrDyn **out) { + ScrEventTargetObj *t = scr_event_target_obj_of(d); + if (t) { + if (!t->core) return false; + scr_et_keep_self(t, d); + return scr_et_target_method(t->core, d, method, args, argc, out); + } + ScrEventObj *e = scr_event_obj_of(d); + if (!e || !e->ev || !scr_event_method_is(method)) return false; + *out = scr_event_invoke(e->ev, d, method, args, argc, what); + return true; +} + +/* Node's [kInspect] on the subclass: the constructor's name, then the + * Event view (an empty object for targets). */ +static ScrDyn *scr_event_ref_inspect_view(const ScrDyn *d, const char **cls) { + ScrEventTargetObj *t = scr_event_target_obj_of(d); + if (t) { + *cls = t->cls; + return scr_dyn_new_obj(); + } + ScrEventObj *e = scr_event_obj_of(d); + if (!e || !e->ev) return NULL; + *cls = e->cls; + return scr_event_inspect_view(e->ev); +} + +static const char *scr_event_ref_string_tag(const ScrDyn *d) { + if (scr_event_target_obj_of(d)) return "[object EventTarget]"; + return scr_event_obj_of(d) ? "[object Event]" : NULL; +} + +static const ScrEventRefHooks scr_event_obj_ref_hooks = { + .get = scr_event_ref_get, + .set = scr_event_ref_set, + .invoke = scr_event_ref_invoke, + .inspect_view = scr_event_ref_inspect_view, + .string_tag = scr_event_ref_string_tag, +}; + static void scr_et_install(void) { static SCR_TL bool installed; if (installed) return; @@ -1144,12 +1494,19 @@ static void scr_et_install(void) { scr_dyn_handle_install(SCR_DYNH_EVENT, &scr_event_ops); scr_dyn_handle_install(SCR_DYNH_CUSTOM_EVENT, &scr_custom_event_ops); scr_dyn_handle_install(SCR_DYNH_EVENT_TARGET, &scr_event_target_ops); + scr_event_ref_hooks = &scr_event_obj_ref_hooks; scr_et_register_teardown(); } static void scr_et_teardown(void) { while (scr_et_live_cores) scr_et_core_drop(scr_et_live_cores); while (scr_et_live_events) scr_event_drop_refs(scr_et_live_events); + for (size_t i = 0; i < SCR_ET_METHODS; i++) { + scr_dyn_release(scr_et_method_values[i]); + scr_et_method_values[i] = NULL; + } + scr_dyn_release(scr_et_handle_event_reader); + scr_et_handle_event_reader = NULL; } ScrDyn *scr_event_target_new(void) { @@ -1236,6 +1593,11 @@ ScrDyn *scr_custom_event_new(ScrDyn *args) { } bool scr_event_is(const ScrDyn *v, double kind) { + if (v->kind == SCR_DYN_TYPED_REF) { + /* Compiled subclasses extend Event or EventTarget (never CustomEvent). */ + if (kind == 0) return scr_event_obj_of(v) != NULL; + return kind == 2 && scr_event_target_obj_of(v) != NULL; + } if (v->kind != SCR_DYN_HANDLE) return false; ScrDynHandleTag tag = v->v.handle.tag; if (kind == 0) return tag == SCR_DYNH_EVENT || tag == SCR_DYNH_CUSTOM_EVENT; diff --git a/packages/runtime/src/scr_inspect.c b/packages/runtime/src/scr_inspect.c index 787ff03c79..02d913c58e 100644 --- a/packages/runtime/src/scr_inspect.c +++ b/packages/runtime/src/scr_inspect.c @@ -1078,6 +1078,23 @@ ScrStr *scr_insp_dyn(ScrDyn *d, double recurse, double depth) { } case SCR_DYN_TYPED_REF: { + const char *cls = NULL; + ScrDyn *view = scr_event_ref_hooks ? scr_event_ref_hooks->inspect_view(d, &cls) : NULL; + if (view) { + /* The handle rule above: the class name past the depth limit. */ + if (recurse > depth) { + scr_dyn_release(view); + return scr_str_new(cls, strlen(cls)); + } + ScrStr *body = scr_insp_dyn(view, recurse, depth); + scr_dyn_release(view); + InspBuf out = {0}; + ib_cstr(&out, cls); + ib_char(&out, ' '); + ib_bytes(&out, body->data, body->len); + scr_str_release(body); + return ib_take(&out); + } ScrDyn *materialized = scr_dyn_typed_ref_materialize(d); ScrStr *out = scr_insp_dyn(materialized, recurse, depth); scr_dyn_release(materialized); diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index 0f712ca4ab..215106b66f 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -2517,8 +2517,25 @@ ScrDyn *scr_dyn_typed_ref_element(const ScrDyn *d, size_t index) { return NULL; } +SCR_TL const ScrEventRefHooks *scr_event_ref_hooks = NULL; + +ScrDyn *scr_dyn_typed_ref_string_view(const ScrDyn *d) { + ScrDyn *view = scr_dyn_typed_ref_materialize(d); + const char *tag = scr_event_ref_hooks ? scr_event_ref_hooks->string_tag(d) : NULL; + if (!tag || view->kind != SCR_DYN_OBJ || scr_dyn_property_owner(view, "toString", 8)) return view; + scr_dyn_release(view); + ScrStr *text = scr_str_new(tag, strlen(tag)); + ScrDyn *out = scr_dyn_new_str(text); + scr_str_release(text); + return out; +} + ScrDyn *scr_dyn_typed_ref_key_get(const ScrDyn *d, const ScrStr *key) { if (d->v.typed_ref.record) return scr_typed_ref_record_get(d, key); + if (scr_event_ref_hooks) { + ScrDyn *inherited = scr_event_ref_hooks->get(d, key); + if (inherited) return inherited; + } if (!scr_dyn_typed_ref_array_ops(d)) return NULL; if (scr_typed_ref_is_length(key)) return scr_dyn_new_num((double)((ScrArr *)d->v.typed_ref.ptr)->len); size_t index; @@ -5239,7 +5256,7 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc) { } case SCR_DYN_TYPED_REF: { - ScrDyn *materialized = scr_dyn_typed_ref_materialize(d); + ScrDyn *materialized = scr_dyn_typed_ref_string_view(d); ScrStr *s = scr_dyn_to_string(materialized, enc); scr_dyn_release(materialized); return s; @@ -5355,7 +5372,7 @@ ScrStr *scr_dyn_string_coerce_js(const ScrDyn *d) { return NULL; } if (d->kind == SCR_DYN_TYPED_REF) { - ScrDyn *materialized = scr_dyn_typed_ref_materialize(d); + ScrDyn *materialized = scr_dyn_typed_ref_string_view(d); ScrStr *out = scr_dyn_string_coerce_js(materialized); scr_dyn_release(materialized); return out; @@ -6016,6 +6033,7 @@ void scr_dyn_key_set(ScrDyn *recv, ScrStr *key, ScrDyn *value) { if (recv->kind == SCR_DYN_PROXY) { scr_dyn_proxy_set(recv, key, value); return; } if (recv->kind == SCR_DYN_TYPED_REF) { if (scr_typed_ref_array_set(recv, key, value)) return; + if (scr_event_ref_hooks && scr_event_ref_hooks->set(recv, key, value)) return; ScrDyn *materialized = scr_dyn_typed_ref_materialize(recv); scr_dyn_key_set(materialized, key, value); if (!scr_exc_pending()) scr_dyn_typed_ref_commit(recv); diff --git a/packages/runtime/src/scr_runtime.h b/packages/runtime/src/scr_runtime.h index 4d0b60ca9b..b3a691c824 100644 --- a/packages/runtime/src/scr_runtime.h +++ b/packages/runtime/src/scr_runtime.h @@ -5340,6 +5340,11 @@ bool scr_dyn_typed_ref_is_key(const ScrDyn *d, const ScrStr *type_key); void *scr_dyn_typed_ref_unbox(const ScrDyn *d); /* +1 */ ScrDyn *scr_dyn_class_view_unavailable(void *ptr); ScrDyn *scr_dyn_typed_ref_materialize(const ScrDyn *d); /* +1 */ +/* What string conversion renders for a capsule (+1): its materialized + * view, or, for an EventTarget or Event subclass without its own + * toString, the "[object EventTarget]" / "[object Event]" string of its + * inherited @@toStringTag. */ +ScrDyn *scr_dyn_typed_ref_string_view(const ScrDyn *d); void scr_dyn_typed_ref_commit(ScrDyn *d); /* Attach per-element access to a live array capsule (idempotent). Indexed * reads, `length`, in-range writes, `in`, own-property probes, and array @@ -5663,6 +5668,11 @@ typedef struct ScrEventTargetCore { ScrEtRoot *roots; /* per event type, in first-add order */ ScrEtHandler *handlers; /* event-handler attributes (`onabort`) */ ScrEtHook *hooks; /* options.signal removal hooks aimed here (weak) */ + /* A compiled subclass instance's own capsule (+1), kept from its first + * method call so every later `this` and event target is the same value. + * The instance holds the core, so this is a cycle the collector reclaims + * through the scr_event_target_state_* helpers. NULL otherwise. */ + ScrDyn *self; double max_listeners; /* 0 = no leak warning (AbortSignal) */ bool warned; const char *cls; /* the warning's target name ("EventTarget") */ @@ -5711,9 +5721,91 @@ bool scr_event_is(const ScrDyn *v, double kind); * signal's core and aborted flag, or NULL for a non-signal value. * Installed by the AbortSignal unit; NULL when no signal can exist. */ extern SCR_TL ScrEventTargetCore *(*scr_et_signal_core_fn)(const ScrDyn *d, bool *aborted); +/* The compiled `listener.handleEvent` read (dyn → dyn; the runtime keeps a + * reference), installed by %main when a program class declares + * handleEvent: dispatch reads a capsule listener's handleEvent through it, + * which reaches the class's compiled methods. Without it a capsule's own + * view answers. */ +void scr_event_handle_event_reader(ScrDyn *reader); /* events.addAbortListener(signal, listener): +1 disposable, or NULL. */ ScrDyn *scr_events_add_abort_listener(ScrDyn *signal, ScrDyn *listener); +/* Compiled subclasses (`class Bus extends EventTarget`, `class Ping + * extends Event`): an instance lays out like a compiler-emitted hierarchy + * class (rc, vt, then this prefix, then the subclass fields — the + * ScrEmitter arrangement). super() creates the engine state behind the + * prefix pointer; `cls` is the concrete class's name, stamped by the + * emitted allocation (the leak warning and util.inspect print it). The + * instances' checked-dynamic capsules carry the RC adapters below, which + * is how the engine recognizes them: a target's capsule is the `this` of + * its listeners and the events' target, and an event's capsule is what + * its listeners receive. */ +typedef struct ScrEventTargetObj { + size_t rc; + const ScrVt *vt; + ScrEventTargetCore *core; /* NULL until super() */ + const char *cls; +} ScrEventTargetObj; + +typedef struct ScrEventObj { + size_t rc; + const ScrVt *vt; + ScrEvent *ev; /* NULL until super() */ + const char *cls; +} ScrEventObj; + +void *scr_event_target_obj_retain_v(void *o); +void scr_event_target_obj_release_v(void *o); /* dispatches through vt */ +void *scr_event_obj_retain_v(void *o); +void scr_event_obj_release_v(void *o); +void *scr_event_target_obj_retain(void *o); +void scr_event_target_obj_release(void *o); +void *scr_event_obj_retain(void *o); +void scr_event_obj_release(void *o); +/* super() / super(type, options): `args` is the argument vector as one + * dyn array (borrowed); a bad type or options value leaves Node's + * exception pending. */ +void scr_event_target_obj_init(void *obj); +void scr_event_obj_init(void *obj, ScrDyn *args); +void scr_event_obj_init_type(void *obj, ScrStr *type); /* super(type), type borrowed */ +/* The emitted teardown's and collector's prefix helpers (NULL-tolerant): + * trace visits the listener values, `on` handlers and the cached + * capsule of a target, and the target and detail of an event; gcfree + * frees the state without releasing those traced edges. */ +void scr_event_target_state_drop(ScrEventTargetCore *core); +void scr_event_target_state_trace(ScrEventTargetCore *core, ScrTraceVisit visit, void *ctx); +void scr_event_target_state_gcfree(ScrEventTargetCore *core); +void scr_event_state_drop(ScrEvent *ev); +void scr_event_state_trace(ScrEvent *ev, ScrTraceVisit visit, void *ctx); +void scr_event_state_gcfree(ScrEvent *ev); +/* The inherited members on typed receivers: `method`/`key` name an + * EventTarget or Event member, `args` is the argument vector as one dyn + * array, `self` the target's own capsule (borrowed). +1 results, or NULL + * with the exception pending. */ +ScrDyn *scr_event_target_obj_call(void *obj, ScrDyn *self, ScrStr *method, ScrDyn *args); +/* dispatchEvent(event): the bool result, false with the exception pending. */ +bool scr_event_target_obj_dispatch(void *obj, ScrDyn *self, ScrDyn *event); +ScrDyn *scr_event_obj_call(void *obj, ScrStr *method, ScrDyn *args); +ScrDyn *scr_event_obj_get(void *obj, ScrStr *key); +void scr_event_obj_set(void *obj, ScrStr *key, ScrDyn *value); + +/* The same members through a capsule (property reads and writes, method + * calls, util.inspect, string conversion), installed by the EventTarget + * unit with its first value and NULL before. get answers +1 or NULL (not + * an inherited member); set and invoke answer whether they handled the + * member. */ +typedef struct ScrEventRefHooks { + ScrDyn *(*get)(const ScrDyn *d, const ScrStr *key); + bool (*set)(ScrDyn *d, const ScrStr *key, const ScrDyn *value); + bool (*invoke)(ScrDyn *d, const char *method, ScrDyn *const *args, size_t argc, + const char *what, ScrDyn **out); + ScrDyn *(*inspect_view)(const ScrDyn *d, const char **cls); + /* Object.prototype.toString's answer with the inherited @@toStringTag + * ("[object EventTarget]", "[object Event]"), or NULL. */ + const char *(*string_tag)(const ScrDyn *d); +} ScrEventRefHooks; +extern SCR_TL const ScrEventRefHooks *scr_event_ref_hooks; + ScrDyn *scr_intl_segmenter_new(void); ScrStr *scr_process_builtin_id(ScrDyn *id, ScrArr *known); ScrDyn *scr_process_builtin_module(ScrStr *id, ScrDyn *getter); diff --git a/tests/corpus/5240-event-target-subclass.ts b/tests/corpus/5240-event-target-subclass.ts new file mode 100644 index 0000000000..e9d91acbd1 --- /dev/null +++ b/tests/corpus/5240-event-target-subclass.ts @@ -0,0 +1,92 @@ +// A typed EventTarget subclass: the instance is its listeners' `this` +// and its events' target, methods dispatch through this.dispatchEvent, +// and the inherited add/remove semantics (once, capture, duplicates, +// handleEvent objects) hold on the subclass. A handleEvent listener can be +// a record, an inline literal whose arrow returns a value, or a class +// instance whose method (own or inherited) runs with the instance as +// `this`, on subclass and plain targets alike. +class Counter extends EventTarget { + hits = 0; + readonly label: string; + + constructor(label: string) { + super(); + this.label = label; + } + + bump(): boolean { + return this.dispatchEvent(new Event("bump", { cancelable: true })); + } +} + +const counter = new Counter("main"); +function onBump(this: Counter, event: Event): void { + this.hits++; + console.log( + "bump", + this.label, + this === counter, + event.target === counter, + event.currentTarget === counter, + event.eventPhase, + ); +} + +counter.addEventListener("bump", onBump); +counter.addEventListener("bump", onBump); // a duplicate is ignored +counter.addEventListener("bump", onBump, { capture: true }); // a separate entry +console.log(counter.bump(), counter.hits); +counter.removeEventListener("bump", onBump, true); +console.log(counter.bump(), counter.hits); + +counter.addEventListener("bump", (event: Event) => event.preventDefault(), { once: true }); +console.log(counter.bump(), counter.bump(), counter.hits); + +const watcher = { + seen: 0, + handleEvent(event: Event): void { + this.seen = this.seen + 1; + console.log("handleEvent", event.type, event.target === counter); + }, +}; +counter.addEventListener("reset", watcher); +counter.dispatchEvent(new Event("reset")); +counter.removeEventListener("reset", watcher); +counter.dispatchEvent(new Event("reset")); +console.log("seen", watcher.seen); + +let returned = 0; +counter.addEventListener("tally", { handleEvent: (event: Event) => (returned += event.type.length) }); +counter.dispatchEvent(new Event("tally")); +console.log("returned", returned); + +class Tracker { + calls = 0; + readonly name: string; + constructor(name: string) { + this.name = name; + } + handleEvent(event: Event): void { + this.calls++; + console.log(`${this.name} handles`, event.type, event.currentTarget instanceof Counter); + } +} +class LoudTracker extends Tracker { + override handleEvent(event: Event): void { + super.handleEvent(event); + console.log(`${this.name} is loud`, this.calls); + } +} +class QuietTracker extends Tracker {} +const trackers: Tracker[] = [new Tracker("plain"), new LoudTracker("loud"), new QuietTracker("quiet")]; +for (const tracker of trackers) counter.addEventListener("track", tracker); +counter.dispatchEvent(new Event("track")); +counter.removeEventListener("track", trackers[1]!); +counter.dispatchEvent(new Event("track")); +const plainTarget = new EventTarget(); +plainTarget.addEventListener("track", trackers[0]!); +plainTarget.dispatchEvent(new Event("track")); +console.log(trackers.map((tracker) => `${tracker.name}:${tracker.calls}`).join(" ")); + +console.log(counter instanceof Counter, counter instanceof EventTarget); +console.log(counter); diff --git a/tests/corpus/5241-event-subclass.ts b/tests/corpus/5241-event-subclass.ts new file mode 100644 index 0000000000..5e3a8862df --- /dev/null +++ b/tests/corpus/5241-event-subclass.ts @@ -0,0 +1,66 @@ +// A typed Event subclass: the constructor validates like Event's, the +// inherited accessors and methods read and change the event's own state, +// and the listener receives the instance itself, with its own fields. +import { inspect } from "node:util"; + +class Ping extends Event { + readonly sequence: number; + note = ""; + + constructor(sequence: number, cancelable: boolean) { + super("ping", { cancelable, bubbles: true }); + this.sequence = sequence; + } + + describe(): string { + return `${this.type}#${this.sequence} cancelable=${this.cancelable} prevented=${this.defaultPrevented}`; + } +} + +const target = new EventTarget(); +target.addEventListener("ping", (event: Event) => { + const ping = event as Ping; + ping.note = "seen"; + console.log("listener", ping.describe(), event.eventPhase, ping.composedPath().length); + event.preventDefault(); +}); + +const first = new Ping(1, true); +console.log(first.describe(), first.bubbles, first.composed, first.isTrusted, first.eventPhase); +console.log("dispatch", target.dispatchEvent(first), first.describe(), first.note); +console.log(first.target === target, first.currentTarget, first.composedPath().length); + +const second = new Ping(2, false); +console.log("dispatch", target.dispatchEvent(second), second.describe(), second.returnValue); + +// returnValue = false is preventDefault for a cancelable event. +const third = new Ping(3, true); +third.returnValue = false; +console.log(third.defaultPrevented, third.returnValue); + +// stopImmediatePropagation skips the remaining listeners. +const quiet = new EventTarget(); +quiet.addEventListener("ping", (event: Event) => { + console.log("first listener"); + event.stopImmediatePropagation(); +}); +quiet.addEventListener("ping", () => console.log("never")); +const stopped = new Ping(4, false); +quiet.dispatchEvent(stopped); +console.log("cancelBubble", stopped.cancelBubble); + +console.log(first instanceof Ping, first instanceof Event, first instanceof CustomEvent); +const loose: unknown = first; +console.log(inspect(first, { depth: -1 }), JSON.stringify(loose), Object.keys(first).join(",")); + +class Untyped extends Event { + constructor() { + // @ts-expect-error the type argument is required + super(); + } +} +try { + new Untyped(); +} catch (err) { + console.log((err as Error).name, (err as { code?: string }).code, (err as Error).message); +} diff --git a/tests/corpus/5242-event-target-subclass-hierarchy.ts b/tests/corpus/5242-event-target-subclass-hierarchy.ts new file mode 100644 index 0000000000..bb774f411d --- /dev/null +++ b/tests/corpus/5242-event-target-subclass-hierarchy.ts @@ -0,0 +1,54 @@ +// Hierarchies over the runtime bases: targets and events several levels +// down keep their own class through dispatch (listener `this`, the +// event's target, the received event), super.dispatchEvent reaches the +// inherited method, and Node's inspector names the concrete class. +class Ping extends Event { + readonly level: number; + + constructor(level: number) { + super("ping"); + this.level = level; + } +} + +class LoudPing extends Ping { + readonly volume = 11; +} + +class Station extends EventTarget { + readonly log: string[] = []; + + announce(level: number): void { + this.dispatchEvent(level > 5 ? new LoudPing(level) : new Ping(level)); + } +} + +class Relay extends Station { + forwarded = 0; + + override announce(level: number): void { + this.forwarded++; + super.dispatchEvent(new Ping(level + 1)); + super.announce(level); + } +} + +function record(this: Station, event: Event): void { + const kind = event instanceof LoudPing ? "loud" : event instanceof Ping ? "ping" : "other"; + const level = event instanceof Ping ? event.level : -1; + this.log.push(`${this instanceof Relay ? "relay" : "station"}:${kind}:${level}:${event.target === this}`); +} + +const relay = new Relay(); +const stations: Station[] = [new Station(), relay]; +for (const station of stations) { + station.addEventListener("ping", record); + station.announce(3); + station.announce(8); + console.log(station.log.join(" ")); +} +console.log("forwarded", relay.forwarded, relay instanceof Station, relay instanceof EventTarget); + +const loud = new LoudPing(9); +console.log(loud instanceof Ping, loud instanceof Event, loud.level, loud.volume, loud.type); +console.log(stations[0], relay); diff --git a/tests/corpus/5243-event-target-subclass-dynamic.ts b/tests/corpus/5243-event-target-subclass-dynamic.ts new file mode 100644 index 0000000000..912c3db164 --- /dev/null +++ b/tests/corpus/5243-event-target-subclass-dynamic.ts @@ -0,0 +1,62 @@ +// Subclass instances through checked-dynamic values: inherited methods +// and accessors answer on the instance itself, the subclass's own fields +// and methods stay reachable, and writes to the writable accessors land +// on the event. +class Tick extends Event { + count = 0; + constructor(count: number) { + super("tick", { cancelable: true }); + this.count = count; + } + double(): number { + return this.count * 2; + } +} + +class Clock extends EventTarget { + ticks = 0; +} + +function wire(target: any, log: string[]): void { + target.addEventListener("tick", function (this: any, event: any) { + this.ticks = this.ticks + 1; + log.push(`${event.type}:${event.count}:${event.double()}:${event.target === target}:${this === target}`); + event.returnValue = false; + }); +} + +function fire(target: any, event: any): unknown { + return target.dispatchEvent(event); +} + +const clock = new Clock(); +const log: string[] = []; +wire(clock, log); +const tick = new Tick(4); +console.log(fire(clock, tick), tick.defaultPrevented, clock.ticks, log.join(" ")); + +const loose: any = tick; +console.log(loose.type, loose.cancelable, loose.defaultPrevented, loose.eventPhase, loose.count); +loose.cancelBubble = true; +console.log(tick.cancelBubble, typeof loose.preventDefault, typeof loose.double); +const looseClock: unknown = clock; +console.log(Object.keys(loose).join(","), JSON.stringify(loose), JSON.stringify(looseClock)); +console.log(loose instanceof Tick, loose instanceof Event, looseClock instanceof EventTarget); +console.log(String(loose), `${looseClock}`); + +function listen(target: any, method: string, listener: unknown): void { + target[method]("tick", listener); +} +const other = new Clock(); +const handler = { + calls: 0, + handleEvent(event: Tick): void { + this.calls = this.calls + event.count; + }, +}; +listen(other, "addEventListener", handler); +fire(other, new Tick(5)); +fire(other, new Tick(6)); +listen(other, "removeEventListener", handler); +fire(other, new Tick(7)); +console.log("handler", handler.calls); diff --git a/tests/corpus/5244-event-target-subclass.js b/tests/corpus/5244-event-target-subclass.js new file mode 100644 index 0000000000..963c41decc --- /dev/null +++ b/tests/corpus/5244-event-target-subclass.js @@ -0,0 +1,85 @@ +// The JavaScript lane: EventTarget and Event subclasses declared without +// types dispatch through the same engine, with the instances themselves +// as `this`, target and event, and their members reachable through +// untyped values. Plain events and targets read their methods as the same +// function values, and a class instance with a handleEvent method is a +// listener. +class Job extends Event { + constructor(name, attempts) { + super("job", { cancelable: true }); + this.name = name; + this.attempts = attempts; + } + + retry() { + this.attempts += 1; + return this.attempts; + } +} + +class Queue extends EventTarget { + constructor() { + super(); + this.done = []; + } + + run(job) { + const accepted = this.dispatchEvent(job); + this.done.push(`${job.name}:${accepted}:${job.attempts}`); + return accepted; + } +} + +const queue = new Queue(); +queue.addEventListener("job", function (event) { + console.log("listener", this === queue, event.target === queue, event instanceof Job, event.type); + if (event.retry() > 2) event.preventDefault(); +}); +queue.addEventListener("job", { + handleEvent(event) { + console.log("handleEvent", event.name, event.defaultPrevented, event.eventPhase); + }, +}); + +console.log(queue.run(new Job("build", 0)), queue.run(new Job("deploy", 2))); +console.log(queue.done.join(" ")); + +const job = new Job("lint", 5); +job.initEvent("other", false, false); +console.log(job.type, job.cancelable, job.name, typeof job.stopPropagation); +const stopPropagation = job.stopPropagation; +try { + stopPropagation(); +} catch (err) { + console.log(err.name, err.code); +} +console.log(Object.keys(job).join(","), JSON.stringify(queue.done), queue instanceof EventTarget); + +// Plain events and targets answer the same method values. +const plainEvent = new Event("plain"); +const plainTarget = new EventTarget(); +console.log(typeof plainEvent.preventDefault, plainEvent.preventDefault === job.preventDefault); +console.log(plainTarget.addEventListener === queue.addEventListener, typeof plainTarget.dispatchEvent); + +// A class instance listener: its handleEvent method runs with the instance +// as `this`, and an own property replacing it is what later dispatches call. +class Handler { + constructor(name) { + this.name = name; + this.calls = 0; + } + + handleEvent(event) { + this.calls += 1; + console.log(this.name, "handles", event.type, this.calls, event.target === queue); + } +} +const handler = new Handler("worker"); +queue.addEventListener("ping", handler); +queue.dispatchEvent(new Event("ping")); +handler.handleEvent = function (event) { + console.log("replaced", event.type, this === handler); +}; +queue.dispatchEvent(new Event("ping")); +queue.removeEventListener("ping", handler); +console.log(queue.dispatchEvent(new Event("ping")), handler.calls); diff --git a/tests/corpus/5245-event-target-subclass-signals.ts b/tests/corpus/5245-event-target-subclass-signals.ts new file mode 100644 index 0000000000..2e54ab97f4 --- /dev/null +++ b/tests/corpus/5245-event-target-subclass-signals.ts @@ -0,0 +1,61 @@ +// Subclass instances where the standard types are expected: a target +// passed as `EventTarget` keeps its identity through the engine, its +// listeners leave with an AbortSignal (options.signal) or through +// events.addAbortListener, and an Event subclass dispatches on plain +// targets. +import { addAbortListener } from "node:events"; + +class Door extends EventTarget { + opened = 0; +} + +class Knock extends Event { + readonly times: number; + constructor(times: number) { + super("knock"); + this.times = times; + } +} + +function listen(target: EventTarget, signal: AbortSignal, log: string[]): void { + target.addEventListener( + "knock", + (event: Event) => { + log.push(`${(event as Knock).times}:${event.target === target}:${target instanceof Door}`); + }, + { signal }, + ); +} + +const door = new Door(); +const controller = new AbortController(); +const log: string[] = []; +listen(door, controller.signal, log); +door.dispatchEvent(new Knock(1)); +door.dispatchEvent(new Knock(2)); +controller.abort(); +door.dispatchEvent(new Knock(3)); +console.log(log.join(" ")); + +// A signal that has already aborted adds nothing. +listen(door, AbortSignal.abort(), log); +door.dispatchEvent(new Knock(4)); +console.log(log.length); + +// addAbortListener on a signal, with a subclass target in the listener. +const later = new AbortController(); +const disposable = addAbortListener(later.signal, () => { + door.opened++; + door.dispatchEvent(new Knock(5)); +}); +listen(door, new AbortController().signal, log); +later.abort(); +console.log(door.opened, log.join(" ")); +disposable[Symbol.dispose](); + +// Subclass events on a plain target. +const plain = new EventTarget(); +plain.addEventListener("knock", (event: Event) => { + console.log("plain", event instanceof Knock, (event as Knock).times, event.target === plain); +}); +plain.dispatchEvent(new Knock(6)); diff --git a/tests/corpus/5246-event-target-subclass-listener-throw.ts b/tests/corpus/5246-event-target-subclass-listener-throw.ts new file mode 100644 index 0000000000..8b5d365274 --- /dev/null +++ b/tests/corpus/5246-event-target-subclass-listener-throw.ts @@ -0,0 +1,18 @@ +// @exit: 1 +// A listener's exception on an EventTarget subclass surfaces as an +// uncaught exception from a nextTick once the dispatching code finishes, +// and the dispatch itself goes on to the next listener. +class Alarm extends EventTarget { + rang = 0; +} + +const alarm = new Alarm(); +alarm.addEventListener("ring", () => { + throw new Error("listener failed"); +}); +alarm.addEventListener("ring", function (this: Alarm) { + this.rang++; + console.log("second listener ran", this.rang); +}); +console.log("dispatch", alarm.dispatchEvent(new Event("ring"))); +console.log("after dispatch", alarm.rang); diff --git a/tests/corpus/5247-event-target-subclass-lifetimes.ts b/tests/corpus/5247-event-target-subclass-lifetimes.ts new file mode 100644 index 0000000000..ce22061b9e --- /dev/null +++ b/tests/corpus/5247-event-target-subclass-lifetimes.ts @@ -0,0 +1,75 @@ +// Construction and lifetime shapes: an Event subclass without its own +// constructor takes Event's arguments, a generic EventTarget subclass +// instantiates per element type, and targets and events that hold +// closures and references back to each other are released. +class Note extends Event { + text = ""; +} + +class Store extends EventTarget { + readonly items: T[] = []; + + add(item: T): void { + this.items.push(item); + this.dispatchEvent(new Note("added", { cancelable: true })); + } +} + +const numbers = new Store(); +const words = new Store(); +numbers.addEventListener("added", (event: Event) => { + console.log("numbers", numbers.items.join(","), event instanceof Note, event.cancelable); +}); +words.addEventListener("added", (event: Event) => console.log("words", words.items.join(","))); +numbers.add(1); +numbers.add(2); +words.add("a"); + +const bare = new Note("bare"); +console.log(bare.type, bare.cancelable, bare.text === ""); +try { + // @ts-expect-error options must be an object + new Note("bad", 42); +} catch (err) { + console.log((err as Error).name, (err as { code?: string }).code); +} + +// Cycles: the target's listener captures the target, the event keeps the +// target as its target, and the target keeps the last event in a field. +class Session extends EventTarget { + last: Note | null = null; + readonly onNote = (event: Event): void => { + this.last = event as Note; + this.count++; + }; + count = 0; +} + +for (let round = 0; round < 3; round++) { + const session = new Session(); + session.addEventListener("note", session.onNote); + session.addEventListener("note", () => session.count++); + const note = new Note("note"); + note.text = `round ${round}`; + session.dispatchEvent(note); + console.log(session.count, session.last?.text, session.last?.target === session); +} + +// Many short-lived targets whose listeners capture them: the collector +// reclaims each target, its listeners and its last event while the loop +// runs. +let total = 0; +for (let round = 0; round < 20000; round++) { + const session = new Session(); + session.addEventListener("note", session.onNote); + session.addEventListener("note", () => { + total += session.count; + }); + session.addEventListener("note", { + handleEvent: (event: Event): void => { + total += event.type.length; + }, + }); + session.dispatchEvent(new Note("note")); +} +console.log("total", total); diff --git a/tests/corpus/5248-event-target-subclass-warnings.ts b/tests/corpus/5248-event-target-subclass-warnings.ts new file mode 100644 index 0000000000..f38d67aa32 --- /dev/null +++ b/tests/corpus/5248-event-target-subclass-warnings.ts @@ -0,0 +1,19 @@ +// @exit: 1 +// The process warnings name the subclass: the leak warning past ten +// listeners of one type prints the concrete class (Node's inspector at +// depth -1), once per target. The warnings arrive through +// process.emitWarning on a later tick; the stderr report carries the pid, +// so the @exit directive keeps it out of the comparison. +class Bell extends EventTarget {} +class ChurchBell extends Bell {} + +process.on("warning", (warning) => console.log("warning:", warning.name, "|", warning.message)); +const bell = new Bell(); +const church = new ChurchBell(); +for (let i = 0; i < 11; i++) bell.addEventListener("ring", () => {}); +for (let i = 0; i < 12; i++) church.addEventListener("toll", () => {}); +for (let i = 0; i < 11; i++) church.addEventListener("ring", () => {}); +console.log("sync end"); +setTimeout(() => { + process.exitCode = 1; +}, 1); diff --git a/tests/corpus/5249-event-target-subclass-unconstructed.ts b/tests/corpus/5249-event-target-subclass-unconstructed.ts new file mode 100644 index 0000000000..41b29a3789 --- /dev/null +++ b/tests/corpus/5249-event-target-subclass-unconstructed.ts @@ -0,0 +1,19 @@ +// Subclasses that are declared and tested but never constructed still +// compile and link: instanceof against them answers false for other +// values, plain events and targets included. +class Unused extends Event { + readonly extra = 1; +} + +class Idle extends EventTarget { + readonly name = "idle"; +} + +function classify(value: unknown): string { + if (value instanceof Unused) return "unused event"; + if (value instanceof Idle) return "idle target"; + return typeof value; +} + +console.log(classify(1), classify("x"), classify({ type: "x" }), classify(null)); +console.log(classify(new Event("x")), classify(new EventTarget())); diff --git a/tests/diagnostics/event-target-subclass-fences.ts b/tests/diagnostics/event-target-subclass-fences.ts new file mode 100644 index 0000000000..e00ff2729f --- /dev/null +++ b/tests/diagnostics/event-target-subclass-fences.ts @@ -0,0 +1,19 @@ +// EventTarget and Event subclasses inherit the runtime's members. The +// engine never calls or reads a subclass member with one of those names, +// so declaring one is refused. +class Bus extends EventTarget { + dispatchEvent(event: Event): boolean { + console.log("dispatching", event.type); + return true; + } +} + +class Ping extends Event { + readonly type = "ping"; + constructor() { + super("ping"); + } +} + +console.log(new Ping().type); +console.log(new Bus().dispatchEvent(new Event("x"))); diff --git a/tests/harness/__snapshots__/event-target-subclass-fences.ts.txt b/tests/harness/__snapshots__/event-target-subclass-fences.ts.txt new file mode 100644 index 0000000000..b4912e1865 --- /dev/null +++ b/tests/harness/__snapshots__/event-target-subclass-fences.ts.txt @@ -0,0 +1,27 @@ +event-target-subclass-fences.ts:5:3 - error SC1090: overriding the EventTarget member 'dispatchEvent' (the runtime owns the inherited surface) is not supported yet + + 4 | class Bus extends EventTarget { + 5 | dispatchEvent(event: Event): boolean { + | ^~~~~~~~~~~~~ + 6 | console.log("dispatching", event.type); + +event-target-subclass-fences.ts:12:12 - error SC1090: overriding the Event member 'type' (the runtime owns the inherited surface) is not supported yet + + 11 | class Ping extends Event { + 12 | readonly type = "ping"; + | ^~~~ + 13 | constructor() { + +event-target-subclass-fences.ts:18:13 - error SC1090: constructing through a class value whose class has no lowering (the class declaration itself was rejected — see its own diagnostic) is not supported yet + + 17 | + 18 | console.log(new Ping().type); + | ^~~~~~~~~~ + 19 | console.log(new Bus().dispatchEvent(new Event("x"))); + +event-target-subclass-fences.ts:19:13 - error SC1090: constructing through a class value whose class has no lowering (the class declaration itself was rejected — see its own diagnostic) is not supported yet + + 18 | console.log(new Ping().type); + 19 | console.log(new Bus().dispatchEvent(new Event("x"))); + | ^~~~~~~~~ + 20 | \ No newline at end of file diff --git a/tests/harness/self-hosting-emission-cases.ts b/tests/harness/self-hosting-emission-cases.ts index 5e13f08d9b..126fb5cf3d 100644 --- a/tests/harness/self-hosting-emission-cases.ts +++ b/tests/harness/self-hosting-emission-cases.ts @@ -319,6 +319,20 @@ export function emissionCases(): EmissionCase[] { "@native_string_0", ]); + const eventTarget = emissionModule(); + eventTarget.classes = [ + { name: "%EventTarget", runtime: true, fields: [], loc }, + { name: "Bus", base: "%EventTarget", fields: [], loc }, + { name: "%Event", runtime: true, fields: [], loc }, + { name: "Ping", base: "%Event", fields: [], loc }, + ]; + add("event target and event prefixes", eventTarget, [ + "ScrEventTargetObj prefix at 2", + "@scr_event_target_state_drop", + "ScrEventObj prefix at 2", + "@scr_event_state_drop", + ]); + const stream = emissionModule(); stream.classes = [ { name: "%EventEmitter", runtime: true, fields: [], loc }, diff --git a/tests/harness/wasi-differential.test.ts b/tests/harness/wasi-differential.test.ts index 5b7c1669f2..e532bf154e 100644 --- a/tests/harness/wasi-differential.test.ts +++ b/tests/harness/wasi-differential.test.ts @@ -139,6 +139,16 @@ describe.skipIf(!zigOnPath())("wasm32-wasi differential", () => { "js-promise-all-values.js", "js-promise-catch-handler.js", "js-abort-portable.js", + "5240-event-target-subclass.ts", + "5241-event-subclass.ts", + "5242-event-target-subclass-hierarchy.ts", + "5243-event-target-subclass-dynamic.ts", + "5244-event-target-subclass.js", + "5245-event-target-subclass-signals.ts", + "5246-event-target-subclass-listener-throw.ts", + "5247-event-target-subclass-lifetimes.ts", + "5248-event-target-subclass-warnings.ts", + "5249-event-target-subclass-unconstructed.ts", "5130-event-target-dispatch.js", "5131-event-target-listener-errors.js", "5132-event-target-typed.ts", From 9835ad0d758146462ef8c8ec402120abb5754c69 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 14 Oct 2026 17:27:02 -0500 Subject: [PATCH 3/7] Move scriptc to Node 24.22.0 Pin Node v24.22.0 (commit f14cd3aa7bf9, Undici 7.29.1, OpenSSL 3.5.8) in .node-version, Dockerfile.sandbox, the docs matrix fallback, the compatibility pin, the fetch profile, and process.version. A node-pin test checks that these pins agree. The Node compatibility snapshot is regenerated from the v24.22.0 API docs; the new stream_iter chapter maps to node:stream/iter, and the SuiteContext rows no longer match the TestContext evidence. Runtime and compiler changes follow Node 24.22 behavior: - fs.read, fs.readSync, and FileHandle.read validate the position before the zero-length return. - fs.statfs results include frsize; Windows reads FileFsFullSizeInformation and reports bfree and bavail separately. - fs.utimes, futimes, and lutimes keep nanosecond precision. - ServerResponse sets writableFinished where 'finish' is emitted and runs end() callbacks before the 'finish' listeners while the socket is still attached; a request read to 'end' closes before its response. - socket.write(string, 'buffer') throws ERR_UNKNOWN_ENCODING. - URL protocol-setter rejections keep the current URL, the host setter no longer leaves a "/." escape when it adds a port to a "//" path, and new URLSearchParams(null) parses "null". - util.stripVTControlCharacters uses Node 24.22's ANSI pattern, util.styleText accepts #RGB and #RRGGBB colors, and util.types.isDataView has its JS name and length. - structuredClone and AbortSignal.any use the "cannot be converted to sequence" message. - crypto.getCiphers, getHashes, and constants match Node 24.22. - dns.lookup, net.connect, and tls.connect throw ERR_INVALID_ARG_VALUE for hosts with null bytes. - fs.readFile validates options.buffer and refuses its valid forms; httpValidation and certificateCompression refuse by name. - url.domainToASCII, url.domainToUnicode, and url.parse hostnames follow ada 4.0: ASCII domains are lowercased without checking their xn-- labels, the RFC 5893 rule checks how LTR labels end and how RTL labels start, a Punycode label whose decoded form begins with "xn--" fails, and ToUnicode decodes only labels that pass the ToASCII checks. The url legacy test cases are regenerated with Node 24.22. Corpus programs 5275-5279 cover the new behavior. 1640, 2283, 2599, and 3136 are updated where they pinned Node 24.15 output. --- .node-version | 2 +- Dockerfile.sandbox | 2 +- docs/content/docs/limitations.mdx | 2 +- .../components/node-compatibility-matrix.tsx | 2 +- .../node-v24-compatibility-meta.json | 8 +- .../src/generated/node-v24-compatibility.json | 5442 ++++++- .../generated/node-v24-backlog.json | 12177 +++++++++++----- .../generated/node-v24-internal.json | 7803 +++++++++- internal/compatibility/node-v24.json | 15 +- internal/compatibility/src/generate.mjs | 4 +- internal/compatibility/static-support.json | 5 +- .../compiler/src/backend/llvm/lib-network.ts | 16 +- packages/compiler/src/compat/fetch-profile.ts | 4 +- .../src/frontend/lowering/builtins/process.ts | 4 +- .../src/frontend/lowering/crypto-tables.ts | 89 +- .../src/frontend/lowering/http2-constants.ts | 2 +- .../src/frontend/lowering/lower-server.ts | 26 +- .../src/frontend/lowering/surfaces.ts | 4 + packages/compiler/src/ir/builtin-effects.ts | 5 + .../compiler/src/ir/builtin-signatures.ts | 9 +- packages/compiler/surface-manifest.json | 228 +- packages/compiler/test/node-pin.test.ts | 31 + .../5275-http-end-callback-order.ts.json | 6 + .../5276-style-text-hex-colors.cjs.json | 6 + .../5277-fs-read-file-buffer-option.cjs.json | 6 + .../corpus/5278-host-null-bytes.cjs.json | 6 + .../5279-search-params-null-init.cjs.json | 6 + packages/runtime/src/scr_bytes_io.c | 44 +- packages/runtime/src/scr_dgram.c | 15 + packages/runtime/src/scr_fetch.c | 2 +- packages/runtime/src/scr_http.c | 62 +- packages/runtime/src/scr_idna.c | 91 +- packages/runtime/src/scr_json.c | 74 +- packages/runtime/src/scr_lib.c | 133 +- packages/runtime/src/scr_net.c | 33 + packages/runtime/src/scr_regex.c | 11 +- packages/runtime/src/scr_runtime.h | 4 + packages/runtime/src/scr_system_errors.h | 2 +- packages/runtime/src/scr_text_decoder_data.h | 2 +- packages/runtime/src/scr_tls.c | 7 +- packages/runtime/src/scr_url.c | 27 +- packages/runtime/src/scr_url_internal.h | 3 - packages/runtime/src/scr_util_style.c | 80 +- packages/runtime/test/url-legacy-cases.txt | 222 +- tests/corpus/1640-fd-read-decode.ts | 14 +- tests/corpus/2283-structured-clone.cjs | 2 +- tests/corpus/2599-stream-arg-ladders.cjs | 9 +- tests/corpus/3136-fs-file-handle-options.ts | 7 +- tests/corpus/5275-http-end-callback-order.ts | 72 + tests/corpus/5276-style-text-hex-colors.cjs | 28 + .../5277-fs-read-file-buffer-option.cjs | 28 + tests/corpus/5278-host-null-bytes.cjs | 28 + tests/corpus/5279-search-params-null-init.cjs | 16 + 53 files changed, 22229 insertions(+), 4697 deletions(-) create mode 100644 packages/compiler/test/node-pin.test.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5275-http-end-callback-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5276-style-text-hex-colors.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5277-fs-read-file-buffer-option.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5278-host-null-bytes.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5279-search-params-null-init.cjs.json create mode 100644 tests/corpus/5275-http-end-callback-order.ts create mode 100644 tests/corpus/5276-style-text-hex-colors.cjs create mode 100644 tests/corpus/5277-fs-read-file-buffer-option.cjs create mode 100644 tests/corpus/5278-host-null-bytes.cjs create mode 100644 tests/corpus/5279-search-params-null-init.cjs diff --git a/.node-version b/.node-version index 5bf4400f22..a43a5b943d 100644 --- a/.node-version +++ b/.node-version @@ -1 +1 @@ -24.15.0 +24.22.0 diff --git a/Dockerfile.sandbox b/Dockerfile.sandbox index 597b334451..61f5d8ad90 100644 --- a/Dockerfile.sandbox +++ b/Dockerfile.sandbox @@ -1,4 +1,4 @@ -ARG NODE_VERSION=24.15.0 +ARG NODE_VERSION=24.22.0 FROM ubuntu:24.04 ARG NODE_VERSION diff --git a/docs/content/docs/limitations.mdx b/docs/content/docs/limitations.mdx index eb8d9c570f..7ce6342ba6 100644 --- a/docs/content/docs/limitations.mdx +++ b/docs/content/docs/limitations.mdx @@ -86,7 +86,7 @@ Some builtins can be stored and passed as functions: Other immutable aliases of table-backed Node builtins support direct calls, but cannot be passed elsewhere. `util.promisify` supports compile-time conversions of `child_process.execFile` and UTF-8 `fs.readFile`. -`util.styleText` supports standard formats and aliases, arrays of formats, nested ANSI resets, and explicit color enabling with `{ validateStream: false }`. Native calls accept standard process streams; custom native streams and mutations to `util.inspect.colors` remain unsupported. +`util.styleText` supports standard formats and aliases, `#RGB` and `#RRGGBB` hex colors, arrays of formats, nested ANSI resets, and explicit color enabling with `{ validateStream: false }`. Native calls accept standard process streams; custom native streams and mutations to `util.inspect.colors` remain unsupported. `util.inherits` links the prototypes of constructor functions, and `util.deprecate`, `util.callbackify`, and `util.debuglog` return native function values that forward receivers and arguments. Class constructors passed to `util.inherits` or `util.deprecate` are refused. Deprecation warnings are emitted on the next tick and follow assignments to `process.noDeprecation` and `process.throwDeprecation`; compiled binaries take no Node command-line flags such as `--no-deprecation` or `--trace-deprecation`, and `process.traceDeprecation` is unsupported. A stored `util.deprecate` reports a `length` of 4, where Node reports 3. In TypeScript, a `util.callbackify` result must reach a callback whose error parameter accepts `null`; the @types/node overloads that type it as non-null are refused. `util.debuglog` reads `NODE_DEBUG` as the process started. Its `%s` refuses functions and objects with symbol-keyed members, `%o` refuses objects, and object arguments are refused on a color terminal. diff --git a/docs/src/components/node-compatibility-matrix.tsx b/docs/src/components/node-compatibility-matrix.tsx index 06bfed09f6..f0a817a2f5 100644 --- a/docs/src/components/node-compatibility-matrix.tsx +++ b/docs/src/components/node-compatibility-matrix.tsx @@ -204,7 +204,7 @@ export function NodeCompatibilityMatrix() { const verificationBases = snapshot?.verificationBases; const apiRowCount = useMemo(() => rows.filter((row) => row.scope === "api").length, [rows]); const chapterTitles = useMemo(() => new Map(chapters.map((item) => [item.slug, item.title])), [chapters]); - const base = `https://nodejs.org/docs/v${snapshot?.nodeVersion ?? "24.15.0"}/api/`; + const base = `https://nodejs.org/docs/v${snapshot?.nodeVersion ?? "24.22.0"}/api/`; const staticCounts = useMemo(() => statusCounts(rows, "static"), [rows]); const visibleStatuses = useMemo(() => statuses.filter((status) => staticCounts[status] > 0), [staticCounts]); const tree = useMemo(() => buildTree(rows), [rows]); diff --git a/docs/src/generated/node-v24-compatibility-meta.json b/docs/src/generated/node-v24-compatibility-meta.json index b0c9b4109e..8f5b36279b 100644 --- a/docs/src/generated/node-v24-compatibility-meta.json +++ b/docs/src/generated/node-v24-compatibility-meta.json @@ -1,7 +1,7 @@ { "schemaVersion": 3, - "nodeVersion": "24.15.0", - "nodeCommit": "848430679556aed0bd073f2bc263331ad84fa119", - "artifactVersion": "5bc8e72822dd7065df84", - "rowCount": 3662 + "nodeVersion": "24.22.0", + "nodeCommit": "f14cd3aa7bf9ca8df2cc5b8bb14beb0f335b1d93", + "artifactVersion": "7e9684fe4f97a27c6a16", + "rowCount": 3880 } diff --git a/docs/src/generated/node-v24-compatibility.json b/docs/src/generated/node-v24-compatibility.json index 67efad31fc..a6abba8e6d 100644 --- a/docs/src/generated/node-v24-compatibility.json +++ b/docs/src/generated/node-v24-compatibility.json @@ -1,18 +1,18 @@ { "schemaVersion": 4, - "nodeVersion": "24.15.0", - "nodeTag": "v24.15.0", - "nodeCommit": "848430679556aed0bd073f2bc263331ad84fa119", + "nodeVersion": "24.22.0", + "nodeTag": "v24.22.0", + "nodeCommit": "f14cd3aa7bf9ca8df2cc5b8bb14beb0f335b1d93", "sources": { "allJson": { - "url": "https://nodejs.org/download/release/v24.15.0/docs/api/all.json", - "sha256": "ad66cf85ee273e20ede86b6864cc6ecd1ae6d9ea44f2011e75f4427223f7d16c" + "url": "https://nodejs.org/download/release/v24.22.0/docs/api/all.json", + "sha256": "2445f57511c86b2b8129b3fd8423811fd8b32d1eccc1e54d8c747e823f65be27" }, "indexMarkdown": { - "url": "https://nodejs.org/docs/v24.15.0/api/index.md", - "sha256": "616b1d2c1cd02854963db4598c5ce9dcd633464e1534830be3f55ab714e255c4" + "url": "https://nodejs.org/docs/v24.22.0/api/index.md", + "sha256": "c63ecaedc4a35de0823706cc72ce76cd10e712ce50eaca829bb2eefe1fc2ded2" }, - "sourceBaseUrl": "https://github.com/nodejs/node/tree/848430679556aed0bd073f2bc263331ad84fa119" + "sourceBaseUrl": "https://github.com/nodejs/node/tree/f14cd3aa7bf9ca8df2cc5b8bb14beb0f335b1d93" }, "verificationBases": { "test-backed": { @@ -53,14 +53,14 @@ } }, "inventory": { - "sourceChapters": 62, - "sourceRows": 4690, - "matrixChapters": 55, - "matrixRows": 3662, + "sourceChapters": 63, + "sourceRows": 4996, + "matrixChapters": 56, + "matrixRows": 3880, "excluded": { - "documentation": 564, - "metadata": 207, - "configuration": 242, + "documentation": 640, + "metadata": 210, + "configuration": 251, "non-api": 0, "not-applicable": 8, "chapters": 7 @@ -85,13 +85,13 @@ { "slug": "async_context", "title": "Asynchronous context tracking", - "entries": 17, - "apiEntries": 17, + "entries": 20, + "apiEntries": 20, "static": { "supported": 0, "partial": 7, "refused": 0, - "not-implemented": 10, + "not-implemented": 13, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -115,13 +115,13 @@ { "slug": "buffer", "title": "Buffer", - "entries": 98, - "apiEntries": 98, + "entries": 99, + "apiEntries": 99, "static": { "supported": 8, "partial": 4, "refused": 0, - "not-implemented": 86, + "not-implemented": 87, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -145,14 +145,14 @@ { "slug": "n-api", "title": "C/C++ addons with Node-API", - "entries": 191, - "apiEntries": 191, + "entries": 192, + "apiEntries": 192, "static": { "supported": 0, "partial": 0, "refused": 0, "not-implemented": 0, - "by-design": 191, + "by-design": 192, "unreviewed": 0, "not-applicable": 0 } @@ -205,13 +205,13 @@ { "slug": "crypto", "title": "Crypto", - "entries": 145, - "apiEntries": 145, + "entries": 152, + "apiEntries": 152, "static": { "supported": 0, "partial": 22, "refused": 26, - "not-implemented": 97, + "not-implemented": 104, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -220,13 +220,13 @@ { "slug": "diagnostics_channel", "title": "Diagnostics Channel", - "entries": 69, - "apiEntries": 69, + "entries": 71, + "apiEntries": 71, "static": { "supported": 0, "partial": 8, "refused": 0, - "not-implemented": 61, + "not-implemented": 63, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -280,13 +280,13 @@ { "slug": "errors", "title": "Errors", - "entries": 461, - "apiEntries": 461, + "entries": 478, + "apiEntries": 478, "static": { "supported": 0, "partial": 8, "refused": 0, - "not-implemented": 453, + "not-implemented": 470, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -310,13 +310,13 @@ { "slug": "fs", "title": "File system", - "entries": 276, - "apiEntries": 276, + "entries": 280, + "apiEntries": 280, "static": { "supported": 7, "partial": 98, "refused": 0, - "not-implemented": 171, + "not-implemented": 175, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -340,13 +340,13 @@ { "slug": "http", "title": "HTTP", - "entries": 174, - "apiEntries": 174, + "entries": 176, + "apiEntries": 176, "static": { "supported": 0, "partial": 131, "refused": 0, - "not-implemented": 43, + "not-implemented": 45, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -355,13 +355,13 @@ { "slug": "http2", "title": "HTTP/2", - "entries": 167, - "apiEntries": 167, + "entries": 168, + "apiEntries": 168, "static": { "supported": 0, "partial": 14, "refused": 2, - "not-implemented": 151, + "not-implemented": 152, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -385,13 +385,28 @@ { "slug": "inspector", "title": "Inspector", - "entries": 30, - "apiEntries": 30, + "entries": 35, + "apiEntries": 35, "static": { "supported": 0, "partial": 0, "refused": 0, - "not-implemented": 30, + "not-implemented": 35, + "by-design": 0, + "unreviewed": 0, + "not-applicable": 0 + } + }, + { + "slug": "stream_iter", + "title": "Iterable Streams API", + "entries": 65, + "apiEntries": 65, + "static": { + "supported": 0, + "partial": 0, + "refused": 0, + "not-implemented": 65, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -475,13 +490,13 @@ { "slug": "net", "title": "Net", - "entries": 100, - "apiEntries": 100, + "entries": 119, + "apiEntries": 119, "static": { "supported": 0, "partial": 34, "refused": 0, - "not-implemented": 66, + "not-implemented": 85, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -520,13 +535,13 @@ { "slug": "perf_hooks", "title": "Performance hooks", - "entries": 96, - "apiEntries": 96, + "entries": 131, + "apiEntries": 131, "static": { "supported": 0, "partial": 19, "refused": 0, - "not-implemented": 77, + "not-implemented": 112, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -535,13 +550,13 @@ { "slug": "permissions", "title": "Permissions", - "entries": 3, - "apiEntries": 3, + "entries": 4, + "apiEntries": 4, "static": { "supported": 0, "partial": 0, "refused": 0, - "not-implemented": 3, + "not-implemented": 4, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -550,13 +565,13 @@ { "slug": "process", "title": "Process", - "entries": 119, - "apiEntries": 119, + "entries": 120, + "apiEntries": 120, "static": { "supported": 0, "partial": 50, "refused": 0, - "not-implemented": 69, + "not-implemented": 70, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -625,13 +640,13 @@ { "slug": "sqlite", "title": "SQLite", - "entries": 48, - "apiEntries": 48, + "entries": 52, + "apiEntries": 52, "static": { "supported": 0, "partial": 0, "refused": 0, - "not-implemented": 48, + "not-implemented": 52, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -640,13 +655,13 @@ { "slug": "stream", "title": "Stream", - "entries": 137, - "apiEntries": 137, + "entries": 140, + "apiEntries": 140, "static": { "supported": 0, "partial": 38, "refused": 0, - "not-implemented": 99, + "not-implemented": 102, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -670,13 +685,13 @@ { "slug": "test", "title": "Test runner", - "entries": 105, - "apiEntries": 105, + "entries": 117, + "apiEntries": 117, "static": { "supported": 0, - "partial": 21, + "partial": 20, "refused": 0, - "not-implemented": 84, + "not-implemented": 97, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -700,13 +715,13 @@ { "slug": "tls", "title": "TLS/SSL", - "entries": 64, - "apiEntries": 64, + "entries": 67, + "apiEntries": 67, "static": { "supported": 0, "partial": 7, "refused": 4, - "not-implemented": 53, + "not-implemented": 56, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -730,13 +745,13 @@ { "slug": "tty", "title": "TTY", - "entries": 18, - "apiEntries": 18, + "entries": 19, + "apiEntries": 19, "static": { "supported": 0, "partial": 7, "refused": 0, - "not-implemented": 11, + "not-implemented": 12, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -745,13 +760,13 @@ { "slug": "dgram", "title": "UDP/datagram", - "entries": 36, - "apiEntries": 36, + "entries": 38, + "apiEntries": 38, "static": { "supported": 0, "partial": 12, "refused": 0, - "not-implemented": 24, + "not-implemented": 26, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -775,13 +790,13 @@ { "slug": "util", "title": "Utilities", - "entries": 105, - "apiEntries": 105, + "entries": 109, + "apiEntries": 109, "static": { "supported": 0, "partial": 53, "refused": 0, - "not-implemented": 52, + "not-implemented": 56, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -835,13 +850,13 @@ { "slug": "webcrypto", "title": "Web Crypto API", - "entries": 148, - "apiEntries": 148, + "entries": 156, + "apiEntries": 156, "static": { "supported": 0, "partial": 11, "refused": 0, - "not-implemented": 137, + "not-implemented": 145, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -850,13 +865,13 @@ { "slug": "webstreams", "title": "Web Streams API", - "entries": 88, - "apiEntries": 88, + "entries": 89, + "apiEntries": 89, "static": { "supported": 0, "partial": 7, "refused": 1, - "not-implemented": 80, + "not-implemented": 81, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -880,13 +895,13 @@ { "slug": "zlib", "title": "Zlib", - "entries": 78, - "apiEntries": 78, + "entries": 94, + "apiEntries": 94, "static": { "supported": 0, "partial": 30, "refused": 4, - "not-implemented": 44, + "not-implemented": 60, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -1745,6 +1760,29 @@ "verification": "test-backed" } }, + { + "id": "async_context:1da031ae1416", + "chapter": "async_context", + "kind": "method", + "name": "withScope", + "signature": "`asyncLocalStorage.withScope(store)`", + "label": "asyncLocalStorage.withScope(store)", + "apiSymbol": "asyncLocalStorage.withScope", + "depth": 2, + "scope": "api", + "anchor": "asynclocalstoragewithscopestore", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "async_context:c3f9e759e7a3", "chapter": "async_context", @@ -1768,6 +1806,52 @@ "verification": "registry-gap" } }, + { + "id": "async_context:f017c310f23c", + "chapter": "async_context", + "kind": "class", + "name": "RunScope", + "signature": "Class: `RunScope`", + "label": "RunScope", + "apiSymbol": "RunScope", + "depth": 1, + "scope": "api", + "anchor": "class-runscope", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "async_context:61f0464afb64", + "chapter": "async_context", + "kind": "method", + "name": "dispose", + "signature": "`scope.dispose()`", + "label": "scope.dispose()", + "apiSymbol": "scope.dispose", + "depth": 2, + "scope": "api", + "anchor": "scopedispose", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "async_context:509d8ed918da", "chapter": "async_context", @@ -2964,6 +3048,29 @@ "verification": "registry-gap" } }, + { + "id": "buffer:00e095984e8b", + "chapter": "buffer", + "kind": "method", + "name": "textStream", + "signature": "`blob.textStream()`", + "label": "blob.textStream()", + "apiSymbol": "blob.textStream", + "depth": 2, + "scope": "api", + "anchor": "blobtextstream", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "buffer:fe2720024378", "chapter": "buffer", @@ -3149,16 +3256,16 @@ } }, { - "id": "buffer:036238ad6edd", + "id": "buffer:32a0b4015b4d", "chapter": "buffer", "kind": "method", "name": "includes", - "signature": "`buf.includes(value[, byteOffset][, encoding])`", - "label": "buf.includes(value[, byteOffset][, encoding])", + "signature": "`buf.includes(value[, start[, end]][, encoding])`", + "label": "buf.includes(value[, start[, end]][, encoding])", "apiSymbol": "buf.includes", "depth": 2, "scope": "api", - "anchor": "bufincludesvalue-byteoffset-encoding", + "anchor": "bufincludesvalue-start-end-encoding", "nodeStability": { "index": "2", "level": 2, @@ -3172,16 +3279,16 @@ } }, { - "id": "buffer:4bb2e1c043ab", + "id": "buffer:1b0e4fe87f7d", "chapter": "buffer", "kind": "method", "name": "indexOf", - "signature": "`buf.indexOf(value[, byteOffset][, encoding])`", - "label": "buf.indexOf(value[, byteOffset][, encoding])", + "signature": "`buf.indexOf(value[, start[, end]][, encoding])`", + "label": "buf.indexOf(value[, start[, end]][, encoding])", "apiSymbol": "buf.indexOf", "depth": 2, "scope": "api", - "anchor": "bufindexofvalue-byteoffset-encoding", + "anchor": "bufindexofvalue-start-end-encoding", "nodeStability": { "index": "2", "level": 2, @@ -3218,16 +3325,16 @@ } }, { - "id": "buffer:0f29211b95db", + "id": "buffer:34a6c0cba92a", "chapter": "buffer", "kind": "method", "name": "lastIndexOf", - "signature": "`buf.lastIndexOf(value[, byteOffset][, encoding])`", - "label": "buf.lastIndexOf(value[, byteOffset][, encoding])", + "signature": "`buf.lastIndexOf(value[, start[, end]][, encoding])`", + "label": "buf.lastIndexOf(value[, start[, end]][, encoding])", "apiSymbol": "buf.lastIndexOf", "depth": 2, "scope": "api", - "anchor": "buflastindexofvalue-byteoffset-encoding", + "anchor": "buflastindexofvalue-start-end-encoding", "nodeStability": { "index": "2", "level": 2, @@ -4460,11 +4567,11 @@ } }, { - "id": "buffer:a12afe3296c9", + "id": "buffer:06a34306775b", "chapter": "buffer", "kind": "integer", "name": "Type", - "signature": "`poolSize` Type: {integer} **Default:** `8192`", + "signature": "`poolSize` Type: {integer} **Default:** `65536`", "label": "poolSize", "apiSymbol": "poolSize", "depth": 2, @@ -6289,6 +6396,29 @@ "verification": "architectural-policy" } }, + { + "id": "n-api:63a7b5cc3191", + "chapter": "n-api", + "kind": "module", + "name": "`node_api_create_external_sharedarraybuffer`", + "signature": "`node_api_create_external_sharedarraybuffer`", + "label": "node_api_create_external_sharedarraybuffer", + "apiSymbol": "node_api_create_external_sharedarraybuffer", + "depth": 1, + "scope": "api", + "anchor": "node_api_create_external_sharedarraybuffer", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "by-design", + "detail": "Intentionally outside the static native execution model.", + "verification": "architectural-policy" + } + }, { "id": "n-api:5d9ef3c614d9", "chapter": "n-api", @@ -11407,10 +11537,10 @@ "scope": "api", "anchor": "cryptoargon2algorithm-parameters-callback", "nodeStability": { - "index": "1.2", - "level": 1, - "text": "Release candidate", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-implemented", @@ -11430,10 +11560,10 @@ "scope": "api", "anchor": "cryptoargon2syncalgorithm-parameters", "nodeStability": { - "index": "1.2", - "level": 1, - "text": "Release candidate", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-implemented", @@ -11671,6 +11801,29 @@ "verification": "test-backed" } }, + { + "id": "crypto:8139c367e45c", + "chapter": "crypto", + "kind": "method", + "name": "createMac", + "signature": "`crypto.createMac(algorithm, key[, options])`", + "label": "crypto.createMac(algorithm, key[, options])", + "apiSymbol": "crypto.createMac", + "depth": 2, + "scope": "api", + "anchor": "cryptocreatemacalgorithm-key-options", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "crypto:a91640a96ead", "chapter": "crypto", @@ -11798,10 +11951,10 @@ "scope": "api", "anchor": "cryptodecapsulatekey-ciphertext-callback", "nodeStability": { - "index": "1.2", - "level": 1, - "text": "Release candidate", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-implemented", @@ -11844,10 +11997,10 @@ "scope": "api", "anchor": "cryptoencapsulatekey-callback", "nodeStability": { - "index": "1.2", - "level": 1, - "text": "Release candidate", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-implemented", @@ -12131,6 +12284,29 @@ "verification": "registry-gap" } }, + { + "id": "crypto:8950ad3041b7", + "chapter": "crypto", + "kind": "method", + "name": "getMacs", + "signature": "`crypto.getMacs()`", + "label": "crypto.getMacs()", + "apiSymbol": "crypto.getMacs", + "depth": 2, + "scope": "api", + "anchor": "cryptogetmacs", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "crypto:2ab8394e29a7", "chapter": "crypto", @@ -12223,6 +12399,29 @@ "verification": "test-backed" } }, + { + "id": "crypto:d0b4d9541950", + "chapter": "crypto", + "kind": "method", + "name": "parsePKCS12", + "signature": "`crypto.parsePKCS12(bundle[, options])`", + "label": "crypto.parsePKCS12(bundle[, options])", + "apiSymbol": "crypto.parsePKCS12", + "depth": 2, + "scope": "api", + "anchor": "cryptoparsepkcs12bundle-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "crypto:cb974006b4f5", "chapter": "crypto", @@ -12476,6 +12675,29 @@ "verification": "test-backed" } }, + { + "id": "crypto:5fe8e4024b07", + "chapter": "crypto", + "kind": "method", + "name": "randomUUIDv7", + "signature": "`crypto.randomUUIDv7([options])`", + "label": "crypto.randomUUIDv7([options])", + "apiSymbol": "crypto.randomUUIDv7", + "depth": 2, + "scope": "api", + "anchor": "cryptorandomuuidv7options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "crypto:10402b3c70ca", "chapter": "crypto", @@ -12557,10 +12779,10 @@ "scope": "api", "anchor": "cryptosetengineengine-flags", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "0", + "level": 0, + "text": "Deprecated", + "inherited": false }, "static": { "status": "not-implemented", @@ -13879,6 +14101,75 @@ "verification": "registry-gap" } }, + { + "id": "crypto:f5e3bda9577f", + "chapter": "crypto", + "kind": "class", + "name": "Mac", + "signature": "Class: `Mac`", + "label": "Mac", + "apiSymbol": "Mac", + "depth": 1, + "scope": "api", + "anchor": "class-mac", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "crypto:0165406d6a25", + "chapter": "crypto", + "kind": "method", + "name": "final", + "signature": "`mac.final([outputEncoding])`", + "label": "mac.final([outputEncoding])", + "apiSymbol": "mac.final", + "depth": 2, + "scope": "api", + "anchor": "macfinaloutputencoding", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "crypto:6a72becb6839", + "chapter": "crypto", + "kind": "method", + "name": "update", + "signature": "`mac.update(data[, inputEncoding])`", + "label": "mac.update(data[, inputEncoding])", + "apiSymbol": "mac.update", + "depth": 2, + "scope": "api", + "anchor": "macupdatedata-inputencoding", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "crypto:1f80502ef093", "chapter": "crypto", @@ -13995,16 +14286,16 @@ } }, { - "id": "crypto:16511e6f27c0", + "id": "crypto:1376126d8fea", "chapter": "crypto", "kind": "method", "name": "verify", - "signature": "`verify.verify(object, signature[, signatureEncoding])`", - "label": "verify.verify(object, signature[, signatureEncoding])", + "signature": "`verify.verify(key, signature[, signatureEncoding])`", + "label": "verify.verify(key, signature[, signatureEncoding])", "apiSymbol": "verify.verify", "depth": 2, "scope": "api", - "anchor": "verifyverifyobject-signature-signatureencoding", + "anchor": "verifyverifykey-signature-signatureencoding", "nodeStability": { "index": "2", "level": 2, @@ -15052,6 +15343,29 @@ "verification": "registry-gap" } }, + { + "id": "diagnostics_channel:80f3f937cfe0", + "chapter": "diagnostics_channel", + "kind": "event", + "name": "crypto.fips.indicator", + "signature": "Event: `'crypto.fips.indicator'`", + "label": "'crypto.fips.indicator'", + "apiSymbol": "'crypto.fips.indicator'", + "depth": 1, + "scope": "api", + "anchor": "event-cryptofipsindicator", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "diagnostics_channel:50a76b004ae9", "chapter": "diagnostics_channel", @@ -15490,16 +15804,16 @@ } }, { - "id": "diagnostics_channel:d1c41884e542", + "id": "diagnostics_channel:bb1dd3918bd5", "chapter": "diagnostics_channel", "kind": "event", - "name": "module.require.start", - "signature": "Event: `'module.require.start'`", - "label": "'module.require.start'", - "apiSymbol": "'module.require.start'", + "name": "tracing:module.require:start", + "signature": "Event: `'tracing:module.require:start'`", + "label": "'tracing:module.require:start'", + "apiSymbol": "'tracing:module.require:start'", "depth": 1, "scope": "api", - "anchor": "event-modulerequirestart", + "anchor": "event-tracingmodulerequirestart", "nodeStability": { "index": "1", "level": 1, @@ -15513,16 +15827,16 @@ } }, { - "id": "diagnostics_channel:4cd1c32b77c6", + "id": "diagnostics_channel:990ea4c5a9d7", "chapter": "diagnostics_channel", "kind": "event", - "name": "module.require.end", - "signature": "Event: `'module.require.end'`", - "label": "'module.require.end'", - "apiSymbol": "'module.require.end'", + "name": "tracing:module.require:end", + "signature": "Event: `'tracing:module.require:end'`", + "label": "'tracing:module.require:end'", + "apiSymbol": "'tracing:module.require:end'", "depth": 1, "scope": "api", - "anchor": "event-modulerequireend", + "anchor": "event-tracingmodulerequireend", "nodeStability": { "index": "1", "level": 1, @@ -15536,16 +15850,16 @@ } }, { - "id": "diagnostics_channel:cd31d16f125f", + "id": "diagnostics_channel:494f069b7279", "chapter": "diagnostics_channel", "kind": "event", - "name": "module.require.error", - "signature": "Event: `'module.require.error'`", - "label": "'module.require.error'", - "apiSymbol": "'module.require.error'", + "name": "tracing:module.require:error", + "signature": "Event: `'tracing:module.require:error'`", + "label": "'tracing:module.require:error'", + "apiSymbol": "'tracing:module.require:error'", "depth": 1, "scope": "api", - "anchor": "event-modulerequireerror", + "anchor": "event-tracingmodulerequireerror", "nodeStability": { "index": "1", "level": 1, @@ -15559,16 +15873,16 @@ } }, { - "id": "diagnostics_channel:a2840f3e48cc", + "id": "diagnostics_channel:24d45c5b63f5", "chapter": "diagnostics_channel", "kind": "event", - "name": "module.import.asyncStart", - "signature": "Event: `'module.import.asyncStart'`", - "label": "'module.import.asyncStart'", - "apiSymbol": "'module.import.asyncStart'", + "name": "tracing:module.import:asyncStart", + "signature": "Event: `'tracing:module.import:asyncStart'`", + "label": "'tracing:module.import:asyncStart'", + "apiSymbol": "'tracing:module.import:asyncStart'", "depth": 1, "scope": "api", - "anchor": "event-moduleimportasyncstart", + "anchor": "event-tracingmoduleimportasyncstart", "nodeStability": { "index": "1", "level": 1, @@ -15582,16 +15896,16 @@ } }, { - "id": "diagnostics_channel:730d6618877f", + "id": "diagnostics_channel:fd44953e860d", "chapter": "diagnostics_channel", "kind": "event", - "name": "module.import.asyncEnd", - "signature": "Event: `'module.import.asyncEnd'`", - "label": "'module.import.asyncEnd'", - "apiSymbol": "'module.import.asyncEnd'", + "name": "tracing:module.import:asyncEnd", + "signature": "Event: `'tracing:module.import:asyncEnd'`", + "label": "'tracing:module.import:asyncEnd'", + "apiSymbol": "'tracing:module.import:asyncEnd'", "depth": 1, "scope": "api", - "anchor": "event-moduleimportasyncend", + "anchor": "event-tracingmoduleimportasyncend", "nodeStability": { "index": "1", "level": 1, @@ -15605,16 +15919,16 @@ } }, { - "id": "diagnostics_channel:b94f162dfbad", + "id": "diagnostics_channel:a25388ac262b", "chapter": "diagnostics_channel", "kind": "event", - "name": "module.import.error", - "signature": "Event: `'module.import.error'`", - "label": "'module.import.error'", - "apiSymbol": "'module.import.error'", + "name": "tracing:module.import:error", + "signature": "Event: `'tracing:module.import:error'`", + "label": "'tracing:module.import:error'", + "apiSymbol": "'tracing:module.import:error'", "depth": 1, "scope": "api", - "anchor": "event-moduleimporterror", + "anchor": "event-tracingmoduleimporterror", "nodeStability": { "index": "1", "level": 1, @@ -15789,16 +16103,16 @@ } }, { - "id": "diagnostics_channel:3e684ab90652", + "id": "diagnostics_channel:990885f7c68c", "chapter": "diagnostics_channel", "kind": "event", - "name": "execve", - "signature": "Event: `'execve'`", - "label": "'execve'", - "apiSymbol": "'execve'", + "name": "process.execve", + "signature": "Event: `'process.execve'`", + "label": "'process.execve'", + "apiSymbol": "'process.execve'", "depth": 1, "scope": "api", - "anchor": "event-execve", + "anchor": "event-processexecve", "nodeStability": { "index": "1", "level": 1, @@ -15926,6 +16240,29 @@ "verification": "registry-gap" } }, + { + "id": "diagnostics_channel:f9ab0dfd2826", + "chapter": "diagnostics_channel", + "kind": "event", + "name": "sqlite.db.query", + "signature": "Event: `'sqlite.db.query'`", + "label": "'sqlite.db.query'", + "apiSymbol": "'sqlite.db.query'", + "depth": 1, + "scope": "api", + "anchor": "event-sqlitedbquery", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "diagnostics_channel:e311810f8dca", "chapter": "diagnostics_channel", @@ -17918,6 +18255,24 @@ "verification": "registry-gap" } }, + { + "id": "errors:7c2e0440b499", + "chapter": "errors", + "kind": "class", + "name": "DOMException", + "signature": "Class: `DOMException`", + "label": "DOMException", + "apiSymbol": "DOMException", + "depth": 1, + "scope": "api", + "anchor": "class-domexception", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "errors:2c13de112ff5", "chapter": "errors", @@ -19088,6 +19443,24 @@ "verification": "registry-gap" } }, + { + "id": "errors:1d435e87eb56", + "chapter": "errors", + "kind": "module", + "name": "`err_crypto_invalid_mac`", + "signature": "`ERR_CRYPTO_INVALID_MAC`", + "label": "ERR_CRYPTO_INVALID_MAC", + "apiSymbol": "ERR_CRYPTO_INVALID_MAC", + "depth": 1, + "scope": "api", + "anchor": "err_crypto_invalid_mac", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "errors:f62618221d0d", "chapter": "errors", @@ -19232,6 +19605,60 @@ "verification": "registry-gap" } }, + { + "id": "errors:d6c1b25e885d", + "chapter": "errors", + "kind": "module", + "name": "`err_crypto_mac_finalized`", + "signature": "`ERR_CRYPTO_MAC_FINALIZED`", + "label": "ERR_CRYPTO_MAC_FINALIZED", + "apiSymbol": "ERR_CRYPTO_MAC_FINALIZED", + "depth": 1, + "scope": "api", + "anchor": "err_crypto_mac_finalized", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "errors:d0b894204eed", + "chapter": "errors", + "kind": "module", + "name": "`err_crypto_mac_not_supported`", + "signature": "`ERR_CRYPTO_MAC_NOT_SUPPORTED`", + "label": "ERR_CRYPTO_MAC_NOT_SUPPORTED", + "apiSymbol": "ERR_CRYPTO_MAC_NOT_SUPPORTED", + "depth": 1, + "scope": "api", + "anchor": "err_crypto_mac_not_supported", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "errors:89c3bbbbe04b", + "chapter": "errors", + "kind": "module", + "name": "`err_crypto_mac_update_failed`", + "signature": "`ERR_CRYPTO_MAC_UPDATE_FAILED`", + "label": "ERR_CRYPTO_MAC_UPDATE_FAILED", + "apiSymbol": "ERR_CRYPTO_MAC_UPDATE_FAILED", + "depth": 1, + "scope": "api", + "anchor": "err_crypto_mac_update_failed", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "errors:bbb816de6720", "chapter": "errors", @@ -20672,6 +21099,24 @@ "verification": "registry-gap" } }, + { + "id": "errors:bc2b4b418075", + "chapter": "errors", + "kind": "module", + "name": "`err_http2_too_many_origins`", + "signature": "`ERR_HTTP2_TOO_MANY_ORIGINS`", + "label": "ERR_HTTP2_TOO_MANY_ORIGINS", + "apiSymbol": "ERR_HTTP2_TOO_MANY_ORIGINS", + "depth": 1, + "scope": "api", + "anchor": "err_http2_too_many_origins", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "errors:799603ae61ed", "chapter": "errors", @@ -22418,6 +22863,60 @@ "verification": "registry-gap" } }, + { + "id": "errors:e17495198d37", + "chapter": "errors", + "kind": "module", + "name": "`err_package_map_external_file`", + "signature": "`ERR_PACKAGE_MAP_EXTERNAL_FILE`", + "label": "ERR_PACKAGE_MAP_EXTERNAL_FILE", + "apiSymbol": "ERR_PACKAGE_MAP_EXTERNAL_FILE", + "depth": 1, + "scope": "api", + "anchor": "err_package_map_external_file", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "errors:ff3640a7d624", + "chapter": "errors", + "kind": "module", + "name": "`err_package_map_invalid`", + "signature": "`ERR_PACKAGE_MAP_INVALID`", + "label": "ERR_PACKAGE_MAP_INVALID", + "apiSymbol": "ERR_PACKAGE_MAP_INVALID", + "depth": 1, + "scope": "api", + "anchor": "err_package_map_invalid", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "errors:4bc366c6011c", + "chapter": "errors", + "kind": "module", + "name": "`err_package_map_key_not_found`", + "signature": "`ERR_PACKAGE_MAP_KEY_NOT_FOUND`", + "label": "ERR_PACKAGE_MAP_KEY_NOT_FOUND", + "apiSymbol": "ERR_PACKAGE_MAP_KEY_NOT_FOUND", + "depth": 1, + "scope": "api", + "anchor": "err_package_map_key_not_found", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "errors:9a703bb883e6", "chapter": "errors", @@ -22672,6 +23171,52 @@ "verification": "registry-gap" } }, + { + "id": "errors:26e263d339c6", + "chapter": "errors", + "kind": "module", + "name": "`err_quic_stream_aborted`", + "signature": "`ERR_QUIC_STREAM_ABORTED`", + "label": "ERR_QUIC_STREAM_ABORTED", + "apiSymbol": "ERR_QUIC_STREAM_ABORTED", + "depth": 1, + "scope": "api", + "anchor": "err_quic_stream_aborted", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "errors:a8b44a283f33", + "chapter": "errors", + "kind": "module", + "name": "`err_quic_stream_reset`", + "signature": "`ERR_QUIC_STREAM_RESET`", + "label": "ERR_QUIC_STREAM_RESET", + "apiSymbol": "ERR_QUIC_STREAM_RESET", + "depth": 1, + "scope": "api", + "anchor": "err_quic_stream_reset", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "errors:266e07dc7ced", "chapter": "errors", @@ -22777,6 +23322,29 @@ "verification": "registry-gap" } }, + { + "id": "errors:ad1a5adf2534", + "chapter": "errors", + "kind": "module", + "name": "`err_require_esm_race_condition`", + "signature": "`ERR_REQUIRE_ESM_RACE_CONDITION`", + "label": "ERR_REQUIRE_ESM_RACE_CONDITION", + "apiSymbol": "ERR_REQUIRE_ESM_RACE_CONDITION", + "depth": 1, + "scope": "api", + "anchor": "err_require_esm_race_condition", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental.", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "errors:50007aab8780", "chapter": "errors", @@ -23065,6 +23633,24 @@ "verification": "registry-gap" } }, + { + "id": "errors:7e6c1ed4db94", + "chapter": "errors", + "kind": "module", + "name": "`err_socket_handle_adopted`", + "signature": "`ERR_SOCKET_HANDLE_ADOPTED`", + "label": "ERR_SOCKET_HANDLE_ADOPTED", + "apiSymbol": "ERR_SOCKET_HANDLE_ADOPTED", + "depth": 1, + "scope": "api", + "anchor": "err_socket_handle_adopted", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "errors:e1def23be437", "chapter": "errors", @@ -23209,6 +23795,24 @@ "verification": "registry-gap" } }, + { + "id": "errors:a378bec92079", + "chapter": "errors", + "kind": "module", + "name": "`err_stream_iter_missing_flag`", + "signature": "`ERR_STREAM_ITER_MISSING_FLAG`", + "label": "ERR_STREAM_ITER_MISSING_FLAG", + "apiSymbol": "ERR_STREAM_ITER_MISSING_FLAG", + "depth": 1, + "scope": "api", + "anchor": "err_stream_iter_missing_flag", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "errors:b69c141eb822", "chapter": "errors", @@ -23407,6 +24011,24 @@ "verification": "registry-gap" } }, + { + "id": "errors:e23d44126eae", + "chapter": "errors", + "kind": "module", + "name": "`err_throttled`", + "signature": "`ERR_THROTTLED`", + "label": "ERR_THROTTLED", + "apiSymbol": "ERR_THROTTLED", + "depth": 1, + "scope": "api", + "anchor": "err_throttled", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "errors:9b1bacff6b37", "chapter": "errors", @@ -23641,6 +24263,24 @@ "verification": "registry-gap" } }, + { + "id": "errors:1d4c8b8ea330", + "chapter": "errors", + "kind": "module", + "name": "`err_tls_renegotiation_unsupported`", + "signature": "`ERR_TLS_RENEGOTIATION_UNSUPPORTED`", + "label": "ERR_TLS_RENEGOTIATION_UNSUPPORTED", + "apiSymbol": "ERR_TLS_RENEGOTIATION_UNSUPPORTED", + "depth": 1, + "scope": "api", + "anchor": "err_tls_renegotiation_unsupported", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "errors:ebb5c98b76d6", "chapter": "errors", @@ -24343,6 +24983,24 @@ "verification": "registry-gap" } }, + { + "id": "errors:b5224b626f86", + "chapter": "errors", + "kind": "module", + "name": "`err_worker_handle_not_transferable`", + "signature": "`ERR_WORKER_HANDLE_NOT_TRANSFERABLE`", + "label": "ERR_WORKER_HANDLE_NOT_TRANSFERABLE", + "apiSymbol": "ERR_WORKER_HANDLE_NOT_TRANSFERABLE", + "depth": 1, + "scope": "api", + "anchor": "err_worker_handle_not_transferable", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "errors:75ec70605835", "chapter": "errors", @@ -28370,6 +29028,52 @@ "verification": "test-backed" } }, + { + "id": "fs:3eddc68c4823", + "chapter": "fs", + "kind": "method", + "name": "pull", + "signature": "`filehandle.pull([...transforms][, options])`", + "label": "filehandle.pull([...transforms][, options])", + "apiSymbol": "filehandle.pull", + "depth": 2, + "scope": "api", + "anchor": "filehandlepulltransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "fs:236cfefb2bd7", + "chapter": "fs", + "kind": "method", + "name": "pullSync", + "signature": "`filehandle.pullSync([...transforms][, options])`", + "label": "filehandle.pullSync([...transforms][, options])", + "apiSymbol": "filehandle.pullSync", + "depth": 2, + "scope": "api", + "anchor": "filehandlepullsynctransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "fs:8bff339d602d", "chapter": "fs", @@ -28738,6 +29442,29 @@ "verification": "test-backed" } }, + { + "id": "fs:db142178f3b2", + "chapter": "fs", + "kind": "method", + "name": "writer", + "signature": "`filehandle.writer([options])`", + "label": "filehandle.writer([options])", + "apiSymbol": "filehandle.writer", + "depth": 2, + "scope": "api", + "anchor": "filehandlewriteroptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "fs:0eb79d089322", "chapter": "fs", @@ -33614,6 +34341,29 @@ "verification": "test-backed" } }, + { + "id": "fs:fc5a2ccba935", + "chapter": "fs", + "kind": "number|bigint", + "name": "Type", + "signature": "`frsize` Type: {number|bigint}", + "label": "frsize", + "apiSymbol": "frsize", + "depth": 2, + "scope": "api", + "anchor": "class-fsstatfs", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "fs:4d046e9b2b75", "chapter": "fs", @@ -37456,11 +38206,11 @@ } }, { - "id": "http:faf8578bc834", + "id": "http:3ec3b8b2efa8", "chapter": "http", "kind": "number", "name": "Type", - "signature": "`maxHeadersCount` Type: {number} **Default:** `2000`", + "signature": "`maxHeadersCount` Type: {number} **Default:** `1000`", "label": "maxHeadersCount", "apiSymbol": "maxHeadersCount", "depth": 2, @@ -37571,11 +38321,11 @@ } }, { - "id": "http:9ca269feac75", + "id": "http:e7028cb19b03", "chapter": "http", "kind": "boolean", "name": "Type", - "signature": "`reusedSocket` Type: {boolean} Whether the request is send through a reused socket.", + "signature": "`reusedSocket` Type: {boolean} Whether the request is sent through a reused socket.", "label": "reusedSocket", "apiSymbol": "reusedSocket", "depth": 2, @@ -38100,11 +38850,11 @@ } }, { - "id": "http:2b341e7f7ddb", + "id": "http:d2aac123456e", "chapter": "http", "kind": "number", "name": "Type", - "signature": "`maxHeadersCount` Type: {number} **Default:** `2000`", + "signature": "`maxHeadersCount` Type: {number} **Default:** `1000`", "label": "maxHeadersCount", "apiSymbol": "maxHeadersCount", "depth": 2, @@ -38835,6 +39585,29 @@ "verification": "test-backed" } }, + { + "id": "http:3228cdffbf09", + "chapter": "http", + "kind": "method", + "name": "writeInformation", + "signature": "`response.writeInformation(statusCode[, headers][, callback])`", + "label": "response.writeInformation(statusCode[, headers][, callback])", + "apiSymbol": "response.writeInformation", + "depth": 2, + "scope": "api", + "anchor": "responsewriteinformationstatuscode-headers-callback", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "http:66f1ca12e0bb", "chapter": "http", @@ -39433,6 +40206,29 @@ "verification": "test-backed" } }, + { + "id": "http:17e4f98aa2fc", + "chapter": "http", + "kind": "AbortSignal", + "name": "Type", + "signature": "`signal` Type: {AbortSignal}", + "label": "signal", + "apiSymbol": "signal", + "depth": 2, + "scope": "api", + "anchor": "class-httpincomingmessage", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "http:63ef1a2fb4c2", "chapter": "http", @@ -44148,6 +44944,29 @@ "verification": "registry-gap" } }, + { + "id": "http2:5deaac8d8f97", + "chapter": "http2", + "kind": "method", + "name": "writeInformation", + "signature": "`response.writeInformation(statusCode[, headers])`", + "label": "response.writeInformation(statusCode[, headers])", + "apiSymbol": "response.writeInformation", + "depth": 2, + "scope": "api", + "anchor": "responsewriteinformationstatuscode-headers", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "http2:b551a5ca3a62", "chapter": "http2", @@ -44701,11 +45520,11 @@ } }, { - "id": "https:705c007905d2", + "id": "https:2c6b974ec0c1", "chapter": "https", "kind": "number", "name": "Type", - "signature": "`maxHeadersCount` Type: {number} **Default:** `2000`", + "signature": "`maxHeadersCount` Type: {number} **Default:** `1000`", "label": "maxHeadersCount", "apiSymbol": "maxHeadersCount", "depth": 2, @@ -45620,6 +46439,1616 @@ "verification": "registry-gap" } }, + { + "id": "inspector:91e693d16a79", + "chapter": "inspector", + "kind": "Object", + "name": "params", + "signature": "`domStorageItemAdded` `params` {Object}", + "label": "domStorageItemAdded", + "apiSymbol": "domStorageItemAdded", + "depth": 1, + "scope": "api", + "anchor": "integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "inspector:ac553f71ee67", + "chapter": "inspector", + "kind": "Object", + "name": "params", + "signature": "`domStorageItemRemoved` `params` {Object}", + "label": "domStorageItemRemoved", + "apiSymbol": "domStorageItemRemoved", + "depth": 1, + "scope": "api", + "anchor": "integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "inspector:551b41cae8b6", + "chapter": "inspector", + "kind": "Object", + "name": "params", + "signature": "`domStorageItemUpdated` `params` {Object}", + "label": "domStorageItemUpdated", + "apiSymbol": "domStorageItemUpdated", + "depth": 1, + "scope": "api", + "anchor": "integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "inspector:3cba411858f1", + "chapter": "inspector", + "kind": "Object", + "name": "params", + "signature": "`domStorageItemsCleared` `params` {Object}", + "label": "domStorageItemsCleared", + "apiSymbol": "domStorageItemsCleared", + "depth": 1, + "scope": "api", + "anchor": "integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "inspector:352bce26d961", + "chapter": "inspector", + "kind": "Object", + "name": "params", + "signature": "`registerStorage` `params` {Object}", + "label": "registerStorage", + "apiSymbol": "registerStorage", + "depth": 1, + "scope": "api", + "anchor": "integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:94e2aeab4df6", + "chapter": "stream_iter", + "kind": "module", + "name": "iterable_streams", + "signature": "Iterable Streams", + "label": "Iterable Streams", + "apiSymbol": "iterable_streams", + "depth": 0, + "scope": "api", + "anchor": "", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "Derived from the exact API rows in this chapter.", + "verification": "derived" + } + }, + { + "id": "stream_iter:74881c7a8ea5", + "chapter": "stream_iter", + "kind": "method", + "name": "end", + "signature": "`writer.end([options])`", + "label": "writer.end([options])", + "apiSymbol": "writer.end", + "depth": 1, + "scope": "api", + "anchor": "writerendoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:25b778a0a19a", + "chapter": "stream_iter", + "kind": "method", + "name": "endSync", + "signature": "`writer.endSync()`", + "label": "writer.endSync()", + "apiSymbol": "writer.endSync", + "depth": 1, + "scope": "api", + "anchor": "writerendsync", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:dd1332b8c7a3", + "chapter": "stream_iter", + "kind": "method", + "name": "fail", + "signature": "`writer.fail(reason)`", + "label": "writer.fail(reason)", + "apiSymbol": "writer.fail", + "depth": 1, + "scope": "api", + "anchor": "writerfailreason", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:9fe673a6f9a0", + "chapter": "stream_iter", + "kind": "method", + "name": "[Symbol.asyncDispose]", + "signature": "`writer[Symbol.asyncDispose]()`", + "label": "writer[Symbol.asyncDispose]()", + "apiSymbol": "writer", + "depth": 1, + "scope": "api", + "anchor": "writersymbolasyncdispose", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:122792b034fd", + "chapter": "stream_iter", + "kind": "method", + "name": "write", + "signature": "`writer.write(chunk[, options])`", + "label": "writer.write(chunk[, options])", + "apiSymbol": "writer.write", + "depth": 1, + "scope": "api", + "anchor": "writerwritechunk-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:70029a8cc441", + "chapter": "stream_iter", + "kind": "method", + "name": "writeSync", + "signature": "`writer.writeSync(chunk)`", + "label": "writer.writeSync(chunk)", + "apiSymbol": "writer.writeSync", + "depth": 1, + "scope": "api", + "anchor": "writerwritesyncchunk", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:75d546da6ee2", + "chapter": "stream_iter", + "kind": "method", + "name": "writev", + "signature": "`writer.writev(chunks[, options])`", + "label": "writer.writev(chunks[, options])", + "apiSymbol": "writer.writev", + "depth": 1, + "scope": "api", + "anchor": "writerwritevchunks-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:9b24338e15dd", + "chapter": "stream_iter", + "kind": "method", + "name": "writevSync", + "signature": "`writer.writevSync(chunks)`", + "label": "writer.writevSync(chunks)", + "apiSymbol": "writer.writevSync", + "depth": 1, + "scope": "api", + "anchor": "writerwritevsyncchunks", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:71e88296da2b", + "chapter": "stream_iter", + "kind": "boolean|null", + "name": "canWrite", + "signature": "`canWrite` {boolean|null}", + "label": "canWrite", + "apiSymbol": "canWrite", + "depth": 1, + "scope": "api", + "anchor": "writer-interface", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:f31bb04ebfd3", + "chapter": "stream_iter", + "kind": "module", + "name": "the_`stream/iter`_module", + "signature": "The `stream/iter` module", + "label": "The stream/iter module", + "apiSymbol": "stream/iter", + "depth": 1, + "scope": "api", + "anchor": "the-streamiter-module", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:e81bf2b065dc", + "chapter": "stream_iter", + "kind": "method", + "name": "from", + "signature": "`from(input)`", + "label": "from(input)", + "apiSymbol": "from", + "depth": 1, + "scope": "api", + "anchor": "frominput", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:6f3664ed818c", + "chapter": "stream_iter", + "kind": "method", + "name": "fromSync", + "signature": "`fromSync(input)`", + "label": "fromSync(input)", + "apiSymbol": "fromSync", + "depth": 1, + "scope": "api", + "anchor": "fromsyncinput", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:c35641af526f", + "chapter": "stream_iter", + "kind": "method", + "name": "pipeTo", + "signature": "`pipeTo(source[, ...transforms], writer[, options])`", + "label": "pipeTo(source[, ...transforms], writer[, options])", + "apiSymbol": "pipeTo", + "depth": 1, + "scope": "api", + "anchor": "pipetosource-transforms-writer-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:2daa0291481c", + "chapter": "stream_iter", + "kind": "method", + "name": "pipeToSync", + "signature": "`pipeToSync(source[, ...transforms], writer[, options])`", + "label": "pipeToSync(source[, ...transforms], writer[, options])", + "apiSymbol": "pipeToSync", + "depth": 1, + "scope": "api", + "anchor": "pipetosyncsource-transforms-writer-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:00e796148b11", + "chapter": "stream_iter", + "kind": "method", + "name": "pull", + "signature": "`pull(source[, ...transforms][, options])`", + "label": "pull(source[, ...transforms][, options])", + "apiSymbol": "pull", + "depth": 1, + "scope": "api", + "anchor": "pullsource-transforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:f89b0e75e302", + "chapter": "stream_iter", + "kind": "method", + "name": "pullSync", + "signature": "`pullSync(source[, ...transforms])`", + "label": "pullSync(source[, ...transforms])", + "apiSymbol": "pullSync", + "depth": 1, + "scope": "api", + "anchor": "pullsyncsource-transforms", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:ea066cb12f48", + "chapter": "stream_iter", + "kind": "method", + "name": "push", + "signature": "`push([...transforms][, options])`", + "label": "push([...transforms][, options])", + "apiSymbol": "push", + "depth": 1, + "scope": "api", + "anchor": "pushtransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:199f13b2e259", + "chapter": "stream_iter", + "kind": "method", + "name": "duplex", + "signature": "`duplex([options])`", + "label": "duplex([options])", + "apiSymbol": "duplex", + "depth": 1, + "scope": "api", + "anchor": "duplexoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:921683aeccfe", + "chapter": "stream_iter", + "kind": "method", + "name": "array", + "signature": "`array(source[, options])`", + "label": "array(source[, options])", + "apiSymbol": "array", + "depth": 1, + "scope": "api", + "anchor": "arraysource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:fbf10b4b189e", + "chapter": "stream_iter", + "kind": "method", + "name": "arrayBuffer", + "signature": "`arrayBuffer(source[, options])`", + "label": "arrayBuffer(source[, options])", + "apiSymbol": "arrayBuffer", + "depth": 1, + "scope": "api", + "anchor": "arraybuffersource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:e0afcafcc6fb", + "chapter": "stream_iter", + "kind": "method", + "name": "arrayBufferSync", + "signature": "`arrayBufferSync(source[, options])`", + "label": "arrayBufferSync(source[, options])", + "apiSymbol": "arrayBufferSync", + "depth": 1, + "scope": "api", + "anchor": "arraybuffersyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:b0128d2ee8ff", + "chapter": "stream_iter", + "kind": "method", + "name": "arraySync", + "signature": "`arraySync(source[, options])`", + "label": "arraySync(source[, options])", + "apiSymbol": "arraySync", + "depth": 1, + "scope": "api", + "anchor": "arraysyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:463c54160f7b", + "chapter": "stream_iter", + "kind": "method", + "name": "bytes", + "signature": "`bytes(source[, options])`", + "label": "bytes(source[, options])", + "apiSymbol": "bytes", + "depth": 1, + "scope": "api", + "anchor": "bytessource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:ee97f670b7fe", + "chapter": "stream_iter", + "kind": "method", + "name": "bytesSync", + "signature": "`bytesSync(source[, options])`", + "label": "bytesSync(source[, options])", + "apiSymbol": "bytesSync", + "depth": 1, + "scope": "api", + "anchor": "bytessyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:64923f0bbaa4", + "chapter": "stream_iter", + "kind": "method", + "name": "text", + "signature": "`text(source[, options])`", + "label": "text(source[, options])", + "apiSymbol": "text", + "depth": 1, + "scope": "api", + "anchor": "textsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:920695b6cf72", + "chapter": "stream_iter", + "kind": "method", + "name": "textSync", + "signature": "`textSync(source[, options])`", + "label": "textSync(source[, options])", + "apiSymbol": "textSync", + "depth": 1, + "scope": "api", + "anchor": "textsyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:8b98f79752a4", + "chapter": "stream_iter", + "kind": "method", + "name": "ondrain", + "signature": "`ondrain(drainable)`", + "label": "ondrain(drainable)", + "apiSymbol": "ondrain", + "depth": 1, + "scope": "api", + "anchor": "ondraindrainable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:87224fe2c755", + "chapter": "stream_iter", + "kind": "method", + "name": "merge", + "signature": "`merge(...sources[, options])`", + "label": "merge(...sources[, options])", + "apiSymbol": "merge", + "depth": 1, + "scope": "api", + "anchor": "mergesources-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:5fd18544d6db", + "chapter": "stream_iter", + "kind": "method", + "name": "tap", + "signature": "`tap(callback)`", + "label": "tap(callback)", + "apiSymbol": "tap", + "depth": 1, + "scope": "api", + "anchor": "tapcallback", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:b86a9a538ee6", + "chapter": "stream_iter", + "kind": "method", + "name": "tapSync", + "signature": "`tapSync(callback)`", + "label": "tapSync(callback)", + "apiSymbol": "tapSync", + "depth": 1, + "scope": "api", + "anchor": "tapsynccallback", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:942c17d001f2", + "chapter": "stream_iter", + "kind": "module", + "name": "interface:_`shareable`", + "signature": "Interface: `Shareable`", + "label": "Interface: Shareable", + "apiSymbol": "Shareable", + "depth": 1, + "scope": "api", + "anchor": "interface-shareable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:3468fe11b070", + "chapter": "stream_iter", + "kind": "module", + "name": "`sharable[symbol.for('stream.shareprotocol')]`", + "signature": "`sharable[Symbol.for('Stream.shareProtocol')]`", + "label": "sharable[Symbol.for('Stream.shareProtocol')]", + "apiSymbol": "sharable", + "depth": 2, + "scope": "api", + "anchor": "sharablesymbolforstreamshareprotocol", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:4155dfe49484", + "chapter": "stream_iter", + "kind": "module", + "name": "interface:_`syncshareable`", + "signature": "Interface: `SyncShareable`", + "label": "Interface: SyncShareable", + "apiSymbol": "SyncShareable", + "depth": 1, + "scope": "api", + "anchor": "interface-syncshareable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:242fb4da0e1d", + "chapter": "stream_iter", + "kind": "module", + "name": "`sharable[symbol.for('stream.sharesyncprotocol')]`", + "signature": "`sharable[Symbol.for('Stream.shareSyncProtocol')]`", + "label": "sharable[Symbol.for('Stream.shareSyncProtocol')]", + "apiSymbol": "sharable", + "depth": 2, + "scope": "api", + "anchor": "sharablesymbolforstreamsharesyncprotocol", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:c284e9cc071d", + "chapter": "stream_iter", + "kind": "class", + "name": "Share", + "signature": "Class: `Share`", + "label": "Share", + "apiSymbol": "Share", + "depth": 1, + "scope": "api", + "anchor": "class-share", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:699ee25e7836", + "chapter": "stream_iter", + "kind": "method", + "name": "cancel", + "signature": "`share.cancel([reason])`", + "label": "share.cancel([reason])", + "apiSymbol": "share.cancel", + "depth": 2, + "scope": "api", + "anchor": "sharecancelreason", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:8fcfa00b2e13", + "chapter": "stream_iter", + "kind": "method", + "name": "pull", + "signature": "`share.pull([...transforms][, options])`", + "label": "share.pull([...transforms][, options])", + "apiSymbol": "share.pull", + "depth": 2, + "scope": "api", + "anchor": "sharepulltransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:72b6caf2da05", + "chapter": "stream_iter", + "kind": "method", + "name": "[Symbol.dispose]", + "signature": "`share[Symbol.dispose]()`", + "label": "share[Symbol.dispose]()", + "apiSymbol": "share", + "depth": 2, + "scope": "api", + "anchor": "sharesymboldispose", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:ff3d33f63dae", + "chapter": "stream_iter", + "kind": "number", + "name": "consumerCount", + "signature": "`consumerCount` {number}", + "label": "consumerCount", + "apiSymbol": "consumerCount", + "depth": 2, + "scope": "api", + "anchor": "class-share", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:56fab04f6670", + "chapter": "stream_iter", + "kind": "class", + "name": "SyncShare", + "signature": "Class: `SyncShare`", + "label": "SyncShare", + "apiSymbol": "SyncShare", + "depth": 1, + "scope": "api", + "anchor": "class-syncshare", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:738b333def1d", + "chapter": "stream_iter", + "kind": "method", + "name": "cancel", + "signature": "`share.cancel([reason])`", + "label": "share.cancel([reason])", + "apiSymbol": "share.cancel", + "depth": 2, + "scope": "api", + "anchor": "sharecancelreason_1", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:54163998d82f", + "chapter": "stream_iter", + "kind": "method", + "name": "pull", + "signature": "`share.pull([...transforms][, options])`", + "label": "share.pull([...transforms][, options])", + "apiSymbol": "share.pull", + "depth": 2, + "scope": "api", + "anchor": "sharepulltransforms-options_1", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:9947ae5ee9f7", + "chapter": "stream_iter", + "kind": "method", + "name": "[Symbol.dispose]", + "signature": "`share[Symbol.dispose]()`", + "label": "share[Symbol.dispose]()", + "apiSymbol": "share", + "depth": 2, + "scope": "api", + "anchor": "sharesymboldispose_1", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:eb993c0d329d", + "chapter": "stream_iter", + "kind": "number", + "name": "bufferSize", + "signature": "`bufferSize` {number}", + "label": "bufferSize", + "apiSymbol": "bufferSize", + "depth": 2, + "scope": "api", + "anchor": "class-syncshare", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:84388db1cec2", + "chapter": "stream_iter", + "kind": "number", + "name": "consumerCount", + "signature": "`consumerCount` {number}", + "label": "consumerCount", + "apiSymbol": "consumerCount", + "depth": 2, + "scope": "api", + "anchor": "class-syncshare", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:fcc12813a840", + "chapter": "stream_iter", + "kind": "method", + "name": "broadcast", + "signature": "`broadcast([options])`", + "label": "broadcast([options])", + "apiSymbol": "broadcast", + "depth": 1, + "scope": "api", + "anchor": "broadcastoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:7909dd2cdb5d", + "chapter": "stream_iter", + "kind": "method", + "name": "cancel", + "signature": "`broadcast.cancel([reason])`", + "label": "broadcast.cancel([reason])", + "apiSymbol": "broadcast.cancel", + "depth": 2, + "scope": "api", + "anchor": "broadcastcancelreason", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:676e8ecc6237", + "chapter": "stream_iter", + "kind": "method", + "name": "push", + "signature": "`broadcast.push([...transforms][, options])`", + "label": "broadcast.push([...transforms][, options])", + "apiSymbol": "broadcast.push", + "depth": 2, + "scope": "api", + "anchor": "broadcastpushtransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:23f1e2d4c639", + "chapter": "stream_iter", + "kind": "method", + "name": "[Symbol.dispose]", + "signature": "`broadcast[Symbol.dispose]()`", + "label": "broadcast[Symbol.dispose]()", + "apiSymbol": "broadcast", + "depth": 2, + "scope": "api", + "anchor": "broadcastsymboldispose", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:75b743029db1", + "chapter": "stream_iter", + "kind": "number", + "name": "consumerCount", + "signature": "`consumerCount` {number}", + "label": "consumerCount", + "apiSymbol": "consumerCount", + "depth": 2, + "scope": "api", + "anchor": "broadcastoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:fd8809959bcf", + "chapter": "stream_iter", + "kind": "method", + "name": "from", + "signature": "`Broadcast.from(input[, options])`", + "label": "Broadcast.from(input[, options])", + "apiSymbol": "Broadcast.from", + "depth": 1, + "scope": "api", + "anchor": "broadcastfrominput-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:e47f09ec7c74", + "chapter": "stream_iter", + "kind": "method", + "name": "share", + "signature": "`share(source[, options])`", + "label": "share(source[, options])", + "apiSymbol": "share", + "depth": 1, + "scope": "api", + "anchor": "sharesource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:8e955476f8e6", + "chapter": "stream_iter", + "kind": "method", + "name": "shareSync", + "signature": "`shareSync(source[, options])`", + "label": "shareSync(source[, options])", + "apiSymbol": "shareSync", + "depth": 1, + "scope": "api", + "anchor": "sharesyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:335f2485e371", + "chapter": "stream_iter", + "kind": "method", + "name": "fromReadable", + "signature": "`fromReadable(readable)`", + "label": "fromReadable(readable)", + "apiSymbol": "fromReadable", + "depth": 1, + "scope": "api", + "anchor": "fromreadablereadable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:58f5bcd9e475", + "chapter": "stream_iter", + "kind": "method", + "name": "fromWritable", + "signature": "`fromWritable(writable[, options])`", + "label": "fromWritable(writable[, options])", + "apiSymbol": "fromWritable", + "depth": 1, + "scope": "api", + "anchor": "fromwritablewritable-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:f2dddb7c0fd6", + "chapter": "stream_iter", + "kind": "method", + "name": "toReadable", + "signature": "`toReadable(source[, options])`", + "label": "toReadable(source[, options])", + "apiSymbol": "toReadable", + "depth": 1, + "scope": "api", + "anchor": "toreadablesource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:980c4eedf78c", + "chapter": "stream_iter", + "kind": "method", + "name": "toReadableSync", + "signature": "`toReadableSync(source[, options])`", + "label": "toReadableSync(source[, options])", + "apiSymbol": "toReadableSync", + "depth": 1, + "scope": "api", + "anchor": "toreadablesyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:0eadccfb86e1", + "chapter": "stream_iter", + "kind": "method", + "name": "toWritable", + "signature": "`toWritable(writer)`", + "label": "toWritable(writer)", + "apiSymbol": "toWritable", + "depth": 1, + "scope": "api", + "anchor": "towritablewriter", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:a3fb72adb9d4", + "chapter": "stream_iter", + "kind": "section", + "name": "Value", + "signature": "`broadcastProtocol` Value: `Symbol.for('Stream.broadcastProtocol')`", + "label": "broadcastProtocol", + "apiSymbol": "broadcastProtocol", + "depth": 1, + "scope": "api", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:80709c59ac66", + "chapter": "stream_iter", + "kind": "section", + "name": "Value", + "signature": "`drainableProtocol` Value: `Symbol.for('Stream.drainableProtocol')`", + "label": "drainableProtocol", + "apiSymbol": "drainableProtocol", + "depth": 1, + "scope": "api", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:d6e40713d854", + "chapter": "stream_iter", + "kind": "section", + "name": "Value", + "signature": "`shareProtocol` Value: `Symbol.for('Stream.shareProtocol')`", + "label": "shareProtocol", + "apiSymbol": "shareProtocol", + "depth": 1, + "scope": "api", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:1df144641604", + "chapter": "stream_iter", + "kind": "section", + "name": "Value", + "signature": "`shareSyncProtocol` Value: `Symbol.for('Stream.shareSyncProtocol')`", + "label": "shareSyncProtocol", + "apiSymbol": "shareSyncProtocol", + "depth": 1, + "scope": "api", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:02b320eb031a", + "chapter": "stream_iter", + "kind": "section", + "name": "Value", + "signature": "`toAsyncStreamable` Value: `Symbol.for('Stream.toAsyncStreamable')`", + "label": "toAsyncStreamable", + "apiSymbol": "toAsyncStreamable", + "depth": 1, + "scope": "api", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream_iter:870e05b0278a", + "chapter": "stream_iter", + "kind": "section", + "name": "Value", + "signature": "`toStreamable` Value: `Symbol.for('Stream.toStreamable')`", + "label": "toStreamable", + "apiSymbol": "toStreamable", + "depth": 1, + "scope": "api", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "modules:407c51651126", "chapter": "modules", @@ -47631,6 +50060,60 @@ "verification": "registry-gap" } }, + { + "id": "net:bed278373fec", + "chapter": "net", + "kind": "method", + "name": "addAddresses", + "signature": "`blockList.addAddresses(addresses[, type])`", + "label": "blockList.addAddresses(addresses[, type])", + "apiSymbol": "blockList.addAddresses", + "depth": 2, + "scope": "api", + "anchor": "blocklistaddaddressesaddresses-type", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:3eab1fde8dda", + "chapter": "net", + "kind": "method", + "name": "addCIDR", + "signature": "`blockList.addCIDR(cidr)`", + "label": "blockList.addCIDR(cidr)", + "apiSymbol": "blockList.addCIDR", + "depth": 2, + "scope": "api", + "anchor": "blocklistaddcidrcidr", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:85bb2c28b8b4", + "chapter": "net", + "kind": "method", + "name": "addCIDRs", + "signature": "`blockList.addCIDRs(cidrs)`", + "label": "blockList.addCIDRs(cidrs)", + "apiSymbol": "blockList.addCIDRs", + "depth": 2, + "scope": "api", + "anchor": "blocklistaddcidrscidrs", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "net:035828cd10e1", "chapter": "net", @@ -47686,16 +50169,16 @@ } }, { - "id": "net:4ff6a4c12f52", + "id": "net:e0681ee0179f", "chapter": "net", "kind": "method", - "name": "isBlockList", - "signature": "`BlockList.isBlockList(value)`", - "label": "BlockList.isBlockList(value)", - "apiSymbol": "BlockList.isBlockList", + "name": "clear", + "signature": "`blockList.clear()`", + "label": "blockList.clear()", + "apiSymbol": "blockList.clear", "depth": 2, "scope": "api", - "anchor": "blocklistisblocklistvalue", + "anchor": "blocklistclear", "nodeStability": null, "static": { "status": "not-implemented", @@ -47715,9 +50198,9 @@ "scope": "api", "anchor": "blocklistfromjsonvalue", "nodeStability": { - "index": "1", + "index": "1.2", "level": 1, - "text": "Experimental", + "text": "Release candidate", "inherited": false }, "static": { @@ -47726,6 +50209,96 @@ "verification": "registry-gap" } }, + { + "id": "net:4ff6a4c12f52", + "chapter": "net", + "kind": "method", + "name": "isBlockList", + "signature": "`BlockList.isBlockList(value)`", + "label": "BlockList.isBlockList(value)", + "apiSymbol": "BlockList.isBlockList", + "depth": 2, + "scope": "api", + "anchor": "blocklistisblocklistvalue", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:6ccaedabc10a", + "chapter": "net", + "kind": "method", + "name": "removeAddress", + "signature": "`blockList.removeAddress(address[, type])`", + "label": "blockList.removeAddress(address[, type])", + "apiSymbol": "blockList.removeAddress", + "depth": 2, + "scope": "api", + "anchor": "blocklistremoveaddressaddress-type", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:03c6467a8162", + "chapter": "net", + "kind": "method", + "name": "removeCIDR", + "signature": "`blockList.removeCIDR(cidr)`", + "label": "blockList.removeCIDR(cidr)", + "apiSymbol": "blockList.removeCIDR", + "depth": 2, + "scope": "api", + "anchor": "blocklistremovecidrcidr", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:8ba4f8ec27e3", + "chapter": "net", + "kind": "method", + "name": "removeRange", + "signature": "`blockList.removeRange(start, end[, type])`", + "label": "blockList.removeRange(start, end[, type])", + "apiSymbol": "blockList.removeRange", + "depth": 2, + "scope": "api", + "anchor": "blocklistremoverangestart-end-type", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:6cc98f6368e6", + "chapter": "net", + "kind": "method", + "name": "removeSubnet", + "signature": "`blockList.removeSubnet(net, prefix[, type])`", + "label": "blockList.removeSubnet(net, prefix[, type])", + "apiSymbol": "blockList.removeSubnet", + "depth": 2, + "scope": "api", + "anchor": "blocklistremovesubnetnet-prefix-type", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "net:fb2019fd5533", "chapter": "net", @@ -47738,9 +50311,9 @@ "scope": "api", "anchor": "blocklisttojson", "nodeStability": { - "index": "1", + "index": "1.2", "level": 1, - "text": "Experimental", + "text": "Release candidate", "inherited": false }, "static": { @@ -47749,6 +50322,24 @@ "verification": "registry-gap" } }, + { + "id": "net:cdbc674629fb", + "chapter": "net", + "kind": "string\\[]", + "name": "Type", + "signature": "`PRIVATE_RANGES` Type: {string\\[]}", + "label": "PRIVATE_RANGES", + "apiSymbol": "PRIVATE_RANGES", + "depth": 2, + "scope": "api", + "anchor": "class-netblocklist", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "net:044763579a8b", "chapter": "net", @@ -47767,6 +50358,24 @@ "verification": "registry-gap" } }, + { + "id": "net:67046fe1e98b", + "chapter": "net", + "kind": "number", + "name": "Type", + "signature": "`size` Type: {number}", + "label": "size", + "apiSymbol": "size", + "depth": 2, + "scope": "api", + "anchor": "class-netblocklist", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "net:89343bd5aaf9", "chapter": "net", @@ -48488,16 +51097,52 @@ } }, { - "id": "net:7412f0f2828d", + "id": "net:b6eb2938c348", "chapter": "net", "kind": "method", "name": "setKeepAlive", - "signature": "`socket.setKeepAlive([enable][, initialDelay])`", - "label": "socket.setKeepAlive([enable][, initialDelay])", + "signature": "`socket.setKeepAlive()`", + "label": "socket.setKeepAlive()", "apiSymbol": "socket.setKeepAlive", "depth": 2, "scope": "api", - "anchor": "socketsetkeepaliveenable-initialdelay", + "anchor": "socketsetkeepalive", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:9fb8a064a508", + "chapter": "net", + "kind": "method", + "name": "setKeepAlive", + "signature": "`socket.setKeepAlive([options])`", + "label": "socket.setKeepAlive([options])", + "apiSymbol": "socket.setKeepAlive", + "depth": 3, + "scope": "api", + "anchor": "socketsetkeepaliveoptions", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:50eb33c33a53", + "chapter": "net", + "kind": "method", + "name": "setKeepAlive", + "signature": "`socket.setKeepAlive([enable][, initialDelay][, interval][, count])`", + "label": "socket.setKeepAlive([enable][, initialDelay][, interval][, count])", + "apiSymbol": "socket.setKeepAlive", + "depth": 3, + "scope": "api", + "anchor": "socketsetkeepaliveenable-initialdelay-interval-count", "nodeStability": null, "static": { "status": "not-implemented", @@ -48709,11 +51354,11 @@ } }, { - "id": "net:606071fbf392", + "id": "net:5fb78ca7306f", "chapter": "net", "kind": "boolean", "name": "Type", - "signature": "`destroyed` Type: {boolean} Indicates if the connection is destroyed or not. Once a connection is destroyed no further data can be transferred using it.", + "signature": "`destroyed` Type: {boolean} Indicates if the connection is destroyed or not. No further data can be transferred using a destroyed connection.", "label": "destroyed", "apiSymbol": "destroyed", "depth": 2, @@ -48852,6 +51497,24 @@ "verification": "registry-gap" } }, + { + "id": "net:d1a2a3208778", + "chapter": "net", + "kind": "net.Server|null", + "name": "Type", + "signature": "`server` Type: {net.Server|null}", + "label": "server", + "apiSymbol": "server", + "depth": 2, + "scope": "api", + "anchor": "class-netsocket", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "net:f96568725a94", "chapter": "net", @@ -49104,6 +51767,114 @@ "verification": "registry-gap" } }, + { + "id": "net:414417365ac3", + "chapter": "net", + "kind": "class", + "name": "net.BoundSocket", + "signature": "Class: `net.BoundSocket`", + "label": "net.BoundSocket", + "apiSymbol": "net.BoundSocket", + "depth": 1, + "scope": "api", + "anchor": "class-netboundsocket", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:400d8120e3ab", + "chapter": "net", + "kind": "method", + "name": "address", + "signature": "`boundSocket.address()`", + "label": "boundSocket.address()", + "apiSymbol": "boundSocket.address", + "depth": 2, + "scope": "api", + "anchor": "boundsocketaddress", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:ea9d92069057", + "chapter": "net", + "kind": "method", + "name": "fd", + "signature": "`boundSocket.fd()`", + "label": "boundSocket.fd()", + "apiSymbol": "boundSocket.fd", + "depth": 2, + "scope": "api", + "anchor": "boundsocketfd", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:185a5473f064", + "chapter": "net", + "kind": "method", + "name": "close", + "signature": "`boundSocket.close()`", + "label": "boundSocket.close()", + "apiSymbol": "boundSocket.close", + "depth": 2, + "scope": "api", + "anchor": "boundsocketclose", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:9cc281d92386", + "chapter": "net", + "kind": "method", + "name": "[Symbol.dispose]", + "signature": "`boundSocket[Symbol.dispose]()`", + "label": "boundSocket[Symbol.dispose]()", + "apiSymbol": "boundSocket", + "depth": 2, + "scope": "api", + "anchor": "boundsocketsymboldispose", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "net:66918477ba37", + "chapter": "net", + "kind": "boolean", + "name": "isPipe", + "signature": "`isPipe` {boolean}", + "label": "isPipe", + "apiSymbol": "isPipe", + "depth": 2, + "scope": "api", + "anchor": "class-netboundsocket", + "nodeStability": null, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "net:2d7b6dbbbe2c", "chapter": "net", @@ -50358,6 +53129,29 @@ "verification": "derived" } }, + { + "id": "perf_hooks:0f3b0bd30e2d", + "chapter": "perf_hooks", + "kind": "module", + "name": "measuring_how_long_the_`net.connect`_(only_for_tcp)_takes_when_the_connection_is_successful", + "signature": "Measuring how long the `net.connect` (only for TCP) takes when the connection is successful", + "label": "Measuring how long the net.connect (only for TCP) takes when the connection is successful", + "apiSymbol": "net.connect", + "depth": 1, + "scope": "api", + "anchor": "measuring-how-long-the-netconnect-only-for-tcp-takes-when-the-connection-is-successful", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "partial", + "detail": "Implemented by a dedicated static compiler/runtime path.", + "verification": "test-backed" + } + }, { "id": "perf_hooks:4191f3d1f637", "chapter": "perf_hooks", @@ -51140,6 +53934,75 @@ "verification": "registry-gap" } }, + { + "id": "perf_hooks:6af5b39b755a", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`finalResponseHeadersStart` Type: {number}", + "label": "finalResponseHeadersStart", + "apiSymbol": "finalResponseHeadersStart", + "depth": 2, + "scope": "api", + "anchor": "class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:756cbc84eee9", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`firstInterimResponseStart` Type: {number}", + "label": "firstInterimResponseStart", + "apiSymbol": "firstInterimResponseStart", + "depth": 2, + "scope": "api", + "anchor": "class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:7869397fdf24", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`responseStart` Type: {number}", + "label": "responseStart", + "apiSymbol": "responseStart", + "depth": 2, + "scope": "api", + "anchor": "class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "perf_hooks:19c7eaa1d601", "chapter": "perf_hooks", @@ -51232,6 +54095,75 @@ "verification": "registry-gap" } }, + { + "id": "perf_hooks:3d425c5f696c", + "chapter": "perf_hooks", + "kind": "string", + "name": "Type", + "signature": "`renderBlockingStatus` Type: {string}", + "label": "renderBlockingStatus", + "apiSymbol": "renderBlockingStatus", + "depth": 2, + "scope": "api", + "anchor": "class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:03b62556cc5e", + "chapter": "perf_hooks", + "kind": "string", + "name": "Type", + "signature": "`contentType` Type: {string}", + "label": "contentType", + "apiSymbol": "contentType", + "depth": 2, + "scope": "api", + "anchor": "class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:29830b9da1a6", + "chapter": "perf_hooks", + "kind": "string", + "name": "Type", + "signature": "`contentEncoding` Type: {string}", + "label": "contentEncoding", + "apiSymbol": "contentEncoding", + "depth": 2, + "scope": "api", + "anchor": "class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "perf_hooks:44c5636e6a4c", "chapter": "perf_hooks", @@ -51462,6 +54394,282 @@ "verification": "registry-gap" } }, + { + "id": "perf_hooks:759eb564d36d", + "chapter": "perf_hooks", + "kind": "method", + "name": "ccdf", + "signature": "`histogram.ccdf(value)`", + "label": "histogram.ccdf(value)", + "apiSymbol": "histogram.ccdf", + "depth": 2, + "scope": "api", + "anchor": "histogramccdfvalue", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:8d22421f4895", + "chapter": "perf_hooks", + "kind": "method", + "name": "cdf", + "signature": "`histogram.cdf(value)`", + "label": "histogram.cdf(value)", + "apiSymbol": "histogram.cdf", + "depth": 2, + "scope": "api", + "anchor": "histogramcdfvalue", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:7d3698e4b7e1", + "chapter": "perf_hooks", + "kind": "method", + "name": "cliffsD", + "signature": "`histogram.cliffsD(other)`", + "label": "histogram.cliffsD(other)", + "apiSymbol": "histogram.cliffsD", + "depth": 2, + "scope": "api", + "anchor": "histogramcliffsdother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:f6b0fdd4f95c", + "chapter": "perf_hooks", + "kind": "method", + "name": "cohensD", + "signature": "`histogram.cohensD(other)`", + "label": "histogram.cohensD(other)", + "apiSymbol": "histogram.cohensD", + "depth": 2, + "scope": "api", + "anchor": "histogramcohensdother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:32d32caabb57", + "chapter": "perf_hooks", + "kind": "method", + "name": "countAt", + "signature": "`histogram.countAt(value)`", + "label": "histogram.countAt(value)", + "apiSymbol": "histogram.countAt", + "depth": 2, + "scope": "api", + "anchor": "histogramcountatvalue", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:a654b4b820aa", + "chapter": "perf_hooks", + "kind": "method", + "name": "export", + "signature": "`histogram.export()`", + "label": "histogram.export()", + "apiSymbol": "histogram.export", + "depth": 2, + "scope": "api", + "anchor": "histogramexport", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:9eb87d68eed4", + "chapter": "perf_hooks", + "kind": "method", + "name": "burnRate", + "signature": "`histogram.burnRate(sloTarget)`", + "label": "histogram.burnRate(sloTarget)", + "apiSymbol": "histogram.burnRate", + "depth": 2, + "scope": "api", + "anchor": "histogramburnrateslotarget", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:efa4bd467f9d", + "chapter": "perf_hooks", + "kind": "method", + "name": "ksTest", + "signature": "`histogram.ksTest(other)`", + "label": "histogram.ksTest(other)", + "apiSymbol": "histogram.ksTest", + "depth": 2, + "scope": "api", + "anchor": "histogramkstestother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:c0563cf15d0e", + "chapter": "perf_hooks", + "kind": "method", + "name": "linearBuckets", + "signature": "`histogram.linearBuckets(stepSize)`", + "label": "histogram.linearBuckets(stepSize)", + "apiSymbol": "histogram.linearBuckets", + "depth": 2, + "scope": "api", + "anchor": "histogramlinearbucketsstepsize", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:5899ce3fef5c", + "chapter": "perf_hooks", + "kind": "method", + "name": "logBuckets", + "signature": "`histogram.logBuckets(firstBucket, base)`", + "label": "histogram.logBuckets(firstBucket, base)", + "apiSymbol": "histogram.logBuckets", + "depth": 2, + "scope": "api", + "anchor": "histogramlogbucketsfirstbucket-base", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:b477f2eb976a", + "chapter": "perf_hooks", + "kind": "method", + "name": "mannWhitneyTest", + "signature": "`histogram.mannWhitneyTest(other)`", + "label": "histogram.mannWhitneyTest(other)", + "apiSymbol": "histogram.mannWhitneyTest", + "depth": 2, + "scope": "api", + "anchor": "histogrammannwhitneytestother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:57aff1eb8969", + "chapter": "perf_hooks", + "kind": "method", + "name": "meanCI", + "signature": "`histogram.meanCI([options])`", + "label": "histogram.meanCI([options])", + "apiSymbol": "histogram.meanCI", + "depth": 2, + "scope": "api", + "anchor": "histogrammeancioptions", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "perf_hooks:831e531b3964", "chapter": "perf_hooks", @@ -51508,6 +54716,75 @@ "verification": "registry-gap" } }, + { + "id": "perf_hooks:5a5e7386f377", + "chapter": "perf_hooks", + "kind": "method", + "name": "percentileCI", + "signature": "`histogram.percentileCI(percentile[, options])`", + "label": "histogram.percentileCI(percentile[, options])", + "apiSymbol": "histogram.percentileCI", + "depth": 2, + "scope": "api", + "anchor": "histogrampercentilecipercentile-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:e35001d4c8a0", + "chapter": "perf_hooks", + "kind": "method", + "name": "percentilesAt", + "signature": "`histogram.percentilesAt(percentiles)`", + "label": "histogram.percentilesAt(percentiles)", + "apiSymbol": "histogram.percentilesAt", + "depth": 2, + "scope": "api", + "anchor": "histogrampercentilesatpercentiles", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:e8464d875a0d", + "chapter": "perf_hooks", + "kind": "method", + "name": "qrde", + "signature": "`histogram.qrde([options])`", + "label": "histogram.qrde([options])", + "apiSymbol": "histogram.qrde", + "depth": 2, + "scope": "api", + "anchor": "histogramqrdeoptions", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "perf_hooks:0c8a168f2d58", "chapter": "perf_hooks", @@ -51531,6 +54808,29 @@ "verification": "registry-gap" } }, + { + "id": "perf_hooks:355c107f6c4d", + "chapter": "perf_hooks", + "kind": "method", + "name": "welchTest", + "signature": "`histogram.welchTest(other[, options])`", + "label": "histogram.welchTest(other[, options])", + "apiSymbol": "histogram.welchTest", + "depth": 2, + "scope": "api", + "anchor": "histogramwelchtestother-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "perf_hooks:c3ade18455b5", "chapter": "perf_hooks", @@ -51623,6 +54923,98 @@ "verification": "registry-gap" } }, + { + "id": "perf_hooks:a6dbb2c261dd", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`ewmaMean` Type: {number}", + "label": "ewmaMean", + "apiSymbol": "ewmaMean", + "depth": 2, + "scope": "api", + "anchor": "class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:ff01abf35e25", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`ewmaStddev` Type: {number}", + "label": "ewmaStddev", + "apiSymbol": "ewmaStddev", + "depth": 2, + "scope": "api", + "anchor": "class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:5b140d5efd8a", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`ewmaErrorRate` Type: {number}", + "label": "ewmaErrorRate", + "apiSymbol": "ewmaErrorRate", + "depth": 2, + "scope": "api", + "anchor": "class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:0b729495c21e", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`kurtosis` Type: {number}", + "label": "kurtosis", + "apiSymbol": "kurtosis", + "depth": 2, + "scope": "api", + "anchor": "class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "perf_hooks:2a2f8716b952", "chapter": "perf_hooks", @@ -51784,6 +55176,29 @@ "verification": "registry-gap" } }, + { + "id": "perf_hooks:740617c55837", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`skewness` Type: {number}", + "label": "skewness", + "apiSymbol": "skewness", + "depth": 2, + "scope": "api", + "anchor": "class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "perf_hooks:dcfa27e91fad", "chapter": "perf_hooks", @@ -51808,16 +55223,16 @@ } }, { - "id": "perf_hooks:d8033c297e16", + "id": "perf_hooks:8a7e519bbfcf", "chapter": "perf_hooks", "kind": "class", - "name": "IntervalHistogram", - "signature": "Class: `IntervalHistogram extends Histogram`", - "label": "IntervalHistogram extends Histogram", - "apiSymbol": "IntervalHistogram extends Histogram", + "name": "ELDHistogram", + "signature": "Class: `ELDHistogram extends Histogram`", + "label": "ELDHistogram extends Histogram", + "apiSymbol": "ELDHistogram extends Histogram", "depth": 1, "scope": "api", - "anchor": "class-intervalhistogram-extends-histogram", + "anchor": "class-eldhistogram-extends-histogram", "nodeStability": { "index": "2", "level": 2, @@ -51831,16 +55246,16 @@ } }, { - "id": "perf_hooks:22e7f3f19476", + "id": "perf_hooks:c4fd14c1e628", "chapter": "perf_hooks", "kind": "module", - "name": "cloning_an_`intervalhistogram`", - "signature": "Cloning an `IntervalHistogram`", - "label": "Cloning an IntervalHistogram", - "apiSymbol": "IntervalHistogram", + "name": "cloning_an_`eldhistogram`", + "signature": "Cloning an `ELDHistogram`", + "label": "Cloning an ELDHistogram", + "apiSymbol": "ELDHistogram", "depth": 2, "scope": "api", - "anchor": "cloning-an-intervalhistogram", + "anchor": "cloning-an-eldhistogram", "nodeStability": { "index": "2", "level": 2, @@ -51854,7 +55269,7 @@ } }, { - "id": "perf_hooks:b164c7ab2b1f", + "id": "perf_hooks:b534ec2912d4", "chapter": "perf_hooks", "kind": "method", "name": "disable", @@ -51877,7 +55292,7 @@ } }, { - "id": "perf_hooks:651554deb586", + "id": "perf_hooks:6101277d5070", "chapter": "perf_hooks", "kind": "method", "name": "enable", @@ -51900,7 +55315,7 @@ } }, { - "id": "perf_hooks:e996f640b593", + "id": "perf_hooks:02e07d3a1e87", "chapter": "perf_hooks", "kind": "method", "name": "[Symbol.dispose]", @@ -51945,29 +55360,6 @@ "verification": "registry-gap" } }, - { - "id": "perf_hooks:07074b77fe50", - "chapter": "perf_hooks", - "kind": "module", - "name": "measuring_how_long_the_`net.connect`_(only_for_tcp)_takes_when_the_connection_is_successful", - "signature": "Measuring how long the `net.connect` (only for TCP) takes when the connection is successful", - "label": "Measuring how long the net.connect (only for TCP) takes when the connection is successful", - "apiSymbol": "net.connect", - "depth": 2, - "scope": "api", - "anchor": "measuring-how-long-the-netconnect-only-for-tcp-takes-when-the-connection-is-successful", - "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true - }, - "static": { - "status": "partial", - "detail": "Implemented by a dedicated static compiler/runtime path.", - "verification": "test-backed" - } - }, { "id": "perf_hooks:30eb4343b866", "chapter": "perf_hooks", @@ -52037,6 +55429,144 @@ "verification": "registry-gap" } }, + { + "id": "perf_hooks:7bb1ff7d8dee", + "chapter": "perf_hooks", + "kind": "method", + "name": "recordCorrected", + "signature": "`histogram.recordCorrected(val, expectedInterval)`", + "label": "histogram.recordCorrected(val, expectedInterval)", + "apiSymbol": "histogram.recordCorrected", + "depth": 2, + "scope": "api", + "anchor": "histogramrecordcorrectedval-expectedinterval", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:45ea9ace9906", + "chapter": "perf_hooks", + "kind": "method", + "name": "subtract", + "signature": "`histogram.subtract(other)`", + "label": "histogram.subtract(other)", + "apiSymbol": "histogram.subtract", + "depth": 2, + "scope": "api", + "anchor": "histogramsubtractother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:f2dbe6996530", + "chapter": "perf_hooks", + "kind": "class", + "name": "SlidingWindowHistogram", + "signature": "Class: `SlidingWindowHistogram`", + "label": "SlidingWindowHistogram", + "apiSymbol": "SlidingWindowHistogram", + "depth": 1, + "scope": "api", + "anchor": "class-slidingwindowhistogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:7d8e0c897024", + "chapter": "perf_hooks", + "kind": "method", + "name": "record", + "signature": "`slidingWindowHistogram.record(val)`", + "label": "slidingWindowHistogram.record(val)", + "apiSymbol": "slidingWindowHistogram.record", + "depth": 2, + "scope": "api", + "anchor": "slidingwindowhistogramrecordval", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:dc33b594890e", + "chapter": "perf_hooks", + "kind": "method", + "name": "reset", + "signature": "`slidingWindowHistogram.reset()`", + "label": "slidingWindowHistogram.reset()", + "apiSymbol": "slidingWindowHistogram.reset", + "depth": 2, + "scope": "api", + "anchor": "slidingwindowhistogramreset", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:562f505d25da", + "chapter": "perf_hooks", + "kind": "method", + "name": "snapshot", + "signature": "`slidingWindowHistogram.snapshot()`", + "label": "slidingWindowHistogram.snapshot()", + "apiSymbol": "slidingWindowHistogram.snapshot", + "depth": 2, + "scope": "api", + "anchor": "slidingwindowhistogramsnapshot", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "perf_hooks:5ac562207ef9", "chapter": "perf_hooks", @@ -52060,6 +55590,52 @@ "verification": "registry-gap" } }, + { + "id": "perf_hooks:8d8858b23a7d", + "chapter": "perf_hooks", + "kind": "method", + "name": "createSlidingWindowHistogram", + "signature": "`perf_hooks.createSlidingWindowHistogram(options)`", + "label": "perf_hooks.createSlidingWindowHistogram(options)", + "apiSymbol": "perf_hooks.createSlidingWindowHistogram", + "depth": 1, + "scope": "api", + "anchor": "perf_hookscreateslidingwindowhistogramoptions", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "perf_hooks:3b65cfa382c4", + "chapter": "perf_hooks", + "kind": "method", + "name": "importHistogram", + "signature": "`perf_hooks.importHistogram(data)`", + "label": "perf_hooks.importHistogram(data)", + "apiSymbol": "perf_hooks.importHistogram", + "depth": 1, + "scope": "api", + "anchor": "perf_hooksimporthistogramdata", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "perf_hooks:0136161053c0", "chapter": "perf_hooks", @@ -52584,6 +56160,29 @@ "verification": "declared-gap" } }, + { + "id": "permissions:11ad69fabdba", + "chapter": "permissions", + "kind": "method", + "name": "drop", + "signature": "`permission.drop(scope[, reference])`", + "label": "permission.drop(scope[, reference])", + "apiSymbol": "permission.drop", + "depth": 1, + "scope": "api", + "anchor": "permissiondropscope-reference", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static implementation exists for this Node API family yet.", + "verification": "declared-gap" + } + }, { "id": "permissions:bd6544e08561", "chapter": "permissions", @@ -54340,6 +57939,29 @@ "verification": "registry-gap" } }, + { + "id": "process:1755d174d4bc", + "chapter": "process", + "kind": "method", + "name": "drop", + "signature": "`process.permission.drop(scope[, reference])`", + "label": "process.permission.drop(scope[, reference])", + "apiSymbol": "process.permission.drop", + "depth": 2, + "scope": "api", + "anchor": "processpermissiondropscope-reference", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active Development", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "process:0fbc1d44adb8", "chapter": "process", @@ -56621,16 +60243,16 @@ } }, { - "id": "sqlite:bea9dd7076f9", + "id": "sqlite:e96387cf8afc", "chapter": "sqlite", "kind": "method", "name": "loadExtension", - "signature": "`database.loadExtension(path)`", - "label": "database.loadExtension(path)", + "signature": "`database.loadExtension(path[, entryPoint])`", + "label": "database.loadExtension(path[, entryPoint])", "apiSymbol": "database.loadExtension", "depth": 2, "scope": "api", - "anchor": "databaseloadextensionpath", + "anchor": "databaseloadextensionpath-entrypoint", "nodeStability": { "index": "1.2", "level": 1, @@ -56804,6 +60426,52 @@ "verification": "declared-gap" } }, + { + "id": "sqlite:1369c16ccdef", + "chapter": "sqlite", + "kind": "method", + "name": "serialize", + "signature": "`database.serialize([dbName])`", + "label": "database.serialize([dbName])", + "apiSymbol": "database.serialize", + "depth": 2, + "scope": "api", + "anchor": "databaseserializedbname", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static implementation exists for this Node API family yet.", + "verification": "declared-gap" + } + }, + { + "id": "sqlite:eca22e258945", + "chapter": "sqlite", + "kind": "method", + "name": "deserialize", + "signature": "`database.deserialize(buffer[, options])`", + "label": "database.deserialize(buffer[, options])", + "apiSymbol": "database.deserialize", + "depth": 2, + "scope": "api", + "anchor": "databasedeserializebuffer-options", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static implementation exists for this Node API family yet.", + "verification": "declared-gap" + } + }, { "id": "sqlite:29d553079aa0", "chapter": "sqlite", @@ -57149,6 +60817,29 @@ "verification": "declared-gap" } }, + { + "id": "sqlite:bbac258c4b2c", + "chapter": "sqlite", + "kind": "method", + "name": "close", + "signature": "`statement.close()`", + "label": "statement.close()", + "apiSymbol": "statement.close", + "depth": 2, + "scope": "api", + "anchor": "statementclose", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static implementation exists for this Node API family yet.", + "verification": "declared-gap" + } + }, { "id": "sqlite:8a2767b377e2", "chapter": "sqlite", @@ -57333,6 +61024,29 @@ "verification": "declared-gap" } }, + { + "id": "sqlite:370aee8447bb", + "chapter": "sqlite", + "kind": "method", + "name": "[Symbol.dispose]", + "signature": "`statement[Symbol.dispose]()`", + "label": "statement[Symbol.dispose]()", + "apiSymbol": "statement", + "depth": 2, + "scope": "api", + "anchor": "statementsymboldispose", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static implementation exists for this Node API family yet.", + "verification": "declared-gap" + } + }, { "id": "sqlite:9f7687fa081c", "chapter": "sqlite", @@ -57805,10 +61519,33 @@ "scope": "api", "anchor": "streamcomposestreams", "nodeStability": { - "index": "1", - "level": 1, - "text": "`stream.compose` is experimental.", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream:8f50ba066613", + "chapter": "stream", + "kind": "method", + "name": "isDestroyed", + "signature": "`stream.isDestroyed(stream)`", + "label": "stream.isDestroyed(stream)", + "apiSymbol": "stream.isDestroyed", + "depth": 1, + "scope": "api", + "anchor": "streamisdestroyedstream", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-implemented", @@ -58104,10 +61841,10 @@ "scope": "api", "anchor": "streamaddabortsignalsignal-stream", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "0", + "level": 0, + "text": "Deprecated. Using [`stream.addAbortSignal()`][] to destroy long-lived stream resources is documentation-only deprecated. See DEP0209.", + "inherited": false }, "static": { "status": "partial", @@ -58288,10 +62025,33 @@ "scope": "api", "anchor": "api-for-stream-consumers", "nodeStability": { - "index": "1", - "level": 1, - "text": "`stream.compose` is experimental.", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "stream:bce99dfc80e7", + "chapter": "stream", + "kind": "method", + "name": "isDestroyed", + "signature": "`stream.isDestroyed(stream)`", + "label": "stream.isDestroyed(stream)", + "apiSymbol": "stream.isDestroyed", + "depth": 1, + "scope": "api", + "anchor": "api-for-stream-consumers", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-implemented", @@ -58587,10 +62347,10 @@ "scope": "api", "anchor": "api-for-stream-consumers", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "0", + "level": 0, + "text": "Deprecated. Using [`stream.addAbortSignal()`][] to destroy long-lived stream resources is documentation-only deprecated. See DEP0209.", + "inherited": false }, "static": { "status": "partial", @@ -59265,6 +63025,29 @@ "verification": "registry-gap" } }, + { + "id": "stream:e149f8b1cd66", + "chapter": "stream", + "kind": "module", + "name": "`readable[symbol.for('stream.toasyncstreamable')]()`", + "signature": "`readable[Symbol.for('Stream.toAsyncStreamable')]()`", + "label": "readable[Symbol.for('Stream.toAsyncStreamable')]()", + "apiSymbol": "readable", + "depth": 2, + "scope": "api", + "anchor": "readablesymbolforstreamtoasyncstreamable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "stream:fffb9a73545d", "chapter": "stream", @@ -61059,6 +64842,98 @@ "verification": "registry-gap" } }, + { + "id": "test:f8e1a11bf73b", + "chapter": "test", + "kind": "module", + "name": "channel:_`'tracing:node.test:start'`", + "signature": "Channel: `'tracing:node.test:start'`", + "label": "Channel: 'tracing:node.test:start'", + "apiSymbol": "'tracing:node.test:start'", + "depth": 1, + "scope": "api", + "anchor": "channel-tracingnodeteststart", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "test:20a82a92c5ee", + "chapter": "test", + "kind": "module", + "name": "channel:_`'tracing:node.test:end'`", + "signature": "Channel: `'tracing:node.test:end'`", + "label": "Channel: 'tracing:node.test:end'", + "apiSymbol": "'tracing:node.test:end'", + "depth": 1, + "scope": "api", + "anchor": "channel-tracingnodetestend", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "test:1c3a160d93a5", + "chapter": "test", + "kind": "module", + "name": "channel:_`'tracing:node.test:error'`", + "signature": "Channel: `'tracing:node.test:error'`", + "label": "Channel: 'tracing:node.test:error'", + "apiSymbol": "'tracing:node.test:error'", + "depth": 1, + "scope": "api", + "anchor": "channel-tracingnodetesterror", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "test:67c55a98f438", + "chapter": "test", + "kind": "module", + "name": "context_propagation_with_`bindstore()`", + "signature": "Context propagation with `bindStore()`", + "label": "Context propagation with bindStore()", + "apiSymbol": "bindStore", + "depth": 1, + "scope": "api", + "anchor": "context-propagation-with-bindstore", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "test:94ee1fc64cba", "chapter": "test", @@ -61979,6 +65854,29 @@ "verification": "registry-gap" } }, + { + "id": "test:3b0586b4ebf5", + "chapter": "test", + "kind": "event", + "name": "test:log", + "signature": "Event: `'test:log'`", + "label": "'test:log'", + "apiSymbol": "'test:log'", + "depth": 2, + "scope": "api", + "anchor": "event-testlog", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "test:89f1682d338d", "chapter": "test", @@ -62297,10 +66195,33 @@ }, "static": { "status": "partial", - "detail": "Implemented by a dedicated static compiler/runtime path.", + "detail": "Implemented for the documented scriptc module-loader subset.", "verification": "test-backed" } }, + { + "id": "test:0c374aa5a4a0", + "chapter": "test", + "kind": "method", + "name": "log", + "signature": "`context.log(message[, data])`", + "label": "context.log(message[, data])", + "apiSymbol": "context.log", + "depth": 2, + "scope": "api", + "anchor": "contextlogmessage-data", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "test:d5d9833c77e2", "chapter": "test", @@ -62573,7 +66494,7 @@ }, "static": { "status": "partial", - "detail": "Implemented by a dedicated static compiler/runtime path.", + "detail": "Implemented for the documented scriptc module-loader subset.", "verification": "test-backed" } }, @@ -62646,6 +66567,29 @@ "verification": "registry-gap" } }, + { + "id": "test:1d5db8900faf", + "chapter": "test", + "kind": "string\\[]", + "name": "Type", + "signature": "`tags` Type: {string\\[]}", + "label": "tags", + "apiSymbol": "tags", + "depth": 2, + "scope": "api", + "anchor": "class-testcontext", + "nodeStability": { + "index": "1.0", + "level": 1, + "text": "Early development", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "test:0ee703f51144", "chapter": "test", @@ -62715,6 +66659,52 @@ "verification": "registry-gap" } }, + { + "id": "test:fc7f1b42c35e", + "chapter": "test", + "kind": "method", + "name": "diagnostic", + "signature": "`context.diagnostic(message)`", + "label": "context.diagnostic(message)", + "apiSymbol": "context.diagnostic", + "depth": 2, + "scope": "api", + "anchor": "contextdiagnosticmessage_1", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "test:eed9c6589bd2", + "chapter": "test", + "kind": "method", + "name": "log", + "signature": "`context.log(message[, data])`", + "label": "context.log(message[, data])", + "apiSymbol": "context.log", + "depth": 2, + "scope": "api", + "anchor": "contextlogmessage-data_1", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "test:4b1cfc88fc4d", "chapter": "test", @@ -62779,9 +66769,9 @@ "inherited": true }, "static": { - "status": "partial", - "detail": "Implemented by a dedicated static compiler/runtime path.", - "verification": "test-backed" + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" } }, { @@ -62807,6 +66797,52 @@ "verification": "registry-gap" } }, + { + "id": "test:9af04b8cf499", + "chapter": "test", + "kind": "boolean", + "name": "Type", + "signature": "`passed` Type: {boolean}", + "label": "passed", + "apiSymbol": "passed", + "depth": 2, + "scope": "api", + "anchor": "class-suitecontext", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "test:ab6d3613f62b", + "chapter": "test", + "kind": "number", + "name": "Type", + "signature": "`attempt` Type: {number}", + "label": "attempt", + "apiSymbol": "attempt", + "depth": 2, + "scope": "api", + "anchor": "class-suitecontext", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "test:674c7aed221a", "chapter": "test", @@ -63290,6 +67326,29 @@ "verification": "test-backed" } }, + { + "id": "test:079e32fafea1", + "chapter": "test", + "kind": "method", + "name": "getTestContext", + "signature": "`getTestContext()`", + "label": "getTestContext()", + "apiSymbol": "getTestContext", + "depth": 1, + "scope": "api", + "anchor": "gettestcontext", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "timers:958d8284adff", "chapter": "timers", @@ -64716,6 +68775,29 @@ "verification": "registry-gap" } }, + { + "id": "tls:0961fd354257", + "chapter": "tls", + "kind": "string|boolean|null", + "name": "Type", + "signature": "`alpnProtocol` Type: {string|boolean|null}", + "label": "alpnProtocol", + "apiSymbol": "alpnProtocol", + "depth": 2, + "scope": "api", + "anchor": "class-tlstlssocket", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "tls:f2e0cdec5975", "chapter": "tls", @@ -64900,6 +68982,29 @@ "verification": "registry-gap" } }, + { + "id": "tls:66d9155a5c20", + "chapter": "tls", + "kind": "string|boolean|null", + "name": "Type", + "signature": "`servername` Type: {string|boolean|null}", + "label": "servername", + "apiSymbol": "servername", + "depth": 2, + "scope": "api", + "anchor": "class-tlstlssocket", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "tls:c5970763c4f8", "chapter": "tls", @@ -65222,6 +69327,29 @@ "verification": "registry-gap" } }, + { + "id": "tls:5a3cdc74e2b5", + "chapter": "tls", + "kind": "method", + "name": "getCertificateCompressionAlgorithms", + "signature": "`tls.getCertificateCompressionAlgorithms()`", + "label": "tls.getCertificateCompressionAlgorithms()", + "apiSymbol": "tls.getCertificateCompressionAlgorithms", + "depth": 1, + "scope": "api", + "anchor": "tlsgetcertificatecompressionalgorithms", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "tls:df163bf0e931", "chapter": "tls", @@ -65659,6 +69787,29 @@ "verification": "test-backed" } }, + { + "id": "tty:85fc0b85d933", + "chapter": "tty", + "kind": "boolean|string", + "name": "rawMode", + "signature": "`rawMode` {boolean|string}", + "label": "rawMode", + "apiSymbol": "rawMode", + "depth": 2, + "scope": "api", + "anchor": "class-ttyreadstream", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "tty:cdef680b84c7", "chapter": "tty", @@ -66188,6 +70339,29 @@ "verification": "test-backed" } }, + { + "id": "dgram:283dec88737f", + "chapter": "dgram", + "kind": "method", + "name": "bindSync", + "signature": "`socket.bindSync([options])`", + "label": "socket.bindSync([options])", + "apiSymbol": "socket.bindSync", + "depth": 2, + "scope": "api", + "anchor": "socketbindsyncoptions", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "dgram:40eeb2e82c2b", "chapter": "dgram", @@ -66257,6 +70431,29 @@ "verification": "test-backed" } }, + { + "id": "dgram:e4bb4d698b04", + "chapter": "dgram", + "kind": "method", + "name": "connectSync", + "signature": "`socket.connectSync(port[, address])`", + "label": "socket.connectSync(port[, address])", + "apiSymbol": "socket.connectSync", + "depth": 2, + "scope": "api", + "anchor": "socketconnectsyncport-address", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "dgram:c2008af7f485", "chapter": "dgram", @@ -68350,6 +72547,29 @@ "verification": "registry-gap" } }, + { + "id": "util:78d79ebcd11e", + "chapter": "util", + "kind": "method", + "name": "parse", + "signature": "`MIMEType.parse(string)`", + "label": "MIMEType.parse(string)", + "apiSymbol": "MIMEType.parse", + "depth": 2, + "scope": "api", + "anchor": "mimetypeparsestring", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "util:f1c74a06ab01", "chapter": "util", @@ -69017,6 +73237,52 @@ "verification": "test-backed" } }, + { + "id": "util:90257f3f102f", + "chapter": "util", + "kind": "method", + "name": "debounce", + "signature": "`util.debounce(fn, wait[, options])`", + "label": "util.debounce(fn, wait[, options])", + "apiSymbol": "util.debounce", + "depth": 1, + "scope": "api", + "anchor": "utildebouncefn-wait-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "util:0cc4a80eb7db", + "chapter": "util", + "kind": "method", + "name": "throttle", + "signature": "`util.throttle(fn, limit, interval[, options])`", + "label": "util.throttle(fn, limit, interval[, options])", + "apiSymbol": "util.throttle", + "depth": 1, + "scope": "api", + "anchor": "utilthrottlefn-limit-interval-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "util:dd79eb4f9e99", "chapter": "util", @@ -69362,6 +73628,29 @@ "verification": "test-backed" } }, + { + "id": "util:e9e90e65a33a", + "chapter": "util", + "kind": "method", + "name": "markPromiseAsHandled", + "signature": "`util.markPromiseAsHandled(promise)`", + "label": "util.markPromiseAsHandled(promise)", + "apiSymbol": "util.markPromiseAsHandled", + "depth": 1, + "scope": "api", + "anchor": "utilmarkpromiseashandledpromise", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "util:96bd98b2e0c0", "chapter": "util", @@ -73738,11 +78027,11 @@ } }, { - "id": "webcrypto:348599f69c92", + "id": "webcrypto:f03c4c689ade", "chapter": "webcrypto", "kind": "string", "name": "Type", - "signature": "`name` Type: {string} Must be `Ed448`[^secure-curves], `'ML-DSA-44'`[^modern-algos], `'ML-DSA-65'`[^modern-algos], or `'ML-DSA-87'`[^modern-algos].", + "signature": "`name` Type: {string} Must be `'Ed448'`[^secure-curves], `'ML-DSA-44'`[^modern-algos], `'ML-DSA-65'`[^modern-algos], or `'ML-DSA-87'`[^modern-algos].", "label": "name", "apiSymbol": "name", "depth": 2, @@ -73807,11 +78096,11 @@ } }, { - "id": "webcrypto:e97ed4559769", + "id": "webcrypto:fbbc457c6c6e", "chapter": "webcrypto", "kind": "string", "name": "Type", - "signature": "`name` Type: {string} Must be `'cSHAKE128'`[^modern-algos] or `'cSHAKE256'`[^modern-algos]", + "signature": "`name` Type: {string} Must be `'cSHAKE128'`[^modern-algos] or `'cSHAKE256'`[^modern-algos].", "label": "name", "apiSymbol": "name", "depth": 2, @@ -74818,6 +79107,98 @@ "verification": "registry-gap" } }, + { + "id": "webcrypto:2bc7e9909260", + "chapter": "webcrypto", + "kind": "class", + "name": "KangarooTwelveParams", + "signature": "Class: `KangarooTwelveParams`", + "label": "KangarooTwelveParams", + "apiSymbol": "KangarooTwelveParams", + "depth": 1, + "scope": "api", + "anchor": "class-kangarootwelveparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "webcrypto:2f2a2546b394", + "chapter": "webcrypto", + "kind": "ArrayBuffer|TypedArray|DataView|Buffer|undefined", + "name": "Type", + "signature": "`customization` Type: {ArrayBuffer|TypedArray|DataView|Buffer|undefined}", + "label": "customization", + "apiSymbol": "customization", + "depth": 2, + "scope": "api", + "anchor": "class-kangarootwelveparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "webcrypto:f70b118f8060", + "chapter": "webcrypto", + "kind": "string", + "name": "Type", + "signature": "`name` Type: {string} Must be `'KT128'`[^modern-algos] or `'KT256'`[^modern-algos]", + "label": "name", + "apiSymbol": "name", + "depth": 2, + "scope": "api", + "anchor": "class-kangarootwelveparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "webcrypto:0c10b01b7537", + "chapter": "webcrypto", + "kind": "number", + "name": "Type", + "signature": "`outputLength` Type: {number} represents the requested output length in bits.", + "label": "outputLength", + "apiSymbol": "outputLength", + "depth": 2, + "scope": "api", + "anchor": "class-kangarootwelveparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "webcrypto:fd89bc275372", "chapter": "webcrypto", @@ -75072,11 +79453,11 @@ } }, { - "id": "webcrypto:82fe1baefa90", + "id": "webcrypto:02a1dd7526a6", "chapter": "webcrypto", "kind": "number", "name": "Type", - "signature": "`outputLength` Type: {number}", + "signature": "`outputLength` Type: {number} represents the requested output length in bits.", "label": "outputLength", "apiSymbol": "outputLength", "depth": 2, @@ -75669,6 +80050,98 @@ "verification": "registry-gap" } }, + { + "id": "webcrypto:077e576b19c6", + "chapter": "webcrypto", + "kind": "class", + "name": "TurboShakeParams", + "signature": "Class: `TurboShakeParams`", + "label": "TurboShakeParams", + "apiSymbol": "TurboShakeParams", + "depth": 1, + "scope": "api", + "anchor": "class-turboshakeparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "webcrypto:080709a8f851", + "chapter": "webcrypto", + "kind": "number|undefined", + "name": "Type", + "signature": "`domainSeparation` Type: {number|undefined}", + "label": "domainSeparation", + "apiSymbol": "domainSeparation", + "depth": 2, + "scope": "api", + "anchor": "class-turboshakeparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "webcrypto:ba3db2b61ce3", + "chapter": "webcrypto", + "kind": "string", + "name": "Type", + "signature": "`name` Type: {string} Must be `'TurboSHAKE128'`[^modern-algos] or `'TurboSHAKE256'`[^modern-algos]", + "label": "name", + "apiSymbol": "name", + "depth": 2, + "scope": "api", + "anchor": "class-turboshakeparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "webcrypto:0797ed062eb1", + "chapter": "webcrypto", + "kind": "number", + "name": "Type", + "signature": "`outputLength` Type: {number} represents the requested output length in bits.", + "label": "outputLength", + "apiSymbol": "outputLength", + "depth": 2, + "scope": "api", + "anchor": "class-turboshakeparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "webcrypto:92a3a1223e3b", "chapter": "webcrypto", @@ -75992,16 +80465,16 @@ } }, { - "id": "webcrypto:d8f38474b5e5", + "id": "webcrypto:282fa1aa9829", "chapter": "webcrypto", "kind": "method", "name": "decapsulateKey", - "signature": "`subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, usages)`", - "label": "subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, usages)", + "signature": "`subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, keyUsages)`", + "label": "subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, keyUsages)", "apiSymbol": "subtle.decapsulateKey", "depth": 2, "scope": "api", - "anchor": "subtledecapsulatekeydecapsulationalgorithm-decapsulationkey-ciphertext-sharedkeyalgorithm-extractable-usages", + "anchor": "subtledecapsulatekeydecapsulationalgorithm-decapsulationkey-ciphertext-sharedkeyalgorithm-extractable-keyusages", "nodeStability": { "index": "1.1", "level": 1, @@ -76061,16 +80534,16 @@ } }, { - "id": "webcrypto:8618a4716426", + "id": "webcrypto:3790d3167cb1", "chapter": "webcrypto", "kind": "method", "name": "deriveKey", - "signature": "`subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)`", - "label": "subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)", + "signature": "`subtle.deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages)`", + "label": "subtle.deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages)", "apiSymbol": "subtle.deriveKey", "depth": 2, "scope": "api", - "anchor": "subtlederivekeyalgorithm-basekey-derivedkeyalgorithm-extractable-keyusages", + "anchor": "subtlederivekeyalgorithm-basekey-derivedkeytype-extractable-keyusages", "nodeStability": { "index": "2", "level": 2, @@ -76130,16 +80603,16 @@ } }, { - "id": "webcrypto:5e146a8a6347", + "id": "webcrypto:097ba43bcee4", "chapter": "webcrypto", "kind": "method", "name": "encapsulateKey", - "signature": "`subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, usages)`", - "label": "subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, usages)", + "signature": "`subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, keyUsages)`", + "label": "subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, keyUsages)", "apiSymbol": "subtle.encapsulateKey", "depth": 2, "scope": "api", - "anchor": "subtleencapsulatekeyencapsulationalgorithm-encapsulationkey-sharedkeyalgorithm-extractable-usages", + "anchor": "subtleencapsulatekeyencapsulationalgorithm-encapsulationkey-sharedkeyalgorithm-extractable-keyusages", "nodeStability": { "index": "1.1", "level": 1, @@ -76291,16 +80764,16 @@ } }, { - "id": "webcrypto:67f9b9466d2c", + "id": "webcrypto:4109de4ba359", "chapter": "webcrypto", "kind": "method", "name": "unwrapKey", - "signature": "`subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgo, unwrappedKeyAlgo, extractable, keyUsages)`", - "label": "subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgo, unwrappedKeyAlgo, extractable, keyUsages)", + "signature": "`subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages)`", + "label": "subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages)", "apiSymbol": "subtle.unwrapKey", "depth": 2, "scope": "api", - "anchor": "subtleunwrapkeyformat-wrappedkey-unwrappingkey-unwrapalgo-unwrappedkeyalgo-extractable-keyusages", + "anchor": "subtleunwrapkeyformat-wrappedkey-unwrappingkey-unwrapalgorithm-unwrappedkeyalgorithm-extractable-keyusages", "nodeStability": { "index": "2", "level": 2, @@ -76337,16 +80810,16 @@ } }, { - "id": "webcrypto:62ec6d9ec96a", + "id": "webcrypto:25faa11630ae", "chapter": "webcrypto", "kind": "method", "name": "wrapKey", - "signature": "`subtle.wrapKey(format, key, wrappingKey, wrapAlgo)`", - "label": "subtle.wrapKey(format, key, wrappingKey, wrapAlgo)", + "signature": "`subtle.wrapKey(format, key, wrappingKey, wrapAlgorithm)`", + "label": "subtle.wrapKey(format, key, wrappingKey, wrapAlgorithm)", "apiSymbol": "subtle.wrapKey", "depth": 2, "scope": "api", - "anchor": "subtlewrapkeyformat-key-wrappingkey-wrapalgo", + "anchor": "subtlewrapkeyformat-key-wrappingkey-wrapalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -78360,6 +82833,29 @@ "verification": "registry-gap" } }, + { + "id": "webstreams:5a92c91c4929", + "chapter": "webstreams", + "kind": "method", + "name": "ReadableStreamTee", + "signature": "`ReadableStreamTee(stream[, cloneForBranch2])`", + "label": "ReadableStreamTee(stream[, cloneForBranch2])", + "apiSymbol": "ReadableStreamTee", + "depth": 1, + "scope": "api", + "anchor": "readablestreamteestream-cloneforbranch2", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "webstreams:4c7d9f984091", "chapter": "webstreams", @@ -79924,6 +84420,374 @@ "verification": "derived" } }, + { + "id": "zlib:b33e2218a29a", + "chapter": "zlib", + "kind": "method", + "name": "compressBrotli", + "signature": "`compressBrotli([options])`", + "label": "compressBrotli([options])", + "apiSymbol": "compressBrotli", + "depth": 1, + "scope": "api", + "anchor": "compressbrotlioptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:f52bcb0441b4", + "chapter": "zlib", + "kind": "method", + "name": "compressBrotliSync", + "signature": "`compressBrotliSync([options])`", + "label": "compressBrotliSync([options])", + "apiSymbol": "compressBrotliSync", + "depth": 1, + "scope": "api", + "anchor": "compressbrotlisyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:5d9b6e75680e", + "chapter": "zlib", + "kind": "method", + "name": "compressDeflate", + "signature": "`compressDeflate([options])`", + "label": "compressDeflate([options])", + "apiSymbol": "compressDeflate", + "depth": 1, + "scope": "api", + "anchor": "compressdeflateoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:2f423bd21cab", + "chapter": "zlib", + "kind": "method", + "name": "compressDeflateSync", + "signature": "`compressDeflateSync([options])`", + "label": "compressDeflateSync([options])", + "apiSymbol": "compressDeflateSync", + "depth": 1, + "scope": "api", + "anchor": "compressdeflatesyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:14600f289b64", + "chapter": "zlib", + "kind": "method", + "name": "compressGzip", + "signature": "`compressGzip([options])`", + "label": "compressGzip([options])", + "apiSymbol": "compressGzip", + "depth": 1, + "scope": "api", + "anchor": "compressgzipoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:7354fd8fdadf", + "chapter": "zlib", + "kind": "method", + "name": "compressGzipSync", + "signature": "`compressGzipSync([options])`", + "label": "compressGzipSync([options])", + "apiSymbol": "compressGzipSync", + "depth": 1, + "scope": "api", + "anchor": "compressgzipsyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:c1b6e7dd5506", + "chapter": "zlib", + "kind": "method", + "name": "compressZstd", + "signature": "`compressZstd([options])`", + "label": "compressZstd([options])", + "apiSymbol": "compressZstd", + "depth": 1, + "scope": "api", + "anchor": "compresszstdoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:3ed321c39c37", + "chapter": "zlib", + "kind": "method", + "name": "compressZstdSync", + "signature": "`compressZstdSync([options])`", + "label": "compressZstdSync([options])", + "apiSymbol": "compressZstdSync", + "depth": 1, + "scope": "api", + "anchor": "compresszstdsyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:2c89860f52a5", + "chapter": "zlib", + "kind": "method", + "name": "decompressBrotli", + "signature": "`decompressBrotli([options])`", + "label": "decompressBrotli([options])", + "apiSymbol": "decompressBrotli", + "depth": 1, + "scope": "api", + "anchor": "decompressbrotlioptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:cb37070b5ee0", + "chapter": "zlib", + "kind": "method", + "name": "decompressBrotliSync", + "signature": "`decompressBrotliSync([options])`", + "label": "decompressBrotliSync([options])", + "apiSymbol": "decompressBrotliSync", + "depth": 1, + "scope": "api", + "anchor": "decompressbrotlisyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:d829a0b75f6c", + "chapter": "zlib", + "kind": "method", + "name": "decompressDeflate", + "signature": "`decompressDeflate([options])`", + "label": "decompressDeflate([options])", + "apiSymbol": "decompressDeflate", + "depth": 1, + "scope": "api", + "anchor": "decompressdeflateoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:f1a96211af38", + "chapter": "zlib", + "kind": "method", + "name": "decompressDeflateSync", + "signature": "`decompressDeflateSync([options])`", + "label": "decompressDeflateSync([options])", + "apiSymbol": "decompressDeflateSync", + "depth": 1, + "scope": "api", + "anchor": "decompressdeflatesyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:b1209d1fe9bf", + "chapter": "zlib", + "kind": "method", + "name": "decompressGzip", + "signature": "`decompressGzip([options])`", + "label": "decompressGzip([options])", + "apiSymbol": "decompressGzip", + "depth": 1, + "scope": "api", + "anchor": "decompressgzipoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:955fb7cb393c", + "chapter": "zlib", + "kind": "method", + "name": "decompressGzipSync", + "signature": "`decompressGzipSync([options])`", + "label": "decompressGzipSync([options])", + "apiSymbol": "decompressGzipSync", + "depth": 1, + "scope": "api", + "anchor": "decompressgzipsyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:d9ea319f8e5e", + "chapter": "zlib", + "kind": "method", + "name": "decompressZstd", + "signature": "`decompressZstd([options])`", + "label": "decompressZstd([options])", + "apiSymbol": "decompressZstd", + "depth": 1, + "scope": "api", + "anchor": "decompresszstdoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, + { + "id": "zlib:e0d0e947882d", + "chapter": "zlib", + "kind": "method", + "name": "decompressZstdSync", + "signature": "`decompressZstdSync([options])`", + "label": "decompressZstdSync([options])", + "apiSymbol": "decompressZstdSync", + "depth": 1, + "scope": "api", + "anchor": "decompresszstdsyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "detail": "No static compiler lowering is registered for this API yet.", + "verification": "registry-gap" + } + }, { "id": "zlib:4b20a6571ae3", "chapter": "zlib", @@ -81063,10 +85927,10 @@ "scope": "api", "anchor": "zlibzstddecompressbuffer-options-callback", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false }, "static": { "status": "not-implemented", @@ -81661,10 +86525,10 @@ "scope": "api", "anchor": "convenience-methods", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false }, "static": { "status": "not-implemented", diff --git a/internal/compatibility/generated/node-v24-backlog.json b/internal/compatibility/generated/node-v24-backlog.json index c745613fe6..e220f1eff0 100644 --- a/internal/compatibility/generated/node-v24-backlog.json +++ b/internal/compatibility/generated/node-v24-backlog.json @@ -1,23 +1,23 @@ { "schemaVersion": 1, - "nodeVersion": "24.15.0", - "nodeCommit": "848430679556aed0bd073f2bc263331ad84fa119", + "nodeVersion": "24.22.0", + "nodeCommit": "f14cd3aa7bf9ca8df2cc5b8bb14beb0f335b1d93", "summary": { - "taskCount": 3270, - "tierItemCount": 3270, + "taskCount": 3486, + "tierItemCount": 3486, "tiers": { "static": { "replace-refusal": 40, - "verify-gap": 2277, - "audit-partial": 871, + "verify-gap": 2489, + "audit-partial": 870, "classify": 2, - "implement": 80 + "implement": 85 } }, "priorities": { - "high": 2225, - "normal": 673, - "low": 372 + "high": 2303, + "normal": 710, + "low": 473 } }, "tasks": [ @@ -27,7 +27,7 @@ "label": "assert.AssertionError", "signature": "Class: `assert.AssertionError`", "apiSymbol": "assert.AssertionError", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#class-assertassertionerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#class-assertassertionerror", "nodeStability": { "index": "2", "level": 2, @@ -52,7 +52,7 @@ "label": "assert.Assert", "signature": "Class: `assert.Assert`", "apiSymbol": "assert.Assert", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#class-assertassert", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#class-assertassert", "nodeStability": { "index": "2", "level": 2, @@ -77,7 +77,7 @@ "label": "assert.CallTracker", "signature": "Class: `assert.CallTracker`", "apiSymbol": "assert.CallTracker", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#class-assertcalltracker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#class-assertcalltracker", "nodeStability": { "index": "0", "level": 0, @@ -102,7 +102,7 @@ "label": "tracker.calls([fn][, exact])", "signature": "`tracker.calls([fn][, exact])`", "apiSymbol": "tracker.calls", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#trackercallsfn-exact", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#trackercallsfn-exact", "nodeStability": { "index": "0", "level": 0, @@ -127,7 +127,7 @@ "label": "tracker.getCalls(fn)", "signature": "`tracker.getCalls(fn)`", "apiSymbol": "tracker.getCalls", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#trackergetcallsfn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#trackergetcallsfn", "nodeStability": { "index": "0", "level": 0, @@ -152,7 +152,7 @@ "label": "tracker.report()", "signature": "`tracker.report()`", "apiSymbol": "tracker.report", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#trackerreport", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#trackerreport", "nodeStability": { "index": "0", "level": 0, @@ -177,7 +177,7 @@ "label": "tracker.reset([fn])", "signature": "`tracker.reset([fn])`", "apiSymbol": "tracker.reset", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#trackerresetfn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#trackerresetfn", "nodeStability": { "index": "0", "level": 0, @@ -202,7 +202,7 @@ "label": "tracker.verify()", "signature": "`tracker.verify()`", "apiSymbol": "tracker.verify", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#trackerverify", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#trackerverify", "nodeStability": { "index": "0", "level": 0, @@ -227,7 +227,7 @@ "label": "assert(value[, message])", "signature": "`assert(value[, message])`", "apiSymbol": "assert", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertvalue-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertvalue-message", "nodeStability": { "index": "2", "level": 2, @@ -258,7 +258,7 @@ "label": "assert.deepEqual(actual, expected[, message])", "signature": "`assert.deepEqual(actual, expected[, message])`", "apiSymbol": "assert.deepEqual", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertdeepequalactual-expected-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertdeepequalactual-expected-message", "nodeStability": { "index": "2", "level": 2, @@ -283,7 +283,7 @@ "label": "assert.deepStrictEqual(actual, expected[, message])", "signature": "`assert.deepStrictEqual(actual, expected[, message])`", "apiSymbol": "assert.deepStrictEqual", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertdeepstrictequalactual-expected-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertdeepstrictequalactual-expected-message", "nodeStability": { "index": "2", "level": 2, @@ -314,7 +314,7 @@ "label": "assert.doesNotMatch(string, regexp[, message])", "signature": "`assert.doesNotMatch(string, regexp[, message])`", "apiSymbol": "assert.doesNotMatch", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertdoesnotmatchstring-regexp-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertdoesnotmatchstring-regexp-message", "nodeStability": { "index": "2", "level": 2, @@ -345,7 +345,7 @@ "label": "assert.doesNotReject(asyncFn[, error][, message])", "signature": "`assert.doesNotReject(asyncFn[, error][, message])`", "apiSymbol": "assert.doesNotReject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertdoesnotrejectasyncfn-error-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertdoesnotrejectasyncfn-error-message", "nodeStability": { "index": "2", "level": 2, @@ -376,7 +376,7 @@ "label": "assert.doesNotThrow(fn[, error][, message])", "signature": "`assert.doesNotThrow(fn[, error][, message])`", "apiSymbol": "assert.doesNotThrow", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertdoesnotthrowfn-error-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertdoesnotthrowfn-error-message", "nodeStability": { "index": "2", "level": 2, @@ -407,7 +407,7 @@ "label": "assert.equal(actual, expected[, message])", "signature": "`assert.equal(actual, expected[, message])`", "apiSymbol": "assert.equal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertequalactual-expected-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertequalactual-expected-message", "nodeStability": { "index": "2", "level": 2, @@ -438,7 +438,7 @@ "label": "assert.fail([message])", "signature": "`assert.fail([message])`", "apiSymbol": "assert.fail", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertfailmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertfailmessage", "nodeStability": { "index": "2", "level": 2, @@ -469,7 +469,7 @@ "label": "assert.fail(actual, expected[, message[, operator[, stackStartFn]]])", "signature": "`assert.fail(actual, expected[, message[, operator[, stackStartFn]]])`", "apiSymbol": "assert.fail", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertfailactual-expected-message-operator-stackstartfn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertfailactual-expected-message-operator-stackstartfn", "nodeStability": { "index": "0", "level": 0, @@ -500,7 +500,7 @@ "label": "assert.ifError(value)", "signature": "`assert.ifError(value)`", "apiSymbol": "assert.ifError", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertiferrorvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertiferrorvalue", "nodeStability": { "index": "2", "level": 2, @@ -531,7 +531,7 @@ "label": "assert.match(string, regexp[, message])", "signature": "`assert.match(string, regexp[, message])`", "apiSymbol": "assert.match", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertmatchstring-regexp-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertmatchstring-regexp-message", "nodeStability": { "index": "2", "level": 2, @@ -562,7 +562,7 @@ "label": "assert.notDeepEqual(actual, expected[, message])", "signature": "`assert.notDeepEqual(actual, expected[, message])`", "apiSymbol": "assert.notDeepEqual", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertnotdeepequalactual-expected-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertnotdeepequalactual-expected-message", "nodeStability": { "index": "2", "level": 2, @@ -587,7 +587,7 @@ "label": "assert.notDeepStrictEqual(actual, expected[, message])", "signature": "`assert.notDeepStrictEqual(actual, expected[, message])`", "apiSymbol": "assert.notDeepStrictEqual", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertnotdeepstrictequalactual-expected-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertnotdeepstrictequalactual-expected-message", "nodeStability": { "index": "2", "level": 2, @@ -618,7 +618,7 @@ "label": "assert.notEqual(actual, expected[, message])", "signature": "`assert.notEqual(actual, expected[, message])`", "apiSymbol": "assert.notEqual", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertnotequalactual-expected-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertnotequalactual-expected-message", "nodeStability": { "index": "2", "level": 2, @@ -649,7 +649,7 @@ "label": "assert.notStrictEqual(actual, expected[, message])", "signature": "`assert.notStrictEqual(actual, expected[, message])`", "apiSymbol": "assert.notStrictEqual", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertnotstrictequalactual-expected-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertnotstrictequalactual-expected-message", "nodeStability": { "index": "2", "level": 2, @@ -680,7 +680,7 @@ "label": "assert.ok(value[, message])", "signature": "`assert.ok(value[, message])`", "apiSymbol": "assert.ok", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertokvalue-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertokvalue-message", "nodeStability": { "index": "2", "level": 2, @@ -711,7 +711,7 @@ "label": "assert.rejects(asyncFn[, error][, message])", "signature": "`assert.rejects(asyncFn[, error][, message])`", "apiSymbol": "assert.rejects", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertrejectsasyncfn-error-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertrejectsasyncfn-error-message", "nodeStability": { "index": "2", "level": 2, @@ -742,7 +742,7 @@ "label": "assert.strictEqual(actual, expected[, message])", "signature": "`assert.strictEqual(actual, expected[, message])`", "apiSymbol": "assert.strictEqual", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertstrictequalactual-expected-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertstrictequalactual-expected-message", "nodeStability": { "index": "2", "level": 2, @@ -773,7 +773,7 @@ "label": "assert.throws(fn[, error][, message])", "signature": "`assert.throws(fn[, error][, message])`", "apiSymbol": "assert.throws", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertthrowsfn-error-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertthrowsfn-error-message", "nodeStability": { "index": "2", "level": 2, @@ -804,7 +804,7 @@ "label": "assert.partialDeepStrictEqual(actual, expected[, message])", "signature": "`assert.partialDeepStrictEqual(actual, expected[, message])`", "apiSymbol": "assert.partialDeepStrictEqual", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/assert.html#assertpartialdeepstrictequalactual-expected-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/assert.html#assertpartialdeepstrictequalactual-expected-message", "nodeStability": { "index": "2", "level": 2, @@ -829,7 +829,7 @@ "label": "AsyncLocalStorage", "signature": "Class: `AsyncLocalStorage`", "apiSymbol": "AsyncLocalStorage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#class-asynclocalstorage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#class-asynclocalstorage", "nodeStability": { "index": "2", "level": 2, @@ -856,7 +856,7 @@ "label": "Usage with async/await", "signature": "Usage with `async/await`", "apiSymbol": "async/await", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#usage-with-asyncawait", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#usage-with-asyncawait", "nodeStability": { "index": "2", "level": 2, @@ -881,7 +881,7 @@ "label": "asyncLocalStorage.disable()", "signature": "`asyncLocalStorage.disable()`", "apiSymbol": "asyncLocalStorage.disable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#asynclocalstoragedisable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#asynclocalstoragedisable", "nodeStability": { "index": "1", "level": 1, @@ -908,7 +908,7 @@ "label": "asyncLocalStorage.getStore()", "signature": "`asyncLocalStorage.getStore()`", "apiSymbol": "asyncLocalStorage.getStore", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#asynclocalstoragegetstore", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#asynclocalstoragegetstore", "nodeStability": { "index": "2", "level": 2, @@ -935,7 +935,7 @@ "label": "asyncLocalStorage.enterWith(store)", "signature": "`asyncLocalStorage.enterWith(store)`", "apiSymbol": "asyncLocalStorage.enterWith", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#asynclocalstorageenterwithstore", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#asynclocalstorageenterwithstore", "nodeStability": { "index": "1", "level": 1, @@ -962,7 +962,7 @@ "label": "asyncLocalStorage.run(store, callback[, ...args])", "signature": "`asyncLocalStorage.run(store, callback[, ...args])`", "apiSymbol": "asyncLocalStorage.run", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#asynclocalstoragerunstore-callback-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#asynclocalstoragerunstore-callback-args", "nodeStability": { "index": "2", "level": 2, @@ -989,7 +989,7 @@ "label": "asyncLocalStorage.exit(callback[, ...args])", "signature": "`asyncLocalStorage.exit(callback[, ...args])`", "apiSymbol": "asyncLocalStorage.exit", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#asynclocalstorageexitcallback-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#asynclocalstorageexitcallback-args", "nodeStability": { "index": "1", "level": 1, @@ -1010,13 +1010,38 @@ } } }, + { + "id": "async_context:1da031ae1416", + "chapter": "async_context", + "label": "asyncLocalStorage.withScope(store)", + "signature": "`asyncLocalStorage.withScope(store)`", + "apiSymbol": "asyncLocalStorage.withScope", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#asynclocalstoragewithscopestore", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:async_context", + "tests": [] + } + } + }, { "id": "async_context:c3f9e759e7a3", "chapter": "async_context", "label": "name", "signature": "`name` Type: {string}", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#class-asynclocalstorage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#class-asynclocalstorage", "nodeStability": { "index": "2", "level": 2, @@ -1035,13 +1060,63 @@ } } }, + { + "id": "async_context:f017c310f23c", + "chapter": "async_context", + "label": "RunScope", + "signature": "Class: `RunScope`", + "apiSymbol": "RunScope", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#class-runscope", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:async_context", + "tests": [] + } + } + }, + { + "id": "async_context:61f0464afb64", + "chapter": "async_context", + "label": "scope.dispose()", + "signature": "`scope.dispose()`", + "apiSymbol": "scope.dispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#scopedispose", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:async_context", + "tests": [] + } + } + }, { "id": "async_context:509d8ed918da", "chapter": "async_context", "label": "AsyncResource", "signature": "Class: `AsyncResource`", "apiSymbol": "AsyncResource", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#class-asyncresource", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#class-asyncresource", "nodeStability": { "index": "2", "level": 2, @@ -1066,7 +1141,7 @@ "label": "Using AsyncResource for a Worker thread pool", "signature": "Using `AsyncResource` for a `Worker` thread pool", "apiSymbol": "AsyncResource", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#using-asyncresource-for-a-worker-thread-pool", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#using-asyncresource-for-a-worker-thread-pool", "nodeStability": { "index": "2", "level": 2, @@ -1091,7 +1166,7 @@ "label": "Integrating AsyncResource with EventEmitter", "signature": "Integrating `AsyncResource` with `EventEmitter`", "apiSymbol": "AsyncResource", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#integrating-asyncresource-with-eventemitter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#integrating-asyncresource-with-eventemitter", "nodeStability": { "index": "2", "level": 2, @@ -1116,7 +1191,7 @@ "label": "asyncResource.bind(fn[, thisArg])", "signature": "`asyncResource.bind(fn[, thisArg])`", "apiSymbol": "asyncResource.bind", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#asyncresourcebindfn-thisarg", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#asyncresourcebindfn-thisarg", "nodeStability": { "index": "2", "level": 2, @@ -1141,7 +1216,7 @@ "label": "asyncResource.runInAsyncScope(fn[, thisArg, ...args])", "signature": "`asyncResource.runInAsyncScope(fn[, thisArg, ...args])`", "apiSymbol": "asyncResource.runInAsyncScope", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#asyncresourceruninasyncscopefn-thisarg-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#asyncresourceruninasyncscopefn-thisarg-args", "nodeStability": { "index": "2", "level": 2, @@ -1166,7 +1241,7 @@ "label": "asyncResource.emitDestroy()", "signature": "`asyncResource.emitDestroy()`", "apiSymbol": "asyncResource.emitDestroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#asyncresourceemitdestroy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#asyncresourceemitdestroy", "nodeStability": { "index": "2", "level": 2, @@ -1191,7 +1266,7 @@ "label": "asyncResource.asyncId()", "signature": "`asyncResource.asyncId()`", "apiSymbol": "asyncResource.asyncId", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#asyncresourceasyncid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#asyncresourceasyncid", "nodeStability": { "index": "2", "level": 2, @@ -1216,7 +1291,7 @@ "label": "asyncResource.triggerAsyncId()", "signature": "`asyncResource.triggerAsyncId()`", "apiSymbol": "asyncResource.triggerAsyncId", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_context.html#asyncresourcetriggerasyncid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_context.html#asyncresourcetriggerasyncid", "nodeStability": { "index": "2", "level": 2, @@ -1241,7 +1316,7 @@ "label": "AsyncResource", "signature": "Class: `AsyncResource`", "apiSymbol": "AsyncResource", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#class-asyncresource", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#class-asyncresource", "nodeStability": { "index": "1", "level": 1, @@ -1266,7 +1341,7 @@ "label": "AsyncHook", "signature": "Class: `AsyncHook`", "apiSymbol": "AsyncHook", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#class-asynchook", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#class-asynchook", "nodeStability": { "index": "1", "level": 1, @@ -1291,7 +1366,7 @@ "label": "init(asyncId, type, triggerAsyncId, resource)", "signature": "`init(asyncId, type, triggerAsyncId, resource)`", "apiSymbol": "init", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#initasyncid-type-triggerasyncid-resource", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#initasyncid-type-triggerasyncid-resource", "nodeStability": { "index": "1", "level": 1, @@ -1316,7 +1391,7 @@ "label": "type", "signature": "`type`", "apiSymbol": "type", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#type", "nodeStability": { "index": "1", "level": 1, @@ -1341,7 +1416,7 @@ "label": "triggerAsyncId", "signature": "`triggerAsyncId`", "apiSymbol": "triggerAsyncId", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#triggerasyncid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#triggerasyncid", "nodeStability": { "index": "1", "level": 1, @@ -1366,7 +1441,7 @@ "label": "resource", "signature": "`resource`", "apiSymbol": "resource", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#resource", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#resource", "nodeStability": { "index": "1", "level": 1, @@ -1391,7 +1466,7 @@ "label": "before(asyncId)", "signature": "`before(asyncId)`", "apiSymbol": "before", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#beforeasyncid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#beforeasyncid", "nodeStability": { "index": "1", "level": 1, @@ -1418,7 +1493,7 @@ "label": "after(asyncId)", "signature": "`after(asyncId)`", "apiSymbol": "after", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#afterasyncid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#afterasyncid", "nodeStability": { "index": "1", "level": 1, @@ -1445,7 +1520,7 @@ "label": "destroy(asyncId)", "signature": "`destroy(asyncId)`", "apiSymbol": "destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#destroyasyncid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#destroyasyncid", "nodeStability": { "index": "1", "level": 1, @@ -1470,7 +1545,7 @@ "label": "promiseResolve(asyncId)", "signature": "`promiseResolve(asyncId)`", "apiSymbol": "promiseResolve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#promiseresolveasyncid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#promiseresolveasyncid", "nodeStability": { "index": "1", "level": 1, @@ -1495,7 +1570,7 @@ "label": "asyncHook.enable()", "signature": "`asyncHook.enable()`", "apiSymbol": "asyncHook.enable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#asynchookenable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#asynchookenable", "nodeStability": { "index": "1", "level": 1, @@ -1520,7 +1595,7 @@ "label": "asyncHook.disable()", "signature": "`asyncHook.disable()`", "apiSymbol": "asyncHook.disable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#asynchookdisable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#asynchookdisable", "nodeStability": { "index": "1", "level": 1, @@ -1545,7 +1620,7 @@ "label": "async_hooks.executionAsyncResource()", "signature": "`async_hooks.executionAsyncResource()`", "apiSymbol": "async_hooks.executionAsyncResource", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#async_hooksexecutionasyncresource", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#async_hooksexecutionasyncresource", "nodeStability": { "index": "1", "level": 1, @@ -1570,7 +1645,7 @@ "label": "async_hooks.executionAsyncId()", "signature": "`async_hooks.executionAsyncId()`", "apiSymbol": "async_hooks.executionAsyncId", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#async_hooksexecutionasyncid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#async_hooksexecutionasyncid", "nodeStability": { "index": "1", "level": 1, @@ -1595,7 +1670,7 @@ "label": "async_hooks.triggerAsyncId()", "signature": "`async_hooks.triggerAsyncId()`", "apiSymbol": "async_hooks.triggerAsyncId", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#async_hookstriggerasyncid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#async_hookstriggerasyncid", "nodeStability": { "index": "1", "level": 1, @@ -1620,7 +1695,7 @@ "label": "asyncWrapProviders", "signature": "`asyncWrapProviders` Returns: A map of provider types to the corresponding numeric id. This map contains all the event types that might be emitted by the `async_hooks.init()` event.", "apiSymbol": "asyncWrapProviders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#class-asynchook", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#class-asynchook", "nodeStability": { "index": "1", "level": 1, @@ -1645,7 +1720,7 @@ "label": "AsyncLocalStorage", "signature": "Class: `AsyncLocalStorage`", "apiSymbol": "AsyncLocalStorage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#class-asynclocalstorage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#class-asynclocalstorage", "nodeStability": { "index": "1", "level": 1, @@ -1672,7 +1747,7 @@ "label": "async_hooks.createHook(options)", "signature": "`async_hooks.createHook(options)`", "apiSymbol": "async_hooks.createHook", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#async_hookscreatehookoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#async_hookscreatehookoptions", "nodeStability": { "index": "1", "level": 1, @@ -1697,7 +1772,7 @@ "label": "Printing in AsyncHook callbacks", "signature": "Printing in `AsyncHook` callbacks", "apiSymbol": "AsyncHook", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/async_hooks.html#printing-in-asynchook-callbacks", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/async_hooks.html#printing-in-asynchook-callbacks", "nodeStability": { "index": "1", "level": 1, @@ -1722,7 +1797,7 @@ "label": "Buffer methods are callable with Uint8Array instances", "signature": "Buffer methods are callable with `Uint8Array` instances", "apiSymbol": "Uint8Array", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#buffer-methods-are-callable-with-uint8array-instances", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#buffer-methods-are-callable-with-uint8array-instances", "nodeStability": { "index": "2", "level": 2, @@ -1747,7 +1822,7 @@ "label": "node:buffer", "signature": "`node:buffer` module APIs", "apiSymbol": "node:buffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#nodebuffer-module-apis", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#nodebuffer-module-apis", "nodeStability": { "index": "2", "level": 2, @@ -1772,7 +1847,7 @@ "label": "MAX_LENGTH", "signature": "`MAX_LENGTH` Type: {integer} The largest size allowed for a single `Buffer` instance.", "apiSymbol": "MAX_LENGTH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#buffer-constants", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#buffer-constants", "nodeStability": { "index": "2", "level": 2, @@ -1797,7 +1872,7 @@ "label": "MAX_STRING_LENGTH", "signature": "`MAX_STRING_LENGTH` Type: {integer} The largest length allowed for a single `string` instance.", "apiSymbol": "MAX_STRING_LENGTH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#buffer-constants", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#buffer-constants", "nodeStability": { "index": "2", "level": 2, @@ -1822,7 +1897,7 @@ "label": "SlowBuffer", "signature": "Class: `SlowBuffer`", "apiSymbol": "SlowBuffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#class-slowbuffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#class-slowbuffer", "nodeStability": { "index": "0", "level": 0, @@ -1847,7 +1922,7 @@ "label": "buffer.atob(data)", "signature": "`buffer.atob(data)`", "apiSymbol": "buffer.atob", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufferatobdata", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufferatobdata", "nodeStability": { "index": "3", "level": 3, @@ -1872,7 +1947,7 @@ "label": "buffer.btoa(data)", "signature": "`buffer.btoa(data)`", "apiSymbol": "buffer.btoa", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufferbtoadata", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufferbtoadata", "nodeStability": { "index": "3", "level": 3, @@ -1897,7 +1972,7 @@ "label": "buffer.isAscii(input)", "signature": "`buffer.isAscii(input)`", "apiSymbol": "buffer.isAscii", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufferisasciiinput", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufferisasciiinput", "nodeStability": { "index": "2", "level": 2, @@ -1926,7 +2001,7 @@ "label": "buffer.isUtf8(input)", "signature": "`buffer.isUtf8(input)`", "apiSymbol": "buffer.isUtf8", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufferisutf8input", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufferisutf8input", "nodeStability": { "index": "2", "level": 2, @@ -1955,7 +2030,7 @@ "label": "buffer.resolveObjectURL(id)", "signature": "`buffer.resolveObjectURL(id)`", "apiSymbol": "buffer.resolveObjectURL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufferresolveobjecturlid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufferresolveobjecturlid", "nodeStability": { "index": "2", "level": 2, @@ -1980,7 +2055,7 @@ "label": "buffer.transcode(source, fromEnc, toEnc)", "signature": "`buffer.transcode(source, fromEnc, toEnc)`", "apiSymbol": "buffer.transcode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#buffertranscodesource-fromenc-toenc", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#buffertranscodesource-fromenc-toenc", "nodeStability": { "index": "2", "level": 2, @@ -2009,7 +2084,7 @@ "label": "INSPECT_MAX_BYTES", "signature": "`INSPECT_MAX_BYTES` Type: {integer} **Default:** `50`", "apiSymbol": "INSPECT_MAX_BYTES", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#nodebuffer-module-apis", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#nodebuffer-module-apis", "nodeStability": { "index": "2", "level": 2, @@ -2034,7 +2109,7 @@ "label": "kMaxLength", "signature": "`kMaxLength` Type: {integer} The largest size allowed for a single `Buffer` instance.", "apiSymbol": "kMaxLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#nodebuffer-module-apis", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#nodebuffer-module-apis", "nodeStability": { "index": "2", "level": 2, @@ -2059,7 +2134,7 @@ "label": "kStringMaxLength", "signature": "`kStringMaxLength` Type: {integer} The largest length allowed for a single `string` instance.", "apiSymbol": "kStringMaxLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#nodebuffer-module-apis", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#nodebuffer-module-apis", "nodeStability": { "index": "2", "level": 2, @@ -2084,7 +2159,7 @@ "label": "Buffer.from()", "signature": "`Buffer.from()`, `Buffer.alloc()`, and `Buffer.allocUnsafe()`", "apiSymbol": "Buffer.from", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufferfrom-bufferalloc-and-bufferallocunsafe", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufferfrom-bufferalloc-and-bufferallocunsafe", "nodeStability": { "index": "2", "level": 2, @@ -2109,7 +2184,7 @@ "label": "What makes Buffer.allocUnsafe() and Buffer.allocUnsafeSlow() \"unsafe\"?", "signature": "What makes `Buffer.allocUnsafe()` and `Buffer.allocUnsafeSlow()` \"unsafe\"?", "apiSymbol": "Buffer.allocUnsafe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#what-makes-bufferallocunsafe-and-bufferallocunsafeslow-unsafe", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#what-makes-bufferallocunsafe-and-bufferallocunsafeslow-unsafe", "nodeStability": { "index": "2", "level": 2, @@ -2134,7 +2209,7 @@ "label": "Blob", "signature": "Class: `Blob`", "apiSymbol": "Blob", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#class-blob", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#class-blob", "nodeStability": { "index": "2", "level": 2, @@ -2159,7 +2234,7 @@ "label": "Blob", "signature": "`Blob` objects and `MessageChannel`", "apiSymbol": "Blob", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#blob-objects-and-messagechannel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#blob-objects-and-messagechannel", "nodeStability": { "index": "2", "level": 2, @@ -2184,7 +2259,7 @@ "label": "blob.arrayBuffer()", "signature": "`blob.arrayBuffer()`", "apiSymbol": "blob.arrayBuffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#blobarraybuffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#blobarraybuffer", "nodeStability": { "index": "2", "level": 2, @@ -2209,7 +2284,7 @@ "label": "blob.bytes()", "signature": "`blob.bytes()`", "apiSymbol": "blob.bytes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#blobbytes", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#blobbytes", "nodeStability": { "index": "2", "level": 2, @@ -2234,7 +2309,7 @@ "label": "blob.slice([start[, end[, type]]])", "signature": "`blob.slice([start[, end[, type]]])`", "apiSymbol": "blob.slice", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#blobslicestart-end-type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#blobslicestart-end-type", "nodeStability": { "index": "2", "level": 2, @@ -2259,7 +2334,7 @@ "label": "blob.stream()", "signature": "`blob.stream()`", "apiSymbol": "blob.stream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#blobstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#blobstream", "nodeStability": { "index": "2", "level": 2, @@ -2284,7 +2359,32 @@ "label": "blob.text()", "signature": "`blob.text()`", "apiSymbol": "blob.text", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#blobtext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#blobtext", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:buffer", + "tests": [] + } + } + }, + { + "id": "buffer:00e095984e8b", + "chapter": "buffer", + "label": "blob.textStream()", + "signature": "`blob.textStream()`", + "apiSymbol": "blob.textStream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#blobtextstream", "nodeStability": { "index": "2", "level": 2, @@ -2309,7 +2409,7 @@ "label": "blob.size", "signature": "`blob.size`", "apiSymbol": "blob.size", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#blobsize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#blobsize", "nodeStability": { "index": "2", "level": 2, @@ -2334,7 +2434,7 @@ "label": "type", "signature": "`type` Type: {string}", "apiSymbol": "type", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#class-blob", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#class-blob", "nodeStability": { "index": "2", "level": 2, @@ -2359,7 +2459,7 @@ "label": "Buffer", "signature": "Class: `Buffer`", "apiSymbol": "Buffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#class-buffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#class-buffer", "nodeStability": { "index": "2", "level": 2, @@ -2384,7 +2484,7 @@ "label": "buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])", "signature": "`buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])`", "apiSymbol": "buf.compare", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufcomparetarget-targetstart-targetend-sourcestart-sourceend", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufcomparetarget-targetstart-targetend-sourcestart-sourceend", "nodeStability": { "index": "2", "level": 2, @@ -2409,7 +2509,7 @@ "label": "buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])", "signature": "`buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])`", "apiSymbol": "buf.copy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufcopytarget-targetstart-sourcestart-sourceend", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufcopytarget-targetstart-sourcestart-sourceend", "nodeStability": { "index": "2", "level": 2, @@ -2434,7 +2534,7 @@ "label": "buf.entries()", "signature": "`buf.entries()`", "apiSymbol": "buf.entries", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufentries", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufentries", "nodeStability": { "index": "2", "level": 2, @@ -2459,7 +2559,7 @@ "label": "buf.equals(otherBuffer)", "signature": "`buf.equals(otherBuffer)`", "apiSymbol": "buf.equals", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufequalsotherbuffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufequalsotherbuffer", "nodeStability": { "index": "2", "level": 2, @@ -2484,7 +2584,7 @@ "label": "buf.fill(value[, offset[, end]][, encoding])", "signature": "`buf.fill(value[, offset[, end]][, encoding])`", "apiSymbol": "buf.fill", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#buffillvalue-offset-end-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#buffillvalue-offset-end-encoding", "nodeStability": { "index": "2", "level": 2, @@ -2504,12 +2604,12 @@ } }, { - "id": "buffer:036238ad6edd", + "id": "buffer:32a0b4015b4d", "chapter": "buffer", - "label": "buf.includes(value[, byteOffset][, encoding])", - "signature": "`buf.includes(value[, byteOffset][, encoding])`", + "label": "buf.includes(value[, start[, end]][, encoding])", + "signature": "`buf.includes(value[, start[, end]][, encoding])`", "apiSymbol": "buf.includes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufincludesvalue-byteoffset-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufincludesvalue-start-end-encoding", "nodeStability": { "index": "2", "level": 2, @@ -2529,12 +2629,12 @@ } }, { - "id": "buffer:4bb2e1c043ab", + "id": "buffer:1b0e4fe87f7d", "chapter": "buffer", - "label": "buf.indexOf(value[, byteOffset][, encoding])", - "signature": "`buf.indexOf(value[, byteOffset][, encoding])`", + "label": "buf.indexOf(value[, start[, end]][, encoding])", + "signature": "`buf.indexOf(value[, start[, end]][, encoding])`", "apiSymbol": "buf.indexOf", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufindexofvalue-byteoffset-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufindexofvalue-start-end-encoding", "nodeStability": { "index": "2", "level": 2, @@ -2559,7 +2659,7 @@ "label": "buf.keys()", "signature": "`buf.keys()`", "apiSymbol": "buf.keys", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufkeys", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufkeys", "nodeStability": { "index": "2", "level": 2, @@ -2579,12 +2679,12 @@ } }, { - "id": "buffer:0f29211b95db", + "id": "buffer:34a6c0cba92a", "chapter": "buffer", - "label": "buf.lastIndexOf(value[, byteOffset][, encoding])", - "signature": "`buf.lastIndexOf(value[, byteOffset][, encoding])`", + "label": "buf.lastIndexOf(value[, start[, end]][, encoding])", + "signature": "`buf.lastIndexOf(value[, start[, end]][, encoding])`", "apiSymbol": "buf.lastIndexOf", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#buflastindexofvalue-byteoffset-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#buflastindexofvalue-start-end-encoding", "nodeStability": { "index": "2", "level": 2, @@ -2609,7 +2709,7 @@ "label": "buf.readDoubleBE([offset])", "signature": "`buf.readDoubleBE([offset])`", "apiSymbol": "buf.readDoubleBE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreaddoublebeoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreaddoublebeoffset", "nodeStability": { "index": "2", "level": 2, @@ -2634,7 +2734,7 @@ "label": "buf.readDoubleLE([offset])", "signature": "`buf.readDoubleLE([offset])`", "apiSymbol": "buf.readDoubleLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreaddoubleleoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreaddoubleleoffset", "nodeStability": { "index": "2", "level": 2, @@ -2659,7 +2759,7 @@ "label": "buf.readFloatBE([offset])", "signature": "`buf.readFloatBE([offset])`", "apiSymbol": "buf.readFloatBE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreadfloatbeoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreadfloatbeoffset", "nodeStability": { "index": "2", "level": 2, @@ -2684,7 +2784,7 @@ "label": "buf.readFloatLE([offset])", "signature": "`buf.readFloatLE([offset])`", "apiSymbol": "buf.readFloatLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreadfloatleoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreadfloatleoffset", "nodeStability": { "index": "2", "level": 2, @@ -2709,7 +2809,7 @@ "label": "buf.readInt8([offset])", "signature": "`buf.readInt8([offset])`", "apiSymbol": "buf.readInt8", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreadint8offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreadint8offset", "nodeStability": { "index": "2", "level": 2, @@ -2734,7 +2834,7 @@ "label": "buf.readInt16BE([offset])", "signature": "`buf.readInt16BE([offset])`", "apiSymbol": "buf.readInt16BE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreadint16beoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreadint16beoffset", "nodeStability": { "index": "2", "level": 2, @@ -2759,7 +2859,7 @@ "label": "buf.readInt16LE([offset])", "signature": "`buf.readInt16LE([offset])`", "apiSymbol": "buf.readInt16LE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreadint16leoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreadint16leoffset", "nodeStability": { "index": "2", "level": 2, @@ -2784,7 +2884,7 @@ "label": "buf.readInt32BE([offset])", "signature": "`buf.readInt32BE([offset])`", "apiSymbol": "buf.readInt32BE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreadint32beoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreadint32beoffset", "nodeStability": { "index": "2", "level": 2, @@ -2809,7 +2909,7 @@ "label": "buf.readInt32LE([offset])", "signature": "`buf.readInt32LE([offset])`", "apiSymbol": "buf.readInt32LE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreadint32leoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreadint32leoffset", "nodeStability": { "index": "2", "level": 2, @@ -2834,7 +2934,7 @@ "label": "buf.readIntBE(offset, byteLength)", "signature": "`buf.readIntBE(offset, byteLength)`", "apiSymbol": "buf.readIntBE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreadintbeoffset-bytelength", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreadintbeoffset-bytelength", "nodeStability": { "index": "2", "level": 2, @@ -2859,7 +2959,7 @@ "label": "buf.readIntLE(offset, byteLength)", "signature": "`buf.readIntLE(offset, byteLength)`", "apiSymbol": "buf.readIntLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreadintleoffset-bytelength", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreadintleoffset-bytelength", "nodeStability": { "index": "2", "level": 2, @@ -2884,7 +2984,7 @@ "label": "buf.readUInt8([offset])", "signature": "`buf.readUInt8([offset])`", "apiSymbol": "buf.readUInt8", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreaduint8offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreaduint8offset", "nodeStability": { "index": "2", "level": 2, @@ -2909,7 +3009,7 @@ "label": "buf.readUInt16BE([offset])", "signature": "`buf.readUInt16BE([offset])`", "apiSymbol": "buf.readUInt16BE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreaduint16beoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreaduint16beoffset", "nodeStability": { "index": "2", "level": 2, @@ -2934,7 +3034,7 @@ "label": "buf.readUInt16LE([offset])", "signature": "`buf.readUInt16LE([offset])`", "apiSymbol": "buf.readUInt16LE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreaduint16leoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreaduint16leoffset", "nodeStability": { "index": "2", "level": 2, @@ -2959,7 +3059,7 @@ "label": "buf.readUInt32BE([offset])", "signature": "`buf.readUInt32BE([offset])`", "apiSymbol": "buf.readUInt32BE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreaduint32beoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreaduint32beoffset", "nodeStability": { "index": "2", "level": 2, @@ -2984,7 +3084,7 @@ "label": "buf.readUInt32LE([offset])", "signature": "`buf.readUInt32LE([offset])`", "apiSymbol": "buf.readUInt32LE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreaduint32leoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreaduint32leoffset", "nodeStability": { "index": "2", "level": 2, @@ -3009,7 +3109,7 @@ "label": "buf.readUIntBE(offset, byteLength)", "signature": "`buf.readUIntBE(offset, byteLength)`", "apiSymbol": "buf.readUIntBE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreaduintbeoffset-bytelength", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreaduintbeoffset-bytelength", "nodeStability": { "index": "2", "level": 2, @@ -3034,7 +3134,7 @@ "label": "buf.readUIntLE(offset, byteLength)", "signature": "`buf.readUIntLE(offset, byteLength)`", "apiSymbol": "buf.readUIntLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufreaduintleoffset-bytelength", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufreaduintleoffset-bytelength", "nodeStability": { "index": "2", "level": 2, @@ -3059,7 +3159,7 @@ "label": "buf.subarray([start[, end]])", "signature": "`buf.subarray([start[, end]])`", "apiSymbol": "buf.subarray", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufsubarraystart-end", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufsubarraystart-end", "nodeStability": { "index": "2", "level": 2, @@ -3084,7 +3184,7 @@ "label": "buf.slice([start[, end]])", "signature": "`buf.slice([start[, end]])`", "apiSymbol": "buf.slice", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufslicestart-end", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufslicestart-end", "nodeStability": { "index": "0", "level": 0, @@ -3109,7 +3209,7 @@ "label": "buf.swap16()", "signature": "`buf.swap16()`", "apiSymbol": "buf.swap16", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufswap16", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufswap16", "nodeStability": { "index": "2", "level": 2, @@ -3134,7 +3234,7 @@ "label": "buf.swap32()", "signature": "`buf.swap32()`", "apiSymbol": "buf.swap32", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufswap32", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufswap32", "nodeStability": { "index": "2", "level": 2, @@ -3159,7 +3259,7 @@ "label": "buf.swap64()", "signature": "`buf.swap64()`", "apiSymbol": "buf.swap64", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufswap64", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufswap64", "nodeStability": { "index": "2", "level": 2, @@ -3184,7 +3284,7 @@ "label": "buf.toJSON()", "signature": "`buf.toJSON()`", "apiSymbol": "buf.toJSON", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#buftojson", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#buftojson", "nodeStability": { "index": "2", "level": 2, @@ -3209,7 +3309,7 @@ "label": "buf.toString([encoding[, start[, end]]])", "signature": "`buf.toString([encoding[, start[, end]]])`", "apiSymbol": "buf.toString", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#buftostringencoding-start-end", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#buftostringencoding-start-end", "nodeStability": { "index": "2", "level": 2, @@ -3234,7 +3334,7 @@ "label": "buf.values()", "signature": "`buf.values()`", "apiSymbol": "buf.values", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufvalues", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufvalues", "nodeStability": { "index": "2", "level": 2, @@ -3259,7 +3359,7 @@ "label": "buf.write(string[, offset[, length]][, encoding])", "signature": "`buf.write(string[, offset[, length]][, encoding])`", "apiSymbol": "buf.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwritestring-offset-length-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwritestring-offset-length-encoding", "nodeStability": { "index": "2", "level": 2, @@ -3284,7 +3384,7 @@ "label": "buf.writeDoubleBE(value[, offset])", "signature": "`buf.writeDoubleBE(value[, offset])`", "apiSymbol": "buf.writeDoubleBE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwritedoublebevalue-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwritedoublebevalue-offset", "nodeStability": { "index": "2", "level": 2, @@ -3309,7 +3409,7 @@ "label": "buf.writeDoubleLE(value[, offset])", "signature": "`buf.writeDoubleLE(value[, offset])`", "apiSymbol": "buf.writeDoubleLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwritedoublelevalue-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwritedoublelevalue-offset", "nodeStability": { "index": "2", "level": 2, @@ -3334,7 +3434,7 @@ "label": "buf.writeFloatBE(value[, offset])", "signature": "`buf.writeFloatBE(value[, offset])`", "apiSymbol": "buf.writeFloatBE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwritefloatbevalue-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwritefloatbevalue-offset", "nodeStability": { "index": "2", "level": 2, @@ -3359,7 +3459,7 @@ "label": "buf.writeFloatLE(value[, offset])", "signature": "`buf.writeFloatLE(value[, offset])`", "apiSymbol": "buf.writeFloatLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwritefloatlevalue-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwritefloatlevalue-offset", "nodeStability": { "index": "2", "level": 2, @@ -3384,7 +3484,7 @@ "label": "buf.writeInt8(value[, offset])", "signature": "`buf.writeInt8(value[, offset])`", "apiSymbol": "buf.writeInt8", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteint8value-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteint8value-offset", "nodeStability": { "index": "2", "level": 2, @@ -3409,7 +3509,7 @@ "label": "buf.writeInt16BE(value[, offset])", "signature": "`buf.writeInt16BE(value[, offset])`", "apiSymbol": "buf.writeInt16BE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteint16bevalue-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteint16bevalue-offset", "nodeStability": { "index": "2", "level": 2, @@ -3434,7 +3534,7 @@ "label": "buf.writeInt16LE(value[, offset])", "signature": "`buf.writeInt16LE(value[, offset])`", "apiSymbol": "buf.writeInt16LE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteint16levalue-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteint16levalue-offset", "nodeStability": { "index": "2", "level": 2, @@ -3459,7 +3559,7 @@ "label": "buf.writeInt32BE(value[, offset])", "signature": "`buf.writeInt32BE(value[, offset])`", "apiSymbol": "buf.writeInt32BE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteint32bevalue-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteint32bevalue-offset", "nodeStability": { "index": "2", "level": 2, @@ -3484,7 +3584,7 @@ "label": "buf.writeInt32LE(value[, offset])", "signature": "`buf.writeInt32LE(value[, offset])`", "apiSymbol": "buf.writeInt32LE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteint32levalue-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteint32levalue-offset", "nodeStability": { "index": "2", "level": 2, @@ -3509,7 +3609,7 @@ "label": "buf.writeIntBE(value, offset, byteLength)", "signature": "`buf.writeIntBE(value, offset, byteLength)`", "apiSymbol": "buf.writeIntBE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteintbevalue-offset-bytelength", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteintbevalue-offset-bytelength", "nodeStability": { "index": "2", "level": 2, @@ -3534,7 +3634,7 @@ "label": "buf.writeIntLE(value, offset, byteLength)", "signature": "`buf.writeIntLE(value, offset, byteLength)`", "apiSymbol": "buf.writeIntLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteintlevalue-offset-bytelength", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteintlevalue-offset-bytelength", "nodeStability": { "index": "2", "level": 2, @@ -3559,7 +3659,7 @@ "label": "buf.writeUInt8(value[, offset])", "signature": "`buf.writeUInt8(value[, offset])`", "apiSymbol": "buf.writeUInt8", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteuint8value-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteuint8value-offset", "nodeStability": { "index": "2", "level": 2, @@ -3584,7 +3684,7 @@ "label": "buf.writeUInt16BE(value[, offset])", "signature": "`buf.writeUInt16BE(value[, offset])`", "apiSymbol": "buf.writeUInt16BE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteuint16bevalue-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteuint16bevalue-offset", "nodeStability": { "index": "2", "level": 2, @@ -3609,7 +3709,7 @@ "label": "buf.writeUInt16LE(value[, offset])", "signature": "`buf.writeUInt16LE(value[, offset])`", "apiSymbol": "buf.writeUInt16LE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteuint16levalue-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteuint16levalue-offset", "nodeStability": { "index": "2", "level": 2, @@ -3634,7 +3734,7 @@ "label": "buf.writeUInt32BE(value[, offset])", "signature": "`buf.writeUInt32BE(value[, offset])`", "apiSymbol": "buf.writeUInt32BE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteuint32bevalue-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteuint32bevalue-offset", "nodeStability": { "index": "2", "level": 2, @@ -3659,7 +3759,7 @@ "label": "buf.writeUInt32LE(value[, offset])", "signature": "`buf.writeUInt32LE(value[, offset])`", "apiSymbol": "buf.writeUInt32LE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteuint32levalue-offset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteuint32levalue-offset", "nodeStability": { "index": "2", "level": 2, @@ -3684,7 +3784,7 @@ "label": "buf.writeUIntBE(value, offset, byteLength)", "signature": "`buf.writeUIntBE(value, offset, byteLength)`", "apiSymbol": "buf.writeUIntBE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteuintbevalue-offset-bytelength", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteuintbevalue-offset-bytelength", "nodeStability": { "index": "2", "level": 2, @@ -3709,7 +3809,7 @@ "label": "buf.writeUIntLE(value, offset, byteLength)", "signature": "`buf.writeUIntLE(value, offset, byteLength)`", "apiSymbol": "buf.writeUIntLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufwriteuintlevalue-offset-bytelength", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufwriteuintlevalue-offset-bytelength", "nodeStability": { "index": "2", "level": 2, @@ -3729,12 +3829,12 @@ } }, { - "id": "buffer:a12afe3296c9", + "id": "buffer:06a34306775b", "chapter": "buffer", "label": "poolSize", - "signature": "`poolSize` Type: {integer} **Default:** `8192`", + "signature": "`poolSize` Type: {integer} **Default:** `65536`", "apiSymbol": "poolSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#class-buffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#class-buffer", "nodeStability": { "index": "2", "level": 2, @@ -3759,7 +3859,7 @@ "label": "[index]", "signature": "`[index]` `index` {integer}", "apiSymbol": "", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#class-buffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#class-buffer", "nodeStability": { "index": "2", "level": 2, @@ -3784,7 +3884,7 @@ "label": "buffer", "signature": "`buffer` Type: {ArrayBuffer} The underlying `ArrayBuffer` object based on which this `Buffer` object is created.", "apiSymbol": "buffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#class-buffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#class-buffer", "nodeStability": { "index": "2", "level": 2, @@ -3809,7 +3909,7 @@ "label": "byteOffset", "signature": "`byteOffset` Type: {integer} The `byteOffset` of the `Buffer`'s underlying `ArrayBuffer` object.", "apiSymbol": "byteOffset", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#class-buffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#class-buffer", "nodeStability": { "index": "2", "level": 2, @@ -3834,7 +3934,7 @@ "label": "length", "signature": "`length` Type: {integer}", "apiSymbol": "length", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#class-buffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#class-buffer", "nodeStability": { "index": "2", "level": 2, @@ -3859,7 +3959,7 @@ "label": "buf.parent", "signature": "`buf.parent`", "apiSymbol": "buf.parent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#bufparent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#bufparent", "nodeStability": { "index": "0", "level": 0, @@ -3884,7 +3984,7 @@ "label": "File", "signature": "Class: `File`", "apiSymbol": "File", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#class-file", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#class-file", "nodeStability": { "index": "2", "level": 2, @@ -3909,7 +4009,7 @@ "label": "name", "signature": "`name` Type: {string}", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#class-file", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#class-file", "nodeStability": { "index": "2", "level": 2, @@ -3934,7 +4034,7 @@ "label": "lastModified", "signature": "`lastModified` Type: {number}", "apiSymbol": "lastModified", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/buffer.html#class-file", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/buffer.html#class-file", "nodeStability": { "index": "2", "level": 2, @@ -3959,7 +4059,7 @@ "label": "Spawning .bat and .cmd files on Windows", "signature": "Spawning `.bat` and `.cmd` files on Windows", "apiSymbol": ".bat", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#spawning-bat-and-cmd-files-on-windows", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#spawning-bat-and-cmd-files-on-windows", "nodeStability": { "index": "2", "level": 2, @@ -3984,7 +4084,7 @@ "label": "child_process.exec(command[, options][, callback])", "signature": "`child_process.exec(command[, options][, callback])`", "apiSymbol": "child_process.exec", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#child_processexeccommand-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#child_processexeccommand-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -4009,7 +4109,7 @@ "label": "child_process.execFile(file[, args][, options][, callback])", "signature": "`child_process.execFile(file[, args][, options][, callback])`", "apiSymbol": "child_process.execFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#child_processexecfilefile-args-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#child_processexecfilefile-args-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -4036,7 +4136,7 @@ "label": "child_process.fork(modulePath[, args][, options])", "signature": "`child_process.fork(modulePath[, args][, options])`", "apiSymbol": "child_process.fork", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#child_processforkmodulepath-args-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#child_processforkmodulepath-args-options", "nodeStability": { "index": "2", "level": 2, @@ -4063,7 +4163,7 @@ "label": "child_process.spawn(command[, args][, options])", "signature": "`child_process.spawn(command[, args][, options])`", "apiSymbol": "child_process.spawn", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#child_processspawncommand-args-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#child_processspawncommand-args-options", "nodeStability": { "index": "2", "level": 2, @@ -4098,7 +4198,7 @@ "label": "options.detached", "signature": "`options.detached`", "apiSymbol": "options.detached", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#optionsdetached", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#optionsdetached", "nodeStability": { "index": "2", "level": 2, @@ -4123,7 +4223,7 @@ "label": "options.stdio", "signature": "`options.stdio`", "apiSymbol": "options.stdio", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#optionsstdio", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#optionsstdio", "nodeStability": { "index": "2", "level": 2, @@ -4148,7 +4248,7 @@ "label": "child_process.execFileSync(file[, args][, options])", "signature": "`child_process.execFileSync(file[, args][, options])`", "apiSymbol": "child_process.execFileSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#child_processexecfilesyncfile-args-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#child_processexecfilesyncfile-args-options", "nodeStability": { "index": "2", "level": 2, @@ -4183,7 +4283,7 @@ "label": "child_process.execSync(command[, options])", "signature": "`child_process.execSync(command[, options])`", "apiSymbol": "child_process.execSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#child_processexecsynccommand-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#child_processexecsynccommand-options", "nodeStability": { "index": "2", "level": 2, @@ -4218,7 +4318,7 @@ "label": "child_process.spawnSync(command[, args][, options])", "signature": "`child_process.spawnSync(command[, args][, options])`", "apiSymbol": "child_process.spawnSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#child_processspawnsynccommand-args-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#child_processspawnsynccommand-args-options", "nodeStability": { "index": "2", "level": 2, @@ -4253,7 +4353,7 @@ "label": "maxBuffer", "signature": "`maxBuffer` and Unicode", "apiSymbol": "maxBuffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#maxbuffer-and-unicode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#maxbuffer-and-unicode", "nodeStability": { "index": "2", "level": 2, @@ -4278,7 +4378,7 @@ "label": "ChildProcess", "signature": "Class: `ChildProcess`", "apiSymbol": "ChildProcess", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4303,7 +4403,7 @@ "label": "subprocess.disconnect()", "signature": "`subprocess.disconnect()`", "apiSymbol": "subprocess.disconnect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#subprocessdisconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#subprocessdisconnect", "nodeStability": { "index": "2", "level": 2, @@ -4330,7 +4430,7 @@ "label": "subprocess.kill([signal])", "signature": "`subprocess.kill([signal])`", "apiSymbol": "subprocess.kill", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#subprocesskillsignal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#subprocesskillsignal", "nodeStability": { "index": "2", "level": 2, @@ -4355,7 +4455,7 @@ "label": "subprocess[Symbol.dispose]()", "signature": "`subprocess[Symbol.dispose]()`", "apiSymbol": "subprocess", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#subprocesssymboldispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#subprocesssymboldispose", "nodeStability": { "index": "2", "level": 2, @@ -4382,7 +4482,7 @@ "label": "subprocess.ref()", "signature": "`subprocess.ref()`", "apiSymbol": "subprocess.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#subprocessref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#subprocessref", "nodeStability": { "index": "2", "level": 2, @@ -4407,7 +4507,7 @@ "label": "subprocess.send(message[, sendHandle[, options]][, callback])", "signature": "`subprocess.send(message[, sendHandle[, options]][, callback])`", "apiSymbol": "subprocess.send", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#subprocesssendmessage-sendhandle-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#subprocesssendmessage-sendhandle-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -4434,7 +4534,7 @@ "label": "subprocess.unref()", "signature": "`subprocess.unref()`", "apiSymbol": "subprocess.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#subprocessunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#subprocessunref", "nodeStability": { "index": "2", "level": 2, @@ -4459,7 +4559,7 @@ "label": "channel", "signature": "`channel` Type: {Object} A pipe representing the IPC channel to the child process.", "apiSymbol": "channel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4484,7 +4584,7 @@ "label": "subprocess.channel.ref()", "signature": "`subprocess.channel.ref()`", "apiSymbol": "subprocess.channel.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#subprocesschannelref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#subprocesschannelref", "nodeStability": { "index": "2", "level": 2, @@ -4509,7 +4609,7 @@ "label": "subprocess.channel.unref()", "signature": "`subprocess.channel.unref()`", "apiSymbol": "subprocess.channel.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#subprocesschannelunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#subprocesschannelunref", "nodeStability": { "index": "2", "level": 2, @@ -4534,7 +4634,7 @@ "label": "connected", "signature": "`connected` Type: {boolean} Set to `false` after `subprocess.disconnect()` is called.", "apiSymbol": "connected", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4561,7 +4661,7 @@ "label": "exitCode", "signature": "`exitCode` Type: {integer}", "apiSymbol": "exitCode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4586,7 +4686,7 @@ "label": "killed", "signature": "`killed` Type: {boolean} Set to `true` after `subprocess.kill()` is used to successfully send a signal to the child process.", "apiSymbol": "killed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4611,7 +4711,7 @@ "label": "pid", "signature": "`pid` Type: {integer|undefined}", "apiSymbol": "pid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4636,7 +4736,7 @@ "label": "signalCode", "signature": "`signalCode` Type: {string|null}", "apiSymbol": "signalCode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4661,7 +4761,7 @@ "label": "spawnargs", "signature": "`spawnargs` Type: {Array}", "apiSymbol": "spawnargs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4686,7 +4786,7 @@ "label": "spawnfile", "signature": "`spawnfile` Type: {string}", "apiSymbol": "spawnfile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4711,7 +4811,7 @@ "label": "stderr", "signature": "`stderr` Type: {stream.Readable|null|undefined}", "apiSymbol": "stderr", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4739,7 +4839,7 @@ "label": "stdin", "signature": "`stdin` Type: {stream.Writable|null|undefined}", "apiSymbol": "stdin", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4771,7 +4871,7 @@ "label": "stdio", "signature": "`stdio` Type: {Array}", "apiSymbol": "stdio", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4796,7 +4896,7 @@ "label": "stdout", "signature": "`stdout` Type: {stream.Readable|null|undefined}", "apiSymbol": "stdout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#class-childprocess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#class-childprocess", "nodeStability": { "index": "2", "level": 2, @@ -4824,7 +4924,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#event-close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#event-close", "nodeStability": { "index": "2", "level": 2, @@ -4852,7 +4952,7 @@ "label": "'disconnect'", "signature": "Event: `'disconnect'`", "apiSymbol": "'disconnect'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#event-disconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#event-disconnect", "nodeStability": { "index": "2", "level": 2, @@ -4879,7 +4979,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#event-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#event-error", "nodeStability": { "index": "2", "level": 2, @@ -4904,7 +5004,7 @@ "label": "'exit'", "signature": "Event: `'exit'`", "apiSymbol": "'exit'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#event-exit", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#event-exit", "nodeStability": { "index": "2", "level": 2, @@ -4929,7 +5029,7 @@ "label": "'message'", "signature": "Event: `'message'`", "apiSymbol": "'message'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#event-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#event-message", "nodeStability": { "index": "2", "level": 2, @@ -4956,7 +5056,7 @@ "label": "'spawn'", "signature": "Event: `'spawn'`", "apiSymbol": "'spawn'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/child_process.html#event-spawn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/child_process.html#event-spawn", "nodeStability": { "index": "2", "level": 2, @@ -4981,7 +5081,7 @@ "label": "Worker", "signature": "Class: `Worker`", "apiSymbol": "Worker", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#class-worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#class-worker", "nodeStability": { "index": "2", "level": 2, @@ -5006,7 +5106,7 @@ "label": "worker.disconnect()", "signature": "`worker.disconnect()`", "apiSymbol": "worker.disconnect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#workerdisconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#workerdisconnect", "nodeStability": { "index": "2", "level": 2, @@ -5031,7 +5131,7 @@ "label": "worker.isConnected()", "signature": "`worker.isConnected()`", "apiSymbol": "worker.isConnected", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#workerisconnected", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#workerisconnected", "nodeStability": { "index": "2", "level": 2, @@ -5056,7 +5156,7 @@ "label": "worker.isDead()", "signature": "`worker.isDead()`", "apiSymbol": "worker.isDead", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#workerisdead", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#workerisdead", "nodeStability": { "index": "2", "level": 2, @@ -5081,7 +5181,7 @@ "label": "worker.kill([signal])", "signature": "`worker.kill([signal])`", "apiSymbol": "worker.kill", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#workerkillsignal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#workerkillsignal", "nodeStability": { "index": "2", "level": 2, @@ -5106,7 +5206,7 @@ "label": "worker.send(message[, sendHandle[, options]][, callback])", "signature": "`worker.send(message[, sendHandle[, options]][, callback])`", "apiSymbol": "worker.send", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#workersendmessage-sendhandle-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#workersendmessage-sendhandle-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -5131,7 +5231,7 @@ "label": "exitedAfterDisconnect", "signature": "`exitedAfterDisconnect` Type: {boolean}", "apiSymbol": "exitedAfterDisconnect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#class-worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#class-worker", "nodeStability": { "index": "2", "level": 2, @@ -5156,7 +5256,7 @@ "label": "id", "signature": "`id` Type: {integer}", "apiSymbol": "id", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#class-worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#class-worker", "nodeStability": { "index": "2", "level": 2, @@ -5181,7 +5281,7 @@ "label": "process", "signature": "`process` Type: {ChildProcess}", "apiSymbol": "process", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#class-worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#class-worker", "nodeStability": { "index": "2", "level": 2, @@ -5206,7 +5306,7 @@ "label": "'disconnect'", "signature": "Event: `'disconnect'`", "apiSymbol": "'disconnect'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-disconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-disconnect", "nodeStability": { "index": "2", "level": 2, @@ -5231,7 +5331,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-error", "nodeStability": { "index": "2", "level": 2, @@ -5256,7 +5356,7 @@ "label": "'exit'", "signature": "Event: `'exit'`", "apiSymbol": "'exit'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-exit", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-exit", "nodeStability": { "index": "2", "level": 2, @@ -5281,7 +5381,7 @@ "label": "'listening'", "signature": "Event: `'listening'`", "apiSymbol": "'listening'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-listening", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-listening", "nodeStability": { "index": "2", "level": 2, @@ -5306,7 +5406,7 @@ "label": "'message'", "signature": "Event: `'message'`", "apiSymbol": "'message'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-message", "nodeStability": { "index": "2", "level": 2, @@ -5331,7 +5431,7 @@ "label": "'online'", "signature": "Event: `'online'`", "apiSymbol": "'online'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-online", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-online", "nodeStability": { "index": "2", "level": 2, @@ -5356,7 +5456,7 @@ "label": "cluster.disconnect([callback])", "signature": "`cluster.disconnect([callback])`", "apiSymbol": "cluster.disconnect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#clusterdisconnectcallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#clusterdisconnectcallback", "nodeStability": { "index": "2", "level": 2, @@ -5381,7 +5481,7 @@ "label": "cluster.fork([env])", "signature": "`cluster.fork([env])`", "apiSymbol": "cluster.fork", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#clusterforkenv", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#clusterforkenv", "nodeStability": { "index": "2", "level": 2, @@ -5406,7 +5506,7 @@ "label": "cluster.setupMaster([settings])", "signature": "`cluster.setupMaster([settings])`", "apiSymbol": "cluster.setupMaster", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#clustersetupmastersettings", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#clustersetupmastersettings", "nodeStability": { "index": "0", "level": 0, @@ -5431,7 +5531,7 @@ "label": "cluster.setupPrimary([settings])", "signature": "`cluster.setupPrimary([settings])`", "apiSymbol": "cluster.setupPrimary", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#clustersetupprimarysettings", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#clustersetupprimarysettings", "nodeStability": { "index": "2", "level": 2, @@ -5456,7 +5556,7 @@ "label": "cluster.isMaster", "signature": "`cluster.isMaster`", "apiSymbol": "cluster.isMaster", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#clusterismaster", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#clusterismaster", "nodeStability": { "index": "0", "level": 0, @@ -5483,7 +5583,7 @@ "label": "isPrimary", "signature": "`isPrimary` Type: {boolean}", "apiSymbol": "isPrimary", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html", "nodeStability": { "index": "2", "level": 2, @@ -5510,7 +5610,7 @@ "label": "isWorker", "signature": "`isWorker` Type: {boolean}", "apiSymbol": "isWorker", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html", "nodeStability": { "index": "2", "level": 2, @@ -5537,7 +5637,7 @@ "label": "cluster.schedulingPolicy", "signature": "`cluster.schedulingPolicy`", "apiSymbol": "cluster.schedulingPolicy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#clusterschedulingpolicy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#clusterschedulingpolicy", "nodeStability": { "index": "2", "level": 2, @@ -5562,7 +5662,7 @@ "label": "settings", "signature": "`settings` Type: {Object}", "apiSymbol": "settings", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html", "nodeStability": { "index": "2", "level": 2, @@ -5587,7 +5687,7 @@ "label": "worker", "signature": "`worker` Type: {Object}", "apiSymbol": "worker", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html", "nodeStability": { "index": "2", "level": 2, @@ -5612,7 +5712,7 @@ "label": "workers", "signature": "`workers` Type: {Object}", "apiSymbol": "workers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html", "nodeStability": { "index": "2", "level": 2, @@ -5637,7 +5737,7 @@ "label": "'disconnect'", "signature": "Event: `'disconnect'`", "apiSymbol": "'disconnect'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-disconnect_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-disconnect_1", "nodeStability": { "index": "2", "level": 2, @@ -5662,7 +5762,7 @@ "label": "'exit'", "signature": "Event: `'exit'`", "apiSymbol": "'exit'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-exit_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-exit_1", "nodeStability": { "index": "2", "level": 2, @@ -5687,7 +5787,7 @@ "label": "'fork'", "signature": "Event: `'fork'`", "apiSymbol": "'fork'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-fork", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-fork", "nodeStability": { "index": "2", "level": 2, @@ -5712,7 +5812,7 @@ "label": "'listening'", "signature": "Event: `'listening'`", "apiSymbol": "'listening'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-listening_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-listening_1", "nodeStability": { "index": "2", "level": 2, @@ -5737,7 +5837,7 @@ "label": "'message'", "signature": "Event: `'message'`", "apiSymbol": "'message'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-message_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-message_1", "nodeStability": { "index": "2", "level": 2, @@ -5762,7 +5862,7 @@ "label": "'online'", "signature": "Event: `'online'`", "apiSymbol": "'online'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-online_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-online_1", "nodeStability": { "index": "2", "level": 2, @@ -5787,7 +5887,7 @@ "label": "'setup'", "signature": "Event: `'setup'`", "apiSymbol": "'setup'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/cluster.html#event-setup", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/cluster.html#event-setup", "nodeStability": { "index": "2", "level": 2, @@ -5812,7 +5912,7 @@ "label": "console.profile([label])", "signature": "`console.profile([label])`", "apiSymbol": "console.profile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoleprofilelabel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoleprofilelabel", "nodeStability": { "index": "2", "level": 2, @@ -5839,7 +5939,7 @@ "label": "console.profileEnd([label])", "signature": "`console.profileEnd([label])`", "apiSymbol": "console.profileEnd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoleprofileendlabel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoleprofileendlabel", "nodeStability": { "index": "2", "level": 2, @@ -5866,7 +5966,7 @@ "label": "console.timeStamp([label])", "signature": "`console.timeStamp([label])`", "apiSymbol": "console.timeStamp", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoletimestamplabel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoletimestamplabel", "nodeStability": { "index": "2", "level": 2, @@ -5893,7 +5993,7 @@ "label": "Console", "signature": "Class: `Console`", "apiSymbol": "Console", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#class-console", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#class-console", "nodeStability": { "index": "2", "level": 2, @@ -5921,7 +6021,7 @@ "label": "console.assert(value[, ...message])", "signature": "`console.assert(value[, ...message])`", "apiSymbol": "console.assert", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoleassertvalue-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoleassertvalue-message", "nodeStability": { "index": "2", "level": 2, @@ -5949,7 +6049,7 @@ "label": "console.clear()", "signature": "`console.clear()`", "apiSymbol": "console.clear", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoleclear", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoleclear", "nodeStability": { "index": "2", "level": 2, @@ -5976,7 +6076,7 @@ "label": "console.count([label])", "signature": "`console.count([label])`", "apiSymbol": "console.count", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consolecountlabel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consolecountlabel", "nodeStability": { "index": "2", "level": 2, @@ -6005,7 +6105,7 @@ "label": "console.countReset([label])", "signature": "`console.countReset([label])`", "apiSymbol": "console.countReset", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consolecountresetlabel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consolecountresetlabel", "nodeStability": { "index": "2", "level": 2, @@ -6034,7 +6134,7 @@ "label": "console.debug(data[, ...args])", "signature": "`console.debug(data[, ...args])`", "apiSymbol": "console.debug", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoledebugdata-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoledebugdata-args", "nodeStability": { "index": "2", "level": 2, @@ -6065,7 +6165,7 @@ "label": "console.dir(obj[, options])", "signature": "`console.dir(obj[, options])`", "apiSymbol": "console.dir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoledirobj-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoledirobj-options", "nodeStability": { "index": "2", "level": 2, @@ -6093,7 +6193,7 @@ "label": "console.dirxml(...data)", "signature": "`console.dirxml(...data)`", "apiSymbol": "console.dirxml", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoledirxmldata", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoledirxmldata", "nodeStability": { "index": "2", "level": 2, @@ -6121,7 +6221,7 @@ "label": "console.error([data][, ...args])", "signature": "`console.error([data][, ...args])`", "apiSymbol": "console.error", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoleerrordata-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoleerrordata-args", "nodeStability": { "index": "2", "level": 2, @@ -6152,7 +6252,7 @@ "label": "console.group([...label])", "signature": "`console.group([...label])`", "apiSymbol": "console.group", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consolegrouplabel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consolegrouplabel", "nodeStability": { "index": "2", "level": 2, @@ -6181,7 +6281,7 @@ "label": "console.groupCollapsed()", "signature": "`console.groupCollapsed()`", "apiSymbol": "console.groupCollapsed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consolegroupcollapsed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consolegroupcollapsed", "nodeStability": { "index": "2", "level": 2, @@ -6210,7 +6310,7 @@ "label": "console.groupEnd()", "signature": "`console.groupEnd()`", "apiSymbol": "console.groupEnd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consolegroupend", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consolegroupend", "nodeStability": { "index": "2", "level": 2, @@ -6239,7 +6339,7 @@ "label": "console.info([data][, ...args])", "signature": "`console.info([data][, ...args])`", "apiSymbol": "console.info", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoleinfodata-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoleinfodata-args", "nodeStability": { "index": "2", "level": 2, @@ -6270,7 +6370,7 @@ "label": "console.log([data][, ...args])", "signature": "`console.log([data][, ...args])`", "apiSymbol": "console.log", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consolelogdata-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consolelogdata-args", "nodeStability": { "index": "2", "level": 2, @@ -6301,7 +6401,7 @@ "label": "console.table(tabularData[, properties])", "signature": "`console.table(tabularData[, properties])`", "apiSymbol": "console.table", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoletabletabulardata-properties", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoletabletabulardata-properties", "nodeStability": { "index": "2", "level": 2, @@ -6329,7 +6429,7 @@ "label": "console.time([label])", "signature": "`console.time([label])`", "apiSymbol": "console.time", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoletimelabel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoletimelabel", "nodeStability": { "index": "2", "level": 2, @@ -6356,7 +6456,7 @@ "label": "console.timeEnd([label])", "signature": "`console.timeEnd([label])`", "apiSymbol": "console.timeEnd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoletimeendlabel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoletimeendlabel", "nodeStability": { "index": "2", "level": 2, @@ -6383,7 +6483,7 @@ "label": "console.timeLog([label][, ...data])", "signature": "`console.timeLog([label][, ...data])`", "apiSymbol": "console.timeLog", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoletimeloglabel-data", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoletimeloglabel-data", "nodeStability": { "index": "2", "level": 2, @@ -6410,7 +6510,7 @@ "label": "console.trace([message][, ...args])", "signature": "`console.trace([message][, ...args])`", "apiSymbol": "console.trace", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consoletracemessage-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consoletracemessage-args", "nodeStability": { "index": "2", "level": 2, @@ -6435,7 +6535,7 @@ "label": "console.warn([data][, ...args])", "signature": "`console.warn([data][, ...args])`", "apiSymbol": "console.warn", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/console.html#consolewarndata-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/console.html#consolewarndata-args", "nodeStability": { "index": "2", "level": 2, @@ -6466,7 +6566,7 @@ "label": "node:crypto", "signature": "`node:crypto` module methods and properties", "apiSymbol": "node:crypto", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#nodecrypto-module-methods-and-properties", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#nodecrypto-module-methods-and-properties", "nodeStability": { "index": "2", "level": 2, @@ -6491,14 +6591,14 @@ "label": "crypto.argon2(algorithm, parameters, callback)", "signature": "`crypto.argon2(algorithm, parameters, callback)`", "apiSymbol": "crypto.argon2", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptoargon2algorithm-parameters-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptoargon2algorithm-parameters-callback", "nodeStability": { - "index": "1.2", - "level": 1, - "text": "Release candidate", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, - "priority": "normal", + "priority": "high", "tiers": { "static": { "status": "not-implemented", @@ -6516,14 +6616,14 @@ "label": "crypto.argon2Sync(algorithm, parameters)", "signature": "`crypto.argon2Sync(algorithm, parameters)`", "apiSymbol": "crypto.argon2Sync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptoargon2syncalgorithm-parameters", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptoargon2syncalgorithm-parameters", "nodeStability": { - "index": "1.2", - "level": 1, - "text": "Release candidate", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, - "priority": "normal", + "priority": "high", "tiers": { "static": { "status": "not-implemented", @@ -6541,7 +6641,7 @@ "label": "crypto.checkPrime(candidate[, options], callback)", "signature": "`crypto.checkPrime(candidate[, options], callback)`", "apiSymbol": "crypto.checkPrime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocheckprimecandidate-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocheckprimecandidate-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -6566,7 +6666,7 @@ "label": "crypto.checkPrimeSync(candidate[, options])", "signature": "`crypto.checkPrimeSync(candidate[, options])`", "apiSymbol": "crypto.checkPrimeSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocheckprimesynccandidate-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocheckprimesynccandidate-options", "nodeStability": { "index": "2", "level": 2, @@ -6591,7 +6691,7 @@ "label": "crypto.createCipheriv(algorithm, key, iv[, options])", "signature": "`crypto.createCipheriv(algorithm, key, iv[, options])`", "apiSymbol": "crypto.createCipheriv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreatecipherivalgorithm-key-iv-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreatecipherivalgorithm-key-iv-options", "nodeStability": { "index": "2", "level": 2, @@ -6616,7 +6716,7 @@ "label": "crypto.createDecipheriv(algorithm, key, iv[, options])", "signature": "`crypto.createDecipheriv(algorithm, key, iv[, options])`", "apiSymbol": "crypto.createDecipheriv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreatedecipherivalgorithm-key-iv-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreatedecipherivalgorithm-key-iv-options", "nodeStability": { "index": "2", "level": 2, @@ -6641,7 +6741,7 @@ "label": "crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])", "signature": "`crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])`", "apiSymbol": "crypto.createDiffieHellman", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreatediffiehellmanprime-primeencoding-generator-generatorencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreatediffiehellmanprime-primeencoding-generator-generatorencoding", "nodeStability": { "index": "2", "level": 2, @@ -6666,7 +6766,7 @@ "label": "crypto.createDiffieHellman(primeLength[, generator])", "signature": "`crypto.createDiffieHellman(primeLength[, generator])`", "apiSymbol": "crypto.createDiffieHellman", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreatediffiehellmanprimelength-generator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreatediffiehellmanprimelength-generator", "nodeStability": { "index": "2", "level": 2, @@ -6691,7 +6791,7 @@ "label": "crypto.createDiffieHellmanGroup(name)", "signature": "`crypto.createDiffieHellmanGroup(name)`", "apiSymbol": "crypto.createDiffieHellmanGroup", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreatediffiehellmangroupname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreatediffiehellmangroupname", "nodeStability": { "index": "2", "level": 2, @@ -6716,7 +6816,7 @@ "label": "crypto.createECDH(curveName)", "signature": "`crypto.createECDH(curveName)`", "apiSymbol": "crypto.createECDH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreateecdhcurvename", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreateecdhcurvename", "nodeStability": { "index": "2", "level": 2, @@ -6741,7 +6841,7 @@ "label": "crypto.createHash(algorithm[, options])", "signature": "`crypto.createHash(algorithm[, options])`", "apiSymbol": "crypto.createHash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreatehashalgorithm-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreatehashalgorithm-options", "nodeStability": { "index": "2", "level": 2, @@ -6770,7 +6870,7 @@ "label": "crypto.createHmac(algorithm, key[, options])", "signature": "`crypto.createHmac(algorithm, key[, options])`", "apiSymbol": "crypto.createHmac", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreatehmacalgorithm-key-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreatehmacalgorithm-key-options", "nodeStability": { "index": "2", "level": 2, @@ -6793,13 +6893,38 @@ } } }, + { + "id": "crypto:8139c367e45c", + "chapter": "crypto", + "label": "crypto.createMac(algorithm, key[, options])", + "signature": "`crypto.createMac(algorithm, key[, options])`", + "apiSymbol": "crypto.createMac", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreatemacalgorithm-key-options", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate", + "inherited": false + }, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:crypto", + "tests": [] + } + } + }, { "id": "crypto:a91640a96ead", "chapter": "crypto", "label": "crypto.createPrivateKey(key)", "signature": "`crypto.createPrivateKey(key)`", "apiSymbol": "crypto.createPrivateKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreateprivatekeykey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreateprivatekeykey", "nodeStability": { "index": "2", "level": 2, @@ -6824,7 +6949,7 @@ "label": "crypto.createPublicKey(key)", "signature": "`crypto.createPublicKey(key)`", "apiSymbol": "crypto.createPublicKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreatepublickeykey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreatepublickeykey", "nodeStability": { "index": "2", "level": 2, @@ -6849,7 +6974,7 @@ "label": "crypto.createSecretKey(key[, encoding])", "signature": "`crypto.createSecretKey(key[, encoding])`", "apiSymbol": "crypto.createSecretKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreatesecretkeykey-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreatesecretkeykey-encoding", "nodeStability": { "index": "2", "level": 2, @@ -6874,7 +6999,7 @@ "label": "crypto.createSign(algorithm[, options])", "signature": "`crypto.createSign(algorithm[, options])`", "apiSymbol": "crypto.createSign", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreatesignalgorithm-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreatesignalgorithm-options", "nodeStability": { "index": "2", "level": 2, @@ -6899,7 +7024,7 @@ "label": "crypto.createVerify(algorithm[, options])", "signature": "`crypto.createVerify(algorithm[, options])`", "apiSymbol": "crypto.createVerify", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptocreateverifyalgorithm-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptocreateverifyalgorithm-options", "nodeStability": { "index": "2", "level": 2, @@ -6924,14 +7049,14 @@ "label": "crypto.decapsulate(key, ciphertext[, callback])", "signature": "`crypto.decapsulate(key, ciphertext[, callback])`", "apiSymbol": "crypto.decapsulate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptodecapsulatekey-ciphertext-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptodecapsulatekey-ciphertext-callback", "nodeStability": { - "index": "1.2", - "level": 1, - "text": "Release candidate", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, - "priority": "normal", + "priority": "high", "tiers": { "static": { "status": "not-implemented", @@ -6949,7 +7074,7 @@ "label": "crypto.diffieHellman(options[, callback])", "signature": "`crypto.diffieHellman(options[, callback])`", "apiSymbol": "crypto.diffieHellman", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptodiffiehellmanoptions-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptodiffiehellmanoptions-callback", "nodeStability": { "index": "2", "level": 2, @@ -6974,14 +7099,14 @@ "label": "crypto.encapsulate(key[, callback])", "signature": "`crypto.encapsulate(key[, callback])`", "apiSymbol": "crypto.encapsulate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptoencapsulatekey-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptoencapsulatekey-callback", "nodeStability": { - "index": "1.2", - "level": 1, - "text": "Release candidate", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, - "priority": "normal", + "priority": "high", "tiers": { "static": { "status": "not-implemented", @@ -6999,7 +7124,7 @@ "label": "crypto.generateKey(type, options, callback)", "signature": "`crypto.generateKey(type, options, callback)`", "apiSymbol": "crypto.generateKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogeneratekeytype-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogeneratekeytype-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -7024,7 +7149,7 @@ "label": "crypto.generateKeyPair(type, options, callback)", "signature": "`crypto.generateKeyPair(type, options, callback)`", "apiSymbol": "crypto.generateKeyPair", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogeneratekeypairtype-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogeneratekeypairtype-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -7049,7 +7174,7 @@ "label": "crypto.generateKeyPairSync(type, options)", "signature": "`crypto.generateKeyPairSync(type, options)`", "apiSymbol": "crypto.generateKeyPairSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogeneratekeypairsynctype-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogeneratekeypairsynctype-options", "nodeStability": { "index": "2", "level": 2, @@ -7074,7 +7199,7 @@ "label": "crypto.generateKeySync(type, options)", "signature": "`crypto.generateKeySync(type, options)`", "apiSymbol": "crypto.generateKeySync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogeneratekeysynctype-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogeneratekeysynctype-options", "nodeStability": { "index": "2", "level": 2, @@ -7099,7 +7224,7 @@ "label": "crypto.generatePrime(size[, options], callback)", "signature": "`crypto.generatePrime(size[, options], callback)`", "apiSymbol": "crypto.generatePrime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogenerateprimesize-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogenerateprimesize-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -7124,7 +7249,7 @@ "label": "crypto.generatePrimeSync(size[, options])", "signature": "`crypto.generatePrimeSync(size[, options])`", "apiSymbol": "crypto.generatePrimeSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogenerateprimesyncsize-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogenerateprimesyncsize-options", "nodeStability": { "index": "2", "level": 2, @@ -7149,7 +7274,7 @@ "label": "crypto.getCipherInfo(nameOrNid[, options])", "signature": "`crypto.getCipherInfo(nameOrNid[, options])`", "apiSymbol": "crypto.getCipherInfo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogetcipherinfonameornid-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogetcipherinfonameornid-options", "nodeStability": { "index": "2", "level": 2, @@ -7174,7 +7299,7 @@ "label": "crypto.getCiphers()", "signature": "`crypto.getCiphers()`", "apiSymbol": "crypto.getCiphers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogetciphers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogetciphers", "nodeStability": { "index": "2", "level": 2, @@ -7199,7 +7324,7 @@ "label": "crypto.getCurves()", "signature": "`crypto.getCurves()`", "apiSymbol": "crypto.getCurves", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogetcurves", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogetcurves", "nodeStability": { "index": "2", "level": 2, @@ -7224,7 +7349,7 @@ "label": "crypto.getDiffieHellman(groupName)", "signature": "`crypto.getDiffieHellman(groupName)`", "apiSymbol": "crypto.getDiffieHellman", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogetdiffiehellmangroupname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogetdiffiehellmangroupname", "nodeStability": { "index": "2", "level": 2, @@ -7249,7 +7374,7 @@ "label": "crypto.getFips()", "signature": "`crypto.getFips()`", "apiSymbol": "crypto.getFips", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogetfips", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogetfips", "nodeStability": { "index": "2", "level": 2, @@ -7274,7 +7399,7 @@ "label": "crypto.getHashes()", "signature": "`crypto.getHashes()`", "apiSymbol": "crypto.getHashes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogethashes", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogethashes", "nodeStability": { "index": "2", "level": 2, @@ -7293,13 +7418,38 @@ } } }, + { + "id": "crypto:8950ad3041b7", + "chapter": "crypto", + "label": "crypto.getMacs()", + "signature": "`crypto.getMacs()`", + "apiSymbol": "crypto.getMacs", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogetmacs", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate", + "inherited": false + }, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:crypto", + "tests": [] + } + } + }, { "id": "crypto:2ab8394e29a7", "chapter": "crypto", "label": "crypto.getRandomValues(typedArray)", "signature": "`crypto.getRandomValues(typedArray)`", "apiSymbol": "crypto.getRandomValues", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptogetrandomvaluestypedarray", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptogetrandomvaluestypedarray", "nodeStability": { "index": "2", "level": 2, @@ -7324,7 +7474,7 @@ "label": "crypto.hash(algorithm, data[, options])", "signature": "`crypto.hash(algorithm, data[, options])`", "apiSymbol": "crypto.hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptohashalgorithm-data-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptohashalgorithm-data-options", "nodeStability": { "index": "2", "level": 2, @@ -7353,7 +7503,7 @@ "label": "crypto.hkdf(digest, ikm, salt, info, keylen, callback)", "signature": "`crypto.hkdf(digest, ikm, salt, info, keylen, callback)`", "apiSymbol": "crypto.hkdf", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptohkdfdigest-ikm-salt-info-keylen-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptohkdfdigest-ikm-salt-info-keylen-callback", "nodeStability": { "index": "2", "level": 2, @@ -7382,7 +7532,7 @@ "label": "crypto.hkdfSync(digest, ikm, salt, info, keylen)", "signature": "`crypto.hkdfSync(digest, ikm, salt, info, keylen)`", "apiSymbol": "crypto.hkdfSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptohkdfsyncdigest-ikm-salt-info-keylen", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptohkdfsyncdigest-ikm-salt-info-keylen", "nodeStability": { "index": "2", "level": 2, @@ -7405,13 +7555,38 @@ } } }, + { + "id": "crypto:d0b4d9541950", + "chapter": "crypto", + "label": "crypto.parsePKCS12(bundle[, options])", + "signature": "`crypto.parsePKCS12(bundle[, options])`", + "apiSymbol": "crypto.parsePKCS12", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptoparsepkcs12bundle-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:crypto", + "tests": [] + } + } + }, { "id": "crypto:cb974006b4f5", "chapter": "crypto", "label": "crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)", "signature": "`crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)`", "apiSymbol": "crypto.pbkdf2", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptopbkdf2password-salt-iterations-keylen-digest-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptopbkdf2password-salt-iterations-keylen-digest-callback", "nodeStability": { "index": "2", "level": 2, @@ -7440,7 +7615,7 @@ "label": "crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)", "signature": "`crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)`", "apiSymbol": "crypto.pbkdf2Sync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptopbkdf2syncpassword-salt-iterations-keylen-digest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptopbkdf2syncpassword-salt-iterations-keylen-digest", "nodeStability": { "index": "2", "level": 2, @@ -7469,7 +7644,7 @@ "label": "crypto.privateDecrypt(privateKey, buffer)", "signature": "`crypto.privateDecrypt(privateKey, buffer)`", "apiSymbol": "crypto.privateDecrypt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptoprivatedecryptprivatekey-buffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptoprivatedecryptprivatekey-buffer", "nodeStability": { "index": "2", "level": 2, @@ -7494,7 +7669,7 @@ "label": "crypto.privateEncrypt(privateKey, buffer)", "signature": "`crypto.privateEncrypt(privateKey, buffer)`", "apiSymbol": "crypto.privateEncrypt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptoprivateencryptprivatekey-buffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptoprivateencryptprivatekey-buffer", "nodeStability": { "index": "2", "level": 2, @@ -7519,7 +7694,7 @@ "label": "crypto.publicDecrypt(key, buffer)", "signature": "`crypto.publicDecrypt(key, buffer)`", "apiSymbol": "crypto.publicDecrypt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptopublicdecryptkey-buffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptopublicdecryptkey-buffer", "nodeStability": { "index": "2", "level": 2, @@ -7544,7 +7719,7 @@ "label": "crypto.publicEncrypt(key, buffer)", "signature": "`crypto.publicEncrypt(key, buffer)`", "apiSymbol": "crypto.publicEncrypt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptopublicencryptkey-buffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptopublicencryptkey-buffer", "nodeStability": { "index": "2", "level": 2, @@ -7569,7 +7744,7 @@ "label": "crypto.randomBytes(size[, callback])", "signature": "`crypto.randomBytes(size[, callback])`", "apiSymbol": "crypto.randomBytes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptorandombytessize-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptorandombytessize-callback", "nodeStability": { "index": "2", "level": 2, @@ -7604,7 +7779,7 @@ "label": "crypto.randomFill(buffer[, offset][, size], callback)", "signature": "`crypto.randomFill(buffer[, offset][, size], callback)`", "apiSymbol": "crypto.randomFill", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptorandomfillbuffer-offset-size-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptorandomfillbuffer-offset-size-callback", "nodeStability": { "index": "2", "level": 2, @@ -7629,7 +7804,7 @@ "label": "crypto.randomFillSync(buffer[, offset][, size])", "signature": "`crypto.randomFillSync(buffer[, offset][, size])`", "apiSymbol": "crypto.randomFillSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptorandomfillsyncbuffer-offset-size", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptorandomfillsyncbuffer-offset-size", "nodeStability": { "index": "2", "level": 2, @@ -7658,7 +7833,7 @@ "label": "crypto.randomInt([min, ]max[, callback])", "signature": "`crypto.randomInt([min, ]max[, callback])`", "apiSymbol": "crypto.randomInt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptorandomintmin-max-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptorandomintmin-max-callback", "nodeStability": { "index": "2", "level": 2, @@ -7687,7 +7862,7 @@ "label": "crypto.randomUUID([options])", "signature": "`crypto.randomUUID([options])`", "apiSymbol": "crypto.randomUUID", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptorandomuuidoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptorandomuuidoptions", "nodeStability": { "index": "2", "level": 2, @@ -7716,13 +7891,38 @@ } } }, + { + "id": "crypto:5fe8e4024b07", + "chapter": "crypto", + "label": "crypto.randomUUIDv7([options])", + "signature": "`crypto.randomUUIDv7([options])`", + "apiSymbol": "crypto.randomUUIDv7", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptorandomuuidv7options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:crypto", + "tests": [] + } + } + }, { "id": "crypto:10402b3c70ca", "chapter": "crypto", "label": "crypto.scrypt(password, salt, keylen[, options], callback)", "signature": "`crypto.scrypt(password, salt, keylen[, options], callback)`", "apiSymbol": "crypto.scrypt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptoscryptpassword-salt-keylen-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptoscryptpassword-salt-keylen-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -7751,7 +7951,7 @@ "label": "crypto.scryptSync(password, salt, keylen[, options])", "signature": "`crypto.scryptSync(password, salt, keylen[, options])`", "apiSymbol": "crypto.scryptSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptoscryptsyncpassword-salt-keylen-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptoscryptsyncpassword-salt-keylen-options", "nodeStability": { "index": "2", "level": 2, @@ -7780,7 +7980,7 @@ "label": "crypto.secureHeapUsed()", "signature": "`crypto.secureHeapUsed()`", "apiSymbol": "crypto.secureHeapUsed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptosecureheapused", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptosecureheapused", "nodeStability": { "index": "2", "level": 2, @@ -7805,14 +8005,14 @@ "label": "crypto.setEngine(engine[, flags])", "signature": "`crypto.setEngine(engine[, flags])`", "apiSymbol": "crypto.setEngine", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptosetengineengine-flags", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptosetengineengine-flags", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "0", + "level": 0, + "text": "Deprecated", + "inherited": false }, - "priority": "high", + "priority": "low", "tiers": { "static": { "status": "not-implemented", @@ -7830,7 +8030,7 @@ "label": "crypto.setFips(bool)", "signature": "`crypto.setFips(bool)`", "apiSymbol": "crypto.setFips", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptosetfipsbool", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptosetfipsbool", "nodeStability": { "index": "2", "level": 2, @@ -7855,7 +8055,7 @@ "label": "crypto.sign(algorithm, data, key[, callback])", "signature": "`crypto.sign(algorithm, data, key[, callback])`", "apiSymbol": "crypto.sign", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptosignalgorithm-data-key-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptosignalgorithm-data-key-callback", "nodeStability": { "index": "2", "level": 2, @@ -7880,7 +8080,7 @@ "label": "crypto.timingSafeEqual(a, b)", "signature": "`crypto.timingSafeEqual(a, b)`", "apiSymbol": "crypto.timingSafeEqual", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptotimingsafeequala-b", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptotimingsafeequala-b", "nodeStability": { "index": "2", "level": 2, @@ -7909,7 +8109,7 @@ "label": "crypto.verify(algorithm, data, key, signature[, callback])", "signature": "`crypto.verify(algorithm, data, key, signature[, callback])`", "apiSymbol": "crypto.verify", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptoverifyalgorithm-data-key-signature-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptoverifyalgorithm-data-key-signature-callback", "nodeStability": { "index": "2", "level": 2, @@ -7934,7 +8134,7 @@ "label": "constants", "signature": "`constants` Type: {Object}", "apiSymbol": "constants", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#nodecrypto-module-methods-and-properties", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#nodecrypto-module-methods-and-properties", "nodeStability": { "index": "2", "level": 2, @@ -7959,7 +8159,7 @@ "label": "crypto.fips", "signature": "`crypto.fips`", "apiSymbol": "crypto.fips", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptofips", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptofips", "nodeStability": { "index": "0", "level": 0, @@ -7984,7 +8184,7 @@ "label": "subtle", "signature": "`subtle` Type: {SubtleCrypto}", "apiSymbol": "subtle", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#nodecrypto-module-methods-and-properties", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#nodecrypto-module-methods-and-properties", "nodeStability": { "index": "2", "level": 2, @@ -8009,7 +8209,7 @@ "label": "crypto.webcrypto", "signature": "`crypto.webcrypto`", "apiSymbol": "crypto.webcrypto", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cryptowebcrypto", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cryptowebcrypto", "nodeStability": { "index": "2", "level": 2, @@ -8034,7 +8234,7 @@ "label": "Certificate", "signature": "Class: `Certificate`", "apiSymbol": "Certificate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-certificate", "nodeStability": { "index": "2", "level": 2, @@ -8059,7 +8259,7 @@ "label": "certificate.exportChallenge(spkac[, encoding])", "signature": "`certificate.exportChallenge(spkac[, encoding])`", "apiSymbol": "certificate.exportChallenge", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#certificateexportchallengespkac-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#certificateexportchallengespkac-encoding", "nodeStability": { "index": "0", "level": 0, @@ -8084,7 +8284,7 @@ "label": "certificate.exportPublicKey(spkac[, encoding])", "signature": "`certificate.exportPublicKey(spkac[, encoding])`", "apiSymbol": "certificate.exportPublicKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#certificateexportpublickeyspkac-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#certificateexportpublickeyspkac-encoding", "nodeStability": { "index": "0", "level": 0, @@ -8109,7 +8309,7 @@ "label": "certificate.verifySpkac(spkac[, encoding])", "signature": "`certificate.verifySpkac(spkac[, encoding])`", "apiSymbol": "certificate.verifySpkac", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#certificateverifyspkacspkac-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#certificateverifyspkacspkac-encoding", "nodeStability": { "index": "0", "level": 0, @@ -8134,7 +8334,7 @@ "label": "Cipheriv", "signature": "Class: `Cipheriv`", "apiSymbol": "Cipheriv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-cipheriv", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-cipheriv", "nodeStability": { "index": "2", "level": 2, @@ -8159,7 +8359,7 @@ "label": "cipher.final([outputEncoding])", "signature": "`cipher.final([outputEncoding])`", "apiSymbol": "cipher.final", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cipherfinaloutputencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cipherfinaloutputencoding", "nodeStability": { "index": "2", "level": 2, @@ -8184,7 +8384,7 @@ "label": "cipher.getAuthTag()", "signature": "`cipher.getAuthTag()`", "apiSymbol": "cipher.getAuthTag", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#ciphergetauthtag", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#ciphergetauthtag", "nodeStability": { "index": "2", "level": 2, @@ -8209,7 +8409,7 @@ "label": "cipher.setAAD(buffer[, options])", "signature": "`cipher.setAAD(buffer[, options])`", "apiSymbol": "cipher.setAAD", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#ciphersetaadbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#ciphersetaadbuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -8234,7 +8434,7 @@ "label": "cipher.setAutoPadding([autoPadding])", "signature": "`cipher.setAutoPadding([autoPadding])`", "apiSymbol": "cipher.setAutoPadding", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#ciphersetautopaddingautopadding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#ciphersetautopaddingautopadding", "nodeStability": { "index": "2", "level": 2, @@ -8259,7 +8459,7 @@ "label": "cipher.update(data[, inputEncoding][, outputEncoding])", "signature": "`cipher.update(data[, inputEncoding][, outputEncoding])`", "apiSymbol": "cipher.update", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#cipherupdatedata-inputencoding-outputencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#cipherupdatedata-inputencoding-outputencoding", "nodeStability": { "index": "2", "level": 2, @@ -8284,7 +8484,7 @@ "label": "Decipheriv", "signature": "Class: `Decipheriv`", "apiSymbol": "Decipheriv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-decipheriv", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-decipheriv", "nodeStability": { "index": "2", "level": 2, @@ -8309,7 +8509,7 @@ "label": "decipher.final([outputEncoding])", "signature": "`decipher.final([outputEncoding])`", "apiSymbol": "decipher.final", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#decipherfinaloutputencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#decipherfinaloutputencoding", "nodeStability": { "index": "2", "level": 2, @@ -8334,7 +8534,7 @@ "label": "decipher.setAAD(buffer[, options])", "signature": "`decipher.setAAD(buffer[, options])`", "apiSymbol": "decipher.setAAD", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#deciphersetaadbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#deciphersetaadbuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -8359,7 +8559,7 @@ "label": "decipher.setAuthTag(buffer[, encoding])", "signature": "`decipher.setAuthTag(buffer[, encoding])`", "apiSymbol": "decipher.setAuthTag", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#deciphersetauthtagbuffer-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#deciphersetauthtagbuffer-encoding", "nodeStability": { "index": "2", "level": 2, @@ -8384,7 +8584,7 @@ "label": "decipher.setAutoPadding([autoPadding])", "signature": "`decipher.setAutoPadding([autoPadding])`", "apiSymbol": "decipher.setAutoPadding", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#deciphersetautopaddingautopadding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#deciphersetautopaddingautopadding", "nodeStability": { "index": "2", "level": 2, @@ -8409,7 +8609,7 @@ "label": "decipher.update(data[, inputEncoding][, outputEncoding])", "signature": "`decipher.update(data[, inputEncoding][, outputEncoding])`", "apiSymbol": "decipher.update", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#decipherupdatedata-inputencoding-outputencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#decipherupdatedata-inputencoding-outputencoding", "nodeStability": { "index": "2", "level": 2, @@ -8434,7 +8634,7 @@ "label": "DiffieHellman", "signature": "Class: `DiffieHellman`", "apiSymbol": "DiffieHellman", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-diffiehellman", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-diffiehellman", "nodeStability": { "index": "2", "level": 2, @@ -8459,7 +8659,7 @@ "label": "diffieHellman.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])", "signature": "`diffieHellman.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])`", "apiSymbol": "diffieHellman.computeSecret", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#diffiehellmancomputesecretotherpublickey-inputencoding-outputencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#diffiehellmancomputesecretotherpublickey-inputencoding-outputencoding", "nodeStability": { "index": "2", "level": 2, @@ -8484,7 +8684,7 @@ "label": "diffieHellman.generateKeys([encoding])", "signature": "`diffieHellman.generateKeys([encoding])`", "apiSymbol": "diffieHellman.generateKeys", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#diffiehellmangeneratekeysencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#diffiehellmangeneratekeysencoding", "nodeStability": { "index": "2", "level": 2, @@ -8509,7 +8709,7 @@ "label": "diffieHellman.getGenerator([encoding])", "signature": "`diffieHellman.getGenerator([encoding])`", "apiSymbol": "diffieHellman.getGenerator", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#diffiehellmangetgeneratorencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#diffiehellmangetgeneratorencoding", "nodeStability": { "index": "2", "level": 2, @@ -8534,7 +8734,7 @@ "label": "diffieHellman.getPrime([encoding])", "signature": "`diffieHellman.getPrime([encoding])`", "apiSymbol": "diffieHellman.getPrime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#diffiehellmangetprimeencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#diffiehellmangetprimeencoding", "nodeStability": { "index": "2", "level": 2, @@ -8559,7 +8759,7 @@ "label": "diffieHellman.getPrivateKey([encoding])", "signature": "`diffieHellman.getPrivateKey([encoding])`", "apiSymbol": "diffieHellman.getPrivateKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#diffiehellmangetprivatekeyencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#diffiehellmangetprivatekeyencoding", "nodeStability": { "index": "2", "level": 2, @@ -8584,7 +8784,7 @@ "label": "diffieHellman.getPublicKey([encoding])", "signature": "`diffieHellman.getPublicKey([encoding])`", "apiSymbol": "diffieHellman.getPublicKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#diffiehellmangetpublickeyencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#diffiehellmangetpublickeyencoding", "nodeStability": { "index": "2", "level": 2, @@ -8609,7 +8809,7 @@ "label": "diffieHellman.setPrivateKey(privateKey[, encoding])", "signature": "`diffieHellman.setPrivateKey(privateKey[, encoding])`", "apiSymbol": "diffieHellman.setPrivateKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#diffiehellmansetprivatekeyprivatekey-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#diffiehellmansetprivatekeyprivatekey-encoding", "nodeStability": { "index": "2", "level": 2, @@ -8634,7 +8834,7 @@ "label": "diffieHellman.setPublicKey(publicKey[, encoding])", "signature": "`diffieHellman.setPublicKey(publicKey[, encoding])`", "apiSymbol": "diffieHellman.setPublicKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#diffiehellmansetpublickeypublickey-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#diffiehellmansetpublickeypublickey-encoding", "nodeStability": { "index": "2", "level": 2, @@ -8659,7 +8859,7 @@ "label": "diffieHellman.verifyError", "signature": "`diffieHellman.verifyError`", "apiSymbol": "diffieHellman.verifyError", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#diffiehellmanverifyerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#diffiehellmanverifyerror", "nodeStability": { "index": "2", "level": 2, @@ -8684,7 +8884,7 @@ "label": "DiffieHellmanGroup", "signature": "Class: `DiffieHellmanGroup`", "apiSymbol": "DiffieHellmanGroup", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-diffiehellmangroup", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-diffiehellmangroup", "nodeStability": { "index": "2", "level": 2, @@ -8709,7 +8909,7 @@ "label": "ECDH", "signature": "Class: `ECDH`", "apiSymbol": "ECDH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-ecdh", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-ecdh", "nodeStability": { "index": "2", "level": 2, @@ -8734,7 +8934,7 @@ "label": "ecdh.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])", "signature": "`ecdh.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])`", "apiSymbol": "ecdh.computeSecret", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#ecdhcomputesecretotherpublickey-inputencoding-outputencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#ecdhcomputesecretotherpublickey-inputencoding-outputencoding", "nodeStability": { "index": "2", "level": 2, @@ -8759,7 +8959,7 @@ "label": "ecdh.generateKeys([encoding[, format]])", "signature": "`ecdh.generateKeys([encoding[, format]])`", "apiSymbol": "ecdh.generateKeys", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#ecdhgeneratekeysencoding-format", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#ecdhgeneratekeysencoding-format", "nodeStability": { "index": "2", "level": 2, @@ -8784,7 +8984,7 @@ "label": "ecdh.getPrivateKey([encoding])", "signature": "`ecdh.getPrivateKey([encoding])`", "apiSymbol": "ecdh.getPrivateKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#ecdhgetprivatekeyencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#ecdhgetprivatekeyencoding", "nodeStability": { "index": "2", "level": 2, @@ -8809,7 +9009,7 @@ "label": "ecdh.getPublicKey([encoding][, format])", "signature": "`ecdh.getPublicKey([encoding][, format])`", "apiSymbol": "ecdh.getPublicKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#ecdhgetpublickeyencoding-format", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#ecdhgetpublickeyencoding-format", "nodeStability": { "index": "2", "level": 2, @@ -8834,7 +9034,7 @@ "label": "ecdh.setPrivateKey(privateKey[, encoding])", "signature": "`ecdh.setPrivateKey(privateKey[, encoding])`", "apiSymbol": "ecdh.setPrivateKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#ecdhsetprivatekeyprivatekey-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#ecdhsetprivatekeyprivatekey-encoding", "nodeStability": { "index": "2", "level": 2, @@ -8859,7 +9059,7 @@ "label": "ecdh.setPublicKey(publicKey[, encoding])", "signature": "`ecdh.setPublicKey(publicKey[, encoding])`", "apiSymbol": "ecdh.setPublicKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#ecdhsetpublickeypublickey-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#ecdhsetpublickeypublickey-encoding", "nodeStability": { "index": "0", "level": 0, @@ -8884,7 +9084,7 @@ "label": "Hash", "signature": "Class: `Hash`", "apiSymbol": "Hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-hash", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-hash", "nodeStability": { "index": "2", "level": 2, @@ -8913,7 +9113,7 @@ "label": "hash.copy([options])", "signature": "`hash.copy([options])`", "apiSymbol": "hash.copy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#hashcopyoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#hashcopyoptions", "nodeStability": { "index": "2", "level": 2, @@ -8942,7 +9142,7 @@ "label": "hash.digest([encoding])", "signature": "`hash.digest([encoding])`", "apiSymbol": "hash.digest", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#hashdigestencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#hashdigestencoding", "nodeStability": { "index": "2", "level": 2, @@ -8971,7 +9171,7 @@ "label": "hash.update(data[, inputEncoding])", "signature": "`hash.update(data[, inputEncoding])`", "apiSymbol": "hash.update", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#hashupdatedata-inputencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#hashupdatedata-inputencoding", "nodeStability": { "index": "2", "level": 2, @@ -9000,7 +9200,7 @@ "label": "Hmac", "signature": "Class: `Hmac`", "apiSymbol": "Hmac", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-hmac", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-hmac", "nodeStability": { "index": "2", "level": 2, @@ -9029,7 +9229,7 @@ "label": "hmac.digest([encoding])", "signature": "`hmac.digest([encoding])`", "apiSymbol": "hmac.digest", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#hmacdigestencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#hmacdigestencoding", "nodeStability": { "index": "2", "level": 2, @@ -9058,7 +9258,7 @@ "label": "hmac.update(data[, inputEncoding])", "signature": "`hmac.update(data[, inputEncoding])`", "apiSymbol": "hmac.update", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#hmacupdatedata-inputencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#hmacupdatedata-inputencoding", "nodeStability": { "index": "2", "level": 2, @@ -9087,7 +9287,7 @@ "label": "KeyObject", "signature": "Class: `KeyObject`", "apiSymbol": "KeyObject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-keyobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-keyobject", "nodeStability": { "index": "2", "level": 2, @@ -9112,7 +9312,7 @@ "label": "keyObject.equals(otherKeyObject)", "signature": "`keyObject.equals(otherKeyObject)`", "apiSymbol": "keyObject.equals", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#keyobjectequalsotherkeyobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#keyobjectequalsotherkeyobject", "nodeStability": { "index": "2", "level": 2, @@ -9137,7 +9337,7 @@ "label": "keyObject.export([options])", "signature": "`keyObject.export([options])`", "apiSymbol": "keyObject.export", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#keyobjectexportoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#keyobjectexportoptions", "nodeStability": { "index": "2", "level": 2, @@ -9162,7 +9362,7 @@ "label": "keyObject.toCryptoKey(algorithm, extractable, keyUsages)", "signature": "`keyObject.toCryptoKey(algorithm, extractable, keyUsages)`", "apiSymbol": "keyObject.toCryptoKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#keyobjecttocryptokeyalgorithm-extractable-keyusages", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#keyobjecttocryptokeyalgorithm-extractable-keyusages", "nodeStability": { "index": "2", "level": 2, @@ -9187,7 +9387,7 @@ "label": "asymmetricKeyDetails", "signature": "`asymmetricKeyDetails` Type: {Object}", "apiSymbol": "asymmetricKeyDetails", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-keyobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-keyobject", "nodeStability": { "index": "2", "level": 2, @@ -9212,7 +9412,7 @@ "label": "asymmetricKeyType", "signature": "`asymmetricKeyType` Type: {string}", "apiSymbol": "asymmetricKeyType", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-keyobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-keyobject", "nodeStability": { "index": "2", "level": 2, @@ -9237,7 +9437,7 @@ "label": "symmetricKeySize", "signature": "`symmetricKeySize` Type: {number}", "apiSymbol": "symmetricKeySize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-keyobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-keyobject", "nodeStability": { "index": "2", "level": 2, @@ -9262,7 +9462,82 @@ "label": "type", "signature": "`type` Type: {string}", "apiSymbol": "type", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-keyobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-keyobject", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:crypto", + "tests": [] + } + } + }, + { + "id": "crypto:f5e3bda9577f", + "chapter": "crypto", + "label": "Mac", + "signature": "Class: `Mac`", + "apiSymbol": "Mac", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-mac", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:crypto", + "tests": [] + } + } + }, + { + "id": "crypto:0165406d6a25", + "chapter": "crypto", + "label": "mac.final([outputEncoding])", + "signature": "`mac.final([outputEncoding])`", + "apiSymbol": "mac.final", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#macfinaloutputencoding", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:crypto", + "tests": [] + } + } + }, + { + "id": "crypto:6a72becb6839", + "chapter": "crypto", + "label": "mac.update(data[, inputEncoding])", + "signature": "`mac.update(data[, inputEncoding])`", + "apiSymbol": "mac.update", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#macupdatedata-inputencoding", "nodeStability": { "index": "2", "level": 2, @@ -9287,7 +9562,7 @@ "label": "Sign", "signature": "Class: `Sign`", "apiSymbol": "Sign", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-sign", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-sign", "nodeStability": { "index": "2", "level": 2, @@ -9312,7 +9587,7 @@ "label": "sign.sign(privateKey[, outputEncoding])", "signature": "`sign.sign(privateKey[, outputEncoding])`", "apiSymbol": "sign.sign", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#signsignprivatekey-outputencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#signsignprivatekey-outputencoding", "nodeStability": { "index": "2", "level": 2, @@ -9337,7 +9612,7 @@ "label": "sign.update(data[, inputEncoding])", "signature": "`sign.update(data[, inputEncoding])`", "apiSymbol": "sign.update", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#signupdatedata-inputencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#signupdatedata-inputencoding", "nodeStability": { "index": "2", "level": 2, @@ -9362,7 +9637,7 @@ "label": "Verify", "signature": "Class: `Verify`", "apiSymbol": "Verify", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-verify", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-verify", "nodeStability": { "index": "2", "level": 2, @@ -9387,7 +9662,7 @@ "label": "verify.update(data[, inputEncoding])", "signature": "`verify.update(data[, inputEncoding])`", "apiSymbol": "verify.update", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#verifyupdatedata-inputencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#verifyupdatedata-inputencoding", "nodeStability": { "index": "2", "level": 2, @@ -9407,12 +9682,12 @@ } }, { - "id": "crypto:16511e6f27c0", + "id": "crypto:1376126d8fea", "chapter": "crypto", - "label": "verify.verify(object, signature[, signatureEncoding])", - "signature": "`verify.verify(object, signature[, signatureEncoding])`", + "label": "verify.verify(key, signature[, signatureEncoding])", + "signature": "`verify.verify(key, signature[, signatureEncoding])`", "apiSymbol": "verify.verify", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#verifyverifyobject-signature-signatureencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#verifyverifykey-signature-signatureencoding", "nodeStability": { "index": "2", "level": 2, @@ -9437,7 +9712,7 @@ "label": "X509Certificate", "signature": "Class: `X509Certificate`", "apiSymbol": "X509Certificate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9462,7 +9737,7 @@ "label": "x509.checkEmail(email[, options])", "signature": "`x509.checkEmail(email[, options])`", "apiSymbol": "x509.checkEmail", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#x509checkemailemail-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#x509checkemailemail-options", "nodeStability": { "index": "2", "level": 2, @@ -9487,7 +9762,7 @@ "label": "x509.checkHost(name[, options])", "signature": "`x509.checkHost(name[, options])`", "apiSymbol": "x509.checkHost", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#x509checkhostname-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#x509checkhostname-options", "nodeStability": { "index": "2", "level": 2, @@ -9512,7 +9787,7 @@ "label": "x509.checkIP(ip)", "signature": "`x509.checkIP(ip)`", "apiSymbol": "x509.checkIP", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#x509checkipip", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#x509checkipip", "nodeStability": { "index": "2", "level": 2, @@ -9537,7 +9812,7 @@ "label": "x509.checkIssued(otherCert)", "signature": "`x509.checkIssued(otherCert)`", "apiSymbol": "x509.checkIssued", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#x509checkissuedothercert", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#x509checkissuedothercert", "nodeStability": { "index": "2", "level": 2, @@ -9562,7 +9837,7 @@ "label": "x509.checkPrivateKey(privateKey)", "signature": "`x509.checkPrivateKey(privateKey)`", "apiSymbol": "x509.checkPrivateKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#x509checkprivatekeyprivatekey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#x509checkprivatekeyprivatekey", "nodeStability": { "index": "2", "level": 2, @@ -9587,7 +9862,7 @@ "label": "x509.toJSON()", "signature": "`x509.toJSON()`", "apiSymbol": "x509.toJSON", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#x509tojson", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#x509tojson", "nodeStability": { "index": "2", "level": 2, @@ -9612,7 +9887,7 @@ "label": "x509.toLegacyObject()", "signature": "`x509.toLegacyObject()`", "apiSymbol": "x509.toLegacyObject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#x509tolegacyobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#x509tolegacyobject", "nodeStability": { "index": "2", "level": 2, @@ -9637,7 +9912,7 @@ "label": "x509.toString()", "signature": "`x509.toString()`", "apiSymbol": "x509.toString", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#x509tostring", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#x509tostring", "nodeStability": { "index": "2", "level": 2, @@ -9662,7 +9937,7 @@ "label": "x509.verify(publicKey)", "signature": "`x509.verify(publicKey)`", "apiSymbol": "x509.verify", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#x509verifypublickey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#x509verifypublickey", "nodeStability": { "index": "2", "level": 2, @@ -9687,7 +9962,7 @@ "label": "ca", "signature": "`ca` Type: {boolean} Will be `true` if this is a Certificate Authority (CA) certificate.", "apiSymbol": "ca", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9712,7 +9987,7 @@ "label": "fingerprint", "signature": "`fingerprint` Type: {string}", "apiSymbol": "fingerprint", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9737,7 +10012,7 @@ "label": "fingerprint256", "signature": "`fingerprint256` Type: {string}", "apiSymbol": "fingerprint256", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9762,7 +10037,7 @@ "label": "fingerprint512", "signature": "`fingerprint512` Type: {string}", "apiSymbol": "fingerprint512", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9787,7 +10062,7 @@ "label": "infoAccess", "signature": "`infoAccess` Type: {string}", "apiSymbol": "infoAccess", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9812,7 +10087,7 @@ "label": "issuer", "signature": "`issuer` Type: {string}", "apiSymbol": "issuer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9837,7 +10112,7 @@ "label": "issuerCertificate", "signature": "`issuerCertificate` Type: {X509Certificate}", "apiSymbol": "issuerCertificate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9862,7 +10137,7 @@ "label": "keyUsage", "signature": "`keyUsage` Type: {string\\[]}", "apiSymbol": "keyUsage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9887,7 +10162,7 @@ "label": "publicKey", "signature": "`publicKey` Type: {KeyObject}", "apiSymbol": "publicKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9912,7 +10187,7 @@ "label": "raw", "signature": "`raw` Type: {Buffer}", "apiSymbol": "raw", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9937,7 +10212,7 @@ "label": "serialNumber", "signature": "`serialNumber` Type: {string}", "apiSymbol": "serialNumber", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9962,7 +10237,7 @@ "label": "subject", "signature": "`subject` Type: {string}", "apiSymbol": "subject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -9987,7 +10262,7 @@ "label": "subjectAltName", "signature": "`subjectAltName` Type: {string}", "apiSymbol": "subjectAltName", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -10012,7 +10287,7 @@ "label": "validFrom", "signature": "`validFrom` Type: {string}", "apiSymbol": "validFrom", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -10037,7 +10312,7 @@ "label": "validFromDate", "signature": "`validFromDate` Type: {Date}", "apiSymbol": "validFromDate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -10062,7 +10337,7 @@ "label": "validTo", "signature": "`validTo` Type: {string}", "apiSymbol": "validTo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -10087,7 +10362,7 @@ "label": "validToDate", "signature": "`validToDate` Type: {Date}", "apiSymbol": "validToDate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -10112,7 +10387,7 @@ "label": "signatureAlgorithm", "signature": "`signatureAlgorithm` Type: {string|undefined}", "apiSymbol": "signatureAlgorithm", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -10137,7 +10412,7 @@ "label": "signatureAlgorithmOid", "signature": "`signatureAlgorithmOid` Type: {string}", "apiSymbol": "signatureAlgorithmOid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/crypto.html#class-x509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/crypto.html#class-x509certificate", "nodeStability": { "index": "2", "level": 2, @@ -10162,7 +10437,7 @@ "label": "diagnostics_channel.hasSubscribers(name)", "signature": "`diagnostics_channel.hasSubscribers(name)`", "apiSymbol": "diagnostics_channel.hasSubscribers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#diagnostics_channelhassubscribersname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#diagnostics_channelhassubscribersname", "nodeStability": { "index": "2", "level": 2, @@ -10189,7 +10464,7 @@ "label": "diagnostics_channel.channel(name)", "signature": "`diagnostics_channel.channel(name)`", "apiSymbol": "diagnostics_channel.channel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#diagnostics_channelchannelname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#diagnostics_channelchannelname", "nodeStability": { "index": "2", "level": 2, @@ -10216,7 +10491,7 @@ "label": "diagnostics_channel.subscribe(name, onMessage)", "signature": "`diagnostics_channel.subscribe(name, onMessage)`", "apiSymbol": "diagnostics_channel.subscribe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#diagnostics_channelsubscribename-onmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#diagnostics_channelsubscribename-onmessage", "nodeStability": { "index": "2", "level": 2, @@ -10243,7 +10518,7 @@ "label": "diagnostics_channel.unsubscribe(name, onMessage)", "signature": "`diagnostics_channel.unsubscribe(name, onMessage)`", "apiSymbol": "diagnostics_channel.unsubscribe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#diagnostics_channelunsubscribename-onmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#diagnostics_channelunsubscribename-onmessage", "nodeStability": { "index": "2", "level": 2, @@ -10270,7 +10545,7 @@ "label": "diagnostics_channel.tracingChannel(nameOrChannels)", "signature": "`diagnostics_channel.tracingChannel(nameOrChannels)`", "apiSymbol": "diagnostics_channel.tracingChannel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#diagnostics_channeltracingchannelnameorchannels", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#diagnostics_channeltracingchannelnameorchannels", "nodeStability": { "index": "1", "level": 1, @@ -10297,7 +10572,7 @@ "label": "start(event)", "signature": "`start(event)`", "apiSymbol": "start", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#startevent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#startevent", "nodeStability": { "index": "2", "level": 2, @@ -10322,7 +10597,7 @@ "label": "end(event)", "signature": "`end(event)`", "apiSymbol": "end", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#endevent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#endevent", "nodeStability": { "index": "2", "level": 2, @@ -10347,7 +10622,7 @@ "label": "asyncStart(event)", "signature": "`asyncStart(event)`", "apiSymbol": "asyncStart", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#asyncstartevent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#asyncstartevent", "nodeStability": { "index": "2", "level": 2, @@ -10372,7 +10647,7 @@ "label": "asyncEnd(event)", "signature": "`asyncEnd(event)`", "apiSymbol": "asyncEnd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#asyncendevent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#asyncendevent", "nodeStability": { "index": "2", "level": 2, @@ -10397,7 +10672,7 @@ "label": "error(event)", "signature": "`error(event)`", "apiSymbol": "error", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#errorevent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#errorevent", "nodeStability": { "index": "2", "level": 2, @@ -10422,7 +10697,7 @@ "label": "'console.log'", "signature": "Event: `'console.log'`", "apiSymbol": "'console.log'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-consolelog", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-consolelog", "nodeStability": { "index": "1", "level": 1, @@ -10447,7 +10722,7 @@ "label": "'console.info'", "signature": "Event: `'console.info'`", "apiSymbol": "'console.info'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-consoleinfo", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-consoleinfo", "nodeStability": { "index": "1", "level": 1, @@ -10472,7 +10747,7 @@ "label": "'console.debug'", "signature": "Event: `'console.debug'`", "apiSymbol": "'console.debug'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-consoledebug", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-consoledebug", "nodeStability": { "index": "1", "level": 1, @@ -10497,7 +10772,7 @@ "label": "'console.warn'", "signature": "Event: `'console.warn'`", "apiSymbol": "'console.warn'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-consolewarn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-consolewarn", "nodeStability": { "index": "1", "level": 1, @@ -10522,7 +10797,32 @@ "label": "'console.error'", "signature": "Event: `'console.error'`", "apiSymbol": "'console.error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-consoleerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-consoleerror", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:diagnostics_channel", + "tests": [] + } + } + }, + { + "id": "diagnostics_channel:80f3f937cfe0", + "chapter": "diagnostics_channel", + "label": "'crypto.fips.indicator'", + "signature": "Event: `'crypto.fips.indicator'`", + "apiSymbol": "'crypto.fips.indicator'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-cryptofipsindicator", "nodeStability": { "index": "1", "level": 1, @@ -10547,7 +10847,7 @@ "label": "'http.client.request.created'", "signature": "Event: `'http.client.request.created'`", "apiSymbol": "'http.client.request.created'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-httpclientrequestcreated", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-httpclientrequestcreated", "nodeStability": { "index": "1", "level": 1, @@ -10572,7 +10872,7 @@ "label": "'http.client.request.start'", "signature": "Event: `'http.client.request.start'`", "apiSymbol": "'http.client.request.start'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-httpclientrequeststart", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-httpclientrequeststart", "nodeStability": { "index": "1", "level": 1, @@ -10597,7 +10897,7 @@ "label": "'http.client.request.error'", "signature": "Event: `'http.client.request.error'`", "apiSymbol": "'http.client.request.error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-httpclientrequesterror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-httpclientrequesterror", "nodeStability": { "index": "1", "level": 1, @@ -10622,7 +10922,7 @@ "label": "'http.client.response.finish'", "signature": "Event: `'http.client.response.finish'`", "apiSymbol": "'http.client.response.finish'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-httpclientresponsefinish", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-httpclientresponsefinish", "nodeStability": { "index": "1", "level": 1, @@ -10647,7 +10947,7 @@ "label": "'http.server.request.start'", "signature": "Event: `'http.server.request.start'`", "apiSymbol": "'http.server.request.start'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-httpserverrequeststart", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-httpserverrequeststart", "nodeStability": { "index": "1", "level": 1, @@ -10672,7 +10972,7 @@ "label": "'http.server.response.created'", "signature": "Event: `'http.server.response.created'`", "apiSymbol": "'http.server.response.created'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-httpserverresponsecreated", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-httpserverresponsecreated", "nodeStability": { "index": "1", "level": 1, @@ -10697,7 +10997,7 @@ "label": "'http.server.response.finish'", "signature": "Event: `'http.server.response.finish'`", "apiSymbol": "'http.server.response.finish'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-httpserverresponsefinish", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-httpserverresponsefinish", "nodeStability": { "index": "1", "level": 1, @@ -10722,7 +11022,7 @@ "label": "'http2.client.stream.created'", "signature": "Event: `'http2.client.stream.created'`", "apiSymbol": "'http2.client.stream.created'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-http2clientstreamcreated", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-http2clientstreamcreated", "nodeStability": { "index": "1", "level": 1, @@ -10747,7 +11047,7 @@ "label": "'http2.client.stream.start'", "signature": "Event: `'http2.client.stream.start'`", "apiSymbol": "'http2.client.stream.start'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-http2clientstreamstart", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-http2clientstreamstart", "nodeStability": { "index": "1", "level": 1, @@ -10772,7 +11072,7 @@ "label": "'http2.client.stream.error'", "signature": "Event: `'http2.client.stream.error'`", "apiSymbol": "'http2.client.stream.error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-http2clientstreamerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-http2clientstreamerror", "nodeStability": { "index": "1", "level": 1, @@ -10797,7 +11097,7 @@ "label": "'http2.client.stream.finish'", "signature": "Event: `'http2.client.stream.finish'`", "apiSymbol": "'http2.client.stream.finish'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-http2clientstreamfinish", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-http2clientstreamfinish", "nodeStability": { "index": "1", "level": 1, @@ -10822,7 +11122,7 @@ "label": "'http2.client.stream.bodyChunkSent'", "signature": "Event: `'http2.client.stream.bodyChunkSent'`", "apiSymbol": "'http2.client.stream.bodyChunkSent'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-http2clientstreambodychunksent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-http2clientstreambodychunksent", "nodeStability": { "index": "1", "level": 1, @@ -10847,7 +11147,7 @@ "label": "'http2.client.stream.bodySent'", "signature": "Event: `'http2.client.stream.bodySent'`", "apiSymbol": "'http2.client.stream.bodySent'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-http2clientstreambodysent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-http2clientstreambodysent", "nodeStability": { "index": "1", "level": 1, @@ -10872,7 +11172,7 @@ "label": "'http2.client.stream.close'", "signature": "Event: `'http2.client.stream.close'`", "apiSymbol": "'http2.client.stream.close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-http2clientstreamclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-http2clientstreamclose", "nodeStability": { "index": "1", "level": 1, @@ -10897,7 +11197,7 @@ "label": "'http2.server.stream.created'", "signature": "Event: `'http2.server.stream.created'`", "apiSymbol": "'http2.server.stream.created'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-http2serverstreamcreated", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-http2serverstreamcreated", "nodeStability": { "index": "1", "level": 1, @@ -10922,7 +11222,7 @@ "label": "'http2.server.stream.start'", "signature": "Event: `'http2.server.stream.start'`", "apiSymbol": "'http2.server.stream.start'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-http2serverstreamstart", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-http2serverstreamstart", "nodeStability": { "index": "1", "level": 1, @@ -10947,7 +11247,7 @@ "label": "'http2.server.stream.error'", "signature": "Event: `'http2.server.stream.error'`", "apiSymbol": "'http2.server.stream.error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-http2serverstreamerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-http2serverstreamerror", "nodeStability": { "index": "1", "level": 1, @@ -10972,7 +11272,7 @@ "label": "'http2.server.stream.finish'", "signature": "Event: `'http2.server.stream.finish'`", "apiSymbol": "'http2.server.stream.finish'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-http2serverstreamfinish", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-http2serverstreamfinish", "nodeStability": { "index": "1", "level": 1, @@ -10997,7 +11297,7 @@ "label": "'http2.server.stream.close'", "signature": "Event: `'http2.server.stream.close'`", "apiSymbol": "'http2.server.stream.close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-http2serverstreamclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-http2serverstreamclose", "nodeStability": { "index": "1", "level": 1, @@ -11017,12 +11317,12 @@ } }, { - "id": "diagnostics_channel:d1c41884e542", + "id": "diagnostics_channel:bb1dd3918bd5", "chapter": "diagnostics_channel", - "label": "'module.require.start'", - "signature": "Event: `'module.require.start'`", - "apiSymbol": "'module.require.start'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-modulerequirestart", + "label": "'tracing:module.require:start'", + "signature": "Event: `'tracing:module.require:start'`", + "apiSymbol": "'tracing:module.require:start'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-tracingmodulerequirestart", "nodeStability": { "index": "1", "level": 1, @@ -11042,12 +11342,12 @@ } }, { - "id": "diagnostics_channel:4cd1c32b77c6", + "id": "diagnostics_channel:990ea4c5a9d7", "chapter": "diagnostics_channel", - "label": "'module.require.end'", - "signature": "Event: `'module.require.end'`", - "apiSymbol": "'module.require.end'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-modulerequireend", + "label": "'tracing:module.require:end'", + "signature": "Event: `'tracing:module.require:end'`", + "apiSymbol": "'tracing:module.require:end'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-tracingmodulerequireend", "nodeStability": { "index": "1", "level": 1, @@ -11067,12 +11367,12 @@ } }, { - "id": "diagnostics_channel:cd31d16f125f", + "id": "diagnostics_channel:494f069b7279", "chapter": "diagnostics_channel", - "label": "'module.require.error'", - "signature": "Event: `'module.require.error'`", - "apiSymbol": "'module.require.error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-modulerequireerror", + "label": "'tracing:module.require:error'", + "signature": "Event: `'tracing:module.require:error'`", + "apiSymbol": "'tracing:module.require:error'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-tracingmodulerequireerror", "nodeStability": { "index": "1", "level": 1, @@ -11092,12 +11392,12 @@ } }, { - "id": "diagnostics_channel:a2840f3e48cc", + "id": "diagnostics_channel:24d45c5b63f5", "chapter": "diagnostics_channel", - "label": "'module.import.asyncStart'", - "signature": "Event: `'module.import.asyncStart'`", - "apiSymbol": "'module.import.asyncStart'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-moduleimportasyncstart", + "label": "'tracing:module.import:asyncStart'", + "signature": "Event: `'tracing:module.import:asyncStart'`", + "apiSymbol": "'tracing:module.import:asyncStart'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-tracingmoduleimportasyncstart", "nodeStability": { "index": "1", "level": 1, @@ -11117,12 +11417,12 @@ } }, { - "id": "diagnostics_channel:730d6618877f", + "id": "diagnostics_channel:fd44953e860d", "chapter": "diagnostics_channel", - "label": "'module.import.asyncEnd'", - "signature": "Event: `'module.import.asyncEnd'`", - "apiSymbol": "'module.import.asyncEnd'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-moduleimportasyncend", + "label": "'tracing:module.import:asyncEnd'", + "signature": "Event: `'tracing:module.import:asyncEnd'`", + "apiSymbol": "'tracing:module.import:asyncEnd'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-tracingmoduleimportasyncend", "nodeStability": { "index": "1", "level": 1, @@ -11142,12 +11442,12 @@ } }, { - "id": "diagnostics_channel:b94f162dfbad", + "id": "diagnostics_channel:a25388ac262b", "chapter": "diagnostics_channel", - "label": "'module.import.error'", - "signature": "Event: `'module.import.error'`", - "apiSymbol": "'module.import.error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-moduleimporterror", + "label": "'tracing:module.import:error'", + "signature": "Event: `'tracing:module.import:error'`", + "apiSymbol": "'tracing:module.import:error'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-tracingmoduleimporterror", "nodeStability": { "index": "1", "level": 1, @@ -11172,7 +11472,7 @@ "label": "'net.client.socket'", "signature": "Event: `'net.client.socket'`", "apiSymbol": "'net.client.socket'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-netclientsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-netclientsocket", "nodeStability": { "index": "1", "level": 1, @@ -11197,7 +11497,7 @@ "label": "'net.server.socket'", "signature": "Event: `'net.server.socket'`", "apiSymbol": "'net.server.socket'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-netserversocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-netserversocket", "nodeStability": { "index": "1", "level": 1, @@ -11222,7 +11522,7 @@ "label": "'tracing:net.server.listen:asyncStart'", "signature": "Event: `'tracing:net.server.listen:asyncStart'`", "apiSymbol": "'tracing:net.server.listen:asyncStart'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-tracingnetserverlistenasyncstart", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-tracingnetserverlistenasyncstart", "nodeStability": { "index": "1", "level": 1, @@ -11247,7 +11547,7 @@ "label": "'tracing:net.server.listen:asyncEnd'", "signature": "Event: `'tracing:net.server.listen:asyncEnd'`", "apiSymbol": "'tracing:net.server.listen:asyncEnd'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-tracingnetserverlistenasyncend", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-tracingnetserverlistenasyncend", "nodeStability": { "index": "1", "level": 1, @@ -11272,7 +11572,7 @@ "label": "'tracing:net.server.listen:error'", "signature": "Event: `'tracing:net.server.listen:error'`", "apiSymbol": "'tracing:net.server.listen:error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-tracingnetserverlistenerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-tracingnetserverlistenerror", "nodeStability": { "index": "1", "level": 1, @@ -11297,7 +11597,7 @@ "label": "'udp.socket'", "signature": "Event: `'udp.socket'`", "apiSymbol": "'udp.socket'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-udpsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-udpsocket", "nodeStability": { "index": "1", "level": 1, @@ -11322,7 +11622,7 @@ "label": "'child_process'", "signature": "Event: `'child_process'`", "apiSymbol": "'child_process'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-child_process", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-child_process", "nodeStability": { "index": "1", "level": 1, @@ -11342,12 +11642,12 @@ } }, { - "id": "diagnostics_channel:3e684ab90652", + "id": "diagnostics_channel:990885f7c68c", "chapter": "diagnostics_channel", - "label": "'execve'", - "signature": "Event: `'execve'`", - "apiSymbol": "'execve'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-execve", + "label": "'process.execve'", + "signature": "Event: `'process.execve'`", + "apiSymbol": "'process.execve'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-processexecve", "nodeStability": { "index": "1", "level": 1, @@ -11372,7 +11672,7 @@ "label": "'locks.request.start'", "signature": "Event: `'locks.request.start'`", "apiSymbol": "'locks.request.start'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-locksrequeststart", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-locksrequeststart", "nodeStability": { "index": "1", "level": 1, @@ -11397,7 +11697,7 @@ "label": "'locks.request.grant'", "signature": "Event: `'locks.request.grant'`", "apiSymbol": "'locks.request.grant'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-locksrequestgrant", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-locksrequestgrant", "nodeStability": { "index": "1", "level": 1, @@ -11422,7 +11722,7 @@ "label": "'locks.request.miss'", "signature": "Event: `'locks.request.miss'`", "apiSymbol": "'locks.request.miss'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-locksrequestmiss", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-locksrequestmiss", "nodeStability": { "index": "1", "level": 1, @@ -11447,7 +11747,7 @@ "label": "'locks.request.end'", "signature": "Event: `'locks.request.end'`", "apiSymbol": "'locks.request.end'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-locksrequestend", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-locksrequestend", "nodeStability": { "index": "1", "level": 1, @@ -11472,7 +11772,32 @@ "label": "'worker_threads'", "signature": "Event: `'worker_threads'`", "apiSymbol": "'worker_threads'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#event-worker_threads", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-worker_threads", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:diagnostics_channel", + "tests": [] + } + } + }, + { + "id": "diagnostics_channel:f9ab0dfd2826", + "chapter": "diagnostics_channel", + "label": "'sqlite.db.query'", + "signature": "Event: `'sqlite.db.query'`", + "apiSymbol": "'sqlite.db.query'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#event-sqlitedbquery", "nodeStability": { "index": "1", "level": 1, @@ -11497,7 +11822,7 @@ "label": "Channel", "signature": "Class: `Channel`", "apiSymbol": "Channel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#class-channel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#class-channel", "nodeStability": { "index": "2", "level": 2, @@ -11522,7 +11847,7 @@ "label": "channel.publish(message)", "signature": "`channel.publish(message)`", "apiSymbol": "channel.publish", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#channelpublishmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#channelpublishmessage", "nodeStability": { "index": "2", "level": 2, @@ -11547,7 +11872,7 @@ "label": "channel.subscribe(onMessage)", "signature": "`channel.subscribe(onMessage)`", "apiSymbol": "channel.subscribe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#channelsubscribeonmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#channelsubscribeonmessage", "nodeStability": { "index": "2", "level": 2, @@ -11572,7 +11897,7 @@ "label": "channel.unsubscribe(onMessage)", "signature": "`channel.unsubscribe(onMessage)`", "apiSymbol": "channel.unsubscribe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#channelunsubscribeonmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#channelunsubscribeonmessage", "nodeStability": { "index": "2", "level": 2, @@ -11597,7 +11922,7 @@ "label": "channel.bindStore(store[, transform])", "signature": "`channel.bindStore(store[, transform])`", "apiSymbol": "channel.bindStore", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#channelbindstorestore-transform", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#channelbindstorestore-transform", "nodeStability": { "index": "1", "level": 1, @@ -11622,7 +11947,7 @@ "label": "channel.unbindStore(store)", "signature": "`channel.unbindStore(store)`", "apiSymbol": "channel.unbindStore", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#channelunbindstorestore", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#channelunbindstorestore", "nodeStability": { "index": "1", "level": 1, @@ -11647,7 +11972,7 @@ "label": "channel.runStores(context, fn[, thisArg[, ...args]])", "signature": "`channel.runStores(context, fn[, thisArg[, ...args]])`", "apiSymbol": "channel.runStores", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#channelrunstorescontext-fn-thisarg-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#channelrunstorescontext-fn-thisarg-args", "nodeStability": { "index": "1", "level": 1, @@ -11672,7 +11997,7 @@ "label": "hasSubscribers", "signature": "`hasSubscribers` Returns: {boolean} If there are active subscribers", "apiSymbol": "hasSubscribers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#class-channel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#class-channel", "nodeStability": { "index": "2", "level": 2, @@ -11699,7 +12024,7 @@ "label": "TracingChannel", "signature": "Class: `TracingChannel`", "apiSymbol": "TracingChannel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#class-tracingchannel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#class-tracingchannel", "nodeStability": { "index": "1", "level": 1, @@ -11724,7 +12049,7 @@ "label": "tracingChannel.subscribe(subscribers)", "signature": "`tracingChannel.subscribe(subscribers)`", "apiSymbol": "tracingChannel.subscribe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#tracingchannelsubscribesubscribers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#tracingchannelsubscribesubscribers", "nodeStability": { "index": "1", "level": 1, @@ -11749,7 +12074,7 @@ "label": "tracingChannel.unsubscribe(subscribers)", "signature": "`tracingChannel.unsubscribe(subscribers)`", "apiSymbol": "tracingChannel.unsubscribe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#tracingchannelunsubscribesubscribers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#tracingchannelunsubscribesubscribers", "nodeStability": { "index": "1", "level": 1, @@ -11774,7 +12099,7 @@ "label": "tracingChannel.traceSync(fn[, context[, thisArg[, ...args]]])", "signature": "`tracingChannel.traceSync(fn[, context[, thisArg[, ...args]]])`", "apiSymbol": "tracingChannel.traceSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#tracingchanneltracesyncfn-context-thisarg-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#tracingchanneltracesyncfn-context-thisarg-args", "nodeStability": { "index": "1", "level": 1, @@ -11799,7 +12124,7 @@ "label": "tracingChannel.tracePromise(fn[, context[, thisArg[, ...args]]])", "signature": "`tracingChannel.tracePromise(fn[, context[, thisArg[, ...args]]])`", "apiSymbol": "tracingChannel.tracePromise", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#tracingchanneltracepromisefn-context-thisarg-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#tracingchanneltracepromisefn-context-thisarg-args", "nodeStability": { "index": "1", "level": 1, @@ -11824,7 +12149,7 @@ "label": "tracingChannel.traceCallback(fn[, position[, context[, thisArg[, ...args]]]])", "signature": "`tracingChannel.traceCallback(fn[, position[, context[, thisArg[, ...args]]]])`", "apiSymbol": "tracingChannel.traceCallback", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#tracingchanneltracecallbackfn-position-context-thisarg-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#tracingchanneltracecallbackfn-position-context-thisarg-args", "nodeStability": { "index": "1", "level": 1, @@ -11849,7 +12174,7 @@ "label": "hasSubscribers", "signature": "`hasSubscribers` Returns: {boolean} `true` if any of the individual channels has a subscriber, `false` if not.", "apiSymbol": "hasSubscribers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/diagnostics_channel.html#class-tracingchannel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/diagnostics_channel.html#class-tracingchannel", "nodeStability": { "index": "1", "level": 1, @@ -11876,7 +12201,7 @@ "label": "dnsPromises.Resolver", "signature": "Class: `dnsPromises.Resolver`", "apiSymbol": "dnsPromises.Resolver", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#class-dnspromisesresolver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#class-dnspromisesresolver", "nodeStability": { "index": "2", "level": 2, @@ -11901,7 +12226,7 @@ "label": "resolver.cancel()", "signature": "`resolver.cancel()`", "apiSymbol": "resolver.cancel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#resolvercancel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#resolvercancel", "nodeStability": { "index": "2", "level": 2, @@ -11926,7 +12251,7 @@ "label": "dnsPromises.getServers()", "signature": "`dnsPromises.getServers()`", "apiSymbol": "dnsPromises.getServers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesgetservers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesgetservers", "nodeStability": { "index": "2", "level": 2, @@ -11951,7 +12276,7 @@ "label": "dnsPromises.lookup(hostname[, options])", "signature": "`dnsPromises.lookup(hostname[, options])`", "apiSymbol": "dnsPromises.lookup", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromiseslookuphostname-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromiseslookuphostname-options", "nodeStability": { "index": "2", "level": 2, @@ -11976,7 +12301,7 @@ "label": "dnsPromises.lookupService(address, port)", "signature": "`dnsPromises.lookupService(address, port)`", "apiSymbol": "dnsPromises.lookupService", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromiseslookupserviceaddress-port", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromiseslookupserviceaddress-port", "nodeStability": { "index": "2", "level": 2, @@ -12001,7 +12326,7 @@ "label": "dnsPromises.resolve(hostname[, rrtype])", "signature": "`dnsPromises.resolve(hostname[, rrtype])`", "apiSymbol": "dnsPromises.resolve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolvehostname-rrtype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolvehostname-rrtype", "nodeStability": { "index": "2", "level": 2, @@ -12026,7 +12351,7 @@ "label": "dnsPromises.resolve4(hostname[, options])", "signature": "`dnsPromises.resolve4(hostname[, options])`", "apiSymbol": "dnsPromises.resolve4", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolve4hostname-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolve4hostname-options", "nodeStability": { "index": "2", "level": 2, @@ -12051,7 +12376,7 @@ "label": "dnsPromises.resolve6(hostname[, options])", "signature": "`dnsPromises.resolve6(hostname[, options])`", "apiSymbol": "dnsPromises.resolve6", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolve6hostname-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolve6hostname-options", "nodeStability": { "index": "2", "level": 2, @@ -12076,7 +12401,7 @@ "label": "dnsPromises.resolveAny(hostname)", "signature": "`dnsPromises.resolveAny(hostname)`", "apiSymbol": "dnsPromises.resolveAny", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolveanyhostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolveanyhostname", "nodeStability": { "index": "2", "level": 2, @@ -12101,7 +12426,7 @@ "label": "dnsPromises.resolveCaa(hostname)", "signature": "`dnsPromises.resolveCaa(hostname)`", "apiSymbol": "dnsPromises.resolveCaa", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolvecaahostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolvecaahostname", "nodeStability": { "index": "2", "level": 2, @@ -12126,7 +12451,7 @@ "label": "dnsPromises.resolveCname(hostname)", "signature": "`dnsPromises.resolveCname(hostname)`", "apiSymbol": "dnsPromises.resolveCname", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolvecnamehostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolvecnamehostname", "nodeStability": { "index": "2", "level": 2, @@ -12151,7 +12476,7 @@ "label": "dnsPromises.resolveMx(hostname)", "signature": "`dnsPromises.resolveMx(hostname)`", "apiSymbol": "dnsPromises.resolveMx", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolvemxhostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolvemxhostname", "nodeStability": { "index": "2", "level": 2, @@ -12176,7 +12501,7 @@ "label": "dnsPromises.resolveNaptr(hostname)", "signature": "`dnsPromises.resolveNaptr(hostname)`", "apiSymbol": "dnsPromises.resolveNaptr", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolvenaptrhostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolvenaptrhostname", "nodeStability": { "index": "2", "level": 2, @@ -12201,7 +12526,7 @@ "label": "dnsPromises.resolveNs(hostname)", "signature": "`dnsPromises.resolveNs(hostname)`", "apiSymbol": "dnsPromises.resolveNs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolvenshostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolvenshostname", "nodeStability": { "index": "2", "level": 2, @@ -12226,7 +12551,7 @@ "label": "dnsPromises.resolvePtr(hostname)", "signature": "`dnsPromises.resolvePtr(hostname)`", "apiSymbol": "dnsPromises.resolvePtr", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolveptrhostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolveptrhostname", "nodeStability": { "index": "2", "level": 2, @@ -12251,7 +12576,7 @@ "label": "dnsPromises.resolveSoa(hostname)", "signature": "`dnsPromises.resolveSoa(hostname)`", "apiSymbol": "dnsPromises.resolveSoa", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolvesoahostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolvesoahostname", "nodeStability": { "index": "2", "level": 2, @@ -12276,7 +12601,7 @@ "label": "dnsPromises.resolveSrv(hostname)", "signature": "`dnsPromises.resolveSrv(hostname)`", "apiSymbol": "dnsPromises.resolveSrv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolvesrvhostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolvesrvhostname", "nodeStability": { "index": "2", "level": 2, @@ -12301,7 +12626,7 @@ "label": "dnsPromises.resolveTlsa(hostname)", "signature": "`dnsPromises.resolveTlsa(hostname)`", "apiSymbol": "dnsPromises.resolveTlsa", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolvetlsahostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolvetlsahostname", "nodeStability": { "index": "2", "level": 2, @@ -12326,7 +12651,7 @@ "label": "dnsPromises.resolveTxt(hostname)", "signature": "`dnsPromises.resolveTxt(hostname)`", "apiSymbol": "dnsPromises.resolveTxt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesresolvetxthostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesresolvetxthostname", "nodeStability": { "index": "2", "level": 2, @@ -12351,7 +12676,7 @@ "label": "dnsPromises.reverse(ip)", "signature": "`dnsPromises.reverse(ip)`", "apiSymbol": "dnsPromises.reverse", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesreverseip", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesreverseip", "nodeStability": { "index": "2", "level": 2, @@ -12376,7 +12701,7 @@ "label": "dnsPromises.setDefaultResultOrder(order)", "signature": "`dnsPromises.setDefaultResultOrder(order)`", "apiSymbol": "dnsPromises.setDefaultResultOrder", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisessetdefaultresultorderorder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisessetdefaultresultorderorder", "nodeStability": { "index": "2", "level": 2, @@ -12401,7 +12726,7 @@ "label": "dnsPromises.getDefaultResultOrder()", "signature": "`dnsPromises.getDefaultResultOrder()`", "apiSymbol": "dnsPromises.getDefaultResultOrder", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisesgetdefaultresultorder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisesgetdefaultresultorder", "nodeStability": { "index": "2", "level": 2, @@ -12426,7 +12751,7 @@ "label": "dnsPromises.setServers(servers)", "signature": "`dnsPromises.setServers(servers)`", "apiSymbol": "dnsPromises.setServers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnspromisessetserversservers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnspromisessetserversservers", "nodeStability": { "index": "2", "level": 2, @@ -12451,7 +12776,7 @@ "label": "dns.resolve()", "signature": "`dns.resolve()`, `dns.resolve*()`, and `dns.reverse()`", "apiSymbol": "dns.resolve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolve-dnsresolve-and-dnsreverse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolve-dnsresolve-and-dnsreverse", "nodeStability": { "index": "2", "level": 2, @@ -12476,7 +12801,7 @@ "label": "dns.lookup()", "signature": "`dns.lookup()`", "apiSymbol": "dns.lookup", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnslookup", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnslookup", "nodeStability": { "index": "2", "level": 2, @@ -12501,7 +12826,7 @@ "label": "dns.Resolver", "signature": "Class: `dns.Resolver`", "apiSymbol": "dns.Resolver", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#class-dnsresolver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#class-dnsresolver", "nodeStability": { "index": "2", "level": 2, @@ -12526,7 +12851,7 @@ "label": "Resolver([options])", "signature": "`Resolver([options])`", "apiSymbol": "Resolver", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#resolveroptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#resolveroptions", "nodeStability": { "index": "2", "level": 2, @@ -12551,7 +12876,7 @@ "label": "resolver.cancel()", "signature": "`resolver.cancel()`", "apiSymbol": "resolver.cancel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#resolvercancel_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#resolvercancel_1", "nodeStability": { "index": "2", "level": 2, @@ -12576,7 +12901,7 @@ "label": "resolver.setLocalAddress([ipv4][, ipv6])", "signature": "`resolver.setLocalAddress([ipv4][, ipv6])`", "apiSymbol": "resolver.setLocalAddress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#resolversetlocaladdressipv4-ipv6", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#resolversetlocaladdressipv4-ipv6", "nodeStability": { "index": "2", "level": 2, @@ -12601,7 +12926,7 @@ "label": "dns.getServers()", "signature": "`dns.getServers()`", "apiSymbol": "dns.getServers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsgetservers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsgetservers", "nodeStability": { "index": "2", "level": 2, @@ -12626,7 +12951,7 @@ "label": "dns.lookup(hostname[, options], callback)", "signature": "`dns.lookup(hostname[, options], callback)`", "apiSymbol": "dns.lookup", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnslookuphostname-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnslookuphostname-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -12651,7 +12976,7 @@ "label": "dns.lookupService(address, port, callback)", "signature": "`dns.lookupService(address, port, callback)`", "apiSymbol": "dns.lookupService", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnslookupserviceaddress-port-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnslookupserviceaddress-port-callback", "nodeStability": { "index": "2", "level": 2, @@ -12676,7 +13001,7 @@ "label": "dns.resolve(hostname[, rrtype], callback)", "signature": "`dns.resolve(hostname[, rrtype], callback)`", "apiSymbol": "dns.resolve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolvehostname-rrtype-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolvehostname-rrtype-callback", "nodeStability": { "index": "2", "level": 2, @@ -12701,7 +13026,7 @@ "label": "dns.resolve4(hostname[, options], callback)", "signature": "`dns.resolve4(hostname[, options], callback)`", "apiSymbol": "dns.resolve4", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolve4hostname-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolve4hostname-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -12726,7 +13051,7 @@ "label": "dns.resolve6(hostname[, options], callback)", "signature": "`dns.resolve6(hostname[, options], callback)`", "apiSymbol": "dns.resolve6", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolve6hostname-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolve6hostname-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -12751,7 +13076,7 @@ "label": "dns.resolveAny(hostname, callback)", "signature": "`dns.resolveAny(hostname, callback)`", "apiSymbol": "dns.resolveAny", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolveanyhostname-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolveanyhostname-callback", "nodeStability": { "index": "2", "level": 2, @@ -12776,7 +13101,7 @@ "label": "dns.resolveCname(hostname, callback)", "signature": "`dns.resolveCname(hostname, callback)`", "apiSymbol": "dns.resolveCname", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolvecnamehostname-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolvecnamehostname-callback", "nodeStability": { "index": "2", "level": 2, @@ -12801,7 +13126,7 @@ "label": "dns.resolveCaa(hostname, callback)", "signature": "`dns.resolveCaa(hostname, callback)`", "apiSymbol": "dns.resolveCaa", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolvecaahostname-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolvecaahostname-callback", "nodeStability": { "index": "2", "level": 2, @@ -12826,7 +13151,7 @@ "label": "dns.resolveMx(hostname, callback)", "signature": "`dns.resolveMx(hostname, callback)`", "apiSymbol": "dns.resolveMx", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolvemxhostname-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolvemxhostname-callback", "nodeStability": { "index": "2", "level": 2, @@ -12851,7 +13176,7 @@ "label": "dns.resolveNaptr(hostname, callback)", "signature": "`dns.resolveNaptr(hostname, callback)`", "apiSymbol": "dns.resolveNaptr", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolvenaptrhostname-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolvenaptrhostname-callback", "nodeStability": { "index": "2", "level": 2, @@ -12876,7 +13201,7 @@ "label": "dns.resolveNs(hostname, callback)", "signature": "`dns.resolveNs(hostname, callback)`", "apiSymbol": "dns.resolveNs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolvenshostname-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolvenshostname-callback", "nodeStability": { "index": "2", "level": 2, @@ -12901,7 +13226,7 @@ "label": "dns.resolvePtr(hostname, callback)", "signature": "`dns.resolvePtr(hostname, callback)`", "apiSymbol": "dns.resolvePtr", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolveptrhostname-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolveptrhostname-callback", "nodeStability": { "index": "2", "level": 2, @@ -12926,7 +13251,7 @@ "label": "dns.resolveSoa(hostname, callback)", "signature": "`dns.resolveSoa(hostname, callback)`", "apiSymbol": "dns.resolveSoa", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolvesoahostname-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolvesoahostname-callback", "nodeStability": { "index": "2", "level": 2, @@ -12951,7 +13276,7 @@ "label": "dns.resolveSrv(hostname, callback)", "signature": "`dns.resolveSrv(hostname, callback)`", "apiSymbol": "dns.resolveSrv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolvesrvhostname-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolvesrvhostname-callback", "nodeStability": { "index": "2", "level": 2, @@ -12976,7 +13301,7 @@ "label": "dns.resolveTlsa(hostname, callback)", "signature": "`dns.resolveTlsa(hostname, callback)`", "apiSymbol": "dns.resolveTlsa", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolvetlsahostname-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolvetlsahostname-callback", "nodeStability": { "index": "2", "level": 2, @@ -13001,7 +13326,7 @@ "label": "dns.resolveTxt(hostname, callback)", "signature": "`dns.resolveTxt(hostname, callback)`", "apiSymbol": "dns.resolveTxt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsresolvetxthostname-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsresolvetxthostname-callback", "nodeStability": { "index": "2", "level": 2, @@ -13026,7 +13351,7 @@ "label": "dns.reverse(ip, callback)", "signature": "`dns.reverse(ip, callback)`", "apiSymbol": "dns.reverse", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsreverseip-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsreverseip-callback", "nodeStability": { "index": "2", "level": 2, @@ -13051,7 +13376,7 @@ "label": "dns.setDefaultResultOrder(order)", "signature": "`dns.setDefaultResultOrder(order)`", "apiSymbol": "dns.setDefaultResultOrder", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnssetdefaultresultorderorder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnssetdefaultresultorderorder", "nodeStability": { "index": "2", "level": 2, @@ -13076,7 +13401,7 @@ "label": "dns.getDefaultResultOrder()", "signature": "`dns.getDefaultResultOrder()`", "apiSymbol": "dns.getDefaultResultOrder", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnsgetdefaultresultorder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnsgetdefaultresultorder", "nodeStability": { "index": "2", "level": 2, @@ -13101,7 +13426,7 @@ "label": "dns.setServers(servers)", "signature": "`dns.setServers(servers)`", "apiSymbol": "dns.setServers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dns.html#dnssetserversservers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dns.html#dnssetserversservers", "nodeStability": { "index": "2", "level": 2, @@ -13126,7 +13451,7 @@ "label": "Domain", "signature": "Class: `Domain`", "apiSymbol": "Domain", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/domain.html#class-domain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/domain.html#class-domain", "nodeStability": { "index": "0", "level": 0, @@ -13151,7 +13476,7 @@ "label": "domain.add(emitter)", "signature": "`domain.add(emitter)`", "apiSymbol": "domain.add", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/domain.html#domainaddemitter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/domain.html#domainaddemitter", "nodeStability": { "index": "0", "level": 0, @@ -13176,7 +13501,7 @@ "label": "domain.bind(callback)", "signature": "`domain.bind(callback)`", "apiSymbol": "domain.bind", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/domain.html#domainbindcallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/domain.html#domainbindcallback", "nodeStability": { "index": "0", "level": 0, @@ -13201,7 +13526,7 @@ "label": "domain.enter()", "signature": "`domain.enter()`", "apiSymbol": "domain.enter", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/domain.html#domainenter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/domain.html#domainenter", "nodeStability": { "index": "0", "level": 0, @@ -13226,7 +13551,7 @@ "label": "domain.exit()", "signature": "`domain.exit()`", "apiSymbol": "domain.exit", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/domain.html#domainexit", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/domain.html#domainexit", "nodeStability": { "index": "0", "level": 0, @@ -13251,7 +13576,7 @@ "label": "domain.intercept(callback)", "signature": "`domain.intercept(callback)`", "apiSymbol": "domain.intercept", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/domain.html#domaininterceptcallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/domain.html#domaininterceptcallback", "nodeStability": { "index": "0", "level": 0, @@ -13276,7 +13601,7 @@ "label": "domain.remove(emitter)", "signature": "`domain.remove(emitter)`", "apiSymbol": "domain.remove", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/domain.html#domainremoveemitter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/domain.html#domainremoveemitter", "nodeStability": { "index": "0", "level": 0, @@ -13301,7 +13626,7 @@ "label": "domain.run(fn[, ...args])", "signature": "`domain.run(fn[, ...args])`", "apiSymbol": "domain.run", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/domain.html#domainrunfn-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/domain.html#domainrunfn-args", "nodeStability": { "index": "0", "level": 0, @@ -13326,7 +13651,7 @@ "label": "members", "signature": "`members` Type: {Array}", "apiSymbol": "members", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/domain.html#class-domain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/domain.html#class-domain", "nodeStability": { "index": "0", "level": 0, @@ -13351,7 +13676,7 @@ "label": "domain.create()", "signature": "`domain.create()`", "apiSymbol": "domain.create", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/domain.html#domaincreate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/domain.html#domaincreate", "nodeStability": { "index": "0", "level": 0, @@ -13376,7 +13701,7 @@ "label": "Additions to Error objects", "signature": "Additions to `Error` objects", "apiSymbol": "Error", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/domain.html#additions-to-error-objects", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/domain.html#additions-to-error-objects", "nodeStability": { "index": "0", "level": 0, @@ -13401,7 +13726,7 @@ "label": "process.env", "signature": "`process.env`", "apiSymbol": "process.env", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/environment_variables.html#processenv", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/environment_variables.html#processenv", "nodeStability": null, "priority": "normal", "tiers": { @@ -13424,7 +13749,7 @@ "label": "Error", "signature": "Class: `Error`", "apiSymbol": "Error", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-error", "nodeStability": null, "priority": "normal", "tiers": { @@ -13444,7 +13769,7 @@ "label": "Error.captureStackTrace(targetObject[, constructorOpt])", "signature": "`Error.captureStackTrace(targetObject[, constructorOpt])`", "apiSymbol": "Error.captureStackTrace", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#errorcapturestacktracetargetobject-constructoropt", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#errorcapturestacktracetargetobject-constructoropt", "nodeStability": null, "priority": "normal", "tiers": { @@ -13464,7 +13789,7 @@ "label": "stackTraceLimit", "signature": "`stackTraceLimit` Type: {number}", "apiSymbol": "stackTraceLimit", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-error", "nodeStability": null, "priority": "normal", "tiers": { @@ -13486,7 +13811,7 @@ "label": "cause", "signature": "`cause` Type: {any}", "apiSymbol": "cause", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-error", "nodeStability": null, "priority": "normal", "tiers": { @@ -13506,7 +13831,7 @@ "label": "code", "signature": "`code` Type: {string}", "apiSymbol": "code", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-error", "nodeStability": null, "priority": "normal", "tiers": { @@ -13526,7 +13851,7 @@ "label": "message", "signature": "`message` Type: {string}", "apiSymbol": "message", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-error", "nodeStability": null, "priority": "normal", "tiers": { @@ -13546,7 +13871,7 @@ "label": "stack", "signature": "`stack` Type: {string}", "apiSymbol": "stack", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-error", "nodeStability": null, "priority": "normal", "tiers": { @@ -13569,7 +13894,27 @@ "label": "AssertionError", "signature": "Class: `AssertionError`", "apiSymbol": "AssertionError", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-assertionerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-assertionerror", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:7c2e0440b499", + "chapter": "errors", + "label": "DOMException", + "signature": "Class: `DOMException`", + "apiSymbol": "DOMException", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-domexception", "nodeStability": null, "priority": "normal", "tiers": { @@ -13589,7 +13934,7 @@ "label": "RangeError", "signature": "Class: `RangeError`", "apiSymbol": "RangeError", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-rangeerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-rangeerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13609,7 +13954,7 @@ "label": "ReferenceError", "signature": "Class: `ReferenceError`", "apiSymbol": "ReferenceError", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-referenceerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-referenceerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13629,7 +13974,7 @@ "label": "SyntaxError", "signature": "Class: `SyntaxError`", "apiSymbol": "SyntaxError", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-syntaxerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-syntaxerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13649,7 +13994,7 @@ "label": "SystemError", "signature": "Class: `SystemError`", "apiSymbol": "SystemError", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-systemerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-systemerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13669,7 +14014,7 @@ "label": "address", "signature": "`address` Type: {string}", "apiSymbol": "address", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-systemerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-systemerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13689,7 +14034,7 @@ "label": "code", "signature": "`code` Type: {string}", "apiSymbol": "code", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-systemerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-systemerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13713,7 +14058,7 @@ "label": "dest", "signature": "`dest` Type: {string}", "apiSymbol": "dest", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-systemerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-systemerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13737,7 +14082,7 @@ "label": "errno", "signature": "`errno` Type: {number}", "apiSymbol": "errno", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-systemerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-systemerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13761,7 +14106,7 @@ "label": "info", "signature": "`info` Type: {Object}", "apiSymbol": "info", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-systemerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-systemerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13781,7 +14126,7 @@ "label": "message", "signature": "`message` Type: {string}", "apiSymbol": "message", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-systemerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-systemerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13801,7 +14146,7 @@ "label": "path", "signature": "`path` Type: {string}", "apiSymbol": "path", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-systemerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-systemerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13825,7 +14170,7 @@ "label": "port", "signature": "`port` Type: {number}", "apiSymbol": "port", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-systemerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-systemerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13845,7 +14190,7 @@ "label": "syscall", "signature": "`syscall` Type: {string}", "apiSymbol": "syscall", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-systemerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-systemerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13869,7 +14214,7 @@ "label": "TypeError", "signature": "Class: `TypeError`", "apiSymbol": "TypeError", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#class-typeerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#class-typeerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -13889,7 +14234,7 @@ "label": "error.opensslErrorStack", "signature": "`error.opensslErrorStack`", "apiSymbol": "error.opensslErrorStack", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#erroropensslerrorstack", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#erroropensslerrorstack", "nodeStability": null, "priority": "normal", "tiers": { @@ -13909,7 +14254,7 @@ "label": "error.function", "signature": "`error.function`", "apiSymbol": "error.function", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#errorfunction", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#errorfunction", "nodeStability": null, "priority": "normal", "tiers": { @@ -13929,7 +14274,7 @@ "label": "error.library", "signature": "`error.library`", "apiSymbol": "error.library", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#errorlibrary", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#errorlibrary", "nodeStability": null, "priority": "normal", "tiers": { @@ -13949,7 +14294,7 @@ "label": "error.reason", "signature": "`error.reason`", "apiSymbol": "error.reason", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#errorreason", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#errorreason", "nodeStability": null, "priority": "normal", "tiers": { @@ -13969,7 +14314,7 @@ "label": "ABORT_ERR", "signature": "`ABORT_ERR`", "apiSymbol": "ABORT_ERR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#abort_err", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#abort_err", "nodeStability": null, "priority": "normal", "tiers": { @@ -13989,7 +14334,7 @@ "label": "ERR_ACCESS_DENIED", "signature": "`ERR_ACCESS_DENIED`", "apiSymbol": "ERR_ACCESS_DENIED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_access_denied", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_access_denied", "nodeStability": null, "priority": "normal", "tiers": { @@ -14009,7 +14354,7 @@ "label": "ERR_AMBIGUOUS_ARGUMENT", "signature": "`ERR_AMBIGUOUS_ARGUMENT`", "apiSymbol": "ERR_AMBIGUOUS_ARGUMENT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_ambiguous_argument", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_ambiguous_argument", "nodeStability": null, "priority": "normal", "tiers": { @@ -14029,7 +14374,7 @@ "label": "ERR_ARG_NOT_ITERABLE", "signature": "`ERR_ARG_NOT_ITERABLE`", "apiSymbol": "ERR_ARG_NOT_ITERABLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_arg_not_iterable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_arg_not_iterable", "nodeStability": null, "priority": "normal", "tiers": { @@ -14049,7 +14394,7 @@ "label": "ERR_ASSERTION", "signature": "`ERR_ASSERTION`", "apiSymbol": "ERR_ASSERTION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_assertion", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_assertion", "nodeStability": null, "priority": "normal", "tiers": { @@ -14069,7 +14414,7 @@ "label": "ERR_ASYNC_CALLBACK", "signature": "`ERR_ASYNC_CALLBACK`", "apiSymbol": "ERR_ASYNC_CALLBACK", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_async_callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_async_callback", "nodeStability": null, "priority": "normal", "tiers": { @@ -14089,7 +14434,7 @@ "label": "ERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED", "signature": "`ERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED`", "apiSymbol": "ERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_async_loader_request_never_settled", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_async_loader_request_never_settled", "nodeStability": null, "priority": "normal", "tiers": { @@ -14109,7 +14454,7 @@ "label": "ERR_ASYNC_TYPE", "signature": "`ERR_ASYNC_TYPE`", "apiSymbol": "ERR_ASYNC_TYPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_async_type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_async_type", "nodeStability": null, "priority": "normal", "tiers": { @@ -14129,7 +14474,7 @@ "label": "ERR_BROTLI_COMPRESSION_FAILED", "signature": "`ERR_BROTLI_COMPRESSION_FAILED`", "apiSymbol": "ERR_BROTLI_COMPRESSION_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_brotli_compression_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_brotli_compression_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -14149,7 +14494,7 @@ "label": "ERR_BROTLI_INVALID_PARAM", "signature": "`ERR_BROTLI_INVALID_PARAM`", "apiSymbol": "ERR_BROTLI_INVALID_PARAM", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_brotli_invalid_param", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_brotli_invalid_param", "nodeStability": null, "priority": "normal", "tiers": { @@ -14169,7 +14514,7 @@ "label": "ERR_BUFFER_CONTEXT_NOT_AVAILABLE", "signature": "`ERR_BUFFER_CONTEXT_NOT_AVAILABLE`", "apiSymbol": "ERR_BUFFER_CONTEXT_NOT_AVAILABLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_buffer_context_not_available", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_buffer_context_not_available", "nodeStability": null, "priority": "normal", "tiers": { @@ -14189,7 +14534,7 @@ "label": "ERR_BUFFER_OUT_OF_BOUNDS", "signature": "`ERR_BUFFER_OUT_OF_BOUNDS`", "apiSymbol": "ERR_BUFFER_OUT_OF_BOUNDS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_buffer_out_of_bounds", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_buffer_out_of_bounds", "nodeStability": null, "priority": "normal", "tiers": { @@ -14209,7 +14554,7 @@ "label": "ERR_BUFFER_TOO_LARGE", "signature": "`ERR_BUFFER_TOO_LARGE`", "apiSymbol": "ERR_BUFFER_TOO_LARGE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_buffer_too_large", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_buffer_too_large", "nodeStability": null, "priority": "normal", "tiers": { @@ -14229,7 +14574,7 @@ "label": "ERR_CANNOT_WATCH_SIGINT", "signature": "`ERR_CANNOT_WATCH_SIGINT`", "apiSymbol": "ERR_CANNOT_WATCH_SIGINT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_cannot_watch_sigint", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_cannot_watch_sigint", "nodeStability": null, "priority": "normal", "tiers": { @@ -14249,7 +14594,7 @@ "label": "ERR_CHILD_CLOSED_BEFORE_REPLY", "signature": "`ERR_CHILD_CLOSED_BEFORE_REPLY`", "apiSymbol": "ERR_CHILD_CLOSED_BEFORE_REPLY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_child_closed_before_reply", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_child_closed_before_reply", "nodeStability": null, "priority": "normal", "tiers": { @@ -14269,7 +14614,7 @@ "label": "ERR_CHILD_PROCESS_IPC_REQUIRED", "signature": "`ERR_CHILD_PROCESS_IPC_REQUIRED`", "apiSymbol": "ERR_CHILD_PROCESS_IPC_REQUIRED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_child_process_ipc_required", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_child_process_ipc_required", "nodeStability": null, "priority": "normal", "tiers": { @@ -14289,7 +14634,7 @@ "label": "ERR_CHILD_PROCESS_STDIO_MAXBUFFER", "signature": "`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`", "apiSymbol": "ERR_CHILD_PROCESS_STDIO_MAXBUFFER", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_child_process_stdio_maxbuffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_child_process_stdio_maxbuffer", "nodeStability": null, "priority": "normal", "tiers": { @@ -14309,7 +14654,7 @@ "label": "ERR_CLOSED_MESSAGE_PORT", "signature": "`ERR_CLOSED_MESSAGE_PORT`", "apiSymbol": "ERR_CLOSED_MESSAGE_PORT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_closed_message_port", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_closed_message_port", "nodeStability": null, "priority": "normal", "tiers": { @@ -14329,7 +14674,7 @@ "label": "ERR_CONSOLE_WRITABLE_STREAM", "signature": "`ERR_CONSOLE_WRITABLE_STREAM`", "apiSymbol": "ERR_CONSOLE_WRITABLE_STREAM", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_console_writable_stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_console_writable_stream", "nodeStability": null, "priority": "normal", "tiers": { @@ -14349,7 +14694,7 @@ "label": "ERR_CONSTRUCT_CALL_INVALID", "signature": "`ERR_CONSTRUCT_CALL_INVALID`", "apiSymbol": "ERR_CONSTRUCT_CALL_INVALID", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_construct_call_invalid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_construct_call_invalid", "nodeStability": null, "priority": "normal", "tiers": { @@ -14369,7 +14714,7 @@ "label": "ERR_CONSTRUCT_CALL_REQUIRED", "signature": "`ERR_CONSTRUCT_CALL_REQUIRED`", "apiSymbol": "ERR_CONSTRUCT_CALL_REQUIRED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_construct_call_required", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_construct_call_required", "nodeStability": null, "priority": "normal", "tiers": { @@ -14389,7 +14734,7 @@ "label": "ERR_CONTEXT_NOT_INITIALIZED", "signature": "`ERR_CONTEXT_NOT_INITIALIZED`", "apiSymbol": "ERR_CONTEXT_NOT_INITIALIZED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_context_not_initialized", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_context_not_initialized", "nodeStability": null, "priority": "normal", "tiers": { @@ -14409,7 +14754,7 @@ "label": "ERR_CPU_PROFILE_ALREADY_STARTED", "signature": "`ERR_CPU_PROFILE_ALREADY_STARTED`", "apiSymbol": "ERR_CPU_PROFILE_ALREADY_STARTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_cpu_profile_already_started", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_cpu_profile_already_started", "nodeStability": null, "priority": "normal", "tiers": { @@ -14429,7 +14774,7 @@ "label": "ERR_CPU_PROFILE_NOT_STARTED", "signature": "`ERR_CPU_PROFILE_NOT_STARTED`", "apiSymbol": "ERR_CPU_PROFILE_NOT_STARTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_cpu_profile_not_started", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_cpu_profile_not_started", "nodeStability": null, "priority": "normal", "tiers": { @@ -14449,7 +14794,7 @@ "label": "ERR_CPU_PROFILE_TOO_MANY", "signature": "`ERR_CPU_PROFILE_TOO_MANY`", "apiSymbol": "ERR_CPU_PROFILE_TOO_MANY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_cpu_profile_too_many", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_cpu_profile_too_many", "nodeStability": null, "priority": "normal", "tiers": { @@ -14469,7 +14814,7 @@ "label": "ERR_CRYPTO_ARGON2_NOT_SUPPORTED", "signature": "`ERR_CRYPTO_ARGON2_NOT_SUPPORTED`", "apiSymbol": "ERR_CRYPTO_ARGON2_NOT_SUPPORTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_argon2_not_supported", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_argon2_not_supported", "nodeStability": null, "priority": "normal", "tiers": { @@ -14489,7 +14834,7 @@ "label": "ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED", "signature": "`ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED`", "apiSymbol": "ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_custom_engine_not_supported", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_custom_engine_not_supported", "nodeStability": null, "priority": "normal", "tiers": { @@ -14509,7 +14854,7 @@ "label": "ERR_CRYPTO_ECDH_INVALID_FORMAT", "signature": "`ERR_CRYPTO_ECDH_INVALID_FORMAT`", "apiSymbol": "ERR_CRYPTO_ECDH_INVALID_FORMAT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_ecdh_invalid_format", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_ecdh_invalid_format", "nodeStability": null, "priority": "normal", "tiers": { @@ -14529,7 +14874,7 @@ "label": "ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY", "signature": "`ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY`", "apiSymbol": "ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_ecdh_invalid_public_key", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_ecdh_invalid_public_key", "nodeStability": null, "priority": "normal", "tiers": { @@ -14549,7 +14894,7 @@ "label": "ERR_CRYPTO_ENGINE_UNKNOWN", "signature": "`ERR_CRYPTO_ENGINE_UNKNOWN`", "apiSymbol": "ERR_CRYPTO_ENGINE_UNKNOWN", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_engine_unknown", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_engine_unknown", "nodeStability": null, "priority": "normal", "tiers": { @@ -14569,7 +14914,7 @@ "label": "ERR_CRYPTO_FIPS_FORCED", "signature": "`ERR_CRYPTO_FIPS_FORCED`", "apiSymbol": "ERR_CRYPTO_FIPS_FORCED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_fips_forced", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_fips_forced", "nodeStability": null, "priority": "normal", "tiers": { @@ -14589,7 +14934,7 @@ "label": "ERR_CRYPTO_FIPS_UNAVAILABLE", "signature": "`ERR_CRYPTO_FIPS_UNAVAILABLE`", "apiSymbol": "ERR_CRYPTO_FIPS_UNAVAILABLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_fips_unavailable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_fips_unavailable", "nodeStability": null, "priority": "normal", "tiers": { @@ -14609,7 +14954,7 @@ "label": "ERR_CRYPTO_HASH_FINALIZED", "signature": "`ERR_CRYPTO_HASH_FINALIZED`", "apiSymbol": "ERR_CRYPTO_HASH_FINALIZED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_hash_finalized", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_hash_finalized", "nodeStability": null, "priority": "normal", "tiers": { @@ -14629,7 +14974,7 @@ "label": "ERR_CRYPTO_HASH_UPDATE_FAILED", "signature": "`ERR_CRYPTO_HASH_UPDATE_FAILED`", "apiSymbol": "ERR_CRYPTO_HASH_UPDATE_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_hash_update_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_hash_update_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -14649,7 +14994,7 @@ "label": "ERR_CRYPTO_INCOMPATIBLE_KEY", "signature": "`ERR_CRYPTO_INCOMPATIBLE_KEY`", "apiSymbol": "ERR_CRYPTO_INCOMPATIBLE_KEY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_incompatible_key", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_incompatible_key", "nodeStability": null, "priority": "normal", "tiers": { @@ -14669,7 +15014,7 @@ "label": "ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS", "signature": "`ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS`", "apiSymbol": "ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_incompatible_key_options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_incompatible_key_options", "nodeStability": null, "priority": "normal", "tiers": { @@ -14689,7 +15034,7 @@ "label": "ERR_CRYPTO_INITIALIZATION_FAILED", "signature": "`ERR_CRYPTO_INITIALIZATION_FAILED`", "apiSymbol": "ERR_CRYPTO_INITIALIZATION_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_initialization_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_initialization_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -14709,7 +15054,7 @@ "label": "ERR_CRYPTO_INVALID_AUTH_TAG", "signature": "`ERR_CRYPTO_INVALID_AUTH_TAG`", "apiSymbol": "ERR_CRYPTO_INVALID_AUTH_TAG", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_auth_tag", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_auth_tag", "nodeStability": null, "priority": "normal", "tiers": { @@ -14729,7 +15074,7 @@ "label": "ERR_CRYPTO_INVALID_COUNTER", "signature": "`ERR_CRYPTO_INVALID_COUNTER`", "apiSymbol": "ERR_CRYPTO_INVALID_COUNTER", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_counter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_counter", "nodeStability": null, "priority": "normal", "tiers": { @@ -14749,7 +15094,7 @@ "label": "ERR_CRYPTO_INVALID_CURVE", "signature": "`ERR_CRYPTO_INVALID_CURVE`", "apiSymbol": "ERR_CRYPTO_INVALID_CURVE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_curve", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_curve", "nodeStability": null, "priority": "normal", "tiers": { @@ -14769,7 +15114,7 @@ "label": "ERR_CRYPTO_INVALID_DIGEST", "signature": "`ERR_CRYPTO_INVALID_DIGEST`", "apiSymbol": "ERR_CRYPTO_INVALID_DIGEST", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_digest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_digest", "nodeStability": null, "priority": "normal", "tiers": { @@ -14789,7 +15134,7 @@ "label": "ERR_CRYPTO_INVALID_IV", "signature": "`ERR_CRYPTO_INVALID_IV`", "apiSymbol": "ERR_CRYPTO_INVALID_IV", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_iv", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_iv", "nodeStability": null, "priority": "normal", "tiers": { @@ -14809,7 +15154,7 @@ "label": "ERR_CRYPTO_INVALID_JWK", "signature": "`ERR_CRYPTO_INVALID_JWK`", "apiSymbol": "ERR_CRYPTO_INVALID_JWK", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_jwk", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_jwk", "nodeStability": null, "priority": "normal", "tiers": { @@ -14829,7 +15174,7 @@ "label": "ERR_CRYPTO_INVALID_KEYLEN", "signature": "`ERR_CRYPTO_INVALID_KEYLEN`", "apiSymbol": "ERR_CRYPTO_INVALID_KEYLEN", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_keylen", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_keylen", "nodeStability": null, "priority": "normal", "tiers": { @@ -14849,7 +15194,7 @@ "label": "ERR_CRYPTO_INVALID_KEYPAIR", "signature": "`ERR_CRYPTO_INVALID_KEYPAIR`", "apiSymbol": "ERR_CRYPTO_INVALID_KEYPAIR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_keypair", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_keypair", "nodeStability": null, "priority": "normal", "tiers": { @@ -14869,7 +15214,7 @@ "label": "ERR_CRYPTO_INVALID_KEYTYPE", "signature": "`ERR_CRYPTO_INVALID_KEYTYPE`", "apiSymbol": "ERR_CRYPTO_INVALID_KEYTYPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_keytype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_keytype", "nodeStability": null, "priority": "normal", "tiers": { @@ -14889,7 +15234,27 @@ "label": "ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE", "signature": "`ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE`", "apiSymbol": "ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_key_object_type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_key_object_type", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:1d435e87eb56", + "chapter": "errors", + "label": "ERR_CRYPTO_INVALID_MAC", + "signature": "`ERR_CRYPTO_INVALID_MAC`", + "apiSymbol": "ERR_CRYPTO_INVALID_MAC", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_mac", "nodeStability": null, "priority": "normal", "tiers": { @@ -14909,7 +15274,7 @@ "label": "ERR_CRYPTO_INVALID_MESSAGELEN", "signature": "`ERR_CRYPTO_INVALID_MESSAGELEN`", "apiSymbol": "ERR_CRYPTO_INVALID_MESSAGELEN", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_messagelen", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_messagelen", "nodeStability": null, "priority": "normal", "tiers": { @@ -14929,7 +15294,7 @@ "label": "ERR_CRYPTO_INVALID_SCRYPT_PARAMS", "signature": "`ERR_CRYPTO_INVALID_SCRYPT_PARAMS`", "apiSymbol": "ERR_CRYPTO_INVALID_SCRYPT_PARAMS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_scrypt_params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_scrypt_params", "nodeStability": null, "priority": "normal", "tiers": { @@ -14949,7 +15314,7 @@ "label": "ERR_CRYPTO_INVALID_STATE", "signature": "`ERR_CRYPTO_INVALID_STATE`", "apiSymbol": "ERR_CRYPTO_INVALID_STATE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_state", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_state", "nodeStability": null, "priority": "normal", "tiers": { @@ -14969,7 +15334,7 @@ "label": "ERR_CRYPTO_INVALID_TAG_LENGTH", "signature": "`ERR_CRYPTO_INVALID_TAG_LENGTH`", "apiSymbol": "ERR_CRYPTO_INVALID_TAG_LENGTH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_invalid_tag_length", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_invalid_tag_length", "nodeStability": null, "priority": "normal", "tiers": { @@ -14989,7 +15354,7 @@ "label": "ERR_CRYPTO_JOB_INIT_FAILED", "signature": "`ERR_CRYPTO_JOB_INIT_FAILED`", "apiSymbol": "ERR_CRYPTO_JOB_INIT_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_job_init_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_job_init_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -15009,7 +15374,7 @@ "label": "ERR_CRYPTO_JWK_UNSUPPORTED_CURVE", "signature": "`ERR_CRYPTO_JWK_UNSUPPORTED_CURVE`", "apiSymbol": "ERR_CRYPTO_JWK_UNSUPPORTED_CURVE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_jwk_unsupported_curve", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_jwk_unsupported_curve", "nodeStability": null, "priority": "normal", "tiers": { @@ -15029,7 +15394,7 @@ "label": "ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE", "signature": "`ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE`", "apiSymbol": "ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_jwk_unsupported_key_type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_jwk_unsupported_key_type", "nodeStability": null, "priority": "normal", "tiers": { @@ -15049,7 +15414,67 @@ "label": "ERR_CRYPTO_KEM_NOT_SUPPORTED", "signature": "`ERR_CRYPTO_KEM_NOT_SUPPORTED`", "apiSymbol": "ERR_CRYPTO_KEM_NOT_SUPPORTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_kem_not_supported", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_kem_not_supported", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:d6c1b25e885d", + "chapter": "errors", + "label": "ERR_CRYPTO_MAC_FINALIZED", + "signature": "`ERR_CRYPTO_MAC_FINALIZED`", + "apiSymbol": "ERR_CRYPTO_MAC_FINALIZED", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_mac_finalized", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:d0b894204eed", + "chapter": "errors", + "label": "ERR_CRYPTO_MAC_NOT_SUPPORTED", + "signature": "`ERR_CRYPTO_MAC_NOT_SUPPORTED`", + "apiSymbol": "ERR_CRYPTO_MAC_NOT_SUPPORTED", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_mac_not_supported", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:89c3bbbbe04b", + "chapter": "errors", + "label": "ERR_CRYPTO_MAC_UPDATE_FAILED", + "signature": "`ERR_CRYPTO_MAC_UPDATE_FAILED`", + "apiSymbol": "ERR_CRYPTO_MAC_UPDATE_FAILED", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_mac_update_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -15069,7 +15494,7 @@ "label": "ERR_CRYPTO_OPERATION_FAILED", "signature": "`ERR_CRYPTO_OPERATION_FAILED`", "apiSymbol": "ERR_CRYPTO_OPERATION_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_operation_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_operation_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -15089,7 +15514,7 @@ "label": "ERR_CRYPTO_PBKDF2_ERROR", "signature": "`ERR_CRYPTO_PBKDF2_ERROR`", "apiSymbol": "ERR_CRYPTO_PBKDF2_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_pbkdf2_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_pbkdf2_error", "nodeStability": null, "priority": "normal", "tiers": { @@ -15109,7 +15534,7 @@ "label": "ERR_CRYPTO_SCRYPT_NOT_SUPPORTED", "signature": "`ERR_CRYPTO_SCRYPT_NOT_SUPPORTED`", "apiSymbol": "ERR_CRYPTO_SCRYPT_NOT_SUPPORTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_scrypt_not_supported", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_scrypt_not_supported", "nodeStability": null, "priority": "normal", "tiers": { @@ -15129,7 +15554,7 @@ "label": "ERR_CRYPTO_SIGN_KEY_REQUIRED", "signature": "`ERR_CRYPTO_SIGN_KEY_REQUIRED`", "apiSymbol": "ERR_CRYPTO_SIGN_KEY_REQUIRED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_sign_key_required", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_sign_key_required", "nodeStability": null, "priority": "normal", "tiers": { @@ -15149,7 +15574,7 @@ "label": "ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH", "signature": "`ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH`", "apiSymbol": "ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_timing_safe_equal_length", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_timing_safe_equal_length", "nodeStability": null, "priority": "normal", "tiers": { @@ -15169,7 +15594,7 @@ "label": "ERR_CRYPTO_UNKNOWN_CIPHER", "signature": "`ERR_CRYPTO_UNKNOWN_CIPHER`", "apiSymbol": "ERR_CRYPTO_UNKNOWN_CIPHER", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_unknown_cipher", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_unknown_cipher", "nodeStability": null, "priority": "normal", "tiers": { @@ -15189,7 +15614,7 @@ "label": "ERR_CRYPTO_UNKNOWN_DH_GROUP", "signature": "`ERR_CRYPTO_UNKNOWN_DH_GROUP`", "apiSymbol": "ERR_CRYPTO_UNKNOWN_DH_GROUP", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_unknown_dh_group", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_unknown_dh_group", "nodeStability": null, "priority": "normal", "tiers": { @@ -15209,7 +15634,7 @@ "label": "ERR_CRYPTO_UNSUPPORTED_OPERATION", "signature": "`ERR_CRYPTO_UNSUPPORTED_OPERATION`", "apiSymbol": "ERR_CRYPTO_UNSUPPORTED_OPERATION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_unsupported_operation", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_unsupported_operation", "nodeStability": null, "priority": "normal", "tiers": { @@ -15229,7 +15654,7 @@ "label": "ERR_DEBUGGER_ERROR", "signature": "`ERR_DEBUGGER_ERROR`", "apiSymbol": "ERR_DEBUGGER_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_debugger_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_debugger_error", "nodeStability": null, "priority": "normal", "tiers": { @@ -15249,7 +15674,7 @@ "label": "ERR_DEBUGGER_STARTUP_ERROR", "signature": "`ERR_DEBUGGER_STARTUP_ERROR`", "apiSymbol": "ERR_DEBUGGER_STARTUP_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_debugger_startup_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_debugger_startup_error", "nodeStability": null, "priority": "normal", "tiers": { @@ -15269,7 +15694,7 @@ "label": "ERR_DIR_CLOSED", "signature": "`ERR_DIR_CLOSED`", "apiSymbol": "ERR_DIR_CLOSED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_dir_closed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_dir_closed", "nodeStability": null, "priority": "normal", "tiers": { @@ -15289,7 +15714,7 @@ "label": "ERR_DIR_CONCURRENT_OPERATION", "signature": "`ERR_DIR_CONCURRENT_OPERATION`", "apiSymbol": "ERR_DIR_CONCURRENT_OPERATION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_dir_concurrent_operation", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_dir_concurrent_operation", "nodeStability": null, "priority": "normal", "tiers": { @@ -15309,7 +15734,7 @@ "label": "ERR_DLOPEN_DISABLED", "signature": "`ERR_DLOPEN_DISABLED`", "apiSymbol": "ERR_DLOPEN_DISABLED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_dlopen_disabled", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_dlopen_disabled", "nodeStability": null, "priority": "normal", "tiers": { @@ -15329,7 +15754,7 @@ "label": "ERR_DLOPEN_FAILED", "signature": "`ERR_DLOPEN_FAILED`", "apiSymbol": "ERR_DLOPEN_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_dlopen_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_dlopen_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -15349,7 +15774,7 @@ "label": "ERR_DNS_SET_SERVERS_FAILED", "signature": "`ERR_DNS_SET_SERVERS_FAILED`", "apiSymbol": "ERR_DNS_SET_SERVERS_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_dns_set_servers_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_dns_set_servers_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -15369,7 +15794,7 @@ "label": "ERR_DOMAIN_CALLBACK_NOT_AVAILABLE", "signature": "`ERR_DOMAIN_CALLBACK_NOT_AVAILABLE`", "apiSymbol": "ERR_DOMAIN_CALLBACK_NOT_AVAILABLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_domain_callback_not_available", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_domain_callback_not_available", "nodeStability": null, "priority": "normal", "tiers": { @@ -15389,7 +15814,7 @@ "label": "ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE", "signature": "`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`", "apiSymbol": "ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_domain_cannot_set_uncaught_exception_capture", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_domain_cannot_set_uncaught_exception_capture", "nodeStability": null, "priority": "normal", "tiers": { @@ -15409,7 +15834,7 @@ "label": "ERR_DUPLICATE_STARTUP_SNAPSHOT_MAIN_FUNCTION", "signature": "`ERR_DUPLICATE_STARTUP_SNAPSHOT_MAIN_FUNCTION`", "apiSymbol": "ERR_DUPLICATE_STARTUP_SNAPSHOT_MAIN_FUNCTION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_duplicate_startup_snapshot_main_function", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_duplicate_startup_snapshot_main_function", "nodeStability": null, "priority": "normal", "tiers": { @@ -15429,7 +15854,7 @@ "label": "ERR_ENCODING_INVALID_ENCODED_DATA", "signature": "`ERR_ENCODING_INVALID_ENCODED_DATA`", "apiSymbol": "ERR_ENCODING_INVALID_ENCODED_DATA", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_encoding_invalid_encoded_data", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_encoding_invalid_encoded_data", "nodeStability": null, "priority": "normal", "tiers": { @@ -15449,7 +15874,7 @@ "label": "ERR_ENCODING_NOT_SUPPORTED", "signature": "`ERR_ENCODING_NOT_SUPPORTED`", "apiSymbol": "ERR_ENCODING_NOT_SUPPORTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_encoding_not_supported", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_encoding_not_supported", "nodeStability": null, "priority": "normal", "tiers": { @@ -15469,7 +15894,7 @@ "label": "ERR_EVAL_ESM_CANNOT_PRINT", "signature": "`ERR_EVAL_ESM_CANNOT_PRINT`", "apiSymbol": "ERR_EVAL_ESM_CANNOT_PRINT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_eval_esm_cannot_print", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_eval_esm_cannot_print", "nodeStability": null, "priority": "normal", "tiers": { @@ -15489,7 +15914,7 @@ "label": "ERR_EVENT_RECURSION", "signature": "`ERR_EVENT_RECURSION`", "apiSymbol": "ERR_EVENT_RECURSION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_event_recursion", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_event_recursion", "nodeStability": null, "priority": "normal", "tiers": { @@ -15509,7 +15934,7 @@ "label": "ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE", "signature": "`ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE`", "apiSymbol": "ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_execution_environment_not_available", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_execution_environment_not_available", "nodeStability": null, "priority": "normal", "tiers": { @@ -15529,7 +15954,7 @@ "label": "ERR_FALSY_VALUE_REJECTION", "signature": "`ERR_FALSY_VALUE_REJECTION`", "apiSymbol": "ERR_FALSY_VALUE_REJECTION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_falsy_value_rejection", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_falsy_value_rejection", "nodeStability": null, "priority": "normal", "tiers": { @@ -15549,7 +15974,7 @@ "label": "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM", "signature": "`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`", "apiSymbol": "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_feature_unavailable_on_platform", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_feature_unavailable_on_platform", "nodeStability": null, "priority": "normal", "tiers": { @@ -15569,7 +15994,7 @@ "label": "ERR_FS_CP_DIR_TO_NON_DIR", "signature": "`ERR_FS_CP_DIR_TO_NON_DIR`", "apiSymbol": "ERR_FS_CP_DIR_TO_NON_DIR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_fs_cp_dir_to_non_dir", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_fs_cp_dir_to_non_dir", "nodeStability": null, "priority": "normal", "tiers": { @@ -15589,7 +16014,7 @@ "label": "ERR_FS_CP_EEXIST", "signature": "`ERR_FS_CP_EEXIST`", "apiSymbol": "ERR_FS_CP_EEXIST", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_fs_cp_eexist", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_fs_cp_eexist", "nodeStability": null, "priority": "normal", "tiers": { @@ -15609,7 +16034,7 @@ "label": "ERR_FS_CP_EINVAL", "signature": "`ERR_FS_CP_EINVAL`", "apiSymbol": "ERR_FS_CP_EINVAL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_fs_cp_einval", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_fs_cp_einval", "nodeStability": null, "priority": "normal", "tiers": { @@ -15629,7 +16054,7 @@ "label": "ERR_FS_CP_FIFO_PIPE", "signature": "`ERR_FS_CP_FIFO_PIPE`", "apiSymbol": "ERR_FS_CP_FIFO_PIPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_fs_cp_fifo_pipe", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_fs_cp_fifo_pipe", "nodeStability": null, "priority": "normal", "tiers": { @@ -15649,7 +16074,7 @@ "label": "ERR_FS_CP_NON_DIR_TO_DIR", "signature": "`ERR_FS_CP_NON_DIR_TO_DIR`", "apiSymbol": "ERR_FS_CP_NON_DIR_TO_DIR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_fs_cp_non_dir_to_dir", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_fs_cp_non_dir_to_dir", "nodeStability": null, "priority": "normal", "tiers": { @@ -15669,7 +16094,7 @@ "label": "ERR_FS_CP_SOCKET", "signature": "`ERR_FS_CP_SOCKET`", "apiSymbol": "ERR_FS_CP_SOCKET", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_fs_cp_socket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_fs_cp_socket", "nodeStability": null, "priority": "normal", "tiers": { @@ -15689,7 +16114,7 @@ "label": "ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY", "signature": "`ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY`", "apiSymbol": "ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_fs_cp_symlink_to_subdirectory", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_fs_cp_symlink_to_subdirectory", "nodeStability": null, "priority": "normal", "tiers": { @@ -15709,7 +16134,7 @@ "label": "ERR_FS_CP_UNKNOWN", "signature": "`ERR_FS_CP_UNKNOWN`", "apiSymbol": "ERR_FS_CP_UNKNOWN", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_fs_cp_unknown", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_fs_cp_unknown", "nodeStability": null, "priority": "normal", "tiers": { @@ -15729,7 +16154,7 @@ "label": "ERR_FS_EISDIR", "signature": "`ERR_FS_EISDIR`", "apiSymbol": "ERR_FS_EISDIR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_fs_eisdir", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_fs_eisdir", "nodeStability": null, "priority": "normal", "tiers": { @@ -15749,7 +16174,7 @@ "label": "ERR_FS_FILE_TOO_LARGE", "signature": "`ERR_FS_FILE_TOO_LARGE`", "apiSymbol": "ERR_FS_FILE_TOO_LARGE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_fs_file_too_large", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_fs_file_too_large", "nodeStability": null, "priority": "normal", "tiers": { @@ -15769,7 +16194,7 @@ "label": "ERR_FS_WATCH_QUEUE_OVERFLOW", "signature": "`ERR_FS_WATCH_QUEUE_OVERFLOW`", "apiSymbol": "ERR_FS_WATCH_QUEUE_OVERFLOW", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_fs_watch_queue_overflow", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_fs_watch_queue_overflow", "nodeStability": null, "priority": "normal", "tiers": { @@ -15789,7 +16214,7 @@ "label": "ERR_HTTP2_ALTSVC_INVALID_ORIGIN", "signature": "`ERR_HTTP2_ALTSVC_INVALID_ORIGIN`", "apiSymbol": "ERR_HTTP2_ALTSVC_INVALID_ORIGIN", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_altsvc_invalid_origin", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_altsvc_invalid_origin", "nodeStability": null, "priority": "normal", "tiers": { @@ -15809,7 +16234,7 @@ "label": "ERR_HTTP2_ALTSVC_LENGTH", "signature": "`ERR_HTTP2_ALTSVC_LENGTH`", "apiSymbol": "ERR_HTTP2_ALTSVC_LENGTH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_altsvc_length", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_altsvc_length", "nodeStability": null, "priority": "normal", "tiers": { @@ -15829,7 +16254,7 @@ "label": "ERR_HTTP2_CONNECT_AUTHORITY", "signature": "`ERR_HTTP2_CONNECT_AUTHORITY`", "apiSymbol": "ERR_HTTP2_CONNECT_AUTHORITY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_connect_authority", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_connect_authority", "nodeStability": null, "priority": "normal", "tiers": { @@ -15849,7 +16274,7 @@ "label": "ERR_HTTP2_CONNECT_PATH", "signature": "`ERR_HTTP2_CONNECT_PATH`", "apiSymbol": "ERR_HTTP2_CONNECT_PATH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_connect_path", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_connect_path", "nodeStability": null, "priority": "normal", "tiers": { @@ -15869,7 +16294,7 @@ "label": "ERR_HTTP2_CONNECT_SCHEME", "signature": "`ERR_HTTP2_CONNECT_SCHEME`", "apiSymbol": "ERR_HTTP2_CONNECT_SCHEME", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_connect_scheme", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_connect_scheme", "nodeStability": null, "priority": "normal", "tiers": { @@ -15889,7 +16314,7 @@ "label": "ERR_HTTP2_ERROR", "signature": "`ERR_HTTP2_ERROR`", "apiSymbol": "ERR_HTTP2_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_error", "nodeStability": null, "priority": "normal", "tiers": { @@ -15909,7 +16334,7 @@ "label": "ERR_HTTP2_GOAWAY_SESSION", "signature": "`ERR_HTTP2_GOAWAY_SESSION`", "apiSymbol": "ERR_HTTP2_GOAWAY_SESSION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_goaway_session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_goaway_session", "nodeStability": null, "priority": "normal", "tiers": { @@ -15929,7 +16354,7 @@ "label": "ERR_HTTP2_HEADERS_AFTER_RESPOND", "signature": "`ERR_HTTP2_HEADERS_AFTER_RESPOND`", "apiSymbol": "ERR_HTTP2_HEADERS_AFTER_RESPOND", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_headers_after_respond", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_headers_after_respond", "nodeStability": null, "priority": "normal", "tiers": { @@ -15949,7 +16374,7 @@ "label": "ERR_HTTP2_HEADERS_SENT", "signature": "`ERR_HTTP2_HEADERS_SENT`", "apiSymbol": "ERR_HTTP2_HEADERS_SENT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_headers_sent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_headers_sent", "nodeStability": null, "priority": "normal", "tiers": { @@ -15969,7 +16394,7 @@ "label": "ERR_HTTP2_HEADER_SINGLE_VALUE", "signature": "`ERR_HTTP2_HEADER_SINGLE_VALUE`", "apiSymbol": "ERR_HTTP2_HEADER_SINGLE_VALUE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_header_single_value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_header_single_value", "nodeStability": null, "priority": "normal", "tiers": { @@ -15989,7 +16414,7 @@ "label": "ERR_HTTP2_INFO_STATUS_NOT_ALLOWED", "signature": "`ERR_HTTP2_INFO_STATUS_NOT_ALLOWED`", "apiSymbol": "ERR_HTTP2_INFO_STATUS_NOT_ALLOWED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_info_status_not_allowed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_info_status_not_allowed", "nodeStability": null, "priority": "normal", "tiers": { @@ -16009,7 +16434,7 @@ "label": "ERR_HTTP2_INVALID_CONNECTION_HEADERS", "signature": "`ERR_HTTP2_INVALID_CONNECTION_HEADERS`", "apiSymbol": "ERR_HTTP2_INVALID_CONNECTION_HEADERS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_invalid_connection_headers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_invalid_connection_headers", "nodeStability": null, "priority": "normal", "tiers": { @@ -16029,7 +16454,7 @@ "label": "ERR_HTTP2_INVALID_HEADER_VALUE", "signature": "`ERR_HTTP2_INVALID_HEADER_VALUE`", "apiSymbol": "ERR_HTTP2_INVALID_HEADER_VALUE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_invalid_header_value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_invalid_header_value", "nodeStability": null, "priority": "normal", "tiers": { @@ -16049,7 +16474,7 @@ "label": "ERR_HTTP2_INVALID_INFO_STATUS", "signature": "`ERR_HTTP2_INVALID_INFO_STATUS`", "apiSymbol": "ERR_HTTP2_INVALID_INFO_STATUS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_invalid_info_status", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_invalid_info_status", "nodeStability": null, "priority": "normal", "tiers": { @@ -16069,7 +16494,7 @@ "label": "ERR_HTTP2_INVALID_ORIGIN", "signature": "`ERR_HTTP2_INVALID_ORIGIN`", "apiSymbol": "ERR_HTTP2_INVALID_ORIGIN", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_invalid_origin", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_invalid_origin", "nodeStability": null, "priority": "normal", "tiers": { @@ -16089,7 +16514,7 @@ "label": "ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH", "signature": "`ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH`", "apiSymbol": "ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_invalid_packed_settings_length", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_invalid_packed_settings_length", "nodeStability": null, "priority": "normal", "tiers": { @@ -16109,7 +16534,7 @@ "label": "ERR_HTTP2_INVALID_PSEUDOHEADER", "signature": "`ERR_HTTP2_INVALID_PSEUDOHEADER`", "apiSymbol": "ERR_HTTP2_INVALID_PSEUDOHEADER", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_invalid_pseudoheader", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_invalid_pseudoheader", "nodeStability": null, "priority": "normal", "tiers": { @@ -16129,7 +16554,7 @@ "label": "ERR_HTTP2_INVALID_SESSION", "signature": "`ERR_HTTP2_INVALID_SESSION`", "apiSymbol": "ERR_HTTP2_INVALID_SESSION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_invalid_session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_invalid_session", "nodeStability": null, "priority": "normal", "tiers": { @@ -16149,7 +16574,7 @@ "label": "ERR_HTTP2_INVALID_SETTING_VALUE", "signature": "`ERR_HTTP2_INVALID_SETTING_VALUE`", "apiSymbol": "ERR_HTTP2_INVALID_SETTING_VALUE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_invalid_setting_value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_invalid_setting_value", "nodeStability": null, "priority": "normal", "tiers": { @@ -16169,7 +16594,7 @@ "label": "ERR_HTTP2_INVALID_STREAM", "signature": "`ERR_HTTP2_INVALID_STREAM`", "apiSymbol": "ERR_HTTP2_INVALID_STREAM", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_invalid_stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_invalid_stream", "nodeStability": null, "priority": "normal", "tiers": { @@ -16189,7 +16614,7 @@ "label": "ERR_HTTP2_MAX_PENDING_SETTINGS_ACK", "signature": "`ERR_HTTP2_MAX_PENDING_SETTINGS_ACK`", "apiSymbol": "ERR_HTTP2_MAX_PENDING_SETTINGS_ACK", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_max_pending_settings_ack", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_max_pending_settings_ack", "nodeStability": null, "priority": "normal", "tiers": { @@ -16209,7 +16634,7 @@ "label": "ERR_HTTP2_NESTED_PUSH", "signature": "`ERR_HTTP2_NESTED_PUSH`", "apiSymbol": "ERR_HTTP2_NESTED_PUSH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_nested_push", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_nested_push", "nodeStability": null, "priority": "normal", "tiers": { @@ -16229,7 +16654,7 @@ "label": "ERR_HTTP2_NO_MEM", "signature": "`ERR_HTTP2_NO_MEM`", "apiSymbol": "ERR_HTTP2_NO_MEM", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_no_mem", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_no_mem", "nodeStability": null, "priority": "normal", "tiers": { @@ -16249,7 +16674,7 @@ "label": "ERR_HTTP2_NO_SOCKET_MANIPULATION", "signature": "`ERR_HTTP2_NO_SOCKET_MANIPULATION`", "apiSymbol": "ERR_HTTP2_NO_SOCKET_MANIPULATION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_no_socket_manipulation", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_no_socket_manipulation", "nodeStability": null, "priority": "normal", "tiers": { @@ -16269,7 +16694,7 @@ "label": "ERR_HTTP2_ORIGIN_LENGTH", "signature": "`ERR_HTTP2_ORIGIN_LENGTH`", "apiSymbol": "ERR_HTTP2_ORIGIN_LENGTH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_origin_length", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_origin_length", "nodeStability": null, "priority": "normal", "tiers": { @@ -16289,7 +16714,7 @@ "label": "ERR_HTTP2_OUT_OF_STREAMS", "signature": "`ERR_HTTP2_OUT_OF_STREAMS`", "apiSymbol": "ERR_HTTP2_OUT_OF_STREAMS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_out_of_streams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_out_of_streams", "nodeStability": null, "priority": "normal", "tiers": { @@ -16309,7 +16734,7 @@ "label": "ERR_HTTP2_PAYLOAD_FORBIDDEN", "signature": "`ERR_HTTP2_PAYLOAD_FORBIDDEN`", "apiSymbol": "ERR_HTTP2_PAYLOAD_FORBIDDEN", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_payload_forbidden", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_payload_forbidden", "nodeStability": null, "priority": "normal", "tiers": { @@ -16329,7 +16754,7 @@ "label": "ERR_HTTP2_PING_CANCEL", "signature": "`ERR_HTTP2_PING_CANCEL`", "apiSymbol": "ERR_HTTP2_PING_CANCEL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_ping_cancel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_ping_cancel", "nodeStability": null, "priority": "normal", "tiers": { @@ -16349,7 +16774,7 @@ "label": "ERR_HTTP2_PING_LENGTH", "signature": "`ERR_HTTP2_PING_LENGTH`", "apiSymbol": "ERR_HTTP2_PING_LENGTH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_ping_length", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_ping_length", "nodeStability": null, "priority": "normal", "tiers": { @@ -16369,7 +16794,7 @@ "label": "ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED", "signature": "`ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED`", "apiSymbol": "ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_pseudoheader_not_allowed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_pseudoheader_not_allowed", "nodeStability": null, "priority": "normal", "tiers": { @@ -16389,7 +16814,7 @@ "label": "ERR_HTTP2_PUSH_DISABLED", "signature": "`ERR_HTTP2_PUSH_DISABLED`", "apiSymbol": "ERR_HTTP2_PUSH_DISABLED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_push_disabled", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_push_disabled", "nodeStability": null, "priority": "normal", "tiers": { @@ -16409,7 +16834,7 @@ "label": "ERR_HTTP2_SEND_FILE", "signature": "`ERR_HTTP2_SEND_FILE`", "apiSymbol": "ERR_HTTP2_SEND_FILE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_send_file", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_send_file", "nodeStability": null, "priority": "normal", "tiers": { @@ -16429,7 +16854,7 @@ "label": "ERR_HTTP2_SEND_FILE_NOSEEK", "signature": "`ERR_HTTP2_SEND_FILE_NOSEEK`", "apiSymbol": "ERR_HTTP2_SEND_FILE_NOSEEK", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_send_file_noseek", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_send_file_noseek", "nodeStability": null, "priority": "normal", "tiers": { @@ -16449,7 +16874,7 @@ "label": "ERR_HTTP2_SESSION_ERROR", "signature": "`ERR_HTTP2_SESSION_ERROR`", "apiSymbol": "ERR_HTTP2_SESSION_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_session_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_session_error", "nodeStability": null, "priority": "normal", "tiers": { @@ -16469,7 +16894,7 @@ "label": "ERR_HTTP2_SETTINGS_CANCEL", "signature": "`ERR_HTTP2_SETTINGS_CANCEL`", "apiSymbol": "ERR_HTTP2_SETTINGS_CANCEL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_settings_cancel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_settings_cancel", "nodeStability": null, "priority": "normal", "tiers": { @@ -16489,7 +16914,7 @@ "label": "ERR_HTTP2_SOCKET_BOUND", "signature": "`ERR_HTTP2_SOCKET_BOUND`", "apiSymbol": "ERR_HTTP2_SOCKET_BOUND", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_socket_bound", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_socket_bound", "nodeStability": null, "priority": "normal", "tiers": { @@ -16509,7 +16934,7 @@ "label": "ERR_HTTP2_SOCKET_UNBOUND", "signature": "`ERR_HTTP2_SOCKET_UNBOUND`", "apiSymbol": "ERR_HTTP2_SOCKET_UNBOUND", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_socket_unbound", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_socket_unbound", "nodeStability": null, "priority": "normal", "tiers": { @@ -16529,7 +16954,7 @@ "label": "ERR_HTTP2_STATUS_101", "signature": "`ERR_HTTP2_STATUS_101`", "apiSymbol": "ERR_HTTP2_STATUS_101", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_status_101", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_status_101", "nodeStability": null, "priority": "normal", "tiers": { @@ -16549,7 +16974,7 @@ "label": "ERR_HTTP2_STATUS_INVALID", "signature": "`ERR_HTTP2_STATUS_INVALID`", "apiSymbol": "ERR_HTTP2_STATUS_INVALID", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_status_invalid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_status_invalid", "nodeStability": null, "priority": "normal", "tiers": { @@ -16569,7 +16994,7 @@ "label": "ERR_HTTP2_STREAM_CANCEL", "signature": "`ERR_HTTP2_STREAM_CANCEL`", "apiSymbol": "ERR_HTTP2_STREAM_CANCEL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_stream_cancel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_stream_cancel", "nodeStability": null, "priority": "normal", "tiers": { @@ -16589,7 +17014,7 @@ "label": "ERR_HTTP2_STREAM_ERROR", "signature": "`ERR_HTTP2_STREAM_ERROR`", "apiSymbol": "ERR_HTTP2_STREAM_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_stream_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_stream_error", "nodeStability": null, "priority": "normal", "tiers": { @@ -16609,7 +17034,7 @@ "label": "ERR_HTTP2_STREAM_SELF_DEPENDENCY", "signature": "`ERR_HTTP2_STREAM_SELF_DEPENDENCY`", "apiSymbol": "ERR_HTTP2_STREAM_SELF_DEPENDENCY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_stream_self_dependency", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_stream_self_dependency", "nodeStability": null, "priority": "normal", "tiers": { @@ -16629,7 +17054,7 @@ "label": "ERR_HTTP2_TOO_MANY_CUSTOM_SETTINGS", "signature": "`ERR_HTTP2_TOO_MANY_CUSTOM_SETTINGS`", "apiSymbol": "ERR_HTTP2_TOO_MANY_CUSTOM_SETTINGS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_too_many_custom_settings", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_too_many_custom_settings", "nodeStability": null, "priority": "normal", "tiers": { @@ -16649,7 +17074,27 @@ "label": "ERR_HTTP2_TOO_MANY_INVALID_FRAMES", "signature": "`ERR_HTTP2_TOO_MANY_INVALID_FRAMES`", "apiSymbol": "ERR_HTTP2_TOO_MANY_INVALID_FRAMES", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_too_many_invalid_frames", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_too_many_invalid_frames", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:bc2b4b418075", + "chapter": "errors", + "label": "ERR_HTTP2_TOO_MANY_ORIGINS", + "signature": "`ERR_HTTP2_TOO_MANY_ORIGINS`", + "apiSymbol": "ERR_HTTP2_TOO_MANY_ORIGINS", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_too_many_origins", "nodeStability": null, "priority": "normal", "tiers": { @@ -16669,7 +17114,7 @@ "label": "ERR_HTTP2_TRAILERS_ALREADY_SENT", "signature": "`ERR_HTTP2_TRAILERS_ALREADY_SENT`", "apiSymbol": "ERR_HTTP2_TRAILERS_ALREADY_SENT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_trailers_already_sent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_trailers_already_sent", "nodeStability": null, "priority": "normal", "tiers": { @@ -16689,7 +17134,7 @@ "label": "ERR_HTTP2_TRAILERS_NOT_READY", "signature": "`ERR_HTTP2_TRAILERS_NOT_READY`", "apiSymbol": "ERR_HTTP2_TRAILERS_NOT_READY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_trailers_not_ready", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_trailers_not_ready", "nodeStability": null, "priority": "normal", "tiers": { @@ -16709,7 +17154,7 @@ "label": "ERR_HTTP2_UNSUPPORTED_PROTOCOL", "signature": "`ERR_HTTP2_UNSUPPORTED_PROTOCOL`", "apiSymbol": "ERR_HTTP2_UNSUPPORTED_PROTOCOL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_unsupported_protocol", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_unsupported_protocol", "nodeStability": null, "priority": "normal", "tiers": { @@ -16729,7 +17174,7 @@ "label": "ERR_HTTP_BODY_NOT_ALLOWED", "signature": "`ERR_HTTP_BODY_NOT_ALLOWED`", "apiSymbol": "ERR_HTTP_BODY_NOT_ALLOWED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http_body_not_allowed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http_body_not_allowed", "nodeStability": null, "priority": "normal", "tiers": { @@ -16749,7 +17194,7 @@ "label": "ERR_HTTP_CONTENT_LENGTH_MISMATCH", "signature": "`ERR_HTTP_CONTENT_LENGTH_MISMATCH`", "apiSymbol": "ERR_HTTP_CONTENT_LENGTH_MISMATCH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http_content_length_mismatch", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http_content_length_mismatch", "nodeStability": null, "priority": "normal", "tiers": { @@ -16769,7 +17214,7 @@ "label": "ERR_HTTP_HEADERS_SENT", "signature": "`ERR_HTTP_HEADERS_SENT`", "apiSymbol": "ERR_HTTP_HEADERS_SENT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http_headers_sent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http_headers_sent", "nodeStability": null, "priority": "normal", "tiers": { @@ -16789,7 +17234,7 @@ "label": "ERR_HTTP_INVALID_HEADER_VALUE", "signature": "`ERR_HTTP_INVALID_HEADER_VALUE`", "apiSymbol": "ERR_HTTP_INVALID_HEADER_VALUE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http_invalid_header_value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http_invalid_header_value", "nodeStability": null, "priority": "normal", "tiers": { @@ -16809,7 +17254,7 @@ "label": "ERR_HTTP_INVALID_STATUS_CODE", "signature": "`ERR_HTTP_INVALID_STATUS_CODE`", "apiSymbol": "ERR_HTTP_INVALID_STATUS_CODE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http_invalid_status_code", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http_invalid_status_code", "nodeStability": null, "priority": "normal", "tiers": { @@ -16829,7 +17274,7 @@ "label": "ERR_HTTP_REQUEST_TIMEOUT", "signature": "`ERR_HTTP_REQUEST_TIMEOUT`", "apiSymbol": "ERR_HTTP_REQUEST_TIMEOUT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http_request_timeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http_request_timeout", "nodeStability": null, "priority": "normal", "tiers": { @@ -16849,7 +17294,7 @@ "label": "ERR_HTTP_SOCKET_ASSIGNED", "signature": "`ERR_HTTP_SOCKET_ASSIGNED`", "apiSymbol": "ERR_HTTP_SOCKET_ASSIGNED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http_socket_assigned", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http_socket_assigned", "nodeStability": null, "priority": "normal", "tiers": { @@ -16869,7 +17314,7 @@ "label": "ERR_HTTP_SOCKET_ENCODING", "signature": "`ERR_HTTP_SOCKET_ENCODING`", "apiSymbol": "ERR_HTTP_SOCKET_ENCODING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http_socket_encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http_socket_encoding", "nodeStability": null, "priority": "normal", "tiers": { @@ -16889,7 +17334,7 @@ "label": "ERR_HTTP_TRAILER_INVALID", "signature": "`ERR_HTTP_TRAILER_INVALID`", "apiSymbol": "ERR_HTTP_TRAILER_INVALID", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http_trailer_invalid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http_trailer_invalid", "nodeStability": null, "priority": "normal", "tiers": { @@ -16909,7 +17354,7 @@ "label": "ERR_ILLEGAL_CONSTRUCTOR", "signature": "`ERR_ILLEGAL_CONSTRUCTOR`", "apiSymbol": "ERR_ILLEGAL_CONSTRUCTOR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_illegal_constructor", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_illegal_constructor", "nodeStability": null, "priority": "normal", "tiers": { @@ -16929,7 +17374,7 @@ "label": "ERR_IMPORT_ATTRIBUTE_MISSING", "signature": "`ERR_IMPORT_ATTRIBUTE_MISSING`", "apiSymbol": "ERR_IMPORT_ATTRIBUTE_MISSING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_import_attribute_missing", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_import_attribute_missing", "nodeStability": null, "priority": "normal", "tiers": { @@ -16949,7 +17394,7 @@ "label": "ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE", "signature": "`ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE`", "apiSymbol": "ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_import_attribute_type_incompatible", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_import_attribute_type_incompatible", "nodeStability": null, "priority": "normal", "tiers": { @@ -16969,7 +17414,7 @@ "label": "ERR_IMPORT_ATTRIBUTE_UNSUPPORTED", "signature": "`ERR_IMPORT_ATTRIBUTE_UNSUPPORTED`", "apiSymbol": "ERR_IMPORT_ATTRIBUTE_UNSUPPORTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_import_attribute_unsupported", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_import_attribute_unsupported", "nodeStability": null, "priority": "normal", "tiers": { @@ -16989,7 +17434,7 @@ "label": "ERR_INCOMPATIBLE_OPTION_PAIR", "signature": "`ERR_INCOMPATIBLE_OPTION_PAIR`", "apiSymbol": "ERR_INCOMPATIBLE_OPTION_PAIR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_incompatible_option_pair", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_incompatible_option_pair", "nodeStability": null, "priority": "normal", "tiers": { @@ -17009,7 +17454,7 @@ "label": "ERR_INPUT_TYPE_NOT_ALLOWED", "signature": "`ERR_INPUT_TYPE_NOT_ALLOWED`", "apiSymbol": "ERR_INPUT_TYPE_NOT_ALLOWED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_input_type_not_allowed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_input_type_not_allowed", "nodeStability": null, "priority": "normal", "tiers": { @@ -17029,7 +17474,7 @@ "label": "ERR_INSPECTOR_ALREADY_ACTIVATED", "signature": "`ERR_INSPECTOR_ALREADY_ACTIVATED`", "apiSymbol": "ERR_INSPECTOR_ALREADY_ACTIVATED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_inspector_already_activated", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_inspector_already_activated", "nodeStability": null, "priority": "normal", "tiers": { @@ -17049,7 +17494,7 @@ "label": "ERR_INSPECTOR_ALREADY_CONNECTED", "signature": "`ERR_INSPECTOR_ALREADY_CONNECTED`", "apiSymbol": "ERR_INSPECTOR_ALREADY_CONNECTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_inspector_already_connected", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_inspector_already_connected", "nodeStability": null, "priority": "normal", "tiers": { @@ -17069,7 +17514,7 @@ "label": "ERR_INSPECTOR_CLOSED", "signature": "`ERR_INSPECTOR_CLOSED`", "apiSymbol": "ERR_INSPECTOR_CLOSED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_inspector_closed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_inspector_closed", "nodeStability": null, "priority": "normal", "tiers": { @@ -17089,7 +17534,7 @@ "label": "ERR_INSPECTOR_COMMAND", "signature": "`ERR_INSPECTOR_COMMAND`", "apiSymbol": "ERR_INSPECTOR_COMMAND", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_inspector_command", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_inspector_command", "nodeStability": null, "priority": "normal", "tiers": { @@ -17109,7 +17554,7 @@ "label": "ERR_INSPECTOR_NOT_ACTIVE", "signature": "`ERR_INSPECTOR_NOT_ACTIVE`", "apiSymbol": "ERR_INSPECTOR_NOT_ACTIVE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_inspector_not_active", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_inspector_not_active", "nodeStability": null, "priority": "normal", "tiers": { @@ -17129,7 +17574,7 @@ "label": "ERR_INSPECTOR_NOT_AVAILABLE", "signature": "`ERR_INSPECTOR_NOT_AVAILABLE`", "apiSymbol": "ERR_INSPECTOR_NOT_AVAILABLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_inspector_not_available", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_inspector_not_available", "nodeStability": null, "priority": "normal", "tiers": { @@ -17149,7 +17594,7 @@ "label": "ERR_INSPECTOR_NOT_CONNECTED", "signature": "`ERR_INSPECTOR_NOT_CONNECTED`", "apiSymbol": "ERR_INSPECTOR_NOT_CONNECTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_inspector_not_connected", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_inspector_not_connected", "nodeStability": null, "priority": "normal", "tiers": { @@ -17169,7 +17614,7 @@ "label": "ERR_INSPECTOR_NOT_WORKER", "signature": "`ERR_INSPECTOR_NOT_WORKER`", "apiSymbol": "ERR_INSPECTOR_NOT_WORKER", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_inspector_not_worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_inspector_not_worker", "nodeStability": null, "priority": "normal", "tiers": { @@ -17189,7 +17634,7 @@ "label": "ERR_INTERNAL_ASSERTION", "signature": "`ERR_INTERNAL_ASSERTION`", "apiSymbol": "ERR_INTERNAL_ASSERTION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_internal_assertion", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_internal_assertion", "nodeStability": null, "priority": "normal", "tiers": { @@ -17209,7 +17654,7 @@ "label": "ERR_INVALID_ADDRESS", "signature": "`ERR_INVALID_ADDRESS`", "apiSymbol": "ERR_INVALID_ADDRESS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_address", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_address", "nodeStability": null, "priority": "normal", "tiers": { @@ -17229,7 +17674,7 @@ "label": "ERR_INVALID_ADDRESS_FAMILY", "signature": "`ERR_INVALID_ADDRESS_FAMILY`", "apiSymbol": "ERR_INVALID_ADDRESS_FAMILY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_address_family", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_address_family", "nodeStability": null, "priority": "normal", "tiers": { @@ -17249,7 +17694,7 @@ "label": "ERR_INVALID_ARG_TYPE", "signature": "`ERR_INVALID_ARG_TYPE`", "apiSymbol": "ERR_INVALID_ARG_TYPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_arg_type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_arg_type", "nodeStability": null, "priority": "normal", "tiers": { @@ -17269,7 +17714,7 @@ "label": "ERR_INVALID_ARG_VALUE", "signature": "`ERR_INVALID_ARG_VALUE`", "apiSymbol": "ERR_INVALID_ARG_VALUE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_arg_value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_arg_value", "nodeStability": null, "priority": "normal", "tiers": { @@ -17289,7 +17734,7 @@ "label": "ERR_INVALID_ASYNC_ID", "signature": "`ERR_INVALID_ASYNC_ID`", "apiSymbol": "ERR_INVALID_ASYNC_ID", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_async_id", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_async_id", "nodeStability": null, "priority": "normal", "tiers": { @@ -17309,7 +17754,7 @@ "label": "ERR_INVALID_BUFFER_SIZE", "signature": "`ERR_INVALID_BUFFER_SIZE`", "apiSymbol": "ERR_INVALID_BUFFER_SIZE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_buffer_size", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_buffer_size", "nodeStability": null, "priority": "normal", "tiers": { @@ -17329,7 +17774,7 @@ "label": "ERR_INVALID_CHAR", "signature": "`ERR_INVALID_CHAR`", "apiSymbol": "ERR_INVALID_CHAR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_char", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_char", "nodeStability": null, "priority": "normal", "tiers": { @@ -17349,7 +17794,7 @@ "label": "ERR_INVALID_CURSOR_POS", "signature": "`ERR_INVALID_CURSOR_POS`", "apiSymbol": "ERR_INVALID_CURSOR_POS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_cursor_pos", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_cursor_pos", "nodeStability": null, "priority": "normal", "tiers": { @@ -17369,7 +17814,7 @@ "label": "ERR_INVALID_FD", "signature": "`ERR_INVALID_FD`", "apiSymbol": "ERR_INVALID_FD", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_fd", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_fd", "nodeStability": null, "priority": "normal", "tiers": { @@ -17389,7 +17834,7 @@ "label": "ERR_INVALID_FD_TYPE", "signature": "`ERR_INVALID_FD_TYPE`", "apiSymbol": "ERR_INVALID_FD_TYPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_fd_type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_fd_type", "nodeStability": null, "priority": "normal", "tiers": { @@ -17409,7 +17854,7 @@ "label": "ERR_INVALID_FILE_URL_HOST", "signature": "`ERR_INVALID_FILE_URL_HOST`", "apiSymbol": "ERR_INVALID_FILE_URL_HOST", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_file_url_host", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_file_url_host", "nodeStability": null, "priority": "normal", "tiers": { @@ -17429,7 +17874,7 @@ "label": "ERR_INVALID_FILE_URL_PATH", "signature": "`ERR_INVALID_FILE_URL_PATH`", "apiSymbol": "ERR_INVALID_FILE_URL_PATH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_file_url_path", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_file_url_path", "nodeStability": null, "priority": "normal", "tiers": { @@ -17449,7 +17894,7 @@ "label": "ERR_INVALID_HANDLE_TYPE", "signature": "`ERR_INVALID_HANDLE_TYPE`", "apiSymbol": "ERR_INVALID_HANDLE_TYPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_handle_type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_handle_type", "nodeStability": null, "priority": "normal", "tiers": { @@ -17469,7 +17914,7 @@ "label": "ERR_INVALID_HTTP_TOKEN", "signature": "`ERR_INVALID_HTTP_TOKEN`", "apiSymbol": "ERR_INVALID_HTTP_TOKEN", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_http_token", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_http_token", "nodeStability": null, "priority": "normal", "tiers": { @@ -17489,7 +17934,7 @@ "label": "ERR_INVALID_IP_ADDRESS", "signature": "`ERR_INVALID_IP_ADDRESS`", "apiSymbol": "ERR_INVALID_IP_ADDRESS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_ip_address", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_ip_address", "nodeStability": null, "priority": "normal", "tiers": { @@ -17509,7 +17954,7 @@ "label": "ERR_INVALID_MIME_SYNTAX", "signature": "`ERR_INVALID_MIME_SYNTAX`", "apiSymbol": "ERR_INVALID_MIME_SYNTAX", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_mime_syntax", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_mime_syntax", "nodeStability": null, "priority": "normal", "tiers": { @@ -17529,7 +17974,7 @@ "label": "ERR_INVALID_MODULE", "signature": "`ERR_INVALID_MODULE`", "apiSymbol": "ERR_INVALID_MODULE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_module", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_module", "nodeStability": null, "priority": "normal", "tiers": { @@ -17549,7 +17994,7 @@ "label": "ERR_INVALID_MODULE_SPECIFIER", "signature": "`ERR_INVALID_MODULE_SPECIFIER`", "apiSymbol": "ERR_INVALID_MODULE_SPECIFIER", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_module_specifier", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_module_specifier", "nodeStability": null, "priority": "normal", "tiers": { @@ -17569,7 +18014,7 @@ "label": "ERR_INVALID_OBJECT_DEFINE_PROPERTY", "signature": "`ERR_INVALID_OBJECT_DEFINE_PROPERTY`", "apiSymbol": "ERR_INVALID_OBJECT_DEFINE_PROPERTY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_object_define_property", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_object_define_property", "nodeStability": null, "priority": "normal", "tiers": { @@ -17589,7 +18034,7 @@ "label": "ERR_INVALID_PACKAGE_CONFIG", "signature": "`ERR_INVALID_PACKAGE_CONFIG`", "apiSymbol": "ERR_INVALID_PACKAGE_CONFIG", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_package_config", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_package_config", "nodeStability": null, "priority": "normal", "tiers": { @@ -17609,7 +18054,7 @@ "label": "ERR_INVALID_PACKAGE_TARGET", "signature": "`ERR_INVALID_PACKAGE_TARGET`", "apiSymbol": "ERR_INVALID_PACKAGE_TARGET", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_package_target", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_package_target", "nodeStability": null, "priority": "normal", "tiers": { @@ -17629,7 +18074,7 @@ "label": "ERR_INVALID_PROTOCOL", "signature": "`ERR_INVALID_PROTOCOL`", "apiSymbol": "ERR_INVALID_PROTOCOL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_protocol", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_protocol", "nodeStability": null, "priority": "normal", "tiers": { @@ -17649,7 +18094,7 @@ "label": "ERR_INVALID_REPL_EVAL_CONFIG", "signature": "`ERR_INVALID_REPL_EVAL_CONFIG`", "apiSymbol": "ERR_INVALID_REPL_EVAL_CONFIG", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_repl_eval_config", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_repl_eval_config", "nodeStability": null, "priority": "normal", "tiers": { @@ -17669,7 +18114,7 @@ "label": "ERR_INVALID_REPL_INPUT", "signature": "`ERR_INVALID_REPL_INPUT`", "apiSymbol": "ERR_INVALID_REPL_INPUT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_repl_input", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_repl_input", "nodeStability": null, "priority": "normal", "tiers": { @@ -17689,7 +18134,7 @@ "label": "ERR_INVALID_RETURN_PROPERTY", "signature": "`ERR_INVALID_RETURN_PROPERTY`", "apiSymbol": "ERR_INVALID_RETURN_PROPERTY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_return_property", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_return_property", "nodeStability": null, "priority": "normal", "tiers": { @@ -17709,7 +18154,7 @@ "label": "ERR_INVALID_RETURN_PROPERTY_VALUE", "signature": "`ERR_INVALID_RETURN_PROPERTY_VALUE`", "apiSymbol": "ERR_INVALID_RETURN_PROPERTY_VALUE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_return_property_value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_return_property_value", "nodeStability": null, "priority": "normal", "tiers": { @@ -17729,7 +18174,7 @@ "label": "ERR_INVALID_RETURN_VALUE", "signature": "`ERR_INVALID_RETURN_VALUE`", "apiSymbol": "ERR_INVALID_RETURN_VALUE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_return_value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_return_value", "nodeStability": null, "priority": "normal", "tiers": { @@ -17749,7 +18194,7 @@ "label": "ERR_INVALID_STATE", "signature": "`ERR_INVALID_STATE`", "apiSymbol": "ERR_INVALID_STATE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_state", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_state", "nodeStability": null, "priority": "normal", "tiers": { @@ -17769,7 +18214,7 @@ "label": "ERR_INVALID_SYNC_FORK_INPUT", "signature": "`ERR_INVALID_SYNC_FORK_INPUT`", "apiSymbol": "ERR_INVALID_SYNC_FORK_INPUT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_sync_fork_input", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_sync_fork_input", "nodeStability": null, "priority": "normal", "tiers": { @@ -17789,7 +18234,7 @@ "label": "ERR_INVALID_THIS", "signature": "`ERR_INVALID_THIS`", "apiSymbol": "ERR_INVALID_THIS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_this", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_this", "nodeStability": null, "priority": "normal", "tiers": { @@ -17809,7 +18254,7 @@ "label": "ERR_INVALID_TUPLE", "signature": "`ERR_INVALID_TUPLE`", "apiSymbol": "ERR_INVALID_TUPLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_tuple", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_tuple", "nodeStability": null, "priority": "normal", "tiers": { @@ -17829,7 +18274,7 @@ "label": "ERR_INVALID_TYPESCRIPT_SYNTAX", "signature": "`ERR_INVALID_TYPESCRIPT_SYNTAX`", "apiSymbol": "ERR_INVALID_TYPESCRIPT_SYNTAX", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_typescript_syntax", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_typescript_syntax", "nodeStability": null, "priority": "normal", "tiers": { @@ -17849,7 +18294,7 @@ "label": "ERR_INVALID_URI", "signature": "`ERR_INVALID_URI`", "apiSymbol": "ERR_INVALID_URI", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_uri", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_uri", "nodeStability": null, "priority": "normal", "tiers": { @@ -17869,7 +18314,7 @@ "label": "ERR_INVALID_URL", "signature": "`ERR_INVALID_URL`", "apiSymbol": "ERR_INVALID_URL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_url", "nodeStability": null, "priority": "normal", "tiers": { @@ -17889,7 +18334,7 @@ "label": "ERR_INVALID_URL_PATTERN", "signature": "`ERR_INVALID_URL_PATTERN`", "apiSymbol": "ERR_INVALID_URL_PATTERN", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_url_pattern", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_url_pattern", "nodeStability": null, "priority": "normal", "tiers": { @@ -17909,7 +18354,7 @@ "label": "ERR_INVALID_URL_SCHEME", "signature": "`ERR_INVALID_URL_SCHEME`", "apiSymbol": "ERR_INVALID_URL_SCHEME", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_url_scheme", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_url_scheme", "nodeStability": null, "priority": "normal", "tiers": { @@ -17929,7 +18374,7 @@ "label": "ERR_IPC_CHANNEL_CLOSED", "signature": "`ERR_IPC_CHANNEL_CLOSED`", "apiSymbol": "ERR_IPC_CHANNEL_CLOSED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_ipc_channel_closed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_ipc_channel_closed", "nodeStability": null, "priority": "normal", "tiers": { @@ -17949,7 +18394,7 @@ "label": "ERR_IPC_DISCONNECTED", "signature": "`ERR_IPC_DISCONNECTED`", "apiSymbol": "ERR_IPC_DISCONNECTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_ipc_disconnected", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_ipc_disconnected", "nodeStability": null, "priority": "normal", "tiers": { @@ -17969,7 +18414,7 @@ "label": "ERR_IPC_ONE_PIPE", "signature": "`ERR_IPC_ONE_PIPE`", "apiSymbol": "ERR_IPC_ONE_PIPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_ipc_one_pipe", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_ipc_one_pipe", "nodeStability": null, "priority": "normal", "tiers": { @@ -17989,7 +18434,7 @@ "label": "ERR_IPC_SYNC_FORK", "signature": "`ERR_IPC_SYNC_FORK`", "apiSymbol": "ERR_IPC_SYNC_FORK", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_ipc_sync_fork", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_ipc_sync_fork", "nodeStability": null, "priority": "normal", "tiers": { @@ -18009,7 +18454,7 @@ "label": "ERR_IP_BLOCKED", "signature": "`ERR_IP_BLOCKED`", "apiSymbol": "ERR_IP_BLOCKED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_ip_blocked", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_ip_blocked", "nodeStability": null, "priority": "normal", "tiers": { @@ -18029,7 +18474,7 @@ "label": "ERR_LOADER_CHAIN_INCOMPLETE", "signature": "`ERR_LOADER_CHAIN_INCOMPLETE`", "apiSymbol": "ERR_LOADER_CHAIN_INCOMPLETE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_loader_chain_incomplete", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_loader_chain_incomplete", "nodeStability": null, "priority": "normal", "tiers": { @@ -18049,7 +18494,7 @@ "label": "ERR_LOAD_SQLITE_EXTENSION", "signature": "`ERR_LOAD_SQLITE_EXTENSION`", "apiSymbol": "ERR_LOAD_SQLITE_EXTENSION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_load_sqlite_extension", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_load_sqlite_extension", "nodeStability": null, "priority": "normal", "tiers": { @@ -18069,7 +18514,7 @@ "label": "ERR_MEMORY_ALLOCATION_FAILED", "signature": "`ERR_MEMORY_ALLOCATION_FAILED`", "apiSymbol": "ERR_MEMORY_ALLOCATION_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_memory_allocation_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_memory_allocation_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -18089,7 +18534,7 @@ "label": "ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE", "signature": "`ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE`", "apiSymbol": "ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_message_target_context_unavailable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_message_target_context_unavailable", "nodeStability": null, "priority": "normal", "tiers": { @@ -18109,7 +18554,7 @@ "label": "ERR_METHOD_NOT_IMPLEMENTED", "signature": "`ERR_METHOD_NOT_IMPLEMENTED`", "apiSymbol": "ERR_METHOD_NOT_IMPLEMENTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_method_not_implemented", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_method_not_implemented", "nodeStability": null, "priority": "normal", "tiers": { @@ -18129,7 +18574,7 @@ "label": "ERR_MISSING_ARGS", "signature": "`ERR_MISSING_ARGS`", "apiSymbol": "ERR_MISSING_ARGS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_missing_args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_missing_args", "nodeStability": null, "priority": "normal", "tiers": { @@ -18149,7 +18594,7 @@ "label": "ERR_MISSING_OPTION", "signature": "`ERR_MISSING_OPTION`", "apiSymbol": "ERR_MISSING_OPTION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_missing_option", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_missing_option", "nodeStability": null, "priority": "normal", "tiers": { @@ -18169,7 +18614,7 @@ "label": "ERR_MISSING_PASSPHRASE", "signature": "`ERR_MISSING_PASSPHRASE`", "apiSymbol": "ERR_MISSING_PASSPHRASE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_missing_passphrase", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_missing_passphrase", "nodeStability": null, "priority": "normal", "tiers": { @@ -18189,7 +18634,7 @@ "label": "ERR_MISSING_PLATFORM_FOR_WORKER", "signature": "`ERR_MISSING_PLATFORM_FOR_WORKER`", "apiSymbol": "ERR_MISSING_PLATFORM_FOR_WORKER", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_missing_platform_for_worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_missing_platform_for_worker", "nodeStability": null, "priority": "normal", "tiers": { @@ -18209,7 +18654,7 @@ "label": "ERR_MODULE_LINK_MISMATCH", "signature": "`ERR_MODULE_LINK_MISMATCH`", "apiSymbol": "ERR_MODULE_LINK_MISMATCH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_module_link_mismatch", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_module_link_mismatch", "nodeStability": null, "priority": "normal", "tiers": { @@ -18229,7 +18674,7 @@ "label": "ERR_MODULE_NOT_FOUND", "signature": "`ERR_MODULE_NOT_FOUND`", "apiSymbol": "ERR_MODULE_NOT_FOUND", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_module_not_found", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_module_not_found", "nodeStability": null, "priority": "normal", "tiers": { @@ -18249,7 +18694,7 @@ "label": "ERR_MULTIPLE_CALLBACK", "signature": "`ERR_MULTIPLE_CALLBACK`", "apiSymbol": "ERR_MULTIPLE_CALLBACK", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_multiple_callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_multiple_callback", "nodeStability": null, "priority": "normal", "tiers": { @@ -18269,7 +18714,7 @@ "label": "ERR_NAPI_CONS_FUNCTION", "signature": "`ERR_NAPI_CONS_FUNCTION`", "apiSymbol": "ERR_NAPI_CONS_FUNCTION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_napi_cons_function", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_napi_cons_function", "nodeStability": null, "priority": "normal", "tiers": { @@ -18289,7 +18734,7 @@ "label": "ERR_NAPI_INVALID_DATAVIEW_ARGS", "signature": "`ERR_NAPI_INVALID_DATAVIEW_ARGS`", "apiSymbol": "ERR_NAPI_INVALID_DATAVIEW_ARGS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_napi_invalid_dataview_args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_napi_invalid_dataview_args", "nodeStability": null, "priority": "normal", "tiers": { @@ -18309,7 +18754,7 @@ "label": "ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT", "signature": "`ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT`", "apiSymbol": "ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_napi_invalid_typedarray_alignment", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_napi_invalid_typedarray_alignment", "nodeStability": null, "priority": "normal", "tiers": { @@ -18329,7 +18774,7 @@ "label": "ERR_NAPI_INVALID_TYPEDARRAY_LENGTH", "signature": "`ERR_NAPI_INVALID_TYPEDARRAY_LENGTH`", "apiSymbol": "ERR_NAPI_INVALID_TYPEDARRAY_LENGTH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_napi_invalid_typedarray_length", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_napi_invalid_typedarray_length", "nodeStability": null, "priority": "normal", "tiers": { @@ -18349,7 +18794,7 @@ "label": "ERR_NAPI_TSFN_CALL_JS", "signature": "`ERR_NAPI_TSFN_CALL_JS`", "apiSymbol": "ERR_NAPI_TSFN_CALL_JS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_napi_tsfn_call_js", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_napi_tsfn_call_js", "nodeStability": null, "priority": "normal", "tiers": { @@ -18369,7 +18814,7 @@ "label": "ERR_NAPI_TSFN_GET_UNDEFINED", "signature": "`ERR_NAPI_TSFN_GET_UNDEFINED`", "apiSymbol": "ERR_NAPI_TSFN_GET_UNDEFINED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_napi_tsfn_get_undefined", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_napi_tsfn_get_undefined", "nodeStability": null, "priority": "normal", "tiers": { @@ -18389,7 +18834,7 @@ "label": "ERR_NON_CONTEXT_AWARE_DISABLED", "signature": "`ERR_NON_CONTEXT_AWARE_DISABLED`", "apiSymbol": "ERR_NON_CONTEXT_AWARE_DISABLED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_non_context_aware_disabled", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_non_context_aware_disabled", "nodeStability": null, "priority": "normal", "tiers": { @@ -18409,7 +18854,7 @@ "label": "ERR_NOT_BUILDING_SNAPSHOT", "signature": "`ERR_NOT_BUILDING_SNAPSHOT`", "apiSymbol": "ERR_NOT_BUILDING_SNAPSHOT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_not_building_snapshot", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_not_building_snapshot", "nodeStability": null, "priority": "normal", "tiers": { @@ -18429,7 +18874,7 @@ "label": "ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION", "signature": "`ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION`", "apiSymbol": "ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_not_in_single_executable_application", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_not_in_single_executable_application", "nodeStability": null, "priority": "normal", "tiers": { @@ -18449,7 +18894,7 @@ "label": "ERR_NOT_SUPPORTED_IN_SNAPSHOT", "signature": "`ERR_NOT_SUPPORTED_IN_SNAPSHOT`", "apiSymbol": "ERR_NOT_SUPPORTED_IN_SNAPSHOT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_not_supported_in_snapshot", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_not_supported_in_snapshot", "nodeStability": null, "priority": "normal", "tiers": { @@ -18469,7 +18914,7 @@ "label": "ERR_NO_CRYPTO", "signature": "`ERR_NO_CRYPTO`", "apiSymbol": "ERR_NO_CRYPTO", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_no_crypto", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_no_crypto", "nodeStability": null, "priority": "normal", "tiers": { @@ -18489,7 +18934,7 @@ "label": "ERR_NO_ICU", "signature": "`ERR_NO_ICU`", "apiSymbol": "ERR_NO_ICU", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_no_icu", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_no_icu", "nodeStability": null, "priority": "normal", "tiers": { @@ -18509,7 +18954,7 @@ "label": "ERR_NO_TYPESCRIPT", "signature": "`ERR_NO_TYPESCRIPT`", "apiSymbol": "ERR_NO_TYPESCRIPT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_no_typescript", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_no_typescript", "nodeStability": null, "priority": "normal", "tiers": { @@ -18529,7 +18974,7 @@ "label": "ERR_OPERATION_FAILED", "signature": "`ERR_OPERATION_FAILED`", "apiSymbol": "ERR_OPERATION_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_operation_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_operation_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -18549,7 +18994,7 @@ "label": "ERR_OPTIONS_BEFORE_BOOTSTRAPPING", "signature": "`ERR_OPTIONS_BEFORE_BOOTSTRAPPING`", "apiSymbol": "ERR_OPTIONS_BEFORE_BOOTSTRAPPING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_options_before_bootstrapping", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_options_before_bootstrapping", "nodeStability": null, "priority": "normal", "tiers": { @@ -18569,7 +19014,7 @@ "label": "ERR_OUT_OF_RANGE", "signature": "`ERR_OUT_OF_RANGE`", "apiSymbol": "ERR_OUT_OF_RANGE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_out_of_range", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_out_of_range", "nodeStability": null, "priority": "normal", "tiers": { @@ -18589,7 +19034,67 @@ "label": "ERR_PACKAGE_IMPORT_NOT_DEFINED", "signature": "`ERR_PACKAGE_IMPORT_NOT_DEFINED`", "apiSymbol": "ERR_PACKAGE_IMPORT_NOT_DEFINED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_package_import_not_defined", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_package_import_not_defined", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:e17495198d37", + "chapter": "errors", + "label": "ERR_PACKAGE_MAP_EXTERNAL_FILE", + "signature": "`ERR_PACKAGE_MAP_EXTERNAL_FILE`", + "apiSymbol": "ERR_PACKAGE_MAP_EXTERNAL_FILE", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_package_map_external_file", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:ff3640a7d624", + "chapter": "errors", + "label": "ERR_PACKAGE_MAP_INVALID", + "signature": "`ERR_PACKAGE_MAP_INVALID`", + "apiSymbol": "ERR_PACKAGE_MAP_INVALID", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_package_map_invalid", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:4bc366c6011c", + "chapter": "errors", + "label": "ERR_PACKAGE_MAP_KEY_NOT_FOUND", + "signature": "`ERR_PACKAGE_MAP_KEY_NOT_FOUND`", + "apiSymbol": "ERR_PACKAGE_MAP_KEY_NOT_FOUND", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_package_map_key_not_found", "nodeStability": null, "priority": "normal", "tiers": { @@ -18609,7 +19114,7 @@ "label": "ERR_PACKAGE_PATH_NOT_EXPORTED", "signature": "`ERR_PACKAGE_PATH_NOT_EXPORTED`", "apiSymbol": "ERR_PACKAGE_PATH_NOT_EXPORTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_package_path_not_exported", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_package_path_not_exported", "nodeStability": null, "priority": "normal", "tiers": { @@ -18629,7 +19134,7 @@ "label": "ERR_PARSE_ARGS_INVALID_OPTION_VALUE", "signature": "`ERR_PARSE_ARGS_INVALID_OPTION_VALUE`", "apiSymbol": "ERR_PARSE_ARGS_INVALID_OPTION_VALUE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_parse_args_invalid_option_value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_parse_args_invalid_option_value", "nodeStability": null, "priority": "normal", "tiers": { @@ -18649,7 +19154,7 @@ "label": "ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL", "signature": "`ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL`", "apiSymbol": "ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_parse_args_unexpected_positional", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_parse_args_unexpected_positional", "nodeStability": null, "priority": "normal", "tiers": { @@ -18669,7 +19174,7 @@ "label": "ERR_PARSE_ARGS_UNKNOWN_OPTION", "signature": "`ERR_PARSE_ARGS_UNKNOWN_OPTION`", "apiSymbol": "ERR_PARSE_ARGS_UNKNOWN_OPTION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_parse_args_unknown_option", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_parse_args_unknown_option", "nodeStability": null, "priority": "normal", "tiers": { @@ -18689,7 +19194,7 @@ "label": "ERR_PERFORMANCE_INVALID_TIMESTAMP", "signature": "`ERR_PERFORMANCE_INVALID_TIMESTAMP`", "apiSymbol": "ERR_PERFORMANCE_INVALID_TIMESTAMP", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_performance_invalid_timestamp", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_performance_invalid_timestamp", "nodeStability": null, "priority": "normal", "tiers": { @@ -18709,7 +19214,7 @@ "label": "ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS", "signature": "`ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS`", "apiSymbol": "ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_performance_measure_invalid_options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_performance_measure_invalid_options", "nodeStability": null, "priority": "normal", "tiers": { @@ -18729,7 +19234,7 @@ "label": "ERR_PROTO_ACCESS", "signature": "`ERR_PROTO_ACCESS`", "apiSymbol": "ERR_PROTO_ACCESS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_proto_access", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_proto_access", "nodeStability": null, "priority": "normal", "tiers": { @@ -18749,7 +19254,7 @@ "label": "ERR_PROXY_INVALID_CONFIG", "signature": "`ERR_PROXY_INVALID_CONFIG`", "apiSymbol": "ERR_PROXY_INVALID_CONFIG", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_proxy_invalid_config", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_proxy_invalid_config", "nodeStability": null, "priority": "normal", "tiers": { @@ -18769,7 +19274,7 @@ "label": "ERR_PROXY_TUNNEL", "signature": "`ERR_PROXY_TUNNEL`", "apiSymbol": "ERR_PROXY_TUNNEL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_proxy_tunnel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_proxy_tunnel", "nodeStability": null, "priority": "normal", "tiers": { @@ -18789,7 +19294,7 @@ "label": "ERR_QUIC_APPLICATION_ERROR", "signature": "`ERR_QUIC_APPLICATION_ERROR`", "apiSymbol": "ERR_QUIC_APPLICATION_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_quic_application_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_quic_application_error", "nodeStability": { "index": "1", "level": 1, @@ -18814,7 +19319,7 @@ "label": "ERR_QUIC_CONNECTION_FAILED", "signature": "`ERR_QUIC_CONNECTION_FAILED`", "apiSymbol": "ERR_QUIC_CONNECTION_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_quic_connection_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_quic_connection_failed", "nodeStability": { "index": "1", "level": 1, @@ -18839,7 +19344,7 @@ "label": "ERR_QUIC_ENDPOINT_CLOSED", "signature": "`ERR_QUIC_ENDPOINT_CLOSED`", "apiSymbol": "ERR_QUIC_ENDPOINT_CLOSED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_quic_endpoint_closed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_quic_endpoint_closed", "nodeStability": { "index": "1", "level": 1, @@ -18864,7 +19369,57 @@ "label": "ERR_QUIC_OPEN_STREAM_FAILED", "signature": "`ERR_QUIC_OPEN_STREAM_FAILED`", "apiSymbol": "ERR_QUIC_OPEN_STREAM_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_quic_open_stream_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_quic_open_stream_failed", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:26e263d339c6", + "chapter": "errors", + "label": "ERR_QUIC_STREAM_ABORTED", + "signature": "`ERR_QUIC_STREAM_ABORTED`", + "apiSymbol": "ERR_QUIC_STREAM_ABORTED", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_quic_stream_aborted", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:a8b44a283f33", + "chapter": "errors", + "label": "ERR_QUIC_STREAM_RESET", + "signature": "`ERR_QUIC_STREAM_RESET`", + "apiSymbol": "ERR_QUIC_STREAM_RESET", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_quic_stream_reset", "nodeStability": { "index": "1", "level": 1, @@ -18889,7 +19444,7 @@ "label": "ERR_QUIC_TRANSPORT_ERROR", "signature": "`ERR_QUIC_TRANSPORT_ERROR`", "apiSymbol": "ERR_QUIC_TRANSPORT_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_quic_transport_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_quic_transport_error", "nodeStability": { "index": "1", "level": 1, @@ -18914,7 +19469,7 @@ "label": "ERR_QUIC_VERSION_NEGOTIATION_ERROR", "signature": "`ERR_QUIC_VERSION_NEGOTIATION_ERROR`", "apiSymbol": "ERR_QUIC_VERSION_NEGOTIATION_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_quic_version_negotiation_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_quic_version_negotiation_error", "nodeStability": { "index": "1", "level": 1, @@ -18939,7 +19494,7 @@ "label": "ERR_REQUIRE_ASYNC_MODULE", "signature": "`ERR_REQUIRE_ASYNC_MODULE`", "apiSymbol": "ERR_REQUIRE_ASYNC_MODULE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_require_async_module", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_require_async_module", "nodeStability": null, "priority": "normal", "tiers": { @@ -18959,7 +19514,7 @@ "label": "ERR_REQUIRE_CYCLE_MODULE", "signature": "`ERR_REQUIRE_CYCLE_MODULE`", "apiSymbol": "ERR_REQUIRE_CYCLE_MODULE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_require_cycle_module", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_require_cycle_module", "nodeStability": null, "priority": "normal", "tiers": { @@ -18979,7 +19534,7 @@ "label": "ERR_REQUIRE_ESM", "signature": "`ERR_REQUIRE_ESM`", "apiSymbol": "ERR_REQUIRE_ESM", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_require_esm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_require_esm", "nodeStability": { "index": "0", "level": 0, @@ -18998,13 +19553,38 @@ } } }, + { + "id": "errors:ad1a5adf2534", + "chapter": "errors", + "label": "ERR_REQUIRE_ESM_RACE_CONDITION", + "signature": "`ERR_REQUIRE_ESM_RACE_CONDITION`", + "apiSymbol": "ERR_REQUIRE_ESM_RACE_CONDITION", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_require_esm_race_condition", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental.", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, { "id": "errors:50007aab8780", "chapter": "errors", "label": "ERR_SCRIPT_EXECUTION_INTERRUPTED", "signature": "`ERR_SCRIPT_EXECUTION_INTERRUPTED`", "apiSymbol": "ERR_SCRIPT_EXECUTION_INTERRUPTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_script_execution_interrupted", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_script_execution_interrupted", "nodeStability": null, "priority": "normal", "tiers": { @@ -19024,7 +19604,7 @@ "label": "ERR_SCRIPT_EXECUTION_TIMEOUT", "signature": "`ERR_SCRIPT_EXECUTION_TIMEOUT`", "apiSymbol": "ERR_SCRIPT_EXECUTION_TIMEOUT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_script_execution_timeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_script_execution_timeout", "nodeStability": null, "priority": "normal", "tiers": { @@ -19044,7 +19624,7 @@ "label": "ERR_SERVER_ALREADY_LISTEN", "signature": "`ERR_SERVER_ALREADY_LISTEN`", "apiSymbol": "ERR_SERVER_ALREADY_LISTEN", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_server_already_listen", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_server_already_listen", "nodeStability": null, "priority": "normal", "tiers": { @@ -19064,7 +19644,7 @@ "label": "ERR_SERVER_NOT_RUNNING", "signature": "`ERR_SERVER_NOT_RUNNING`", "apiSymbol": "ERR_SERVER_NOT_RUNNING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_server_not_running", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_server_not_running", "nodeStability": null, "priority": "normal", "tiers": { @@ -19084,7 +19664,7 @@ "label": "ERR_SINGLE_EXECUTABLE_APPLICATION_ASSET_NOT_FOUND", "signature": "`ERR_SINGLE_EXECUTABLE_APPLICATION_ASSET_NOT_FOUND`", "apiSymbol": "ERR_SINGLE_EXECUTABLE_APPLICATION_ASSET_NOT_FOUND", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_single_executable_application_asset_not_found", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_single_executable_application_asset_not_found", "nodeStability": null, "priority": "normal", "tiers": { @@ -19104,7 +19684,7 @@ "label": "ERR_SOCKET_ALREADY_BOUND", "signature": "`ERR_SOCKET_ALREADY_BOUND`", "apiSymbol": "ERR_SOCKET_ALREADY_BOUND", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_socket_already_bound", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_already_bound", "nodeStability": null, "priority": "normal", "tiers": { @@ -19124,7 +19704,7 @@ "label": "ERR_SOCKET_BAD_BUFFER_SIZE", "signature": "`ERR_SOCKET_BAD_BUFFER_SIZE`", "apiSymbol": "ERR_SOCKET_BAD_BUFFER_SIZE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_socket_bad_buffer_size", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_bad_buffer_size", "nodeStability": null, "priority": "normal", "tiers": { @@ -19144,7 +19724,7 @@ "label": "ERR_SOCKET_BAD_PORT", "signature": "`ERR_SOCKET_BAD_PORT`", "apiSymbol": "ERR_SOCKET_BAD_PORT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_socket_bad_port", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_bad_port", "nodeStability": null, "priority": "normal", "tiers": { @@ -19164,7 +19744,7 @@ "label": "ERR_SOCKET_BAD_TYPE", "signature": "`ERR_SOCKET_BAD_TYPE`", "apiSymbol": "ERR_SOCKET_BAD_TYPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_socket_bad_type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_bad_type", "nodeStability": null, "priority": "normal", "tiers": { @@ -19184,7 +19764,7 @@ "label": "ERR_SOCKET_BUFFER_SIZE", "signature": "`ERR_SOCKET_BUFFER_SIZE`", "apiSymbol": "ERR_SOCKET_BUFFER_SIZE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_socket_buffer_size", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_buffer_size", "nodeStability": null, "priority": "normal", "tiers": { @@ -19204,7 +19784,7 @@ "label": "ERR_SOCKET_CLOSED", "signature": "`ERR_SOCKET_CLOSED`", "apiSymbol": "ERR_SOCKET_CLOSED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_socket_closed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_closed", "nodeStability": null, "priority": "normal", "tiers": { @@ -19224,7 +19804,7 @@ "label": "ERR_SOCKET_CLOSED_BEFORE_CONNECTION", "signature": "`ERR_SOCKET_CLOSED_BEFORE_CONNECTION`", "apiSymbol": "ERR_SOCKET_CLOSED_BEFORE_CONNECTION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_socket_closed_before_connection", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_closed_before_connection", "nodeStability": null, "priority": "normal", "tiers": { @@ -19244,7 +19824,7 @@ "label": "ERR_SOCKET_CONNECTION_TIMEOUT", "signature": "`ERR_SOCKET_CONNECTION_TIMEOUT`", "apiSymbol": "ERR_SOCKET_CONNECTION_TIMEOUT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_socket_connection_timeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_connection_timeout", "nodeStability": null, "priority": "normal", "tiers": { @@ -19264,7 +19844,7 @@ "label": "ERR_SOCKET_DGRAM_IS_CONNECTED", "signature": "`ERR_SOCKET_DGRAM_IS_CONNECTED`", "apiSymbol": "ERR_SOCKET_DGRAM_IS_CONNECTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_socket_dgram_is_connected", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_dgram_is_connected", "nodeStability": null, "priority": "normal", "tiers": { @@ -19284,7 +19864,7 @@ "label": "ERR_SOCKET_DGRAM_NOT_CONNECTED", "signature": "`ERR_SOCKET_DGRAM_NOT_CONNECTED`", "apiSymbol": "ERR_SOCKET_DGRAM_NOT_CONNECTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_socket_dgram_not_connected", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_dgram_not_connected", "nodeStability": null, "priority": "normal", "tiers": { @@ -19304,7 +19884,27 @@ "label": "ERR_SOCKET_DGRAM_NOT_RUNNING", "signature": "`ERR_SOCKET_DGRAM_NOT_RUNNING`", "apiSymbol": "ERR_SOCKET_DGRAM_NOT_RUNNING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_socket_dgram_not_running", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_dgram_not_running", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:7e6c1ed4db94", + "chapter": "errors", + "label": "ERR_SOCKET_HANDLE_ADOPTED", + "signature": "`ERR_SOCKET_HANDLE_ADOPTED`", + "apiSymbol": "ERR_SOCKET_HANDLE_ADOPTED", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_handle_adopted", "nodeStability": null, "priority": "normal", "tiers": { @@ -19324,7 +19924,7 @@ "label": "ERR_SOURCE_MAP_CORRUPT", "signature": "`ERR_SOURCE_MAP_CORRUPT`", "apiSymbol": "ERR_SOURCE_MAP_CORRUPT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_source_map_corrupt", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_source_map_corrupt", "nodeStability": null, "priority": "normal", "tiers": { @@ -19344,7 +19944,7 @@ "label": "ERR_SOURCE_MAP_MISSING_SOURCE", "signature": "`ERR_SOURCE_MAP_MISSING_SOURCE`", "apiSymbol": "ERR_SOURCE_MAP_MISSING_SOURCE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_source_map_missing_source", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_source_map_missing_source", "nodeStability": null, "priority": "normal", "tiers": { @@ -19364,7 +19964,7 @@ "label": "ERR_SOURCE_PHASE_NOT_DEFINED", "signature": "`ERR_SOURCE_PHASE_NOT_DEFINED`", "apiSymbol": "ERR_SOURCE_PHASE_NOT_DEFINED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_source_phase_not_defined", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_source_phase_not_defined", "nodeStability": null, "priority": "normal", "tiers": { @@ -19384,7 +19984,7 @@ "label": "ERR_SQLITE_ERROR", "signature": "`ERR_SQLITE_ERROR`", "apiSymbol": "ERR_SQLITE_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_sqlite_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_sqlite_error", "nodeStability": null, "priority": "normal", "tiers": { @@ -19404,7 +20004,7 @@ "label": "ERR_SRI_PARSE", "signature": "`ERR_SRI_PARSE`", "apiSymbol": "ERR_SRI_PARSE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_sri_parse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_sri_parse", "nodeStability": null, "priority": "normal", "tiers": { @@ -19424,7 +20024,7 @@ "label": "ERR_STREAM_ALREADY_FINISHED", "signature": "`ERR_STREAM_ALREADY_FINISHED`", "apiSymbol": "ERR_STREAM_ALREADY_FINISHED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stream_already_finished", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stream_already_finished", "nodeStability": null, "priority": "normal", "tiers": { @@ -19444,7 +20044,7 @@ "label": "ERR_STREAM_CANNOT_PIPE", "signature": "`ERR_STREAM_CANNOT_PIPE`", "apiSymbol": "ERR_STREAM_CANNOT_PIPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stream_cannot_pipe", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stream_cannot_pipe", "nodeStability": null, "priority": "normal", "tiers": { @@ -19464,7 +20064,27 @@ "label": "ERR_STREAM_DESTROYED", "signature": "`ERR_STREAM_DESTROYED`", "apiSymbol": "ERR_STREAM_DESTROYED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stream_destroyed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stream_destroyed", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:a378bec92079", + "chapter": "errors", + "label": "ERR_STREAM_ITER_MISSING_FLAG", + "signature": "`ERR_STREAM_ITER_MISSING_FLAG`", + "apiSymbol": "ERR_STREAM_ITER_MISSING_FLAG", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stream_iter_missing_flag", "nodeStability": null, "priority": "normal", "tiers": { @@ -19484,7 +20104,7 @@ "label": "ERR_STREAM_NULL_VALUES", "signature": "`ERR_STREAM_NULL_VALUES`", "apiSymbol": "ERR_STREAM_NULL_VALUES", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stream_null_values", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stream_null_values", "nodeStability": null, "priority": "normal", "tiers": { @@ -19504,7 +20124,7 @@ "label": "ERR_STREAM_PREMATURE_CLOSE", "signature": "`ERR_STREAM_PREMATURE_CLOSE`", "apiSymbol": "ERR_STREAM_PREMATURE_CLOSE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stream_premature_close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stream_premature_close", "nodeStability": null, "priority": "normal", "tiers": { @@ -19524,7 +20144,7 @@ "label": "ERR_STREAM_PUSH_AFTER_EOF", "signature": "`ERR_STREAM_PUSH_AFTER_EOF`", "apiSymbol": "ERR_STREAM_PUSH_AFTER_EOF", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stream_push_after_eof", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stream_push_after_eof", "nodeStability": null, "priority": "normal", "tiers": { @@ -19544,7 +20164,7 @@ "label": "ERR_STREAM_UNABLE_TO_PIPE", "signature": "`ERR_STREAM_UNABLE_TO_PIPE`", "apiSymbol": "ERR_STREAM_UNABLE_TO_PIPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stream_unable_to_pipe", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stream_unable_to_pipe", "nodeStability": null, "priority": "normal", "tiers": { @@ -19564,7 +20184,7 @@ "label": "ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "signature": "`ERR_STREAM_UNSHIFT_AFTER_END_EVENT`", "apiSymbol": "ERR_STREAM_UNSHIFT_AFTER_END_EVENT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stream_unshift_after_end_event", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stream_unshift_after_end_event", "nodeStability": null, "priority": "normal", "tiers": { @@ -19584,7 +20204,7 @@ "label": "ERR_STREAM_WRAP", "signature": "`ERR_STREAM_WRAP`", "apiSymbol": "ERR_STREAM_WRAP", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stream_wrap", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stream_wrap", "nodeStability": null, "priority": "normal", "tiers": { @@ -19604,7 +20224,7 @@ "label": "ERR_STREAM_WRITE_AFTER_END", "signature": "`ERR_STREAM_WRITE_AFTER_END`", "apiSymbol": "ERR_STREAM_WRITE_AFTER_END", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stream_write_after_end", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stream_write_after_end", "nodeStability": null, "priority": "normal", "tiers": { @@ -19624,7 +20244,7 @@ "label": "ERR_STRING_TOO_LONG", "signature": "`ERR_STRING_TOO_LONG`", "apiSymbol": "ERR_STRING_TOO_LONG", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_string_too_long", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_string_too_long", "nodeStability": null, "priority": "normal", "tiers": { @@ -19644,7 +20264,7 @@ "label": "ERR_SYNTHETIC", "signature": "`ERR_SYNTHETIC`", "apiSymbol": "ERR_SYNTHETIC", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_synthetic", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_synthetic", "nodeStability": null, "priority": "normal", "tiers": { @@ -19664,7 +20284,7 @@ "label": "ERR_SYSTEM_ERROR", "signature": "`ERR_SYSTEM_ERROR`", "apiSymbol": "ERR_SYSTEM_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_system_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_system_error", "nodeStability": null, "priority": "normal", "tiers": { @@ -19684,7 +20304,27 @@ "label": "ERR_TEST_FAILURE", "signature": "`ERR_TEST_FAILURE`", "apiSymbol": "ERR_TEST_FAILURE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_test_failure", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_test_failure", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:e23d44126eae", + "chapter": "errors", + "label": "ERR_THROTTLED", + "signature": "`ERR_THROTTLED`", + "apiSymbol": "ERR_THROTTLED", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_throttled", "nodeStability": null, "priority": "normal", "tiers": { @@ -19704,7 +20344,7 @@ "label": "ERR_TLS_ALPN_CALLBACK_INVALID_RESULT", "signature": "`ERR_TLS_ALPN_CALLBACK_INVALID_RESULT`", "apiSymbol": "ERR_TLS_ALPN_CALLBACK_INVALID_RESULT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_alpn_callback_invalid_result", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_alpn_callback_invalid_result", "nodeStability": null, "priority": "normal", "tiers": { @@ -19724,7 +20364,7 @@ "label": "ERR_TLS_ALPN_CALLBACK_WITH_PROTOCOLS", "signature": "`ERR_TLS_ALPN_CALLBACK_WITH_PROTOCOLS`", "apiSymbol": "ERR_TLS_ALPN_CALLBACK_WITH_PROTOCOLS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_alpn_callback_with_protocols", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_alpn_callback_with_protocols", "nodeStability": null, "priority": "normal", "tiers": { @@ -19744,7 +20384,7 @@ "label": "ERR_TLS_CERT_ALTNAME_FORMAT", "signature": "`ERR_TLS_CERT_ALTNAME_FORMAT`", "apiSymbol": "ERR_TLS_CERT_ALTNAME_FORMAT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_cert_altname_format", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_cert_altname_format", "nodeStability": null, "priority": "normal", "tiers": { @@ -19764,7 +20404,7 @@ "label": "ERR_TLS_CERT_ALTNAME_INVALID", "signature": "`ERR_TLS_CERT_ALTNAME_INVALID`", "apiSymbol": "ERR_TLS_CERT_ALTNAME_INVALID", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_cert_altname_invalid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_cert_altname_invalid", "nodeStability": null, "priority": "normal", "tiers": { @@ -19784,7 +20424,7 @@ "label": "ERR_TLS_DH_PARAM_SIZE", "signature": "`ERR_TLS_DH_PARAM_SIZE`", "apiSymbol": "ERR_TLS_DH_PARAM_SIZE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_dh_param_size", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_dh_param_size", "nodeStability": null, "priority": "normal", "tiers": { @@ -19804,7 +20444,7 @@ "label": "ERR_TLS_HANDSHAKE_TIMEOUT", "signature": "`ERR_TLS_HANDSHAKE_TIMEOUT`", "apiSymbol": "ERR_TLS_HANDSHAKE_TIMEOUT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_handshake_timeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_handshake_timeout", "nodeStability": null, "priority": "normal", "tiers": { @@ -19824,7 +20464,7 @@ "label": "ERR_TLS_INVALID_CONTEXT", "signature": "`ERR_TLS_INVALID_CONTEXT`", "apiSymbol": "ERR_TLS_INVALID_CONTEXT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_invalid_context", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_invalid_context", "nodeStability": null, "priority": "normal", "tiers": { @@ -19844,7 +20484,7 @@ "label": "ERR_TLS_INVALID_PROTOCOL_METHOD", "signature": "`ERR_TLS_INVALID_PROTOCOL_METHOD`", "apiSymbol": "ERR_TLS_INVALID_PROTOCOL_METHOD", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_invalid_protocol_method", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_invalid_protocol_method", "nodeStability": null, "priority": "normal", "tiers": { @@ -19864,7 +20504,7 @@ "label": "ERR_TLS_INVALID_PROTOCOL_VERSION", "signature": "`ERR_TLS_INVALID_PROTOCOL_VERSION`", "apiSymbol": "ERR_TLS_INVALID_PROTOCOL_VERSION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_invalid_protocol_version", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_invalid_protocol_version", "nodeStability": null, "priority": "normal", "tiers": { @@ -19884,7 +20524,7 @@ "label": "ERR_TLS_INVALID_STATE", "signature": "`ERR_TLS_INVALID_STATE`", "apiSymbol": "ERR_TLS_INVALID_STATE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_invalid_state", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_invalid_state", "nodeStability": null, "priority": "normal", "tiers": { @@ -19904,7 +20544,7 @@ "label": "ERR_TLS_PROTOCOL_VERSION_CONFLICT", "signature": "`ERR_TLS_PROTOCOL_VERSION_CONFLICT`", "apiSymbol": "ERR_TLS_PROTOCOL_VERSION_CONFLICT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_protocol_version_conflict", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_protocol_version_conflict", "nodeStability": null, "priority": "normal", "tiers": { @@ -19924,7 +20564,7 @@ "label": "ERR_TLS_PSK_SET_IDENTITY_HINT_FAILED", "signature": "`ERR_TLS_PSK_SET_IDENTITY_HINT_FAILED`", "apiSymbol": "ERR_TLS_PSK_SET_IDENTITY_HINT_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_psk_set_identity_hint_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_psk_set_identity_hint_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -19944,7 +20584,27 @@ "label": "ERR_TLS_RENEGOTIATION_DISABLED", "signature": "`ERR_TLS_RENEGOTIATION_DISABLED`", "apiSymbol": "ERR_TLS_RENEGOTIATION_DISABLED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_renegotiation_disabled", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_renegotiation_disabled", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:1d4c8b8ea330", + "chapter": "errors", + "label": "ERR_TLS_RENEGOTIATION_UNSUPPORTED", + "signature": "`ERR_TLS_RENEGOTIATION_UNSUPPORTED`", + "apiSymbol": "ERR_TLS_RENEGOTIATION_UNSUPPORTED", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_renegotiation_unsupported", "nodeStability": null, "priority": "normal", "tiers": { @@ -19964,7 +20624,7 @@ "label": "ERR_TLS_REQUIRED_SERVER_NAME", "signature": "`ERR_TLS_REQUIRED_SERVER_NAME`", "apiSymbol": "ERR_TLS_REQUIRED_SERVER_NAME", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_required_server_name", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_required_server_name", "nodeStability": null, "priority": "normal", "tiers": { @@ -19984,7 +20644,7 @@ "label": "ERR_TLS_SESSION_ATTACK", "signature": "`ERR_TLS_SESSION_ATTACK`", "apiSymbol": "ERR_TLS_SESSION_ATTACK", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_session_attack", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_session_attack", "nodeStability": null, "priority": "normal", "tiers": { @@ -20004,7 +20664,7 @@ "label": "ERR_TLS_SNI_FROM_SERVER", "signature": "`ERR_TLS_SNI_FROM_SERVER`", "apiSymbol": "ERR_TLS_SNI_FROM_SERVER", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_sni_from_server", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_sni_from_server", "nodeStability": null, "priority": "normal", "tiers": { @@ -20024,7 +20684,7 @@ "label": "ERR_TRACE_EVENTS_CATEGORY_REQUIRED", "signature": "`ERR_TRACE_EVENTS_CATEGORY_REQUIRED`", "apiSymbol": "ERR_TRACE_EVENTS_CATEGORY_REQUIRED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_trace_events_category_required", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_trace_events_category_required", "nodeStability": null, "priority": "normal", "tiers": { @@ -20044,7 +20704,7 @@ "label": "ERR_TRACE_EVENTS_UNAVAILABLE", "signature": "`ERR_TRACE_EVENTS_UNAVAILABLE`", "apiSymbol": "ERR_TRACE_EVENTS_UNAVAILABLE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_trace_events_unavailable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_trace_events_unavailable", "nodeStability": null, "priority": "normal", "tiers": { @@ -20064,7 +20724,7 @@ "label": "ERR_TRAILING_JUNK_AFTER_STREAM_END", "signature": "`ERR_TRAILING_JUNK_AFTER_STREAM_END`", "apiSymbol": "ERR_TRAILING_JUNK_AFTER_STREAM_END", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_trailing_junk_after_stream_end", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_trailing_junk_after_stream_end", "nodeStability": null, "priority": "normal", "tiers": { @@ -20084,7 +20744,7 @@ "label": "ERR_TRANSFORM_ALREADY_TRANSFORMING", "signature": "`ERR_TRANSFORM_ALREADY_TRANSFORMING`", "apiSymbol": "ERR_TRANSFORM_ALREADY_TRANSFORMING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_transform_already_transforming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_transform_already_transforming", "nodeStability": null, "priority": "normal", "tiers": { @@ -20104,7 +20764,7 @@ "label": "ERR_TRANSFORM_WITH_LENGTH_0", "signature": "`ERR_TRANSFORM_WITH_LENGTH_0`", "apiSymbol": "ERR_TRANSFORM_WITH_LENGTH_0", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_transform_with_length_0", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_transform_with_length_0", "nodeStability": null, "priority": "normal", "tiers": { @@ -20124,7 +20784,7 @@ "label": "ERR_TTY_INIT_FAILED", "signature": "`ERR_TTY_INIT_FAILED`", "apiSymbol": "ERR_TTY_INIT_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tty_init_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tty_init_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -20144,7 +20804,7 @@ "label": "ERR_UNAVAILABLE_DURING_EXIT", "signature": "`ERR_UNAVAILABLE_DURING_EXIT`", "apiSymbol": "ERR_UNAVAILABLE_DURING_EXIT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unavailable_during_exit", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unavailable_during_exit", "nodeStability": null, "priority": "normal", "tiers": { @@ -20164,7 +20824,7 @@ "label": "ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET", "signature": "`ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET`", "apiSymbol": "ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_uncaught_exception_capture_already_set", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_uncaught_exception_capture_already_set", "nodeStability": null, "priority": "normal", "tiers": { @@ -20184,7 +20844,7 @@ "label": "ERR_UNESCAPED_CHARACTERS", "signature": "`ERR_UNESCAPED_CHARACTERS`", "apiSymbol": "ERR_UNESCAPED_CHARACTERS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unescaped_characters", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unescaped_characters", "nodeStability": null, "priority": "normal", "tiers": { @@ -20204,7 +20864,7 @@ "label": "ERR_UNHANDLED_ERROR", "signature": "`ERR_UNHANDLED_ERROR`", "apiSymbol": "ERR_UNHANDLED_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unhandled_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unhandled_error", "nodeStability": null, "priority": "normal", "tiers": { @@ -20224,7 +20884,7 @@ "label": "ERR_UNKNOWN_BUILTIN_MODULE", "signature": "`ERR_UNKNOWN_BUILTIN_MODULE`", "apiSymbol": "ERR_UNKNOWN_BUILTIN_MODULE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unknown_builtin_module", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unknown_builtin_module", "nodeStability": null, "priority": "normal", "tiers": { @@ -20244,7 +20904,7 @@ "label": "ERR_UNKNOWN_CREDENTIAL", "signature": "`ERR_UNKNOWN_CREDENTIAL`", "apiSymbol": "ERR_UNKNOWN_CREDENTIAL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unknown_credential", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unknown_credential", "nodeStability": null, "priority": "normal", "tiers": { @@ -20264,7 +20924,7 @@ "label": "ERR_UNKNOWN_ENCODING", "signature": "`ERR_UNKNOWN_ENCODING`", "apiSymbol": "ERR_UNKNOWN_ENCODING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unknown_encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unknown_encoding", "nodeStability": null, "priority": "normal", "tiers": { @@ -20284,7 +20944,7 @@ "label": "ERR_UNKNOWN_FILE_EXTENSION", "signature": "`ERR_UNKNOWN_FILE_EXTENSION`", "apiSymbol": "ERR_UNKNOWN_FILE_EXTENSION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unknown_file_extension", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unknown_file_extension", "nodeStability": null, "priority": "normal", "tiers": { @@ -20304,7 +20964,7 @@ "label": "ERR_UNKNOWN_MODULE_FORMAT", "signature": "`ERR_UNKNOWN_MODULE_FORMAT`", "apiSymbol": "ERR_UNKNOWN_MODULE_FORMAT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unknown_module_format", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unknown_module_format", "nodeStability": null, "priority": "normal", "tiers": { @@ -20324,7 +20984,7 @@ "label": "ERR_UNKNOWN_SIGNAL", "signature": "`ERR_UNKNOWN_SIGNAL`", "apiSymbol": "ERR_UNKNOWN_SIGNAL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unknown_signal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unknown_signal", "nodeStability": null, "priority": "normal", "tiers": { @@ -20344,7 +21004,7 @@ "label": "ERR_UNSUPPORTED_DIR_IMPORT", "signature": "`ERR_UNSUPPORTED_DIR_IMPORT`", "apiSymbol": "ERR_UNSUPPORTED_DIR_IMPORT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unsupported_dir_import", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unsupported_dir_import", "nodeStability": null, "priority": "normal", "tiers": { @@ -20364,7 +21024,7 @@ "label": "ERR_UNSUPPORTED_ESM_URL_SCHEME", "signature": "`ERR_UNSUPPORTED_ESM_URL_SCHEME`", "apiSymbol": "ERR_UNSUPPORTED_ESM_URL_SCHEME", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unsupported_esm_url_scheme", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unsupported_esm_url_scheme", "nodeStability": null, "priority": "normal", "tiers": { @@ -20384,7 +21044,7 @@ "label": "ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING", "signature": "`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`", "apiSymbol": "ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unsupported_node_modules_type_stripping", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unsupported_node_modules_type_stripping", "nodeStability": null, "priority": "normal", "tiers": { @@ -20404,7 +21064,7 @@ "label": "ERR_UNSUPPORTED_RESOLVE_REQUEST", "signature": "`ERR_UNSUPPORTED_RESOLVE_REQUEST`", "apiSymbol": "ERR_UNSUPPORTED_RESOLVE_REQUEST", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unsupported_resolve_request", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unsupported_resolve_request", "nodeStability": null, "priority": "normal", "tiers": { @@ -20424,7 +21084,7 @@ "label": "ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX", "signature": "`ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX`", "apiSymbol": "ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unsupported_typescript_syntax", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unsupported_typescript_syntax", "nodeStability": null, "priority": "normal", "tiers": { @@ -20444,7 +21104,7 @@ "label": "ERR_USE_AFTER_CLOSE", "signature": "`ERR_USE_AFTER_CLOSE`", "apiSymbol": "ERR_USE_AFTER_CLOSE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_use_after_close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_use_after_close", "nodeStability": null, "priority": "normal", "tiers": { @@ -20464,7 +21124,7 @@ "label": "ERR_VALID_PERFORMANCE_ENTRY_TYPE", "signature": "`ERR_VALID_PERFORMANCE_ENTRY_TYPE`", "apiSymbol": "ERR_VALID_PERFORMANCE_ENTRY_TYPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_valid_performance_entry_type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_valid_performance_entry_type", "nodeStability": null, "priority": "normal", "tiers": { @@ -20484,7 +21144,7 @@ "label": "ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING", "signature": "`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`", "apiSymbol": "ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_vm_dynamic_import_callback_missing", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_vm_dynamic_import_callback_missing", "nodeStability": null, "priority": "normal", "tiers": { @@ -20504,7 +21164,7 @@ "label": "ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG", "signature": "`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG`", "apiSymbol": "ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_vm_dynamic_import_callback_missing_flag", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_vm_dynamic_import_callback_missing_flag", "nodeStability": null, "priority": "normal", "tiers": { @@ -20524,7 +21184,7 @@ "label": "ERR_VM_MODULE_ALREADY_LINKED", "signature": "`ERR_VM_MODULE_ALREADY_LINKED`", "apiSymbol": "ERR_VM_MODULE_ALREADY_LINKED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_vm_module_already_linked", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_vm_module_already_linked", "nodeStability": null, "priority": "normal", "tiers": { @@ -20544,7 +21204,7 @@ "label": "ERR_VM_MODULE_CACHED_DATA_REJECTED", "signature": "`ERR_VM_MODULE_CACHED_DATA_REJECTED`", "apiSymbol": "ERR_VM_MODULE_CACHED_DATA_REJECTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_vm_module_cached_data_rejected", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_vm_module_cached_data_rejected", "nodeStability": null, "priority": "normal", "tiers": { @@ -20564,7 +21224,7 @@ "label": "ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA", "signature": "`ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA`", "apiSymbol": "ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_vm_module_cannot_create_cached_data", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_vm_module_cannot_create_cached_data", "nodeStability": null, "priority": "normal", "tiers": { @@ -20584,7 +21244,7 @@ "label": "ERR_VM_MODULE_DIFFERENT_CONTEXT", "signature": "`ERR_VM_MODULE_DIFFERENT_CONTEXT`", "apiSymbol": "ERR_VM_MODULE_DIFFERENT_CONTEXT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_vm_module_different_context", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_vm_module_different_context", "nodeStability": null, "priority": "normal", "tiers": { @@ -20604,7 +21264,7 @@ "label": "ERR_VM_MODULE_LINK_FAILURE", "signature": "`ERR_VM_MODULE_LINK_FAILURE`", "apiSymbol": "ERR_VM_MODULE_LINK_FAILURE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_vm_module_link_failure", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_vm_module_link_failure", "nodeStability": null, "priority": "normal", "tiers": { @@ -20624,7 +21284,7 @@ "label": "ERR_VM_MODULE_NOT_MODULE", "signature": "`ERR_VM_MODULE_NOT_MODULE`", "apiSymbol": "ERR_VM_MODULE_NOT_MODULE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_vm_module_not_module", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_vm_module_not_module", "nodeStability": null, "priority": "normal", "tiers": { @@ -20644,7 +21304,7 @@ "label": "ERR_VM_MODULE_STATUS", "signature": "`ERR_VM_MODULE_STATUS`", "apiSymbol": "ERR_VM_MODULE_STATUS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_vm_module_status", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_vm_module_status", "nodeStability": null, "priority": "normal", "tiers": { @@ -20664,7 +21324,7 @@ "label": "ERR_WASI_ALREADY_STARTED", "signature": "`ERR_WASI_ALREADY_STARTED`", "apiSymbol": "ERR_WASI_ALREADY_STARTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_wasi_already_started", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_wasi_already_started", "nodeStability": null, "priority": "normal", "tiers": { @@ -20684,7 +21344,7 @@ "label": "ERR_WASI_NOT_STARTED", "signature": "`ERR_WASI_NOT_STARTED`", "apiSymbol": "ERR_WASI_NOT_STARTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_wasi_not_started", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_wasi_not_started", "nodeStability": null, "priority": "normal", "tiers": { @@ -20704,7 +21364,7 @@ "label": "ERR_WEBASSEMBLY_NOT_SUPPORTED", "signature": "`ERR_WEBASSEMBLY_NOT_SUPPORTED`", "apiSymbol": "ERR_WEBASSEMBLY_NOT_SUPPORTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_webassembly_not_supported", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_webassembly_not_supported", "nodeStability": null, "priority": "normal", "tiers": { @@ -20724,7 +21384,27 @@ "label": "ERR_WEBASSEMBLY_RESPONSE", "signature": "`ERR_WEBASSEMBLY_RESPONSE`", "apiSymbol": "ERR_WEBASSEMBLY_RESPONSE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_webassembly_response", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_webassembly_response", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:errors", + "tests": [] + } + } + }, + { + "id": "errors:b5224b626f86", + "chapter": "errors", + "label": "ERR_WORKER_HANDLE_NOT_TRANSFERABLE", + "signature": "`ERR_WORKER_HANDLE_NOT_TRANSFERABLE`", + "apiSymbol": "ERR_WORKER_HANDLE_NOT_TRANSFERABLE", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_handle_not_transferable", "nodeStability": null, "priority": "normal", "tiers": { @@ -20744,7 +21424,7 @@ "label": "ERR_WORKER_INIT_FAILED", "signature": "`ERR_WORKER_INIT_FAILED`", "apiSymbol": "ERR_WORKER_INIT_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_worker_init_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_init_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -20764,7 +21444,7 @@ "label": "ERR_WORKER_INVALID_EXEC_ARGV", "signature": "`ERR_WORKER_INVALID_EXEC_ARGV`", "apiSymbol": "ERR_WORKER_INVALID_EXEC_ARGV", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_worker_invalid_exec_argv", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_invalid_exec_argv", "nodeStability": null, "priority": "normal", "tiers": { @@ -20784,7 +21464,7 @@ "label": "ERR_WORKER_MESSAGING_ERRORED", "signature": "`ERR_WORKER_MESSAGING_ERRORED`", "apiSymbol": "ERR_WORKER_MESSAGING_ERRORED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_worker_messaging_errored", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_messaging_errored", "nodeStability": { "index": "1.1", "level": 1, @@ -20809,7 +21489,7 @@ "label": "ERR_WORKER_MESSAGING_FAILED", "signature": "`ERR_WORKER_MESSAGING_FAILED`", "apiSymbol": "ERR_WORKER_MESSAGING_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_worker_messaging_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_messaging_failed", "nodeStability": { "index": "1.1", "level": 1, @@ -20834,7 +21514,7 @@ "label": "ERR_WORKER_MESSAGING_SAME_THREAD", "signature": "`ERR_WORKER_MESSAGING_SAME_THREAD`", "apiSymbol": "ERR_WORKER_MESSAGING_SAME_THREAD", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_worker_messaging_same_thread", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_messaging_same_thread", "nodeStability": { "index": "1.1", "level": 1, @@ -20859,7 +21539,7 @@ "label": "ERR_WORKER_MESSAGING_TIMEOUT", "signature": "`ERR_WORKER_MESSAGING_TIMEOUT`", "apiSymbol": "ERR_WORKER_MESSAGING_TIMEOUT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_worker_messaging_timeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_messaging_timeout", "nodeStability": { "index": "1.1", "level": 1, @@ -20884,7 +21564,7 @@ "label": "ERR_WORKER_NOT_RUNNING", "signature": "`ERR_WORKER_NOT_RUNNING`", "apiSymbol": "ERR_WORKER_NOT_RUNNING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_worker_not_running", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_not_running", "nodeStability": null, "priority": "normal", "tiers": { @@ -20904,7 +21584,7 @@ "label": "ERR_WORKER_OUT_OF_MEMORY", "signature": "`ERR_WORKER_OUT_OF_MEMORY`", "apiSymbol": "ERR_WORKER_OUT_OF_MEMORY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_worker_out_of_memory", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_out_of_memory", "nodeStability": null, "priority": "normal", "tiers": { @@ -20924,7 +21604,7 @@ "label": "ERR_WORKER_PATH", "signature": "`ERR_WORKER_PATH`", "apiSymbol": "ERR_WORKER_PATH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_worker_path", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_path", "nodeStability": null, "priority": "normal", "tiers": { @@ -20944,7 +21624,7 @@ "label": "ERR_WORKER_UNSERIALIZABLE_ERROR", "signature": "`ERR_WORKER_UNSERIALIZABLE_ERROR`", "apiSymbol": "ERR_WORKER_UNSERIALIZABLE_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_worker_unserializable_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_unserializable_error", "nodeStability": null, "priority": "normal", "tiers": { @@ -20964,7 +21644,7 @@ "label": "ERR_WORKER_UNSUPPORTED_OPERATION", "signature": "`ERR_WORKER_UNSUPPORTED_OPERATION`", "apiSymbol": "ERR_WORKER_UNSUPPORTED_OPERATION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_worker_unsupported_operation", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_unsupported_operation", "nodeStability": null, "priority": "normal", "tiers": { @@ -20984,7 +21664,7 @@ "label": "ERR_ZLIB_INITIALIZATION_FAILED", "signature": "`ERR_ZLIB_INITIALIZATION_FAILED`", "apiSymbol": "ERR_ZLIB_INITIALIZATION_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_zlib_initialization_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_zlib_initialization_failed", "nodeStability": null, "priority": "normal", "tiers": { @@ -21004,7 +21684,7 @@ "label": "ERR_ZSTD_INVALID_PARAM", "signature": "`ERR_ZSTD_INVALID_PARAM`", "apiSymbol": "ERR_ZSTD_INVALID_PARAM", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_zstd_invalid_param", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_zstd_invalid_param", "nodeStability": null, "priority": "normal", "tiers": { @@ -21024,7 +21704,7 @@ "label": "HPE_CHUNK_EXTENSIONS_OVERFLOW", "signature": "`HPE_CHUNK_EXTENSIONS_OVERFLOW`", "apiSymbol": "HPE_CHUNK_EXTENSIONS_OVERFLOW", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#hpe_chunk_extensions_overflow", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#hpe_chunk_extensions_overflow", "nodeStability": null, "priority": "normal", "tiers": { @@ -21044,7 +21724,7 @@ "label": "HPE_HEADER_OVERFLOW", "signature": "`HPE_HEADER_OVERFLOW`", "apiSymbol": "HPE_HEADER_OVERFLOW", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#hpe_header_overflow", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#hpe_header_overflow", "nodeStability": null, "priority": "normal", "tiers": { @@ -21064,7 +21744,7 @@ "label": "HPE_UNEXPECTED_CONTENT_LENGTH", "signature": "`HPE_UNEXPECTED_CONTENT_LENGTH`", "apiSymbol": "HPE_UNEXPECTED_CONTENT_LENGTH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#hpe_unexpected_content_length", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#hpe_unexpected_content_length", "nodeStability": null, "priority": "normal", "tiers": { @@ -21084,7 +21764,7 @@ "label": "MODULE_NOT_FOUND", "signature": "`MODULE_NOT_FOUND`", "apiSymbol": "MODULE_NOT_FOUND", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#module_not_found", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#module_not_found", "nodeStability": null, "priority": "normal", "tiers": { @@ -21104,7 +21784,7 @@ "label": "ERR_CANNOT_TRANSFER_OBJECT", "signature": "`ERR_CANNOT_TRANSFER_OBJECT`", "apiSymbol": "ERR_CANNOT_TRANSFER_OBJECT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_cannot_transfer_object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_cannot_transfer_object", "nodeStability": { "index": "0", "level": 0, @@ -21129,7 +21809,7 @@ "label": "ERR_CPU_USAGE", "signature": "`ERR_CPU_USAGE`", "apiSymbol": "ERR_CPU_USAGE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_cpu_usage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_cpu_usage", "nodeStability": { "index": "0", "level": 0, @@ -21154,7 +21834,7 @@ "label": "ERR_CRYPTO_HASH_DIGEST_NO_UTF16", "signature": "`ERR_CRYPTO_HASH_DIGEST_NO_UTF16`", "apiSymbol": "ERR_CRYPTO_HASH_DIGEST_NO_UTF16", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_hash_digest_no_utf16", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_hash_digest_no_utf16", "nodeStability": { "index": "0", "level": 0, @@ -21179,7 +21859,7 @@ "label": "ERR_CRYPTO_SCRYPT_INVALID_PARAMETER", "signature": "`ERR_CRYPTO_SCRYPT_INVALID_PARAMETER`", "apiSymbol": "ERR_CRYPTO_SCRYPT_INVALID_PARAMETER", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_crypto_scrypt_invalid_parameter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_crypto_scrypt_invalid_parameter", "nodeStability": { "index": "0", "level": 0, @@ -21204,7 +21884,7 @@ "label": "ERR_FS_INVALID_SYMLINK_TYPE", "signature": "`ERR_FS_INVALID_SYMLINK_TYPE`", "apiSymbol": "ERR_FS_INVALID_SYMLINK_TYPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_fs_invalid_symlink_type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_fs_invalid_symlink_type", "nodeStability": { "index": "0", "level": 0, @@ -21229,7 +21909,7 @@ "label": "ERR_HTTP2_FRAME_ERROR", "signature": "`ERR_HTTP2_FRAME_ERROR`", "apiSymbol": "ERR_HTTP2_FRAME_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_frame_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_frame_error", "nodeStability": { "index": "0", "level": 0, @@ -21254,7 +21934,7 @@ "label": "ERR_HTTP2_HEADERS_OBJECT", "signature": "`ERR_HTTP2_HEADERS_OBJECT`", "apiSymbol": "ERR_HTTP2_HEADERS_OBJECT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_headers_object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_headers_object", "nodeStability": { "index": "0", "level": 0, @@ -21279,7 +21959,7 @@ "label": "ERR_HTTP2_HEADER_REQUIRED", "signature": "`ERR_HTTP2_HEADER_REQUIRED`", "apiSymbol": "ERR_HTTP2_HEADER_REQUIRED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_header_required", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_header_required", "nodeStability": { "index": "0", "level": 0, @@ -21304,7 +21984,7 @@ "label": "ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND", "signature": "`ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND`", "apiSymbol": "ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_info_headers_after_respond", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_info_headers_after_respond", "nodeStability": { "index": "0", "level": 0, @@ -21329,7 +22009,7 @@ "label": "ERR_HTTP2_STREAM_CLOSED", "signature": "`ERR_HTTP2_STREAM_CLOSED`", "apiSymbol": "ERR_HTTP2_STREAM_CLOSED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http2_stream_closed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http2_stream_closed", "nodeStability": { "index": "0", "level": 0, @@ -21354,7 +22034,7 @@ "label": "ERR_HTTP_INVALID_CHAR", "signature": "`ERR_HTTP_INVALID_CHAR`", "apiSymbol": "ERR_HTTP_INVALID_CHAR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_http_invalid_char", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_http_invalid_char", "nodeStability": { "index": "0", "level": 0, @@ -21379,7 +22059,7 @@ "label": "ERR_IMPORT_ASSERTION_TYPE_FAILED", "signature": "`ERR_IMPORT_ASSERTION_TYPE_FAILED`", "apiSymbol": "ERR_IMPORT_ASSERTION_TYPE_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_import_assertion_type_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_import_assertion_type_failed", "nodeStability": { "index": "0", "level": 0, @@ -21404,7 +22084,7 @@ "label": "ERR_IMPORT_ASSERTION_TYPE_MISSING", "signature": "`ERR_IMPORT_ASSERTION_TYPE_MISSING`", "apiSymbol": "ERR_IMPORT_ASSERTION_TYPE_MISSING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_import_assertion_type_missing", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_import_assertion_type_missing", "nodeStability": { "index": "0", "level": 0, @@ -21429,7 +22109,7 @@ "label": "ERR_IMPORT_ASSERTION_TYPE_UNSUPPORTED", "signature": "`ERR_IMPORT_ASSERTION_TYPE_UNSUPPORTED`", "apiSymbol": "ERR_IMPORT_ASSERTION_TYPE_UNSUPPORTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_import_assertion_type_unsupported", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_import_assertion_type_unsupported", "nodeStability": { "index": "0", "level": 0, @@ -21454,7 +22134,7 @@ "label": "ERR_INDEX_OUT_OF_RANGE", "signature": "`ERR_INDEX_OUT_OF_RANGE`", "apiSymbol": "ERR_INDEX_OUT_OF_RANGE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_index_out_of_range", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_index_out_of_range", "nodeStability": { "index": "0", "level": 0, @@ -21479,7 +22159,7 @@ "label": "ERR_INVALID_OPT_VALUE", "signature": "`ERR_INVALID_OPT_VALUE`", "apiSymbol": "ERR_INVALID_OPT_VALUE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_opt_value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_opt_value", "nodeStability": { "index": "0", "level": 0, @@ -21504,7 +22184,7 @@ "label": "ERR_INVALID_OPT_VALUE_ENCODING", "signature": "`ERR_INVALID_OPT_VALUE_ENCODING`", "apiSymbol": "ERR_INVALID_OPT_VALUE_ENCODING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_opt_value_encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_opt_value_encoding", "nodeStability": { "index": "0", "level": 0, @@ -21529,7 +22209,7 @@ "label": "ERR_INVALID_PERFORMANCE_MARK", "signature": "`ERR_INVALID_PERFORMANCE_MARK`", "apiSymbol": "ERR_INVALID_PERFORMANCE_MARK", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_performance_mark", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_performance_mark", "nodeStability": { "index": "0", "level": 0, @@ -21554,7 +22234,7 @@ "label": "ERR_INVALID_TRANSFER_OBJECT", "signature": "`ERR_INVALID_TRANSFER_OBJECT`", "apiSymbol": "ERR_INVALID_TRANSFER_OBJECT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_invalid_transfer_object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_invalid_transfer_object", "nodeStability": { "index": "0", "level": 0, @@ -21579,7 +22259,7 @@ "label": "ERR_MANIFEST_ASSERT_INTEGRITY", "signature": "`ERR_MANIFEST_ASSERT_INTEGRITY`", "apiSymbol": "ERR_MANIFEST_ASSERT_INTEGRITY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_manifest_assert_integrity", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_manifest_assert_integrity", "nodeStability": { "index": "0", "level": 0, @@ -21604,7 +22284,7 @@ "label": "ERR_MANIFEST_DEPENDENCY_MISSING", "signature": "`ERR_MANIFEST_DEPENDENCY_MISSING`", "apiSymbol": "ERR_MANIFEST_DEPENDENCY_MISSING", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_manifest_dependency_missing", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_manifest_dependency_missing", "nodeStability": { "index": "0", "level": 0, @@ -21629,7 +22309,7 @@ "label": "ERR_MANIFEST_INTEGRITY_MISMATCH", "signature": "`ERR_MANIFEST_INTEGRITY_MISMATCH`", "apiSymbol": "ERR_MANIFEST_INTEGRITY_MISMATCH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_manifest_integrity_mismatch", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_manifest_integrity_mismatch", "nodeStability": { "index": "0", "level": 0, @@ -21654,7 +22334,7 @@ "label": "ERR_MANIFEST_INVALID_RESOURCE_FIELD", "signature": "`ERR_MANIFEST_INVALID_RESOURCE_FIELD`", "apiSymbol": "ERR_MANIFEST_INVALID_RESOURCE_FIELD", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_manifest_invalid_resource_field", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_manifest_invalid_resource_field", "nodeStability": { "index": "0", "level": 0, @@ -21679,7 +22359,7 @@ "label": "ERR_MANIFEST_INVALID_SPECIFIER", "signature": "`ERR_MANIFEST_INVALID_SPECIFIER`", "apiSymbol": "ERR_MANIFEST_INVALID_SPECIFIER", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_manifest_invalid_specifier", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_manifest_invalid_specifier", "nodeStability": { "index": "0", "level": 0, @@ -21704,7 +22384,7 @@ "label": "ERR_MANIFEST_PARSE_POLICY", "signature": "`ERR_MANIFEST_PARSE_POLICY`", "apiSymbol": "ERR_MANIFEST_PARSE_POLICY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_manifest_parse_policy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_manifest_parse_policy", "nodeStability": { "index": "0", "level": 0, @@ -21729,7 +22409,7 @@ "label": "ERR_MANIFEST_TDZ", "signature": "`ERR_MANIFEST_TDZ`", "apiSymbol": "ERR_MANIFEST_TDZ", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_manifest_tdz", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_manifest_tdz", "nodeStability": { "index": "0", "level": 0, @@ -21754,7 +22434,7 @@ "label": "ERR_MANIFEST_UNKNOWN_ONERROR", "signature": "`ERR_MANIFEST_UNKNOWN_ONERROR`", "apiSymbol": "ERR_MANIFEST_UNKNOWN_ONERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_manifest_unknown_onerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_manifest_unknown_onerror", "nodeStability": { "index": "0", "level": 0, @@ -21779,7 +22459,7 @@ "label": "ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST", "signature": "`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`", "apiSymbol": "ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_missing_message_port_in_transfer_list", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_missing_message_port_in_transfer_list", "nodeStability": { "index": "0", "level": 0, @@ -21804,7 +22484,7 @@ "label": "ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST", "signature": "`ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST`", "apiSymbol": "ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_missing_transferable_in_transfer_list", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_missing_transferable_in_transfer_list", "nodeStability": { "index": "0", "level": 0, @@ -21829,7 +22509,7 @@ "label": "ERR_NAPI_CONS_PROTOTYPE_OBJECT", "signature": "`ERR_NAPI_CONS_PROTOTYPE_OBJECT`", "apiSymbol": "ERR_NAPI_CONS_PROTOTYPE_OBJECT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_napi_cons_prototype_object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_napi_cons_prototype_object", "nodeStability": { "index": "0", "level": 0, @@ -21854,7 +22534,7 @@ "label": "ERR_NAPI_TSFN_START_IDLE_LOOP", "signature": "`ERR_NAPI_TSFN_START_IDLE_LOOP`", "apiSymbol": "ERR_NAPI_TSFN_START_IDLE_LOOP", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_napi_tsfn_start_idle_loop", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_napi_tsfn_start_idle_loop", "nodeStability": { "index": "0", "level": 0, @@ -21879,7 +22559,7 @@ "label": "ERR_NAPI_TSFN_STOP_IDLE_LOOP", "signature": "`ERR_NAPI_TSFN_STOP_IDLE_LOOP`", "apiSymbol": "ERR_NAPI_TSFN_STOP_IDLE_LOOP", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_napi_tsfn_stop_idle_loop", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_napi_tsfn_stop_idle_loop", "nodeStability": { "index": "0", "level": 0, @@ -21904,7 +22584,7 @@ "label": "ERR_NO_LONGER_SUPPORTED", "signature": "`ERR_NO_LONGER_SUPPORTED`", "apiSymbol": "ERR_NO_LONGER_SUPPORTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_no_longer_supported", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_no_longer_supported", "nodeStability": { "index": "0", "level": 0, @@ -21929,7 +22609,7 @@ "label": "ERR_OUTOFMEMORY", "signature": "`ERR_OUTOFMEMORY`", "apiSymbol": "ERR_OUTOFMEMORY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_outofmemory", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_outofmemory", "nodeStability": { "index": "0", "level": 0, @@ -21954,7 +22634,7 @@ "label": "ERR_PARSE_HISTORY_DATA", "signature": "`ERR_PARSE_HISTORY_DATA`", "apiSymbol": "ERR_PARSE_HISTORY_DATA", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_parse_history_data", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_parse_history_data", "nodeStability": { "index": "0", "level": 0, @@ -21979,7 +22659,7 @@ "label": "ERR_SOCKET_CANNOT_SEND", "signature": "`ERR_SOCKET_CANNOT_SEND`", "apiSymbol": "ERR_SOCKET_CANNOT_SEND", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_socket_cannot_send", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_socket_cannot_send", "nodeStability": { "index": "0", "level": 0, @@ -22004,7 +22684,7 @@ "label": "ERR_STDERR_CLOSE", "signature": "`ERR_STDERR_CLOSE`", "apiSymbol": "ERR_STDERR_CLOSE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stderr_close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stderr_close", "nodeStability": { "index": "0", "level": 0, @@ -22029,7 +22709,7 @@ "label": "ERR_STDOUT_CLOSE", "signature": "`ERR_STDOUT_CLOSE`", "apiSymbol": "ERR_STDOUT_CLOSE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stdout_close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stdout_close", "nodeStability": { "index": "0", "level": 0, @@ -22054,7 +22734,7 @@ "label": "ERR_STREAM_READ_NOT_IMPLEMENTED", "signature": "`ERR_STREAM_READ_NOT_IMPLEMENTED`", "apiSymbol": "ERR_STREAM_READ_NOT_IMPLEMENTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_stream_read_not_implemented", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_stream_read_not_implemented", "nodeStability": { "index": "0", "level": 0, @@ -22079,7 +22759,7 @@ "label": "ERR_TAP_LEXER_ERROR", "signature": "`ERR_TAP_LEXER_ERROR`", "apiSymbol": "ERR_TAP_LEXER_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tap_lexer_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tap_lexer_error", "nodeStability": { "index": "0", "level": 0, @@ -22104,7 +22784,7 @@ "label": "ERR_TAP_PARSER_ERROR", "signature": "`ERR_TAP_PARSER_ERROR`", "apiSymbol": "ERR_TAP_PARSER_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tap_parser_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tap_parser_error", "nodeStability": { "index": "0", "level": 0, @@ -22129,7 +22809,7 @@ "label": "ERR_TAP_VALIDATION_ERROR", "signature": "`ERR_TAP_VALIDATION_ERROR`", "apiSymbol": "ERR_TAP_VALIDATION_ERROR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tap_validation_error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tap_validation_error", "nodeStability": { "index": "0", "level": 0, @@ -22154,7 +22834,7 @@ "label": "ERR_TLS_RENEGOTIATION_FAILED", "signature": "`ERR_TLS_RENEGOTIATION_FAILED`", "apiSymbol": "ERR_TLS_RENEGOTIATION_FAILED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_tls_renegotiation_failed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_tls_renegotiation_failed", "nodeStability": { "index": "0", "level": 0, @@ -22179,7 +22859,7 @@ "label": "ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER", "signature": "`ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER`", "apiSymbol": "ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_transferring_externalized_sharedarraybuffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_transferring_externalized_sharedarraybuffer", "nodeStability": { "index": "0", "level": 0, @@ -22204,7 +22884,7 @@ "label": "ERR_UNKNOWN_STDIN_TYPE", "signature": "`ERR_UNKNOWN_STDIN_TYPE`", "apiSymbol": "ERR_UNKNOWN_STDIN_TYPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unknown_stdin_type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unknown_stdin_type", "nodeStability": { "index": "0", "level": 0, @@ -22229,7 +22909,7 @@ "label": "ERR_UNKNOWN_STREAM_TYPE", "signature": "`ERR_UNKNOWN_STREAM_TYPE`", "apiSymbol": "ERR_UNKNOWN_STREAM_TYPE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_unknown_stream_type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_unknown_stream_type", "nodeStability": { "index": "0", "level": 0, @@ -22254,7 +22934,7 @@ "label": "ERR_V8BREAKITERATOR", "signature": "`ERR_V8BREAKITERATOR`", "apiSymbol": "ERR_V8BREAKITERATOR", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_v8breakiterator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_v8breakiterator", "nodeStability": { "index": "0", "level": 0, @@ -22279,7 +22959,7 @@ "label": "ERR_VALUE_OUT_OF_RANGE", "signature": "`ERR_VALUE_OUT_OF_RANGE`", "apiSymbol": "ERR_VALUE_OUT_OF_RANGE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_value_out_of_range", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_value_out_of_range", "nodeStability": { "index": "0", "level": 0, @@ -22304,7 +22984,7 @@ "label": "ERR_VM_MODULE_LINKING_ERRORED", "signature": "`ERR_VM_MODULE_LINKING_ERRORED`", "apiSymbol": "ERR_VM_MODULE_LINKING_ERRORED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_vm_module_linking_errored", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_vm_module_linking_errored", "nodeStability": { "index": "0", "level": 0, @@ -22329,7 +23009,7 @@ "label": "ERR_VM_MODULE_NOT_LINKED", "signature": "`ERR_VM_MODULE_NOT_LINKED`", "apiSymbol": "ERR_VM_MODULE_NOT_LINKED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_vm_module_not_linked", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_vm_module_not_linked", "nodeStability": { "index": "0", "level": 0, @@ -22354,7 +23034,7 @@ "label": "ERR_WORKER_UNSUPPORTED_EXTENSION", "signature": "`ERR_WORKER_UNSUPPORTED_EXTENSION`", "apiSymbol": "ERR_WORKER_UNSUPPORTED_EXTENSION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_worker_unsupported_extension", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_worker_unsupported_extension", "nodeStability": { "index": "0", "level": 0, @@ -22379,7 +23059,7 @@ "label": "ERR_ZLIB_BINDING_CLOSED", "signature": "`ERR_ZLIB_BINDING_CLOSED`", "apiSymbol": "ERR_ZLIB_BINDING_CLOSED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#err_zlib_binding_closed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#err_zlib_binding_closed", "nodeStability": { "index": "0", "level": 0, @@ -22404,7 +23084,7 @@ "label": "CERT_NOT_YET_VALID", "signature": "`CERT_NOT_YET_VALID`", "apiSymbol": "CERT_NOT_YET_VALID", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#cert_not_yet_valid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#cert_not_yet_valid", "nodeStability": null, "priority": "normal", "tiers": { @@ -22424,7 +23104,7 @@ "label": "CERT_HAS_EXPIRED", "signature": "`CERT_HAS_EXPIRED`", "apiSymbol": "CERT_HAS_EXPIRED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#cert_has_expired", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#cert_has_expired", "nodeStability": null, "priority": "normal", "tiers": { @@ -22444,7 +23124,7 @@ "label": "CRL_NOT_YET_VALID", "signature": "`CRL_NOT_YET_VALID`", "apiSymbol": "CRL_NOT_YET_VALID", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#crl_not_yet_valid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#crl_not_yet_valid", "nodeStability": null, "priority": "normal", "tiers": { @@ -22464,7 +23144,7 @@ "label": "CRL_HAS_EXPIRED", "signature": "`CRL_HAS_EXPIRED`", "apiSymbol": "CRL_HAS_EXPIRED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#crl_has_expired", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#crl_has_expired", "nodeStability": null, "priority": "normal", "tiers": { @@ -22484,7 +23164,7 @@ "label": "CERT_REVOKED", "signature": "`CERT_REVOKED`", "apiSymbol": "CERT_REVOKED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#cert_revoked", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#cert_revoked", "nodeStability": null, "priority": "normal", "tiers": { @@ -22504,7 +23184,7 @@ "label": "UNABLE_TO_GET_ISSUER_CERT", "signature": "`UNABLE_TO_GET_ISSUER_CERT`", "apiSymbol": "UNABLE_TO_GET_ISSUER_CERT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#unable_to_get_issuer_cert", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#unable_to_get_issuer_cert", "nodeStability": null, "priority": "normal", "tiers": { @@ -22524,7 +23204,7 @@ "label": "UNABLE_TO_GET_ISSUER_CERT_LOCALLY", "signature": "`UNABLE_TO_GET_ISSUER_CERT_LOCALLY`", "apiSymbol": "UNABLE_TO_GET_ISSUER_CERT_LOCALLY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#unable_to_get_issuer_cert_locally", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#unable_to_get_issuer_cert_locally", "nodeStability": null, "priority": "normal", "tiers": { @@ -22544,7 +23224,7 @@ "label": "DEPTH_ZERO_SELF_SIGNED_CERT", "signature": "`DEPTH_ZERO_SELF_SIGNED_CERT`", "apiSymbol": "DEPTH_ZERO_SELF_SIGNED_CERT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#depth_zero_self_signed_cert", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#depth_zero_self_signed_cert", "nodeStability": null, "priority": "normal", "tiers": { @@ -22564,7 +23244,7 @@ "label": "SELF_SIGNED_CERT_IN_CHAIN", "signature": "`SELF_SIGNED_CERT_IN_CHAIN`", "apiSymbol": "SELF_SIGNED_CERT_IN_CHAIN", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#self_signed_cert_in_chain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#self_signed_cert_in_chain", "nodeStability": null, "priority": "normal", "tiers": { @@ -22584,7 +23264,7 @@ "label": "CERT_CHAIN_TOO_LONG", "signature": "`CERT_CHAIN_TOO_LONG`", "apiSymbol": "CERT_CHAIN_TOO_LONG", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#cert_chain_too_long", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#cert_chain_too_long", "nodeStability": null, "priority": "normal", "tiers": { @@ -22604,7 +23284,7 @@ "label": "UNABLE_TO_GET_CRL", "signature": "`UNABLE_TO_GET_CRL`", "apiSymbol": "UNABLE_TO_GET_CRL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#unable_to_get_crl", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#unable_to_get_crl", "nodeStability": null, "priority": "normal", "tiers": { @@ -22624,7 +23304,7 @@ "label": "UNABLE_TO_VERIFY_LEAF_SIGNATURE", "signature": "`UNABLE_TO_VERIFY_LEAF_SIGNATURE`", "apiSymbol": "UNABLE_TO_VERIFY_LEAF_SIGNATURE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#unable_to_verify_leaf_signature", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#unable_to_verify_leaf_signature", "nodeStability": null, "priority": "normal", "tiers": { @@ -22644,7 +23324,7 @@ "label": "CERT_UNTRUSTED", "signature": "`CERT_UNTRUSTED`", "apiSymbol": "CERT_UNTRUSTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#cert_untrusted", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#cert_untrusted", "nodeStability": null, "priority": "normal", "tiers": { @@ -22664,7 +23344,7 @@ "label": "INVALID_CA", "signature": "`INVALID_CA`", "apiSymbol": "INVALID_CA", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#invalid_ca", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#invalid_ca", "nodeStability": null, "priority": "normal", "tiers": { @@ -22684,7 +23364,7 @@ "label": "PATH_LENGTH_EXCEEDED", "signature": "`PATH_LENGTH_EXCEEDED`", "apiSymbol": "PATH_LENGTH_EXCEEDED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#path_length_exceeded", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#path_length_exceeded", "nodeStability": null, "priority": "normal", "tiers": { @@ -22704,7 +23384,7 @@ "label": "HOSTNAME_MISMATCH", "signature": "`HOSTNAME_MISMATCH`", "apiSymbol": "HOSTNAME_MISMATCH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#hostname_mismatch", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#hostname_mismatch", "nodeStability": null, "priority": "normal", "tiers": { @@ -22724,7 +23404,7 @@ "label": "INVALID_PURPOSE", "signature": "`INVALID_PURPOSE`", "apiSymbol": "INVALID_PURPOSE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#invalid_purpose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#invalid_purpose", "nodeStability": null, "priority": "normal", "tiers": { @@ -22744,7 +23424,7 @@ "label": "CERT_REJECTED", "signature": "`CERT_REJECTED`", "apiSymbol": "CERT_REJECTED", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#cert_rejected", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#cert_rejected", "nodeStability": null, "priority": "normal", "tiers": { @@ -22764,7 +23444,7 @@ "label": "CERT_SIGNATURE_FAILURE", "signature": "`CERT_SIGNATURE_FAILURE`", "apiSymbol": "CERT_SIGNATURE_FAILURE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#cert_signature_failure", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#cert_signature_failure", "nodeStability": null, "priority": "normal", "tiers": { @@ -22784,7 +23464,7 @@ "label": "CRL_SIGNATURE_FAILURE", "signature": "`CRL_SIGNATURE_FAILURE`", "apiSymbol": "CRL_SIGNATURE_FAILURE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#crl_signature_failure", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#crl_signature_failure", "nodeStability": null, "priority": "normal", "tiers": { @@ -22804,7 +23484,7 @@ "label": "ERROR_IN_CERT_NOT_BEFORE_FIELD", "signature": "`ERROR_IN_CERT_NOT_BEFORE_FIELD`", "apiSymbol": "ERROR_IN_CERT_NOT_BEFORE_FIELD", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#error_in_cert_not_before_field", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#error_in_cert_not_before_field", "nodeStability": null, "priority": "normal", "tiers": { @@ -22824,7 +23504,7 @@ "label": "ERROR_IN_CERT_NOT_AFTER_FIELD", "signature": "`ERROR_IN_CERT_NOT_AFTER_FIELD`", "apiSymbol": "ERROR_IN_CERT_NOT_AFTER_FIELD", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#error_in_cert_not_after_field", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#error_in_cert_not_after_field", "nodeStability": null, "priority": "normal", "tiers": { @@ -22844,7 +23524,7 @@ "label": "ERROR_IN_CRL_LAST_UPDATE_FIELD", "signature": "`ERROR_IN_CRL_LAST_UPDATE_FIELD`", "apiSymbol": "ERROR_IN_CRL_LAST_UPDATE_FIELD", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#error_in_crl_last_update_field", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#error_in_crl_last_update_field", "nodeStability": null, "priority": "normal", "tiers": { @@ -22864,7 +23544,7 @@ "label": "ERROR_IN_CRL_NEXT_UPDATE_FIELD", "signature": "`ERROR_IN_CRL_NEXT_UPDATE_FIELD`", "apiSymbol": "ERROR_IN_CRL_NEXT_UPDATE_FIELD", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#error_in_crl_next_update_field", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#error_in_crl_next_update_field", "nodeStability": null, "priority": "normal", "tiers": { @@ -22884,7 +23564,7 @@ "label": "UNABLE_TO_DECRYPT_CERT_SIGNATURE", "signature": "`UNABLE_TO_DECRYPT_CERT_SIGNATURE`", "apiSymbol": "UNABLE_TO_DECRYPT_CERT_SIGNATURE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#unable_to_decrypt_cert_signature", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#unable_to_decrypt_cert_signature", "nodeStability": null, "priority": "normal", "tiers": { @@ -22904,7 +23584,7 @@ "label": "UNABLE_TO_DECRYPT_CRL_SIGNATURE", "signature": "`UNABLE_TO_DECRYPT_CRL_SIGNATURE`", "apiSymbol": "UNABLE_TO_DECRYPT_CRL_SIGNATURE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#unable_to_decrypt_crl_signature", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#unable_to_decrypt_crl_signature", "nodeStability": null, "priority": "normal", "tiers": { @@ -22924,7 +23604,7 @@ "label": "UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY", "signature": "`UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY`", "apiSymbol": "UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#unable_to_decode_issuer_public_key", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#unable_to_decode_issuer_public_key", "nodeStability": null, "priority": "normal", "tiers": { @@ -22944,7 +23624,7 @@ "label": "OUT_OF_MEM", "signature": "`OUT_OF_MEM`", "apiSymbol": "OUT_OF_MEM", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/errors.html#out_of_mem", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/errors.html#out_of_mem", "nodeStability": null, "priority": "normal", "tiers": { @@ -22964,7 +23644,7 @@ "label": "Passing arguments and this to listeners", "signature": "Passing arguments and `this` to listeners", "apiSymbol": "this", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#passing-arguments-and-this-to-listeners", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#passing-arguments-and-this-to-listeners", "nodeStability": { "index": "2", "level": 2, @@ -22989,7 +23669,7 @@ "label": "EventTarget", "signature": "`EventTarget` and `Event` API", "apiSymbol": "EventTarget", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventtarget-and-event-api", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventtarget-and-event-api", "nodeStability": { "index": "2", "level": 2, @@ -23020,7 +23700,7 @@ "label": "Node.js EventTarget vs. DOM EventTarget", "signature": "Node.js `EventTarget` vs. DOM `EventTarget`", "apiSymbol": "EventTarget", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodejs-eventtarget-vs-dom-eventtarget", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodejs-eventtarget-vs-dom-eventtarget", "nodeStability": { "index": "2", "level": 2, @@ -23051,7 +23731,7 @@ "label": "NodeEventTarget", "signature": "`NodeEventTarget` vs. `EventEmitter`", "apiSymbol": "NodeEventTarget", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodeeventtarget-vs-eventemitter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodeeventtarget-vs-eventemitter", "nodeStability": { "index": "2", "level": 2, @@ -23076,7 +23756,7 @@ "label": "EventTarget", "signature": "`EventTarget` error handling", "apiSymbol": "EventTarget", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventtarget-error-handling", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventtarget-error-handling", "nodeStability": { "index": "2", "level": 2, @@ -23107,7 +23787,7 @@ "label": "Event", "signature": "Class: `Event`", "apiSymbol": "Event", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#class-event", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#class-event", "nodeStability": { "index": "2", "level": 2, @@ -23135,7 +23815,7 @@ "label": "EventTarget", "signature": "Class: `EventTarget`", "apiSymbol": "EventTarget", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#class-eventtarget", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#class-eventtarget", "nodeStability": { "index": "2", "level": 2, @@ -23166,7 +23846,7 @@ "label": "eventTarget.addEventListener(type, listener[, options])", "signature": "`eventTarget.addEventListener(type, listener[, options])`", "apiSymbol": "eventTarget.addEventListener", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventtargetaddeventlistenertype-listener-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventtargetaddeventlistenertype-listener-options", "nodeStability": { "index": "2", "level": 2, @@ -23197,7 +23877,7 @@ "label": "eventTarget.dispatchEvent(event)", "signature": "`eventTarget.dispatchEvent(event)`", "apiSymbol": "eventTarget.dispatchEvent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventtargetdispatcheventevent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventtargetdispatcheventevent", "nodeStability": { "index": "2", "level": 2, @@ -23228,7 +23908,7 @@ "label": "eventTarget.removeEventListener(type, listener[, options])", "signature": "`eventTarget.removeEventListener(type, listener[, options])`", "apiSymbol": "eventTarget.removeEventListener", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventtargetremoveeventlistenertype-listener-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventtargetremoveeventlistenertype-listener-options", "nodeStability": { "index": "2", "level": 2, @@ -23259,7 +23939,7 @@ "label": "CustomEvent", "signature": "Class: `CustomEvent`", "apiSymbol": "CustomEvent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#class-customevent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#class-customevent", "nodeStability": { "index": "2", "level": 2, @@ -23287,7 +23967,7 @@ "label": "detail", "signature": "`detail` Type: {any} Returns custom data passed when initializing.", "apiSymbol": "detail", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#class-customevent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#class-customevent", "nodeStability": { "index": "2", "level": 2, @@ -23315,7 +23995,7 @@ "label": "NodeEventTarget", "signature": "Class: `NodeEventTarget`", "apiSymbol": "NodeEventTarget", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#class-nodeeventtarget", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#class-nodeeventtarget", "nodeStability": { "index": "2", "level": 2, @@ -23340,7 +24020,7 @@ "label": "nodeEventTarget.addListener(type, listener)", "signature": "`nodeEventTarget.addListener(type, listener)`", "apiSymbol": "nodeEventTarget.addListener", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodeeventtargetaddlistenertype-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodeeventtargetaddlistenertype-listener", "nodeStability": { "index": "2", "level": 2, @@ -23365,7 +24045,7 @@ "label": "nodeEventTarget.emit(type, arg)", "signature": "`nodeEventTarget.emit(type, arg)`", "apiSymbol": "nodeEventTarget.emit", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodeeventtargetemittype-arg", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodeeventtargetemittype-arg", "nodeStability": { "index": "2", "level": 2, @@ -23390,7 +24070,7 @@ "label": "nodeEventTarget.eventNames()", "signature": "`nodeEventTarget.eventNames()`", "apiSymbol": "nodeEventTarget.eventNames", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodeeventtargeteventnames", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodeeventtargeteventnames", "nodeStability": { "index": "2", "level": 2, @@ -23415,7 +24095,7 @@ "label": "nodeEventTarget.listenerCount(type)", "signature": "`nodeEventTarget.listenerCount(type)`", "apiSymbol": "nodeEventTarget.listenerCount", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodeeventtargetlistenercounttype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodeeventtargetlistenercounttype", "nodeStability": { "index": "2", "level": 2, @@ -23440,7 +24120,7 @@ "label": "nodeEventTarget.setMaxListeners(n)", "signature": "`nodeEventTarget.setMaxListeners(n)`", "apiSymbol": "nodeEventTarget.setMaxListeners", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodeeventtargetsetmaxlistenersn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodeeventtargetsetmaxlistenersn", "nodeStability": { "index": "2", "level": 2, @@ -23465,7 +24145,7 @@ "label": "nodeEventTarget.getMaxListeners()", "signature": "`nodeEventTarget.getMaxListeners()`", "apiSymbol": "nodeEventTarget.getMaxListeners", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodeeventtargetgetmaxlisteners", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodeeventtargetgetmaxlisteners", "nodeStability": { "index": "2", "level": 2, @@ -23490,7 +24170,7 @@ "label": "nodeEventTarget.off(type, listener[, options])", "signature": "`nodeEventTarget.off(type, listener[, options])`", "apiSymbol": "nodeEventTarget.off", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodeeventtargetofftype-listener-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodeeventtargetofftype-listener-options", "nodeStability": { "index": "2", "level": 2, @@ -23515,7 +24195,7 @@ "label": "nodeEventTarget.on(type, listener)", "signature": "`nodeEventTarget.on(type, listener)`", "apiSymbol": "nodeEventTarget.on", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodeeventtargetontype-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodeeventtargetontype-listener", "nodeStability": { "index": "2", "level": 2, @@ -23540,7 +24220,7 @@ "label": "nodeEventTarget.once(type, listener)", "signature": "`nodeEventTarget.once(type, listener)`", "apiSymbol": "nodeEventTarget.once", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodeeventtargetoncetype-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodeeventtargetoncetype-listener", "nodeStability": { "index": "2", "level": 2, @@ -23565,7 +24245,7 @@ "label": "nodeEventTarget.removeAllListeners([type])", "signature": "`nodeEventTarget.removeAllListeners([type])`", "apiSymbol": "nodeEventTarget.removeAllListeners", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodeeventtargetremovealllistenerstype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodeeventtargetremovealllistenerstype", "nodeStability": { "index": "2", "level": 2, @@ -23590,7 +24270,7 @@ "label": "nodeEventTarget.removeListener(type, listener[, options])", "signature": "`nodeEventTarget.removeListener(type, listener[, options])`", "apiSymbol": "nodeEventTarget.removeListener", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#nodeeventtargetremovelistenertype-listener-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#nodeeventtargetremovelistenertype-listener-options", "nodeStability": { "index": "2", "level": 2, @@ -23615,7 +24295,7 @@ "label": "EventEmitter", "signature": "Class: `EventEmitter`", "apiSymbol": "EventEmitter", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#class-eventemitter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#class-eventemitter", "nodeStability": { "index": "2", "level": 2, @@ -23643,7 +24323,7 @@ "label": "emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])", "signature": "`emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])`", "apiSymbol": "emitter", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emittersymbolfornodejsrejectionerr-eventname-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emittersymbolfornodejsrejectionerr-eventname-args", "nodeStability": { "index": "2", "level": 2, @@ -23668,7 +24348,7 @@ "label": "emitter.addListener(eventName, listener)", "signature": "`emitter.addListener(eventName, listener)`", "apiSymbol": "emitter.addListener", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emitteraddlistenereventname-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emitteraddlistenereventname-listener", "nodeStability": { "index": "2", "level": 2, @@ -23696,7 +24376,7 @@ "label": "emitter.emit(eventName[, ...args])", "signature": "`emitter.emit(eventName[, ...args])`", "apiSymbol": "emitter.emit", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emitteremiteventname-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emitteremiteventname-args", "nodeStability": { "index": "2", "level": 2, @@ -23724,7 +24404,7 @@ "label": "emitter.eventNames()", "signature": "`emitter.eventNames()`", "apiSymbol": "emitter.eventNames", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emittereventnames", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emittereventnames", "nodeStability": { "index": "2", "level": 2, @@ -23752,7 +24432,7 @@ "label": "emitter.getMaxListeners()", "signature": "`emitter.getMaxListeners()`", "apiSymbol": "emitter.getMaxListeners", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emittergetmaxlisteners", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emittergetmaxlisteners", "nodeStability": { "index": "2", "level": 2, @@ -23780,7 +24460,7 @@ "label": "emitter.listenerCount(eventName[, listener])", "signature": "`emitter.listenerCount(eventName[, listener])`", "apiSymbol": "emitter.listenerCount", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emitterlistenercounteventname-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emitterlistenercounteventname-listener", "nodeStability": { "index": "2", "level": 2, @@ -23808,7 +24488,7 @@ "label": "emitter.listeners(eventName)", "signature": "`emitter.listeners(eventName)`", "apiSymbol": "emitter.listeners", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emitterlistenerseventname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emitterlistenerseventname", "nodeStability": { "index": "2", "level": 2, @@ -23836,7 +24516,7 @@ "label": "emitter.off(eventName, listener)", "signature": "`emitter.off(eventName, listener)`", "apiSymbol": "emitter.off", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emitteroffeventname-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emitteroffeventname-listener", "nodeStability": { "index": "2", "level": 2, @@ -23864,7 +24544,7 @@ "label": "emitter.on(eventName, listener)", "signature": "`emitter.on(eventName, listener)`", "apiSymbol": "emitter.on", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emitteroneventname-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emitteroneventname-listener", "nodeStability": { "index": "2", "level": 2, @@ -23892,7 +24572,7 @@ "label": "emitter.once(eventName, listener)", "signature": "`emitter.once(eventName, listener)`", "apiSymbol": "emitter.once", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emitteronceeventname-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emitteronceeventname-listener", "nodeStability": { "index": "2", "level": 2, @@ -23920,7 +24600,7 @@ "label": "emitter.prependListener(eventName, listener)", "signature": "`emitter.prependListener(eventName, listener)`", "apiSymbol": "emitter.prependListener", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emitterprependlistenereventname-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emitterprependlistenereventname-listener", "nodeStability": { "index": "2", "level": 2, @@ -23948,7 +24628,7 @@ "label": "emitter.prependOnceListener(eventName, listener)", "signature": "`emitter.prependOnceListener(eventName, listener)`", "apiSymbol": "emitter.prependOnceListener", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emitterprependoncelistenereventname-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emitterprependoncelistenereventname-listener", "nodeStability": { "index": "2", "level": 2, @@ -23976,7 +24656,7 @@ "label": "emitter.removeAllListeners([eventName])", "signature": "`emitter.removeAllListeners([eventName])`", "apiSymbol": "emitter.removeAllListeners", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emitterremovealllistenerseventname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emitterremovealllistenerseventname", "nodeStability": { "index": "2", "level": 2, @@ -24004,7 +24684,7 @@ "label": "emitter.removeListener(eventName, listener)", "signature": "`emitter.removeListener(eventName, listener)`", "apiSymbol": "emitter.removeListener", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emitterremovelistenereventname-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emitterremovelistenereventname-listener", "nodeStability": { "index": "2", "level": 2, @@ -24032,7 +24712,7 @@ "label": "emitter.setMaxListeners(n)", "signature": "`emitter.setMaxListeners(n)`", "apiSymbol": "emitter.setMaxListeners", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emittersetmaxlistenersn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emittersetmaxlistenersn", "nodeStability": { "index": "2", "level": 2, @@ -24060,7 +24740,7 @@ "label": "emitter.rawListeners(eventName)", "signature": "`emitter.rawListeners(eventName)`", "apiSymbol": "emitter.rawListeners", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#emitterrawlistenerseventname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#emitterrawlistenerseventname", "nodeStability": { "index": "2", "level": 2, @@ -24088,7 +24768,7 @@ "label": "'newListener'", "signature": "Event: `'newListener'`", "apiSymbol": "'newListener'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#event-newlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#event-newlistener", "nodeStability": { "index": "2", "level": 2, @@ -24113,7 +24793,7 @@ "label": "'removeListener'", "signature": "Event: `'removeListener'`", "apiSymbol": "'removeListener'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#event-removelistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#event-removelistener", "nodeStability": { "index": "2", "level": 2, @@ -24138,7 +24818,7 @@ "label": "events.EventEmitterAsyncResource extends EventEmitter", "signature": "Class: `events.EventEmitterAsyncResource extends EventEmitter`", "apiSymbol": "events.EventEmitterAsyncResource extends EventEmitter", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#class-eventseventemitterasyncresource-extends-eventemitter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#class-eventseventemitterasyncresource-extends-eventemitter", "nodeStability": { "index": "2", "level": 2, @@ -24163,7 +24843,7 @@ "label": "eventemitterasyncresource.emitDestroy()", "signature": "`eventemitterasyncresource.emitDestroy()`", "apiSymbol": "eventemitterasyncresource.emitDestroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventemitterasyncresourceemitdestroy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventemitterasyncresourceemitdestroy", "nodeStability": { "index": "2", "level": 2, @@ -24188,7 +24868,7 @@ "label": "asyncId", "signature": "`asyncId` Type: {number} The unique `asyncId` assigned to the resource.", "apiSymbol": "asyncId", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#class-eventseventemitterasyncresource-extends-eventemitter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#class-eventseventemitterasyncresource-extends-eventemitter", "nodeStability": { "index": "2", "level": 2, @@ -24213,7 +24893,7 @@ "label": "asyncResource", "signature": "`asyncResource` Type: {AsyncResource} The underlying {AsyncResource}.", "apiSymbol": "asyncResource", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#class-eventseventemitterasyncresource-extends-eventemitter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#class-eventseventemitterasyncresource-extends-eventemitter", "nodeStability": { "index": "2", "level": 2, @@ -24238,7 +24918,7 @@ "label": "triggerAsyncId", "signature": "`triggerAsyncId` Type: {number} The same `triggerAsyncId` that is passed to the `AsyncResource` constructor.", "apiSymbol": "triggerAsyncId", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#class-eventseventemitterasyncresource-extends-eventemitter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#class-eventseventemitterasyncresource-extends-eventemitter", "nodeStability": { "index": "2", "level": 2, @@ -24263,7 +24943,7 @@ "label": "events.getEventListeners(emitterOrTarget, eventName)", "signature": "`events.getEventListeners(emitterOrTarget, eventName)`", "apiSymbol": "events.getEventListeners", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventsgeteventlistenersemitterortarget-eventname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventsgeteventlistenersemitterortarget-eventname", "nodeStability": { "index": "2", "level": 2, @@ -24291,7 +24971,7 @@ "label": "events.getMaxListeners(emitterOrTarget)", "signature": "`events.getMaxListeners(emitterOrTarget)`", "apiSymbol": "events.getMaxListeners", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventsgetmaxlistenersemitterortarget", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventsgetmaxlistenersemitterortarget", "nodeStability": { "index": "2", "level": 2, @@ -24316,7 +24996,7 @@ "label": "events.once(emitter, name[, options])", "signature": "`events.once(emitter, name[, options])`", "apiSymbol": "events.once", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventsonceemitter-name-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventsonceemitter-name-options", "nodeStability": { "index": "2", "level": 2, @@ -24344,7 +25024,7 @@ "label": "events.listenerCount(emitterOrTarget, eventName)", "signature": "`events.listenerCount(emitterOrTarget, eventName)`", "apiSymbol": "events.listenerCount", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventslistenercountemitterortarget-eventname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventslistenercountemitterortarget-eventname", "nodeStability": { "index": "2", "level": 2, @@ -24372,7 +25052,7 @@ "label": "events.on(emitter, eventName[, options])", "signature": "`events.on(emitter, eventName[, options])`", "apiSymbol": "events.on", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventsonemitter-eventname-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventsonemitter-eventname-options", "nodeStability": { "index": "2", "level": 2, @@ -24400,7 +25080,7 @@ "label": "events.setMaxListeners(n[, ...eventTargets])", "signature": "`events.setMaxListeners(n[, ...eventTargets])`", "apiSymbol": "events.setMaxListeners", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventssetmaxlistenersn-eventtargets", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventssetmaxlistenersn-eventtargets", "nodeStability": { "index": "2", "level": 2, @@ -24428,7 +25108,7 @@ "label": "events.addAbortListener(signal, listener)", "signature": "`events.addAbortListener(signal, listener)`", "apiSymbol": "events.addAbortListener", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventsaddabortlistenersignal-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventsaddabortlistenersignal-listener", "nodeStability": { "index": "2", "level": 2, @@ -24455,7 +25135,7 @@ "label": "events.defaultMaxListeners", "signature": "`events.defaultMaxListeners`", "apiSymbol": "events.defaultMaxListeners", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventsdefaultmaxlisteners", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventsdefaultmaxlisteners", "nodeStability": { "index": "2", "level": 2, @@ -24480,7 +25160,7 @@ "label": "events.errorMonitor", "signature": "`events.errorMonitor`", "apiSymbol": "events.errorMonitor", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html#eventserrormonitor", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html#eventserrormonitor", "nodeStability": { "index": "2", "level": 2, @@ -24510,7 +25190,7 @@ "label": "captureRejections", "signature": "`captureRejections` Type: {boolean}", "apiSymbol": "captureRejections", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html", "nodeStability": { "index": "2", "level": 2, @@ -24535,7 +25215,7 @@ "label": "captureRejectionSymbol", "signature": "`captureRejectionSymbol` Type: {symbol} `Symbol.for('nodejs.rejection')`", "apiSymbol": "captureRejectionSymbol", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/events.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/events.html", "nodeStability": { "index": "2", "level": 2, @@ -24560,7 +25240,7 @@ "label": "FileHandle", "signature": "Class: `FileHandle`", "apiSymbol": "FileHandle", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-filehandle", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-filehandle", "nodeStability": { "index": "2", "level": 2, @@ -24588,7 +25268,7 @@ "label": "filehandle.appendFile(data[, options])", "signature": "`filehandle.appendFile(data[, options])`", "apiSymbol": "filehandle.appendFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandleappendfiledata-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandleappendfiledata-options", "nodeStability": { "index": "2", "level": 2, @@ -24616,7 +25296,7 @@ "label": "filehandle.chmod(mode)", "signature": "`filehandle.chmod(mode)`", "apiSymbol": "filehandle.chmod", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlechmodmode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlechmodmode", "nodeStability": { "index": "2", "level": 2, @@ -24643,7 +25323,7 @@ "label": "filehandle.chown(uid, gid)", "signature": "`filehandle.chown(uid, gid)`", "apiSymbol": "filehandle.chown", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlechownuid-gid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlechownuid-gid", "nodeStability": { "index": "2", "level": 2, @@ -24668,7 +25348,7 @@ "label": "filehandle.close()", "signature": "`filehandle.close()`", "apiSymbol": "filehandle.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandleclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandleclose", "nodeStability": { "index": "2", "level": 2, @@ -24696,7 +25376,7 @@ "label": "filehandle.createReadStream([options])", "signature": "`filehandle.createReadStream([options])`", "apiSymbol": "filehandle.createReadStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlecreatereadstreamoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlecreatereadstreamoptions", "nodeStability": { "index": "2", "level": 2, @@ -24721,7 +25401,7 @@ "label": "filehandle.createWriteStream([options])", "signature": "`filehandle.createWriteStream([options])`", "apiSymbol": "filehandle.createWriteStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlecreatewritestreamoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlecreatewritestreamoptions", "nodeStability": { "index": "2", "level": 2, @@ -24746,7 +25426,7 @@ "label": "filehandle.datasync()", "signature": "`filehandle.datasync()`", "apiSymbol": "filehandle.datasync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandledatasync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandledatasync", "nodeStability": { "index": "2", "level": 2, @@ -24767,13 +25447,63 @@ } } }, + { + "id": "fs:3eddc68c4823", + "chapter": "fs", + "label": "filehandle.pull([...transforms][, options])", + "signature": "`filehandle.pull([...transforms][, options])`", + "apiSymbol": "filehandle.pull", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlepulltransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:fs", + "tests": [] + } + } + }, + { + "id": "fs:236cfefb2bd7", + "chapter": "fs", + "label": "filehandle.pullSync([...transforms][, options])", + "signature": "`filehandle.pullSync([...transforms][, options])`", + "apiSymbol": "filehandle.pullSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlepullsynctransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:fs", + "tests": [] + } + } + }, { "id": "fs:8bff339d602d", "chapter": "fs", "label": "filehandle.read(buffer, offset, length, position)", "signature": "`filehandle.read(buffer, offset, length, position)`", "apiSymbol": "filehandle.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlereadbuffer-offset-length-position", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlereadbuffer-offset-length-position", "nodeStability": { "index": "2", "level": 2, @@ -24801,7 +25531,7 @@ "label": "filehandle.read([options])", "signature": "`filehandle.read([options])`", "apiSymbol": "filehandle.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlereadoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlereadoptions", "nodeStability": { "index": "2", "level": 2, @@ -24829,7 +25559,7 @@ "label": "filehandle.read(buffer[, options])", "signature": "`filehandle.read(buffer[, options])`", "apiSymbol": "filehandle.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlereadbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlereadbuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -24857,7 +25587,7 @@ "label": "filehandle.readableWebStream([options])", "signature": "`filehandle.readableWebStream([options])`", "apiSymbol": "filehandle.readableWebStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlereadablewebstreamoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlereadablewebstreamoptions", "nodeStability": { "index": "2", "level": 2, @@ -24882,7 +25612,7 @@ "label": "filehandle.readFile(options)", "signature": "`filehandle.readFile(options)`", "apiSymbol": "filehandle.readFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlereadfileoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlereadfileoptions", "nodeStability": { "index": "2", "level": 2, @@ -24910,7 +25640,7 @@ "label": "filehandle.readLines([options])", "signature": "`filehandle.readLines([options])`", "apiSymbol": "filehandle.readLines", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlereadlinesoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlereadlinesoptions", "nodeStability": { "index": "2", "level": 2, @@ -24935,7 +25665,7 @@ "label": "filehandle.readv(buffers[, position])", "signature": "`filehandle.readv(buffers[, position])`", "apiSymbol": "filehandle.readv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlereadvbuffers-position", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlereadvbuffers-position", "nodeStability": { "index": "2", "level": 2, @@ -24962,7 +25692,7 @@ "label": "filehandle.stat([options])", "signature": "`filehandle.stat([options])`", "apiSymbol": "filehandle.stat", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlestatoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlestatoptions", "nodeStability": { "index": "2", "level": 2, @@ -24990,7 +25720,7 @@ "label": "filehandle.sync()", "signature": "`filehandle.sync()`", "apiSymbol": "filehandle.sync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlesync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlesync", "nodeStability": { "index": "2", "level": 2, @@ -25017,7 +25747,7 @@ "label": "filehandle.truncate(len)", "signature": "`filehandle.truncate(len)`", "apiSymbol": "filehandle.truncate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandletruncatelen", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandletruncatelen", "nodeStability": { "index": "2", "level": 2, @@ -25044,7 +25774,7 @@ "label": "filehandle.utimes(atime, mtime)", "signature": "`filehandle.utimes(atime, mtime)`", "apiSymbol": "filehandle.utimes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandleutimesatime-mtime", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandleutimesatime-mtime", "nodeStability": { "index": "2", "level": 2, @@ -25072,7 +25802,7 @@ "label": "filehandle.write(buffer, offset[, length[, position]])", "signature": "`filehandle.write(buffer, offset[, length[, position]])`", "apiSymbol": "filehandle.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlewritebuffer-offset-length-position", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlewritebuffer-offset-length-position", "nodeStability": { "index": "2", "level": 2, @@ -25100,7 +25830,7 @@ "label": "filehandle.write(buffer[, options])", "signature": "`filehandle.write(buffer[, options])`", "apiSymbol": "filehandle.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlewritebuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlewritebuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -25128,7 +25858,7 @@ "label": "filehandle.write(string[, position[, encoding]])", "signature": "`filehandle.write(string[, position[, encoding]])`", "apiSymbol": "filehandle.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlewritestring-position-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlewritestring-position-encoding", "nodeStability": { "index": "2", "level": 2, @@ -25156,7 +25886,7 @@ "label": "filehandle.writeFile(data, options)", "signature": "`filehandle.writeFile(data, options)`", "apiSymbol": "filehandle.writeFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlewritefiledata-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlewritefiledata-options", "nodeStability": { "index": "2", "level": 2, @@ -25184,7 +25914,7 @@ "label": "filehandle.writev(buffers[, position])", "signature": "`filehandle.writev(buffers[, position])`", "apiSymbol": "filehandle.writev", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlewritevbuffers-position", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlewritevbuffers-position", "nodeStability": { "index": "2", "level": 2, @@ -25205,13 +25935,38 @@ } } }, + { + "id": "fs:db142178f3b2", + "chapter": "fs", + "label": "filehandle.writer([options])", + "signature": "`filehandle.writer([options])`", + "apiSymbol": "filehandle.writer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlewriteroptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:fs", + "tests": [] + } + } + }, { "id": "fs:0eb79d089322", "chapter": "fs", "label": "filehandle[Symbol.asyncDispose]()", "signature": "`filehandle[Symbol.asyncDispose]()`", "apiSymbol": "filehandle", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#filehandlesymbolasyncdispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#filehandlesymbolasyncdispose", "nodeStability": { "index": "2", "level": 2, @@ -25238,7 +25993,7 @@ "label": "fd", "signature": "`fd` Type: {number} The numeric file descriptor managed by the {FileHandle} object.", "apiSymbol": "fd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-filehandle", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-filehandle", "nodeStability": { "index": "2", "level": 2, @@ -25265,7 +26020,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-close", "nodeStability": { "index": "2", "level": 2, @@ -25290,7 +26045,7 @@ "label": "fsPromises.access(path[, mode])", "signature": "`fsPromises.access(path[, mode])`", "apiSymbol": "fsPromises.access", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesaccesspath-mode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesaccesspath-mode", "nodeStability": { "index": "2", "level": 2, @@ -25315,7 +26070,7 @@ "label": "fsPromises.appendFile(path, data[, options])", "signature": "`fsPromises.appendFile(path, data[, options])`", "apiSymbol": "fsPromises.appendFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesappendfilepath-data-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesappendfilepath-data-options", "nodeStability": { "index": "2", "level": 2, @@ -25340,7 +26095,7 @@ "label": "fsPromises.chmod(path, mode)", "signature": "`fsPromises.chmod(path, mode)`", "apiSymbol": "fsPromises.chmod", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromiseschmodpath-mode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromiseschmodpath-mode", "nodeStability": { "index": "2", "level": 2, @@ -25370,7 +26125,7 @@ "label": "fsPromises.chown(path, uid, gid)", "signature": "`fsPromises.chown(path, uid, gid)`", "apiSymbol": "fsPromises.chown", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromiseschownpath-uid-gid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromiseschownpath-uid-gid", "nodeStability": { "index": "2", "level": 2, @@ -25395,7 +26150,7 @@ "label": "fsPromises.copyFile(src, dest[, mode])", "signature": "`fsPromises.copyFile(src, dest[, mode])`", "apiSymbol": "fsPromises.copyFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisescopyfilesrc-dest-mode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisescopyfilesrc-dest-mode", "nodeStability": { "index": "2", "level": 2, @@ -25420,7 +26175,7 @@ "label": "fsPromises.cp(src, dest[, options])", "signature": "`fsPromises.cp(src, dest[, options])`", "apiSymbol": "fsPromises.cp", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisescpsrc-dest-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisescpsrc-dest-options", "nodeStability": { "index": "2", "level": 2, @@ -25445,7 +26200,7 @@ "label": "fsPromises.glob(pattern[, options])", "signature": "`fsPromises.glob(pattern[, options])`", "apiSymbol": "fsPromises.glob", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesglobpattern-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesglobpattern-options", "nodeStability": { "index": "2", "level": 2, @@ -25470,7 +26225,7 @@ "label": "fsPromises.lchmod(path, mode)", "signature": "`fsPromises.lchmod(path, mode)`", "apiSymbol": "fsPromises.lchmod", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromiseslchmodpath-mode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromiseslchmodpath-mode", "nodeStability": { "index": "0", "level": 0, @@ -25495,7 +26250,7 @@ "label": "fsPromises.lchown(path, uid, gid)", "signature": "`fsPromises.lchown(path, uid, gid)`", "apiSymbol": "fsPromises.lchown", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromiseslchownpath-uid-gid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromiseslchownpath-uid-gid", "nodeStability": { "index": "2", "level": 2, @@ -25520,7 +26275,7 @@ "label": "fsPromises.lutimes(path, atime, mtime)", "signature": "`fsPromises.lutimes(path, atime, mtime)`", "apiSymbol": "fsPromises.lutimes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromiseslutimespath-atime-mtime", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromiseslutimespath-atime-mtime", "nodeStability": { "index": "2", "level": 2, @@ -25548,7 +26303,7 @@ "label": "fsPromises.link(existingPath, newPath)", "signature": "`fsPromises.link(existingPath, newPath)`", "apiSymbol": "fsPromises.link", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromiseslinkexistingpath-newpath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromiseslinkexistingpath-newpath", "nodeStability": { "index": "2", "level": 2, @@ -25577,7 +26332,7 @@ "label": "fsPromises.lstat(path[, options])", "signature": "`fsPromises.lstat(path[, options])`", "apiSymbol": "fsPromises.lstat", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromiseslstatpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromiseslstatpath-options", "nodeStability": { "index": "2", "level": 2, @@ -25604,7 +26359,7 @@ "label": "fsPromises.mkdir(path[, options])", "signature": "`fsPromises.mkdir(path[, options])`", "apiSymbol": "fsPromises.mkdir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesmkdirpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesmkdirpath-options", "nodeStability": { "index": "2", "level": 2, @@ -25634,7 +26389,7 @@ "label": "fsPromises.mkdtemp(prefix[, options])", "signature": "`fsPromises.mkdtemp(prefix[, options])`", "apiSymbol": "fsPromises.mkdtemp", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesmkdtempprefix-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesmkdtempprefix-options", "nodeStability": { "index": "2", "level": 2, @@ -25659,7 +26414,7 @@ "label": "fsPromises.mkdtempDisposable(prefix[, options])", "signature": "`fsPromises.mkdtempDisposable(prefix[, options])`", "apiSymbol": "fsPromises.mkdtempDisposable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesmkdtempdisposableprefix-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesmkdtempdisposableprefix-options", "nodeStability": { "index": "2", "level": 2, @@ -25684,7 +26439,7 @@ "label": "fsPromises.open(path, flags[, mode])", "signature": "`fsPromises.open(path, flags[, mode])`", "apiSymbol": "fsPromises.open", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesopenpath-flags-mode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesopenpath-flags-mode", "nodeStability": { "index": "2", "level": 2, @@ -25714,7 +26469,7 @@ "label": "fsPromises.opendir(path[, options])", "signature": "`fsPromises.opendir(path[, options])`", "apiSymbol": "fsPromises.opendir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesopendirpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesopendirpath-options", "nodeStability": { "index": "2", "level": 2, @@ -25739,7 +26494,7 @@ "label": "fsPromises.readdir(path[, options])", "signature": "`fsPromises.readdir(path[, options])`", "apiSymbol": "fsPromises.readdir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesreaddirpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesreaddirpath-options", "nodeStability": { "index": "2", "level": 2, @@ -25766,7 +26521,7 @@ "label": "fsPromises.readFile(path[, options])", "signature": "`fsPromises.readFile(path[, options])`", "apiSymbol": "fsPromises.readFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesreadfilepath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesreadfilepath-options", "nodeStability": { "index": "2", "level": 2, @@ -25796,7 +26551,7 @@ "label": "fsPromises.readlink(path[, options])", "signature": "`fsPromises.readlink(path[, options])`", "apiSymbol": "fsPromises.readlink", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesreadlinkpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesreadlinkpath-options", "nodeStability": { "index": "2", "level": 2, @@ -25826,7 +26581,7 @@ "label": "fsPromises.realpath(path[, options])", "signature": "`fsPromises.realpath(path[, options])`", "apiSymbol": "fsPromises.realpath", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesrealpathpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesrealpathpath-options", "nodeStability": { "index": "2", "level": 2, @@ -25853,7 +26608,7 @@ "label": "fsPromises.rename(oldPath, newPath)", "signature": "`fsPromises.rename(oldPath, newPath)`", "apiSymbol": "fsPromises.rename", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesrenameoldpath-newpath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesrenameoldpath-newpath", "nodeStability": { "index": "2", "level": 2, @@ -25883,7 +26638,7 @@ "label": "fsPromises.rmdir(path[, options])", "signature": "`fsPromises.rmdir(path[, options])`", "apiSymbol": "fsPromises.rmdir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesrmdirpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesrmdirpath-options", "nodeStability": { "index": "2", "level": 2, @@ -25908,7 +26663,7 @@ "label": "fsPromises.rm(path[, options])", "signature": "`fsPromises.rm(path[, options])`", "apiSymbol": "fsPromises.rm", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesrmpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesrmpath-options", "nodeStability": { "index": "2", "level": 2, @@ -25938,7 +26693,7 @@ "label": "fsPromises.stat(path[, options])", "signature": "`fsPromises.stat(path[, options])`", "apiSymbol": "fsPromises.stat", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesstatpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesstatpath-options", "nodeStability": { "index": "2", "level": 2, @@ -25968,7 +26723,7 @@ "label": "fsPromises.statfs(path[, options])", "signature": "`fsPromises.statfs(path[, options])`", "apiSymbol": "fsPromises.statfs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesstatfspath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesstatfspath-options", "nodeStability": { "index": "2", "level": 2, @@ -25998,7 +26753,7 @@ "label": "fsPromises.symlink(target, path[, type])", "signature": "`fsPromises.symlink(target, path[, type])`", "apiSymbol": "fsPromises.symlink", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisessymlinktarget-path-type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisessymlinktarget-path-type", "nodeStability": { "index": "2", "level": 2, @@ -26028,7 +26783,7 @@ "label": "fsPromises.truncate(path[, len])", "signature": "`fsPromises.truncate(path[, len])`", "apiSymbol": "fsPromises.truncate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisestruncatepath-len", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisestruncatepath-len", "nodeStability": { "index": "2", "level": 2, @@ -26053,7 +26808,7 @@ "label": "fsPromises.unlink(path)", "signature": "`fsPromises.unlink(path)`", "apiSymbol": "fsPromises.unlink", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesunlinkpath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesunlinkpath", "nodeStability": { "index": "2", "level": 2, @@ -26083,7 +26838,7 @@ "label": "fsPromises.utimes(path, atime, mtime)", "signature": "`fsPromises.utimes(path, atime, mtime)`", "apiSymbol": "fsPromises.utimes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromisesutimespath-atime-mtime", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromisesutimespath-atime-mtime", "nodeStability": { "index": "2", "level": 2, @@ -26110,7 +26865,7 @@ "label": "fsPromises.watch(filename[, options])", "signature": "`fsPromises.watch(filename[, options])`", "apiSymbol": "fsPromises.watch", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromiseswatchfilename-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromiseswatchfilename-options", "nodeStability": { "index": "2", "level": 2, @@ -26135,7 +26890,7 @@ "label": "fsPromises.writeFile(file, data[, options])", "signature": "`fsPromises.writeFile(file, data[, options])`", "apiSymbol": "fsPromises.writeFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fspromiseswritefilefile-data-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fspromiseswritefilefile-data-options", "nodeStability": { "index": "2", "level": 2, @@ -26165,7 +26920,7 @@ "label": "constants", "signature": "`constants` Type: {Object}", "apiSymbol": "constants", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#promises-api", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#promises-api", "nodeStability": { "index": "2", "level": 2, @@ -26190,7 +26945,7 @@ "label": "fs.access(path[, mode], callback)", "signature": "`fs.access(path[, mode], callback)`", "apiSymbol": "fs.access", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsaccesspath-mode-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsaccesspath-mode-callback", "nodeStability": { "index": "2", "level": 2, @@ -26215,7 +26970,7 @@ "label": "fs.appendFile(path, data[, options], callback)", "signature": "`fs.appendFile(path, data[, options], callback)`", "apiSymbol": "fs.appendFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsappendfilepath-data-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsappendfilepath-data-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -26240,7 +26995,7 @@ "label": "fs.chmod(path, mode, callback)", "signature": "`fs.chmod(path, mode, callback)`", "apiSymbol": "fs.chmod", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fschmodpath-mode-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fschmodpath-mode-callback", "nodeStability": { "index": "2", "level": 2, @@ -26265,7 +27020,7 @@ "label": "fs.chown(path, uid, gid, callback)", "signature": "`fs.chown(path, uid, gid, callback)`", "apiSymbol": "fs.chown", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fschownpath-uid-gid-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fschownpath-uid-gid-callback", "nodeStability": { "index": "2", "level": 2, @@ -26290,7 +27045,7 @@ "label": "fs.close(fd[, callback])", "signature": "`fs.close(fd[, callback])`", "apiSymbol": "fs.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsclosefd-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsclosefd-callback", "nodeStability": { "index": "2", "level": 2, @@ -26315,7 +27070,7 @@ "label": "fs.copyFile(src, dest[, mode], callback)", "signature": "`fs.copyFile(src, dest[, mode], callback)`", "apiSymbol": "fs.copyFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fscopyfilesrc-dest-mode-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fscopyfilesrc-dest-mode-callback", "nodeStability": { "index": "2", "level": 2, @@ -26340,7 +27095,7 @@ "label": "fs.cp(src, dest[, options], callback)", "signature": "`fs.cp(src, dest[, options], callback)`", "apiSymbol": "fs.cp", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fscpsrc-dest-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fscpsrc-dest-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -26365,7 +27120,7 @@ "label": "fs.createReadStream(path[, options])", "signature": "`fs.createReadStream(path[, options])`", "apiSymbol": "fs.createReadStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fscreatereadstreampath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fscreatereadstreampath-options", "nodeStability": { "index": "2", "level": 2, @@ -26390,7 +27145,7 @@ "label": "fs.createWriteStream(path[, options])", "signature": "`fs.createWriteStream(path[, options])`", "apiSymbol": "fs.createWriteStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fscreatewritestreampath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fscreatewritestreampath-options", "nodeStability": { "index": "2", "level": 2, @@ -26415,7 +27170,7 @@ "label": "fs.exists(path, callback)", "signature": "`fs.exists(path, callback)`", "apiSymbol": "fs.exists", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsexistspath-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsexistspath-callback", "nodeStability": { "index": "0", "level": 0, @@ -26440,7 +27195,7 @@ "label": "fs.fchmod(fd, mode, callback)", "signature": "`fs.fchmod(fd, mode, callback)`", "apiSymbol": "fs.fchmod", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsfchmodfd-mode-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsfchmodfd-mode-callback", "nodeStability": { "index": "2", "level": 2, @@ -26467,7 +27222,7 @@ "label": "fs.fchown(fd, uid, gid, callback)", "signature": "`fs.fchown(fd, uid, gid, callback)`", "apiSymbol": "fs.fchown", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsfchownfd-uid-gid-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsfchownfd-uid-gid-callback", "nodeStability": { "index": "2", "level": 2, @@ -26492,7 +27247,7 @@ "label": "fs.fdatasync(fd, callback)", "signature": "`fs.fdatasync(fd, callback)`", "apiSymbol": "fs.fdatasync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsfdatasyncfd-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsfdatasyncfd-callback", "nodeStability": { "index": "2", "level": 2, @@ -26519,7 +27274,7 @@ "label": "fs.fstat(fd[, options], callback)", "signature": "`fs.fstat(fd[, options], callback)`", "apiSymbol": "fs.fstat", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsfstatfd-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsfstatfd-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -26544,7 +27299,7 @@ "label": "fs.fsync(fd, callback)", "signature": "`fs.fsync(fd, callback)`", "apiSymbol": "fs.fsync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsfsyncfd-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsfsyncfd-callback", "nodeStability": { "index": "2", "level": 2, @@ -26569,7 +27324,7 @@ "label": "fs.ftruncate(fd[, len], callback)", "signature": "`fs.ftruncate(fd[, len], callback)`", "apiSymbol": "fs.ftruncate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsftruncatefd-len-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsftruncatefd-len-callback", "nodeStability": { "index": "2", "level": 2, @@ -26596,7 +27351,7 @@ "label": "fs.futimes(fd, atime, mtime, callback)", "signature": "`fs.futimes(fd, atime, mtime, callback)`", "apiSymbol": "fs.futimes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsfutimesfd-atime-mtime-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsfutimesfd-atime-mtime-callback", "nodeStability": { "index": "2", "level": 2, @@ -26625,7 +27380,7 @@ "label": "fs.glob(pattern[, options], callback)", "signature": "`fs.glob(pattern[, options], callback)`", "apiSymbol": "fs.glob", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsglobpattern-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsglobpattern-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -26650,7 +27405,7 @@ "label": "fs.lchmod(path, mode, callback)", "signature": "`fs.lchmod(path, mode, callback)`", "apiSymbol": "fs.lchmod", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fslchmodpath-mode-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fslchmodpath-mode-callback", "nodeStability": { "index": "0", "level": 0, @@ -26675,7 +27430,7 @@ "label": "fs.lchown(path, uid, gid, callback)", "signature": "`fs.lchown(path, uid, gid, callback)`", "apiSymbol": "fs.lchown", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fslchownpath-uid-gid-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fslchownpath-uid-gid-callback", "nodeStability": { "index": "2", "level": 2, @@ -26700,7 +27455,7 @@ "label": "fs.lutimes(path, atime, mtime, callback)", "signature": "`fs.lutimes(path, atime, mtime, callback)`", "apiSymbol": "fs.lutimes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fslutimespath-atime-mtime-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fslutimespath-atime-mtime-callback", "nodeStability": { "index": "2", "level": 2, @@ -26729,7 +27484,7 @@ "label": "fs.link(existingPath, newPath, callback)", "signature": "`fs.link(existingPath, newPath, callback)`", "apiSymbol": "fs.link", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fslinkexistingpath-newpath-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fslinkexistingpath-newpath-callback", "nodeStability": { "index": "2", "level": 2, @@ -26759,7 +27514,7 @@ "label": "fs.lstat(path[, options], callback)", "signature": "`fs.lstat(path[, options], callback)`", "apiSymbol": "fs.lstat", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fslstatpath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fslstatpath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -26784,7 +27539,7 @@ "label": "fs.mkdir(path[, options], callback)", "signature": "`fs.mkdir(path[, options], callback)`", "apiSymbol": "fs.mkdir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsmkdirpath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsmkdirpath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -26809,7 +27564,7 @@ "label": "fs.mkdtemp(prefix[, options], callback)", "signature": "`fs.mkdtemp(prefix[, options], callback)`", "apiSymbol": "fs.mkdtemp", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsmkdtempprefix-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsmkdtempprefix-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -26834,7 +27589,7 @@ "label": "fs.open(path[, flags[, mode]], callback)", "signature": "`fs.open(path[, flags[, mode]], callback)`", "apiSymbol": "fs.open", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsopenpath-flags-mode-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsopenpath-flags-mode-callback", "nodeStability": { "index": "2", "level": 2, @@ -26859,7 +27614,7 @@ "label": "fs.openAsBlob(path[, options])", "signature": "`fs.openAsBlob(path[, options])`", "apiSymbol": "fs.openAsBlob", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsopenasblobpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsopenasblobpath-options", "nodeStability": { "index": "2", "level": 2, @@ -26884,7 +27639,7 @@ "label": "fs.opendir(path[, options], callback)", "signature": "`fs.opendir(path[, options], callback)`", "apiSymbol": "fs.opendir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsopendirpath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsopendirpath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -26909,7 +27664,7 @@ "label": "fs.read(fd, buffer, offset, length, position, callback)", "signature": "`fs.read(fd, buffer, offset, length, position, callback)`", "apiSymbol": "fs.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreadfd-buffer-offset-length-position-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreadfd-buffer-offset-length-position-callback", "nodeStability": { "index": "2", "level": 2, @@ -26934,7 +27689,7 @@ "label": "fs.read(fd[, options], callback)", "signature": "`fs.read(fd[, options], callback)`", "apiSymbol": "fs.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreadfd-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreadfd-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -26959,7 +27714,7 @@ "label": "fs.read(fd, buffer[, options], callback)", "signature": "`fs.read(fd, buffer[, options], callback)`", "apiSymbol": "fs.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreadfd-buffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreadfd-buffer-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -26984,7 +27739,7 @@ "label": "fs.readdir(path[, options], callback)", "signature": "`fs.readdir(path[, options], callback)`", "apiSymbol": "fs.readdir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreaddirpath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreaddirpath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -27009,7 +27764,7 @@ "label": "fs.readFile(path[, options], callback)", "signature": "`fs.readFile(path[, options], callback)`", "apiSymbol": "fs.readFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreadfilepath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreadfilepath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -27034,7 +27789,7 @@ "label": "fs.readlink(path[, options], callback)", "signature": "`fs.readlink(path[, options], callback)`", "apiSymbol": "fs.readlink", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreadlinkpath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreadlinkpath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -27064,7 +27819,7 @@ "label": "fs.readv(fd, buffers[, position], callback)", "signature": "`fs.readv(fd, buffers[, position], callback)`", "apiSymbol": "fs.readv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreadvfd-buffers-position-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreadvfd-buffers-position-callback", "nodeStability": { "index": "2", "level": 2, @@ -27091,7 +27846,7 @@ "label": "fs.realpath(path[, options], callback)", "signature": "`fs.realpath(path[, options], callback)`", "apiSymbol": "fs.realpath", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsrealpathpath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsrealpathpath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -27116,7 +27871,7 @@ "label": "fs.realpath.native(path[, options], callback)", "signature": "`fs.realpath.native(path[, options], callback)`", "apiSymbol": "fs.realpath.native", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsrealpathnativepath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsrealpathnativepath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -27141,7 +27896,7 @@ "label": "fs.rename(oldPath, newPath, callback)", "signature": "`fs.rename(oldPath, newPath, callback)`", "apiSymbol": "fs.rename", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsrenameoldpath-newpath-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsrenameoldpath-newpath-callback", "nodeStability": { "index": "2", "level": 2, @@ -27171,7 +27926,7 @@ "label": "fs.rmdir(path[, options], callback)", "signature": "`fs.rmdir(path[, options], callback)`", "apiSymbol": "fs.rmdir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsrmdirpath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsrmdirpath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -27196,7 +27951,7 @@ "label": "fs.rm(path[, options], callback)", "signature": "`fs.rm(path[, options], callback)`", "apiSymbol": "fs.rm", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsrmpath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsrmpath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -27221,7 +27976,7 @@ "label": "fs.stat(path[, options], callback)", "signature": "`fs.stat(path[, options], callback)`", "apiSymbol": "fs.stat", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsstatpath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsstatpath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -27246,7 +28001,7 @@ "label": "fs.statfs(path[, options], callback)", "signature": "`fs.statfs(path[, options], callback)`", "apiSymbol": "fs.statfs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsstatfspath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsstatfspath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -27276,7 +28031,7 @@ "label": "fs.symlink(target, path[, type], callback)", "signature": "`fs.symlink(target, path[, type], callback)`", "apiSymbol": "fs.symlink", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fssymlinktarget-path-type-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fssymlinktarget-path-type-callback", "nodeStability": { "index": "2", "level": 2, @@ -27306,7 +28061,7 @@ "label": "fs.truncate(path[, len], callback)", "signature": "`fs.truncate(path[, len], callback)`", "apiSymbol": "fs.truncate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fstruncatepath-len-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fstruncatepath-len-callback", "nodeStability": { "index": "2", "level": 2, @@ -27331,7 +28086,7 @@ "label": "fs.unlink(path, callback)", "signature": "`fs.unlink(path, callback)`", "apiSymbol": "fs.unlink", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsunlinkpath-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsunlinkpath-callback", "nodeStability": { "index": "2", "level": 2, @@ -27356,7 +28111,7 @@ "label": "fs.unwatchFile(filename[, listener])", "signature": "`fs.unwatchFile(filename[, listener])`", "apiSymbol": "fs.unwatchFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsunwatchfilefilename-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsunwatchfilefilename-listener", "nodeStability": { "index": "2", "level": 2, @@ -27381,7 +28136,7 @@ "label": "fs.utimes(path, atime, mtime, callback)", "signature": "`fs.utimes(path, atime, mtime, callback)`", "apiSymbol": "fs.utimes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsutimespath-atime-mtime-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsutimespath-atime-mtime-callback", "nodeStability": { "index": "2", "level": 2, @@ -27410,7 +28165,7 @@ "label": "fs.watch(filename[, options][, listener])", "signature": "`fs.watch(filename[, options][, listener])`", "apiSymbol": "fs.watch", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fswatchfilename-options-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fswatchfilename-options-listener", "nodeStability": { "index": "2", "level": 2, @@ -27440,7 +28195,7 @@ "label": "fs.watchFile(filename[, options], listener)", "signature": "`fs.watchFile(filename[, options], listener)`", "apiSymbol": "fs.watchFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fswatchfilefilename-options-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fswatchfilefilename-options-listener", "nodeStability": { "index": "2", "level": 2, @@ -27465,7 +28220,7 @@ "label": "fs.write(fd, buffer, offset[, length[, position]], callback)", "signature": "`fs.write(fd, buffer, offset[, length[, position]], callback)`", "apiSymbol": "fs.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fswritefd-buffer-offset-length-position-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fswritefd-buffer-offset-length-position-callback", "nodeStability": { "index": "2", "level": 2, @@ -27490,7 +28245,7 @@ "label": "fs.write(fd, buffer[, options], callback)", "signature": "`fs.write(fd, buffer[, options], callback)`", "apiSymbol": "fs.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fswritefd-buffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fswritefd-buffer-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -27515,7 +28270,7 @@ "label": "fs.write(fd, string[, position[, encoding]], callback)", "signature": "`fs.write(fd, string[, position[, encoding]], callback)`", "apiSymbol": "fs.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fswritefd-string-position-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fswritefd-string-position-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -27540,7 +28295,7 @@ "label": "fs.writeFile(file, data[, options], callback)", "signature": "`fs.writeFile(file, data[, options], callback)`", "apiSymbol": "fs.writeFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fswritefilefile-data-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fswritefilefile-data-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -27565,7 +28320,7 @@ "label": "Using fs.writeFile() with file descriptors", "signature": "Using `fs.writeFile()` with file descriptors", "apiSymbol": "fs.writeFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#using-fswritefile-with-file-descriptors", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#using-fswritefile-with-file-descriptors", "nodeStability": { "index": "2", "level": 2, @@ -27590,7 +28345,7 @@ "label": "fs.writev(fd, buffers[, position], callback)", "signature": "`fs.writev(fd, buffers[, position], callback)`", "apiSymbol": "fs.writev", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fswritevfd-buffers-position-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fswritevfd-buffers-position-callback", "nodeStability": { "index": "2", "level": 2, @@ -27617,7 +28372,7 @@ "label": "fs.accessSync(path[, mode])", "signature": "`fs.accessSync(path[, mode])`", "apiSymbol": "fs.accessSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsaccesssyncpath-mode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsaccesssyncpath-mode", "nodeStability": { "index": "2", "level": 2, @@ -27647,7 +28402,7 @@ "label": "fs.appendFileSync(path, data[, options])", "signature": "`fs.appendFileSync(path, data[, options])`", "apiSymbol": "fs.appendFileSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsappendfilesyncpath-data-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsappendfilesyncpath-data-options", "nodeStability": { "index": "2", "level": 2, @@ -27677,7 +28432,7 @@ "label": "fs.chmodSync(path, mode)", "signature": "`fs.chmodSync(path, mode)`", "apiSymbol": "fs.chmodSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fschmodsyncpath-mode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fschmodsyncpath-mode", "nodeStability": { "index": "2", "level": 2, @@ -27707,7 +28462,7 @@ "label": "fs.chownSync(path, uid, gid)", "signature": "`fs.chownSync(path, uid, gid)`", "apiSymbol": "fs.chownSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fschownsyncpath-uid-gid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fschownsyncpath-uid-gid", "nodeStability": { "index": "2", "level": 2, @@ -27737,7 +28492,7 @@ "label": "fs.closeSync(fd)", "signature": "`fs.closeSync(fd)`", "apiSymbol": "fs.closeSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsclosesyncfd", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsclosesyncfd", "nodeStability": { "index": "2", "level": 2, @@ -27767,7 +28522,7 @@ "label": "fs.copyFileSync(src, dest[, mode])", "signature": "`fs.copyFileSync(src, dest[, mode])`", "apiSymbol": "fs.copyFileSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fscopyfilesyncsrc-dest-mode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fscopyfilesyncsrc-dest-mode", "nodeStability": { "index": "2", "level": 2, @@ -27797,7 +28552,7 @@ "label": "fs.cpSync(src, dest[, options])", "signature": "`fs.cpSync(src, dest[, options])`", "apiSymbol": "fs.cpSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fscpsyncsrc-dest-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fscpsyncsrc-dest-options", "nodeStability": { "index": "2", "level": 2, @@ -27822,7 +28577,7 @@ "label": "fs.existsSync(path)", "signature": "`fs.existsSync(path)`", "apiSymbol": "fs.existsSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsexistssyncpath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsexistssyncpath", "nodeStability": { "index": "2", "level": 2, @@ -27852,7 +28607,7 @@ "label": "fs.fchmodSync(fd, mode)", "signature": "`fs.fchmodSync(fd, mode)`", "apiSymbol": "fs.fchmodSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsfchmodsyncfd-mode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsfchmodsyncfd-mode", "nodeStability": { "index": "2", "level": 2, @@ -27879,7 +28634,7 @@ "label": "fs.fchownSync(fd, uid, gid)", "signature": "`fs.fchownSync(fd, uid, gid)`", "apiSymbol": "fs.fchownSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsfchownsyncfd-uid-gid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsfchownsyncfd-uid-gid", "nodeStability": { "index": "2", "level": 2, @@ -27904,7 +28659,7 @@ "label": "fs.fdatasyncSync(fd)", "signature": "`fs.fdatasyncSync(fd)`", "apiSymbol": "fs.fdatasyncSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsfdatasyncsyncfd", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsfdatasyncsyncfd", "nodeStability": { "index": "2", "level": 2, @@ -27931,7 +28686,7 @@ "label": "fs.fstatSync(fd[, options])", "signature": "`fs.fstatSync(fd[, options])`", "apiSymbol": "fs.fstatSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsfstatsyncfd-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsfstatsyncfd-options", "nodeStability": { "index": "2", "level": 2, @@ -27958,7 +28713,7 @@ "label": "fs.fsyncSync(fd)", "signature": "`fs.fsyncSync(fd)`", "apiSymbol": "fs.fsyncSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsfsyncsyncfd", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsfsyncsyncfd", "nodeStability": { "index": "2", "level": 2, @@ -27985,7 +28740,7 @@ "label": "fs.ftruncateSync(fd[, len])", "signature": "`fs.ftruncateSync(fd[, len])`", "apiSymbol": "fs.ftruncateSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsftruncatesyncfd-len", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsftruncatesyncfd-len", "nodeStability": { "index": "2", "level": 2, @@ -28012,7 +28767,7 @@ "label": "fs.futimesSync(fd, atime, mtime)", "signature": "`fs.futimesSync(fd, atime, mtime)`", "apiSymbol": "fs.futimesSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsfutimessyncfd-atime-mtime", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsfutimessyncfd-atime-mtime", "nodeStability": { "index": "2", "level": 2, @@ -28040,7 +28795,7 @@ "label": "fs.globSync(pattern[, options])", "signature": "`fs.globSync(pattern[, options])`", "apiSymbol": "fs.globSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsglobsyncpattern-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsglobsyncpattern-options", "nodeStability": { "index": "2", "level": 2, @@ -28065,7 +28820,7 @@ "label": "fs.lchmodSync(path, mode)", "signature": "`fs.lchmodSync(path, mode)`", "apiSymbol": "fs.lchmodSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fslchmodsyncpath-mode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fslchmodsyncpath-mode", "nodeStability": { "index": "0", "level": 0, @@ -28090,7 +28845,7 @@ "label": "fs.lchownSync(path, uid, gid)", "signature": "`fs.lchownSync(path, uid, gid)`", "apiSymbol": "fs.lchownSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fslchownsyncpath-uid-gid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fslchownsyncpath-uid-gid", "nodeStability": { "index": "2", "level": 2, @@ -28115,7 +28870,7 @@ "label": "fs.lutimesSync(path, atime, mtime)", "signature": "`fs.lutimesSync(path, atime, mtime)`", "apiSymbol": "fs.lutimesSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fslutimessyncpath-atime-mtime", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fslutimessyncpath-atime-mtime", "nodeStability": { "index": "2", "level": 2, @@ -28144,7 +28899,7 @@ "label": "fs.linkSync(existingPath, newPath)", "signature": "`fs.linkSync(existingPath, newPath)`", "apiSymbol": "fs.linkSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fslinksyncexistingpath-newpath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fslinksyncexistingpath-newpath", "nodeStability": { "index": "2", "level": 2, @@ -28174,7 +28929,7 @@ "label": "fs.lstatSync(path[, options])", "signature": "`fs.lstatSync(path[, options])`", "apiSymbol": "fs.lstatSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fslstatsyncpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fslstatsyncpath-options", "nodeStability": { "index": "2", "level": 2, @@ -28204,7 +28959,7 @@ "label": "fs.mkdirSync(path[, options])", "signature": "`fs.mkdirSync(path[, options])`", "apiSymbol": "fs.mkdirSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsmkdirsyncpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsmkdirsyncpath-options", "nodeStability": { "index": "2", "level": 2, @@ -28234,7 +28989,7 @@ "label": "fs.mkdtempSync(prefix[, options])", "signature": "`fs.mkdtempSync(prefix[, options])`", "apiSymbol": "fs.mkdtempSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsmkdtempsyncprefix-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsmkdtempsyncprefix-options", "nodeStability": { "index": "2", "level": 2, @@ -28264,7 +29019,7 @@ "label": "fs.mkdtempDisposableSync(prefix[, options])", "signature": "`fs.mkdtempDisposableSync(prefix[, options])`", "apiSymbol": "fs.mkdtempDisposableSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsmkdtempdisposablesyncprefix-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsmkdtempdisposablesyncprefix-options", "nodeStability": { "index": "2", "level": 2, @@ -28289,7 +29044,7 @@ "label": "fs.opendirSync(path[, options])", "signature": "`fs.opendirSync(path[, options])`", "apiSymbol": "fs.opendirSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsopendirsyncpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsopendirsyncpath-options", "nodeStability": { "index": "2", "level": 2, @@ -28314,7 +29069,7 @@ "label": "fs.openSync(path[, flags[, mode]])", "signature": "`fs.openSync(path[, flags[, mode]])`", "apiSymbol": "fs.openSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsopensyncpath-flags-mode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsopensyncpath-flags-mode", "nodeStability": { "index": "2", "level": 2, @@ -28344,7 +29099,7 @@ "label": "fs.readdirSync(path[, options])", "signature": "`fs.readdirSync(path[, options])`", "apiSymbol": "fs.readdirSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreaddirsyncpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreaddirsyncpath-options", "nodeStability": { "index": "2", "level": 2, @@ -28374,7 +29129,7 @@ "label": "fs.readFileSync(path[, options])", "signature": "`fs.readFileSync(path[, options])`", "apiSymbol": "fs.readFileSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreadfilesyncpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreadfilesyncpath-options", "nodeStability": { "index": "2", "level": 2, @@ -28405,7 +29160,7 @@ "label": "fs.readlinkSync(path[, options])", "signature": "`fs.readlinkSync(path[, options])`", "apiSymbol": "fs.readlinkSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreadlinksyncpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreadlinksyncpath-options", "nodeStability": { "index": "2", "level": 2, @@ -28435,7 +29190,7 @@ "label": "fs.readSync(fd, buffer, offset, length[, position])", "signature": "`fs.readSync(fd, buffer, offset, length[, position])`", "apiSymbol": "fs.readSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreadsyncfd-buffer-offset-length-position", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreadsyncfd-buffer-offset-length-position", "nodeStability": { "index": "2", "level": 2, @@ -28465,7 +29220,7 @@ "label": "fs.readSync(fd, buffer[, options])", "signature": "`fs.readSync(fd, buffer[, options])`", "apiSymbol": "fs.readSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreadsyncfd-buffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreadsyncfd-buffer-options", "nodeStability": { "index": "2", "level": 2, @@ -28495,7 +29250,7 @@ "label": "fs.readvSync(fd, buffers[, position])", "signature": "`fs.readvSync(fd, buffers[, position])`", "apiSymbol": "fs.readvSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsreadvsyncfd-buffers-position", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsreadvsyncfd-buffers-position", "nodeStability": { "index": "2", "level": 2, @@ -28522,7 +29277,7 @@ "label": "fs.realpathSync(path[, options])", "signature": "`fs.realpathSync(path[, options])`", "apiSymbol": "fs.realpathSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsrealpathsyncpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsrealpathsyncpath-options", "nodeStability": { "index": "2", "level": 2, @@ -28552,7 +29307,7 @@ "label": "fs.realpathSync.native(path[, options])", "signature": "`fs.realpathSync.native(path[, options])`", "apiSymbol": "fs.realpathSync.native", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsrealpathsyncnativepath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsrealpathsyncnativepath-options", "nodeStability": { "index": "2", "level": 2, @@ -28579,7 +29334,7 @@ "label": "fs.renameSync(oldPath, newPath)", "signature": "`fs.renameSync(oldPath, newPath)`", "apiSymbol": "fs.renameSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsrenamesyncoldpath-newpath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsrenamesyncoldpath-newpath", "nodeStability": { "index": "2", "level": 2, @@ -28609,7 +29364,7 @@ "label": "fs.rmdirSync(path[, options])", "signature": "`fs.rmdirSync(path[, options])`", "apiSymbol": "fs.rmdirSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsrmdirsyncpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsrmdirsyncpath-options", "nodeStability": { "index": "2", "level": 2, @@ -28639,7 +29394,7 @@ "label": "fs.rmSync(path[, options])", "signature": "`fs.rmSync(path[, options])`", "apiSymbol": "fs.rmSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsrmsyncpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsrmsyncpath-options", "nodeStability": { "index": "2", "level": 2, @@ -28669,7 +29424,7 @@ "label": "fs.statSync(path[, options])", "signature": "`fs.statSync(path[, options])`", "apiSymbol": "fs.statSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsstatsyncpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsstatsyncpath-options", "nodeStability": { "index": "2", "level": 2, @@ -28699,7 +29454,7 @@ "label": "fs.statfsSync(path[, options])", "signature": "`fs.statfsSync(path[, options])`", "apiSymbol": "fs.statfsSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsstatfssyncpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsstatfssyncpath-options", "nodeStability": { "index": "2", "level": 2, @@ -28729,7 +29484,7 @@ "label": "fs.symlinkSync(target, path[, type])", "signature": "`fs.symlinkSync(target, path[, type])`", "apiSymbol": "fs.symlinkSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fssymlinksynctarget-path-type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fssymlinksynctarget-path-type", "nodeStability": { "index": "2", "level": 2, @@ -28759,7 +29514,7 @@ "label": "fs.truncateSync(path[, len])", "signature": "`fs.truncateSync(path[, len])`", "apiSymbol": "fs.truncateSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fstruncatesyncpath-len", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fstruncatesyncpath-len", "nodeStability": { "index": "2", "level": 2, @@ -28784,7 +29539,7 @@ "label": "fs.unlinkSync(path)", "signature": "`fs.unlinkSync(path)`", "apiSymbol": "fs.unlinkSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsunlinksyncpath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsunlinksyncpath", "nodeStability": { "index": "2", "level": 2, @@ -28814,7 +29569,7 @@ "label": "fs.utimesSync(path, atime, mtime)", "signature": "`fs.utimesSync(path, atime, mtime)`", "apiSymbol": "fs.utimesSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fsutimessyncpath-atime-mtime", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fsutimessyncpath-atime-mtime", "nodeStability": { "index": "2", "level": 2, @@ -28843,7 +29598,7 @@ "label": "fs.writeFileSync(file, data[, options])", "signature": "`fs.writeFileSync(file, data[, options])`", "apiSymbol": "fs.writeFileSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fswritefilesyncfile-data-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fswritefilesyncfile-data-options", "nodeStability": { "index": "2", "level": 2, @@ -28873,7 +29628,7 @@ "label": "fs.writeSync(fd, buffer, offset[, length[, position]])", "signature": "`fs.writeSync(fd, buffer, offset[, length[, position]])`", "apiSymbol": "fs.writeSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fswritesyncfd-buffer-offset-length-position", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fswritesyncfd-buffer-offset-length-position", "nodeStability": { "index": "2", "level": 2, @@ -28903,7 +29658,7 @@ "label": "fs.writeSync(fd, buffer[, options])", "signature": "`fs.writeSync(fd, buffer[, options])`", "apiSymbol": "fs.writeSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fswritesyncfd-buffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fswritesyncfd-buffer-options", "nodeStability": { "index": "2", "level": 2, @@ -28933,7 +29688,7 @@ "label": "fs.writeSync(fd, string[, position[, encoding]])", "signature": "`fs.writeSync(fd, string[, position[, encoding]])`", "apiSymbol": "fs.writeSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fswritesyncfd-string-position-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fswritesyncfd-string-position-encoding", "nodeStability": { "index": "2", "level": 2, @@ -28963,7 +29718,7 @@ "label": "fs.writevSync(fd, buffers[, position])", "signature": "`fs.writevSync(fd, buffers[, position])`", "apiSymbol": "fs.writevSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#fswritevsyncfd-buffers-position", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#fswritevsyncfd-buffers-position", "nodeStability": { "index": "2", "level": 2, @@ -28990,7 +29745,7 @@ "label": "fs.Dir", "signature": "Class: `fs.Dir`", "apiSymbol": "fs.Dir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsdir", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsdir", "nodeStability": { "index": "2", "level": 2, @@ -29015,7 +29770,7 @@ "label": "dir.close()", "signature": "`dir.close()`", "apiSymbol": "dir.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#dirclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#dirclose", "nodeStability": { "index": "2", "level": 2, @@ -29040,7 +29795,7 @@ "label": "dir.close(callback)", "signature": "`dir.close(callback)`", "apiSymbol": "dir.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#dirclosecallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#dirclosecallback", "nodeStability": { "index": "2", "level": 2, @@ -29065,7 +29820,7 @@ "label": "dir.closeSync()", "signature": "`dir.closeSync()`", "apiSymbol": "dir.closeSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#dirclosesync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#dirclosesync", "nodeStability": { "index": "2", "level": 2, @@ -29090,7 +29845,7 @@ "label": "dir.read()", "signature": "`dir.read()`", "apiSymbol": "dir.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#dirread", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#dirread", "nodeStability": { "index": "2", "level": 2, @@ -29115,7 +29870,7 @@ "label": "dir.read(callback)", "signature": "`dir.read(callback)`", "apiSymbol": "dir.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#dirreadcallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#dirreadcallback", "nodeStability": { "index": "2", "level": 2, @@ -29140,7 +29895,7 @@ "label": "dir.readSync()", "signature": "`dir.readSync()`", "apiSymbol": "dir.readSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#dirreadsync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#dirreadsync", "nodeStability": { "index": "2", "level": 2, @@ -29165,7 +29920,7 @@ "label": "dir[Symbol.asyncIterator]()", "signature": "`dir[Symbol.asyncIterator]()`", "apiSymbol": "dir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#dirsymbolasynciterator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#dirsymbolasynciterator", "nodeStability": { "index": "2", "level": 2, @@ -29190,7 +29945,7 @@ "label": "dir[Symbol.asyncDispose]()", "signature": "`dir[Symbol.asyncDispose]()`", "apiSymbol": "dir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#dirsymbolasyncdispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#dirsymbolasyncdispose", "nodeStability": { "index": "2", "level": 2, @@ -29215,7 +29970,7 @@ "label": "dir[Symbol.dispose]()", "signature": "`dir[Symbol.dispose]()`", "apiSymbol": "dir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#dirsymboldispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#dirsymboldispose", "nodeStability": { "index": "2", "level": 2, @@ -29240,7 +29995,7 @@ "label": "path", "signature": "`path` Type: {string}", "apiSymbol": "path", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsdir", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsdir", "nodeStability": { "index": "2", "level": 2, @@ -29265,7 +30020,7 @@ "label": "fs.Dirent", "signature": "Class: `fs.Dirent`", "apiSymbol": "fs.Dirent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsdirent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsdirent", "nodeStability": { "index": "2", "level": 2, @@ -29290,7 +30045,7 @@ "label": "dirent.isBlockDevice()", "signature": "`dirent.isBlockDevice()`", "apiSymbol": "dirent.isBlockDevice", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#direntisblockdevice", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#direntisblockdevice", "nodeStability": { "index": "2", "level": 2, @@ -29315,7 +30070,7 @@ "label": "dirent.isCharacterDevice()", "signature": "`dirent.isCharacterDevice()`", "apiSymbol": "dirent.isCharacterDevice", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#direntischaracterdevice", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#direntischaracterdevice", "nodeStability": { "index": "2", "level": 2, @@ -29340,7 +30095,7 @@ "label": "dirent.isDirectory()", "signature": "`dirent.isDirectory()`", "apiSymbol": "dirent.isDirectory", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#direntisdirectory", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#direntisdirectory", "nodeStability": { "index": "2", "level": 2, @@ -29365,7 +30120,7 @@ "label": "dirent.isFIFO()", "signature": "`dirent.isFIFO()`", "apiSymbol": "dirent.isFIFO", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#direntisfifo", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#direntisfifo", "nodeStability": { "index": "2", "level": 2, @@ -29390,7 +30145,7 @@ "label": "dirent.isFile()", "signature": "`dirent.isFile()`", "apiSymbol": "dirent.isFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#direntisfile", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#direntisfile", "nodeStability": { "index": "2", "level": 2, @@ -29415,7 +30170,7 @@ "label": "dirent.isSocket()", "signature": "`dirent.isSocket()`", "apiSymbol": "dirent.isSocket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#direntissocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#direntissocket", "nodeStability": { "index": "2", "level": 2, @@ -29440,7 +30195,7 @@ "label": "dirent.isSymbolicLink()", "signature": "`dirent.isSymbolicLink()`", "apiSymbol": "dirent.isSymbolicLink", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#direntissymboliclink", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#direntissymboliclink", "nodeStability": { "index": "2", "level": 2, @@ -29465,7 +30220,7 @@ "label": "name", "signature": "`name` Type: {string|Buffer}", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsdirent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsdirent", "nodeStability": { "index": "2", "level": 2, @@ -29490,7 +30245,7 @@ "label": "parentPath", "signature": "`parentPath` Type: {string}", "apiSymbol": "parentPath", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsdirent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsdirent", "nodeStability": { "index": "2", "level": 2, @@ -29515,7 +30270,7 @@ "label": "fs.FSWatcher", "signature": "Class: `fs.FSWatcher`", "apiSymbol": "fs.FSWatcher", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsfswatcher", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsfswatcher", "nodeStability": { "index": "2", "level": 2, @@ -29540,7 +30295,7 @@ "label": "watcher.close()", "signature": "`watcher.close()`", "apiSymbol": "watcher.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#watcherclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#watcherclose", "nodeStability": { "index": "2", "level": 2, @@ -29565,7 +30320,7 @@ "label": "watcher.ref()", "signature": "`watcher.ref()`", "apiSymbol": "watcher.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#watcherref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#watcherref", "nodeStability": { "index": "2", "level": 2, @@ -29590,7 +30345,7 @@ "label": "watcher.unref()", "signature": "`watcher.unref()`", "apiSymbol": "watcher.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#watcherunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#watcherunref", "nodeStability": { "index": "2", "level": 2, @@ -29615,7 +30370,7 @@ "label": "'change'", "signature": "Event: `'change'`", "apiSymbol": "'change'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-change", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-change", "nodeStability": { "index": "2", "level": 2, @@ -29640,7 +30395,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-close_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-close_1", "nodeStability": { "index": "2", "level": 2, @@ -29665,7 +30420,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-error", "nodeStability": { "index": "2", "level": 2, @@ -29690,7 +30445,7 @@ "label": "fs.StatWatcher", "signature": "Class: `fs.StatWatcher`", "apiSymbol": "fs.StatWatcher", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstatwatcher", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstatwatcher", "nodeStability": { "index": "2", "level": 2, @@ -29715,7 +30470,7 @@ "label": "watcher.ref()", "signature": "`watcher.ref()`", "apiSymbol": "watcher.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#watcherref_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#watcherref_1", "nodeStability": { "index": "2", "level": 2, @@ -29740,7 +30495,7 @@ "label": "watcher.unref()", "signature": "`watcher.unref()`", "apiSymbol": "watcher.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#watcherunref_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#watcherunref_1", "nodeStability": { "index": "2", "level": 2, @@ -29765,7 +30520,7 @@ "label": "fs.ReadStream", "signature": "Class: `fs.ReadStream`", "apiSymbol": "fs.ReadStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsreadstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsreadstream", "nodeStability": { "index": "2", "level": 2, @@ -29790,7 +30545,7 @@ "label": "bytesRead", "signature": "`bytesRead` Type: {number}", "apiSymbol": "bytesRead", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsreadstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsreadstream", "nodeStability": { "index": "2", "level": 2, @@ -29815,7 +30570,7 @@ "label": "path", "signature": "`path` Type: {string|Buffer}", "apiSymbol": "path", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsreadstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsreadstream", "nodeStability": { "index": "2", "level": 2, @@ -29840,7 +30595,7 @@ "label": "pending", "signature": "`pending` Type: {boolean}", "apiSymbol": "pending", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsreadstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsreadstream", "nodeStability": { "index": "2", "level": 2, @@ -29865,7 +30620,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-close_2", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-close_2", "nodeStability": { "index": "2", "level": 2, @@ -29890,7 +30645,7 @@ "label": "'open'", "signature": "Event: `'open'`", "apiSymbol": "'open'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-open", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-open", "nodeStability": { "index": "2", "level": 2, @@ -29915,7 +30670,7 @@ "label": "'ready'", "signature": "Event: `'ready'`", "apiSymbol": "'ready'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-ready", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-ready", "nodeStability": { "index": "2", "level": 2, @@ -29940,7 +30695,7 @@ "label": "fs.Stats", "signature": "Class: `fs.Stats`", "apiSymbol": "fs.Stats", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -29965,7 +30720,7 @@ "label": "stats.isBlockDevice()", "signature": "`stats.isBlockDevice()`", "apiSymbol": "stats.isBlockDevice", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#statsisblockdevice", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#statsisblockdevice", "nodeStability": { "index": "2", "level": 2, @@ -29990,7 +30745,7 @@ "label": "stats.isCharacterDevice()", "signature": "`stats.isCharacterDevice()`", "apiSymbol": "stats.isCharacterDevice", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#statsischaracterdevice", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#statsischaracterdevice", "nodeStability": { "index": "2", "level": 2, @@ -30015,7 +30770,7 @@ "label": "stats.isDirectory()", "signature": "`stats.isDirectory()`", "apiSymbol": "stats.isDirectory", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#statsisdirectory", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#statsisdirectory", "nodeStability": { "index": "2", "level": 2, @@ -30040,7 +30795,7 @@ "label": "stats.isFIFO()", "signature": "`stats.isFIFO()`", "apiSymbol": "stats.isFIFO", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#statsisfifo", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#statsisfifo", "nodeStability": { "index": "2", "level": 2, @@ -30065,7 +30820,7 @@ "label": "stats.isFile()", "signature": "`stats.isFile()`", "apiSymbol": "stats.isFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#statsisfile", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#statsisfile", "nodeStability": { "index": "2", "level": 2, @@ -30090,7 +30845,7 @@ "label": "stats.isSocket()", "signature": "`stats.isSocket()`", "apiSymbol": "stats.isSocket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#statsissocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#statsissocket", "nodeStability": { "index": "2", "level": 2, @@ -30115,7 +30870,7 @@ "label": "stats.isSymbolicLink()", "signature": "`stats.isSymbolicLink()`", "apiSymbol": "stats.isSymbolicLink", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#statsissymboliclink", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#statsissymboliclink", "nodeStability": { "index": "2", "level": 2, @@ -30140,7 +30895,7 @@ "label": "dev", "signature": "`dev` Type: {number|bigint}", "apiSymbol": "dev", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30167,7 +30922,7 @@ "label": "ino", "signature": "`ino` Type: {number|bigint}", "apiSymbol": "ino", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30194,7 +30949,7 @@ "label": "mode", "signature": "`mode` Type: {number|bigint}", "apiSymbol": "mode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30219,7 +30974,7 @@ "label": "nlink", "signature": "`nlink` Type: {number|bigint}", "apiSymbol": "nlink", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30244,7 +30999,7 @@ "label": "uid", "signature": "`uid` Type: {number|bigint}", "apiSymbol": "uid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30269,7 +31024,7 @@ "label": "gid", "signature": "`gid` Type: {number|bigint}", "apiSymbol": "gid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30294,7 +31049,7 @@ "label": "rdev", "signature": "`rdev` Type: {number|bigint}", "apiSymbol": "rdev", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30319,7 +31074,7 @@ "label": "size", "signature": "`size` Type: {number|bigint}", "apiSymbol": "size", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30344,7 +31099,7 @@ "label": "blksize", "signature": "`blksize` Type: {number|bigint}", "apiSymbol": "blksize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30369,7 +31124,7 @@ "label": "blocks", "signature": "`blocks` Type: {number|bigint}", "apiSymbol": "blocks", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30394,7 +31149,7 @@ "label": "atimeMs", "signature": "`atimeMs` Type: {number|bigint}", "apiSymbol": "atimeMs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30419,7 +31174,7 @@ "label": "mtimeMs", "signature": "`mtimeMs` Type: {number|bigint}", "apiSymbol": "mtimeMs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30444,7 +31199,7 @@ "label": "ctimeMs", "signature": "`ctimeMs` Type: {number|bigint}", "apiSymbol": "ctimeMs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30471,7 +31226,7 @@ "label": "birthtimeMs", "signature": "`birthtimeMs` Type: {number|bigint}", "apiSymbol": "birthtimeMs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30496,7 +31251,7 @@ "label": "atimeNs", "signature": "`atimeNs` Type: {bigint}", "apiSymbol": "atimeNs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30521,7 +31276,7 @@ "label": "mtimeNs", "signature": "`mtimeNs` Type: {bigint}", "apiSymbol": "mtimeNs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30546,7 +31301,7 @@ "label": "ctimeNs", "signature": "`ctimeNs` Type: {bigint}", "apiSymbol": "ctimeNs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30571,7 +31326,7 @@ "label": "birthtimeNs", "signature": "`birthtimeNs` Type: {bigint}", "apiSymbol": "birthtimeNs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30596,7 +31351,7 @@ "label": "atime", "signature": "`atime` Type: {Date}", "apiSymbol": "atime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30621,7 +31376,7 @@ "label": "mtime", "signature": "`mtime` Type: {Date}", "apiSymbol": "mtime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30646,7 +31401,7 @@ "label": "ctime", "signature": "`ctime` Type: {Date}", "apiSymbol": "ctime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30671,7 +31426,7 @@ "label": "birthtime", "signature": "`birthtime` Type: {Date}", "apiSymbol": "birthtime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstats", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstats", "nodeStability": { "index": "2", "level": 2, @@ -30696,7 +31451,7 @@ "label": "fs.StatFs", "signature": "Class: `fs.StatFs`", "apiSymbol": "fs.StatFs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsstatfs", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstatfs", "nodeStability": { "index": "2", "level": 2, @@ -30719,13 +31474,38 @@ } } }, + { + "id": "fs:fc5a2ccba935", + "chapter": "fs", + "label": "frsize", + "signature": "`frsize` Type: {number|bigint}", + "apiSymbol": "frsize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsstatfs", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:fs", + "tests": [] + } + } + }, { "id": "fs:3616aeebdd25", "chapter": "fs", "label": "fs.Utf8Stream", "signature": "Class: `fs.Utf8Stream`", "apiSymbol": "fs.Utf8Stream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -30750,7 +31530,7 @@ "label": "utf8Stream.destroy()", "signature": "`utf8Stream.destroy()`", "apiSymbol": "utf8Stream.destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#utf8streamdestroy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#utf8streamdestroy", "nodeStability": { "index": "1", "level": 1, @@ -30775,7 +31555,7 @@ "label": "utf8Stream.end()", "signature": "`utf8Stream.end()`", "apiSymbol": "utf8Stream.end", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#utf8streamend", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#utf8streamend", "nodeStability": { "index": "1", "level": 1, @@ -30800,7 +31580,7 @@ "label": "utf8Stream.flush(callback)", "signature": "`utf8Stream.flush(callback)`", "apiSymbol": "utf8Stream.flush", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#utf8streamflushcallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#utf8streamflushcallback", "nodeStability": { "index": "1", "level": 1, @@ -30825,7 +31605,7 @@ "label": "utf8Stream.flushSync()", "signature": "`utf8Stream.flushSync()`", "apiSymbol": "utf8Stream.flushSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#utf8streamflushsync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#utf8streamflushsync", "nodeStability": { "index": "1", "level": 1, @@ -30850,7 +31630,7 @@ "label": "utf8Stream.reopen(file)", "signature": "`utf8Stream.reopen(file)`", "apiSymbol": "utf8Stream.reopen", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#utf8streamreopenfile", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#utf8streamreopenfile", "nodeStability": { "index": "1", "level": 1, @@ -30875,7 +31655,7 @@ "label": "utf8Stream.write(data)", "signature": "`utf8Stream.write(data)`", "apiSymbol": "utf8Stream.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#utf8streamwritedata", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#utf8streamwritedata", "nodeStability": { "index": "1", "level": 1, @@ -30900,7 +31680,7 @@ "label": "utf8Stream[Symbol.dispose]()", "signature": "`utf8Stream[Symbol.dispose]()`", "apiSymbol": "utf8Stream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#utf8streamsymboldispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#utf8streamsymboldispose", "nodeStability": { "index": "1", "level": 1, @@ -30925,7 +31705,7 @@ "label": "append", "signature": "`append` {boolean} Whether the stream is appending to the file or truncating it.", "apiSymbol": "append", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -30950,7 +31730,7 @@ "label": "contentMode", "signature": "`contentMode` {string} The type of data that can be written to the stream. Supported values are `'utf8'` or `'buffer'`. **Default**: `'utf8'`.", "apiSymbol": "contentMode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -30975,7 +31755,7 @@ "label": "fd", "signature": "`fd` {number} The file descriptor that is being written to.", "apiSymbol": "fd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -31000,7 +31780,7 @@ "label": "file", "signature": "`file` {string} The file that is being written to.", "apiSymbol": "file", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -31025,7 +31805,7 @@ "label": "fsync", "signature": "`fsync` {boolean} Whether the stream is performing a `fs.fsyncSync()` after every write operation.", "apiSymbol": "fsync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -31050,7 +31830,7 @@ "label": "maxLength", "signature": "`maxLength` {number} The maximum length of the internal buffer. If a write operation would cause the buffer to exceed `maxLength`, the data written is dropped and a drop event is emitted with the dropped data.", "apiSymbol": "maxLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -31075,7 +31855,7 @@ "label": "minLength", "signature": "`minLength` {number} The minimum length of the internal buffer that is required to be full before flushing.", "apiSymbol": "minLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -31100,7 +31880,7 @@ "label": "mkdir", "signature": "`mkdir` {boolean} Whether the stream should ensure that the directory for the `dest` file exists. If `true`, it will create the directory if it does not exist. **Default**: `false`.", "apiSymbol": "mkdir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -31125,7 +31905,7 @@ "label": "mode", "signature": "`mode` {number|string} The mode of the file that is being written to.", "apiSymbol": "mode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -31150,7 +31930,7 @@ "label": "periodicFlush", "signature": "`periodicFlush` {number} The number of milliseconds between flushes. If set to `0`, no periodic flushes will be performed.", "apiSymbol": "periodicFlush", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -31175,7 +31955,7 @@ "label": "sync", "signature": "`sync` {boolean} Whether the stream is writing synchronously or asynchronously.", "apiSymbol": "sync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -31200,7 +31980,7 @@ "label": "writing", "signature": "`writing` {boolean} Whether the stream is currently writing data to the file.", "apiSymbol": "writing", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fsutf8stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fsutf8stream", "nodeStability": { "index": "1", "level": 1, @@ -31225,7 +32005,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-close_3", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-close_3", "nodeStability": { "index": "1", "level": 1, @@ -31250,7 +32030,7 @@ "label": "'drain'", "signature": "Event: `'drain'`", "apiSymbol": "'drain'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-drain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-drain", "nodeStability": { "index": "1", "level": 1, @@ -31275,7 +32055,7 @@ "label": "'drop'", "signature": "Event: `'drop'`", "apiSymbol": "'drop'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-drop", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-drop", "nodeStability": { "index": "1", "level": 1, @@ -31300,7 +32080,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-error_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-error_1", "nodeStability": { "index": "1", "level": 1, @@ -31325,7 +32105,7 @@ "label": "'finish'", "signature": "Event: `'finish'`", "apiSymbol": "'finish'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-finish", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-finish", "nodeStability": { "index": "1", "level": 1, @@ -31350,7 +32130,7 @@ "label": "'ready'", "signature": "Event: `'ready'`", "apiSymbol": "'ready'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-ready_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-ready_1", "nodeStability": { "index": "1", "level": 1, @@ -31375,7 +32155,7 @@ "label": "'write'", "signature": "Event: `'write'`", "apiSymbol": "'write'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-write", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-write", "nodeStability": { "index": "1", "level": 1, @@ -31400,7 +32180,7 @@ "label": "fs.WriteStream", "signature": "Class: `fs.WriteStream`", "apiSymbol": "fs.WriteStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fswritestream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fswritestream", "nodeStability": { "index": "2", "level": 2, @@ -31425,7 +32205,7 @@ "label": "writeStream.close([callback])", "signature": "`writeStream.close([callback])`", "apiSymbol": "writeStream.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#writestreamclosecallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#writestreamclosecallback", "nodeStability": { "index": "2", "level": 2, @@ -31450,7 +32230,7 @@ "label": "writeStream.bytesWritten", "signature": "`writeStream.bytesWritten`", "apiSymbol": "writeStream.bytesWritten", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#writestreambyteswritten", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#writestreambyteswritten", "nodeStability": { "index": "2", "level": 2, @@ -31475,7 +32255,7 @@ "label": "writeStream.path", "signature": "`writeStream.path`", "apiSymbol": "writeStream.path", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#writestreampath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#writestreampath", "nodeStability": { "index": "2", "level": 2, @@ -31500,7 +32280,7 @@ "label": "pending", "signature": "`pending` Type: {boolean}", "apiSymbol": "pending", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#class-fswritestream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#class-fswritestream", "nodeStability": { "index": "2", "level": 2, @@ -31525,7 +32305,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-close_4", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-close_4", "nodeStability": { "index": "2", "level": 2, @@ -31550,7 +32330,7 @@ "label": "'open'", "signature": "Event: `'open'`", "apiSymbol": "'open'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-open_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-open_1", "nodeStability": { "index": "2", "level": 2, @@ -31575,7 +32355,7 @@ "label": "'ready'", "signature": "Event: `'ready'`", "apiSymbol": "'ready'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#event-ready_2", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#event-ready_2", "nodeStability": { "index": "2", "level": 2, @@ -31600,7 +32380,7 @@ "label": "constants", "signature": "`constants` Type: {Object}", "apiSymbol": "constants", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/fs.html#common-objects", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/fs.html#common-objects", "nodeStability": { "index": "2", "level": 2, @@ -31625,7 +32405,7 @@ "label": "AbortController", "signature": "Class: `AbortController`", "apiSymbol": "AbortController", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-abortcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-abortcontroller", "nodeStability": { "index": "2", "level": 2, @@ -31650,7 +32430,7 @@ "label": "abortController.abort([reason])", "signature": "`abortController.abort([reason])`", "apiSymbol": "abortController.abort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#abortcontrollerabortreason", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#abortcontrollerabortreason", "nodeStability": { "index": "2", "level": 2, @@ -31675,7 +32455,7 @@ "label": "signal", "signature": "`signal` Type: {AbortSignal}", "apiSymbol": "signal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-abortcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-abortcontroller", "nodeStability": { "index": "2", "level": 2, @@ -31700,7 +32480,7 @@ "label": "AbortSignal", "signature": "Class: `AbortSignal`", "apiSymbol": "AbortSignal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-abortsignal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-abortsignal", "nodeStability": { "index": "2", "level": 2, @@ -31725,7 +32505,7 @@ "label": "abortSignal.throwIfAborted()", "signature": "`abortSignal.throwIfAborted()`", "apiSymbol": "abortSignal.throwIfAborted", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#abortsignalthrowifaborted", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#abortsignalthrowifaborted", "nodeStability": { "index": "2", "level": 2, @@ -31750,7 +32530,7 @@ "label": "aborted", "signature": "`aborted` Type: {boolean}", "apiSymbol": "aborted", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-abortsignal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-abortsignal", "nodeStability": { "index": "2", "level": 2, @@ -31775,7 +32555,7 @@ "label": "onabort", "signature": "`onabort` Type: {Function}", "apiSymbol": "onabort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-abortsignal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-abortsignal", "nodeStability": { "index": "2", "level": 2, @@ -31800,7 +32580,7 @@ "label": "reason", "signature": "`reason` Type: {any}", "apiSymbol": "reason", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-abortsignal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-abortsignal", "nodeStability": { "index": "2", "level": 2, @@ -31825,7 +32605,7 @@ "label": "'abort'", "signature": "Event: `'abort'`", "apiSymbol": "'abort'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#event-abort", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#event-abort", "nodeStability": { "index": "2", "level": 2, @@ -31850,7 +32630,7 @@ "label": "Blob", "signature": "Class: `Blob`", "apiSymbol": "Blob", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-blob", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-blob", "nodeStability": { "index": "2", "level": 2, @@ -31875,7 +32655,7 @@ "label": "BroadcastChannel", "signature": "Class: `BroadcastChannel`", "apiSymbol": "BroadcastChannel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-broadcastchannel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-broadcastchannel", "nodeStability": { "index": "2", "level": 2, @@ -31900,7 +32680,7 @@ "label": "Buffer", "signature": "Class: `Buffer`", "apiSymbol": "Buffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-buffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-buffer", "nodeStability": { "index": "2", "level": 2, @@ -31925,7 +32705,7 @@ "label": "ByteLengthQueuingStrategy", "signature": "Class: `ByteLengthQueuingStrategy`", "apiSymbol": "ByteLengthQueuingStrategy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-bytelengthqueuingstrategy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-bytelengthqueuingstrategy", "nodeStability": { "index": "2", "level": 2, @@ -31950,7 +32730,7 @@ "label": "CloseEvent", "signature": "Class: `CloseEvent`", "apiSymbol": "CloseEvent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-closeevent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-closeevent", "nodeStability": { "index": "2", "level": 2, @@ -31975,7 +32755,7 @@ "label": "CompressionStream", "signature": "Class: `CompressionStream`", "apiSymbol": "CompressionStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-compressionstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-compressionstream", "nodeStability": { "index": "2", "level": 2, @@ -32000,7 +32780,7 @@ "label": "CountQueuingStrategy", "signature": "Class: `CountQueuingStrategy`", "apiSymbol": "CountQueuingStrategy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-countqueuingstrategy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-countqueuingstrategy", "nodeStability": { "index": "2", "level": 2, @@ -32025,7 +32805,7 @@ "label": "Crypto", "signature": "Class: `Crypto`", "apiSymbol": "Crypto", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-crypto", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-crypto", "nodeStability": { "index": "2", "level": 2, @@ -32050,7 +32830,7 @@ "label": "CryptoKey", "signature": "Class: `CryptoKey`", "apiSymbol": "CryptoKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-cryptokey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-cryptokey", "nodeStability": { "index": "2", "level": 2, @@ -32075,7 +32855,7 @@ "label": "CustomEvent", "signature": "Class: `CustomEvent`", "apiSymbol": "CustomEvent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-customevent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-customevent", "nodeStability": { "index": "2", "level": 2, @@ -32100,7 +32880,7 @@ "label": "DecompressionStream", "signature": "Class: `DecompressionStream`", "apiSymbol": "DecompressionStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-decompressionstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-decompressionstream", "nodeStability": { "index": "2", "level": 2, @@ -32125,7 +32905,7 @@ "label": "DOMException", "signature": "Class: `DOMException`", "apiSymbol": "DOMException", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-domexception", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-domexception", "nodeStability": { "index": "2", "level": 2, @@ -32150,7 +32930,7 @@ "label": "Event", "signature": "Class: `Event`", "apiSymbol": "Event", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-event", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-event", "nodeStability": { "index": "2", "level": 2, @@ -32175,7 +32955,7 @@ "label": "EventSource", "signature": "Class: `EventSource`", "apiSymbol": "EventSource", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-eventsource", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-eventsource", "nodeStability": { "index": "1", "level": 1, @@ -32200,7 +32980,7 @@ "label": "EventTarget", "signature": "Class: `EventTarget`", "apiSymbol": "EventTarget", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-eventtarget", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-eventtarget", "nodeStability": { "index": "2", "level": 2, @@ -32225,7 +33005,7 @@ "label": "File", "signature": "Class: `File`", "apiSymbol": "File", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-file", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-file", "nodeStability": { "index": "2", "level": 2, @@ -32250,7 +33030,7 @@ "label": "FormData", "signature": "Class: `FormData`", "apiSymbol": "FormData", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-formdata", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-formdata", "nodeStability": { "index": "2", "level": 2, @@ -32275,7 +33055,7 @@ "label": "Headers", "signature": "Class: `Headers`", "apiSymbol": "Headers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-headers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-headers", "nodeStability": { "index": "2", "level": 2, @@ -32300,7 +33080,7 @@ "label": "MessageChannel", "signature": "Class: `MessageChannel`", "apiSymbol": "MessageChannel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-messagechannel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-messagechannel", "nodeStability": { "index": "2", "level": 2, @@ -32325,7 +33105,7 @@ "label": "MessageEvent", "signature": "Class: `MessageEvent`", "apiSymbol": "MessageEvent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-messageevent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-messageevent", "nodeStability": { "index": "2", "level": 2, @@ -32350,7 +33130,7 @@ "label": "MessagePort", "signature": "Class: `MessagePort`", "apiSymbol": "MessagePort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-messageport", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-messageport", "nodeStability": { "index": "2", "level": 2, @@ -32375,7 +33155,7 @@ "label": "Navigator", "signature": "Class: `Navigator`", "apiSymbol": "Navigator", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-navigator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-navigator", "nodeStability": { "index": "1.1", "level": 1, @@ -32400,7 +33180,7 @@ "label": "PerformanceEntry", "signature": "Class: `PerformanceEntry`", "apiSymbol": "PerformanceEntry", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-performanceentry", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-performanceentry", "nodeStability": { "index": "2", "level": 2, @@ -32425,7 +33205,7 @@ "label": "PerformanceMark", "signature": "Class: `PerformanceMark`", "apiSymbol": "PerformanceMark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-performancemark", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-performancemark", "nodeStability": { "index": "2", "level": 2, @@ -32450,7 +33230,7 @@ "label": "PerformanceMeasure", "signature": "Class: `PerformanceMeasure`", "apiSymbol": "PerformanceMeasure", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-performancemeasure", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-performancemeasure", "nodeStability": { "index": "2", "level": 2, @@ -32475,7 +33255,7 @@ "label": "PerformanceObserver", "signature": "Class: `PerformanceObserver`", "apiSymbol": "PerformanceObserver", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-performanceobserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-performanceobserver", "nodeStability": { "index": "2", "level": 2, @@ -32500,7 +33280,7 @@ "label": "PerformanceObserverEntryList", "signature": "Class: `PerformanceObserverEntryList`", "apiSymbol": "PerformanceObserverEntryList", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-performanceobserverentrylist", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-performanceobserverentrylist", "nodeStability": { "index": "2", "level": 2, @@ -32525,7 +33305,7 @@ "label": "PerformanceResourceTiming", "signature": "Class: `PerformanceResourceTiming`", "apiSymbol": "PerformanceResourceTiming", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -32550,7 +33330,7 @@ "label": "ReadableByteStreamController", "signature": "Class: `ReadableByteStreamController`", "apiSymbol": "ReadableByteStreamController", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-readablebytestreamcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-readablebytestreamcontroller", "nodeStability": { "index": "2", "level": 2, @@ -32575,7 +33355,7 @@ "label": "ReadableStream", "signature": "Class: `ReadableStream`", "apiSymbol": "ReadableStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-readablestream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-readablestream", "nodeStability": { "index": "2", "level": 2, @@ -32600,7 +33380,7 @@ "label": "ReadableStreamBYOBReader", "signature": "Class: `ReadableStreamBYOBReader`", "apiSymbol": "ReadableStreamBYOBReader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-readablestreambyobreader", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-readablestreambyobreader", "nodeStability": { "index": "2", "level": 2, @@ -32625,7 +33405,7 @@ "label": "ReadableStreamBYOBRequest", "signature": "Class: `ReadableStreamBYOBRequest`", "apiSymbol": "ReadableStreamBYOBRequest", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-readablestreambyobrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-readablestreambyobrequest", "nodeStability": { "index": "2", "level": 2, @@ -32650,7 +33430,7 @@ "label": "ReadableStreamDefaultController", "signature": "Class: `ReadableStreamDefaultController`", "apiSymbol": "ReadableStreamDefaultController", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-readablestreamdefaultcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-readablestreamdefaultcontroller", "nodeStability": { "index": "2", "level": 2, @@ -32675,7 +33455,7 @@ "label": "ReadableStreamDefaultReader", "signature": "Class: `ReadableStreamDefaultReader`", "apiSymbol": "ReadableStreamDefaultReader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-readablestreamdefaultreader", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-readablestreamdefaultreader", "nodeStability": { "index": "2", "level": 2, @@ -32700,7 +33480,7 @@ "label": "Request", "signature": "Class: `Request`", "apiSymbol": "Request", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-request", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-request", "nodeStability": { "index": "2", "level": 2, @@ -32725,7 +33505,7 @@ "label": "Response", "signature": "Class: `Response`", "apiSymbol": "Response", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-response", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-response", "nodeStability": { "index": "2", "level": 2, @@ -32750,7 +33530,7 @@ "label": "Storage", "signature": "Class: `Storage`", "apiSymbol": "Storage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-storage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-storage", "nodeStability": { "index": "1.2", "level": 1, @@ -32775,7 +33555,7 @@ "label": "SubtleCrypto", "signature": "Class: `SubtleCrypto`", "apiSymbol": "SubtleCrypto", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-subtlecrypto", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-subtlecrypto", "nodeStability": { "index": "2", "level": 2, @@ -32800,7 +33580,7 @@ "label": "TextDecoder", "signature": "Class: `TextDecoder`", "apiSymbol": "TextDecoder", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-textdecoder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-textdecoder", "nodeStability": { "index": "2", "level": 2, @@ -32829,7 +33609,7 @@ "label": "TextDecoderStream", "signature": "Class: `TextDecoderStream`", "apiSymbol": "TextDecoderStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-textdecoderstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-textdecoderstream", "nodeStability": { "index": "2", "level": 2, @@ -32854,7 +33634,7 @@ "label": "TextEncoder", "signature": "Class: `TextEncoder`", "apiSymbol": "TextEncoder", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-textencoder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-textencoder", "nodeStability": { "index": "2", "level": 2, @@ -32883,7 +33663,7 @@ "label": "TextEncoderStream", "signature": "Class: `TextEncoderStream`", "apiSymbol": "TextEncoderStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-textencoderstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-textencoderstream", "nodeStability": { "index": "2", "level": 2, @@ -32908,7 +33688,7 @@ "label": "TransformStream", "signature": "Class: `TransformStream`", "apiSymbol": "TransformStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-transformstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-transformstream", "nodeStability": { "index": "2", "level": 2, @@ -32933,7 +33713,7 @@ "label": "TransformStreamDefaultController", "signature": "Class: `TransformStreamDefaultController`", "apiSymbol": "TransformStreamDefaultController", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-transformstreamdefaultcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-transformstreamdefaultcontroller", "nodeStability": { "index": "2", "level": 2, @@ -32958,7 +33738,7 @@ "label": "URL", "signature": "Class: `URL`", "apiSymbol": "URL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -32983,7 +33763,7 @@ "label": "URLPattern", "signature": "Class: `URLPattern`", "apiSymbol": "URLPattern", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-urlpattern", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-urlpattern", "nodeStability": { "index": "1", "level": 1, @@ -33008,7 +33788,7 @@ "label": "URLSearchParams", "signature": "Class: `URLSearchParams`", "apiSymbol": "URLSearchParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-urlsearchparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-urlsearchparams", "nodeStability": { "index": "2", "level": 2, @@ -33033,7 +33813,7 @@ "label": "WebAssembly", "signature": "Class: `WebAssembly`", "apiSymbol": "WebAssembly", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-webassembly", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-webassembly", "nodeStability": { "index": "2", "level": 2, @@ -33058,7 +33838,7 @@ "label": "WebSocket", "signature": "Class: `WebSocket`", "apiSymbol": "WebSocket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-websocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-websocket", "nodeStability": { "index": "2", "level": 2, @@ -33083,7 +33863,7 @@ "label": "WritableStream", "signature": "Class: `WritableStream`", "apiSymbol": "WritableStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-writablestream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-writablestream", "nodeStability": { "index": "2", "level": 2, @@ -33108,7 +33888,7 @@ "label": "WritableStreamDefaultController", "signature": "Class: `WritableStreamDefaultController`", "apiSymbol": "WritableStreamDefaultController", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-writablestreamdefaultcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-writablestreamdefaultcontroller", "nodeStability": { "index": "2", "level": 2, @@ -33133,7 +33913,7 @@ "label": "WritableStreamDefaultWriter", "signature": "Class: `WritableStreamDefaultWriter`", "apiSymbol": "WritableStreamDefaultWriter", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#class-writablestreamdefaultwriter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#class-writablestreamdefaultwriter", "nodeStability": { "index": "2", "level": 2, @@ -33158,7 +33938,7 @@ "label": "atob(data)", "signature": "`atob(data)`", "apiSymbol": "atob", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#atobdata", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#atobdata", "nodeStability": { "index": "3", "level": 3, @@ -33183,7 +33963,7 @@ "label": "btoa(data)", "signature": "`btoa(data)`", "apiSymbol": "btoa", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#btoadata", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#btoadata", "nodeStability": { "index": "3", "level": 3, @@ -33208,7 +33988,7 @@ "label": "clearImmediate(immediateObject)", "signature": "`clearImmediate(immediateObject)`", "apiSymbol": "clearImmediate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#clearimmediateimmediateobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#clearimmediateimmediateobject", "nodeStability": { "index": "2", "level": 2, @@ -33238,7 +34018,7 @@ "label": "clearInterval(intervalObject)", "signature": "`clearInterval(intervalObject)`", "apiSymbol": "clearInterval", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#clearintervalintervalobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#clearintervalintervalobject", "nodeStability": { "index": "2", "level": 2, @@ -33268,7 +34048,7 @@ "label": "clearTimeout(timeoutObject)", "signature": "`clearTimeout(timeoutObject)`", "apiSymbol": "clearTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#cleartimeouttimeoutobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#cleartimeouttimeoutobject", "nodeStability": { "index": "2", "level": 2, @@ -33298,7 +34078,7 @@ "label": "queueMicrotask(callback)", "signature": "`queueMicrotask(callback)`", "apiSymbol": "queueMicrotask", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#queuemicrotaskcallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#queuemicrotaskcallback", "nodeStability": { "index": "2", "level": 2, @@ -33323,7 +34103,7 @@ "label": "require()", "signature": "`require()`", "apiSymbol": "require", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#require", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#require", "nodeStability": { "index": "2", "level": 2, @@ -33348,7 +34128,7 @@ "label": "setImmediate(callback[, ...args])", "signature": "`setImmediate(callback[, ...args])`", "apiSymbol": "setImmediate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#setimmediatecallback-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#setimmediatecallback-args", "nodeStability": { "index": "2", "level": 2, @@ -33378,7 +34158,7 @@ "label": "setInterval(callback, delay[, ...args])", "signature": "`setInterval(callback, delay[, ...args])`", "apiSymbol": "setInterval", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#setintervalcallback-delay-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#setintervalcallback-delay-args", "nodeStability": { "index": "2", "level": 2, @@ -33408,7 +34188,7 @@ "label": "setTimeout(callback, delay[, ...args])", "signature": "`setTimeout(callback, delay[, ...args])`", "apiSymbol": "setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#settimeoutcallback-delay-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#settimeoutcallback-delay-args", "nodeStability": { "index": "2", "level": 2, @@ -33438,7 +34218,7 @@ "label": "structuredClone(value[, options])", "signature": "`structuredClone(value[, options])`", "apiSymbol": "structuredClone", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#structuredclonevalue-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#structuredclonevalue-options", "nodeStability": { "index": "2", "level": 2, @@ -33463,7 +34243,7 @@ "label": "__dirname", "signature": "`__dirname`", "apiSymbol": "__dirname", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#__dirname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#__dirname", "nodeStability": { "index": "2", "level": 2, @@ -33488,7 +34268,7 @@ "label": "__filename", "signature": "`__filename`", "apiSymbol": "__filename", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#__filename", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#__filename", "nodeStability": { "index": "2", "level": 2, @@ -33513,7 +34293,7 @@ "label": "console", "signature": "`console`", "apiSymbol": "console", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#console", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#console", "nodeStability": { "index": "2", "level": 2, @@ -33538,7 +34318,7 @@ "label": "crypto", "signature": "`crypto`", "apiSymbol": "crypto", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#crypto", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#crypto", "nodeStability": { "index": "2", "level": 2, @@ -33563,7 +34343,7 @@ "label": "exports", "signature": "`exports`", "apiSymbol": "exports", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#exports", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#exports", "nodeStability": { "index": "2", "level": 2, @@ -33588,7 +34368,7 @@ "label": "fetch", "signature": "`fetch`", "apiSymbol": "fetch", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#fetch", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#fetch", "nodeStability": { "index": "2", "level": 2, @@ -33615,7 +34395,7 @@ "label": "global", "signature": "`global`", "apiSymbol": "global", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#global", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#global", "nodeStability": { "index": "3", "level": 3, @@ -33640,7 +34420,7 @@ "label": "localStorage", "signature": "`localStorage`", "apiSymbol": "localStorage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#localstorage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#localstorage", "nodeStability": { "index": "1.2", "level": 1, @@ -33665,7 +34445,7 @@ "label": "module", "signature": "`module`", "apiSymbol": "module", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#module", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#module", "nodeStability": { "index": "2", "level": 2, @@ -33690,7 +34470,7 @@ "label": "navigator", "signature": "`navigator`", "apiSymbol": "navigator", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#navigator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#navigator", "nodeStability": { "index": "1.1", "level": 1, @@ -33715,7 +34495,7 @@ "label": "hardwareConcurrency", "signature": "`hardwareConcurrency` Type: {number}", "apiSymbol": "hardwareConcurrency", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#navigator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#navigator", "nodeStability": { "index": "1.1", "level": 1, @@ -33740,7 +34520,7 @@ "label": "language", "signature": "`language` Type: {string}", "apiSymbol": "language", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#navigator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#navigator", "nodeStability": { "index": "1.1", "level": 1, @@ -33765,7 +34545,7 @@ "label": "languages", "signature": "`languages` Type: {string\\[]}", "apiSymbol": "languages", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#navigator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#navigator", "nodeStability": { "index": "1.1", "level": 1, @@ -33790,7 +34570,7 @@ "label": "navigator.locks", "signature": "`navigator.locks`", "apiSymbol": "navigator.locks", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#navigatorlocks", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#navigatorlocks", "nodeStability": { "index": "1", "level": 1, @@ -33815,7 +34595,7 @@ "label": "platform", "signature": "`platform` Type: {string}", "apiSymbol": "platform", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#navigator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#navigator", "nodeStability": { "index": "1.1", "level": 1, @@ -33840,7 +34620,7 @@ "label": "userAgent", "signature": "`userAgent` Type: {string}", "apiSymbol": "userAgent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#navigator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#navigator", "nodeStability": { "index": "1.1", "level": 1, @@ -33865,7 +34645,7 @@ "label": "performance", "signature": "`performance`", "apiSymbol": "performance", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#performance", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#performance", "nodeStability": { "index": "2", "level": 2, @@ -33890,7 +34670,7 @@ "label": "process", "signature": "`process`", "apiSymbol": "process", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#process", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#process", "nodeStability": { "index": "2", "level": 2, @@ -33915,7 +34695,7 @@ "label": "sessionStorage", "signature": "`sessionStorage`", "apiSymbol": "sessionStorage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/globals.html#sessionstorage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/globals.html#sessionstorage", "nodeStability": { "index": "1.2", "level": 1, @@ -33940,7 +34720,7 @@ "label": "NO_PROXY", "signature": "`NO_PROXY` Format", "apiSymbol": "NO_PROXY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#no_proxy-format", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#no_proxy-format", "nodeStability": { "index": "1.1", "level": 1, @@ -33965,7 +34745,7 @@ "label": "http.Agent", "signature": "Class: `http.Agent`", "apiSymbol": "http.Agent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpagent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpagent", "nodeStability": { "index": "2", "level": 2, @@ -33992,7 +34772,7 @@ "label": "agent.createConnection(options[, callback])", "signature": "`agent.createConnection(options[, callback])`", "apiSymbol": "agent.createConnection", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#agentcreateconnectionoptions-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#agentcreateconnectionoptions-callback", "nodeStability": { "index": "2", "level": 2, @@ -34017,7 +34797,7 @@ "label": "agent.keepSocketAlive(socket)", "signature": "`agent.keepSocketAlive(socket)`", "apiSymbol": "agent.keepSocketAlive", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#agentkeepsocketalivesocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#agentkeepsocketalivesocket", "nodeStability": { "index": "2", "level": 2, @@ -34042,7 +34822,7 @@ "label": "agent.reuseSocket(socket, request)", "signature": "`agent.reuseSocket(socket, request)`", "apiSymbol": "agent.reuseSocket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#agentreusesocketsocket-request", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#agentreusesocketsocket-request", "nodeStability": { "index": "2", "level": 2, @@ -34067,7 +34847,7 @@ "label": "agent.destroy()", "signature": "`agent.destroy()`", "apiSymbol": "agent.destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#agentdestroy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#agentdestroy", "nodeStability": { "index": "2", "level": 2, @@ -34094,7 +34874,7 @@ "label": "agent.getName([options])", "signature": "`agent.getName([options])`", "apiSymbol": "agent.getName", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#agentgetnameoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#agentgetnameoptions", "nodeStability": { "index": "2", "level": 2, @@ -34121,7 +34901,7 @@ "label": "freeSockets", "signature": "`freeSockets` Type: {Object}", "apiSymbol": "freeSockets", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpagent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpagent", "nodeStability": { "index": "2", "level": 2, @@ -34148,7 +34928,7 @@ "label": "maxFreeSockets", "signature": "`maxFreeSockets` Type: {number}", "apiSymbol": "maxFreeSockets", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpagent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpagent", "nodeStability": { "index": "2", "level": 2, @@ -34175,7 +34955,7 @@ "label": "maxSockets", "signature": "`maxSockets` Type: {number}", "apiSymbol": "maxSockets", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpagent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpagent", "nodeStability": { "index": "2", "level": 2, @@ -34202,7 +34982,7 @@ "label": "maxTotalSockets", "signature": "`maxTotalSockets` Type: {number}", "apiSymbol": "maxTotalSockets", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpagent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpagent", "nodeStability": { "index": "2", "level": 2, @@ -34227,7 +35007,7 @@ "label": "requests", "signature": "`requests` Type: {Object}", "apiSymbol": "requests", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpagent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpagent", "nodeStability": { "index": "2", "level": 2, @@ -34254,7 +35034,7 @@ "label": "sockets", "signature": "`sockets` Type: {Object}", "apiSymbol": "sockets", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpagent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpagent", "nodeStability": { "index": "2", "level": 2, @@ -34281,7 +35061,7 @@ "label": "http.ClientRequest", "signature": "Class: `http.ClientRequest`", "apiSymbol": "http.ClientRequest", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "2", "level": 2, @@ -34309,7 +35089,7 @@ "label": "request.abort()", "signature": "`request.abort()`", "apiSymbol": "request.abort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestabort", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestabort", "nodeStability": { "index": "0", "level": 0, @@ -34336,7 +35116,7 @@ "label": "request.cork()", "signature": "`request.cork()`", "apiSymbol": "request.cork", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestcork", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestcork", "nodeStability": { "index": "2", "level": 2, @@ -34367,7 +35147,7 @@ "label": "request.end([data[, encoding]][, callback])", "signature": "`request.end([data[, encoding]][, callback])`", "apiSymbol": "request.end", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestenddata-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestenddata-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -34396,7 +35176,7 @@ "label": "request.destroy([error])", "signature": "`request.destroy([error])`", "apiSymbol": "request.destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestdestroyerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestdestroyerror", "nodeStability": { "index": "2", "level": 2, @@ -34425,7 +35205,7 @@ "label": "destroyed", "signature": "`destroyed` Type: {boolean}", "apiSymbol": "destroyed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestdestroyerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestdestroyerror", "nodeStability": { "index": "2", "level": 2, @@ -34453,7 +35233,7 @@ "label": "request.flushHeaders()", "signature": "`request.flushHeaders()`", "apiSymbol": "request.flushHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestflushheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestflushheaders", "nodeStability": { "index": "2", "level": 2, @@ -34484,7 +35264,7 @@ "label": "request.getHeader(name)", "signature": "`request.getHeader(name)`", "apiSymbol": "request.getHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestgetheadername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestgetheadername", "nodeStability": { "index": "2", "level": 2, @@ -34511,7 +35291,7 @@ "label": "request.getHeaderNames()", "signature": "`request.getHeaderNames()`", "apiSymbol": "request.getHeaderNames", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestgetheadernames", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestgetheadernames", "nodeStability": { "index": "2", "level": 2, @@ -34538,7 +35318,7 @@ "label": "request.getHeaders()", "signature": "`request.getHeaders()`", "apiSymbol": "request.getHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestgetheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestgetheaders", "nodeStability": { "index": "2", "level": 2, @@ -34565,7 +35345,7 @@ "label": "request.getRawHeaderNames()", "signature": "`request.getRawHeaderNames()`", "apiSymbol": "request.getRawHeaderNames", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestgetrawheadernames", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestgetrawheadernames", "nodeStability": { "index": "2", "level": 2, @@ -34592,7 +35372,7 @@ "label": "request.hasHeader(name)", "signature": "`request.hasHeader(name)`", "apiSymbol": "request.hasHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requesthasheadername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requesthasheadername", "nodeStability": { "index": "2", "level": 2, @@ -34619,7 +35399,7 @@ "label": "request.removeHeader(name)", "signature": "`request.removeHeader(name)`", "apiSymbol": "request.removeHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestremoveheadername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestremoveheadername", "nodeStability": { "index": "2", "level": 2, @@ -34646,7 +35426,7 @@ "label": "request.setHeader(name, value)", "signature": "`request.setHeader(name, value)`", "apiSymbol": "request.setHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestsetheadername-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestsetheadername-value", "nodeStability": { "index": "2", "level": 2, @@ -34673,7 +35453,7 @@ "label": "request.setNoDelay([noDelay])", "signature": "`request.setNoDelay([noDelay])`", "apiSymbol": "request.setNoDelay", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestsetnodelaynodelay", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestsetnodelaynodelay", "nodeStability": { "index": "2", "level": 2, @@ -34700,7 +35480,7 @@ "label": "request.setSocketKeepAlive([enable][, initialDelay])", "signature": "`request.setSocketKeepAlive([enable][, initialDelay])`", "apiSymbol": "request.setSocketKeepAlive", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestsetsocketkeepaliveenable-initialdelay", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestsetsocketkeepaliveenable-initialdelay", "nodeStability": { "index": "2", "level": 2, @@ -34728,7 +35508,7 @@ "label": "request.setTimeout(timeout[, callback])", "signature": "`request.setTimeout(timeout[, callback])`", "apiSymbol": "request.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestsettimeouttimeout-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestsettimeouttimeout-callback", "nodeStability": { "index": "2", "level": 2, @@ -34756,7 +35536,7 @@ "label": "request.uncork()", "signature": "`request.uncork()`", "apiSymbol": "request.uncork", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestuncork", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestuncork", "nodeStability": { "index": "2", "level": 2, @@ -34787,7 +35567,7 @@ "label": "request.write(chunk[, encoding][, callback])", "signature": "`request.write(chunk[, encoding][, callback])`", "apiSymbol": "request.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#requestwritechunk-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#requestwritechunk-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -34816,7 +35596,7 @@ "label": "aborted", "signature": "`aborted` Type: {boolean}", "apiSymbol": "aborted", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "0", "level": 0, @@ -34843,7 +35623,7 @@ "label": "connection", "signature": "`connection` Type: {stream.Duplex}", "apiSymbol": "connection", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "0", "level": 0, @@ -34870,7 +35650,7 @@ "label": "finished", "signature": "`finished` Type: {boolean}", "apiSymbol": "finished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "0", "level": 0, @@ -34892,12 +35672,12 @@ } }, { - "id": "http:faf8578bc834", + "id": "http:3ec3b8b2efa8", "chapter": "http", "label": "maxHeadersCount", - "signature": "`maxHeadersCount` Type: {number} **Default:** `2000`", + "signature": "`maxHeadersCount` Type: {number} **Default:** `1000`", "apiSymbol": "maxHeadersCount", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "2", "level": 2, @@ -34922,7 +35702,7 @@ "label": "path", "signature": "`path` Type: {string} The request path.", "apiSymbol": "path", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "2", "level": 2, @@ -34949,7 +35729,7 @@ "label": "method", "signature": "`method` Type: {string} The request method.", "apiSymbol": "method", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "2", "level": 2, @@ -34976,7 +35756,7 @@ "label": "host", "signature": "`host` Type: {string} The request host.", "apiSymbol": "host", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "2", "level": 2, @@ -35003,7 +35783,7 @@ "label": "protocol", "signature": "`protocol` Type: {string} The request protocol.", "apiSymbol": "protocol", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "2", "level": 2, @@ -35025,12 +35805,12 @@ } }, { - "id": "http:9ca269feac75", + "id": "http:e7028cb19b03", "chapter": "http", "label": "reusedSocket", - "signature": "`reusedSocket` Type: {boolean} Whether the request is send through a reused socket.", + "signature": "`reusedSocket` Type: {boolean} Whether the request is sent through a reused socket.", "apiSymbol": "reusedSocket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "2", "level": 2, @@ -35057,7 +35837,7 @@ "label": "socket", "signature": "`socket` Type: {stream.Duplex}", "apiSymbol": "socket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "2", "level": 2, @@ -35084,7 +35864,7 @@ "label": "writableEnded", "signature": "`writableEnded` Type: {boolean}", "apiSymbol": "writableEnded", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "2", "level": 2, @@ -35111,7 +35891,7 @@ "label": "writableFinished", "signature": "`writableFinished` Type: {boolean}", "apiSymbol": "writableFinished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpclientrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpclientrequest", "nodeStability": { "index": "2", "level": 2, @@ -35138,7 +35918,7 @@ "label": "'abort'", "signature": "Event: `'abort'`", "apiSymbol": "'abort'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-abort", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-abort", "nodeStability": { "index": "0", "level": 0, @@ -35165,7 +35945,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-close", "nodeStability": { "index": "2", "level": 2, @@ -35192,7 +35972,7 @@ "label": "'connect'", "signature": "Event: `'connect'`", "apiSymbol": "'connect'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-connect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-connect", "nodeStability": { "index": "2", "level": 2, @@ -35217,7 +35997,7 @@ "label": "'continue'", "signature": "Event: `'continue'`", "apiSymbol": "'continue'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-continue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-continue", "nodeStability": { "index": "2", "level": 2, @@ -35242,7 +36022,7 @@ "label": "'finish'", "signature": "Event: `'finish'`", "apiSymbol": "'finish'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-finish", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-finish", "nodeStability": { "index": "2", "level": 2, @@ -35269,7 +36049,7 @@ "label": "'information'", "signature": "Event: `'information'`", "apiSymbol": "'information'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-information", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-information", "nodeStability": { "index": "2", "level": 2, @@ -35294,7 +36074,7 @@ "label": "'response'", "signature": "Event: `'response'`", "apiSymbol": "'response'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-response", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-response", "nodeStability": { "index": "2", "level": 2, @@ -35321,7 +36101,7 @@ "label": "'socket'", "signature": "Event: `'socket'`", "apiSymbol": "'socket'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-socket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-socket", "nodeStability": { "index": "2", "level": 2, @@ -35348,7 +36128,7 @@ "label": "'timeout'", "signature": "Event: `'timeout'`", "apiSymbol": "'timeout'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-timeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-timeout", "nodeStability": { "index": "2", "level": 2, @@ -35376,7 +36156,7 @@ "label": "'upgrade'", "signature": "Event: `'upgrade'`", "apiSymbol": "'upgrade'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-upgrade", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-upgrade", "nodeStability": { "index": "2", "level": 2, @@ -35403,7 +36183,7 @@ "label": "http.Server", "signature": "Class: `http.Server`", "apiSymbol": "http.Server", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserver", "nodeStability": { "index": "2", "level": 2, @@ -35431,7 +36211,7 @@ "label": "server.close([callback])", "signature": "`server.close([callback])`", "apiSymbol": "server.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#serverclosecallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#serverclosecallback", "nodeStability": { "index": "2", "level": 2, @@ -35459,7 +36239,7 @@ "label": "server.closeAllConnections()", "signature": "`server.closeAllConnections()`", "apiSymbol": "server.closeAllConnections", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#servercloseallconnections", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#servercloseallconnections", "nodeStability": { "index": "2", "level": 2, @@ -35488,7 +36268,7 @@ "label": "server.closeIdleConnections()", "signature": "`server.closeIdleConnections()`", "apiSymbol": "server.closeIdleConnections", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#servercloseidleconnections", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#servercloseidleconnections", "nodeStability": { "index": "2", "level": 2, @@ -35517,7 +36297,7 @@ "label": "server.listen()", "signature": "`server.listen()`", "apiSymbol": "server.listen", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#serverlisten", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#serverlisten", "nodeStability": { "index": "2", "level": 2, @@ -35545,7 +36325,7 @@ "label": "server.setTimeout([msecs][, callback])", "signature": "`server.setTimeout([msecs][, callback])`", "apiSymbol": "server.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#serversettimeoutmsecs-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#serversettimeoutmsecs-callback", "nodeStability": { "index": "2", "level": 2, @@ -35573,7 +36353,7 @@ "label": "server[Symbol.asyncDispose]()", "signature": "`server[Symbol.asyncDispose]()`", "apiSymbol": "server", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#serversymbolasyncdispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#serversymbolasyncdispose", "nodeStability": { "index": "2", "level": 2, @@ -35598,7 +36378,7 @@ "label": "headersTimeout", "signature": "`headersTimeout` Type: {number} **Default:** The minimum between [`server.requestTimeout`][] or `60000`.", "apiSymbol": "headersTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserver", "nodeStability": { "index": "2", "level": 2, @@ -35627,7 +36407,7 @@ "label": "listening", "signature": "`listening` Type: {boolean} Indicates whether or not the server is listening for connections.", "apiSymbol": "listening", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserver", "nodeStability": { "index": "2", "level": 2, @@ -35649,12 +36429,12 @@ } }, { - "id": "http:2b341e7f7ddb", + "id": "http:d2aac123456e", "chapter": "http", "label": "maxHeadersCount", - "signature": "`maxHeadersCount` Type: {number} **Default:** `2000`", + "signature": "`maxHeadersCount` Type: {number} **Default:** `1000`", "apiSymbol": "maxHeadersCount", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserver", "nodeStability": { "index": "2", "level": 2, @@ -35679,7 +36459,7 @@ "label": "requestTimeout", "signature": "`requestTimeout` Type: {number} **Default:** `300000`", "apiSymbol": "requestTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserver", "nodeStability": { "index": "2", "level": 2, @@ -35708,7 +36488,7 @@ "label": "maxRequestsPerSocket", "signature": "`maxRequestsPerSocket` Type: {number} Requests per socket. **Default:** 0 (no limit)", "apiSymbol": "maxRequestsPerSocket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserver", "nodeStability": { "index": "2", "level": 2, @@ -35733,7 +36513,7 @@ "label": "timeout", "signature": "`timeout` Type: {number} Timeout in milliseconds. **Default:** 0 (no timeout)", "apiSymbol": "timeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserver", "nodeStability": { "index": "2", "level": 2, @@ -35762,7 +36542,7 @@ "label": "keepAliveTimeout", "signature": "`keepAliveTimeout` Type: {number} Timeout in milliseconds. **Default:** `5000` (5 seconds).", "apiSymbol": "keepAliveTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserver", "nodeStability": { "index": "2", "level": 2, @@ -35791,7 +36571,7 @@ "label": "keepAliveTimeoutBuffer", "signature": "`keepAliveTimeoutBuffer` Type: {number} Timeout in milliseconds. **Default:** `1000` (1 second).", "apiSymbol": "keepAliveTimeoutBuffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserver", "nodeStability": { "index": "2", "level": 2, @@ -35820,7 +36600,7 @@ "label": "'checkContinue'", "signature": "Event: `'checkContinue'`", "apiSymbol": "'checkContinue'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-checkcontinue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-checkcontinue", "nodeStability": { "index": "2", "level": 2, @@ -35845,7 +36625,7 @@ "label": "'checkExpectation'", "signature": "Event: `'checkExpectation'`", "apiSymbol": "'checkExpectation'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-checkexpectation", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-checkexpectation", "nodeStability": { "index": "2", "level": 2, @@ -35870,7 +36650,7 @@ "label": "'clientError'", "signature": "Event: `'clientError'`", "apiSymbol": "'clientError'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-clienterror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-clienterror", "nodeStability": { "index": "2", "level": 2, @@ -35895,7 +36675,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-close_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-close_1", "nodeStability": { "index": "2", "level": 2, @@ -35922,7 +36702,7 @@ "label": "'connect'", "signature": "Event: `'connect'`", "apiSymbol": "'connect'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-connect_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-connect_1", "nodeStability": { "index": "2", "level": 2, @@ -35949,7 +36729,7 @@ "label": "'connection'", "signature": "Event: `'connection'`", "apiSymbol": "'connection'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-connection", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-connection", "nodeStability": { "index": "2", "level": 2, @@ -35976,7 +36756,7 @@ "label": "'dropRequest'", "signature": "Event: `'dropRequest'`", "apiSymbol": "'dropRequest'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-droprequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-droprequest", "nodeStability": { "index": "2", "level": 2, @@ -36001,7 +36781,7 @@ "label": "'request'", "signature": "Event: `'request'`", "apiSymbol": "'request'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-request", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-request", "nodeStability": { "index": "2", "level": 2, @@ -36028,7 +36808,7 @@ "label": "'upgrade'", "signature": "Event: `'upgrade'`", "apiSymbol": "'upgrade'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-upgrade_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-upgrade_1", "nodeStability": { "index": "2", "level": 2, @@ -36055,7 +36835,7 @@ "label": "http.ServerResponse", "signature": "Class: `http.ServerResponse`", "apiSymbol": "http.ServerResponse", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserverresponse", "nodeStability": { "index": "2", "level": 2, @@ -36083,7 +36863,7 @@ "label": "response.addTrailers(headers)", "signature": "`response.addTrailers(headers)`", "apiSymbol": "response.addTrailers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responseaddtrailersheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responseaddtrailersheaders", "nodeStability": { "index": "2", "level": 2, @@ -36114,7 +36894,7 @@ "label": "response.cork()", "signature": "`response.cork()`", "apiSymbol": "response.cork", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responsecork", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsecork", "nodeStability": { "index": "2", "level": 2, @@ -36145,7 +36925,7 @@ "label": "response.end([data[, encoding]][, callback])", "signature": "`response.end([data[, encoding]][, callback])`", "apiSymbol": "response.end", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responseenddata-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responseenddata-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -36174,7 +36954,7 @@ "label": "response.flushHeaders()", "signature": "`response.flushHeaders()`", "apiSymbol": "response.flushHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responseflushheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responseflushheaders", "nodeStability": { "index": "2", "level": 2, @@ -36205,7 +36985,7 @@ "label": "response.getHeader(name)", "signature": "`response.getHeader(name)`", "apiSymbol": "response.getHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responsegetheadername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsegetheadername", "nodeStability": { "index": "2", "level": 2, @@ -36234,7 +37014,7 @@ "label": "response.getHeaderNames()", "signature": "`response.getHeaderNames()`", "apiSymbol": "response.getHeaderNames", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responsegetheadernames", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsegetheadernames", "nodeStability": { "index": "2", "level": 2, @@ -36261,7 +37041,7 @@ "label": "response.getHeaders()", "signature": "`response.getHeaders()`", "apiSymbol": "response.getHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responsegetheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsegetheaders", "nodeStability": { "index": "2", "level": 2, @@ -36288,7 +37068,7 @@ "label": "response.hasHeader(name)", "signature": "`response.hasHeader(name)`", "apiSymbol": "response.hasHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responsehasheadername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsehasheadername", "nodeStability": { "index": "2", "level": 2, @@ -36317,7 +37097,7 @@ "label": "response.removeHeader(name)", "signature": "`response.removeHeader(name)`", "apiSymbol": "response.removeHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responseremoveheadername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responseremoveheadername", "nodeStability": { "index": "2", "level": 2, @@ -36346,7 +37126,7 @@ "label": "response.setHeader(name, value)", "signature": "`response.setHeader(name, value)`", "apiSymbol": "response.setHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responsesetheadername-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsesetheadername-value", "nodeStability": { "index": "2", "level": 2, @@ -36375,7 +37155,7 @@ "label": "response.setTimeout(msecs[, callback])", "signature": "`response.setTimeout(msecs[, callback])`", "apiSymbol": "response.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responsesettimeoutmsecs-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsesettimeoutmsecs-callback", "nodeStability": { "index": "2", "level": 2, @@ -36402,7 +37182,7 @@ "label": "response.uncork()", "signature": "`response.uncork()`", "apiSymbol": "response.uncork", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responseuncork", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responseuncork", "nodeStability": { "index": "2", "level": 2, @@ -36433,7 +37213,7 @@ "label": "response.write(chunk[, encoding][, callback])", "signature": "`response.write(chunk[, encoding][, callback])`", "apiSymbol": "response.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responsewritechunk-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsewritechunk-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -36462,7 +37242,7 @@ "label": "response.writeContinue()", "signature": "`response.writeContinue()`", "apiSymbol": "response.writeContinue", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responsewritecontinue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsewritecontinue", "nodeStability": { "index": "2", "level": 2, @@ -36489,7 +37269,7 @@ "label": "response.writeEarlyHints(hints[, callback])", "signature": "`response.writeEarlyHints(hints[, callback])`", "apiSymbol": "response.writeEarlyHints", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responsewriteearlyhintshints-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsewriteearlyhintshints-callback", "nodeStability": { "index": "2", "level": 2, @@ -36516,7 +37296,7 @@ "label": "response.writeHead(statusCode[, statusMessage][, headers])", "signature": "`response.writeHead(statusCode[, statusMessage][, headers])`", "apiSymbol": "response.writeHead", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responsewriteheadstatuscode-statusmessage-headers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsewriteheadstatuscode-statusmessage-headers", "nodeStability": { "index": "2", "level": 2, @@ -36539,13 +37319,38 @@ } } }, + { + "id": "http:3228cdffbf09", + "chapter": "http", + "label": "response.writeInformation(statusCode[, headers][, callback])", + "signature": "`response.writeInformation(statusCode[, headers][, callback])`", + "apiSymbol": "response.writeInformation", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsewriteinformationstatuscode-headers-callback", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:http", + "tests": [] + } + } + }, { "id": "http:66f1ca12e0bb", "chapter": "http", "label": "response.writeProcessing()", "signature": "`response.writeProcessing()`", "apiSymbol": "response.writeProcessing", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#responsewriteprocessing", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#responsewriteprocessing", "nodeStability": { "index": "2", "level": 2, @@ -36572,7 +37377,7 @@ "label": "connection", "signature": "`connection` Type: {stream.Duplex}", "apiSymbol": "connection", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserverresponse", "nodeStability": { "index": "0", "level": 0, @@ -36599,7 +37404,7 @@ "label": "finished", "signature": "`finished` Type: {boolean}", "apiSymbol": "finished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserverresponse", "nodeStability": { "index": "0", "level": 0, @@ -36626,7 +37431,7 @@ "label": "headersSent", "signature": "`headersSent` Type: {boolean}", "apiSymbol": "headersSent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserverresponse", "nodeStability": { "index": "2", "level": 2, @@ -36653,7 +37458,7 @@ "label": "req", "signature": "`req` Type: {http.IncomingMessage}", "apiSymbol": "req", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserverresponse", "nodeStability": { "index": "2", "level": 2, @@ -36680,7 +37485,7 @@ "label": "sendDate", "signature": "`sendDate` Type: {boolean}", "apiSymbol": "sendDate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserverresponse", "nodeStability": { "index": "2", "level": 2, @@ -36707,7 +37512,7 @@ "label": "socket", "signature": "`socket` Type: {stream.Duplex}", "apiSymbol": "socket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserverresponse", "nodeStability": { "index": "2", "level": 2, @@ -36734,7 +37539,7 @@ "label": "statusCode", "signature": "`statusCode` Type: {number} **Default:** `200`", "apiSymbol": "statusCode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserverresponse", "nodeStability": { "index": "2", "level": 2, @@ -36761,7 +37566,7 @@ "label": "statusMessage", "signature": "`statusMessage` Type: {string}", "apiSymbol": "statusMessage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserverresponse", "nodeStability": { "index": "2", "level": 2, @@ -36788,7 +37593,7 @@ "label": "strictContentLength", "signature": "`strictContentLength` Type: {boolean} **Default:** `false`", "apiSymbol": "strictContentLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserverresponse", "nodeStability": { "index": "2", "level": 2, @@ -36815,7 +37620,7 @@ "label": "writableEnded", "signature": "`writableEnded` Type: {boolean}", "apiSymbol": "writableEnded", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserverresponse", "nodeStability": { "index": "2", "level": 2, @@ -36842,7 +37647,7 @@ "label": "writableFinished", "signature": "`writableFinished` Type: {boolean}", "apiSymbol": "writableFinished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpserverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpserverresponse", "nodeStability": { "index": "2", "level": 2, @@ -36869,7 +37674,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-close_2", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-close_2", "nodeStability": { "index": "2", "level": 2, @@ -36896,7 +37701,7 @@ "label": "'finish'", "signature": "Event: `'finish'`", "apiSymbol": "'finish'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-finish_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-finish_1", "nodeStability": { "index": "2", "level": 2, @@ -36923,7 +37728,7 @@ "label": "http.IncomingMessage", "signature": "Class: `http.IncomingMessage`", "apiSymbol": "http.IncomingMessage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -36951,7 +37756,7 @@ "label": "message.destroy([error])", "signature": "`message.destroy([error])`", "apiSymbol": "message.destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#messagedestroyerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#messagedestroyerror", "nodeStability": { "index": "2", "level": 2, @@ -36978,7 +37783,7 @@ "label": "message.setTimeout(msecs[, callback])", "signature": "`message.setTimeout(msecs[, callback])`", "apiSymbol": "message.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#messagesettimeoutmsecs-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#messagesettimeoutmsecs-callback", "nodeStability": { "index": "2", "level": 2, @@ -37007,7 +37812,7 @@ "label": "aborted", "signature": "`aborted` Type: {boolean}", "apiSymbol": "aborted", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "0", "level": 0, @@ -37034,7 +37839,7 @@ "label": "complete", "signature": "`complete` Type: {boolean}", "apiSymbol": "complete", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37061,7 +37866,7 @@ "label": "message.connection", "signature": "`message.connection`", "apiSymbol": "message.connection", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#messageconnection", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#messageconnection", "nodeStability": { "index": "0", "level": 0, @@ -37088,7 +37893,7 @@ "label": "headers", "signature": "`headers` Type: {Object}", "apiSymbol": "headers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37115,7 +37920,7 @@ "label": "headersDistinct", "signature": "`headersDistinct` Type: {Object}", "apiSymbol": "headersDistinct", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37146,7 +37951,7 @@ "label": "httpVersion", "signature": "`httpVersion` Type: {string}", "apiSymbol": "httpVersion", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37173,7 +37978,7 @@ "label": "method", "signature": "`method` Type: {string}", "apiSymbol": "method", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37200,7 +38005,7 @@ "label": "rawHeaders", "signature": "`rawHeaders` Type: {string\\[]}", "apiSymbol": "rawHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37227,7 +38032,7 @@ "label": "rawTrailers", "signature": "`rawTrailers` Type: {string\\[]}", "apiSymbol": "rawTrailers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37252,13 +38057,38 @@ } } }, + { + "id": "http:17e4f98aa2fc", + "chapter": "http", + "label": "signal", + "signature": "`signal` Type: {AbortSignal}", + "apiSymbol": "signal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:http", + "tests": [] + } + } + }, { "id": "http:63ef1a2fb4c2", "chapter": "http", "label": "socket", "signature": "`socket` Type: {stream.Duplex}", "apiSymbol": "socket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37285,7 +38115,7 @@ "label": "statusCode", "signature": "`statusCode` Type: {number}", "apiSymbol": "statusCode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37312,7 +38142,7 @@ "label": "statusMessage", "signature": "`statusMessage` Type: {string}", "apiSymbol": "statusMessage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37339,7 +38169,7 @@ "label": "trailers", "signature": "`trailers` Type: {Object}", "apiSymbol": "trailers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37370,7 +38200,7 @@ "label": "trailersDistinct", "signature": "`trailersDistinct` Type: {Object}", "apiSymbol": "trailersDistinct", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37401,7 +38231,7 @@ "label": "url", "signature": "`url` Type: {string}", "apiSymbol": "url", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpincomingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpincomingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37428,7 +38258,7 @@ "label": "'aborted'", "signature": "Event: `'aborted'`", "apiSymbol": "'aborted'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-aborted", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-aborted", "nodeStability": { "index": "0", "level": 0, @@ -37455,7 +38285,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-close_3", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-close_3", "nodeStability": { "index": "2", "level": 2, @@ -37482,7 +38312,7 @@ "label": "http.OutgoingMessage", "signature": "Class: `http.OutgoingMessage`", "apiSymbol": "http.OutgoingMessage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpoutgoingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpoutgoingmessage", "nodeStability": { "index": "2", "level": 2, @@ -37507,7 +38337,7 @@ "label": "outgoingMessage.addTrailers(headers)", "signature": "`outgoingMessage.addTrailers(headers)`", "apiSymbol": "outgoingMessage.addTrailers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessageaddtrailersheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessageaddtrailersheaders", "nodeStability": { "index": "2", "level": 2, @@ -37538,7 +38368,7 @@ "label": "outgoingMessage.appendHeader(name, value)", "signature": "`outgoingMessage.appendHeader(name, value)`", "apiSymbol": "outgoingMessage.appendHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessageappendheadername-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessageappendheadername-value", "nodeStability": { "index": "2", "level": 2, @@ -37563,7 +38393,7 @@ "label": "outgoingMessage.cork()", "signature": "`outgoingMessage.cork()`", "apiSymbol": "outgoingMessage.cork", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessagecork", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessagecork", "nodeStability": { "index": "2", "level": 2, @@ -37594,7 +38424,7 @@ "label": "outgoingMessage.destroy([error])", "signature": "`outgoingMessage.destroy([error])`", "apiSymbol": "outgoingMessage.destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessagedestroyerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessagedestroyerror", "nodeStability": { "index": "2", "level": 2, @@ -37619,7 +38449,7 @@ "label": "outgoingMessage.end(chunk[, encoding][, callback])", "signature": "`outgoingMessage.end(chunk[, encoding][, callback])`", "apiSymbol": "outgoingMessage.end", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessageendchunk-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessageendchunk-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -37644,7 +38474,7 @@ "label": "outgoingMessage.flushHeaders()", "signature": "`outgoingMessage.flushHeaders()`", "apiSymbol": "outgoingMessage.flushHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessageflushheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessageflushheaders", "nodeStability": { "index": "2", "level": 2, @@ -37675,7 +38505,7 @@ "label": "outgoingMessage.getHeader(name)", "signature": "`outgoingMessage.getHeader(name)`", "apiSymbol": "outgoingMessage.getHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessagegetheadername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessagegetheadername", "nodeStability": { "index": "2", "level": 2, @@ -37700,7 +38530,7 @@ "label": "outgoingMessage.getHeaderNames()", "signature": "`outgoingMessage.getHeaderNames()`", "apiSymbol": "outgoingMessage.getHeaderNames", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessagegetheadernames", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessagegetheadernames", "nodeStability": { "index": "2", "level": 2, @@ -37725,7 +38555,7 @@ "label": "outgoingMessage.getHeaders()", "signature": "`outgoingMessage.getHeaders()`", "apiSymbol": "outgoingMessage.getHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessagegetheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessagegetheaders", "nodeStability": { "index": "2", "level": 2, @@ -37750,7 +38580,7 @@ "label": "outgoingMessage.hasHeader(name)", "signature": "`outgoingMessage.hasHeader(name)`", "apiSymbol": "outgoingMessage.hasHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessagehasheadername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessagehasheadername", "nodeStability": { "index": "2", "level": 2, @@ -37775,7 +38605,7 @@ "label": "outgoingMessage.pipe()", "signature": "`outgoingMessage.pipe()`", "apiSymbol": "outgoingMessage.pipe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessagepipe", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessagepipe", "nodeStability": { "index": "2", "level": 2, @@ -37800,7 +38630,7 @@ "label": "outgoingMessage.removeHeader(name)", "signature": "`outgoingMessage.removeHeader(name)`", "apiSymbol": "outgoingMessage.removeHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessageremoveheadername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessageremoveheadername", "nodeStability": { "index": "2", "level": 2, @@ -37825,7 +38655,7 @@ "label": "outgoingMessage.setHeader(name, value)", "signature": "`outgoingMessage.setHeader(name, value)`", "apiSymbol": "outgoingMessage.setHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessagesetheadername-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessagesetheadername-value", "nodeStability": { "index": "2", "level": 2, @@ -37850,7 +38680,7 @@ "label": "outgoingMessage.setHeaders(headers)", "signature": "`outgoingMessage.setHeaders(headers)`", "apiSymbol": "outgoingMessage.setHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessagesetheadersheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessagesetheadersheaders", "nodeStability": { "index": "2", "level": 2, @@ -37875,7 +38705,7 @@ "label": "outgoingMessage.setTimeout(msecs[, callback])", "signature": "`outgoingMessage.setTimeout(msecs[, callback])`", "apiSymbol": "outgoingMessage.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessagesettimeoutmsecs-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessagesettimeoutmsecs-callback", "nodeStability": { "index": "2", "level": 2, @@ -37900,7 +38730,7 @@ "label": "outgoingMessage.uncork()", "signature": "`outgoingMessage.uncork()`", "apiSymbol": "outgoingMessage.uncork", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessageuncork", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessageuncork", "nodeStability": { "index": "2", "level": 2, @@ -37931,7 +38761,7 @@ "label": "outgoingMessage.write(chunk[, encoding][, callback])", "signature": "`outgoingMessage.write(chunk[, encoding][, callback])`", "apiSymbol": "outgoingMessage.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessagewritechunk-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessagewritechunk-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -37956,7 +38786,7 @@ "label": "outgoingMessage.connection", "signature": "`outgoingMessage.connection`", "apiSymbol": "outgoingMessage.connection", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#outgoingmessageconnection", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#outgoingmessageconnection", "nodeStability": { "index": "0", "level": 0, @@ -37981,7 +38811,7 @@ "label": "headersSent", "signature": "`headersSent` Type: {boolean}", "apiSymbol": "headersSent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpoutgoingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpoutgoingmessage", "nodeStability": { "index": "2", "level": 2, @@ -38008,7 +38838,7 @@ "label": "socket", "signature": "`socket` Type: {stream.Duplex}", "apiSymbol": "socket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpoutgoingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpoutgoingmessage", "nodeStability": { "index": "2", "level": 2, @@ -38033,7 +38863,7 @@ "label": "writableCorked", "signature": "`writableCorked` Type: {number}", "apiSymbol": "writableCorked", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpoutgoingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpoutgoingmessage", "nodeStability": { "index": "2", "level": 2, @@ -38064,7 +38894,7 @@ "label": "writableEnded", "signature": "`writableEnded` Type: {boolean}", "apiSymbol": "writableEnded", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpoutgoingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpoutgoingmessage", "nodeStability": { "index": "2", "level": 2, @@ -38091,7 +38921,7 @@ "label": "writableFinished", "signature": "`writableFinished` Type: {boolean}", "apiSymbol": "writableFinished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpoutgoingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpoutgoingmessage", "nodeStability": { "index": "2", "level": 2, @@ -38116,7 +38946,7 @@ "label": "writableHighWaterMark", "signature": "`writableHighWaterMark` Type: {number}", "apiSymbol": "writableHighWaterMark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpoutgoingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpoutgoingmessage", "nodeStability": { "index": "2", "level": 2, @@ -38141,7 +38971,7 @@ "label": "writableLength", "signature": "`writableLength` Type: {number}", "apiSymbol": "writableLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpoutgoingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpoutgoingmessage", "nodeStability": { "index": "2", "level": 2, @@ -38166,7 +38996,7 @@ "label": "writableObjectMode", "signature": "`writableObjectMode` Type: {boolean}", "apiSymbol": "writableObjectMode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-httpoutgoingmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-httpoutgoingmessage", "nodeStability": { "index": "2", "level": 2, @@ -38191,7 +39021,7 @@ "label": "'drain'", "signature": "Event: `'drain'`", "apiSymbol": "'drain'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-drain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-drain", "nodeStability": { "index": "2", "level": 2, @@ -38216,7 +39046,7 @@ "label": "'finish'", "signature": "Event: `'finish'`", "apiSymbol": "'finish'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-finish_2", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-finish_2", "nodeStability": { "index": "2", "level": 2, @@ -38241,7 +39071,7 @@ "label": "'prefinish'", "signature": "Event: `'prefinish'`", "apiSymbol": "'prefinish'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#event-prefinish", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#event-prefinish", "nodeStability": { "index": "2", "level": 2, @@ -38266,7 +39096,7 @@ "label": "WebSocket", "signature": "Class: `WebSocket`", "apiSymbol": "WebSocket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#class-websocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#class-websocket", "nodeStability": { "index": "2", "level": 2, @@ -38291,7 +39121,7 @@ "label": "http.createServer([options][, requestListener])", "signature": "`http.createServer([options][, requestListener])`", "apiSymbol": "http.createServer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#httpcreateserveroptions-requestlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#httpcreateserveroptions-requestlistener", "nodeStability": { "index": "2", "level": 2, @@ -38320,7 +39150,7 @@ "label": "http.get(options[, callback])", "signature": "`http.get(options[, callback])`", "apiSymbol": "http.get", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#httpgetoptions-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#httpgetoptions-callback", "nodeStability": { "index": "2", "level": 2, @@ -38349,7 +39179,7 @@ "label": "http.get(url[, options][, callback])", "signature": "`http.get(url[, options][, callback])`", "apiSymbol": "http.get", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#httpgeturl-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#httpgeturl-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -38378,7 +39208,7 @@ "label": "http.request(options[, callback])", "signature": "`http.request(options[, callback])`", "apiSymbol": "http.request", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#httprequestoptions-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#httprequestoptions-callback", "nodeStability": { "index": "2", "level": 2, @@ -38407,7 +39237,7 @@ "label": "http.request(url[, options][, callback])", "signature": "`http.request(url[, options][, callback])`", "apiSymbol": "http.request", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#httprequesturl-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#httprequesturl-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -38436,7 +39266,7 @@ "label": "http.validateHeaderName(name[, label])", "signature": "`http.validateHeaderName(name[, label])`", "apiSymbol": "http.validateHeaderName", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#httpvalidateheadernamename-label", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#httpvalidateheadernamename-label", "nodeStability": { "index": "2", "level": 2, @@ -38463,7 +39293,7 @@ "label": "http.validateHeaderValue(name, value)", "signature": "`http.validateHeaderValue(name, value)`", "apiSymbol": "http.validateHeaderValue", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#httpvalidateheadervaluename-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#httpvalidateheadervaluename-value", "nodeStability": { "index": "2", "level": 2, @@ -38490,7 +39320,7 @@ "label": "http.setMaxIdleHTTPParsers(max)", "signature": "`http.setMaxIdleHTTPParsers(max)`", "apiSymbol": "http.setMaxIdleHTTPParsers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#httpsetmaxidlehttpparsersmax", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#httpsetmaxidlehttpparsersmax", "nodeStability": { "index": "2", "level": 2, @@ -38515,7 +39345,7 @@ "label": "http.setGlobalProxyFromEnv([proxyEnv])", "signature": "`http.setGlobalProxyFromEnv([proxyEnv])`", "apiSymbol": "http.setGlobalProxyFromEnv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html#httpsetglobalproxyfromenvproxyenv", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html#httpsetglobalproxyfromenvproxyenv", "nodeStability": { "index": "2", "level": 2, @@ -38540,7 +39370,7 @@ "label": "METHODS", "signature": "`METHODS` Type: {string\\[]}", "apiSymbol": "METHODS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html", "nodeStability": { "index": "2", "level": 2, @@ -38567,7 +39397,7 @@ "label": "STATUS_CODES", "signature": "`STATUS_CODES` Type: {Object}", "apiSymbol": "STATUS_CODES", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html", "nodeStability": { "index": "2", "level": 2, @@ -38594,7 +39424,7 @@ "label": "globalAgent", "signature": "`globalAgent` Type: {http.Agent}", "apiSymbol": "globalAgent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html", "nodeStability": { "index": "2", "level": 2, @@ -38619,7 +39449,7 @@ "label": "maxHeaderSize", "signature": "`maxHeaderSize` Type: {number}", "apiSymbol": "maxHeaderSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http.html", "nodeStability": { "index": "2", "level": 2, @@ -38646,7 +39476,7 @@ "label": "Supporting the CONNECT method", "signature": "Supporting the `CONNECT` method", "apiSymbol": "CONNECT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#supporting-the-connect-method", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#supporting-the-connect-method", "nodeStability": { "index": "2", "level": 2, @@ -38671,7 +39501,7 @@ "label": "The extended CONNECT protocol", "signature": "The extended `CONNECT` protocol", "apiSymbol": "CONNECT", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#the-extended-connect-protocol", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#the-extended-connect-protocol", "nodeStability": { "index": "2", "level": 2, @@ -38696,7 +39526,7 @@ "label": "Http2Session", "signature": "Class: `Http2Session`", "apiSymbol": "Http2Session", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2session", "nodeStability": { "index": "2", "level": 2, @@ -38721,7 +39551,7 @@ "label": "Http2Session", "signature": "`Http2Session` and sockets", "apiSymbol": "Http2Session", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2session-and-sockets", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2session-and-sockets", "nodeStability": { "index": "2", "level": 2, @@ -38746,7 +39576,7 @@ "label": "http2session.close([callback])", "signature": "`http2session.close([callback])`", "apiSymbol": "http2session.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2sessionclosecallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2sessionclosecallback", "nodeStability": { "index": "2", "level": 2, @@ -38771,7 +39601,7 @@ "label": "http2session.destroy([error][, code])", "signature": "`http2session.destroy([error][, code])`", "apiSymbol": "http2session.destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2sessiondestroyerror-code", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2sessiondestroyerror-code", "nodeStability": { "index": "2", "level": 2, @@ -38796,7 +39626,7 @@ "label": "http2session.goaway([code[, lastStreamID[, opaqueData]]])", "signature": "`http2session.goaway([code[, lastStreamID[, opaqueData]]])`", "apiSymbol": "http2session.goaway", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2sessiongoawaycode-laststreamid-opaquedata", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2sessiongoawaycode-laststreamid-opaquedata", "nodeStability": { "index": "2", "level": 2, @@ -38821,7 +39651,7 @@ "label": "http2session.ping([payload, ]callback)", "signature": "`http2session.ping([payload, ]callback)`", "apiSymbol": "http2session.ping", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2sessionpingpayload-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2sessionpingpayload-callback", "nodeStability": { "index": "2", "level": 2, @@ -38846,7 +39676,7 @@ "label": "http2session.ref()", "signature": "`http2session.ref()`", "apiSymbol": "http2session.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2sessionref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2sessionref", "nodeStability": { "index": "2", "level": 2, @@ -38871,7 +39701,7 @@ "label": "http2session.setLocalWindowSize(windowSize)", "signature": "`http2session.setLocalWindowSize(windowSize)`", "apiSymbol": "http2session.setLocalWindowSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2sessionsetlocalwindowsizewindowsize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2sessionsetlocalwindowsizewindowsize", "nodeStability": { "index": "2", "level": 2, @@ -38896,7 +39726,7 @@ "label": "http2session.setTimeout(msecs, callback)", "signature": "`http2session.setTimeout(msecs, callback)`", "apiSymbol": "http2session.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2sessionsettimeoutmsecs-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2sessionsettimeoutmsecs-callback", "nodeStability": { "index": "2", "level": 2, @@ -38921,7 +39751,7 @@ "label": "http2session.settings([settings][, callback])", "signature": "`http2session.settings([settings][, callback])`", "apiSymbol": "http2session.settings", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2sessionsettingssettings-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2sessionsettingssettings-callback", "nodeStability": { "index": "2", "level": 2, @@ -38946,7 +39776,7 @@ "label": "http2session.unref()", "signature": "`http2session.unref()`", "apiSymbol": "http2session.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2sessionunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2sessionunref", "nodeStability": { "index": "2", "level": 2, @@ -38971,7 +39801,7 @@ "label": "alpnProtocol", "signature": "`alpnProtocol` Type: {string|undefined}", "apiSymbol": "alpnProtocol", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2session", "nodeStability": { "index": "2", "level": 2, @@ -38996,7 +39826,7 @@ "label": "closed", "signature": "`closed` Type: {boolean}", "apiSymbol": "closed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2session", "nodeStability": { "index": "2", "level": 2, @@ -39021,7 +39851,7 @@ "label": "connecting", "signature": "`connecting` Type: {boolean}", "apiSymbol": "connecting", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2session", "nodeStability": { "index": "2", "level": 2, @@ -39046,7 +39876,7 @@ "label": "destroyed", "signature": "`destroyed` Type: {boolean}", "apiSymbol": "destroyed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2session", "nodeStability": { "index": "2", "level": 2, @@ -39071,7 +39901,7 @@ "label": "encrypted", "signature": "`encrypted` Type: {boolean|undefined}", "apiSymbol": "encrypted", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2session", "nodeStability": { "index": "2", "level": 2, @@ -39096,7 +39926,7 @@ "label": "localSettings", "signature": "`localSettings` Type: {HTTP/2 Settings Object}", "apiSymbol": "localSettings", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2session", "nodeStability": { "index": "2", "level": 2, @@ -39121,7 +39951,7 @@ "label": "originSet", "signature": "`originSet` Type: {string\\[]|undefined}", "apiSymbol": "originSet", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2session", "nodeStability": { "index": "2", "level": 2, @@ -39146,7 +39976,7 @@ "label": "pendingSettingsAck", "signature": "`pendingSettingsAck` Type: {boolean}", "apiSymbol": "pendingSettingsAck", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2session", "nodeStability": { "index": "2", "level": 2, @@ -39171,7 +40001,7 @@ "label": "remoteSettings", "signature": "`remoteSettings` Type: {HTTP/2 Settings Object}", "apiSymbol": "remoteSettings", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2session", "nodeStability": { "index": "2", "level": 2, @@ -39196,7 +40026,7 @@ "label": "socket", "signature": "`socket` Type: {net.Socket|tls.TLSSocket}", "apiSymbol": "socket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2session", "nodeStability": { "index": "2", "level": 2, @@ -39221,7 +40051,7 @@ "label": "http2session.state", "signature": "`http2session.state`", "apiSymbol": "http2session.state", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2sessionstate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2sessionstate", "nodeStability": { "index": "2", "level": 2, @@ -39246,7 +40076,7 @@ "label": "type", "signature": "`type` Type: {number}", "apiSymbol": "type", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2session", "nodeStability": { "index": "2", "level": 2, @@ -39271,7 +40101,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-close", "nodeStability": { "index": "2", "level": 2, @@ -39296,7 +40126,7 @@ "label": "'connect'", "signature": "Event: `'connect'`", "apiSymbol": "'connect'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-connect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-connect", "nodeStability": { "index": "2", "level": 2, @@ -39321,7 +40151,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-error", "nodeStability": { "index": "2", "level": 2, @@ -39346,7 +40176,7 @@ "label": "'frameError'", "signature": "Event: `'frameError'`", "apiSymbol": "'frameError'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-frameerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-frameerror", "nodeStability": { "index": "2", "level": 2, @@ -39371,7 +40201,7 @@ "label": "'goaway'", "signature": "Event: `'goaway'`", "apiSymbol": "'goaway'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-goaway", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-goaway", "nodeStability": { "index": "2", "level": 2, @@ -39396,7 +40226,7 @@ "label": "'localSettings'", "signature": "Event: `'localSettings'`", "apiSymbol": "'localSettings'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-localsettings", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-localsettings", "nodeStability": { "index": "2", "level": 2, @@ -39421,7 +40251,7 @@ "label": "'ping'", "signature": "Event: `'ping'`", "apiSymbol": "'ping'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-ping", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-ping", "nodeStability": { "index": "2", "level": 2, @@ -39446,7 +40276,7 @@ "label": "'remoteSettings'", "signature": "Event: `'remoteSettings'`", "apiSymbol": "'remoteSettings'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-remotesettings", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-remotesettings", "nodeStability": { "index": "2", "level": 2, @@ -39471,7 +40301,7 @@ "label": "'stream'", "signature": "Event: `'stream'`", "apiSymbol": "'stream'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-stream", "nodeStability": { "index": "2", "level": 2, @@ -39496,7 +40326,7 @@ "label": "'timeout'", "signature": "Event: `'timeout'`", "apiSymbol": "'timeout'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-timeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-timeout", "nodeStability": { "index": "2", "level": 2, @@ -39521,7 +40351,7 @@ "label": "ServerHttp2Session", "signature": "Class: `ServerHttp2Session`", "apiSymbol": "ServerHttp2Session", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-serverhttp2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-serverhttp2session", "nodeStability": { "index": "2", "level": 2, @@ -39546,7 +40376,7 @@ "label": "serverhttp2session.altsvc(alt, originOrStream)", "signature": "`serverhttp2session.altsvc(alt, originOrStream)`", "apiSymbol": "serverhttp2session.altsvc", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#serverhttp2sessionaltsvcalt-originorstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#serverhttp2sessionaltsvcalt-originorstream", "nodeStability": { "index": "2", "level": 2, @@ -39571,7 +40401,7 @@ "label": "serverhttp2session.origin(...origins)", "signature": "`serverhttp2session.origin(...origins)`", "apiSymbol": "serverhttp2session.origin", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#serverhttp2sessionoriginorigins", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#serverhttp2sessionoriginorigins", "nodeStability": { "index": "2", "level": 2, @@ -39596,7 +40426,7 @@ "label": "ClientHttp2Session", "signature": "Class: `ClientHttp2Session`", "apiSymbol": "ClientHttp2Session", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-clienthttp2session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-clienthttp2session", "nodeStability": { "index": "2", "level": 2, @@ -39621,7 +40451,7 @@ "label": "clienthttp2session.request(headers[, options])", "signature": "`clienthttp2session.request(headers[, options])`", "apiSymbol": "clienthttp2session.request", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#clienthttp2sessionrequestheaders-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#clienthttp2sessionrequestheaders-options", "nodeStability": { "index": "2", "level": 2, @@ -39646,7 +40476,7 @@ "label": "'altsvc'", "signature": "Event: `'altsvc'`", "apiSymbol": "'altsvc'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-altsvc", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-altsvc", "nodeStability": { "index": "2", "level": 2, @@ -39671,7 +40501,7 @@ "label": "'origin'", "signature": "Event: `'origin'`", "apiSymbol": "'origin'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-origin", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-origin", "nodeStability": { "index": "2", "level": 2, @@ -39696,7 +40526,7 @@ "label": "Http2Stream", "signature": "Class: `Http2Stream`", "apiSymbol": "Http2Stream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -39721,7 +40551,7 @@ "label": "Http2Stream", "signature": "`Http2Stream` Lifecycle", "apiSymbol": "Http2Stream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2stream-lifecycle", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2stream-lifecycle", "nodeStability": { "index": "2", "level": 2, @@ -39746,7 +40576,7 @@ "label": "http2stream.close(code[, callback])", "signature": "`http2stream.close(code[, callback])`", "apiSymbol": "http2stream.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2streamclosecode-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2streamclosecode-callback", "nodeStability": { "index": "2", "level": 2, @@ -39771,7 +40601,7 @@ "label": "http2stream.priority(options)", "signature": "`http2stream.priority(options)`", "apiSymbol": "http2stream.priority", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2streampriorityoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2streampriorityoptions", "nodeStability": { "index": "0", "level": 0, @@ -39796,7 +40626,7 @@ "label": "http2stream.setTimeout(msecs, callback)", "signature": "`http2stream.setTimeout(msecs, callback)`", "apiSymbol": "http2stream.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2streamsettimeoutmsecs-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2streamsettimeoutmsecs-callback", "nodeStability": { "index": "2", "level": 2, @@ -39821,7 +40651,7 @@ "label": "http2stream.sendTrailers(headers)", "signature": "`http2stream.sendTrailers(headers)`", "apiSymbol": "http2stream.sendTrailers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2streamsendtrailersheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2streamsendtrailersheaders", "nodeStability": { "index": "2", "level": 2, @@ -39846,7 +40676,7 @@ "label": "aborted", "signature": "`aborted` Type: {boolean}", "apiSymbol": "aborted", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -39871,7 +40701,7 @@ "label": "bufferSize", "signature": "`bufferSize` Type: {number}", "apiSymbol": "bufferSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -39896,7 +40726,7 @@ "label": "closed", "signature": "`closed` Type: {boolean}", "apiSymbol": "closed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -39921,7 +40751,7 @@ "label": "destroyed", "signature": "`destroyed` Type: {boolean}", "apiSymbol": "destroyed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -39946,7 +40776,7 @@ "label": "endAfterHeaders", "signature": "`endAfterHeaders` Type: {boolean}", "apiSymbol": "endAfterHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -39971,7 +40801,7 @@ "label": "id", "signature": "`id` Type: {number|undefined}", "apiSymbol": "id", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -39996,7 +40826,7 @@ "label": "pending", "signature": "`pending` Type: {boolean}", "apiSymbol": "pending", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -40021,7 +40851,7 @@ "label": "rstCode", "signature": "`rstCode` Type: {number}", "apiSymbol": "rstCode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -40046,7 +40876,7 @@ "label": "sentHeaders", "signature": "`sentHeaders` Type: {HTTP/2 Headers Object}", "apiSymbol": "sentHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -40071,7 +40901,7 @@ "label": "sentInfoHeaders", "signature": "`sentInfoHeaders` Type: {HTTP/2 Headers Object\\[]}", "apiSymbol": "sentInfoHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -40096,7 +40926,7 @@ "label": "sentTrailers", "signature": "`sentTrailers` Type: {HTTP/2 Headers Object}", "apiSymbol": "sentTrailers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -40121,7 +40951,7 @@ "label": "session", "signature": "`session` Type: {Http2Session}", "apiSymbol": "session", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2stream", "nodeStability": { "index": "2", "level": 2, @@ -40146,7 +40976,7 @@ "label": "http2stream.state", "signature": "`http2stream.state`", "apiSymbol": "http2stream.state", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2streamstate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2streamstate", "nodeStability": { "index": "2", "level": 2, @@ -40171,7 +41001,7 @@ "label": "'aborted'", "signature": "Event: `'aborted'`", "apiSymbol": "'aborted'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-aborted", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-aborted", "nodeStability": { "index": "2", "level": 2, @@ -40196,7 +41026,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-close_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-close_1", "nodeStability": { "index": "2", "level": 2, @@ -40221,7 +41051,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-error_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-error_1", "nodeStability": { "index": "2", "level": 2, @@ -40246,7 +41076,7 @@ "label": "'frameError'", "signature": "Event: `'frameError'`", "apiSymbol": "'frameError'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-frameerror_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-frameerror_1", "nodeStability": { "index": "2", "level": 2, @@ -40271,7 +41101,7 @@ "label": "'ready'", "signature": "Event: `'ready'`", "apiSymbol": "'ready'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-ready", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-ready", "nodeStability": { "index": "2", "level": 2, @@ -40296,7 +41126,7 @@ "label": "'timeout'", "signature": "Event: `'timeout'`", "apiSymbol": "'timeout'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-timeout_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-timeout_1", "nodeStability": { "index": "2", "level": 2, @@ -40321,7 +41151,7 @@ "label": "'trailers'", "signature": "Event: `'trailers'`", "apiSymbol": "'trailers'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-trailers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-trailers", "nodeStability": { "index": "2", "level": 2, @@ -40346,7 +41176,7 @@ "label": "'wantTrailers'", "signature": "Event: `'wantTrailers'`", "apiSymbol": "'wantTrailers'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-wanttrailers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-wanttrailers", "nodeStability": { "index": "2", "level": 2, @@ -40371,7 +41201,7 @@ "label": "ClientHttp2Stream", "signature": "Class: `ClientHttp2Stream`", "apiSymbol": "ClientHttp2Stream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-clienthttp2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-clienthttp2stream", "nodeStability": { "index": "2", "level": 2, @@ -40396,7 +41226,7 @@ "label": "'continue'", "signature": "Event: `'continue'`", "apiSymbol": "'continue'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-continue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-continue", "nodeStability": { "index": "2", "level": 2, @@ -40421,7 +41251,7 @@ "label": "'headers'", "signature": "Event: `'headers'`", "apiSymbol": "'headers'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-headers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-headers", "nodeStability": { "index": "2", "level": 2, @@ -40446,7 +41276,7 @@ "label": "'push'", "signature": "Event: `'push'`", "apiSymbol": "'push'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-push", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-push", "nodeStability": { "index": "2", "level": 2, @@ -40471,7 +41301,7 @@ "label": "'response'", "signature": "Event: `'response'`", "apiSymbol": "'response'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-response", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-response", "nodeStability": { "index": "2", "level": 2, @@ -40496,7 +41326,7 @@ "label": "ServerHttp2Stream", "signature": "Class: `ServerHttp2Stream`", "apiSymbol": "ServerHttp2Stream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-serverhttp2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-serverhttp2stream", "nodeStability": { "index": "2", "level": 2, @@ -40521,7 +41351,7 @@ "label": "http2stream.additionalHeaders(headers)", "signature": "`http2stream.additionalHeaders(headers)`", "apiSymbol": "http2stream.additionalHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2streamadditionalheadersheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2streamadditionalheadersheaders", "nodeStability": { "index": "2", "level": 2, @@ -40546,7 +41376,7 @@ "label": "http2stream.pushStream(headers[, options], callback)", "signature": "`http2stream.pushStream(headers[, options], callback)`", "apiSymbol": "http2stream.pushStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2streampushstreamheaders-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2streampushstreamheaders-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -40571,7 +41401,7 @@ "label": "http2stream.respond([headers[, options]])", "signature": "`http2stream.respond([headers[, options]])`", "apiSymbol": "http2stream.respond", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2streamrespondheaders-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2streamrespondheaders-options", "nodeStability": { "index": "2", "level": 2, @@ -40596,7 +41426,7 @@ "label": "http2stream.respondWithFD(fd[, headers[, options]])", "signature": "`http2stream.respondWithFD(fd[, headers[, options]])`", "apiSymbol": "http2stream.respondWithFD", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2streamrespondwithfdfd-headers-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2streamrespondwithfdfd-headers-options", "nodeStability": { "index": "2", "level": 2, @@ -40621,7 +41451,7 @@ "label": "http2stream.respondWithFile(path[, headers[, options]])", "signature": "`http2stream.respondWithFile(path[, headers[, options]])`", "apiSymbol": "http2stream.respondWithFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2streamrespondwithfilepath-headers-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2streamrespondwithfilepath-headers-options", "nodeStability": { "index": "2", "level": 2, @@ -40646,7 +41476,7 @@ "label": "headersSent", "signature": "`headersSent` Type: {boolean}", "apiSymbol": "headersSent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-serverhttp2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-serverhttp2stream", "nodeStability": { "index": "2", "level": 2, @@ -40671,7 +41501,7 @@ "label": "pushAllowed", "signature": "`pushAllowed` Type: {boolean}", "apiSymbol": "pushAllowed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-serverhttp2stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-serverhttp2stream", "nodeStability": { "index": "2", "level": 2, @@ -40696,7 +41526,7 @@ "label": "Http2Server", "signature": "Class: `Http2Server`", "apiSymbol": "Http2Server", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2server", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2server", "nodeStability": { "index": "2", "level": 2, @@ -40721,7 +41551,7 @@ "label": "server.close([callback])", "signature": "`server.close([callback])`", "apiSymbol": "server.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#serverclosecallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#serverclosecallback", "nodeStability": { "index": "2", "level": 2, @@ -40749,7 +41579,7 @@ "label": "server[Symbol.asyncDispose]()", "signature": "`server[Symbol.asyncDispose]()`", "apiSymbol": "server", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#serversymbolasyncdispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#serversymbolasyncdispose", "nodeStability": { "index": "2", "level": 2, @@ -40774,7 +41604,7 @@ "label": "server.setTimeout([msecs][, callback])", "signature": "`server.setTimeout([msecs][, callback])`", "apiSymbol": "server.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#serversettimeoutmsecs-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#serversettimeoutmsecs-callback", "nodeStability": { "index": "2", "level": 2, @@ -40799,7 +41629,7 @@ "label": "server.updateSettings([settings])", "signature": "`server.updateSettings([settings])`", "apiSymbol": "server.updateSettings", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#serverupdatesettingssettings", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#serverupdatesettingssettings", "nodeStability": { "index": "2", "level": 2, @@ -40824,7 +41654,7 @@ "label": "timeout", "signature": "`timeout` Type: {number} Timeout in milliseconds. **Default:** 0 (no timeout)", "apiSymbol": "timeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2server", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2server", "nodeStability": { "index": "2", "level": 2, @@ -40853,7 +41683,7 @@ "label": "'checkContinue'", "signature": "Event: `'checkContinue'`", "apiSymbol": "'checkContinue'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-checkcontinue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-checkcontinue", "nodeStability": { "index": "2", "level": 2, @@ -40878,7 +41708,7 @@ "label": "'connection'", "signature": "Event: `'connection'`", "apiSymbol": "'connection'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-connection", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-connection", "nodeStability": { "index": "2", "level": 2, @@ -40903,7 +41733,7 @@ "label": "'request'", "signature": "Event: `'request'`", "apiSymbol": "'request'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-request", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-request", "nodeStability": { "index": "2", "level": 2, @@ -40928,7 +41758,7 @@ "label": "'session'", "signature": "Event: `'session'`", "apiSymbol": "'session'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-session", "nodeStability": { "index": "2", "level": 2, @@ -40953,7 +41783,7 @@ "label": "'sessionError'", "signature": "Event: `'sessionError'`", "apiSymbol": "'sessionError'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-sessionerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-sessionerror", "nodeStability": { "index": "2", "level": 2, @@ -40978,7 +41808,7 @@ "label": "'stream'", "signature": "Event: `'stream'`", "apiSymbol": "'stream'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-stream_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-stream_1", "nodeStability": { "index": "2", "level": 2, @@ -41003,7 +41833,7 @@ "label": "'timeout'", "signature": "Event: `'timeout'`", "apiSymbol": "'timeout'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-timeout_2", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-timeout_2", "nodeStability": { "index": "2", "level": 2, @@ -41028,7 +41858,7 @@ "label": "Http2SecureServer", "signature": "Class: `Http2SecureServer`", "apiSymbol": "Http2SecureServer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2secureserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2secureserver", "nodeStability": { "index": "2", "level": 2, @@ -41053,7 +41883,7 @@ "label": "server.close([callback])", "signature": "`server.close([callback])`", "apiSymbol": "server.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#serverclosecallback_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#serverclosecallback_1", "nodeStability": { "index": "2", "level": 2, @@ -41081,7 +41911,7 @@ "label": "server.setTimeout([msecs][, callback])", "signature": "`server.setTimeout([msecs][, callback])`", "apiSymbol": "server.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#serversettimeoutmsecs-callback_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#serversettimeoutmsecs-callback_1", "nodeStability": { "index": "2", "level": 2, @@ -41106,7 +41936,7 @@ "label": "server.updateSettings([settings])", "signature": "`server.updateSettings([settings])`", "apiSymbol": "server.updateSettings", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#serverupdatesettingssettings_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#serverupdatesettingssettings_1", "nodeStability": { "index": "2", "level": 2, @@ -41131,7 +41961,7 @@ "label": "timeout", "signature": "`timeout` Type: {number} Timeout in milliseconds. **Default:** 0 (no timeout)", "apiSymbol": "timeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2secureserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2secureserver", "nodeStability": { "index": "2", "level": 2, @@ -41160,7 +41990,7 @@ "label": "'checkContinue'", "signature": "Event: `'checkContinue'`", "apiSymbol": "'checkContinue'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-checkcontinue_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-checkcontinue_1", "nodeStability": { "index": "2", "level": 2, @@ -41185,7 +42015,7 @@ "label": "'connection'", "signature": "Event: `'connection'`", "apiSymbol": "'connection'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-connection_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-connection_1", "nodeStability": { "index": "2", "level": 2, @@ -41210,7 +42040,7 @@ "label": "'request'", "signature": "Event: `'request'`", "apiSymbol": "'request'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-request_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-request_1", "nodeStability": { "index": "2", "level": 2, @@ -41235,7 +42065,7 @@ "label": "'session'", "signature": "Event: `'session'`", "apiSymbol": "'session'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-session_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-session_1", "nodeStability": { "index": "2", "level": 2, @@ -41260,7 +42090,7 @@ "label": "'sessionError'", "signature": "Event: `'sessionError'`", "apiSymbol": "'sessionError'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-sessionerror_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-sessionerror_1", "nodeStability": { "index": "2", "level": 2, @@ -41285,7 +42115,7 @@ "label": "'stream'", "signature": "Event: `'stream'`", "apiSymbol": "'stream'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-stream_2", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-stream_2", "nodeStability": { "index": "2", "level": 2, @@ -41310,7 +42140,7 @@ "label": "'timeout'", "signature": "Event: `'timeout'`", "apiSymbol": "'timeout'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-timeout_3", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-timeout_3", "nodeStability": { "index": "2", "level": 2, @@ -41335,7 +42165,7 @@ "label": "'unknownProtocol'", "signature": "Event: `'unknownProtocol'`", "apiSymbol": "'unknownProtocol'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-unknownprotocol", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-unknownprotocol", "nodeStability": { "index": "2", "level": 2, @@ -41360,7 +42190,7 @@ "label": "http2.createServer([options][, onRequestHandler])", "signature": "`http2.createServer([options][, onRequestHandler])`", "apiSymbol": "http2.createServer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2createserveroptions-onrequesthandler", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2createserveroptions-onrequesthandler", "nodeStability": { "index": "2", "level": 2, @@ -41385,7 +42215,7 @@ "label": "http2.createSecureServer(options[, onRequestHandler])", "signature": "`http2.createSecureServer(options[, onRequestHandler])`", "apiSymbol": "http2.createSecureServer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2createsecureserveroptions-onrequesthandler", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2createsecureserveroptions-onrequesthandler", "nodeStability": { "index": "2", "level": 2, @@ -41410,7 +42240,7 @@ "label": "http2.connect(authority[, options][, listener])", "signature": "`http2.connect(authority[, options][, listener])`", "apiSymbol": "http2.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2connectauthority-options-listener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2connectauthority-options-listener", "nodeStability": { "index": "2", "level": 2, @@ -41435,7 +42265,7 @@ "label": "http2.getDefaultSettings()", "signature": "`http2.getDefaultSettings()`", "apiSymbol": "http2.getDefaultSettings", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2getdefaultsettings", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2getdefaultsettings", "nodeStability": { "index": "2", "level": 2, @@ -41460,7 +42290,7 @@ "label": "http2.getPackedSettings([settings])", "signature": "`http2.getPackedSettings([settings])`", "apiSymbol": "http2.getPackedSettings", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2getpackedsettingssettings", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2getpackedsettingssettings", "nodeStability": { "index": "2", "level": 2, @@ -41485,7 +42315,7 @@ "label": "http2.getUnpackedSettings(buf)", "signature": "`http2.getUnpackedSettings(buf)`", "apiSymbol": "http2.getUnpackedSettings", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2getunpackedsettingsbuf", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2getunpackedsettingsbuf", "nodeStability": { "index": "2", "level": 2, @@ -41510,7 +42340,7 @@ "label": "http2.performServerHandshake(socket[, options])", "signature": "`http2.performServerHandshake(socket[, options])`", "apiSymbol": "http2.performServerHandshake", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2performserverhandshakesocket-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2performserverhandshakesocket-options", "nodeStability": { "index": "2", "level": 2, @@ -41535,7 +42365,7 @@ "label": "http2.constants", "signature": "`http2.constants`", "apiSymbol": "http2.constants", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#http2constants", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#http2constants", "nodeStability": { "index": "2", "level": 2, @@ -41560,7 +42390,7 @@ "label": "Error codes for RST_STREAM and GOAWAY", "signature": "Error codes for `RST_STREAM` and `GOAWAY`", "apiSymbol": "RST_STREAM", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#error-codes-for-rst_stream-and-goaway", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#error-codes-for-rst_stream-and-goaway", "nodeStability": { "index": "2", "level": 2, @@ -41585,7 +42415,7 @@ "label": "sensitiveHeaders", "signature": "`sensitiveHeaders` Type: {symbol}", "apiSymbol": "sensitiveHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#core-api", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#core-api", "nodeStability": { "index": "2", "level": 2, @@ -41610,7 +42440,7 @@ "label": "http2.Http2ServerRequest", "signature": "Class: `http2.Http2ServerRequest`", "apiSymbol": "http2.Http2ServerRequest", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -41635,7 +42465,7 @@ "label": "request.destroy([error])", "signature": "`request.destroy([error])`", "apiSymbol": "request.destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#requestdestroyerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#requestdestroyerror", "nodeStability": { "index": "2", "level": 2, @@ -41664,7 +42494,7 @@ "label": "request.setTimeout(msecs, callback)", "signature": "`request.setTimeout(msecs, callback)`", "apiSymbol": "request.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#requestsettimeoutmsecs-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#requestsettimeoutmsecs-callback", "nodeStability": { "index": "2", "level": 2, @@ -41693,7 +42523,7 @@ "label": "aborted", "signature": "`aborted` Type: {boolean}", "apiSymbol": "aborted", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -41718,7 +42548,7 @@ "label": "authority", "signature": "`authority` Type: {string}", "apiSymbol": "authority", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -41743,7 +42573,7 @@ "label": "complete", "signature": "`complete` Type: {boolean}", "apiSymbol": "complete", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -41768,7 +42598,7 @@ "label": "connection", "signature": "`connection` Type: {net.Socket|tls.TLSSocket}", "apiSymbol": "connection", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "0", "level": 0, @@ -41793,7 +42623,7 @@ "label": "headers", "signature": "`headers` Type: {Object}", "apiSymbol": "headers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -41818,7 +42648,7 @@ "label": "httpVersion", "signature": "`httpVersion` Type: {string}", "apiSymbol": "httpVersion", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -41843,7 +42673,7 @@ "label": "method", "signature": "`method` Type: {string}", "apiSymbol": "method", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -41868,7 +42698,7 @@ "label": "rawHeaders", "signature": "`rawHeaders` Type: {HTTP/2 Raw Headers}", "apiSymbol": "rawHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -41893,7 +42723,7 @@ "label": "rawTrailers", "signature": "`rawTrailers` Type: {string\\[]}", "apiSymbol": "rawTrailers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -41918,7 +42748,7 @@ "label": "scheme", "signature": "`scheme` Type: {string}", "apiSymbol": "scheme", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -41943,7 +42773,7 @@ "label": "socket", "signature": "`socket` Type: {net.Socket|tls.TLSSocket}", "apiSymbol": "socket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -41968,7 +42798,7 @@ "label": "stream", "signature": "`stream` Type: {Http2Stream}", "apiSymbol": "stream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -41993,7 +42823,7 @@ "label": "trailers", "signature": "`trailers` Type: {Object}", "apiSymbol": "trailers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -42018,7 +42848,7 @@ "label": "url", "signature": "`url` Type: {string}", "apiSymbol": "url", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverrequest", "nodeStability": { "index": "2", "level": 2, @@ -42043,7 +42873,7 @@ "label": "'aborted'", "signature": "Event: `'aborted'`", "apiSymbol": "'aborted'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-aborted_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-aborted_1", "nodeStability": { "index": "2", "level": 2, @@ -42068,7 +42898,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-close_2", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-close_2", "nodeStability": { "index": "2", "level": 2, @@ -42093,7 +42923,7 @@ "label": "http2.Http2ServerResponse", "signature": "Class: `http2.Http2ServerResponse`", "apiSymbol": "http2.Http2ServerResponse", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverresponse", "nodeStability": { "index": "2", "level": 2, @@ -42118,7 +42948,7 @@ "label": "response.addTrailers(headers)", "signature": "`response.addTrailers(headers)`", "apiSymbol": "response.addTrailers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responseaddtrailersheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responseaddtrailersheaders", "nodeStability": { "index": "2", "level": 2, @@ -42143,7 +42973,7 @@ "label": "response.appendHeader(name, value)", "signature": "`response.appendHeader(name, value)`", "apiSymbol": "response.appendHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responseappendheadername-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responseappendheadername-value", "nodeStability": { "index": "2", "level": 2, @@ -42168,7 +42998,7 @@ "label": "response.createPushResponse(headers, callback)", "signature": "`response.createPushResponse(headers, callback)`", "apiSymbol": "response.createPushResponse", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responsecreatepushresponseheaders-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responsecreatepushresponseheaders-callback", "nodeStability": { "index": "2", "level": 2, @@ -42193,7 +43023,7 @@ "label": "response.end([data[, encoding]][, callback])", "signature": "`response.end([data[, encoding]][, callback])`", "apiSymbol": "response.end", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responseenddata-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responseenddata-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -42222,7 +43052,7 @@ "label": "response.getHeader(name)", "signature": "`response.getHeader(name)`", "apiSymbol": "response.getHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responsegetheadername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responsegetheadername", "nodeStability": { "index": "2", "level": 2, @@ -42251,7 +43081,7 @@ "label": "response.getHeaderNames()", "signature": "`response.getHeaderNames()`", "apiSymbol": "response.getHeaderNames", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responsegetheadernames", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responsegetheadernames", "nodeStability": { "index": "2", "level": 2, @@ -42276,7 +43106,7 @@ "label": "response.getHeaders()", "signature": "`response.getHeaders()`", "apiSymbol": "response.getHeaders", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responsegetheaders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responsegetheaders", "nodeStability": { "index": "2", "level": 2, @@ -42301,7 +43131,7 @@ "label": "response.hasHeader(name)", "signature": "`response.hasHeader(name)`", "apiSymbol": "response.hasHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responsehasheadername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responsehasheadername", "nodeStability": { "index": "2", "level": 2, @@ -42330,7 +43160,7 @@ "label": "response.removeHeader(name)", "signature": "`response.removeHeader(name)`", "apiSymbol": "response.removeHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responseremoveheadername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responseremoveheadername", "nodeStability": { "index": "2", "level": 2, @@ -42359,7 +43189,7 @@ "label": "response.setHeader(name, value)", "signature": "`response.setHeader(name, value)`", "apiSymbol": "response.setHeader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responsesetheadername-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responsesetheadername-value", "nodeStability": { "index": "2", "level": 2, @@ -42388,7 +43218,7 @@ "label": "response.setTimeout(msecs[, callback])", "signature": "`response.setTimeout(msecs[, callback])`", "apiSymbol": "response.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responsesettimeoutmsecs-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responsesettimeoutmsecs-callback", "nodeStability": { "index": "2", "level": 2, @@ -42413,7 +43243,7 @@ "label": "response.write(chunk[, encoding][, callback])", "signature": "`response.write(chunk[, encoding][, callback])`", "apiSymbol": "response.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responsewritechunk-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responsewritechunk-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -42442,7 +43272,7 @@ "label": "response.writeContinue()", "signature": "`response.writeContinue()`", "apiSymbol": "response.writeContinue", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responsewritecontinue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responsewritecontinue", "nodeStability": { "index": "2", "level": 2, @@ -42467,7 +43297,32 @@ "label": "response.writeEarlyHints(hints)", "signature": "`response.writeEarlyHints(hints)`", "apiSymbol": "response.writeEarlyHints", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responsewriteearlyhintshints", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responsewriteearlyhintshints", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:http2", + "tests": [] + } + } + }, + { + "id": "http2:5deaac8d8f97", + "chapter": "http2", + "label": "response.writeInformation(statusCode[, headers])", + "signature": "`response.writeInformation(statusCode[, headers])`", + "apiSymbol": "response.writeInformation", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responsewriteinformationstatuscode-headers", "nodeStability": { "index": "2", "level": 2, @@ -42492,7 +43347,7 @@ "label": "response.writeHead(statusCode[, statusMessage][, headers])", "signature": "`response.writeHead(statusCode[, statusMessage][, headers])`", "apiSymbol": "response.writeHead", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#responsewriteheadstatuscode-statusmessage-headers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#responsewriteheadstatuscode-statusmessage-headers", "nodeStability": { "index": "2", "level": 2, @@ -42521,7 +43376,7 @@ "label": "connection", "signature": "`connection` Type: {net.Socket|tls.TLSSocket}", "apiSymbol": "connection", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverresponse", "nodeStability": { "index": "0", "level": 0, @@ -42546,7 +43401,7 @@ "label": "finished", "signature": "`finished` Type: {boolean}", "apiSymbol": "finished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverresponse", "nodeStability": { "index": "0", "level": 0, @@ -42571,7 +43426,7 @@ "label": "headersSent", "signature": "`headersSent` Type: {boolean}", "apiSymbol": "headersSent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverresponse", "nodeStability": { "index": "2", "level": 2, @@ -42596,7 +43451,7 @@ "label": "req", "signature": "`req` Type: {http2.Http2ServerRequest}", "apiSymbol": "req", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverresponse", "nodeStability": { "index": "2", "level": 2, @@ -42621,7 +43476,7 @@ "label": "sendDate", "signature": "`sendDate` Type: {boolean}", "apiSymbol": "sendDate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverresponse", "nodeStability": { "index": "2", "level": 2, @@ -42646,7 +43501,7 @@ "label": "socket", "signature": "`socket` Type: {net.Socket|tls.TLSSocket}", "apiSymbol": "socket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverresponse", "nodeStability": { "index": "2", "level": 2, @@ -42671,7 +43526,7 @@ "label": "statusCode", "signature": "`statusCode` Type: {number}", "apiSymbol": "statusCode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverresponse", "nodeStability": { "index": "2", "level": 2, @@ -42696,7 +43551,7 @@ "label": "statusMessage", "signature": "`statusMessage` Type: {string}", "apiSymbol": "statusMessage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverresponse", "nodeStability": { "index": "2", "level": 2, @@ -42721,7 +43576,7 @@ "label": "stream", "signature": "`stream` Type: {Http2Stream}", "apiSymbol": "stream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverresponse", "nodeStability": { "index": "2", "level": 2, @@ -42746,7 +43601,7 @@ "label": "writableEnded", "signature": "`writableEnded` Type: {boolean}", "apiSymbol": "writableEnded", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#class-http2http2serverresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#class-http2http2serverresponse", "nodeStability": { "index": "2", "level": 2, @@ -42771,7 +43626,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-close_3", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-close_3", "nodeStability": { "index": "2", "level": 2, @@ -42796,7 +43651,7 @@ "label": "'finish'", "signature": "Event: `'finish'`", "apiSymbol": "'finish'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#event-finish", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#event-finish", "nodeStability": { "index": "2", "level": 2, @@ -42821,7 +43676,7 @@ "label": "Note on :authority and host", "signature": "Note on `:authority` and `host`", "apiSymbol": ":authority", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/http2.html#note-on-authority-and-host", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/http2.html#note-on-authority-and-host", "nodeStability": { "index": "2", "level": 2, @@ -42846,7 +43701,7 @@ "label": "https.Agent", "signature": "Class: `https.Agent`", "apiSymbol": "https.Agent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#class-httpsagent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#class-httpsagent", "nodeStability": { "index": "2", "level": 2, @@ -42871,7 +43726,7 @@ "label": "https.Server", "signature": "Class: `https.Server`", "apiSymbol": "https.Server", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#class-httpsserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#class-httpsserver", "nodeStability": { "index": "2", "level": 2, @@ -42896,7 +43751,7 @@ "label": "server.close([callback])", "signature": "`server.close([callback])`", "apiSymbol": "server.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#serverclosecallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#serverclosecallback", "nodeStability": { "index": "2", "level": 2, @@ -42924,7 +43779,7 @@ "label": "server[Symbol.asyncDispose]()", "signature": "`server[Symbol.asyncDispose]()`", "apiSymbol": "server", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#serversymbolasyncdispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#serversymbolasyncdispose", "nodeStability": { "index": "2", "level": 2, @@ -42949,7 +43804,7 @@ "label": "server.closeAllConnections()", "signature": "`server.closeAllConnections()`", "apiSymbol": "server.closeAllConnections", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#servercloseallconnections", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#servercloseallconnections", "nodeStability": { "index": "2", "level": 2, @@ -42974,7 +43829,7 @@ "label": "server.closeIdleConnections()", "signature": "`server.closeIdleConnections()`", "apiSymbol": "server.closeIdleConnections", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#servercloseidleconnections", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#servercloseidleconnections", "nodeStability": { "index": "2", "level": 2, @@ -42999,7 +43854,7 @@ "label": "server.listen()", "signature": "`server.listen()`", "apiSymbol": "server.listen", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#serverlisten", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#serverlisten", "nodeStability": { "index": "2", "level": 2, @@ -43027,7 +43882,7 @@ "label": "server.setTimeout([msecs][, callback])", "signature": "`server.setTimeout([msecs][, callback])`", "apiSymbol": "server.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#serversettimeoutmsecs-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#serversettimeoutmsecs-callback", "nodeStability": { "index": "2", "level": 2, @@ -43052,7 +43907,7 @@ "label": "headersTimeout", "signature": "`headersTimeout` Type: {number} **Default:** `60000`", "apiSymbol": "headersTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#class-httpsserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#class-httpsserver", "nodeStability": { "index": "2", "level": 2, @@ -43076,12 +43931,12 @@ } }, { - "id": "https:705c007905d2", + "id": "https:2c6b974ec0c1", "chapter": "https", "label": "maxHeadersCount", - "signature": "`maxHeadersCount` Type: {number} **Default:** `2000`", + "signature": "`maxHeadersCount` Type: {number} **Default:** `1000`", "apiSymbol": "maxHeadersCount", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#class-httpsserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#class-httpsserver", "nodeStability": { "index": "2", "level": 2, @@ -43106,7 +43961,7 @@ "label": "requestTimeout", "signature": "`requestTimeout` Type: {number} **Default:** `300000`", "apiSymbol": "requestTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#class-httpsserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#class-httpsserver", "nodeStability": { "index": "2", "level": 2, @@ -43135,7 +43990,7 @@ "label": "timeout", "signature": "`timeout` Type: {number} **Default:** 0 (no timeout)", "apiSymbol": "timeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#class-httpsserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#class-httpsserver", "nodeStability": { "index": "2", "level": 2, @@ -43164,7 +44019,7 @@ "label": "keepAliveTimeout", "signature": "`keepAliveTimeout` Type: {number} **Default:** `5000` (5 seconds)", "apiSymbol": "keepAliveTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#class-httpsserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#class-httpsserver", "nodeStability": { "index": "2", "level": 2, @@ -43193,7 +44048,7 @@ "label": "https.createServer([options][, requestListener])", "signature": "`https.createServer([options][, requestListener])`", "apiSymbol": "https.createServer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#httpscreateserveroptions-requestlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#httpscreateserveroptions-requestlistener", "nodeStability": { "index": "2", "level": 2, @@ -43222,7 +44077,7 @@ "label": "https.get(options[, callback])", "signature": "`https.get(options[, callback])`", "apiSymbol": "https.get", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#httpsgetoptions-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#httpsgetoptions-callback", "nodeStability": { "index": "2", "level": 2, @@ -43251,7 +44106,7 @@ "label": "https.get(url[, options][, callback])", "signature": "`https.get(url[, options][, callback])`", "apiSymbol": "https.get", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#httpsgeturl-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#httpsgeturl-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -43280,7 +44135,7 @@ "label": "https.request(options[, callback])", "signature": "`https.request(options[, callback])`", "apiSymbol": "https.request", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#httpsrequestoptions-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#httpsrequestoptions-callback", "nodeStability": { "index": "2", "level": 2, @@ -43309,7 +44164,7 @@ "label": "https.request(url[, options][, callback])", "signature": "`https.request(url[, options][, callback])`", "apiSymbol": "https.request", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#httpsrequesturl-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#httpsrequesturl-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -43338,7 +44193,7 @@ "label": "https.globalAgent", "signature": "`https.globalAgent`", "apiSymbol": "https.globalAgent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/https.html#httpsglobalagent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/https.html#httpsglobalagent", "nodeStability": { "index": "2", "level": 2, @@ -43363,7 +44218,7 @@ "label": "inspector.Session", "signature": "Class: `inspector.Session`", "apiSymbol": "inspector.Session", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#class-inspectorsession", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#class-inspectorsession", "nodeStability": { "index": "1", "level": 1, @@ -43388,7 +44243,7 @@ "label": "session.connect()", "signature": "`session.connect()`", "apiSymbol": "session.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#sessionconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#sessionconnect", "nodeStability": { "index": "1", "level": 1, @@ -43413,7 +44268,7 @@ "label": "session.connectToMainThread()", "signature": "`session.connectToMainThread()`", "apiSymbol": "session.connectToMainThread", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#sessionconnecttomainthread", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#sessionconnecttomainthread", "nodeStability": { "index": "1", "level": 1, @@ -43438,7 +44293,7 @@ "label": "session.disconnect()", "signature": "`session.disconnect()`", "apiSymbol": "session.disconnect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#sessiondisconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#sessiondisconnect", "nodeStability": { "index": "1", "level": 1, @@ -43463,7 +44318,7 @@ "label": "session.post(method[, params])", "signature": "`session.post(method[, params])`", "apiSymbol": "session.post", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#sessionpostmethod-params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#sessionpostmethod-params", "nodeStability": { "index": "1", "level": 1, @@ -43488,7 +44343,7 @@ "label": "'inspectorNotification'", "signature": "Event: `'inspectorNotification'`", "apiSymbol": "'inspectorNotification'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#event-inspectornotification", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#event-inspectornotification", "nodeStability": { "index": "1", "level": 1, @@ -43513,7 +44368,7 @@ "label": "", "signature": "Event: ``", "apiSymbol": "", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#event-inspector-protocol-method", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#event-inspector-protocol-method", "nodeStability": { "index": "1", "level": 1, @@ -43538,7 +44393,7 @@ "label": "inspector.Session", "signature": "Class: `inspector.Session`", "apiSymbol": "inspector.Session", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#class-inspectorsession_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#class-inspectorsession_1", "nodeStability": { "index": "2", "level": 2, @@ -43563,7 +44418,7 @@ "label": "session.connect()", "signature": "`session.connect()`", "apiSymbol": "session.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#sessionconnect_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#sessionconnect_1", "nodeStability": { "index": "2", "level": 2, @@ -43588,7 +44443,7 @@ "label": "session.connectToMainThread()", "signature": "`session.connectToMainThread()`", "apiSymbol": "session.connectToMainThread", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#sessionconnecttomainthread_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#sessionconnecttomainthread_1", "nodeStability": { "index": "2", "level": 2, @@ -43613,7 +44468,7 @@ "label": "session.disconnect()", "signature": "`session.disconnect()`", "apiSymbol": "session.disconnect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#sessiondisconnect_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#sessiondisconnect_1", "nodeStability": { "index": "2", "level": 2, @@ -43638,7 +44493,7 @@ "label": "session.post(method[, params][, callback])", "signature": "`session.post(method[, params][, callback])`", "apiSymbol": "session.post", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#sessionpostmethod-params-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#sessionpostmethod-params-callback", "nodeStability": { "index": "2", "level": 2, @@ -43663,7 +44518,7 @@ "label": "'inspectorNotification'", "signature": "Event: `'inspectorNotification'`", "apiSymbol": "'inspectorNotification'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#event-inspectornotification_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#event-inspectornotification_1", "nodeStability": { "index": "2", "level": 2, @@ -43688,7 +44543,7 @@ "label": ";", "signature": "Event: ``;", "apiSymbol": "", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#event-inspector-protocol-method_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#event-inspector-protocol-method_1", "nodeStability": { "index": "2", "level": 2, @@ -43713,7 +44568,7 @@ "label": "inspector.close()", "signature": "`inspector.close()`", "apiSymbol": "inspector.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectorclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectorclose", "nodeStability": { "index": "2", "level": 2, @@ -43738,7 +44593,7 @@ "label": "inspector.open([port[, host[, wait]]])", "signature": "`inspector.open([port[, host[, wait]]])`", "apiSymbol": "inspector.open", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectoropenport-host-wait", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectoropenport-host-wait", "nodeStability": { "index": "2", "level": 2, @@ -43763,7 +44618,7 @@ "label": "inspector.url()", "signature": "`inspector.url()`", "apiSymbol": "inspector.url", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectorurl", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectorurl", "nodeStability": { "index": "2", "level": 2, @@ -43788,7 +44643,7 @@ "label": "inspector.waitForDebugger()", "signature": "`inspector.waitForDebugger()`", "apiSymbol": "inspector.waitForDebugger", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectorwaitfordebugger", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectorwaitfordebugger", "nodeStability": { "index": "2", "level": 2, @@ -43813,7 +44668,7 @@ "label": "console", "signature": "`console` Type: {Object} An object to send messages to the remote inspector console.", "apiSymbol": "console", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#common-objects", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#common-objects", "nodeStability": { "index": "2", "level": 2, @@ -43838,7 +44693,7 @@ "label": "inspector.Network.dataReceived([params])", "signature": "`inspector.Network.dataReceived([params])`", "apiSymbol": "inspector.Network.dataReceived", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectornetworkdatareceivedparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectornetworkdatareceivedparams", "nodeStability": { "index": "1.1", "level": 1, @@ -43863,7 +44718,7 @@ "label": "inspector.Network.dataSent([params])", "signature": "`inspector.Network.dataSent([params])`", "apiSymbol": "inspector.Network.dataSent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectornetworkdatasentparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectornetworkdatasentparams", "nodeStability": { "index": "1.1", "level": 1, @@ -43888,7 +44743,7 @@ "label": "inspector.Network.requestWillBeSent([params])", "signature": "`inspector.Network.requestWillBeSent([params])`", "apiSymbol": "inspector.Network.requestWillBeSent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectornetworkrequestwillbesentparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectornetworkrequestwillbesentparams", "nodeStability": { "index": "1.1", "level": 1, @@ -43913,7 +44768,7 @@ "label": "inspector.Network.responseReceived([params])", "signature": "`inspector.Network.responseReceived([params])`", "apiSymbol": "inspector.Network.responseReceived", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectornetworkresponsereceivedparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectornetworkresponsereceivedparams", "nodeStability": { "index": "1.1", "level": 1, @@ -43938,7 +44793,7 @@ "label": "inspector.Network.loadingFinished([params])", "signature": "`inspector.Network.loadingFinished([params])`", "apiSymbol": "inspector.Network.loadingFinished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectornetworkloadingfinishedparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectornetworkloadingfinishedparams", "nodeStability": { "index": "1.1", "level": 1, @@ -43963,7 +44818,7 @@ "label": "inspector.Network.loadingFailed([params])", "signature": "`inspector.Network.loadingFailed([params])`", "apiSymbol": "inspector.Network.loadingFailed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectornetworkloadingfailedparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectornetworkloadingfailedparams", "nodeStability": { "index": "1.1", "level": 1, @@ -43988,7 +44843,7 @@ "label": "inspector.Network.webSocketCreated([params])", "signature": "`inspector.Network.webSocketCreated([params])`", "apiSymbol": "inspector.Network.webSocketCreated", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectornetworkwebsocketcreatedparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectornetworkwebsocketcreatedparams", "nodeStability": { "index": "1.1", "level": 1, @@ -44013,7 +44868,7 @@ "label": "inspector.Network.webSocketHandshakeResponseReceived([params])", "signature": "`inspector.Network.webSocketHandshakeResponseReceived([params])`", "apiSymbol": "inspector.Network.webSocketHandshakeResponseReceived", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectornetworkwebsockethandshakeresponsereceivedparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectornetworkwebsockethandshakeresponsereceivedparams", "nodeStability": { "index": "1.1", "level": 1, @@ -44038,7 +44893,7 @@ "label": "inspector.Network.webSocketClosed([params])", "signature": "`inspector.Network.webSocketClosed([params])`", "apiSymbol": "inspector.Network.webSocketClosed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectornetworkwebsocketclosedparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectornetworkwebsocketclosedparams", "nodeStability": { "index": "1.1", "level": 1, @@ -44063,7 +44918,7 @@ "label": "inspector.NetworkResources.put", "signature": "`inspector.NetworkResources.put`", "apiSymbol": "inspector.NetworkResources.put", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/inspector.html#inspectornetworkresourcesput", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#inspectornetworkresourcesput", "nodeStability": { "index": "1.1", "level": 1, @@ -44082,13 +44937,1738 @@ } } }, + { + "id": "inspector:91e693d16a79", + "chapter": "inspector", + "label": "domStorageItemAdded", + "signature": "`domStorageItemAdded` `params` {Object}", + "apiSymbol": "domStorageItemAdded", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:inspector", + "tests": [] + } + } + }, + { + "id": "inspector:ac553f71ee67", + "chapter": "inspector", + "label": "domStorageItemRemoved", + "signature": "`domStorageItemRemoved` `params` {Object}", + "apiSymbol": "domStorageItemRemoved", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:inspector", + "tests": [] + } + } + }, + { + "id": "inspector:551b41cae8b6", + "chapter": "inspector", + "label": "domStorageItemUpdated", + "signature": "`domStorageItemUpdated` `params` {Object}", + "apiSymbol": "domStorageItemUpdated", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:inspector", + "tests": [] + } + } + }, + { + "id": "inspector:3cba411858f1", + "chapter": "inspector", + "label": "domStorageItemsCleared", + "signature": "`domStorageItemsCleared` `params` {Object}", + "apiSymbol": "domStorageItemsCleared", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:inspector", + "tests": [] + } + } + }, + { + "id": "inspector:352bce26d961", + "chapter": "inspector", + "label": "registerStorage", + "signature": "`registerStorage` `params` {Object}", + "apiSymbol": "registerStorage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/inspector.html#integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:inspector", + "tests": [] + } + } + }, + { + "id": "stream_iter:74881c7a8ea5", + "chapter": "stream_iter", + "label": "writer.end([options])", + "signature": "`writer.end([options])`", + "apiSymbol": "writer.end", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#writerendoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:25b778a0a19a", + "chapter": "stream_iter", + "label": "writer.endSync()", + "signature": "`writer.endSync()`", + "apiSymbol": "writer.endSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#writerendsync", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:dd1332b8c7a3", + "chapter": "stream_iter", + "label": "writer.fail(reason)", + "signature": "`writer.fail(reason)`", + "apiSymbol": "writer.fail", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#writerfailreason", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:9fe673a6f9a0", + "chapter": "stream_iter", + "label": "writer[Symbol.asyncDispose]()", + "signature": "`writer[Symbol.asyncDispose]()`", + "apiSymbol": "writer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#writersymbolasyncdispose", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:122792b034fd", + "chapter": "stream_iter", + "label": "writer.write(chunk[, options])", + "signature": "`writer.write(chunk[, options])`", + "apiSymbol": "writer.write", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#writerwritechunk-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:70029a8cc441", + "chapter": "stream_iter", + "label": "writer.writeSync(chunk)", + "signature": "`writer.writeSync(chunk)`", + "apiSymbol": "writer.writeSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#writerwritesyncchunk", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:75d546da6ee2", + "chapter": "stream_iter", + "label": "writer.writev(chunks[, options])", + "signature": "`writer.writev(chunks[, options])`", + "apiSymbol": "writer.writev", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#writerwritevchunks-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:9b24338e15dd", + "chapter": "stream_iter", + "label": "writer.writevSync(chunks)", + "signature": "`writer.writevSync(chunks)`", + "apiSymbol": "writer.writevSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#writerwritevsyncchunks", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:71e88296da2b", + "chapter": "stream_iter", + "label": "canWrite", + "signature": "`canWrite` {boolean|null}", + "apiSymbol": "canWrite", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#writer-interface", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:f31bb04ebfd3", + "chapter": "stream_iter", + "label": "The stream/iter module", + "signature": "The `stream/iter` module", + "apiSymbol": "stream/iter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#the-streamiter-module", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:e81bf2b065dc", + "chapter": "stream_iter", + "label": "from(input)", + "signature": "`from(input)`", + "apiSymbol": "from", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#frominput", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:6f3664ed818c", + "chapter": "stream_iter", + "label": "fromSync(input)", + "signature": "`fromSync(input)`", + "apiSymbol": "fromSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#fromsyncinput", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:c35641af526f", + "chapter": "stream_iter", + "label": "pipeTo(source[, ...transforms], writer[, options])", + "signature": "`pipeTo(source[, ...transforms], writer[, options])`", + "apiSymbol": "pipeTo", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#pipetosource-transforms-writer-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:2daa0291481c", + "chapter": "stream_iter", + "label": "pipeToSync(source[, ...transforms], writer[, options])", + "signature": "`pipeToSync(source[, ...transforms], writer[, options])`", + "apiSymbol": "pipeToSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#pipetosyncsource-transforms-writer-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:00e796148b11", + "chapter": "stream_iter", + "label": "pull(source[, ...transforms][, options])", + "signature": "`pull(source[, ...transforms][, options])`", + "apiSymbol": "pull", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#pullsource-transforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:f89b0e75e302", + "chapter": "stream_iter", + "label": "pullSync(source[, ...transforms])", + "signature": "`pullSync(source[, ...transforms])`", + "apiSymbol": "pullSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#pullsyncsource-transforms", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:ea066cb12f48", + "chapter": "stream_iter", + "label": "push([...transforms][, options])", + "signature": "`push([...transforms][, options])`", + "apiSymbol": "push", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#pushtransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:199f13b2e259", + "chapter": "stream_iter", + "label": "duplex([options])", + "signature": "`duplex([options])`", + "apiSymbol": "duplex", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#duplexoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:921683aeccfe", + "chapter": "stream_iter", + "label": "array(source[, options])", + "signature": "`array(source[, options])`", + "apiSymbol": "array", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#arraysource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:fbf10b4b189e", + "chapter": "stream_iter", + "label": "arrayBuffer(source[, options])", + "signature": "`arrayBuffer(source[, options])`", + "apiSymbol": "arrayBuffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#arraybuffersource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:e0afcafcc6fb", + "chapter": "stream_iter", + "label": "arrayBufferSync(source[, options])", + "signature": "`arrayBufferSync(source[, options])`", + "apiSymbol": "arrayBufferSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#arraybuffersyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:b0128d2ee8ff", + "chapter": "stream_iter", + "label": "arraySync(source[, options])", + "signature": "`arraySync(source[, options])`", + "apiSymbol": "arraySync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#arraysyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:463c54160f7b", + "chapter": "stream_iter", + "label": "bytes(source[, options])", + "signature": "`bytes(source[, options])`", + "apiSymbol": "bytes", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#bytessource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:ee97f670b7fe", + "chapter": "stream_iter", + "label": "bytesSync(source[, options])", + "signature": "`bytesSync(source[, options])`", + "apiSymbol": "bytesSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#bytessyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:64923f0bbaa4", + "chapter": "stream_iter", + "label": "text(source[, options])", + "signature": "`text(source[, options])`", + "apiSymbol": "text", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#textsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:920695b6cf72", + "chapter": "stream_iter", + "label": "textSync(source[, options])", + "signature": "`textSync(source[, options])`", + "apiSymbol": "textSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#textsyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:8b98f79752a4", + "chapter": "stream_iter", + "label": "ondrain(drainable)", + "signature": "`ondrain(drainable)`", + "apiSymbol": "ondrain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#ondraindrainable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:87224fe2c755", + "chapter": "stream_iter", + "label": "merge(...sources[, options])", + "signature": "`merge(...sources[, options])`", + "apiSymbol": "merge", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#mergesources-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:5fd18544d6db", + "chapter": "stream_iter", + "label": "tap(callback)", + "signature": "`tap(callback)`", + "apiSymbol": "tap", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#tapcallback", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:b86a9a538ee6", + "chapter": "stream_iter", + "label": "tapSync(callback)", + "signature": "`tapSync(callback)`", + "apiSymbol": "tapSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#tapsynccallback", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:942c17d001f2", + "chapter": "stream_iter", + "label": "Interface: Shareable", + "signature": "Interface: `Shareable`", + "apiSymbol": "Shareable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#interface-shareable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:3468fe11b070", + "chapter": "stream_iter", + "label": "sharable[Symbol.for('Stream.shareProtocol')]", + "signature": "`sharable[Symbol.for('Stream.shareProtocol')]`", + "apiSymbol": "sharable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#sharablesymbolforstreamshareprotocol", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:4155dfe49484", + "chapter": "stream_iter", + "label": "Interface: SyncShareable", + "signature": "Interface: `SyncShareable`", + "apiSymbol": "SyncShareable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#interface-syncshareable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:242fb4da0e1d", + "chapter": "stream_iter", + "label": "sharable[Symbol.for('Stream.shareSyncProtocol')]", + "signature": "`sharable[Symbol.for('Stream.shareSyncProtocol')]`", + "apiSymbol": "sharable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#sharablesymbolforstreamsharesyncprotocol", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:c284e9cc071d", + "chapter": "stream_iter", + "label": "Share", + "signature": "Class: `Share`", + "apiSymbol": "Share", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#class-share", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:699ee25e7836", + "chapter": "stream_iter", + "label": "share.cancel([reason])", + "signature": "`share.cancel([reason])`", + "apiSymbol": "share.cancel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#sharecancelreason", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:8fcfa00b2e13", + "chapter": "stream_iter", + "label": "share.pull([...transforms][, options])", + "signature": "`share.pull([...transforms][, options])`", + "apiSymbol": "share.pull", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#sharepulltransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:72b6caf2da05", + "chapter": "stream_iter", + "label": "share[Symbol.dispose]()", + "signature": "`share[Symbol.dispose]()`", + "apiSymbol": "share", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#sharesymboldispose", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:ff3d33f63dae", + "chapter": "stream_iter", + "label": "consumerCount", + "signature": "`consumerCount` {number}", + "apiSymbol": "consumerCount", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#class-share", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:56fab04f6670", + "chapter": "stream_iter", + "label": "SyncShare", + "signature": "Class: `SyncShare`", + "apiSymbol": "SyncShare", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#class-syncshare", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:738b333def1d", + "chapter": "stream_iter", + "label": "share.cancel([reason])", + "signature": "`share.cancel([reason])`", + "apiSymbol": "share.cancel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#sharecancelreason_1", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:54163998d82f", + "chapter": "stream_iter", + "label": "share.pull([...transforms][, options])", + "signature": "`share.pull([...transforms][, options])`", + "apiSymbol": "share.pull", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#sharepulltransforms-options_1", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:9947ae5ee9f7", + "chapter": "stream_iter", + "label": "share[Symbol.dispose]()", + "signature": "`share[Symbol.dispose]()`", + "apiSymbol": "share", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#sharesymboldispose_1", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:eb993c0d329d", + "chapter": "stream_iter", + "label": "bufferSize", + "signature": "`bufferSize` {number}", + "apiSymbol": "bufferSize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#class-syncshare", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:84388db1cec2", + "chapter": "stream_iter", + "label": "consumerCount", + "signature": "`consumerCount` {number}", + "apiSymbol": "consumerCount", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#class-syncshare", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:fcc12813a840", + "chapter": "stream_iter", + "label": "broadcast([options])", + "signature": "`broadcast([options])`", + "apiSymbol": "broadcast", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#broadcastoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:7909dd2cdb5d", + "chapter": "stream_iter", + "label": "broadcast.cancel([reason])", + "signature": "`broadcast.cancel([reason])`", + "apiSymbol": "broadcast.cancel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#broadcastcancelreason", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:676e8ecc6237", + "chapter": "stream_iter", + "label": "broadcast.push([...transforms][, options])", + "signature": "`broadcast.push([...transforms][, options])`", + "apiSymbol": "broadcast.push", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#broadcastpushtransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:23f1e2d4c639", + "chapter": "stream_iter", + "label": "broadcast[Symbol.dispose]()", + "signature": "`broadcast[Symbol.dispose]()`", + "apiSymbol": "broadcast", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#broadcastsymboldispose", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:75b743029db1", + "chapter": "stream_iter", + "label": "consumerCount", + "signature": "`consumerCount` {number}", + "apiSymbol": "consumerCount", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#broadcastoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:fd8809959bcf", + "chapter": "stream_iter", + "label": "Broadcast.from(input[, options])", + "signature": "`Broadcast.from(input[, options])`", + "apiSymbol": "Broadcast.from", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#broadcastfrominput-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:e47f09ec7c74", + "chapter": "stream_iter", + "label": "share(source[, options])", + "signature": "`share(source[, options])`", + "apiSymbol": "share", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#sharesource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:8e955476f8e6", + "chapter": "stream_iter", + "label": "shareSync(source[, options])", + "signature": "`shareSync(source[, options])`", + "apiSymbol": "shareSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#sharesyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:335f2485e371", + "chapter": "stream_iter", + "label": "fromReadable(readable)", + "signature": "`fromReadable(readable)`", + "apiSymbol": "fromReadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#fromreadablereadable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:58f5bcd9e475", + "chapter": "stream_iter", + "label": "fromWritable(writable[, options])", + "signature": "`fromWritable(writable[, options])`", + "apiSymbol": "fromWritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#fromwritablewritable-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:f2dddb7c0fd6", + "chapter": "stream_iter", + "label": "toReadable(source[, options])", + "signature": "`toReadable(source[, options])`", + "apiSymbol": "toReadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#toreadablesource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:980c4eedf78c", + "chapter": "stream_iter", + "label": "toReadableSync(source[, options])", + "signature": "`toReadableSync(source[, options])`", + "apiSymbol": "toReadableSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#toreadablesyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:0eadccfb86e1", + "chapter": "stream_iter", + "label": "toWritable(writer)", + "signature": "`toWritable(writer)`", + "apiSymbol": "toWritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#towritablewriter", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:a3fb72adb9d4", + "chapter": "stream_iter", + "label": "broadcastProtocol", + "signature": "`broadcastProtocol` Value: `Symbol.for('Stream.broadcastProtocol')`", + "apiSymbol": "broadcastProtocol", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:80709c59ac66", + "chapter": "stream_iter", + "label": "drainableProtocol", + "signature": "`drainableProtocol` Value: `Symbol.for('Stream.drainableProtocol')`", + "apiSymbol": "drainableProtocol", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:d6e40713d854", + "chapter": "stream_iter", + "label": "shareProtocol", + "signature": "`shareProtocol` Value: `Symbol.for('Stream.shareProtocol')`", + "apiSymbol": "shareProtocol", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:1df144641604", + "chapter": "stream_iter", + "label": "shareSyncProtocol", + "signature": "`shareSyncProtocol` Value: `Symbol.for('Stream.shareSyncProtocol')`", + "apiSymbol": "shareSyncProtocol", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:02b320eb031a", + "chapter": "stream_iter", + "label": "toAsyncStreamable", + "signature": "`toAsyncStreamable` Value: `Symbol.for('Stream.toAsyncStreamable')`", + "apiSymbol": "toAsyncStreamable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, + { + "id": "stream_iter:870e05b0278a", + "chapter": "stream_iter", + "label": "toStreamable", + "signature": "`toStreamable` Value: `Symbol.for('Stream.toStreamable')`", + "apiSymbol": "toStreamable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream_iter.html#protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream_iter", + "tests": [] + } + } + }, { "id": "modules:748c4e009d36", "chapter": "modules", "label": "Loading ECMAScript modules using require()", "signature": "Loading ECMAScript modules using `require()`", "apiSymbol": "require", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#loading-ecmascript-modules-using-require", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#loading-ecmascript-modules-using-require", "nodeStability": { "index": "2", "level": 2, @@ -44120,7 +46700,7 @@ "label": "__dirname", "signature": "`__dirname`", "apiSymbol": "__dirname", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#__dirname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#__dirname", "nodeStability": { "index": "2", "level": 2, @@ -44152,7 +46732,7 @@ "label": "__filename", "signature": "`__filename`", "apiSymbol": "__filename", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#__filename", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#__filename", "nodeStability": { "index": "2", "level": 2, @@ -44184,7 +46764,7 @@ "label": "exports", "signature": "`exports`", "apiSymbol": "exports", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#exports", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#exports", "nodeStability": { "index": "2", "level": 2, @@ -44216,7 +46796,7 @@ "label": "module", "signature": "`module`", "apiSymbol": "module", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#module", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#module", "nodeStability": { "index": "2", "level": 2, @@ -44241,7 +46821,7 @@ "label": "require(id)", "signature": "`require(id)`", "apiSymbol": "require", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#requireid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#requireid", "nodeStability": { "index": "2", "level": 2, @@ -44273,7 +46853,7 @@ "label": "require.resolve(request[, options])", "signature": "`require.resolve(request[, options])`", "apiSymbol": "require.resolve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#requireresolverequest-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#requireresolverequest-options", "nodeStability": { "index": "2", "level": 2, @@ -44301,7 +46881,7 @@ "label": "require.resolve.paths(request)", "signature": "`require.resolve.paths(request)`", "apiSymbol": "require.resolve.paths", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#requireresolvepathsrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#requireresolvepathsrequest", "nodeStability": { "index": "2", "level": 2, @@ -44329,7 +46909,7 @@ "label": "cache", "signature": "`cache` Type: {Object}", "apiSymbol": "cache", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#requireid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#requireid", "nodeStability": { "index": "2", "level": 2, @@ -44356,7 +46936,7 @@ "label": "extensions", "signature": "`extensions` Type: {Object}", "apiSymbol": "extensions", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#requireid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#requireid", "nodeStability": { "index": "0", "level": 0, @@ -44381,7 +46961,7 @@ "label": "main", "signature": "`main` Type: {module | undefined}", "apiSymbol": "main", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#requireid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#requireid", "nodeStability": { "index": "2", "level": 2, @@ -44413,7 +46993,7 @@ "label": "The module object", "signature": "The `module` object", "apiSymbol": "module", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#the-module-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#the-module-object", "nodeStability": { "index": "2", "level": 2, @@ -44438,7 +47018,7 @@ "label": "module.require(id)", "signature": "`module.require(id)`", "apiSymbol": "module.require", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#modulerequireid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#modulerequireid", "nodeStability": { "index": "2", "level": 2, @@ -44470,7 +47050,7 @@ "label": "children", "signature": "`children` Type: {module\\[]}", "apiSymbol": "children", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#the-module-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#the-module-object", "nodeStability": { "index": "2", "level": 2, @@ -44497,7 +47077,7 @@ "label": "exports", "signature": "`exports` Type: {Object}", "apiSymbol": "exports", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#the-module-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#the-module-object", "nodeStability": { "index": "2", "level": 2, @@ -44529,7 +47109,7 @@ "label": "exports", "signature": "`exports` shortcut", "apiSymbol": "exports", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#exports-shortcut", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#exports-shortcut", "nodeStability": { "index": "2", "level": 2, @@ -44561,7 +47141,7 @@ "label": "filename", "signature": "`filename` Type: {string}", "apiSymbol": "filename", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#the-module-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#the-module-object", "nodeStability": { "index": "2", "level": 2, @@ -44593,7 +47173,7 @@ "label": "id", "signature": "`id` Type: {string}", "apiSymbol": "id", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#the-module-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#the-module-object", "nodeStability": { "index": "2", "level": 2, @@ -44620,7 +47200,7 @@ "label": "isPreloading", "signature": "`isPreloading` Type: {boolean} `true` if the module is running during the Node.js preload phase.", "apiSymbol": "isPreloading", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#the-module-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#the-module-object", "nodeStability": { "index": "2", "level": 2, @@ -44647,7 +47227,7 @@ "label": "loaded", "signature": "`loaded` Type: {boolean}", "apiSymbol": "loaded", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#the-module-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#the-module-object", "nodeStability": { "index": "2", "level": 2, @@ -44674,7 +47254,7 @@ "label": "parent", "signature": "`parent` Type: {module | null | undefined}", "apiSymbol": "parent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#the-module-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#the-module-object", "nodeStability": { "index": "0", "level": 0, @@ -44701,7 +47281,7 @@ "label": "path", "signature": "`path` Type: {string}", "apiSymbol": "path", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#the-module-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#the-module-object", "nodeStability": { "index": "2", "level": 2, @@ -44728,7 +47308,7 @@ "label": "paths", "signature": "`paths` Type: {string\\[]}", "apiSymbol": "paths", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#the-module-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#the-module-object", "nodeStability": { "index": "2", "level": 2, @@ -44755,7 +47335,7 @@ "label": "The Module object", "signature": "The `Module` object", "apiSymbol": "Module", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#the-module-object_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#the-module-object_1", "nodeStability": { "index": "2", "level": 2, @@ -44782,7 +47362,7 @@ "label": "Built-in modules with mandatory node: prefix", "signature": "Built-in modules with mandatory `node:` prefix", "apiSymbol": "node:", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#built-in-modules-with-mandatory-node-prefix", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#built-in-modules-with-mandatory-node-prefix", "nodeStability": { "index": "2", "level": 2, @@ -44810,7 +47390,7 @@ "label": "Loading from node_modules folders", "signature": "Loading from `node_modules` folders", "apiSymbol": "node_modules", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/modules.html#loading-from-node_modules-folders", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/modules.html#loading-from-node_modules-folders", "nodeStability": { "index": "2", "level": 2, @@ -44838,7 +47418,7 @@ "label": "meta", "signature": "`meta` Type: {Object}", "apiSymbol": "meta", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html", "nodeStability": { "index": "2", "level": 2, @@ -44867,7 +47447,7 @@ "label": "import.meta.resolve(specifier)", "signature": "`import.meta.resolve(specifier)`", "apiSymbol": "import.meta.resolve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#importmetaresolvespecifier", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#importmetaresolvespecifier", "nodeStability": { "index": "1.2", "level": 1, @@ -44894,7 +47474,7 @@ "label": "dirname", "signature": "`dirname` Type: {string} The directory name of the current module.", "apiSymbol": "dirname", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html", "nodeStability": { "index": "2", "level": 2, @@ -44923,7 +47503,7 @@ "label": "filename", "signature": "`filename` Type: {string} The full absolute path and filename of the current module, with symlinks resolved.", "apiSymbol": "filename", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html", "nodeStability": { "index": "2", "level": 2, @@ -44952,7 +47532,7 @@ "label": "url", "signature": "`url` Type: {string} The absolute `file:` URL of the module.", "apiSymbol": "url", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html", "nodeStability": { "index": "2", "level": 2, @@ -44981,7 +47561,7 @@ "label": "main", "signature": "`main` Type: {boolean} `true` when the current module is the entry point of the current process; `false` otherwise.", "apiSymbol": "main", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html", "nodeStability": { "index": "1.0", "level": 1, @@ -45010,7 +47590,7 @@ "label": "import", "signature": "`import` Specifiers", "apiSymbol": "import", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#import-specifiers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#import-specifiers", "nodeStability": { "index": "2", "level": 2, @@ -45041,7 +47621,7 @@ "label": "file:", "signature": "`file:` URLs", "apiSymbol": "file:", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#file-urls", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#file-urls", "nodeStability": { "index": "2", "level": 2, @@ -45072,7 +47652,7 @@ "label": "data:", "signature": "`data:` imports", "apiSymbol": "data:", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#data-imports", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#data-imports", "nodeStability": { "index": "2", "level": 2, @@ -45097,7 +47677,7 @@ "label": "node:", "signature": "`node:` imports", "apiSymbol": "node:", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#node-imports", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#node-imports", "nodeStability": { "index": "2", "level": 2, @@ -45128,7 +47708,7 @@ "label": "import()", "signature": "`import()` expressions", "apiSymbol": "import", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#import-expressions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#import-expressions", "nodeStability": { "index": "2", "level": 2, @@ -45159,7 +47739,7 @@ "label": "import", "signature": "`import` statements", "apiSymbol": "import", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#import-statements", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#import-statements", "nodeStability": { "index": "2", "level": 2, @@ -45190,7 +47770,7 @@ "label": "require", "signature": "`require`", "apiSymbol": "require", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#require", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#require", "nodeStability": { "index": "2", "level": 2, @@ -45215,7 +47795,7 @@ "label": "No require, exports, or module.exports", "signature": "No `require`, `exports`, or `module.exports`", "apiSymbol": "require", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#no-require-exports-or-moduleexports", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#no-require-exports-or-moduleexports", "nodeStability": { "index": "2", "level": 2, @@ -45240,7 +47820,7 @@ "label": "No __filename or __dirname", "signature": "No `__filename` or `__dirname`", "apiSymbol": "__filename", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#no-__filename-or-__dirname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#no-__filename-or-__dirname", "nodeStability": { "index": "2", "level": 2, @@ -45265,7 +47845,7 @@ "label": "No require.main", "signature": "No `require.main`", "apiSymbol": "require.main", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#no-requiremain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#no-requiremain", "nodeStability": { "index": "2", "level": 2, @@ -45290,7 +47870,7 @@ "label": "No require.resolve", "signature": "No `require.resolve`", "apiSymbol": "require.resolve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#no-requireresolve", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#no-requireresolve", "nodeStability": { "index": "2", "level": 2, @@ -45315,7 +47895,7 @@ "label": "No NODE_PATH", "signature": "No `NODE_PATH`", "apiSymbol": "NODE_PATH", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#no-node_path", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#no-node_path", "nodeStability": { "index": "2", "level": 2, @@ -45340,7 +47920,7 @@ "label": "No require.extensions", "signature": "No `require.extensions`", "apiSymbol": "require.extensions", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#no-requireextensions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#no-requireextensions", "nodeStability": { "index": "2", "level": 2, @@ -45365,7 +47945,7 @@ "label": "No require.cache", "signature": "No `require.cache`", "apiSymbol": "require.cache", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#no-requirecache", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#no-requirecache", "nodeStability": { "index": "2", "level": 2, @@ -45390,7 +47970,7 @@ "label": "Top-level await", "signature": "Top-level `await`", "apiSymbol": "await", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/esm.html#top-level-await", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/esm.html#top-level-await", "nodeStability": { "index": "2", "level": 2, @@ -45421,7 +48001,7 @@ "label": "The Module object", "signature": "The `Module` object", "apiSymbol": "Module", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#the-module-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#the-module-object", "nodeStability": null, "priority": "normal", "tiers": { @@ -45441,7 +48021,7 @@ "label": "module.createRequire(filename)", "signature": "`module.createRequire(filename)`", "apiSymbol": "module.createRequire", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#modulecreaterequirefilename", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#modulecreaterequirefilename", "nodeStability": null, "priority": "normal", "tiers": { @@ -45467,7 +48047,7 @@ "label": "module.findPackageJSON(specifier[, base])", "signature": "`module.findPackageJSON(specifier[, base])`", "apiSymbol": "module.findPackageJSON", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#modulefindpackagejsonspecifier-base", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#modulefindpackagejsonspecifier-base", "nodeStability": { "index": "1.1", "level": 1, @@ -45492,7 +48072,7 @@ "label": "module.isBuiltin(moduleName)", "signature": "`module.isBuiltin(moduleName)`", "apiSymbol": "module.isBuiltin", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#moduleisbuiltinmodulename", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#moduleisbuiltinmodulename", "nodeStability": null, "priority": "normal", "tiers": { @@ -45514,7 +48094,7 @@ "label": "module.register(specifier[, parentURL][, options])", "signature": "`module.register(specifier[, parentURL][, options])`", "apiSymbol": "module.register", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#moduleregisterspecifier-parenturl-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#moduleregisterspecifier-parenturl-options", "nodeStability": { "index": "0", "level": 0, @@ -45539,7 +48119,7 @@ "label": "module.registerHooks(options)", "signature": "`module.registerHooks(options)`", "apiSymbol": "module.registerHooks", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#moduleregisterhooksoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#moduleregisterhooksoptions", "nodeStability": { "index": "1.2", "level": 1, @@ -45564,7 +48144,7 @@ "label": "module.stripTypeScriptTypes(code[, options])", "signature": "`module.stripTypeScriptTypes(code[, options])`", "apiSymbol": "module.stripTypeScriptTypes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#modulestriptypescripttypescode-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#modulestriptypescripttypescode-options", "nodeStability": { "index": "1.2", "level": 1, @@ -45589,7 +48169,7 @@ "label": "module.syncBuiltinESMExports()", "signature": "`module.syncBuiltinESMExports()`", "apiSymbol": "module.syncBuiltinESMExports", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#modulesyncbuiltinesmexports", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#modulesyncbuiltinesmexports", "nodeStability": null, "priority": "normal", "tiers": { @@ -45611,7 +48191,7 @@ "label": "builtinModules", "signature": "`builtinModules` Type: {string\\[]}", "apiSymbol": "builtinModules", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#the-module-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#the-module-object", "nodeStability": null, "priority": "normal", "tiers": { @@ -45635,7 +48215,7 @@ "label": "module.enableCompileCache([options])", "signature": "`module.enableCompileCache([options])`", "apiSymbol": "module.enableCompileCache", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#moduleenablecompilecacheoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#moduleenablecompilecacheoptions", "nodeStability": null, "priority": "normal", "tiers": { @@ -45655,7 +48235,7 @@ "label": "module.flushCompileCache()", "signature": "`module.flushCompileCache()`", "apiSymbol": "module.flushCompileCache", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#moduleflushcompilecache", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#moduleflushcompilecache", "nodeStability": null, "priority": "normal", "tiers": { @@ -45675,7 +48255,7 @@ "label": "module.getCompileCacheDir()", "signature": "`module.getCompileCacheDir()`", "apiSymbol": "module.getCompileCacheDir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#modulegetcompilecachedir", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#modulegetcompilecachedir", "nodeStability": null, "priority": "normal", "tiers": { @@ -45695,7 +48275,7 @@ "label": "module.constants.compileCacheStatus", "signature": "`module.constants.compileCacheStatus`", "apiSymbol": "module.constants.compileCacheStatus", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#moduleconstantscompilecachestatus", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#moduleconstantscompilecachestatus", "nodeStability": null, "priority": "normal", "tiers": { @@ -45715,7 +48295,7 @@ "label": "module.SourceMap", "signature": "Class: `module.SourceMap`", "apiSymbol": "module.SourceMap", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#class-modulesourcemap", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#class-modulesourcemap", "nodeStability": { "index": "1", "level": 1, @@ -45740,7 +48320,7 @@ "label": "sourceMap.findEntry(lineOffset, columnOffset)", "signature": "`sourceMap.findEntry(lineOffset, columnOffset)`", "apiSymbol": "sourceMap.findEntry", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#sourcemapfindentrylineoffset-columnoffset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#sourcemapfindentrylineoffset-columnoffset", "nodeStability": { "index": "1", "level": 1, @@ -45765,7 +48345,7 @@ "label": "sourceMap.findOrigin(lineNumber, columnNumber)", "signature": "`sourceMap.findOrigin(lineNumber, columnNumber)`", "apiSymbol": "sourceMap.findOrigin", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#sourcemapfindoriginlinenumber-columnnumber", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#sourcemapfindoriginlinenumber-columnnumber", "nodeStability": { "index": "1", "level": 1, @@ -45790,7 +48370,7 @@ "label": "payload", "signature": "`payload` Returns: {Object}", "apiSymbol": "payload", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#class-modulesourcemap", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#class-modulesourcemap", "nodeStability": { "index": "1", "level": 1, @@ -45815,7 +48395,7 @@ "label": "module.getSourceMapsSupport()", "signature": "`module.getSourceMapsSupport()`", "apiSymbol": "module.getSourceMapsSupport", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#modulegetsourcemapssupport", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#modulegetsourcemapssupport", "nodeStability": { "index": "1", "level": 1, @@ -45840,7 +48420,7 @@ "label": "module.findSourceMap(path)", "signature": "`module.findSourceMap(path)`", "apiSymbol": "module.findSourceMap", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#modulefindsourcemappath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#modulefindsourcemappath", "nodeStability": { "index": "1", "level": 1, @@ -45865,7 +48445,7 @@ "label": "module.setSourceMapsSupport(enabled[, options])", "signature": "`module.setSourceMapsSupport(enabled[, options])`", "apiSymbol": "module.setSourceMapsSupport", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#modulesetsourcemapssupportenabled-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#modulesetsourcemapssupportenabled-options", "nodeStability": { "index": "1", "level": 1, @@ -45890,7 +48470,7 @@ "label": "Registering hooks before application code runs with a data: URL", "signature": "Registering hooks before application code runs with a `data:` URL", "apiSymbol": "data:", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#registering-hooks-before-application-code-runs-with-a-data-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#registering-hooks-before-application-code-runs-with-a-data-url", "nodeStability": { "index": "1.2", "level": 1, @@ -45915,7 +48495,7 @@ "label": "Hook functions accepted by module.registerHooks()", "signature": "Hook functions accepted by `module.registerHooks()`", "apiSymbol": "module.registerHooks", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#hook-functions-accepted-by-moduleregisterhooks", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#hook-functions-accepted-by-moduleregisterhooks", "nodeStability": { "index": "1.2", "level": 1, @@ -45940,7 +48520,7 @@ "label": "Synchronous resolve(specifier, context, nextResolve)", "signature": "Synchronous `resolve(specifier, context, nextResolve)`", "apiSymbol": "resolve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#synchronous-resolvespecifier-context-nextresolve", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#synchronous-resolvespecifier-context-nextresolve", "nodeStability": { "index": "1.2", "level": 1, @@ -45965,7 +48545,7 @@ "label": "Synchronous load(url, context, nextLoad)", "signature": "Synchronous `load(url, context, nextLoad)`", "apiSymbol": "load", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#synchronous-loadurl-context-nextload", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#synchronous-loadurl-context-nextload", "nodeStability": { "index": "1.2", "level": 1, @@ -45990,7 +48570,7 @@ "label": "Accepted final formats returned by load", "signature": "Accepted final formats returned by `load`", "apiSymbol": "load", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#accepted-final-formats-returned-by-load", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#accepted-final-formats-returned-by-load", "nodeStability": { "index": "1.2", "level": 1, @@ -46015,7 +48595,7 @@ "label": "Asynchronous hooks accepted by module.register()", "signature": "Asynchronous hooks accepted by `module.register()`", "apiSymbol": "module.register", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#asynchronous-hooks-accepted-by-moduleregister", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#asynchronous-hooks-accepted-by-moduleregister", "nodeStability": { "index": "1.1", "level": 1, @@ -46040,7 +48620,7 @@ "label": "Asynchronous resolve(specifier, context, nextResolve)", "signature": "Asynchronous `resolve(specifier, context, nextResolve)`", "apiSymbol": "resolve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#asynchronous-resolvespecifier-context-nextresolve", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#asynchronous-resolvespecifier-context-nextresolve", "nodeStability": { "index": "1.1", "level": 1, @@ -46065,7 +48645,7 @@ "label": "Asynchronous load(url, context, nextLoad)", "signature": "Asynchronous `load(url, context, nextLoad)`", "apiSymbol": "load", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#asynchronous-loadurl-context-nextload", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#asynchronous-loadurl-context-nextload", "nodeStability": { "index": "1.1", "level": 1, @@ -46090,7 +48670,7 @@ "label": "initialize()", "signature": "`initialize()`", "apiSymbol": "initialize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/module.html#initialize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/module.html#initialize", "nodeStability": { "index": "1.1", "level": 1, @@ -46115,7 +48695,7 @@ "label": "package.json", "signature": "`package.json` and file extensions", "apiSymbol": "package.json", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/packages.html#packagejson-and-file-extensions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/packages.html#packagejson-and-file-extensions", "nodeStability": null, "priority": "normal", "tiers": { @@ -46141,7 +48721,7 @@ "label": "Node.js package.json field definitions", "signature": "Node.js `package.json` field definitions", "apiSymbol": "package.json", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/packages.html#nodejs-packagejson-field-definitions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/packages.html#nodejs-packagejson-field-definitions", "nodeStability": null, "priority": "normal", "tiers": { @@ -46167,7 +48747,7 @@ "label": "\"name\"", "signature": "`\"name\"`", "apiSymbol": "\"name\"", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/packages.html#name", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/packages.html#name", "nodeStability": null, "priority": "normal", "tiers": { @@ -46193,7 +48773,7 @@ "label": "\"main\"", "signature": "`\"main\"`", "apiSymbol": "\"main\"", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/packages.html#main", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/packages.html#main", "nodeStability": null, "priority": "normal", "tiers": { @@ -46219,7 +48799,7 @@ "label": "\"type\"", "signature": "`\"type\"`", "apiSymbol": "\"type\"", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/packages.html#type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/packages.html#type", "nodeStability": null, "priority": "normal", "tiers": { @@ -46245,7 +48825,7 @@ "label": "\"exports\"", "signature": "`\"exports\"`", "apiSymbol": "\"exports\"", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/packages.html#exports", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/packages.html#exports", "nodeStability": null, "priority": "normal", "tiers": { @@ -46271,7 +48851,7 @@ "label": "\"imports\"", "signature": "`\"imports\"`", "apiSymbol": "\"imports\"", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/packages.html#imports", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/packages.html#imports", "nodeStability": null, "priority": "normal", "tiers": { @@ -46297,7 +48877,7 @@ "label": "net.BlockList", "signature": "Class: `net.BlockList`", "apiSymbol": "net.BlockList", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netblocklist", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netblocklist", "nodeStability": null, "priority": "normal", "tiers": { @@ -46317,7 +48897,67 @@ "label": "blockList.addAddress(address[, type])", "signature": "`blockList.addAddress(address[, type])`", "apiSymbol": "blockList.addAddress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#blocklistaddaddressaddress-type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistaddaddressaddress-type", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:bed278373fec", + "chapter": "net", + "label": "blockList.addAddresses(addresses[, type])", + "signature": "`blockList.addAddresses(addresses[, type])`", + "apiSymbol": "blockList.addAddresses", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistaddaddressesaddresses-type", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:3eab1fde8dda", + "chapter": "net", + "label": "blockList.addCIDR(cidr)", + "signature": "`blockList.addCIDR(cidr)`", + "apiSymbol": "blockList.addCIDR", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistaddcidrcidr", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:85bb2c28b8b4", + "chapter": "net", + "label": "blockList.addCIDRs(cidrs)", + "signature": "`blockList.addCIDRs(cidrs)`", + "apiSymbol": "blockList.addCIDRs", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistaddcidrscidrs", "nodeStability": null, "priority": "normal", "tiers": { @@ -46337,7 +48977,7 @@ "label": "blockList.addRange(start, end[, type])", "signature": "`blockList.addRange(start, end[, type])`", "apiSymbol": "blockList.addRange", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#blocklistaddrangestart-end-type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistaddrangestart-end-type", "nodeStability": null, "priority": "normal", "tiers": { @@ -46357,7 +48997,7 @@ "label": "blockList.addSubnet(net, prefix[, type])", "signature": "`blockList.addSubnet(net, prefix[, type])`", "apiSymbol": "blockList.addSubnet", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#blocklistaddsubnetnet-prefix-type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistaddsubnetnet-prefix-type", "nodeStability": null, "priority": "normal", "tiers": { @@ -46377,7 +49017,7 @@ "label": "blockList.check(address[, type])", "signature": "`blockList.check(address[, type])`", "apiSymbol": "blockList.check", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#blocklistcheckaddress-type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistcheckaddress-type", "nodeStability": null, "priority": "normal", "tiers": { @@ -46392,12 +49032,12 @@ } }, { - "id": "net:4ff6a4c12f52", + "id": "net:e0681ee0179f", "chapter": "net", - "label": "BlockList.isBlockList(value)", - "signature": "`BlockList.isBlockList(value)`", - "apiSymbol": "BlockList.isBlockList", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#blocklistisblocklistvalue", + "label": "blockList.clear()", + "signature": "`blockList.clear()`", + "apiSymbol": "blockList.clear", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistclear", "nodeStability": null, "priority": "normal", "tiers": { @@ -46417,14 +49057,114 @@ "label": "blockList.fromJSON(value)", "signature": "`blockList.fromJSON(value)`", "apiSymbol": "blockList.fromJSON", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#blocklistfromjsonvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistfromjsonvalue", "nodeStability": { - "index": "1", + "index": "1.2", "level": 1, - "text": "Experimental", + "text": "Release candidate", "inherited": false }, - "priority": "low", + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:4ff6a4c12f52", + "chapter": "net", + "label": "BlockList.isBlockList(value)", + "signature": "`BlockList.isBlockList(value)`", + "apiSymbol": "BlockList.isBlockList", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistisblocklistvalue", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:6ccaedabc10a", + "chapter": "net", + "label": "blockList.removeAddress(address[, type])", + "signature": "`blockList.removeAddress(address[, type])`", + "apiSymbol": "blockList.removeAddress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistremoveaddressaddress-type", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:03c6467a8162", + "chapter": "net", + "label": "blockList.removeCIDR(cidr)", + "signature": "`blockList.removeCIDR(cidr)`", + "apiSymbol": "blockList.removeCIDR", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistremovecidrcidr", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:8ba4f8ec27e3", + "chapter": "net", + "label": "blockList.removeRange(start, end[, type])", + "signature": "`blockList.removeRange(start, end[, type])`", + "apiSymbol": "blockList.removeRange", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistremoverangestart-end-type", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:6cc98f6368e6", + "chapter": "net", + "label": "blockList.removeSubnet(net, prefix[, type])", + "signature": "`blockList.removeSubnet(net, prefix[, type])`", + "apiSymbol": "blockList.removeSubnet", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklistremovesubnetnet-prefix-type", + "nodeStability": null, + "priority": "normal", "tiers": { "static": { "status": "not-implemented", @@ -46442,14 +49182,34 @@ "label": "blockList.toJSON()", "signature": "`blockList.toJSON()`", "apiSymbol": "blockList.toJSON", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#blocklisttojson", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#blocklisttojson", "nodeStability": { - "index": "1", + "index": "1.2", "level": 1, - "text": "Experimental", + "text": "Release candidate", "inherited": false }, - "priority": "low", + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:cdbc674629fb", + "chapter": "net", + "label": "PRIVATE_RANGES", + "signature": "`PRIVATE_RANGES` Type: {string\\[]}", + "apiSymbol": "PRIVATE_RANGES", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netblocklist", + "nodeStability": null, + "priority": "normal", "tiers": { "static": { "status": "not-implemented", @@ -46467,7 +49227,27 @@ "label": "rules", "signature": "`rules` Type: {string\\[]}", "apiSymbol": "rules", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netblocklist", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netblocklist", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:67046fe1e98b", + "chapter": "net", + "label": "size", + "signature": "`size` Type: {number}", + "apiSymbol": "size", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netblocklist", "nodeStability": null, "priority": "normal", "tiers": { @@ -46487,7 +49267,7 @@ "label": "net.SocketAddress", "signature": "Class: `net.SocketAddress`", "apiSymbol": "net.SocketAddress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocketaddress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocketaddress", "nodeStability": null, "priority": "normal", "tiers": { @@ -46507,7 +49287,7 @@ "label": "SocketAddress.parse(input)", "signature": "`SocketAddress.parse(input)`", "apiSymbol": "SocketAddress.parse", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketaddressparseinput", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketaddressparseinput", "nodeStability": null, "priority": "normal", "tiers": { @@ -46527,7 +49307,7 @@ "label": "address", "signature": "`address` Type: {string}", "apiSymbol": "address", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocketaddress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocketaddress", "nodeStability": null, "priority": "normal", "tiers": { @@ -46547,7 +49327,7 @@ "label": "family", "signature": "`family` Type: {string} Either `'ipv4'` or `'ipv6'`.", "apiSymbol": "family", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocketaddress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocketaddress", "nodeStability": null, "priority": "normal", "tiers": { @@ -46567,7 +49347,7 @@ "label": "flowlabel", "signature": "`flowlabel` Type: {number}", "apiSymbol": "flowlabel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocketaddress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocketaddress", "nodeStability": null, "priority": "normal", "tiers": { @@ -46587,7 +49367,7 @@ "label": "port", "signature": "`port` Type: {number}", "apiSymbol": "port", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocketaddress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocketaddress", "nodeStability": null, "priority": "normal", "tiers": { @@ -46607,7 +49387,7 @@ "label": "net.Server", "signature": "Class: `net.Server`", "apiSymbol": "net.Server", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netserver", "nodeStability": null, "priority": "normal", "tiers": { @@ -46627,7 +49407,7 @@ "label": "server.address()", "signature": "`server.address()`", "apiSymbol": "server.address", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#serveraddress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#serveraddress", "nodeStability": null, "priority": "normal", "tiers": { @@ -46650,7 +49430,7 @@ "label": "server.close([callback])", "signature": "`server.close([callback])`", "apiSymbol": "server.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#serverclosecallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#serverclosecallback", "nodeStability": null, "priority": "normal", "tiers": { @@ -46673,7 +49453,7 @@ "label": "server[Symbol.asyncDispose]()", "signature": "`server[Symbol.asyncDispose]()`", "apiSymbol": "server", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#serversymbolasyncdispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#serversymbolasyncdispose", "nodeStability": null, "priority": "normal", "tiers": { @@ -46693,7 +49473,7 @@ "label": "server.getConnections(callback)", "signature": "`server.getConnections(callback)`", "apiSymbol": "server.getConnections", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#servergetconnectionscallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#servergetconnectionscallback", "nodeStability": null, "priority": "normal", "tiers": { @@ -46713,7 +49493,7 @@ "label": "server.listen()", "signature": "`server.listen()`", "apiSymbol": "server.listen", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#serverlisten", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#serverlisten", "nodeStability": null, "priority": "normal", "tiers": { @@ -46736,7 +49516,7 @@ "label": "server.listen(handle[, backlog][, callback])", "signature": "`server.listen(handle[, backlog][, callback])`", "apiSymbol": "server.listen", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#serverlistenhandle-backlog-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#serverlistenhandle-backlog-callback", "nodeStability": null, "priority": "normal", "tiers": { @@ -46759,7 +49539,7 @@ "label": "server.listen(options[, callback])", "signature": "`server.listen(options[, callback])`", "apiSymbol": "server.listen", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#serverlistenoptions-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#serverlistenoptions-callback", "nodeStability": null, "priority": "normal", "tiers": { @@ -46782,7 +49562,7 @@ "label": "server.listen(path[, backlog][, callback])", "signature": "`server.listen(path[, backlog][, callback])`", "apiSymbol": "server.listen", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#serverlistenpath-backlog-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#serverlistenpath-backlog-callback", "nodeStability": null, "priority": "normal", "tiers": { @@ -46805,7 +49585,7 @@ "label": "server.listen([port[, host[, backlog]]][, callback])", "signature": "`server.listen([port[, host[, backlog]]][, callback])`", "apiSymbol": "server.listen", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#serverlistenport-host-backlog-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#serverlistenport-host-backlog-callback", "nodeStability": null, "priority": "normal", "tiers": { @@ -46828,7 +49608,7 @@ "label": "server.ref()", "signature": "`server.ref()`", "apiSymbol": "server.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#serverref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#serverref", "nodeStability": null, "priority": "normal", "tiers": { @@ -46848,7 +49628,7 @@ "label": "server.unref()", "signature": "`server.unref()`", "apiSymbol": "server.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#serverunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#serverunref", "nodeStability": null, "priority": "normal", "tiers": { @@ -46868,7 +49648,7 @@ "label": "listening", "signature": "`listening` Type: {boolean} Indicates whether or not the server is listening for connections.", "apiSymbol": "listening", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netserver", "nodeStability": null, "priority": "normal", "tiers": { @@ -46888,7 +49668,7 @@ "label": "maxConnections", "signature": "`maxConnections` Type: {integer}", "apiSymbol": "maxConnections", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netserver", "nodeStability": null, "priority": "normal", "tiers": { @@ -46908,7 +49688,7 @@ "label": "dropMaxConnection", "signature": "`dropMaxConnection` Type: {boolean}", "apiSymbol": "dropMaxConnection", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netserver", "nodeStability": null, "priority": "normal", "tiers": { @@ -46928,7 +49708,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-close", "nodeStability": null, "priority": "normal", "tiers": { @@ -46948,7 +49728,7 @@ "label": "'connection'", "signature": "Event: `'connection'`", "apiSymbol": "'connection'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-connection", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-connection", "nodeStability": null, "priority": "normal", "tiers": { @@ -46968,7 +49748,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-error", "nodeStability": null, "priority": "normal", "tiers": { @@ -46988,7 +49768,7 @@ "label": "'listening'", "signature": "Event: `'listening'`", "apiSymbol": "'listening'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-listening", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-listening", "nodeStability": null, "priority": "normal", "tiers": { @@ -47008,7 +49788,7 @@ "label": "'drop'", "signature": "Event: `'drop'`", "apiSymbol": "'drop'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-drop", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-drop", "nodeStability": null, "priority": "normal", "tiers": { @@ -47028,7 +49808,7 @@ "label": "net.Socket", "signature": "Class: `net.Socket`", "apiSymbol": "net.Socket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47048,7 +49828,7 @@ "label": "socket.address()", "signature": "`socket.address()`", "apiSymbol": "socket.address", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketaddress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketaddress", "nodeStability": null, "priority": "normal", "tiers": { @@ -47070,7 +49850,7 @@ "label": "socket.connect()", "signature": "`socket.connect()`", "apiSymbol": "socket.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketconnect", "nodeStability": null, "priority": "normal", "tiers": { @@ -47092,7 +49872,7 @@ "label": "socket.connect(options[, connectListener])", "signature": "`socket.connect(options[, connectListener])`", "apiSymbol": "socket.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketconnectoptions-connectlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketconnectoptions-connectlistener", "nodeStability": null, "priority": "normal", "tiers": { @@ -47114,7 +49894,7 @@ "label": "socket.connect(path[, connectListener])", "signature": "`socket.connect(path[, connectListener])`", "apiSymbol": "socket.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketconnectpath-connectlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketconnectpath-connectlistener", "nodeStability": null, "priority": "normal", "tiers": { @@ -47136,7 +49916,7 @@ "label": "socket.connect(port[, host][, connectListener])", "signature": "`socket.connect(port[, host][, connectListener])`", "apiSymbol": "socket.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketconnectport-host-connectlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketconnectport-host-connectlistener", "nodeStability": null, "priority": "normal", "tiers": { @@ -47158,7 +49938,7 @@ "label": "socket.destroy([error])", "signature": "`socket.destroy([error])`", "apiSymbol": "socket.destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketdestroyerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketdestroyerror", "nodeStability": null, "priority": "normal", "tiers": { @@ -47181,7 +49961,7 @@ "label": "socket.destroySoon()", "signature": "`socket.destroySoon()`", "apiSymbol": "socket.destroySoon", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketdestroysoon", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketdestroysoon", "nodeStability": null, "priority": "normal", "tiers": { @@ -47201,7 +49981,7 @@ "label": "socket.end([data[, encoding]][, callback])", "signature": "`socket.end([data[, encoding]][, callback])`", "apiSymbol": "socket.end", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketenddata-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketenddata-encoding-callback", "nodeStability": null, "priority": "normal", "tiers": { @@ -47224,7 +50004,7 @@ "label": "socket.pause()", "signature": "`socket.pause()`", "apiSymbol": "socket.pause", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketpause", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketpause", "nodeStability": null, "priority": "normal", "tiers": { @@ -47247,7 +50027,7 @@ "label": "socket.ref()", "signature": "`socket.ref()`", "apiSymbol": "socket.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketref", "nodeStability": null, "priority": "normal", "tiers": { @@ -47269,7 +50049,7 @@ "label": "socket.resetAndDestroy()", "signature": "`socket.resetAndDestroy()`", "apiSymbol": "socket.resetAndDestroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketresetanddestroy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketresetanddestroy", "nodeStability": null, "priority": "normal", "tiers": { @@ -47289,7 +50069,7 @@ "label": "socket.resume()", "signature": "`socket.resume()`", "apiSymbol": "socket.resume", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketresume", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketresume", "nodeStability": null, "priority": "normal", "tiers": { @@ -47312,7 +50092,7 @@ "label": "socket.setEncoding([encoding])", "signature": "`socket.setEncoding([encoding])`", "apiSymbol": "socket.setEncoding", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketsetencodingencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketsetencodingencoding", "nodeStability": null, "priority": "normal", "tiers": { @@ -47330,12 +50110,52 @@ } }, { - "id": "net:7412f0f2828d", + "id": "net:b6eb2938c348", "chapter": "net", - "label": "socket.setKeepAlive([enable][, initialDelay])", - "signature": "`socket.setKeepAlive([enable][, initialDelay])`", + "label": "socket.setKeepAlive()", + "signature": "`socket.setKeepAlive()`", "apiSymbol": "socket.setKeepAlive", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketsetkeepaliveenable-initialdelay", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketsetkeepalive", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:9fb8a064a508", + "chapter": "net", + "label": "socket.setKeepAlive([options])", + "signature": "`socket.setKeepAlive([options])`", + "apiSymbol": "socket.setKeepAlive", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketsetkeepaliveoptions", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:50eb33c33a53", + "chapter": "net", + "label": "socket.setKeepAlive([enable][, initialDelay][, interval][, count])", + "signature": "`socket.setKeepAlive([enable][, initialDelay][, interval][, count])`", + "apiSymbol": "socket.setKeepAlive", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketsetkeepaliveenable-initialdelay-interval-count", "nodeStability": null, "priority": "normal", "tiers": { @@ -47355,7 +50175,7 @@ "label": "socket.setNoDelay([noDelay])", "signature": "`socket.setNoDelay([noDelay])`", "apiSymbol": "socket.setNoDelay", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketsetnodelaynodelay", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketsetnodelaynodelay", "nodeStability": null, "priority": "normal", "tiers": { @@ -47375,7 +50195,7 @@ "label": "socket.setTimeout(timeout[, callback])", "signature": "`socket.setTimeout(timeout[, callback])`", "apiSymbol": "socket.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketsettimeouttimeout-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketsettimeouttimeout-callback", "nodeStability": null, "priority": "normal", "tiers": { @@ -47398,7 +50218,7 @@ "label": "socket.getTypeOfService()", "signature": "`socket.getTypeOfService()`", "apiSymbol": "socket.getTypeOfService", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketgettypeofservice", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketgettypeofservice", "nodeStability": null, "priority": "normal", "tiers": { @@ -47418,7 +50238,7 @@ "label": "socket.setTypeOfService(tos)", "signature": "`socket.setTypeOfService(tos)`", "apiSymbol": "socket.setTypeOfService", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketsettypeofservicetos", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketsettypeofservicetos", "nodeStability": null, "priority": "normal", "tiers": { @@ -47438,7 +50258,7 @@ "label": "socket.unref()", "signature": "`socket.unref()`", "apiSymbol": "socket.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketunref", "nodeStability": null, "priority": "normal", "tiers": { @@ -47460,7 +50280,7 @@ "label": "socket.write(data[, encoding][, callback])", "signature": "`socket.write(data[, encoding][, callback])`", "apiSymbol": "socket.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#socketwritedata-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#socketwritedata-encoding-callback", "nodeStability": null, "priority": "normal", "tiers": { @@ -47483,7 +50303,7 @@ "label": "autoSelectFamilyAttemptedAddresses", "signature": "`autoSelectFamilyAttemptedAddresses` Type: {string\\[]}", "apiSymbol": "autoSelectFamilyAttemptedAddresses", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47503,7 +50323,7 @@ "label": "bufferSize", "signature": "`bufferSize` Type: {integer}", "apiSymbol": "bufferSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": { "index": "0", "level": 0, @@ -47528,7 +50348,7 @@ "label": "bytesRead", "signature": "`bytesRead` Type: {integer}", "apiSymbol": "bytesRead", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47548,7 +50368,7 @@ "label": "bytesWritten", "signature": "`bytesWritten` Type: {integer}", "apiSymbol": "bytesWritten", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47568,7 +50388,7 @@ "label": "connecting", "signature": "`connecting` Type: {boolean}", "apiSymbol": "connecting", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47583,12 +50403,12 @@ } }, { - "id": "net:606071fbf392", + "id": "net:5fb78ca7306f", "chapter": "net", "label": "destroyed", - "signature": "`destroyed` Type: {boolean} Indicates if the connection is destroyed or not. Once a connection is destroyed no further data can be transferred using it.", + "signature": "`destroyed` Type: {boolean} Indicates if the connection is destroyed or not. No further data can be transferred using a destroyed connection.", "apiSymbol": "destroyed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47608,7 +50428,7 @@ "label": "localAddress", "signature": "`localAddress` Type: {string}", "apiSymbol": "localAddress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47628,7 +50448,7 @@ "label": "localPort", "signature": "`localPort` Type: {integer}", "apiSymbol": "localPort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47648,7 +50468,7 @@ "label": "localFamily", "signature": "`localFamily` Type: {string}", "apiSymbol": "localFamily", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47668,7 +50488,7 @@ "label": "pending", "signature": "`pending` Type: {boolean}", "apiSymbol": "pending", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47688,7 +50508,7 @@ "label": "remoteAddress", "signature": "`remoteAddress` Type: {string}", "apiSymbol": "remoteAddress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47708,7 +50528,7 @@ "label": "remoteFamily", "signature": "`remoteFamily` Type: {string}", "apiSymbol": "remoteFamily", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47728,7 +50548,27 @@ "label": "remotePort", "signature": "`remotePort` Type: {integer}", "apiSymbol": "remotePort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:d1a2a3208778", + "chapter": "net", + "label": "server", + "signature": "`server` Type: {net.Server|null}", + "apiSymbol": "server", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47748,7 +50588,7 @@ "label": "timeout", "signature": "`timeout` Type: {number|undefined}", "apiSymbol": "timeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47772,7 +50612,7 @@ "label": "readyState", "signature": "`readyState` Type: {string}", "apiSymbol": "readyState", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#class-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -47792,7 +50632,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-close_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-close_1", "nodeStability": null, "priority": "normal", "tiers": { @@ -47812,7 +50652,7 @@ "label": "'connect'", "signature": "Event: `'connect'`", "apiSymbol": "'connect'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-connect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-connect", "nodeStability": null, "priority": "normal", "tiers": { @@ -47832,7 +50672,7 @@ "label": "'connectionAttempt'", "signature": "Event: `'connectionAttempt'`", "apiSymbol": "'connectionAttempt'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-connectionattempt", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-connectionattempt", "nodeStability": null, "priority": "normal", "tiers": { @@ -47852,7 +50692,7 @@ "label": "'connectionAttemptFailed'", "signature": "Event: `'connectionAttemptFailed'`", "apiSymbol": "'connectionAttemptFailed'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-connectionattemptfailed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-connectionattemptfailed", "nodeStability": null, "priority": "normal", "tiers": { @@ -47872,7 +50712,7 @@ "label": "'connectionAttemptTimeout'", "signature": "Event: `'connectionAttemptTimeout'`", "apiSymbol": "'connectionAttemptTimeout'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-connectionattempttimeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-connectionattempttimeout", "nodeStability": null, "priority": "normal", "tiers": { @@ -47892,7 +50732,7 @@ "label": "'data'", "signature": "Event: `'data'`", "apiSymbol": "'data'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-data", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-data", "nodeStability": null, "priority": "normal", "tiers": { @@ -47912,7 +50752,7 @@ "label": "'drain'", "signature": "Event: `'drain'`", "apiSymbol": "'drain'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-drain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-drain", "nodeStability": null, "priority": "normal", "tiers": { @@ -47932,7 +50772,7 @@ "label": "'end'", "signature": "Event: `'end'`", "apiSymbol": "'end'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-end", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-end", "nodeStability": null, "priority": "normal", "tiers": { @@ -47952,7 +50792,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-error_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-error_1", "nodeStability": null, "priority": "normal", "tiers": { @@ -47972,7 +50812,7 @@ "label": "'lookup'", "signature": "Event: `'lookup'`", "apiSymbol": "'lookup'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-lookup", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-lookup", "nodeStability": null, "priority": "normal", "tiers": { @@ -47992,7 +50832,7 @@ "label": "'ready'", "signature": "Event: `'ready'`", "apiSymbol": "'ready'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-ready", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-ready", "nodeStability": null, "priority": "normal", "tiers": { @@ -48012,7 +50852,127 @@ "label": "'timeout'", "signature": "Event: `'timeout'`", "apiSymbol": "'timeout'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#event-timeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#event-timeout", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:414417365ac3", + "chapter": "net", + "label": "net.BoundSocket", + "signature": "Class: `net.BoundSocket`", + "apiSymbol": "net.BoundSocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netboundsocket", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:400d8120e3ab", + "chapter": "net", + "label": "boundSocket.address()", + "signature": "`boundSocket.address()`", + "apiSymbol": "boundSocket.address", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#boundsocketaddress", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:ea9d92069057", + "chapter": "net", + "label": "boundSocket.fd()", + "signature": "`boundSocket.fd()`", + "apiSymbol": "boundSocket.fd", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#boundsocketfd", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:185a5473f064", + "chapter": "net", + "label": "boundSocket.close()", + "signature": "`boundSocket.close()`", + "apiSymbol": "boundSocket.close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#boundsocketclose", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:9cc281d92386", + "chapter": "net", + "label": "boundSocket[Symbol.dispose]()", + "signature": "`boundSocket[Symbol.dispose]()`", + "apiSymbol": "boundSocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#boundsocketsymboldispose", + "nodeStability": null, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:net", + "tests": [] + } + } + }, + { + "id": "net:66918477ba37", + "chapter": "net", + "label": "isPipe", + "signature": "`isPipe` {boolean}", + "apiSymbol": "isPipe", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#class-netboundsocket", "nodeStability": null, "priority": "normal", "tiers": { @@ -48032,7 +50992,7 @@ "label": "net.connect()", "signature": "`net.connect()`", "apiSymbol": "net.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netconnect", "nodeStability": null, "priority": "normal", "tiers": { @@ -48055,7 +51015,7 @@ "label": "net.connect(options[, connectListener])", "signature": "`net.connect(options[, connectListener])`", "apiSymbol": "net.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netconnectoptions-connectlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netconnectoptions-connectlistener", "nodeStability": null, "priority": "normal", "tiers": { @@ -48078,7 +51038,7 @@ "label": "net.connect(path[, connectListener])", "signature": "`net.connect(path[, connectListener])`", "apiSymbol": "net.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netconnectpath-connectlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netconnectpath-connectlistener", "nodeStability": null, "priority": "normal", "tiers": { @@ -48101,7 +51061,7 @@ "label": "net.connect(port[, host][, connectListener])", "signature": "`net.connect(port[, host][, connectListener])`", "apiSymbol": "net.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netconnectport-host-connectlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netconnectport-host-connectlistener", "nodeStability": null, "priority": "normal", "tiers": { @@ -48124,7 +51084,7 @@ "label": "net.createConnection()", "signature": "`net.createConnection()`", "apiSymbol": "net.createConnection", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netcreateconnection", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netcreateconnection", "nodeStability": null, "priority": "normal", "tiers": { @@ -48147,7 +51107,7 @@ "label": "net.createConnection(options[, connectListener])", "signature": "`net.createConnection(options[, connectListener])`", "apiSymbol": "net.createConnection", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netcreateconnectionoptions-connectlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netcreateconnectionoptions-connectlistener", "nodeStability": null, "priority": "normal", "tiers": { @@ -48170,7 +51130,7 @@ "label": "net.createConnection(path[, connectListener])", "signature": "`net.createConnection(path[, connectListener])`", "apiSymbol": "net.createConnection", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netcreateconnectionpath-connectlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netcreateconnectionpath-connectlistener", "nodeStability": null, "priority": "normal", "tiers": { @@ -48193,7 +51153,7 @@ "label": "net.createConnection(port[, host][, connectListener])", "signature": "`net.createConnection(port[, host][, connectListener])`", "apiSymbol": "net.createConnection", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netcreateconnectionport-host-connectlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netcreateconnectionport-host-connectlistener", "nodeStability": null, "priority": "normal", "tiers": { @@ -48216,7 +51176,7 @@ "label": "net.createServer([options][, connectionListener])", "signature": "`net.createServer([options][, connectionListener])`", "apiSymbol": "net.createServer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netcreateserveroptions-connectionlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netcreateserveroptions-connectionlistener", "nodeStability": null, "priority": "normal", "tiers": { @@ -48239,7 +51199,7 @@ "label": "net.getDefaultAutoSelectFamily()", "signature": "`net.getDefaultAutoSelectFamily()`", "apiSymbol": "net.getDefaultAutoSelectFamily", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netgetdefaultautoselectfamily", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netgetdefaultautoselectfamily", "nodeStability": null, "priority": "normal", "tiers": { @@ -48259,7 +51219,7 @@ "label": "net.setDefaultAutoSelectFamily(value)", "signature": "`net.setDefaultAutoSelectFamily(value)`", "apiSymbol": "net.setDefaultAutoSelectFamily", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netsetdefaultautoselectfamilyvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netsetdefaultautoselectfamilyvalue", "nodeStability": null, "priority": "normal", "tiers": { @@ -48279,7 +51239,7 @@ "label": "net.getDefaultAutoSelectFamilyAttemptTimeout()", "signature": "`net.getDefaultAutoSelectFamilyAttemptTimeout()`", "apiSymbol": "net.getDefaultAutoSelectFamilyAttemptTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netgetdefaultautoselectfamilyattempttimeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netgetdefaultautoselectfamilyattempttimeout", "nodeStability": null, "priority": "normal", "tiers": { @@ -48302,7 +51262,7 @@ "label": "net.setDefaultAutoSelectFamilyAttemptTimeout(value)", "signature": "`net.setDefaultAutoSelectFamilyAttemptTimeout(value)`", "apiSymbol": "net.setDefaultAutoSelectFamilyAttemptTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netsetdefaultautoselectfamilyattempttimeoutvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netsetdefaultautoselectfamilyattempttimeoutvalue", "nodeStability": null, "priority": "normal", "tiers": { @@ -48325,7 +51285,7 @@ "label": "net.isIP(input)", "signature": "`net.isIP(input)`", "apiSymbol": "net.isIP", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netisipinput", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netisipinput", "nodeStability": null, "priority": "normal", "tiers": { @@ -48345,7 +51305,7 @@ "label": "net.isIPv4(input)", "signature": "`net.isIPv4(input)`", "apiSymbol": "net.isIPv4", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netisipv4input", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netisipv4input", "nodeStability": null, "priority": "normal", "tiers": { @@ -48365,7 +51325,7 @@ "label": "net.isIPv6(input)", "signature": "`net.isIPv6(input)`", "apiSymbol": "net.isIPv6", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/net.html#netisipv6input", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/net.html#netisipv6input", "nodeStability": null, "priority": "normal", "tiers": { @@ -48385,7 +51345,7 @@ "label": "os.availableParallelism()", "signature": "`os.availableParallelism()`", "apiSymbol": "os.availableParallelism", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osavailableparallelism", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osavailableparallelism", "nodeStability": { "index": "2", "level": 2, @@ -48412,7 +51372,7 @@ "label": "os.arch()", "signature": "`os.arch()`", "apiSymbol": "os.arch", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osarch", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osarch", "nodeStability": { "index": "2", "level": 2, @@ -48439,7 +51399,7 @@ "label": "os.cpus()", "signature": "`os.cpus()`", "apiSymbol": "os.cpus", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#oscpus", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#oscpus", "nodeStability": { "index": "2", "level": 2, @@ -48466,7 +51426,7 @@ "label": "os.endianness()", "signature": "`os.endianness()`", "apiSymbol": "os.endianness", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osendianness", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osendianness", "nodeStability": { "index": "2", "level": 2, @@ -48493,7 +51453,7 @@ "label": "os.freemem()", "signature": "`os.freemem()`", "apiSymbol": "os.freemem", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osfreemem", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osfreemem", "nodeStability": { "index": "2", "level": 2, @@ -48520,7 +51480,7 @@ "label": "os.getPriority([pid])", "signature": "`os.getPriority([pid])`", "apiSymbol": "os.getPriority", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osgetprioritypid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osgetprioritypid", "nodeStability": { "index": "2", "level": 2, @@ -48547,7 +51507,7 @@ "label": "os.homedir()", "signature": "`os.homedir()`", "apiSymbol": "os.homedir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#oshomedir", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#oshomedir", "nodeStability": { "index": "2", "level": 2, @@ -48575,7 +51535,7 @@ "label": "os.hostname()", "signature": "`os.hostname()`", "apiSymbol": "os.hostname", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#oshostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#oshostname", "nodeStability": { "index": "2", "level": 2, @@ -48602,7 +51562,7 @@ "label": "os.loadavg()", "signature": "`os.loadavg()`", "apiSymbol": "os.loadavg", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osloadavg", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osloadavg", "nodeStability": { "index": "2", "level": 2, @@ -48629,7 +51589,7 @@ "label": "os.machine()", "signature": "`os.machine()`", "apiSymbol": "os.machine", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osmachine", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osmachine", "nodeStability": { "index": "2", "level": 2, @@ -48656,7 +51616,7 @@ "label": "os.networkInterfaces()", "signature": "`os.networkInterfaces()`", "apiSymbol": "os.networkInterfaces", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osnetworkinterfaces", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osnetworkinterfaces", "nodeStability": { "index": "2", "level": 2, @@ -48684,7 +51644,7 @@ "label": "os.platform()", "signature": "`os.platform()`", "apiSymbol": "os.platform", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osplatform", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osplatform", "nodeStability": { "index": "2", "level": 2, @@ -48712,7 +51672,7 @@ "label": "os.release()", "signature": "`os.release()`", "apiSymbol": "os.release", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osrelease", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osrelease", "nodeStability": { "index": "2", "level": 2, @@ -48740,7 +51700,7 @@ "label": "os.setPriority([pid, ]priority)", "signature": "`os.setPriority([pid, ]priority)`", "apiSymbol": "os.setPriority", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#ossetprioritypid-priority", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#ossetprioritypid-priority", "nodeStability": { "index": "2", "level": 2, @@ -48765,7 +51725,7 @@ "label": "os.tmpdir()", "signature": "`os.tmpdir()`", "apiSymbol": "os.tmpdir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#ostmpdir", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#ostmpdir", "nodeStability": { "index": "2", "level": 2, @@ -48793,7 +51753,7 @@ "label": "os.totalmem()", "signature": "`os.totalmem()`", "apiSymbol": "os.totalmem", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#ostotalmem", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#ostotalmem", "nodeStability": { "index": "2", "level": 2, @@ -48821,7 +51781,7 @@ "label": "os.type()", "signature": "`os.type()`", "apiSymbol": "os.type", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#ostype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#ostype", "nodeStability": { "index": "2", "level": 2, @@ -48849,7 +51809,7 @@ "label": "os.uptime()", "signature": "`os.uptime()`", "apiSymbol": "os.uptime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osuptime", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osuptime", "nodeStability": { "index": "2", "level": 2, @@ -48876,7 +51836,7 @@ "label": "os.userInfo([options])", "signature": "`os.userInfo([options])`", "apiSymbol": "os.userInfo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osuserinfooptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osuserinfooptions", "nodeStability": { "index": "2", "level": 2, @@ -48904,7 +51864,7 @@ "label": "os.version()", "signature": "`os.version()`", "apiSymbol": "os.version", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html#osversion", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html#osversion", "nodeStability": { "index": "2", "level": 2, @@ -48931,7 +51891,7 @@ "label": "EOL", "signature": "`EOL` Type: {string}", "apiSymbol": "EOL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html", "nodeStability": { "index": "2", "level": 2, @@ -48959,7 +51919,7 @@ "label": "constants", "signature": "`constants` Type: {Object}", "apiSymbol": "constants", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html", "nodeStability": { "index": "2", "level": 2, @@ -48986,7 +51946,7 @@ "label": "devNull", "signature": "`devNull` Type: {string}", "apiSymbol": "devNull", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/os.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/os.html", "nodeStability": { "index": "2", "level": 2, @@ -49013,7 +51973,7 @@ "label": "path.basename(path[, suffix])", "signature": "`path.basename(path[, suffix])`", "apiSymbol": "path.basename", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html#pathbasenamepath-suffix", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html#pathbasenamepath-suffix", "nodeStability": { "index": "2", "level": 2, @@ -49044,7 +52004,7 @@ "label": "path.dirname(path)", "signature": "`path.dirname(path)`", "apiSymbol": "path.dirname", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html#pathdirnamepath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html#pathdirnamepath", "nodeStability": { "index": "2", "level": 2, @@ -49075,7 +52035,7 @@ "label": "path.extname(path)", "signature": "`path.extname(path)`", "apiSymbol": "path.extname", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html#pathextnamepath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html#pathextnamepath", "nodeStability": { "index": "2", "level": 2, @@ -49106,7 +52066,7 @@ "label": "path.format(pathObject)", "signature": "`path.format(pathObject)`", "apiSymbol": "path.format", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html#pathformatpathobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html#pathformatpathobject", "nodeStability": { "index": "2", "level": 2, @@ -49134,7 +52094,7 @@ "label": "path.matchesGlob(path, pattern)", "signature": "`path.matchesGlob(path, pattern)`", "apiSymbol": "path.matchesGlob", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html#pathmatchesglobpath-pattern", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html#pathmatchesglobpath-pattern", "nodeStability": { "index": "2", "level": 2, @@ -49165,7 +52125,7 @@ "label": "path.isAbsolute(path)", "signature": "`path.isAbsolute(path)`", "apiSymbol": "path.isAbsolute", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html#pathisabsolutepath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html#pathisabsolutepath", "nodeStability": { "index": "2", "level": 2, @@ -49196,7 +52156,7 @@ "label": "path.join([...paths])", "signature": "`path.join([...paths])`", "apiSymbol": "path.join", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html#pathjoinpaths", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html#pathjoinpaths", "nodeStability": { "index": "2", "level": 2, @@ -49227,7 +52187,7 @@ "label": "path.normalize(path)", "signature": "`path.normalize(path)`", "apiSymbol": "path.normalize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html#pathnormalizepath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html#pathnormalizepath", "nodeStability": { "index": "2", "level": 2, @@ -49258,7 +52218,7 @@ "label": "path.parse(path)", "signature": "`path.parse(path)`", "apiSymbol": "path.parse", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html#pathparsepath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html#pathparsepath", "nodeStability": { "index": "2", "level": 2, @@ -49286,7 +52246,7 @@ "label": "path.relative(from, to)", "signature": "`path.relative(from, to)`", "apiSymbol": "path.relative", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html#pathrelativefrom-to", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html#pathrelativefrom-to", "nodeStability": { "index": "2", "level": 2, @@ -49317,7 +52277,7 @@ "label": "path.resolve([...paths])", "signature": "`path.resolve([...paths])`", "apiSymbol": "path.resolve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html#pathresolvepaths", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html#pathresolvepaths", "nodeStability": { "index": "2", "level": 2, @@ -49348,7 +52308,7 @@ "label": "path.toNamespacedPath(path)", "signature": "`path.toNamespacedPath(path)`", "apiSymbol": "path.toNamespacedPath", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html#pathtonamespacedpathpath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html#pathtonamespacedpathpath", "nodeStability": { "index": "2", "level": 2, @@ -49379,7 +52339,7 @@ "label": "delimiter", "signature": "`delimiter` Type: {string}", "apiSymbol": "delimiter", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html", "nodeStability": { "index": "2", "level": 2, @@ -49410,7 +52370,7 @@ "label": "posix", "signature": "`posix` Type: {Object}", "apiSymbol": "posix", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html", "nodeStability": { "index": "2", "level": 2, @@ -49441,7 +52401,7 @@ "label": "sep", "signature": "`sep` Type: {string}", "apiSymbol": "sep", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html", "nodeStability": { "index": "2", "level": 2, @@ -49472,7 +52432,7 @@ "label": "win32", "signature": "`win32` Type: {Object}", "apiSymbol": "win32", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/path.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/path.html", "nodeStability": { "index": "2", "level": 2, @@ -49497,13 +52457,41 @@ } } }, + { + "id": "perf_hooks:0f3b0bd30e2d", + "chapter": "perf_hooks", + "label": "Measuring how long the net.connect (only for TCP) takes when the connection is successful", + "signature": "Measuring how long the `net.connect` (only for TCP) takes when the connection is successful", + "apiSymbol": "net.connect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#measuring-how-long-the-netconnect-only-for-tcp-takes-when-the-connection-is-successful", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "partial", + "action": "audit-partial", + "verification": "test-backed", + "confidence": "high", + "source": "compiler-dedicated:net.connect", + "tests": [ + "tests/corpus/2500-net-autosel-timeout.ts", + "tests/corpus/2596-net-arg-ladders.cjs" + ] + } + } + }, { "id": "perf_hooks:4191f3d1f637", "chapter": "perf_hooks", "label": "PerformanceEntry", "signature": "Class: `PerformanceEntry`", "apiSymbol": "PerformanceEntry", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceentry", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceentry", "nodeStability": { "index": "2", "level": 2, @@ -49531,7 +52519,7 @@ "label": "duration", "signature": "`duration` Type: {number}", "apiSymbol": "duration", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceentry", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceentry", "nodeStability": { "index": "2", "level": 2, @@ -49559,7 +52547,7 @@ "label": "entryType", "signature": "`entryType` Type: {string}", "apiSymbol": "entryType", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceentry", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceentry", "nodeStability": { "index": "2", "level": 2, @@ -49587,7 +52575,7 @@ "label": "name", "signature": "`name` Type: {string}", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceentry", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceentry", "nodeStability": { "index": "2", "level": 2, @@ -49615,7 +52603,7 @@ "label": "startTime", "signature": "`startTime` Type: {number}", "apiSymbol": "startTime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceentry", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceentry", "nodeStability": { "index": "2", "level": 2, @@ -49643,7 +52631,7 @@ "label": "PerformanceMark", "signature": "Class: `PerformanceMark`", "apiSymbol": "PerformanceMark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancemark", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancemark", "nodeStability": { "index": "2", "level": 2, @@ -49671,7 +52659,7 @@ "label": "detail", "signature": "`detail` Type: {any}", "apiSymbol": "detail", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancemark", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancemark", "nodeStability": { "index": "2", "level": 2, @@ -49699,7 +52687,7 @@ "label": "PerformanceMeasure", "signature": "Class: `PerformanceMeasure`", "apiSymbol": "PerformanceMeasure", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancemeasure", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancemeasure", "nodeStability": { "index": "2", "level": 2, @@ -49727,7 +52715,7 @@ "label": "detail", "signature": "`detail` Type: {any}", "apiSymbol": "detail", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancemeasure", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancemeasure", "nodeStability": { "index": "2", "level": 2, @@ -49755,7 +52743,7 @@ "label": "PerformanceNodeEntry", "signature": "Class: `PerformanceNodeEntry`", "apiSymbol": "PerformanceNodeEntry", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodeentry", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodeentry", "nodeStability": { "index": "2", "level": 2, @@ -49780,7 +52768,7 @@ "label": "detail", "signature": "`detail` Type: {any}", "apiSymbol": "detail", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodeentry", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodeentry", "nodeStability": { "index": "2", "level": 2, @@ -49805,7 +52793,7 @@ "label": "flags", "signature": "`flags` Type: {number}", "apiSymbol": "flags", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodeentry", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodeentry", "nodeStability": { "index": "0", "level": 0, @@ -49830,7 +52818,7 @@ "label": "kind", "signature": "`kind` Type: {number}", "apiSymbol": "kind", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodeentry", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodeentry", "nodeStability": { "index": "0", "level": 0, @@ -49855,7 +52843,7 @@ "label": "PerformanceNodeTiming", "signature": "Class: `PerformanceNodeTiming`", "apiSymbol": "PerformanceNodeTiming", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodetiming", "nodeStability": { "index": "2", "level": 2, @@ -49880,7 +52868,7 @@ "label": "bootstrapComplete", "signature": "`bootstrapComplete` Type: {number}", "apiSymbol": "bootstrapComplete", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodetiming", "nodeStability": { "index": "2", "level": 2, @@ -49905,7 +52893,7 @@ "label": "environment", "signature": "`environment` Type: {number}", "apiSymbol": "environment", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodetiming", "nodeStability": { "index": "2", "level": 2, @@ -49930,7 +52918,7 @@ "label": "idleTime", "signature": "`idleTime` Type: {number}", "apiSymbol": "idleTime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodetiming", "nodeStability": { "index": "2", "level": 2, @@ -49955,7 +52943,7 @@ "label": "loopExit", "signature": "`loopExit` Type: {number}", "apiSymbol": "loopExit", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodetiming", "nodeStability": { "index": "2", "level": 2, @@ -49980,7 +52968,7 @@ "label": "loopStart", "signature": "`loopStart` Type: {number}", "apiSymbol": "loopStart", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodetiming", "nodeStability": { "index": "2", "level": 2, @@ -50005,7 +52993,7 @@ "label": "nodeStart", "signature": "`nodeStart` Type: {number}", "apiSymbol": "nodeStart", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodetiming", "nodeStability": { "index": "2", "level": 2, @@ -50030,7 +53018,7 @@ "label": "uvMetricsInfo", "signature": "`uvMetricsInfo` Returns: {Object}", "apiSymbol": "uvMetricsInfo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodetiming", "nodeStability": { "index": "2", "level": 2, @@ -50055,7 +53043,7 @@ "label": "v8Start", "signature": "`v8Start` Type: {number}", "apiSymbol": "v8Start", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performancenodetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performancenodetiming", "nodeStability": { "index": "2", "level": 2, @@ -50080,7 +53068,7 @@ "label": "PerformanceResourceTiming", "signature": "Class: `PerformanceResourceTiming`", "apiSymbol": "PerformanceResourceTiming", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50105,7 +53093,7 @@ "label": "performanceResourceTiming.toJSON()", "signature": "`performanceResourceTiming.toJSON()`", "apiSymbol": "performanceResourceTiming.toJSON", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performanceresourcetimingtojson", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performanceresourcetimingtojson", "nodeStability": { "index": "2", "level": 2, @@ -50130,7 +53118,7 @@ "label": "workerStart", "signature": "`workerStart` Type: {number}", "apiSymbol": "workerStart", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50155,7 +53143,7 @@ "label": "redirectStart", "signature": "`redirectStart` Type: {number}", "apiSymbol": "redirectStart", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50180,7 +53168,7 @@ "label": "redirectEnd", "signature": "`redirectEnd` Type: {number}", "apiSymbol": "redirectEnd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50205,7 +53193,7 @@ "label": "fetchStart", "signature": "`fetchStart` Type: {number}", "apiSymbol": "fetchStart", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50230,7 +53218,7 @@ "label": "domainLookupStart", "signature": "`domainLookupStart` Type: {number}", "apiSymbol": "domainLookupStart", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50255,7 +53243,7 @@ "label": "domainLookupEnd", "signature": "`domainLookupEnd` Type: {number}", "apiSymbol": "domainLookupEnd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50280,7 +53268,7 @@ "label": "connectStart", "signature": "`connectStart` Type: {number}", "apiSymbol": "connectStart", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50305,7 +53293,7 @@ "label": "connectEnd", "signature": "`connectEnd` Type: {number}", "apiSymbol": "connectEnd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50330,7 +53318,7 @@ "label": "secureConnectionStart", "signature": "`secureConnectionStart` Type: {number}", "apiSymbol": "secureConnectionStart", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50355,7 +53343,82 @@ "label": "requestStart", "signature": "`requestStart` Type: {number}", "apiSymbol": "requestStart", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:6af5b39b755a", + "chapter": "perf_hooks", + "label": "finalResponseHeadersStart", + "signature": "`finalResponseHeadersStart` Type: {number}", + "apiSymbol": "finalResponseHeadersStart", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:756cbc84eee9", + "chapter": "perf_hooks", + "label": "firstInterimResponseStart", + "signature": "`firstInterimResponseStart` Type: {number}", + "apiSymbol": "firstInterimResponseStart", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:7869397fdf24", + "chapter": "perf_hooks", + "label": "responseStart", + "signature": "`responseStart` Type: {number}", + "apiSymbol": "responseStart", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50380,7 +53443,7 @@ "label": "responseEnd", "signature": "`responseEnd` Type: {number}", "apiSymbol": "responseEnd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50405,7 +53468,7 @@ "label": "transferSize", "signature": "`transferSize` Type: {number}", "apiSymbol": "transferSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50430,7 +53493,7 @@ "label": "encodedBodySize", "signature": "`encodedBodySize` Type: {number}", "apiSymbol": "encodedBodySize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50455,7 +53518,82 @@ "label": "decodedBodySize", "signature": "`decodedBodySize` Type: {number}", "apiSymbol": "decodedBodySize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceresourcetiming", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:3d425c5f696c", + "chapter": "perf_hooks", + "label": "renderBlockingStatus", + "signature": "`renderBlockingStatus` Type: {string}", + "apiSymbol": "renderBlockingStatus", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:03b62556cc5e", + "chapter": "perf_hooks", + "label": "contentType", + "signature": "`contentType` Type: {string}", + "apiSymbol": "contentType", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:29830b9da1a6", + "chapter": "perf_hooks", + "label": "contentEncoding", + "signature": "`contentEncoding` Type: {string}", + "apiSymbol": "contentEncoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceresourcetiming", "nodeStability": { "index": "2", "level": 2, @@ -50480,7 +53618,7 @@ "label": "PerformanceObserver", "signature": "Class: `PerformanceObserver`", "apiSymbol": "PerformanceObserver", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceobserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceobserver", "nodeStability": { "index": "2", "level": 2, @@ -50505,7 +53643,7 @@ "label": "performanceObserver.disconnect()", "signature": "`performanceObserver.disconnect()`", "apiSymbol": "performanceObserver.disconnect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performanceobserverdisconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performanceobserverdisconnect", "nodeStability": { "index": "2", "level": 2, @@ -50530,7 +53668,7 @@ "label": "performanceObserver.observe(options)", "signature": "`performanceObserver.observe(options)`", "apiSymbol": "performanceObserver.observe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performanceobserverobserveoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performanceobserverobserveoptions", "nodeStability": { "index": "2", "level": 2, @@ -50555,7 +53693,7 @@ "label": "performanceObserver.takeRecords()", "signature": "`performanceObserver.takeRecords()`", "apiSymbol": "performanceObserver.takeRecords", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performanceobservertakerecords", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performanceobservertakerecords", "nodeStability": { "index": "2", "level": 2, @@ -50580,7 +53718,7 @@ "label": "supportedEntryTypes", "signature": "`supportedEntryTypes` Type: {string\\[]}", "apiSymbol": "supportedEntryTypes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceobserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceobserver", "nodeStability": { "index": "2", "level": 2, @@ -50605,7 +53743,7 @@ "label": "PerformanceObserverEntryList", "signature": "Class: `PerformanceObserverEntryList`", "apiSymbol": "PerformanceObserverEntryList", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-performanceobserverentrylist", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-performanceobserverentrylist", "nodeStability": { "index": "2", "level": 2, @@ -50630,7 +53768,7 @@ "label": "performanceObserverEntryList.getEntries()", "signature": "`performanceObserverEntryList.getEntries()`", "apiSymbol": "performanceObserverEntryList.getEntries", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performanceobserverentrylistgetentries", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performanceobserverentrylistgetentries", "nodeStability": { "index": "2", "level": 2, @@ -50655,7 +53793,7 @@ "label": "performanceObserverEntryList.getEntriesByName(name[, type])", "signature": "`performanceObserverEntryList.getEntriesByName(name[, type])`", "apiSymbol": "performanceObserverEntryList.getEntriesByName", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performanceobserverentrylistgetentriesbynamename-type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performanceobserverentrylistgetentriesbynamename-type", "nodeStability": { "index": "2", "level": 2, @@ -50680,7 +53818,7 @@ "label": "performanceObserverEntryList.getEntriesByType(type)", "signature": "`performanceObserverEntryList.getEntriesByType(type)`", "apiSymbol": "performanceObserverEntryList.getEntriesByType", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performanceobserverentrylistgetentriesbytypetype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performanceobserverentrylistgetentriesbytypetype", "nodeStability": { "index": "2", "level": 2, @@ -50705,7 +53843,307 @@ "label": "Histogram", "signature": "Class: `Histogram`", "apiSymbol": "Histogram", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:759eb564d36d", + "chapter": "perf_hooks", + "label": "histogram.ccdf(value)", + "signature": "`histogram.ccdf(value)`", + "apiSymbol": "histogram.ccdf", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramccdfvalue", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:8d22421f4895", + "chapter": "perf_hooks", + "label": "histogram.cdf(value)", + "signature": "`histogram.cdf(value)`", + "apiSymbol": "histogram.cdf", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramcdfvalue", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:7d3698e4b7e1", + "chapter": "perf_hooks", + "label": "histogram.cliffsD(other)", + "signature": "`histogram.cliffsD(other)`", + "apiSymbol": "histogram.cliffsD", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramcliffsdother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:f6b0fdd4f95c", + "chapter": "perf_hooks", + "label": "histogram.cohensD(other)", + "signature": "`histogram.cohensD(other)`", + "apiSymbol": "histogram.cohensD", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramcohensdother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:32d32caabb57", + "chapter": "perf_hooks", + "label": "histogram.countAt(value)", + "signature": "`histogram.countAt(value)`", + "apiSymbol": "histogram.countAt", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramcountatvalue", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:a654b4b820aa", + "chapter": "perf_hooks", + "label": "histogram.export()", + "signature": "`histogram.export()`", + "apiSymbol": "histogram.export", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramexport", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:9eb87d68eed4", + "chapter": "perf_hooks", + "label": "histogram.burnRate(sloTarget)", + "signature": "`histogram.burnRate(sloTarget)`", + "apiSymbol": "histogram.burnRate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramburnrateslotarget", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:efa4bd467f9d", + "chapter": "perf_hooks", + "label": "histogram.ksTest(other)", + "signature": "`histogram.ksTest(other)`", + "apiSymbol": "histogram.ksTest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramkstestother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:c0563cf15d0e", + "chapter": "perf_hooks", + "label": "histogram.linearBuckets(stepSize)", + "signature": "`histogram.linearBuckets(stepSize)`", + "apiSymbol": "histogram.linearBuckets", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramlinearbucketsstepsize", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:5899ce3fef5c", + "chapter": "perf_hooks", + "label": "histogram.logBuckets(firstBucket, base)", + "signature": "`histogram.logBuckets(firstBucket, base)`", + "apiSymbol": "histogram.logBuckets", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramlogbucketsfirstbucket-base", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:b477f2eb976a", + "chapter": "perf_hooks", + "label": "histogram.mannWhitneyTest(other)", + "signature": "`histogram.mannWhitneyTest(other)`", + "apiSymbol": "histogram.mannWhitneyTest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogrammannwhitneytestother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:57aff1eb8969", + "chapter": "perf_hooks", + "label": "histogram.meanCI([options])", + "signature": "`histogram.meanCI([options])`", + "apiSymbol": "histogram.meanCI", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogrammeancioptions", "nodeStability": { "index": "2", "level": 2, @@ -50730,7 +54168,7 @@ "label": "histogram.percentile(percentile)", "signature": "`histogram.percentile(percentile)`", "apiSymbol": "histogram.percentile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#histogrampercentilepercentile", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogrampercentilepercentile", "nodeStability": { "index": "2", "level": 2, @@ -50755,7 +54193,82 @@ "label": "histogram.percentileBigInt(percentile)", "signature": "`histogram.percentileBigInt(percentile)`", "apiSymbol": "histogram.percentileBigInt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#histogrampercentilebigintpercentile", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogrampercentilebigintpercentile", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:5a5e7386f377", + "chapter": "perf_hooks", + "label": "histogram.percentileCI(percentile[, options])", + "signature": "`histogram.percentileCI(percentile[, options])`", + "apiSymbol": "histogram.percentileCI", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogrampercentilecipercentile-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:e35001d4c8a0", + "chapter": "perf_hooks", + "label": "histogram.percentilesAt(percentiles)", + "signature": "`histogram.percentilesAt(percentiles)`", + "apiSymbol": "histogram.percentilesAt", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogrampercentilesatpercentiles", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:e8464d875a0d", + "chapter": "perf_hooks", + "label": "histogram.qrde([options])", + "signature": "`histogram.qrde([options])`", + "apiSymbol": "histogram.qrde", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramqrdeoptions", "nodeStability": { "index": "2", "level": 2, @@ -50780,7 +54293,32 @@ "label": "histogram.reset()", "signature": "`histogram.reset()`", "apiSymbol": "histogram.reset", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#histogramreset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramreset", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:355c107f6c4d", + "chapter": "perf_hooks", + "label": "histogram.welchTest(other[, options])", + "signature": "`histogram.welchTest(other[, options])`", + "apiSymbol": "histogram.welchTest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramwelchtestother-options", "nodeStability": { "index": "2", "level": 2, @@ -50805,7 +54343,7 @@ "label": "count", "signature": "`count` Type: {number}", "apiSymbol": "count", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", "nodeStability": { "index": "2", "level": 2, @@ -50830,7 +54368,7 @@ "label": "countBigInt", "signature": "`countBigInt` Type: {bigint}", "apiSymbol": "countBigInt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", "nodeStability": { "index": "2", "level": 2, @@ -50855,7 +54393,7 @@ "label": "exceeds", "signature": "`exceeds` Type: {number}", "apiSymbol": "exceeds", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", "nodeStability": { "index": "2", "level": 2, @@ -50880,7 +54418,107 @@ "label": "exceedsBigInt", "signature": "`exceedsBigInt` Type: {bigint}", "apiSymbol": "exceedsBigInt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:a6dbb2c261dd", + "chapter": "perf_hooks", + "label": "ewmaMean", + "signature": "`ewmaMean` Type: {number}", + "apiSymbol": "ewmaMean", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:ff01abf35e25", + "chapter": "perf_hooks", + "label": "ewmaStddev", + "signature": "`ewmaStddev` Type: {number}", + "apiSymbol": "ewmaStddev", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:5b140d5efd8a", + "chapter": "perf_hooks", + "label": "ewmaErrorRate", + "signature": "`ewmaErrorRate` Type: {number}", + "apiSymbol": "ewmaErrorRate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:0b729495c21e", + "chapter": "perf_hooks", + "label": "kurtosis", + "signature": "`kurtosis` Type: {number}", + "apiSymbol": "kurtosis", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", "nodeStability": { "index": "2", "level": 2, @@ -50905,7 +54543,7 @@ "label": "max", "signature": "`max` Type: {number}", "apiSymbol": "max", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", "nodeStability": { "index": "2", "level": 2, @@ -50930,7 +54568,7 @@ "label": "maxBigInt", "signature": "`maxBigInt` Type: {bigint}", "apiSymbol": "maxBigInt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", "nodeStability": { "index": "2", "level": 2, @@ -50955,7 +54593,7 @@ "label": "mean", "signature": "`mean` Type: {number}", "apiSymbol": "mean", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", "nodeStability": { "index": "2", "level": 2, @@ -50980,7 +54618,7 @@ "label": "min", "signature": "`min` Type: {number}", "apiSymbol": "min", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", "nodeStability": { "index": "2", "level": 2, @@ -51005,7 +54643,7 @@ "label": "minBigInt", "signature": "`minBigInt` Type: {bigint}", "apiSymbol": "minBigInt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", "nodeStability": { "index": "2", "level": 2, @@ -51030,7 +54668,7 @@ "label": "percentiles", "signature": "`percentiles` Type: {Map}", "apiSymbol": "percentiles", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", "nodeStability": { "index": "2", "level": 2, @@ -51055,7 +54693,32 @@ "label": "percentilesBigInt", "signature": "`percentilesBigInt` Type: {Map}", "apiSymbol": "percentilesBigInt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:740617c55837", + "chapter": "perf_hooks", + "label": "skewness", + "signature": "`skewness` Type: {number}", + "apiSymbol": "skewness", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", "nodeStability": { "index": "2", "level": 2, @@ -51080,7 +54743,7 @@ "label": "stddev", "signature": "`stddev` Type: {number}", "apiSymbol": "stddev", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-histogram", "nodeStability": { "index": "2", "level": 2, @@ -51100,12 +54763,12 @@ } }, { - "id": "perf_hooks:d8033c297e16", + "id": "perf_hooks:8a7e519bbfcf", "chapter": "perf_hooks", - "label": "IntervalHistogram extends Histogram", - "signature": "Class: `IntervalHistogram extends Histogram`", - "apiSymbol": "IntervalHistogram extends Histogram", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-intervalhistogram-extends-histogram", + "label": "ELDHistogram extends Histogram", + "signature": "Class: `ELDHistogram extends Histogram`", + "apiSymbol": "ELDHistogram extends Histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-eldhistogram-extends-histogram", "nodeStability": { "index": "2", "level": 2, @@ -51125,12 +54788,12 @@ } }, { - "id": "perf_hooks:22e7f3f19476", + "id": "perf_hooks:c4fd14c1e628", "chapter": "perf_hooks", - "label": "Cloning an IntervalHistogram", - "signature": "Cloning an `IntervalHistogram`", - "apiSymbol": "IntervalHistogram", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#cloning-an-intervalhistogram", + "label": "Cloning an ELDHistogram", + "signature": "Cloning an `ELDHistogram`", + "apiSymbol": "ELDHistogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#cloning-an-eldhistogram", "nodeStability": { "index": "2", "level": 2, @@ -51150,12 +54813,12 @@ } }, { - "id": "perf_hooks:b164c7ab2b1f", + "id": "perf_hooks:b534ec2912d4", "chapter": "perf_hooks", "label": "histogram.disable()", "signature": "`histogram.disable()`", "apiSymbol": "histogram.disable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#histogramdisable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramdisable", "nodeStability": { "index": "2", "level": 2, @@ -51175,12 +54838,12 @@ } }, { - "id": "perf_hooks:651554deb586", + "id": "perf_hooks:6101277d5070", "chapter": "perf_hooks", "label": "histogram.enable()", "signature": "`histogram.enable()`", "apiSymbol": "histogram.enable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#histogramenable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramenable", "nodeStability": { "index": "2", "level": 2, @@ -51200,12 +54863,12 @@ } }, { - "id": "perf_hooks:e996f640b593", + "id": "perf_hooks:02e07d3a1e87", "chapter": "perf_hooks", "label": "histogram[Symbol.dispose]()", "signature": "`histogram[Symbol.dispose]()`", "apiSymbol": "histogram", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#histogramsymboldispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramsymboldispose", "nodeStability": { "index": "2", "level": 2, @@ -51230,7 +54893,7 @@ "label": "RecordableHistogram extends Histogram", "signature": "Class: `RecordableHistogram extends Histogram`", "apiSymbol": "RecordableHistogram extends Histogram", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#class-recordablehistogram-extends-histogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-recordablehistogram-extends-histogram", "nodeStability": { "index": "2", "level": 2, @@ -51249,41 +54912,13 @@ } } }, - { - "id": "perf_hooks:07074b77fe50", - "chapter": "perf_hooks", - "label": "Measuring how long the net.connect (only for TCP) takes when the connection is successful", - "signature": "Measuring how long the `net.connect` (only for TCP) takes when the connection is successful", - "apiSymbol": "net.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#measuring-how-long-the-netconnect-only-for-tcp-takes-when-the-connection-is-successful", - "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true - }, - "priority": "high", - "tiers": { - "static": { - "status": "partial", - "action": "audit-partial", - "verification": "test-backed", - "confidence": "high", - "source": "compiler-dedicated:net.connect", - "tests": [ - "tests/corpus/2500-net-autosel-timeout.ts", - "tests/corpus/2596-net-arg-ladders.cjs" - ] - } - } - }, { "id": "perf_hooks:30eb4343b866", "chapter": "perf_hooks", "label": "histogram.add(other)", "signature": "`histogram.add(other)`", "apiSymbol": "histogram.add", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#histogramaddother", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramaddother", "nodeStability": { "index": "2", "level": 2, @@ -51308,7 +54943,7 @@ "label": "histogram.record(val)", "signature": "`histogram.record(val)`", "apiSymbol": "histogram.record", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#histogramrecordval", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramrecordval", "nodeStability": { "index": "2", "level": 2, @@ -51333,7 +54968,157 @@ "label": "histogram.recordDelta()", "signature": "`histogram.recordDelta()`", "apiSymbol": "histogram.recordDelta", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#histogramrecorddelta", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramrecorddelta", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:7bb1ff7d8dee", + "chapter": "perf_hooks", + "label": "histogram.recordCorrected(val, expectedInterval)", + "signature": "`histogram.recordCorrected(val, expectedInterval)`", + "apiSymbol": "histogram.recordCorrected", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramrecordcorrectedval-expectedinterval", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:45ea9ace9906", + "chapter": "perf_hooks", + "label": "histogram.subtract(other)", + "signature": "`histogram.subtract(other)`", + "apiSymbol": "histogram.subtract", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#histogramsubtractother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:f2dbe6996530", + "chapter": "perf_hooks", + "label": "SlidingWindowHistogram", + "signature": "Class: `SlidingWindowHistogram`", + "apiSymbol": "SlidingWindowHistogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#class-slidingwindowhistogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:7d8e0c897024", + "chapter": "perf_hooks", + "label": "slidingWindowHistogram.record(val)", + "signature": "`slidingWindowHistogram.record(val)`", + "apiSymbol": "slidingWindowHistogram.record", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#slidingwindowhistogramrecordval", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:dc33b594890e", + "chapter": "perf_hooks", + "label": "slidingWindowHistogram.reset()", + "signature": "`slidingWindowHistogram.reset()`", + "apiSymbol": "slidingWindowHistogram.reset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#slidingwindowhistogramreset", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:562f505d25da", + "chapter": "perf_hooks", + "label": "slidingWindowHistogram.snapshot()", + "signature": "`slidingWindowHistogram.snapshot()`", + "apiSymbol": "slidingWindowHistogram.snapshot", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#slidingwindowhistogramsnapshot", "nodeStability": { "index": "2", "level": 2, @@ -51358,7 +55143,57 @@ "label": "perf_hooks.createHistogram([options])", "signature": "`perf_hooks.createHistogram([options])`", "apiSymbol": "perf_hooks.createHistogram", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#perf_hookscreatehistogramoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#perf_hookscreatehistogramoptions", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:8d8858b23a7d", + "chapter": "perf_hooks", + "label": "perf_hooks.createSlidingWindowHistogram(options)", + "signature": "`perf_hooks.createSlidingWindowHistogram(options)`", + "apiSymbol": "perf_hooks.createSlidingWindowHistogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#perf_hookscreateslidingwindowhistogramoptions", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:perf_hooks", + "tests": [] + } + } + }, + { + "id": "perf_hooks:3b65cfa382c4", + "chapter": "perf_hooks", + "label": "perf_hooks.importHistogram(data)", + "signature": "`perf_hooks.importHistogram(data)`", + "apiSymbol": "perf_hooks.importHistogram", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#perf_hooksimporthistogramdata", "nodeStability": { "index": "2", "level": 2, @@ -51383,7 +55218,7 @@ "label": "perf_hooks.eventLoopUtilization([utilization1[, utilization2]])", "signature": "`perf_hooks.eventLoopUtilization([utilization1[, utilization2]])`", "apiSymbol": "perf_hooks.eventLoopUtilization", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#perf_hookseventlooputilizationutilization1-utilization2", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#perf_hookseventlooputilizationutilization1-utilization2", "nodeStability": { "index": "2", "level": 2, @@ -51408,7 +55243,7 @@ "label": "perf_hooks.monitorEventLoopDelay([options])", "signature": "`perf_hooks.monitorEventLoopDelay([options])`", "apiSymbol": "perf_hooks.monitorEventLoopDelay", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#perf_hooksmonitoreventloopdelayoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#perf_hooksmonitoreventloopdelayoptions", "nodeStability": { "index": "2", "level": 2, @@ -51433,7 +55268,7 @@ "label": "perf_hooks.timerify(fn[, options])", "signature": "`perf_hooks.timerify(fn[, options])`", "apiSymbol": "perf_hooks.timerify", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#perf_hookstimerifyfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#perf_hookstimerifyfn-options", "nodeStability": { "index": "2", "level": 2, @@ -51458,7 +55293,7 @@ "label": "perf_hooks.performance", "signature": "`perf_hooks.performance`", "apiSymbol": "perf_hooks.performance", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#perf_hooksperformance", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#perf_hooksperformance", "nodeStability": { "index": "2", "level": 2, @@ -51483,7 +55318,7 @@ "label": "performance.clearMarks([name])", "signature": "`performance.clearMarks([name])`", "apiSymbol": "performance.clearMarks", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performanceclearmarksname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performanceclearmarksname", "nodeStability": { "index": "2", "level": 2, @@ -51513,7 +55348,7 @@ "label": "performance.clearMeasures([name])", "signature": "`performance.clearMeasures([name])`", "apiSymbol": "performance.clearMeasures", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performanceclearmeasuresname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performanceclearmeasuresname", "nodeStability": { "index": "2", "level": 2, @@ -51543,7 +55378,7 @@ "label": "performance.clearResourceTimings([name])", "signature": "`performance.clearResourceTimings([name])`", "apiSymbol": "performance.clearResourceTimings", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performanceclearresourcetimingsname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performanceclearresourcetimingsname", "nodeStability": { "index": "2", "level": 2, @@ -51568,7 +55403,7 @@ "label": "performance.eventLoopUtilization([utilization1[, utilization2]])", "signature": "`performance.eventLoopUtilization([utilization1[, utilization2]])`", "apiSymbol": "performance.eventLoopUtilization", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performanceeventlooputilizationutilization1-utilization2", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performanceeventlooputilizationutilization1-utilization2", "nodeStability": { "index": "2", "level": 2, @@ -51593,7 +55428,7 @@ "label": "performance.getEntries()", "signature": "`performance.getEntries()`", "apiSymbol": "performance.getEntries", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performancegetentries", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performancegetentries", "nodeStability": { "index": "2", "level": 2, @@ -51623,7 +55458,7 @@ "label": "performance.getEntriesByName(name[, type])", "signature": "`performance.getEntriesByName(name[, type])`", "apiSymbol": "performance.getEntriesByName", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performancegetentriesbynamename-type", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performancegetentriesbynamename-type", "nodeStability": { "index": "2", "level": 2, @@ -51653,7 +55488,7 @@ "label": "performance.getEntriesByType(type)", "signature": "`performance.getEntriesByType(type)`", "apiSymbol": "performance.getEntriesByType", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performancegetentriesbytypetype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performancegetentriesbytypetype", "nodeStability": { "index": "2", "level": 2, @@ -51683,7 +55518,7 @@ "label": "performance.mark(name[, options])", "signature": "`performance.mark(name[, options])`", "apiSymbol": "performance.mark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performancemarkname-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performancemarkname-options", "nodeStability": { "index": "2", "level": 2, @@ -51713,7 +55548,7 @@ "label": "performance.markResourceTiming(timingInfo, requestedUrl, initiatorType, global, cacheMode, bodyInfo, responseStatus[, deliveryType])", "signature": "`performance.markResourceTiming(timingInfo, requestedUrl, initiatorType, global, cacheMode, bodyInfo, responseStatus[, deliveryType])`", "apiSymbol": "performance.markResourceTiming", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performancemarkresourcetimingtiminginfo-requestedurl-initiatortype-global-cachemode-bodyinfo-responsestatus-deliverytype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performancemarkresourcetimingtiminginfo-requestedurl-initiatortype-global-cachemode-bodyinfo-responsestatus-deliverytype", "nodeStability": { "index": "2", "level": 2, @@ -51738,7 +55573,7 @@ "label": "performance.measure(name[, startMarkOrOptions[, endMark]])", "signature": "`performance.measure(name[, startMarkOrOptions[, endMark]])`", "apiSymbol": "performance.measure", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performancemeasurename-startmarkoroptions-endmark", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performancemeasurename-startmarkoroptions-endmark", "nodeStability": { "index": "2", "level": 2, @@ -51768,7 +55603,7 @@ "label": "performance.now()", "signature": "`performance.now()`", "apiSymbol": "performance.now", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performancenow", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performancenow", "nodeStability": { "index": "2", "level": 2, @@ -51796,7 +55631,7 @@ "label": "performance.setResourceTimingBufferSize(maxSize)", "signature": "`performance.setResourceTimingBufferSize(maxSize)`", "apiSymbol": "performance.setResourceTimingBufferSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performancesetresourcetimingbuffersizemaxsize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performancesetresourcetimingbuffersizemaxsize", "nodeStability": { "index": "2", "level": 2, @@ -51821,7 +55656,7 @@ "label": "performance.timerify(fn[, options])", "signature": "`performance.timerify(fn[, options])`", "apiSymbol": "performance.timerify", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performancetimerifyfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performancetimerifyfn-options", "nodeStability": { "index": "2", "level": 2, @@ -51846,7 +55681,7 @@ "label": "performance.toJSON()", "signature": "`performance.toJSON()`", "apiSymbol": "performance.toJSON", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#performancetojson", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#performancetojson", "nodeStability": { "index": "2", "level": 2, @@ -51871,7 +55706,7 @@ "label": "'resourcetimingbufferfull'", "signature": "Event: `'resourcetimingbufferfull'`", "apiSymbol": "'resourcetimingbufferfull'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#event-resourcetimingbufferfull", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#event-resourcetimingbufferfull", "nodeStability": { "index": "2", "level": 2, @@ -51896,7 +55731,7 @@ "label": "nodeTiming", "signature": "`nodeTiming` Type: {PerformanceNodeTiming}", "apiSymbol": "nodeTiming", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#perf_hooksperformance", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#perf_hooksperformance", "nodeStability": { "index": "2", "level": 2, @@ -51921,7 +55756,7 @@ "label": "timeOrigin", "signature": "`timeOrigin` Type: {number}", "apiSymbol": "timeOrigin", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/perf_hooks.html#perf_hooksperformance", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/perf_hooks.html#perf_hooksperformance", "nodeStability": { "index": "2", "level": 2, @@ -51946,7 +55781,32 @@ "label": "permission.has(scope[, reference])", "signature": "`permission.has(scope[, reference])`", "apiSymbol": "permission.has", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/permissions.html#permissionhasscope-reference", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/permissions.html#permissionhasscope-reference", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "implement", + "verification": "declared-gap", + "confidence": "medium", + "source": "compiler-chapter-policy:permissions", + "tests": [] + } + } + }, + { + "id": "permissions:11ad69fabdba", + "chapter": "permissions", + "label": "permission.drop(scope[, reference])", + "signature": "`permission.drop(scope[, reference])`", + "apiSymbol": "permission.drop", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/permissions.html#permissiondropscope-reference", "nodeStability": { "index": "2", "level": 2, @@ -51971,7 +55831,7 @@ "label": "Using the Permission Model with npx", "signature": "Using the Permission Model with `npx`", "apiSymbol": "npx", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/permissions.html#using-the-permission-model-with-npx", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/permissions.html#using-the-permission-model-with-npx", "nodeStability": { "index": "2", "level": 2, @@ -51996,7 +55856,7 @@ "label": "'beforeExit'", "signature": "Event: `'beforeExit'`", "apiSymbol": "'beforeExit'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#event-beforeexit", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#event-beforeexit", "nodeStability": null, "priority": "normal", "tiers": { @@ -52016,7 +55876,7 @@ "label": "'disconnect'", "signature": "Event: `'disconnect'`", "apiSymbol": "'disconnect'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#event-disconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#event-disconnect", "nodeStability": null, "priority": "normal", "tiers": { @@ -52038,7 +55898,7 @@ "label": "'exit'", "signature": "Event: `'exit'`", "apiSymbol": "'exit'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#event-exit", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#event-exit", "nodeStability": null, "priority": "normal", "tiers": { @@ -52058,7 +55918,7 @@ "label": "'message'", "signature": "Event: `'message'`", "apiSymbol": "'message'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#event-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#event-message", "nodeStability": null, "priority": "normal", "tiers": { @@ -52080,7 +55940,7 @@ "label": "'multipleResolves'", "signature": "Event: `'multipleResolves'`", "apiSymbol": "'multipleResolves'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#event-multipleresolves", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#event-multipleresolves", "nodeStability": { "index": "0", "level": 0, @@ -52105,7 +55965,7 @@ "label": "'rejectionHandled'", "signature": "Event: `'rejectionHandled'`", "apiSymbol": "'rejectionHandled'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#event-rejectionhandled", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#event-rejectionhandled", "nodeStability": null, "priority": "normal", "tiers": { @@ -52125,7 +55985,7 @@ "label": "'workerMessage'", "signature": "Event: `'workerMessage'`", "apiSymbol": "'workerMessage'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#event-workermessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#event-workermessage", "nodeStability": null, "priority": "normal", "tiers": { @@ -52145,7 +56005,7 @@ "label": "'uncaughtException'", "signature": "Event: `'uncaughtException'`", "apiSymbol": "'uncaughtException'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#event-uncaughtexception", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#event-uncaughtexception", "nodeStability": null, "priority": "normal", "tiers": { @@ -52172,7 +56032,7 @@ "label": "Warning: Using 'uncaughtException' correctly", "signature": "Warning: Using `'uncaughtException'` correctly", "apiSymbol": "'uncaughtException'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#warning-using-uncaughtexception-correctly", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#warning-using-uncaughtexception-correctly", "nodeStability": null, "priority": "normal", "tiers": { @@ -52192,7 +56052,7 @@ "label": "'uncaughtExceptionMonitor'", "signature": "Event: `'uncaughtExceptionMonitor'`", "apiSymbol": "'uncaughtExceptionMonitor'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#event-uncaughtexceptionmonitor", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#event-uncaughtexceptionmonitor", "nodeStability": null, "priority": "normal", "tiers": { @@ -52219,7 +56079,7 @@ "label": "'unhandledRejection'", "signature": "Event: `'unhandledRejection'`", "apiSymbol": "'unhandledRejection'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#event-unhandledrejection", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#event-unhandledrejection", "nodeStability": null, "priority": "normal", "tiers": { @@ -52239,7 +56099,7 @@ "label": "'warning'", "signature": "Event: `'warning'`", "apiSymbol": "'warning'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#event-warning", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#event-warning", "nodeStability": null, "priority": "normal", "tiers": { @@ -52263,7 +56123,7 @@ "label": "'worker'", "signature": "Event: `'worker'`", "apiSymbol": "'worker'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#event-worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#event-worker", "nodeStability": null, "priority": "normal", "tiers": { @@ -52283,7 +56143,7 @@ "label": "Signal events", "signature": "Signal events", "apiSymbol": "SIGINT, SIGHUP, etc.", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#signal-events", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#signal-events", "nodeStability": null, "priority": "normal", "tiers": { @@ -52306,7 +56166,7 @@ "label": "process.abort()", "signature": "`process.abort()`", "apiSymbol": "process.abort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processabort", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processabort", "nodeStability": null, "priority": "normal", "tiers": { @@ -52326,7 +56186,7 @@ "label": "process.availableMemory()", "signature": "`process.availableMemory()`", "apiSymbol": "process.availableMemory", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processavailablememory", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processavailablememory", "nodeStability": null, "priority": "normal", "tiers": { @@ -52349,7 +56209,7 @@ "label": "process.chdir(directory)", "signature": "`process.chdir(directory)`", "apiSymbol": "process.chdir", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processchdirdirectory", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processchdirdirectory", "nodeStability": null, "priority": "normal", "tiers": { @@ -52372,7 +56232,7 @@ "label": "process.constrainedMemory()", "signature": "`process.constrainedMemory()`", "apiSymbol": "process.constrainedMemory", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processconstrainedmemory", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processconstrainedmemory", "nodeStability": null, "priority": "normal", "tiers": { @@ -52395,7 +56255,7 @@ "label": "process.cpuUsage([previousValue])", "signature": "`process.cpuUsage([previousValue])`", "apiSymbol": "process.cpuUsage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processcpuusagepreviousvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processcpuusagepreviousvalue", "nodeStability": null, "priority": "normal", "tiers": { @@ -52418,7 +56278,7 @@ "label": "process.cwd()", "signature": "`process.cwd()`", "apiSymbol": "process.cwd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processcwd", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processcwd", "nodeStability": null, "priority": "normal", "tiers": { @@ -52441,7 +56301,7 @@ "label": "process.disconnect()", "signature": "`process.disconnect()`", "apiSymbol": "process.disconnect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processdisconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processdisconnect", "nodeStability": null, "priority": "normal", "tiers": { @@ -52463,7 +56323,7 @@ "label": "process.dlopen(module, filename[, flags])", "signature": "`process.dlopen(module, filename[, flags])`", "apiSymbol": "process.dlopen", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processdlopenmodule-filename-flags", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processdlopenmodule-filename-flags", "nodeStability": null, "priority": "normal", "tiers": { @@ -52483,7 +56343,7 @@ "label": "process.emitWarning(warning[, options])", "signature": "`process.emitWarning(warning[, options])`", "apiSymbol": "process.emitWarning", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processemitwarningwarning-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processemitwarningwarning-options", "nodeStability": null, "priority": "normal", "tiers": { @@ -52507,7 +56367,7 @@ "label": "process.emitWarning(warning[, type[, code]][, ctor])", "signature": "`process.emitWarning(warning[, type[, code]][, ctor])`", "apiSymbol": "process.emitWarning", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processemitwarningwarning-type-code-ctor", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processemitwarningwarning-type-code-ctor", "nodeStability": null, "priority": "normal", "tiers": { @@ -52531,7 +56391,7 @@ "label": "process.execve(file[, args[, env]])", "signature": "`process.execve(file[, args[, env]])`", "apiSymbol": "process.execve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processexecvefile-args-env", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processexecvefile-args-env", "nodeStability": { "index": "1", "level": 1, @@ -52556,7 +56416,7 @@ "label": "process.exit([code])", "signature": "`process.exit([code])`", "apiSymbol": "process.exit", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processexitcode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processexitcode", "nodeStability": null, "priority": "normal", "tiers": { @@ -52579,7 +56439,7 @@ "label": "process.finalization.register(ref, callback)", "signature": "`process.finalization.register(ref, callback)`", "apiSymbol": "process.finalization.register", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processfinalizationregisterref-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processfinalizationregisterref-callback", "nodeStability": { "index": "1.1", "level": 1, @@ -52604,7 +56464,7 @@ "label": "process.finalization.registerBeforeExit(ref, callback)", "signature": "`process.finalization.registerBeforeExit(ref, callback)`", "apiSymbol": "process.finalization.registerBeforeExit", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processfinalizationregisterbeforeexitref-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processfinalizationregisterbeforeexitref-callback", "nodeStability": { "index": "1.1", "level": 1, @@ -52629,7 +56489,7 @@ "label": "process.finalization.unregister(ref)", "signature": "`process.finalization.unregister(ref)`", "apiSymbol": "process.finalization.unregister", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processfinalizationunregisterref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processfinalizationunregisterref", "nodeStability": { "index": "1.1", "level": 1, @@ -52654,7 +56514,7 @@ "label": "process.getActiveResourcesInfo()", "signature": "`process.getActiveResourcesInfo()`", "apiSymbol": "process.getActiveResourcesInfo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processgetactiveresourcesinfo", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processgetactiveresourcesinfo", "nodeStability": null, "priority": "normal", "tiers": { @@ -52674,7 +56534,7 @@ "label": "process.getBuiltinModule(id)", "signature": "`process.getBuiltinModule(id)`", "apiSymbol": "process.getBuiltinModule", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processgetbuiltinmoduleid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processgetbuiltinmoduleid", "nodeStability": null, "priority": "normal", "tiers": { @@ -52697,7 +56557,7 @@ "label": "process.getegid()", "signature": "`process.getegid()`", "apiSymbol": "process.getegid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processgetegid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processgetegid", "nodeStability": null, "priority": "normal", "tiers": { @@ -52719,7 +56579,7 @@ "label": "process.geteuid()", "signature": "`process.geteuid()`", "apiSymbol": "process.geteuid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processgeteuid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processgeteuid", "nodeStability": null, "priority": "normal", "tiers": { @@ -52741,7 +56601,7 @@ "label": "process.getgid()", "signature": "`process.getgid()`", "apiSymbol": "process.getgid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processgetgid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processgetgid", "nodeStability": null, "priority": "normal", "tiers": { @@ -52764,7 +56624,7 @@ "label": "process.getgroups()", "signature": "`process.getgroups()`", "apiSymbol": "process.getgroups", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processgetgroups", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processgetgroups", "nodeStability": null, "priority": "normal", "tiers": { @@ -52786,7 +56646,7 @@ "label": "process.getuid()", "signature": "`process.getuid()`", "apiSymbol": "process.getuid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processgetuid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processgetuid", "nodeStability": null, "priority": "normal", "tiers": { @@ -52809,7 +56669,7 @@ "label": "process.hasUncaughtExceptionCaptureCallback()", "signature": "`process.hasUncaughtExceptionCaptureCallback()`", "apiSymbol": "process.hasUncaughtExceptionCaptureCallback", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processhasuncaughtexceptioncapturecallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processhasuncaughtexceptioncapturecallback", "nodeStability": null, "priority": "normal", "tiers": { @@ -52829,7 +56689,7 @@ "label": "process.hrtime([time])", "signature": "`process.hrtime([time])`", "apiSymbol": "process.hrtime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processhrtimetime", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processhrtimetime", "nodeStability": { "index": "3", "level": 3, @@ -52856,7 +56716,7 @@ "label": "process.hrtime.bigint()", "signature": "`process.hrtime.bigint()`", "apiSymbol": "process.hrtime.bigint", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processhrtimebigint", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processhrtimebigint", "nodeStability": null, "priority": "normal", "tiers": { @@ -52878,7 +56738,7 @@ "label": "process.initgroups(user, extraGroup)", "signature": "`process.initgroups(user, extraGroup)`", "apiSymbol": "process.initgroups", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processinitgroupsuser-extragroup", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processinitgroupsuser-extragroup", "nodeStability": null, "priority": "normal", "tiers": { @@ -52898,7 +56758,7 @@ "label": "process.kill(pid[, signal])", "signature": "`process.kill(pid[, signal])`", "apiSymbol": "process.kill", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processkillpid-signal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processkillpid-signal", "nodeStability": null, "priority": "normal", "tiers": { @@ -52921,7 +56781,7 @@ "label": "process.loadEnvFile(path)", "signature": "`process.loadEnvFile(path)`", "apiSymbol": "process.loadEnvFile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processloadenvfilepath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processloadenvfilepath", "nodeStability": null, "priority": "normal", "tiers": { @@ -52947,7 +56807,7 @@ "label": "process.memoryUsage()", "signature": "`process.memoryUsage()`", "apiSymbol": "process.memoryUsage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processmemoryusage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processmemoryusage", "nodeStability": null, "priority": "normal", "tiers": { @@ -52969,7 +56829,7 @@ "label": "process.memoryUsage.rss()", "signature": "`process.memoryUsage.rss()`", "apiSymbol": "process.memoryUsage.rss", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processmemoryusagerss", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processmemoryusagerss", "nodeStability": null, "priority": "normal", "tiers": { @@ -52991,7 +56851,7 @@ "label": "process.nextTick(callback[, ...args])", "signature": "`process.nextTick(callback[, ...args])`", "apiSymbol": "process.nextTick", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processnexttickcallback-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processnexttickcallback-args", "nodeStability": { "index": "3", "level": 3, @@ -53016,7 +56876,7 @@ "label": "When to use queueMicrotask() vs. process.nextTick()", "signature": "When to use `queueMicrotask()` vs. `process.nextTick()`", "apiSymbol": "queueMicrotask", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#when-to-use-queuemicrotask-vs-processnexttick", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#when-to-use-queuemicrotask-vs-processnexttick", "nodeStability": { "index": "3", "level": 3, @@ -53041,7 +56901,7 @@ "label": "process.ref(maybeRefable)", "signature": "`process.ref(maybeRefable)`", "apiSymbol": "process.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processrefmayberefable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processrefmayberefable", "nodeStability": { "index": "1", "level": 1, @@ -53066,7 +56926,7 @@ "label": "process.resourceUsage()", "signature": "`process.resourceUsage()`", "apiSymbol": "process.resourceUsage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processresourceusage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processresourceusage", "nodeStability": null, "priority": "normal", "tiers": { @@ -53089,7 +56949,7 @@ "label": "process.send(message[, sendHandle[, options]][, callback])", "signature": "`process.send(message[, sendHandle[, options]][, callback])`", "apiSymbol": "process.send", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processsendmessage-sendhandle-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processsendmessage-sendhandle-options-callback", "nodeStability": null, "priority": "normal", "tiers": { @@ -53111,7 +56971,7 @@ "label": "process.setegid(id)", "signature": "`process.setegid(id)`", "apiSymbol": "process.setegid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processsetegidid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processsetegidid", "nodeStability": null, "priority": "normal", "tiers": { @@ -53131,7 +56991,7 @@ "label": "process.seteuid(id)", "signature": "`process.seteuid(id)`", "apiSymbol": "process.seteuid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processseteuidid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processseteuidid", "nodeStability": null, "priority": "normal", "tiers": { @@ -53151,7 +57011,7 @@ "label": "process.setgid(id)", "signature": "`process.setgid(id)`", "apiSymbol": "process.setgid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processsetgidid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processsetgidid", "nodeStability": null, "priority": "normal", "tiers": { @@ -53171,7 +57031,7 @@ "label": "process.setgroups(groups)", "signature": "`process.setgroups(groups)`", "apiSymbol": "process.setgroups", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processsetgroupsgroups", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processsetgroupsgroups", "nodeStability": null, "priority": "normal", "tiers": { @@ -53191,7 +57051,7 @@ "label": "process.setuid(id)", "signature": "`process.setuid(id)`", "apiSymbol": "process.setuid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processsetuidid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processsetuidid", "nodeStability": null, "priority": "normal", "tiers": { @@ -53211,7 +57071,7 @@ "label": "process.setSourceMapsEnabled(val)", "signature": "`process.setSourceMapsEnabled(val)`", "apiSymbol": "process.setSourceMapsEnabled", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processsetsourcemapsenabledval", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processsetsourcemapsenabledval", "nodeStability": { "index": "1", "level": 1, @@ -53236,7 +57096,7 @@ "label": "process.setUncaughtExceptionCaptureCallback(fn)", "signature": "`process.setUncaughtExceptionCaptureCallback(fn)`", "apiSymbol": "process.setUncaughtExceptionCaptureCallback", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processsetuncaughtexceptioncapturecallbackfn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processsetuncaughtexceptioncapturecallbackfn", "nodeStability": null, "priority": "normal", "tiers": { @@ -53256,7 +57116,7 @@ "label": "process.threadCpuUsage([previousValue])", "signature": "`process.threadCpuUsage([previousValue])`", "apiSymbol": "process.threadCpuUsage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processthreadcpuusagepreviousvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processthreadcpuusagepreviousvalue", "nodeStability": null, "priority": "normal", "tiers": { @@ -53279,7 +57139,7 @@ "label": "process.umask()", "signature": "`process.umask()`", "apiSymbol": "process.umask", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processumask", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processumask", "nodeStability": { "index": "0", "level": 0, @@ -53307,7 +57167,7 @@ "label": "process.umask(mask)", "signature": "`process.umask(mask)`", "apiSymbol": "process.umask", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processumaskmask", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processumaskmask", "nodeStability": null, "priority": "normal", "tiers": { @@ -53330,7 +57190,7 @@ "label": "process.unref(maybeRefable)", "signature": "`process.unref(maybeRefable)`", "apiSymbol": "process.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processunrefmayberefable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processunrefmayberefable", "nodeStability": { "index": "1", "level": 1, @@ -53355,7 +57215,7 @@ "label": "process.uptime()", "signature": "`process.uptime()`", "apiSymbol": "process.uptime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processuptime", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processuptime", "nodeStability": null, "priority": "normal", "tiers": { @@ -53378,7 +57238,7 @@ "label": "allowedNodeEnvironmentFlags", "signature": "`allowedNodeEnvironmentFlags` Type: {Set}", "apiSymbol": "allowedNodeEnvironmentFlags", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53398,7 +57258,7 @@ "label": "arch", "signature": "`arch` Type: {string}", "apiSymbol": "arch", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53418,7 +57278,7 @@ "label": "argv", "signature": "`argv` Type: {string\\[]}", "apiSymbol": "argv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53441,7 +57301,7 @@ "label": "argv0", "signature": "`argv0` Type: {string}", "apiSymbol": "argv0", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53463,7 +57323,7 @@ "label": "channel", "signature": "`channel` Type: {Object}", "apiSymbol": "channel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53483,7 +57343,7 @@ "label": "process.channel.ref()", "signature": "`process.channel.ref()`", "apiSymbol": "process.channel.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processchannelref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processchannelref", "nodeStability": null, "priority": "normal", "tiers": { @@ -53503,7 +57363,7 @@ "label": "process.channel.unref()", "signature": "`process.channel.unref()`", "apiSymbol": "process.channel.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processchannelunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processchannelunref", "nodeStability": null, "priority": "normal", "tiers": { @@ -53523,7 +57383,7 @@ "label": "config", "signature": "`config` Type: {Object}", "apiSymbol": "config", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53543,7 +57403,7 @@ "label": "connected", "signature": "`connected` Type: {boolean}", "apiSymbol": "connected", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53565,7 +57425,7 @@ "label": "debugPort", "signature": "`debugPort` Type: {number}", "apiSymbol": "debugPort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53585,7 +57445,7 @@ "label": "env", "signature": "`env` Type: {Object}", "apiSymbol": "env", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53608,7 +57468,7 @@ "label": "execArgv", "signature": "`execArgv` Type: {string\\[]}", "apiSymbol": "execArgv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53628,7 +57488,7 @@ "label": "execPath", "signature": "`execPath` Type: {string}", "apiSymbol": "execPath", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53651,7 +57511,7 @@ "label": "exitCode", "signature": "`exitCode` Type: {integer|string|null|undefined} The exit code. For string type, only integer strings (e.g.,'1') are allowed. **Default:** `undefined`.", "apiSymbol": "exitCode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53676,7 +57536,7 @@ "label": "cached_builtins", "signature": "`cached_builtins` Type: {boolean}", "apiSymbol": "cached_builtins", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53696,7 +57556,7 @@ "label": "debug", "signature": "`debug` Type: {boolean}", "apiSymbol": "debug", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53716,7 +57576,7 @@ "label": "inspector", "signature": "`inspector` Type: {boolean}", "apiSymbol": "inspector", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53736,7 +57596,7 @@ "label": "ipv6", "signature": "`ipv6` Type: {boolean}", "apiSymbol": "ipv6", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": { "index": "0", "level": 0, @@ -53761,7 +57621,7 @@ "label": "require_module", "signature": "`require_module` Type: {boolean}", "apiSymbol": "require_module", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53781,7 +57641,7 @@ "label": "tls", "signature": "`tls` Type: {boolean}", "apiSymbol": "tls", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53801,7 +57661,7 @@ "label": "tls_alpn", "signature": "`tls_alpn` Type: {boolean}", "apiSymbol": "tls_alpn", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": { "index": "0", "level": 0, @@ -53826,7 +57686,7 @@ "label": "tls_ocsp", "signature": "`tls_ocsp` Type: {boolean}", "apiSymbol": "tls_ocsp", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": { "index": "0", "level": 0, @@ -53851,7 +57711,7 @@ "label": "tls_sni", "signature": "`tls_sni` Type: {boolean}", "apiSymbol": "tls_sni", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": { "index": "0", "level": 0, @@ -53876,7 +57736,7 @@ "label": "typescript", "signature": "`typescript` Type: {boolean|string}", "apiSymbol": "typescript", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": { "index": "1.2", "level": 1, @@ -53901,7 +57761,7 @@ "label": "uv", "signature": "`uv` Type: {boolean}", "apiSymbol": "uv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": { "index": "0", "level": 0, @@ -53926,7 +57786,7 @@ "label": "mainModule", "signature": "`mainModule` Type: {Object}", "apiSymbol": "mainModule", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": { "index": "0", "level": 0, @@ -53951,7 +57811,7 @@ "label": "noDeprecation", "signature": "`noDeprecation` Type: {boolean}", "apiSymbol": "noDeprecation", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53975,7 +57835,7 @@ "label": "permission", "signature": "`permission` Type: {Object}", "apiSymbol": "permission", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -53995,7 +57855,7 @@ "label": "process.permission.has(scope[, reference])", "signature": "`process.permission.has(scope[, reference])`", "apiSymbol": "process.permission.has", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processpermissionhasscope-reference", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processpermissionhasscope-reference", "nodeStability": null, "priority": "normal", "tiers": { @@ -54009,13 +57869,38 @@ } } }, + { + "id": "process:1755d174d4bc", + "chapter": "process", + "label": "process.permission.drop(scope[, reference])", + "signature": "`process.permission.drop(scope[, reference])`", + "apiSymbol": "process.permission.drop", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processpermissiondropscope-reference", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active Development", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:process", + "tests": [] + } + } + }, { "id": "process:0fbc1d44adb8", "chapter": "process", "label": "pid", "signature": "`pid` Type: {integer}", "apiSymbol": "pid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54038,7 +57923,7 @@ "label": "platform", "signature": "`platform` Type: {string}", "apiSymbol": "platform", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54058,7 +57943,7 @@ "label": "ppid", "signature": "`ppid` Type: {integer}", "apiSymbol": "ppid", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54080,7 +57965,7 @@ "label": "release", "signature": "`release` Type: {Object}", "apiSymbol": "release", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54102,7 +57987,7 @@ "label": "report", "signature": "`report` Type: {Object}", "apiSymbol": "report", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54122,7 +58007,7 @@ "label": "process.report.getReport([err])", "signature": "`process.report.getReport([err])`", "apiSymbol": "process.report.getReport", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processreportgetreporterr", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processreportgetreporterr", "nodeStability": null, "priority": "normal", "tiers": { @@ -54142,7 +58027,7 @@ "label": "process.report.writeReport([filename][, err])", "signature": "`process.report.writeReport([filename][, err])`", "apiSymbol": "process.report.writeReport", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html#processreportwritereportfilename-err", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html#processreportwritereportfilename-err", "nodeStability": null, "priority": "normal", "tiers": { @@ -54162,7 +58047,7 @@ "label": "compact", "signature": "`compact` Type: {boolean}", "apiSymbol": "compact", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54182,7 +58067,7 @@ "label": "directory", "signature": "`directory` Type: {string}", "apiSymbol": "directory", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54202,7 +58087,7 @@ "label": "filename", "signature": "`filename` Type: {string}", "apiSymbol": "filename", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54222,7 +58107,7 @@ "label": "reportOnFatalError", "signature": "`reportOnFatalError` Type: {boolean}", "apiSymbol": "reportOnFatalError", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54242,7 +58127,7 @@ "label": "reportOnSignal", "signature": "`reportOnSignal` Type: {boolean}", "apiSymbol": "reportOnSignal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54262,7 +58147,7 @@ "label": "reportOnUncaughtException", "signature": "`reportOnUncaughtException` Type: {boolean}", "apiSymbol": "reportOnUncaughtException", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54282,7 +58167,7 @@ "label": "excludeEnv", "signature": "`excludeEnv` Type: {boolean}", "apiSymbol": "excludeEnv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54302,7 +58187,7 @@ "label": "signal", "signature": "`signal` Type: {string}", "apiSymbol": "signal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54322,7 +58207,7 @@ "label": "sourceMapsEnabled", "signature": "`sourceMapsEnabled` Type: {boolean}", "apiSymbol": "sourceMapsEnabled", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": { "index": "1", "level": 1, @@ -54347,7 +58232,7 @@ "label": "stderr", "signature": "`stderr` Type: {Stream}", "apiSymbol": "stderr", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54372,7 +58257,7 @@ "label": "fd", "signature": "`fd` Type: {number}", "apiSymbol": "fd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54392,7 +58277,7 @@ "label": "stdin", "signature": "`stdin` Type: {Stream}", "apiSymbol": "stdin", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54417,7 +58302,7 @@ "label": "fd", "signature": "`fd` Type: {number}", "apiSymbol": "fd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54437,7 +58322,7 @@ "label": "stdout", "signature": "`stdout` Type: {Stream}", "apiSymbol": "stdout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54462,7 +58347,7 @@ "label": "fd", "signature": "`fd` Type: {number}", "apiSymbol": "fd", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54482,7 +58367,7 @@ "label": "throwDeprecation", "signature": "`throwDeprecation` Type: {boolean}", "apiSymbol": "throwDeprecation", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54506,7 +58391,7 @@ "label": "title", "signature": "`title` Type: {string}", "apiSymbol": "title", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54528,7 +58413,7 @@ "label": "traceDeprecation", "signature": "`traceDeprecation` Type: {boolean}", "apiSymbol": "traceDeprecation", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54548,7 +58433,7 @@ "label": "traceProcessWarnings", "signature": "`traceProcessWarnings` {boolean}", "apiSymbol": "traceProcessWarnings", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54568,7 +58453,7 @@ "label": "version", "signature": "`version` Type: {string}", "apiSymbol": "version", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54588,7 +58473,7 @@ "label": "versions", "signature": "`versions` Type: {Object}", "apiSymbol": "versions", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/process.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/process.html", "nodeStability": null, "priority": "normal", "tiers": { @@ -54610,7 +58495,7 @@ "label": "punycode.decode(string)", "signature": "`punycode.decode(string)`", "apiSymbol": "punycode.decode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/punycode.html#punycodedecodestring", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/punycode.html#punycodedecodestring", "nodeStability": { "index": "0", "level": 0, @@ -54635,7 +58520,7 @@ "label": "punycode.encode(string)", "signature": "`punycode.encode(string)`", "apiSymbol": "punycode.encode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/punycode.html#punycodeencodestring", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/punycode.html#punycodeencodestring", "nodeStability": { "index": "0", "level": 0, @@ -54660,7 +58545,7 @@ "label": "punycode.toASCII(domain)", "signature": "`punycode.toASCII(domain)`", "apiSymbol": "punycode.toASCII", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/punycode.html#punycodetoasciidomain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/punycode.html#punycodetoasciidomain", "nodeStability": { "index": "0", "level": 0, @@ -54685,7 +58570,7 @@ "label": "punycode.toUnicode(domain)", "signature": "`punycode.toUnicode(domain)`", "apiSymbol": "punycode.toUnicode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/punycode.html#punycodetounicodedomain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/punycode.html#punycodetounicodedomain", "nodeStability": { "index": "0", "level": 0, @@ -54710,7 +58595,7 @@ "label": "punycode.ucs2", "signature": "`punycode.ucs2`", "apiSymbol": "punycode.ucs2", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/punycode.html#punycodeucs2", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/punycode.html#punycodeucs2", "nodeStability": { "index": "0", "level": 0, @@ -54735,7 +58620,7 @@ "label": "punycode.ucs2.decode(string)", "signature": "`punycode.ucs2.decode(string)`", "apiSymbol": "punycode.ucs2.decode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/punycode.html#punycodeucs2decodestring", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/punycode.html#punycodeucs2decodestring", "nodeStability": { "index": "0", "level": 0, @@ -54760,7 +58645,7 @@ "label": "punycode.ucs2.encode(codePoints)", "signature": "`punycode.ucs2.encode(codePoints)`", "apiSymbol": "punycode.ucs2.encode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/punycode.html#punycodeucs2encodecodepoints", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/punycode.html#punycodeucs2encodecodepoints", "nodeStability": { "index": "0", "level": 0, @@ -54785,7 +58670,7 @@ "label": "version", "signature": "`version` Type: {string}", "apiSymbol": "version", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/punycode.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/punycode.html", "nodeStability": { "index": "0", "level": 0, @@ -54810,7 +58695,7 @@ "label": "querystring.decode()", "signature": "`querystring.decode()`", "apiSymbol": "querystring.decode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/querystring.html#querystringdecode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/querystring.html#querystringdecode", "nodeStability": { "index": "2", "level": 2, @@ -54838,7 +58723,7 @@ "label": "querystring.encode()", "signature": "`querystring.encode()`", "apiSymbol": "querystring.encode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/querystring.html#querystringencode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/querystring.html#querystringencode", "nodeStability": { "index": "2", "level": 2, @@ -54866,7 +58751,7 @@ "label": "querystring.escape(str)", "signature": "`querystring.escape(str)`", "apiSymbol": "querystring.escape", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/querystring.html#querystringescapestr", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/querystring.html#querystringescapestr", "nodeStability": { "index": "2", "level": 2, @@ -54894,7 +58779,7 @@ "label": "querystring.parse(str[, sep[, eq[, options]]])", "signature": "`querystring.parse(str[, sep[, eq[, options]]])`", "apiSymbol": "querystring.parse", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/querystring.html#querystringparsestr-sep-eq-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/querystring.html#querystringparsestr-sep-eq-options", "nodeStability": { "index": "2", "level": 2, @@ -54922,7 +58807,7 @@ "label": "querystring.stringify(obj[, sep[, eq[, options]]])", "signature": "`querystring.stringify(obj[, sep[, eq[, options]]])`", "apiSymbol": "querystring.stringify", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/querystring.html#querystringstringifyobj-sep-eq-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/querystring.html#querystringstringifyobj-sep-eq-options", "nodeStability": { "index": "2", "level": 2, @@ -54950,7 +58835,7 @@ "label": "querystring.unescape(str)", "signature": "`querystring.unescape(str)`", "apiSymbol": "querystring.unescape", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/querystring.html#querystringunescapestr", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/querystring.html#querystringunescapestr", "nodeStability": { "index": "2", "level": 2, @@ -54978,7 +58863,7 @@ "label": "readlinePromises.Interface", "signature": "Class: `readlinePromises.Interface`", "apiSymbol": "readlinePromises.Interface", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#class-readlinepromisesinterface", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#class-readlinepromisesinterface", "nodeStability": { "index": "2", "level": 2, @@ -55008,7 +58893,7 @@ "label": "rl.question(query[, options])", "signature": "`rl.question(query[, options])`", "apiSymbol": "rl.question", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlquestionquery-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlquestionquery-options", "nodeStability": { "index": "2", "level": 2, @@ -55038,7 +58923,7 @@ "label": "readlinePromises.Readline", "signature": "Class: `readlinePromises.Readline`", "apiSymbol": "readlinePromises.Readline", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#class-readlinepromisesreadline", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#class-readlinepromisesreadline", "nodeStability": { "index": "2", "level": 2, @@ -55063,7 +58948,7 @@ "label": "rl.clearLine(dir)", "signature": "`rl.clearLine(dir)`", "apiSymbol": "rl.clearLine", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlclearlinedir", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlclearlinedir", "nodeStability": { "index": "2", "level": 2, @@ -55088,7 +58973,7 @@ "label": "rl.clearScreenDown()", "signature": "`rl.clearScreenDown()`", "apiSymbol": "rl.clearScreenDown", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlclearscreendown", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlclearscreendown", "nodeStability": { "index": "2", "level": 2, @@ -55113,7 +58998,7 @@ "label": "rl.commit()", "signature": "`rl.commit()`", "apiSymbol": "rl.commit", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlcommit", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlcommit", "nodeStability": { "index": "2", "level": 2, @@ -55138,7 +59023,7 @@ "label": "rl.cursorTo(x[, y])", "signature": "`rl.cursorTo(x[, y])`", "apiSymbol": "rl.cursorTo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlcursortox-y", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlcursortox-y", "nodeStability": { "index": "2", "level": 2, @@ -55163,7 +59048,7 @@ "label": "rl.moveCursor(dx, dy)", "signature": "`rl.moveCursor(dx, dy)`", "apiSymbol": "rl.moveCursor", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlmovecursordx-dy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlmovecursordx-dy", "nodeStability": { "index": "2", "level": 2, @@ -55188,7 +59073,7 @@ "label": "rl.rollback()", "signature": "`rl.rollback()`", "apiSymbol": "rl.rollback", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlrollback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlrollback", "nodeStability": { "index": "2", "level": 2, @@ -55213,7 +59098,7 @@ "label": "readlinePromises.createInterface(options)", "signature": "`readlinePromises.createInterface(options)`", "apiSymbol": "readlinePromises.createInterface", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#readlinepromisescreateinterfaceoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#readlinepromisescreateinterfaceoptions", "nodeStability": { "index": "2", "level": 2, @@ -55243,7 +59128,7 @@ "label": "Use of the completer function", "signature": "Use of the `completer` function", "apiSymbol": "completer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#use-of-the-completer-function", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#use-of-the-completer-function", "nodeStability": { "index": "2", "level": 2, @@ -55268,7 +59153,7 @@ "label": "readline.Interface", "signature": "Class: `readline.Interface`", "apiSymbol": "readline.Interface", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#class-readlineinterface", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#class-readlineinterface", "nodeStability": { "index": "2", "level": 2, @@ -55298,7 +59183,7 @@ "label": "rl.question(query[, options], callback)", "signature": "`rl.question(query[, options], callback)`", "apiSymbol": "rl.question", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlquestionquery-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlquestionquery-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -55328,7 +59213,7 @@ "label": "readline.clearLine(stream, dir[, callback])", "signature": "`readline.clearLine(stream, dir[, callback])`", "apiSymbol": "readline.clearLine", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#readlineclearlinestream-dir-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#readlineclearlinestream-dir-callback", "nodeStability": { "index": "2", "level": 2, @@ -55353,7 +59238,7 @@ "label": "readline.clearScreenDown(stream[, callback])", "signature": "`readline.clearScreenDown(stream[, callback])`", "apiSymbol": "readline.clearScreenDown", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#readlineclearscreendownstream-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#readlineclearscreendownstream-callback", "nodeStability": { "index": "2", "level": 2, @@ -55378,7 +59263,7 @@ "label": "readline.createInterface(options)", "signature": "`readline.createInterface(options)`", "apiSymbol": "readline.createInterface", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#readlinecreateinterfaceoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#readlinecreateinterfaceoptions", "nodeStability": { "index": "2", "level": 2, @@ -55405,7 +59290,7 @@ "label": "Use of the completer function", "signature": "Use of the `completer` function", "apiSymbol": "completer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#use-of-the-completer-function_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#use-of-the-completer-function_1", "nodeStability": { "index": "2", "level": 2, @@ -55430,7 +59315,7 @@ "label": "readline.cursorTo(stream, x[, y][, callback])", "signature": "`readline.cursorTo(stream, x[, y][, callback])`", "apiSymbol": "readline.cursorTo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#readlinecursortostream-x-y-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#readlinecursortostream-x-y-callback", "nodeStability": { "index": "2", "level": 2, @@ -55455,7 +59340,7 @@ "label": "readline.moveCursor(stream, dx, dy[, callback])", "signature": "`readline.moveCursor(stream, dx, dy[, callback])`", "apiSymbol": "readline.moveCursor", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#readlinemovecursorstream-dx-dy-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#readlinemovecursorstream-dx-dy-callback", "nodeStability": { "index": "2", "level": 2, @@ -55480,7 +59365,7 @@ "label": "InterfaceConstructor", "signature": "Class: `InterfaceConstructor`", "apiSymbol": "InterfaceConstructor", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#class-interfaceconstructor", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#class-interfaceconstructor", "nodeStability": { "index": "2", "level": 2, @@ -55505,7 +59390,7 @@ "label": "rl.close()", "signature": "`rl.close()`", "apiSymbol": "rl.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlclose", "nodeStability": { "index": "2", "level": 2, @@ -55532,7 +59417,7 @@ "label": "rl[Symbol.dispose]()", "signature": "`rl[Symbol.dispose]()`", "apiSymbol": "rl", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlsymboldispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlsymboldispose", "nodeStability": { "index": "2", "level": 2, @@ -55562,7 +59447,7 @@ "label": "rl.pause()", "signature": "`rl.pause()`", "apiSymbol": "rl.pause", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlpause", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlpause", "nodeStability": { "index": "2", "level": 2, @@ -55592,7 +59477,7 @@ "label": "rl.prompt([preserveCursor])", "signature": "`rl.prompt([preserveCursor])`", "apiSymbol": "rl.prompt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlpromptpreservecursor", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlpromptpreservecursor", "nodeStability": { "index": "2", "level": 2, @@ -55622,7 +59507,7 @@ "label": "rl.resume()", "signature": "`rl.resume()`", "apiSymbol": "rl.resume", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlresume", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlresume", "nodeStability": { "index": "2", "level": 2, @@ -55652,7 +59537,7 @@ "label": "rl.setPrompt(prompt)", "signature": "`rl.setPrompt(prompt)`", "apiSymbol": "rl.setPrompt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlsetpromptprompt", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlsetpromptprompt", "nodeStability": { "index": "2", "level": 2, @@ -55682,7 +59567,7 @@ "label": "rl.getPrompt()", "signature": "`rl.getPrompt()`", "apiSymbol": "rl.getPrompt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlgetprompt", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlgetprompt", "nodeStability": { "index": "2", "level": 2, @@ -55712,7 +59597,7 @@ "label": "rl.write(data[, key])", "signature": "`rl.write(data[, key])`", "apiSymbol": "rl.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlwritedata-key", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlwritedata-key", "nodeStability": { "index": "2", "level": 2, @@ -55742,7 +59627,7 @@ "label": "rl[Symbol.asyncIterator]()", "signature": "`rl[Symbol.asyncIterator]()`", "apiSymbol": "rl", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlsymbolasynciterator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlsymbolasynciterator", "nodeStability": { "index": "2", "level": 2, @@ -55772,7 +59657,7 @@ "label": "rl.getCursorPos()", "signature": "`rl.getCursorPos()`", "apiSymbol": "rl.getCursorPos", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#rlgetcursorpos", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#rlgetcursorpos", "nodeStability": { "index": "2", "level": 2, @@ -55797,7 +59682,7 @@ "label": "line", "signature": "`line` Type: {string}", "apiSymbol": "line", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#class-interfaceconstructor", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#class-interfaceconstructor", "nodeStability": { "index": "2", "level": 2, @@ -55822,7 +59707,7 @@ "label": "cursor", "signature": "`cursor` Type: {number|undefined}", "apiSymbol": "cursor", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#class-interfaceconstructor", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#class-interfaceconstructor", "nodeStability": { "index": "2", "level": 2, @@ -55847,7 +59732,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#event-close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#event-close", "nodeStability": { "index": "2", "level": 2, @@ -55877,7 +59762,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#event-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#event-error", "nodeStability": { "index": "2", "level": 2, @@ -55907,7 +59792,7 @@ "label": "'line'", "signature": "Event: `'line'`", "apiSymbol": "'line'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#event-line", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#event-line", "nodeStability": { "index": "2", "level": 2, @@ -55937,7 +59822,7 @@ "label": "'history'", "signature": "Event: `'history'`", "apiSymbol": "'history'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#event-history", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#event-history", "nodeStability": { "index": "2", "level": 2, @@ -55962,7 +59847,7 @@ "label": "'pause'", "signature": "Event: `'pause'`", "apiSymbol": "'pause'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#event-pause", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#event-pause", "nodeStability": { "index": "2", "level": 2, @@ -55992,7 +59877,7 @@ "label": "'resume'", "signature": "Event: `'resume'`", "apiSymbol": "'resume'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#event-resume", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#event-resume", "nodeStability": { "index": "2", "level": 2, @@ -56022,7 +59907,7 @@ "label": "'SIGCONT'", "signature": "Event: `'SIGCONT'`", "apiSymbol": "'SIGCONT'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#event-sigcont", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#event-sigcont", "nodeStability": { "index": "2", "level": 2, @@ -56047,7 +59932,7 @@ "label": "'SIGINT'", "signature": "Event: `'SIGINT'`", "apiSymbol": "'SIGINT'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#event-sigint", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#event-sigint", "nodeStability": { "index": "2", "level": 2, @@ -56072,7 +59957,7 @@ "label": "'SIGTSTP'", "signature": "Event: `'SIGTSTP'`", "apiSymbol": "'SIGTSTP'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#event-sigtstp", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#event-sigtstp", "nodeStability": { "index": "2", "level": 2, @@ -56097,7 +59982,7 @@ "label": "readline.emitKeypressEvents(stream[, interface])", "signature": "`readline.emitKeypressEvents(stream[, interface])`", "apiSymbol": "readline.emitKeypressEvents", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/readline.html#readlineemitkeypresseventsstream-interface", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/readline.html#readlineemitkeypresseventsstream-interface", "nodeStability": { "index": "2", "level": 2, @@ -56122,7 +60007,7 @@ "label": "Assignment of the _ (underscore) variable", "signature": "Assignment of the `_` (underscore) variable", "apiSymbol": "_", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html#assignment-of-the-_-underscore-variable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html#assignment-of-the-_-underscore-variable", "nodeStability": { "index": "2", "level": 2, @@ -56147,7 +60032,7 @@ "label": "await", "signature": "`await` keyword", "apiSymbol": "await", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html#await-keyword", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html#await-keyword", "nodeStability": { "index": "2", "level": 2, @@ -56172,7 +60057,7 @@ "label": "Full-featured \"terminal\" REPL over net.Server and net.Socket", "signature": "Full-featured \"terminal\" REPL over `net.Server` and `net.Socket`", "apiSymbol": "net.Server", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html#full-featured-terminal-repl-over-netserver-and-netsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html#full-featured-terminal-repl-over-netserver-and-netsocket", "nodeStability": { "index": "2", "level": 2, @@ -56197,7 +60082,7 @@ "label": "REPL over curl", "signature": "REPL over `curl`", "apiSymbol": "curl", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html#repl-over-curl", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html#repl-over-curl", "nodeStability": { "index": "2", "level": 2, @@ -56222,7 +60107,7 @@ "label": "REPLServer", "signature": "Class: `REPLServer`", "apiSymbol": "REPLServer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html#class-replserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html#class-replserver", "nodeStability": { "index": "2", "level": 2, @@ -56247,7 +60132,7 @@ "label": "replServer.defineCommand(keyword, cmd)", "signature": "`replServer.defineCommand(keyword, cmd)`", "apiSymbol": "replServer.defineCommand", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html#replserverdefinecommandkeyword-cmd", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html#replserverdefinecommandkeyword-cmd", "nodeStability": { "index": "2", "level": 2, @@ -56272,7 +60157,7 @@ "label": "replServer.displayPrompt([preserveCursor])", "signature": "`replServer.displayPrompt([preserveCursor])`", "apiSymbol": "replServer.displayPrompt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html#replserverdisplaypromptpreservecursor", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html#replserverdisplaypromptpreservecursor", "nodeStability": { "index": "2", "level": 2, @@ -56297,7 +60182,7 @@ "label": "replServer.clearBufferedCommand()", "signature": "`replServer.clearBufferedCommand()`", "apiSymbol": "replServer.clearBufferedCommand", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html#replserverclearbufferedcommand", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html#replserverclearbufferedcommand", "nodeStability": { "index": "2", "level": 2, @@ -56322,7 +60207,7 @@ "label": "replServer.setupHistory(historyConfig, callback)", "signature": "`replServer.setupHistory(historyConfig, callback)`", "apiSymbol": "replServer.setupHistory", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html#replserversetuphistoryhistoryconfig-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html#replserversetuphistoryhistoryconfig-callback", "nodeStability": { "index": "2", "level": 2, @@ -56347,7 +60232,7 @@ "label": "'exit'", "signature": "Event: `'exit'`", "apiSymbol": "'exit'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html#event-exit", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html#event-exit", "nodeStability": { "index": "2", "level": 2, @@ -56372,7 +60257,7 @@ "label": "'reset'", "signature": "Event: `'reset'`", "apiSymbol": "'reset'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html#event-reset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html#event-reset", "nodeStability": { "index": "2", "level": 2, @@ -56397,7 +60282,7 @@ "label": "repl.start([options])", "signature": "`repl.start([options])`", "apiSymbol": "repl.start", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html#replstartoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html#replstartoptions", "nodeStability": { "index": "2", "level": 2, @@ -56422,7 +60307,7 @@ "label": "builtinModules", "signature": "`builtinModules` Type: {string\\[]}", "apiSymbol": "builtinModules", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/repl.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/repl.html", "nodeStability": { "index": "0", "level": 0, @@ -56447,7 +60332,7 @@ "label": "DatabaseSync", "signature": "Class: `DatabaseSync`", "apiSymbol": "DatabaseSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#class-databasesync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#class-databasesync", "nodeStability": { "index": "1.2", "level": 1, @@ -56472,7 +60357,7 @@ "label": "database.aggregate(name, options)", "signature": "`database.aggregate(name, options)`", "apiSymbol": "database.aggregate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databaseaggregatename-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databaseaggregatename-options", "nodeStability": { "index": "1.2", "level": 1, @@ -56497,7 +60382,7 @@ "label": "database.close()", "signature": "`database.close()`", "apiSymbol": "database.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databaseclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databaseclose", "nodeStability": { "index": "1.2", "level": 1, @@ -56517,12 +60402,12 @@ } }, { - "id": "sqlite:bea9dd7076f9", + "id": "sqlite:e96387cf8afc", "chapter": "sqlite", - "label": "database.loadExtension(path)", - "signature": "`database.loadExtension(path)`", + "label": "database.loadExtension(path[, entryPoint])", + "signature": "`database.loadExtension(path[, entryPoint])`", "apiSymbol": "database.loadExtension", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databaseloadextensionpath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databaseloadextensionpath-entrypoint", "nodeStability": { "index": "1.2", "level": 1, @@ -56547,7 +60432,7 @@ "label": "database.enableLoadExtension(allow)", "signature": "`database.enableLoadExtension(allow)`", "apiSymbol": "database.enableLoadExtension", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databaseenableloadextensionallow", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databaseenableloadextensionallow", "nodeStability": { "index": "1.2", "level": 1, @@ -56572,7 +60457,7 @@ "label": "database.enableDefensive(active)", "signature": "`database.enableDefensive(active)`", "apiSymbol": "database.enableDefensive", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databaseenabledefensiveactive", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databaseenabledefensiveactive", "nodeStability": { "index": "1.2", "level": 1, @@ -56597,7 +60482,7 @@ "label": "database.location([dbName])", "signature": "`database.location([dbName])`", "apiSymbol": "database.location", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databaselocationdbname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databaselocationdbname", "nodeStability": { "index": "1.2", "level": 1, @@ -56622,7 +60507,7 @@ "label": "database.exec(sql)", "signature": "`database.exec(sql)`", "apiSymbol": "database.exec", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databaseexecsql", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databaseexecsql", "nodeStability": { "index": "1.2", "level": 1, @@ -56647,7 +60532,7 @@ "label": "database.function(name[, options], fn)", "signature": "`database.function(name[, options], fn)`", "apiSymbol": "database.function", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databasefunctionname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databasefunctionname-options-fn", "nodeStability": { "index": "1.2", "level": 1, @@ -56672,7 +60557,7 @@ "label": "database.setAuthorizer(callback)", "signature": "`database.setAuthorizer(callback)`", "apiSymbol": "database.setAuthorizer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databasesetauthorizercallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databasesetauthorizercallback", "nodeStability": { "index": "1.2", "level": 1, @@ -56697,7 +60582,57 @@ "label": "database.open()", "signature": "`database.open()`", "apiSymbol": "database.open", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databaseopen", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databaseopen", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "implement", + "verification": "declared-gap", + "confidence": "medium", + "source": "compiler-chapter-policy:sqlite", + "tests": [] + } + } + }, + { + "id": "sqlite:1369c16ccdef", + "chapter": "sqlite", + "label": "database.serialize([dbName])", + "signature": "`database.serialize([dbName])`", + "apiSymbol": "database.serialize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databaseserializedbname", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "implement", + "verification": "declared-gap", + "confidence": "medium", + "source": "compiler-chapter-policy:sqlite", + "tests": [] + } + } + }, + { + "id": "sqlite:eca22e258945", + "chapter": "sqlite", + "label": "database.deserialize(buffer[, options])", + "signature": "`database.deserialize(buffer[, options])`", + "apiSymbol": "database.deserialize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databasedeserializebuffer-options", "nodeStability": { "index": "1.2", "level": 1, @@ -56722,7 +60657,7 @@ "label": "database.prepare(sql[, options])", "signature": "`database.prepare(sql[, options])`", "apiSymbol": "database.prepare", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databasepreparesql-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databasepreparesql-options", "nodeStability": { "index": "1.2", "level": 1, @@ -56747,7 +60682,7 @@ "label": "database.createTagStore([maxSize])", "signature": "`database.createTagStore([maxSize])`", "apiSymbol": "database.createTagStore", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databasecreatetagstoremaxsize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databasecreatetagstoremaxsize", "nodeStability": { "index": "1.2", "level": 1, @@ -56772,7 +60707,7 @@ "label": "database.createSession([options])", "signature": "`database.createSession([options])`", "apiSymbol": "database.createSession", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databasecreatesessionoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databasecreatesessionoptions", "nodeStability": { "index": "1.2", "level": 1, @@ -56797,7 +60732,7 @@ "label": "database.applyChangeset(changeset[, options])", "signature": "`database.applyChangeset(changeset[, options])`", "apiSymbol": "database.applyChangeset", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databaseapplychangesetchangeset-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databaseapplychangesetchangeset-options", "nodeStability": { "index": "1.2", "level": 1, @@ -56822,7 +60757,7 @@ "label": "database[Symbol.dispose]()", "signature": "`database[Symbol.dispose]()`", "apiSymbol": "database", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#databasesymboldispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#databasesymboldispose", "nodeStability": { "index": "1.2", "level": 1, @@ -56847,7 +60782,7 @@ "label": "isOpen", "signature": "`isOpen` Type: {boolean} Whether the database is currently open or not.", "apiSymbol": "isOpen", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#class-databasesync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#class-databasesync", "nodeStability": { "index": "1.2", "level": 1, @@ -56872,7 +60807,7 @@ "label": "isTransaction", "signature": "`isTransaction` Type: {boolean} Whether the database is currently within a transaction. This method is a wrapper around [`sqlite3_get_autocommit()`][].", "apiSymbol": "isTransaction", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#class-databasesync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#class-databasesync", "nodeStability": { "index": "1.2", "level": 1, @@ -56897,7 +60832,7 @@ "label": "limits", "signature": "`limits` Type: {Object}", "apiSymbol": "limits", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#class-databasesync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#class-databasesync", "nodeStability": { "index": "1.2", "level": 1, @@ -56922,7 +60857,7 @@ "label": "Session", "signature": "Class: `Session`", "apiSymbol": "Session", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#class-session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#class-session", "nodeStability": { "index": "1.2", "level": 1, @@ -56947,7 +60882,7 @@ "label": "session.changeset()", "signature": "`session.changeset()`", "apiSymbol": "session.changeset", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#sessionchangeset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#sessionchangeset", "nodeStability": { "index": "1.2", "level": 1, @@ -56972,7 +60907,7 @@ "label": "session.patchset()", "signature": "`session.patchset()`", "apiSymbol": "session.patchset", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#sessionpatchset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#sessionpatchset", "nodeStability": { "index": "1.2", "level": 1, @@ -56997,7 +60932,7 @@ "label": "session.close()", "signature": "`session.close()`", "apiSymbol": "session.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#sessionclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#sessionclose", "nodeStability": { "index": "1.2", "level": 1, @@ -57022,7 +60957,7 @@ "label": "session[Symbol.dispose]()", "signature": "`session[Symbol.dispose]()`", "apiSymbol": "session", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#sessionsymboldispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#sessionsymboldispose", "nodeStability": { "index": "1.2", "level": 1, @@ -57047,7 +60982,7 @@ "label": "StatementSync", "signature": "Class: `StatementSync`", "apiSymbol": "StatementSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#class-statementsync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#class-statementsync", "nodeStability": { "index": "1.2", "level": 1, @@ -57072,7 +61007,32 @@ "label": "statement.all([namedParameters][, ...anonymousParameters])", "signature": "`statement.all([namedParameters][, ...anonymousParameters])`", "apiSymbol": "statement.all", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#statementallnamedparameters-anonymousparameters", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#statementallnamedparameters-anonymousparameters", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "implement", + "verification": "declared-gap", + "confidence": "medium", + "source": "compiler-chapter-policy:sqlite", + "tests": [] + } + } + }, + { + "id": "sqlite:bbac258c4b2c", + "chapter": "sqlite", + "label": "statement.close()", + "signature": "`statement.close()`", + "apiSymbol": "statement.close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#statementclose", "nodeStability": { "index": "1.2", "level": 1, @@ -57097,7 +61057,7 @@ "label": "statement.columns()", "signature": "`statement.columns()`", "apiSymbol": "statement.columns", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#statementcolumns", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#statementcolumns", "nodeStability": { "index": "1.2", "level": 1, @@ -57122,7 +61082,7 @@ "label": "statement.get([namedParameters][, ...anonymousParameters])", "signature": "`statement.get([namedParameters][, ...anonymousParameters])`", "apiSymbol": "statement.get", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#statementgetnamedparameters-anonymousparameters", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#statementgetnamedparameters-anonymousparameters", "nodeStability": { "index": "1.2", "level": 1, @@ -57147,7 +61107,7 @@ "label": "statement.iterate([namedParameters][, ...anonymousParameters])", "signature": "`statement.iterate([namedParameters][, ...anonymousParameters])`", "apiSymbol": "statement.iterate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#statementiteratenamedparameters-anonymousparameters", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#statementiteratenamedparameters-anonymousparameters", "nodeStability": { "index": "1.2", "level": 1, @@ -57172,7 +61132,7 @@ "label": "statement.run([namedParameters][, ...anonymousParameters])", "signature": "`statement.run([namedParameters][, ...anonymousParameters])`", "apiSymbol": "statement.run", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#statementrunnamedparameters-anonymousparameters", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#statementrunnamedparameters-anonymousparameters", "nodeStability": { "index": "1.2", "level": 1, @@ -57197,7 +61157,7 @@ "label": "statement.setAllowBareNamedParameters(enabled)", "signature": "`statement.setAllowBareNamedParameters(enabled)`", "apiSymbol": "statement.setAllowBareNamedParameters", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#statementsetallowbarenamedparametersenabled", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#statementsetallowbarenamedparametersenabled", "nodeStability": { "index": "1.2", "level": 1, @@ -57222,7 +61182,7 @@ "label": "statement.setAllowUnknownNamedParameters(enabled)", "signature": "`statement.setAllowUnknownNamedParameters(enabled)`", "apiSymbol": "statement.setAllowUnknownNamedParameters", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#statementsetallowunknownnamedparametersenabled", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#statementsetallowunknownnamedparametersenabled", "nodeStability": { "index": "1.2", "level": 1, @@ -57247,7 +61207,7 @@ "label": "statement.setReturnArrays(enabled)", "signature": "`statement.setReturnArrays(enabled)`", "apiSymbol": "statement.setReturnArrays", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#statementsetreturnarraysenabled", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#statementsetreturnarraysenabled", "nodeStability": { "index": "1.2", "level": 1, @@ -57272,7 +61232,32 @@ "label": "statement.setReadBigInts(enabled)", "signature": "`statement.setReadBigInts(enabled)`", "apiSymbol": "statement.setReadBigInts", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#statementsetreadbigintsenabled", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#statementsetreadbigintsenabled", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "priority": "normal", + "tiers": { + "static": { + "status": "not-implemented", + "action": "implement", + "verification": "declared-gap", + "confidence": "medium", + "source": "compiler-chapter-policy:sqlite", + "tests": [] + } + } + }, + { + "id": "sqlite:370aee8447bb", + "chapter": "sqlite", + "label": "statement[Symbol.dispose]()", + "signature": "`statement[Symbol.dispose]()`", + "apiSymbol": "statement", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#statementsymboldispose", "nodeStability": { "index": "1.2", "level": 1, @@ -57297,7 +61282,7 @@ "label": "expandedSQL", "signature": "`expandedSQL` Type: {string} The source SQL expanded to include parameter values.", "apiSymbol": "expandedSQL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#class-statementsync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#class-statementsync", "nodeStability": { "index": "1.2", "level": 1, @@ -57322,7 +61307,7 @@ "label": "sourceSQL", "signature": "`sourceSQL` Type: {string} The source SQL used to create this prepared statement.", "apiSymbol": "sourceSQL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#class-statementsync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#class-statementsync", "nodeStability": { "index": "1.2", "level": 1, @@ -57347,7 +61332,7 @@ "label": "SQLTagStore", "signature": "Class: `SQLTagStore`", "apiSymbol": "SQLTagStore", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#class-sqltagstore", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#class-sqltagstore", "nodeStability": { "index": "1.2", "level": 1, @@ -57372,7 +61357,7 @@ "label": "sqlTagStore.all(stringElements[, ...boundParameters])", "signature": "`sqlTagStore.all(stringElements[, ...boundParameters])`", "apiSymbol": "sqlTagStore.all", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#sqltagstoreallstringelements-boundparameters", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#sqltagstoreallstringelements-boundparameters", "nodeStability": { "index": "1.2", "level": 1, @@ -57397,7 +61382,7 @@ "label": "sqlTagStore.get(stringElements[, ...boundParameters])", "signature": "`sqlTagStore.get(stringElements[, ...boundParameters])`", "apiSymbol": "sqlTagStore.get", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#sqltagstoregetstringelements-boundparameters", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#sqltagstoregetstringelements-boundparameters", "nodeStability": { "index": "1.2", "level": 1, @@ -57422,7 +61407,7 @@ "label": "sqlTagStore.iterate(stringElements[, ...boundParameters])", "signature": "`sqlTagStore.iterate(stringElements[, ...boundParameters])`", "apiSymbol": "sqlTagStore.iterate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#sqltagstoreiteratestringelements-boundparameters", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#sqltagstoreiteratestringelements-boundparameters", "nodeStability": { "index": "1.2", "level": 1, @@ -57447,7 +61432,7 @@ "label": "sqlTagStore.run(stringElements[, ...boundParameters])", "signature": "`sqlTagStore.run(stringElements[, ...boundParameters])`", "apiSymbol": "sqlTagStore.run", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#sqltagstorerunstringelements-boundparameters", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#sqltagstorerunstringelements-boundparameters", "nodeStability": { "index": "1.2", "level": 1, @@ -57472,7 +61457,7 @@ "label": "sqlTagStore.clear()", "signature": "`sqlTagStore.clear()`", "apiSymbol": "sqlTagStore.clear", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#sqltagstoreclear", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#sqltagstoreclear", "nodeStability": { "index": "1.2", "level": 1, @@ -57497,7 +61482,7 @@ "label": "size", "signature": "`size` Type: {integer}", "apiSymbol": "size", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#class-sqltagstore", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#class-sqltagstore", "nodeStability": { "index": "1.2", "level": 1, @@ -57522,7 +61507,7 @@ "label": "capacity", "signature": "`capacity` Type: {integer}", "apiSymbol": "capacity", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#class-sqltagstore", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#class-sqltagstore", "nodeStability": { "index": "1.2", "level": 1, @@ -57547,7 +61532,7 @@ "label": "db", "signature": "`db` Type: {DatabaseSync}", "apiSymbol": "db", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#class-sqltagstore", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#class-sqltagstore", "nodeStability": { "index": "1.2", "level": 1, @@ -57572,7 +61557,7 @@ "label": "sqlite.backup(sourceDb, path[, options])", "signature": "`sqlite.backup(sourceDb, path[, options])`", "apiSymbol": "sqlite.backup", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html#sqlitebackupsourcedb-path-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html#sqlitebackupsourcedb-path-options", "nodeStability": { "index": "1.2", "level": 1, @@ -57597,7 +61582,7 @@ "label": "constants", "signature": "`constants` Type: {Object}", "apiSymbol": "constants", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/sqlite.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/sqlite.html", "nodeStability": { "index": "1.2", "level": 1, @@ -57622,7 +61607,7 @@ "label": "stream.pipeline(streams[, options])", "signature": "`stream.pipeline(streams[, options])`", "apiSymbol": "stream.pipeline", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streampipelinestreams-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streampipelinestreams-options", "nodeStability": { "index": "2", "level": 2, @@ -57653,7 +61638,7 @@ "label": "stream.pipeline(source[, ...transforms], destination[, options])", "signature": "`stream.pipeline(source[, ...transforms], destination[, options])`", "apiSymbol": "stream.pipeline", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streampipelinesource-transforms-destination-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streampipelinesource-transforms-destination-options", "nodeStability": { "index": "2", "level": 2, @@ -57684,7 +61669,7 @@ "label": "stream.finished(stream[, options])", "signature": "`stream.finished(stream[, options])`", "apiSymbol": "stream.finished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamfinishedstream-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamfinishedstream-options", "nodeStability": { "index": "2", "level": 2, @@ -57715,7 +61700,7 @@ "label": "stream.finished(stream[, options], callback)", "signature": "`stream.finished(stream[, options], callback)`", "apiSymbol": "stream.finished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamfinishedstream-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamfinishedstream-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -57746,7 +61731,7 @@ "label": "stream.pipeline(source[, ...transforms], destination, callback)", "signature": "`stream.pipeline(source[, ...transforms], destination, callback)`", "apiSymbol": "stream.pipeline", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streampipelinesource-transforms-destination-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streampipelinesource-transforms-destination-callback", "nodeStability": { "index": "2", "level": 2, @@ -57777,7 +61762,7 @@ "label": "stream.pipeline(streams, callback)", "signature": "`stream.pipeline(streams, callback)`", "apiSymbol": "stream.pipeline", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streampipelinestreams-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streampipelinestreams-callback", "nodeStability": { "index": "2", "level": 2, @@ -57808,14 +61793,39 @@ "label": "stream.compose(...streams)", "signature": "`stream.compose(...streams)`", "apiSymbol": "stream.compose", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamcomposestreams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamcomposestreams", "nodeStability": { - "index": "1", - "level": 1, - "text": "`stream.compose` is experimental.", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, - "priority": "low", + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream", + "tests": [] + } + } + }, + { + "id": "stream:8f50ba066613", + "chapter": "stream", + "label": "stream.isDestroyed(stream)", + "signature": "`stream.isDestroyed(stream)`", + "apiSymbol": "stream.isDestroyed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamisdestroyedstream", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", "tiers": { "static": { "status": "not-implemented", @@ -57833,7 +61843,7 @@ "label": "stream.isErrored(stream)", "signature": "`stream.isErrored(stream)`", "apiSymbol": "stream.isErrored", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamiserroredstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamiserroredstream", "nodeStability": { "index": "2", "level": 2, @@ -57858,7 +61868,7 @@ "label": "stream.isReadable(stream)", "signature": "`stream.isReadable(stream)`", "apiSymbol": "stream.isReadable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamisreadablestream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamisreadablestream", "nodeStability": { "index": "2", "level": 2, @@ -57883,7 +61893,7 @@ "label": "stream.isWritable(stream)", "signature": "`stream.isWritable(stream)`", "apiSymbol": "stream.isWritable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamiswritablestream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamiswritablestream", "nodeStability": { "index": "2", "level": 2, @@ -57908,7 +61918,7 @@ "label": "stream.Readable.from(iterable[, options])", "signature": "`stream.Readable.from(iterable[, options])`", "apiSymbol": "stream.Readable.from", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamreadablefromiterable-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamreadablefromiterable-options", "nodeStability": { "index": "2", "level": 2, @@ -57933,7 +61943,7 @@ "label": "stream.Readable.fromWeb(readableStream[, options])", "signature": "`stream.Readable.fromWeb(readableStream[, options])`", "apiSymbol": "stream.Readable.fromWeb", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamreadablefromwebreadablestream-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamreadablefromwebreadablestream-options", "nodeStability": { "index": "2", "level": 2, @@ -57958,7 +61968,7 @@ "label": "stream.Readable.isDisturbed(stream)", "signature": "`stream.Readable.isDisturbed(stream)`", "apiSymbol": "stream.Readable.isDisturbed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamreadableisdisturbedstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamreadableisdisturbedstream", "nodeStability": { "index": "2", "level": 2, @@ -57983,7 +61993,7 @@ "label": "stream.Readable.toWeb(streamReadable[, options])", "signature": "`stream.Readable.toWeb(streamReadable[, options])`", "apiSymbol": "stream.Readable.toWeb", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamreadabletowebstreamreadable-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamreadabletowebstreamreadable-options", "nodeStability": { "index": "2", "level": 2, @@ -58008,7 +62018,7 @@ "label": "stream.Writable.fromWeb(writableStream[, options])", "signature": "`stream.Writable.fromWeb(writableStream[, options])`", "apiSymbol": "stream.Writable.fromWeb", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamwritablefromwebwritablestream-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamwritablefromwebwritablestream-options", "nodeStability": { "index": "2", "level": 2, @@ -58033,7 +62043,7 @@ "label": "stream.Writable.toWeb(streamWritable)", "signature": "`stream.Writable.toWeb(streamWritable)`", "apiSymbol": "stream.Writable.toWeb", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamwritabletowebstreamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamwritabletowebstreamwritable", "nodeStability": { "index": "2", "level": 2, @@ -58058,7 +62068,7 @@ "label": "stream.Duplex.from(src)", "signature": "`stream.Duplex.from(src)`", "apiSymbol": "stream.Duplex.from", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamduplexfromsrc", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamduplexfromsrc", "nodeStability": { "index": "2", "level": 2, @@ -58083,7 +62093,7 @@ "label": "stream.Duplex.fromWeb(pair[, options])", "signature": "`stream.Duplex.fromWeb(pair[, options])`", "apiSymbol": "stream.Duplex.fromWeb", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamduplexfromwebpair-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamduplexfromwebpair-options", "nodeStability": { "index": "2", "level": 2, @@ -58108,7 +62118,7 @@ "label": "stream.Duplex.toWeb(streamDuplex[, options])", "signature": "`stream.Duplex.toWeb(streamDuplex[, options])`", "apiSymbol": "stream.Duplex.toWeb", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamduplextowebstreamduplex-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamduplextowebstreamduplex-options", "nodeStability": { "index": "2", "level": 2, @@ -58133,14 +62143,14 @@ "label": "stream.addAbortSignal(signal, stream)", "signature": "`stream.addAbortSignal(signal, stream)`", "apiSymbol": "stream.addAbortSignal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamaddabortsignalsignal-stream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamaddabortsignalsignal-stream", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "0", + "level": 0, + "text": "Deprecated. Using [`stream.addAbortSignal()`][] to destroy long-lived stream resources is documentation-only deprecated. See DEP0209.", + "inherited": false }, - "priority": "high", + "priority": "low", "tiers": { "static": { "status": "partial", @@ -58161,7 +62171,7 @@ "label": "stream.getDefaultHighWaterMark(objectMode)", "signature": "`stream.getDefaultHighWaterMark(objectMode)`", "apiSymbol": "stream.getDefaultHighWaterMark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamgetdefaulthighwatermarkobjectmode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamgetdefaulthighwatermarkobjectmode", "nodeStability": { "index": "2", "level": 2, @@ -58192,7 +62202,7 @@ "label": "stream.setDefaultHighWaterMark(objectMode, value)", "signature": "`stream.setDefaultHighWaterMark(objectMode, value)`", "apiSymbol": "stream.setDefaultHighWaterMark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamsetdefaulthighwatermarkobjectmode-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamsetdefaulthighwatermarkobjectmode-value", "nodeStability": { "index": "2", "level": 2, @@ -58217,7 +62227,7 @@ "label": "readable.read(0)", "signature": "`readable.read(0)`", "apiSymbol": "readable.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readableread0", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readableread0", "nodeStability": { "index": "2", "level": 2, @@ -58248,7 +62258,7 @@ "label": "readable.push('')", "signature": "`readable.push('')`", "apiSymbol": "readable.push", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablepush", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablepush", "nodeStability": { "index": "2", "level": 2, @@ -58279,7 +62289,7 @@ "label": "stream.finished(stream[, options], callback)", "signature": "`stream.finished(stream[, options], callback)`", "apiSymbol": "stream.finished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58310,7 +62320,7 @@ "label": "stream.pipeline(source[, ...transforms], destination, callback)", "signature": "`stream.pipeline(source[, ...transforms], destination, callback)`", "apiSymbol": "stream.pipeline", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58341,7 +62351,7 @@ "label": "stream.pipeline(streams, callback)", "signature": "`stream.pipeline(streams, callback)`", "apiSymbol": "stream.pipeline", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58372,14 +62382,39 @@ "label": "stream.compose(...streams)", "signature": "`stream.compose(...streams)`", "apiSymbol": "stream.compose", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { - "index": "1", - "level": 1, - "text": "`stream.compose` is experimental.", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, - "priority": "low", + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream", + "tests": [] + } + } + }, + { + "id": "stream:bce99dfc80e7", + "chapter": "stream", + "label": "stream.isDestroyed(stream)", + "signature": "`stream.isDestroyed(stream)`", + "apiSymbol": "stream.isDestroyed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", "tiers": { "static": { "status": "not-implemented", @@ -58397,7 +62432,7 @@ "label": "stream.isErrored(stream)", "signature": "`stream.isErrored(stream)`", "apiSymbol": "stream.isErrored", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58422,7 +62457,7 @@ "label": "stream.isReadable(stream)", "signature": "`stream.isReadable(stream)`", "apiSymbol": "stream.isReadable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58447,7 +62482,7 @@ "label": "stream.isWritable(stream)", "signature": "`stream.isWritable(stream)`", "apiSymbol": "stream.isWritable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58472,7 +62507,7 @@ "label": "stream.Readable.from(iterable[, options])", "signature": "`stream.Readable.from(iterable[, options])`", "apiSymbol": "stream.Readable.from", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58497,7 +62532,7 @@ "label": "stream.Readable.fromWeb(readableStream[, options])", "signature": "`stream.Readable.fromWeb(readableStream[, options])`", "apiSymbol": "stream.Readable.fromWeb", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58522,7 +62557,7 @@ "label": "stream.Readable.isDisturbed(stream)", "signature": "`stream.Readable.isDisturbed(stream)`", "apiSymbol": "stream.Readable.isDisturbed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58547,7 +62582,7 @@ "label": "stream.Readable.toWeb(streamReadable[, options])", "signature": "`stream.Readable.toWeb(streamReadable[, options])`", "apiSymbol": "stream.Readable.toWeb", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58572,7 +62607,7 @@ "label": "stream.Writable.fromWeb(writableStream[, options])", "signature": "`stream.Writable.fromWeb(writableStream[, options])`", "apiSymbol": "stream.Writable.fromWeb", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58597,7 +62632,7 @@ "label": "stream.Writable.toWeb(streamWritable)", "signature": "`stream.Writable.toWeb(streamWritable)`", "apiSymbol": "stream.Writable.toWeb", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58622,7 +62657,7 @@ "label": "stream.Duplex.from(src)", "signature": "`stream.Duplex.from(src)`", "apiSymbol": "stream.Duplex.from", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58647,7 +62682,7 @@ "label": "stream.Duplex.fromWeb(pair[, options])", "signature": "`stream.Duplex.fromWeb(pair[, options])`", "apiSymbol": "stream.Duplex.fromWeb", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58672,7 +62707,7 @@ "label": "stream.Duplex.toWeb(streamDuplex[, options])", "signature": "`stream.Duplex.toWeb(streamDuplex[, options])`", "apiSymbol": "stream.Duplex.toWeb", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58697,14 +62732,14 @@ "label": "stream.addAbortSignal(signal, stream)", "signature": "`stream.addAbortSignal(signal, stream)`", "apiSymbol": "stream.addAbortSignal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "0", + "level": 0, + "text": "Deprecated. Using [`stream.addAbortSignal()`][] to destroy long-lived stream resources is documentation-only deprecated. See DEP0209.", + "inherited": false }, - "priority": "high", + "priority": "low", "tiers": { "static": { "status": "partial", @@ -58725,7 +62760,7 @@ "label": "stream.getDefaultHighWaterMark(objectMode)", "signature": "`stream.getDefaultHighWaterMark(objectMode)`", "apiSymbol": "stream.getDefaultHighWaterMark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58756,7 +62791,7 @@ "label": "stream.setDefaultHighWaterMark(objectMode, value)", "signature": "`stream.setDefaultHighWaterMark(objectMode, value)`", "apiSymbol": "stream.setDefaultHighWaterMark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#api-for-stream-consumers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#api-for-stream-consumers", "nodeStability": { "index": "2", "level": 2, @@ -58781,7 +62816,7 @@ "label": "stream.Writable", "signature": "Class: `stream.Writable`", "apiSymbol": "stream.Writable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -58806,7 +62841,7 @@ "label": "writable.cork()", "signature": "`writable.cork()`", "apiSymbol": "writable.cork", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#writablecork", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#writablecork", "nodeStability": { "index": "2", "level": 2, @@ -58837,7 +62872,7 @@ "label": "writable.destroy([error])", "signature": "`writable.destroy([error])`", "apiSymbol": "writable.destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#writabledestroyerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#writabledestroyerror", "nodeStability": { "index": "2", "level": 2, @@ -58864,7 +62899,7 @@ "label": "writable.end([chunk[, encoding]][, callback])", "signature": "`writable.end([chunk[, encoding]][, callback])`", "apiSymbol": "writable.end", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#writableendchunk-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#writableendchunk-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -58895,7 +62930,7 @@ "label": "writable.setDefaultEncoding(encoding)", "signature": "`writable.setDefaultEncoding(encoding)`", "apiSymbol": "writable.setDefaultEncoding", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#writablesetdefaultencodingencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#writablesetdefaultencodingencoding", "nodeStability": { "index": "2", "level": 2, @@ -58926,7 +62961,7 @@ "label": "writable.uncork()", "signature": "`writable.uncork()`", "apiSymbol": "writable.uncork", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#writableuncork", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#writableuncork", "nodeStability": { "index": "2", "level": 2, @@ -58957,7 +62992,7 @@ "label": "writable[Symbol.asyncDispose]()", "signature": "`writable[Symbol.asyncDispose]()`", "apiSymbol": "writable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#writablesymbolasyncdispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#writablesymbolasyncdispose", "nodeStability": { "index": "2", "level": 2, @@ -58982,7 +63017,7 @@ "label": "writable.write(chunk[, encoding][, callback])", "signature": "`writable.write(chunk[, encoding][, callback])`", "apiSymbol": "writable.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#writablewritechunk-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#writablewritechunk-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -59013,7 +63048,7 @@ "label": "closed", "signature": "`closed` Type: {boolean}", "apiSymbol": "closed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -59038,7 +63073,7 @@ "label": "destroyed", "signature": "`destroyed` Type: {boolean}", "apiSymbol": "destroyed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -59063,7 +63098,7 @@ "label": "writable", "signature": "`writable` Type: {boolean}", "apiSymbol": "writable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -59091,7 +63126,7 @@ "label": "writableAborted", "signature": "`writableAborted` Type: {boolean}", "apiSymbol": "writableAborted", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -59116,7 +63151,7 @@ "label": "writableEnded", "signature": "`writableEnded` Type: {boolean}", "apiSymbol": "writableEnded", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -59141,7 +63176,7 @@ "label": "writableCorked", "signature": "`writableCorked` Type: {integer}", "apiSymbol": "writableCorked", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -59166,7 +63201,7 @@ "label": "errored", "signature": "`errored` Type: {Error}", "apiSymbol": "errored", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -59191,7 +63226,7 @@ "label": "writableFinished", "signature": "`writableFinished` Type: {boolean}", "apiSymbol": "writableFinished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -59216,7 +63251,7 @@ "label": "writableHighWaterMark", "signature": "`writableHighWaterMark` Type: {number}", "apiSymbol": "writableHighWaterMark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -59241,7 +63276,7 @@ "label": "writableLength", "signature": "`writableLength` Type: {number}", "apiSymbol": "writableLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -59266,7 +63301,7 @@ "label": "writableNeedDrain", "signature": "`writableNeedDrain` Type: {boolean}", "apiSymbol": "writableNeedDrain", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -59291,7 +63326,7 @@ "label": "writableObjectMode", "signature": "`writableObjectMode` Type: {boolean}", "apiSymbol": "writableObjectMode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamwritable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamwritable", "nodeStability": { "index": "2", "level": 2, @@ -59316,7 +63351,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-close", "nodeStability": { "index": "2", "level": 2, @@ -59341,7 +63376,7 @@ "label": "'drain'", "signature": "Event: `'drain'`", "apiSymbol": "'drain'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-drain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-drain", "nodeStability": { "index": "2", "level": 2, @@ -59368,7 +63403,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-error", "nodeStability": { "index": "2", "level": 2, @@ -59393,7 +63428,7 @@ "label": "'finish'", "signature": "Event: `'finish'`", "apiSymbol": "'finish'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-finish", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-finish", "nodeStability": { "index": "2", "level": 2, @@ -59418,7 +63453,7 @@ "label": "'pipe'", "signature": "Event: `'pipe'`", "apiSymbol": "'pipe'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-pipe", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-pipe", "nodeStability": { "index": "2", "level": 2, @@ -59443,7 +63478,7 @@ "label": "'unpipe'", "signature": "Event: `'unpipe'`", "apiSymbol": "'unpipe'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-unpipe", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-unpipe", "nodeStability": { "index": "2", "level": 2, @@ -59468,7 +63503,7 @@ "label": "stream.Readable", "signature": "Class: `stream.Readable`", "apiSymbol": "stream.Readable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -59487,13 +63522,38 @@ } } }, + { + "id": "stream:e149f8b1cd66", + "chapter": "stream", + "label": "readable[Symbol.for('Stream.toAsyncStreamable')]()", + "signature": "`readable[Symbol.for('Stream.toAsyncStreamable')]()`", + "apiSymbol": "readable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablesymbolforstreamtoasyncstreamable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:stream", + "tests": [] + } + } + }, { "id": "stream:fffb9a73545d", "chapter": "stream", "label": "readable.destroy([error])", "signature": "`readable.destroy([error])`", "apiSymbol": "readable.destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readabledestroyerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readabledestroyerror", "nodeStability": { "index": "2", "level": 2, @@ -59524,7 +63584,7 @@ "label": "readable.isPaused()", "signature": "`readable.isPaused()`", "apiSymbol": "readable.isPaused", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readableispaused", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readableispaused", "nodeStability": { "index": "2", "level": 2, @@ -59555,7 +63615,7 @@ "label": "readable.pause()", "signature": "`readable.pause()`", "apiSymbol": "readable.pause", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablepause", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablepause", "nodeStability": { "index": "2", "level": 2, @@ -59586,7 +63646,7 @@ "label": "readable.pipe(destination[, options])", "signature": "`readable.pipe(destination[, options])`", "apiSymbol": "readable.pipe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablepipedestination-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablepipedestination-options", "nodeStability": { "index": "2", "level": 2, @@ -59617,7 +63677,7 @@ "label": "readable.read([size])", "signature": "`readable.read([size])`", "apiSymbol": "readable.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablereadsize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablereadsize", "nodeStability": { "index": "2", "level": 2, @@ -59648,7 +63708,7 @@ "label": "readable.resume()", "signature": "`readable.resume()`", "apiSymbol": "readable.resume", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readableresume", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readableresume", "nodeStability": { "index": "2", "level": 2, @@ -59679,7 +63739,7 @@ "label": "readable.setEncoding(encoding)", "signature": "`readable.setEncoding(encoding)`", "apiSymbol": "readable.setEncoding", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablesetencodingencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablesetencodingencoding", "nodeStability": { "index": "2", "level": 2, @@ -59710,7 +63770,7 @@ "label": "readable.unpipe([destination])", "signature": "`readable.unpipe([destination])`", "apiSymbol": "readable.unpipe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readableunpipedestination", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readableunpipedestination", "nodeStability": { "index": "2", "level": 2, @@ -59741,7 +63801,7 @@ "label": "readable.unshift(chunk[, encoding])", "signature": "`readable.unshift(chunk[, encoding])`", "apiSymbol": "readable.unshift", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readableunshiftchunk-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readableunshiftchunk-encoding", "nodeStability": { "index": "2", "level": 2, @@ -59772,7 +63832,7 @@ "label": "readable.wrap(stream)", "signature": "`readable.wrap(stream)`", "apiSymbol": "readable.wrap", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablewrapstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablewrapstream", "nodeStability": { "index": "2", "level": 2, @@ -59797,7 +63857,7 @@ "label": "readable[Symbol.asyncIterator]()", "signature": "`readable[Symbol.asyncIterator]()`", "apiSymbol": "readable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablesymbolasynciterator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablesymbolasynciterator", "nodeStability": { "index": "2", "level": 2, @@ -59825,7 +63885,7 @@ "label": "readable[Symbol.asyncDispose]()", "signature": "`readable[Symbol.asyncDispose]()`", "apiSymbol": "readable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablesymbolasyncdispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablesymbolasyncdispose", "nodeStability": { "index": "2", "level": 2, @@ -59850,7 +63910,7 @@ "label": "readable.compose(stream[, options])", "signature": "`readable.compose(stream[, options])`", "apiSymbol": "readable.compose", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablecomposestream-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablecomposestream-options", "nodeStability": { "index": "2", "level": 2, @@ -59875,7 +63935,7 @@ "label": "readable.iterator([options])", "signature": "`readable.iterator([options])`", "apiSymbol": "readable.iterator", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readableiteratoroptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readableiteratoroptions", "nodeStability": { "index": "2", "level": 2, @@ -59903,7 +63963,7 @@ "label": "readable.map(fn[, options])", "signature": "`readable.map(fn[, options])`", "apiSymbol": "readable.map", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablemapfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablemapfn-options", "nodeStability": { "index": "1", "level": 1, @@ -59928,7 +63988,7 @@ "label": "readable.filter(fn[, options])", "signature": "`readable.filter(fn[, options])`", "apiSymbol": "readable.filter", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablefilterfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablefilterfn-options", "nodeStability": { "index": "1", "level": 1, @@ -59953,7 +64013,7 @@ "label": "readable.forEach(fn[, options])", "signature": "`readable.forEach(fn[, options])`", "apiSymbol": "readable.forEach", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readableforeachfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readableforeachfn-options", "nodeStability": { "index": "1", "level": 1, @@ -59978,7 +64038,7 @@ "label": "readable.toArray([options])", "signature": "`readable.toArray([options])`", "apiSymbol": "readable.toArray", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readabletoarrayoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readabletoarrayoptions", "nodeStability": { "index": "1", "level": 1, @@ -60003,7 +64063,7 @@ "label": "readable.some(fn[, options])", "signature": "`readable.some(fn[, options])`", "apiSymbol": "readable.some", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablesomefn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablesomefn-options", "nodeStability": { "index": "1", "level": 1, @@ -60028,7 +64088,7 @@ "label": "readable.find(fn[, options])", "signature": "`readable.find(fn[, options])`", "apiSymbol": "readable.find", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablefindfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablefindfn-options", "nodeStability": { "index": "1", "level": 1, @@ -60053,7 +64113,7 @@ "label": "readable.every(fn[, options])", "signature": "`readable.every(fn[, options])`", "apiSymbol": "readable.every", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readableeveryfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readableeveryfn-options", "nodeStability": { "index": "1", "level": 1, @@ -60078,7 +64138,7 @@ "label": "readable.flatMap(fn[, options])", "signature": "`readable.flatMap(fn[, options])`", "apiSymbol": "readable.flatMap", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readableflatmapfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readableflatmapfn-options", "nodeStability": { "index": "1", "level": 1, @@ -60103,7 +64163,7 @@ "label": "readable.drop(limit[, options])", "signature": "`readable.drop(limit[, options])`", "apiSymbol": "readable.drop", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readabledroplimit-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readabledroplimit-options", "nodeStability": { "index": "1", "level": 1, @@ -60128,7 +64188,7 @@ "label": "readable.take(limit[, options])", "signature": "`readable.take(limit[, options])`", "apiSymbol": "readable.take", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readabletakelimit-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readabletakelimit-options", "nodeStability": { "index": "1", "level": 1, @@ -60153,7 +64213,7 @@ "label": "readable.reduce(fn[, initial[, options]])", "signature": "`readable.reduce(fn[, initial[, options]])`", "apiSymbol": "readable.reduce", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablereducefn-initial-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablereducefn-initial-options", "nodeStability": { "index": "1", "level": 1, @@ -60178,7 +64238,7 @@ "label": "closed", "signature": "`closed` Type: {boolean}", "apiSymbol": "closed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -60203,7 +64263,7 @@ "label": "destroyed", "signature": "`destroyed` Type: {boolean}", "apiSymbol": "destroyed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -60228,7 +64288,7 @@ "label": "readable", "signature": "`readable` Type: {boolean}", "apiSymbol": "readable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -60253,7 +64313,7 @@ "label": "readableAborted", "signature": "`readableAborted` Type: {boolean}", "apiSymbol": "readableAborted", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -60278,7 +64338,7 @@ "label": "readableDidRead", "signature": "`readableDidRead` Type: {boolean}", "apiSymbol": "readableDidRead", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -60303,7 +64363,7 @@ "label": "readableEncoding", "signature": "`readableEncoding` Type: {null|string}", "apiSymbol": "readableEncoding", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -60328,7 +64388,7 @@ "label": "readableEnded", "signature": "`readableEnded` Type: {boolean}", "apiSymbol": "readableEnded", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -60353,7 +64413,7 @@ "label": "errored", "signature": "`errored` Type: {Error}", "apiSymbol": "errored", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -60378,7 +64438,7 @@ "label": "readableFlowing", "signature": "`readableFlowing` Type: {boolean}", "apiSymbol": "readableFlowing", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -60403,7 +64463,7 @@ "label": "readableHighWaterMark", "signature": "`readableHighWaterMark` Type: {number}", "apiSymbol": "readableHighWaterMark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -60428,7 +64488,7 @@ "label": "readableLength", "signature": "`readableLength` Type: {number}", "apiSymbol": "readableLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -60453,7 +64513,7 @@ "label": "readableObjectMode", "signature": "`readableObjectMode` Type: {boolean}", "apiSymbol": "readableObjectMode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamreadable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamreadable", "nodeStability": { "index": "2", "level": 2, @@ -60478,7 +64538,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-close_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-close_1", "nodeStability": { "index": "2", "level": 2, @@ -60503,7 +64563,7 @@ "label": "'data'", "signature": "Event: `'data'`", "apiSymbol": "'data'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-data", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-data", "nodeStability": { "index": "2", "level": 2, @@ -60528,7 +64588,7 @@ "label": "'end'", "signature": "Event: `'end'`", "apiSymbol": "'end'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-end", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-end", "nodeStability": { "index": "2", "level": 2, @@ -60553,7 +64613,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-error_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-error_1", "nodeStability": { "index": "2", "level": 2, @@ -60578,7 +64638,7 @@ "label": "'pause'", "signature": "Event: `'pause'`", "apiSymbol": "'pause'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-pause", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-pause", "nodeStability": { "index": "2", "level": 2, @@ -60603,7 +64663,7 @@ "label": "'readable'", "signature": "Event: `'readable'`", "apiSymbol": "'readable'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-readable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-readable", "nodeStability": { "index": "2", "level": 2, @@ -60628,7 +64688,7 @@ "label": "'resume'", "signature": "Event: `'resume'`", "apiSymbol": "'resume'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-resume", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-resume", "nodeStability": { "index": "2", "level": 2, @@ -60653,7 +64713,7 @@ "label": "stream.Duplex", "signature": "Class: `stream.Duplex`", "apiSymbol": "stream.Duplex", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamduplex", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamduplex", "nodeStability": { "index": "2", "level": 2, @@ -60678,7 +64738,7 @@ "label": "allowHalfOpen", "signature": "`allowHalfOpen` Type: {boolean}", "apiSymbol": "allowHalfOpen", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamduplex", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamduplex", "nodeStability": { "index": "2", "level": 2, @@ -60703,7 +64763,7 @@ "label": "stream.Transform", "signature": "Class: `stream.Transform`", "apiSymbol": "stream.Transform", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streamtransform", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streamtransform", "nodeStability": { "index": "2", "level": 2, @@ -60728,7 +64788,7 @@ "label": "transform.destroy([error])", "signature": "`transform.destroy([error])`", "apiSymbol": "transform.destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#transformdestroyerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#transformdestroyerror", "nodeStability": { "index": "2", "level": 2, @@ -60753,7 +64813,7 @@ "label": "stream.duplexPair([options])", "signature": "`stream.duplexPair([options])`", "apiSymbol": "stream.duplexPair", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#streamduplexpairoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#streamduplexpairoptions", "nodeStability": { "index": "2", "level": 2, @@ -60778,7 +64838,7 @@ "label": "writable._construct(callback)", "signature": "`writable._construct(callback)`", "apiSymbol": "writable._construct", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#writable_constructcallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#writable_constructcallback", "nodeStability": { "index": "2", "level": 2, @@ -60803,7 +64863,7 @@ "label": "writable._write(chunk, encoding, callback)", "signature": "`writable._write(chunk, encoding, callback)`", "apiSymbol": "writable._write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#writable_writechunk-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#writable_writechunk-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -60828,7 +64888,7 @@ "label": "writable._writev(chunks, callback)", "signature": "`writable._writev(chunks, callback)`", "apiSymbol": "writable._writev", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#writable_writevchunks-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#writable_writevchunks-callback", "nodeStability": { "index": "2", "level": 2, @@ -60853,7 +64913,7 @@ "label": "writable._destroy(err, callback)", "signature": "`writable._destroy(err, callback)`", "apiSymbol": "writable._destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#writable_destroyerr-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#writable_destroyerr-callback", "nodeStability": { "index": "2", "level": 2, @@ -60878,7 +64938,7 @@ "label": "writable._final(callback)", "signature": "`writable._final(callback)`", "apiSymbol": "writable._final", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#writable_finalcallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#writable_finalcallback", "nodeStability": { "index": "2", "level": 2, @@ -60903,7 +64963,7 @@ "label": "readable._construct(callback)", "signature": "`readable._construct(callback)`", "apiSymbol": "readable._construct", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readable_constructcallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readable_constructcallback", "nodeStability": { "index": "2", "level": 2, @@ -60928,7 +64988,7 @@ "label": "readable._read(size)", "signature": "`readable._read(size)`", "apiSymbol": "readable._read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readable_readsize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readable_readsize", "nodeStability": { "index": "2", "level": 2, @@ -60953,7 +65013,7 @@ "label": "readable._destroy(err, callback)", "signature": "`readable._destroy(err, callback)`", "apiSymbol": "readable._destroy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readable_destroyerr-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readable_destroyerr-callback", "nodeStability": { "index": "2", "level": 2, @@ -60978,7 +65038,7 @@ "label": "readable.push(chunk[, encoding])", "signature": "`readable.push(chunk[, encoding])`", "apiSymbol": "readable.push", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#readablepushchunk-encoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#readablepushchunk-encoding", "nodeStability": { "index": "2", "level": 2, @@ -61009,7 +65069,7 @@ "label": "stream.PassThrough", "signature": "Class: `stream.PassThrough`", "apiSymbol": "stream.PassThrough", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#class-streampassthrough", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#class-streampassthrough", "nodeStability": { "index": "2", "level": 2, @@ -61034,7 +65094,7 @@ "label": "transform._flush(callback)", "signature": "`transform._flush(callback)`", "apiSymbol": "transform._flush", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#transform_flushcallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#transform_flushcallback", "nodeStability": { "index": "2", "level": 2, @@ -61059,7 +65119,7 @@ "label": "transform._transform(chunk, encoding, callback)", "signature": "`transform._transform(chunk, encoding, callback)`", "apiSymbol": "transform._transform", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#transform_transformchunk-encoding-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#transform_transformchunk-encoding-callback", "nodeStability": { "index": "2", "level": 2, @@ -61084,7 +65144,7 @@ "label": "'end'", "signature": "Event: `'end'`", "apiSymbol": "'end'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-end_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-end_1", "nodeStability": { "index": "2", "level": 2, @@ -61109,7 +65169,7 @@ "label": "'finish'", "signature": "Event: `'finish'`", "apiSymbol": "'finish'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#event-finish_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#event-finish_1", "nodeStability": { "index": "2", "level": 2, @@ -61134,7 +65194,7 @@ "label": "readable.read(0)", "signature": "`readable.read(0)`", "apiSymbol": "readable.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#additional-notes", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#additional-notes", "nodeStability": { "index": "2", "level": 2, @@ -61165,7 +65225,7 @@ "label": "readable.push('')", "signature": "`readable.push('')`", "apiSymbol": "readable.push", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#additional-notes", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#additional-notes", "nodeStability": { "index": "2", "level": 2, @@ -61196,7 +65256,7 @@ "label": "highWaterMark", "signature": "`highWaterMark` discrepancy after calling `readable.setEncoding()`", "apiSymbol": "highWaterMark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/stream.html#highwatermark-discrepancy-after-calling-readablesetencoding", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/stream.html#highwatermark-discrepancy-after-calling-readablesetencoding", "nodeStability": { "index": "2", "level": 2, @@ -61221,7 +65281,7 @@ "label": "StringDecoder", "signature": "Class: `StringDecoder`", "apiSymbol": "StringDecoder", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/string_decoder.html#class-stringdecoder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/string_decoder.html#class-stringdecoder", "nodeStability": { "index": "2", "level": 2, @@ -61249,7 +65309,7 @@ "label": "stringDecoder.end([buffer])", "signature": "`stringDecoder.end([buffer])`", "apiSymbol": "stringDecoder.end", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/string_decoder.html#stringdecoderendbuffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/string_decoder.html#stringdecoderendbuffer", "nodeStability": { "index": "2", "level": 2, @@ -61277,7 +65337,7 @@ "label": "stringDecoder.write(buffer)", "signature": "`stringDecoder.write(buffer)`", "apiSymbol": "stringDecoder.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/string_decoder.html#stringdecoderwritebuffer", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/string_decoder.html#stringdecoderwritebuffer", "nodeStability": { "index": "2", "level": 2, @@ -61305,7 +65365,7 @@ "label": "describe()", "signature": "`describe()` and `it()` aliases", "apiSymbol": "describe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#describe-and-it-aliases", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#describe-and-it-aliases", "nodeStability": { "index": "2", "level": 2, @@ -61332,7 +65392,7 @@ "label": "only", "signature": "`only` tests", "apiSymbol": "only", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#only-tests", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#only-tests", "nodeStability": { "index": "2", "level": 2, @@ -61357,7 +65417,7 @@ "label": "assert", "signature": "`assert`", "apiSymbol": "assert", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#assert", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#assert", "nodeStability": { "index": "2", "level": 2, @@ -61388,7 +65448,7 @@ "label": "assert.register(name, fn)", "signature": "`assert.register(name, fn)`", "apiSymbol": "assert.register", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#assertregistername-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#assertregistername-fn", "nodeStability": { "index": "2", "level": 2, @@ -61413,7 +65473,7 @@ "label": "snapshot", "signature": "`snapshot`", "apiSymbol": "snapshot", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#snapshot", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#snapshot", "nodeStability": { "index": "2", "level": 2, @@ -61438,7 +65498,7 @@ "label": "snapshot.setDefaultSnapshotSerializers(serializers)", "signature": "`snapshot.setDefaultSnapshotSerializers(serializers)`", "apiSymbol": "snapshot.setDefaultSnapshotSerializers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#snapshotsetdefaultsnapshotserializersserializers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#snapshotsetdefaultsnapshotserializersserializers", "nodeStability": { "index": "2", "level": 2, @@ -61463,7 +65523,107 @@ "label": "snapshot.setResolveSnapshotPath(fn)", "signature": "`snapshot.setResolveSnapshotPath(fn)`", "apiSymbol": "snapshot.setResolveSnapshotPath", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#snapshotsetresolvesnapshotpathfn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#snapshotsetresolvesnapshotpathfn", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] + } + } + }, + { + "id": "test:f8e1a11bf73b", + "chapter": "test", + "label": "Channel: 'tracing:node.test:start'", + "signature": "Channel: `'tracing:node.test:start'`", + "apiSymbol": "'tracing:node.test:start'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#channel-tracingnodeteststart", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] + } + } + }, + { + "id": "test:20a82a92c5ee", + "chapter": "test", + "label": "Channel: 'tracing:node.test:end'", + "signature": "Channel: `'tracing:node.test:end'`", + "apiSymbol": "'tracing:node.test:end'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#channel-tracingnodetestend", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] + } + } + }, + { + "id": "test:1c3a160d93a5", + "chapter": "test", + "label": "Channel: 'tracing:node.test:error'", + "signature": "Channel: `'tracing:node.test:error'`", + "apiSymbol": "'tracing:node.test:error'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#channel-tracingnodetesterror", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] + } + } + }, + { + "id": "test:67c55a98f438", + "chapter": "test", + "label": "Context propagation with bindStore()", + "signature": "Context propagation with `bindStore()`", + "apiSymbol": "bindStore", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#context-propagation-with-bindstore", "nodeStability": { "index": "2", "level": 2, @@ -61488,7 +65648,7 @@ "label": "MockFunctionContext", "signature": "Class: `MockFunctionContext`", "apiSymbol": "MockFunctionContext", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-mockfunctioncontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-mockfunctioncontext", "nodeStability": { "index": "2", "level": 2, @@ -61513,7 +65673,7 @@ "label": "ctx.callCount()", "signature": "`ctx.callCount()`", "apiSymbol": "ctx.callCount", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#ctxcallcount", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#ctxcallcount", "nodeStability": { "index": "2", "level": 2, @@ -61538,7 +65698,7 @@ "label": "ctx.mockImplementation(implementation)", "signature": "`ctx.mockImplementation(implementation)`", "apiSymbol": "ctx.mockImplementation", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#ctxmockimplementationimplementation", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#ctxmockimplementationimplementation", "nodeStability": { "index": "2", "level": 2, @@ -61563,7 +65723,7 @@ "label": "ctx.mockImplementationOnce(implementation[, onCall])", "signature": "`ctx.mockImplementationOnce(implementation[, onCall])`", "apiSymbol": "ctx.mockImplementationOnce", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#ctxmockimplementationonceimplementation-oncall", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#ctxmockimplementationonceimplementation-oncall", "nodeStability": { "index": "2", "level": 2, @@ -61588,7 +65748,7 @@ "label": "ctx.resetCalls()", "signature": "`ctx.resetCalls()`", "apiSymbol": "ctx.resetCalls", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#ctxresetcalls", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#ctxresetcalls", "nodeStability": { "index": "2", "level": 2, @@ -61613,7 +65773,7 @@ "label": "ctx.restore()", "signature": "`ctx.restore()`", "apiSymbol": "ctx.restore", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#ctxrestore", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#ctxrestore", "nodeStability": { "index": "2", "level": 2, @@ -61638,7 +65798,7 @@ "label": "calls", "signature": "`calls` Type: {Array}", "apiSymbol": "calls", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-mockfunctioncontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-mockfunctioncontext", "nodeStability": { "index": "2", "level": 2, @@ -61663,7 +65823,7 @@ "label": "MockModuleContext", "signature": "Class: `MockModuleContext`", "apiSymbol": "MockModuleContext", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-mockmodulecontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-mockmodulecontext", "nodeStability": { "index": "1.0", "level": 1, @@ -61688,7 +65848,7 @@ "label": "ctx.restore()", "signature": "`ctx.restore()`", "apiSymbol": "ctx.restore", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#ctxrestore_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#ctxrestore_1", "nodeStability": { "index": "1.0", "level": 1, @@ -61713,7 +65873,7 @@ "label": "MockPropertyContext", "signature": "Class: `MockPropertyContext`", "apiSymbol": "MockPropertyContext", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-mockpropertycontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-mockpropertycontext", "nodeStability": { "index": "2", "level": 2, @@ -61738,7 +65898,7 @@ "label": "ctx.accessCount()", "signature": "`ctx.accessCount()`", "apiSymbol": "ctx.accessCount", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#ctxaccesscount", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#ctxaccesscount", "nodeStability": { "index": "2", "level": 2, @@ -61763,7 +65923,7 @@ "label": "ctx.mockImplementation(value)", "signature": "`ctx.mockImplementation(value)`", "apiSymbol": "ctx.mockImplementation", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#ctxmockimplementationvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#ctxmockimplementationvalue", "nodeStability": { "index": "2", "level": 2, @@ -61788,7 +65948,7 @@ "label": "ctx.mockImplementationOnce(value[, onAccess])", "signature": "`ctx.mockImplementationOnce(value[, onAccess])`", "apiSymbol": "ctx.mockImplementationOnce", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#ctxmockimplementationoncevalue-onaccess", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#ctxmockimplementationoncevalue-onaccess", "nodeStability": { "index": "2", "level": 2, @@ -61813,7 +65973,7 @@ "label": "ctx.resetAccesses()", "signature": "`ctx.resetAccesses()`", "apiSymbol": "ctx.resetAccesses", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#ctxresetaccesses", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#ctxresetaccesses", "nodeStability": { "index": "2", "level": 2, @@ -61838,7 +65998,7 @@ "label": "ctx.restore()", "signature": "`ctx.restore()`", "apiSymbol": "ctx.restore", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#ctxrestore_2", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#ctxrestore_2", "nodeStability": { "index": "2", "level": 2, @@ -61863,7 +66023,7 @@ "label": "accesses", "signature": "`accesses` Type: {Array}", "apiSymbol": "accesses", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-mockpropertycontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-mockpropertycontext", "nodeStability": { "index": "2", "level": 2, @@ -61888,7 +66048,7 @@ "label": "MockTracker", "signature": "Class: `MockTracker`", "apiSymbol": "MockTracker", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-mocktracker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-mocktracker", "nodeStability": { "index": "2", "level": 2, @@ -61913,7 +66073,7 @@ "label": "mock.fn([original[, implementation]][, options])", "signature": "`mock.fn([original[, implementation]][, options])`", "apiSymbol": "mock.fn", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#mockfnoriginal-implementation-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#mockfnoriginal-implementation-options", "nodeStability": { "index": "2", "level": 2, @@ -61938,7 +66098,7 @@ "label": "mock.getter(object, methodName[, implementation][, options])", "signature": "`mock.getter(object, methodName[, implementation][, options])`", "apiSymbol": "mock.getter", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#mockgetterobject-methodname-implementation-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#mockgetterobject-methodname-implementation-options", "nodeStability": { "index": "2", "level": 2, @@ -61963,7 +66123,7 @@ "label": "mock.method(object, methodName[, implementation][, options])", "signature": "`mock.method(object, methodName[, implementation][, options])`", "apiSymbol": "mock.method", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#mockmethodobject-methodname-implementation-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#mockmethodobject-methodname-implementation-options", "nodeStability": { "index": "2", "level": 2, @@ -61988,7 +66148,7 @@ "label": "mock.module(specifier[, options])", "signature": "`mock.module(specifier[, options])`", "apiSymbol": "mock.module", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#mockmodulespecifier-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#mockmodulespecifier-options", "nodeStability": { "index": "1.0", "level": 1, @@ -62013,7 +66173,7 @@ "label": "mock.property(object, propertyName[, value])", "signature": "`mock.property(object, propertyName[, value])`", "apiSymbol": "mock.property", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#mockpropertyobject-propertyname-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#mockpropertyobject-propertyname-value", "nodeStability": { "index": "2", "level": 2, @@ -62038,7 +66198,7 @@ "label": "mock.reset()", "signature": "`mock.reset()`", "apiSymbol": "mock.reset", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#mockreset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#mockreset", "nodeStability": { "index": "2", "level": 2, @@ -62063,7 +66223,7 @@ "label": "mock.restoreAll()", "signature": "`mock.restoreAll()`", "apiSymbol": "mock.restoreAll", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#mockrestoreall", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#mockrestoreall", "nodeStability": { "index": "2", "level": 2, @@ -62088,7 +66248,7 @@ "label": "mock.setter(object, methodName[, implementation][, options])", "signature": "`mock.setter(object, methodName[, implementation][, options])`", "apiSymbol": "mock.setter", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#mocksetterobject-methodname-implementation-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#mocksetterobject-methodname-implementation-options", "nodeStability": { "index": "2", "level": 2, @@ -62113,7 +66273,7 @@ "label": "MockTimers", "signature": "Class: `MockTimers`", "apiSymbol": "MockTimers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-mocktimers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-mocktimers", "nodeStability": { "index": "2", "level": 2, @@ -62138,7 +66298,7 @@ "label": "timers.enable([enableOptions])", "signature": "`timers.enable([enableOptions])`", "apiSymbol": "timers.enable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#timersenableenableoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#timersenableenableoptions", "nodeStability": { "index": "2", "level": 2, @@ -62163,7 +66323,7 @@ "label": "timers.reset()", "signature": "`timers.reset()`", "apiSymbol": "timers.reset", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#timersreset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#timersreset", "nodeStability": { "index": "2", "level": 2, @@ -62188,7 +66348,7 @@ "label": "timers[Symbol.dispose]()", "signature": "`timers[Symbol.dispose]()`", "apiSymbol": "timers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#timerssymboldispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#timerssymboldispose", "nodeStability": { "index": "2", "level": 2, @@ -62213,7 +66373,7 @@ "label": "timers.tick([milliseconds])", "signature": "`timers.tick([milliseconds])`", "apiSymbol": "timers.tick", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#timerstickmilliseconds", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#timerstickmilliseconds", "nodeStability": { "index": "2", "level": 2, @@ -62238,7 +66398,7 @@ "label": "timers.runAll()", "signature": "`timers.runAll()`", "apiSymbol": "timers.runAll", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#timersrunall", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#timersrunall", "nodeStability": { "index": "2", "level": 2, @@ -62263,7 +66423,7 @@ "label": "timers.setTime(milliseconds)", "signature": "`timers.setTime(milliseconds)`", "apiSymbol": "timers.setTime", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#timerssettimemilliseconds", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#timerssettimemilliseconds", "nodeStability": { "index": "2", "level": 2, @@ -62288,7 +66448,7 @@ "label": "TestsStream", "signature": "Class: `TestsStream`", "apiSymbol": "TestsStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-testsstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-testsstream", "nodeStability": { "index": "2", "level": 2, @@ -62313,7 +66473,7 @@ "label": "'test:coverage'", "signature": "Event: `'test:coverage'`", "apiSymbol": "'test:coverage'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-testcoverage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testcoverage", "nodeStability": { "index": "2", "level": 2, @@ -62338,7 +66498,7 @@ "label": "'test:complete'", "signature": "Event: `'test:complete'`", "apiSymbol": "'test:complete'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-testcomplete", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testcomplete", "nodeStability": { "index": "2", "level": 2, @@ -62363,7 +66523,7 @@ "label": "'test:dequeue'", "signature": "Event: `'test:dequeue'`", "apiSymbol": "'test:dequeue'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-testdequeue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testdequeue", "nodeStability": { "index": "2", "level": 2, @@ -62388,7 +66548,7 @@ "label": "'test:diagnostic'", "signature": "Event: `'test:diagnostic'`", "apiSymbol": "'test:diagnostic'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-testdiagnostic", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testdiagnostic", "nodeStability": { "index": "2", "level": 2, @@ -62413,7 +66573,7 @@ "label": "'test:enqueue'", "signature": "Event: `'test:enqueue'`", "apiSymbol": "'test:enqueue'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-testenqueue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testenqueue", "nodeStability": { "index": "2", "level": 2, @@ -62438,7 +66598,7 @@ "label": "'test:fail'", "signature": "Event: `'test:fail'`", "apiSymbol": "'test:fail'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-testfail", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testfail", "nodeStability": { "index": "2", "level": 2, @@ -62463,7 +66623,32 @@ "label": "'test:interrupted'", "signature": "Event: `'test:interrupted'`", "apiSymbol": "'test:interrupted'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-testinterrupted", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testinterrupted", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] + } + } + }, + { + "id": "test:3b0586b4ebf5", + "chapter": "test", + "label": "'test:log'", + "signature": "Event: `'test:log'`", + "apiSymbol": "'test:log'", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testlog", "nodeStability": { "index": "2", "level": 2, @@ -62488,7 +66673,7 @@ "label": "'test:pass'", "signature": "Event: `'test:pass'`", "apiSymbol": "'test:pass'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-testpass", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testpass", "nodeStability": { "index": "2", "level": 2, @@ -62513,7 +66698,7 @@ "label": "'test:plan'", "signature": "Event: `'test:plan'`", "apiSymbol": "'test:plan'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-testplan", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testplan", "nodeStability": { "index": "2", "level": 2, @@ -62538,7 +66723,7 @@ "label": "'test:start'", "signature": "Event: `'test:start'`", "apiSymbol": "'test:start'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-teststart", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-teststart", "nodeStability": { "index": "2", "level": 2, @@ -62563,7 +66748,7 @@ "label": "'test:stderr'", "signature": "Event: `'test:stderr'`", "apiSymbol": "'test:stderr'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-teststderr", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-teststderr", "nodeStability": { "index": "2", "level": 2, @@ -62588,7 +66773,7 @@ "label": "'test:stdout'", "signature": "Event: `'test:stdout'`", "apiSymbol": "'test:stdout'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-teststdout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-teststdout", "nodeStability": { "index": "2", "level": 2, @@ -62613,7 +66798,7 @@ "label": "'test:summary'", "signature": "Event: `'test:summary'`", "apiSymbol": "'test:summary'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-testsummary", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testsummary", "nodeStability": { "index": "2", "level": 2, @@ -62638,7 +66823,7 @@ "label": "'test:watch:drained'", "signature": "Event: `'test:watch:drained'`", "apiSymbol": "'test:watch:drained'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-testwatchdrained", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testwatchdrained", "nodeStability": { "index": "2", "level": 2, @@ -62663,7 +66848,7 @@ "label": "'test:watch:restarted'", "signature": "Event: `'test:watch:restarted'`", "apiSymbol": "'test:watch:restarted'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#event-testwatchrestarted", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#event-testwatchrestarted", "nodeStability": { "index": "2", "level": 2, @@ -62688,7 +66873,7 @@ "label": "TestContext", "signature": "Class: `TestContext`", "apiSymbol": "TestContext", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-testcontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-testcontext", "nodeStability": { "index": "2", "level": 2, @@ -62713,7 +66898,7 @@ "label": "context.before([fn][, options])", "signature": "`context.before([fn][, options])`", "apiSymbol": "context.before", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextbeforefn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextbeforefn-options", "nodeStability": { "index": "2", "level": 2, @@ -62738,7 +66923,7 @@ "label": "context.beforeEach([fn][, options])", "signature": "`context.beforeEach([fn][, options])`", "apiSymbol": "context.beforeEach", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextbeforeeachfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextbeforeeachfn-options", "nodeStability": { "index": "2", "level": 2, @@ -62763,7 +66948,7 @@ "label": "context.after([fn][, options])", "signature": "`context.after([fn][, options])`", "apiSymbol": "context.after", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextafterfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextafterfn-options", "nodeStability": { "index": "2", "level": 2, @@ -62788,7 +66973,7 @@ "label": "context.afterEach([fn][, options])", "signature": "`context.afterEach([fn][, options])`", "apiSymbol": "context.afterEach", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextaftereachfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextaftereachfn-options", "nodeStability": { "index": "2", "level": 2, @@ -62813,7 +66998,7 @@ "label": "context.diagnostic(message)", "signature": "`context.diagnostic(message)`", "apiSymbol": "context.diagnostic", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextdiagnosticmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextdiagnosticmessage", "nodeStability": { "index": "2", "level": 2, @@ -62827,20 +67012,45 @@ "action": "audit-partial", "verification": "test-backed", "confidence": "high", - "source": "compiler-dedicated:context.diagnostic", + "source": "compiler-feature:test.context.diagnostic", "tests": [ "tests/harness/node-test.test.ts" ] } } }, + { + "id": "test:0c374aa5a4a0", + "chapter": "test", + "label": "context.log(message[, data])", + "signature": "`context.log(message[, data])`", + "apiSymbol": "context.log", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextlogmessage-data", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] + } + } + }, { "id": "test:d5d9833c77e2", "chapter": "test", "label": "context.plan(count[,options])", "signature": "`context.plan(count[,options])`", "apiSymbol": "context.plan", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextplancountoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextplancountoptions", "nodeStability": { "index": "2", "level": 2, @@ -62865,7 +67075,7 @@ "label": "context.runOnly(shouldRunOnlyTests)", "signature": "`context.runOnly(shouldRunOnlyTests)`", "apiSymbol": "context.runOnly", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextrunonlyshouldrunonlytests", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextrunonlyshouldrunonlytests", "nodeStability": { "index": "2", "level": 2, @@ -62890,7 +67100,7 @@ "label": "context.skip([message])", "signature": "`context.skip([message])`", "apiSymbol": "context.skip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextskipmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextskipmessage", "nodeStability": { "index": "2", "level": 2, @@ -62917,7 +67127,7 @@ "label": "context.todo([message])", "signature": "`context.todo([message])`", "apiSymbol": "context.todo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contexttodomessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contexttodomessage", "nodeStability": { "index": "2", "level": 2, @@ -62944,7 +67154,7 @@ "label": "context.test([name][, options][, fn])", "signature": "`context.test([name][, options][, fn])`", "apiSymbol": "context.test", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contexttestname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contexttestname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -62971,7 +67181,7 @@ "label": "context.waitFor(condition[, options])", "signature": "`context.waitFor(condition[, options])`", "apiSymbol": "context.waitFor", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextwaitforcondition-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextwaitforcondition-options", "nodeStability": { "index": "2", "level": 2, @@ -62996,7 +67206,7 @@ "label": "context.assert", "signature": "`context.assert`", "apiSymbol": "context.assert", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextassert", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextassert", "nodeStability": { "index": "2", "level": 2, @@ -63023,7 +67233,7 @@ "label": "context.assert.fileSnapshot(value, path[, options])", "signature": "`context.assert.fileSnapshot(value, path[, options])`", "apiSymbol": "context.assert.fileSnapshot", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextassertfilesnapshotvalue-path-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextassertfilesnapshotvalue-path-options", "nodeStability": { "index": "2", "level": 2, @@ -63048,7 +67258,7 @@ "label": "context.assert.snapshot(value[, options])", "signature": "`context.assert.snapshot(value[, options])`", "apiSymbol": "context.assert.snapshot", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextassertsnapshotvalue-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextassertsnapshotvalue-options", "nodeStability": { "index": "2", "level": 2, @@ -63073,7 +67283,7 @@ "label": "context.filePath", "signature": "`context.filePath`", "apiSymbol": "context.filePath", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextfilepath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextfilepath", "nodeStability": { "index": "2", "level": 2, @@ -63098,7 +67308,7 @@ "label": "context.fullName", "signature": "`context.fullName`", "apiSymbol": "context.fullName", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextfullname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextfullname", "nodeStability": { "index": "2", "level": 2, @@ -63123,7 +67333,7 @@ "label": "context.name", "signature": "`context.name`", "apiSymbol": "context.name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextname", "nodeStability": { "index": "2", "level": 2, @@ -63137,7 +67347,7 @@ "action": "audit-partial", "verification": "test-backed", "confidence": "high", - "source": "compiler-dedicated:context.name", + "source": "compiler-feature:test.context.name", "tests": [ "tests/harness/node-test.test.ts" ] @@ -63150,7 +67360,7 @@ "label": "passed", "signature": "`passed` Type: {boolean} `false` before the test is executed, e.g. in a `beforeEach` hook.", "apiSymbol": "passed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-testcontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-testcontext", "nodeStability": { "index": "2", "level": 2, @@ -63175,7 +67385,7 @@ "label": "error", "signature": "`error` Type: {Error|null}", "apiSymbol": "error", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-testcontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-testcontext", "nodeStability": { "index": "2", "level": 2, @@ -63200,7 +67410,7 @@ "label": "attempt", "signature": "`attempt` Type: {number}", "apiSymbol": "attempt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-testcontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-testcontext", "nodeStability": { "index": "2", "level": 2, @@ -63219,13 +67429,38 @@ } } }, + { + "id": "test:1d5db8900faf", + "chapter": "test", + "label": "tags", + "signature": "`tags` Type: {string\\[]}", + "apiSymbol": "tags", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-testcontext", + "nodeStability": { + "index": "1.0", + "level": 1, + "text": "Early development", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] + } + } + }, { "id": "test:0ee703f51144", "chapter": "test", "label": "workerId", "signature": "`workerId` Type: {number|undefined}", "apiSymbol": "workerId", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-testcontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-testcontext", "nodeStability": { "index": "2", "level": 2, @@ -63250,7 +67485,7 @@ "label": "signal", "signature": "`signal` Type: {AbortSignal}", "apiSymbol": "signal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-testcontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-testcontext", "nodeStability": { "index": "2", "level": 2, @@ -63275,7 +67510,57 @@ "label": "SuiteContext", "signature": "Class: `SuiteContext`", "apiSymbol": "SuiteContext", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-suitecontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-suitecontext", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] + } + } + }, + { + "id": "test:fc7f1b42c35e", + "chapter": "test", + "label": "context.diagnostic(message)", + "signature": "`context.diagnostic(message)`", + "apiSymbol": "context.diagnostic", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextdiagnosticmessage_1", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] + } + } + }, + { + "id": "test:eed9c6589bd2", + "chapter": "test", + "label": "context.log(message[, data])", + "signature": "`context.log(message[, data])`", + "apiSymbol": "context.log", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextlogmessage-data_1", "nodeStability": { "index": "2", "level": 2, @@ -63300,7 +67585,7 @@ "label": "context.filePath", "signature": "`context.filePath`", "apiSymbol": "context.filePath", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextfilepath_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextfilepath_1", "nodeStability": { "index": "2", "level": 2, @@ -63325,7 +67610,7 @@ "label": "context.fullName", "signature": "`context.fullName`", "apiSymbol": "context.fullName", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextfullname_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextfullname_1", "nodeStability": { "index": "2", "level": 2, @@ -63350,7 +67635,7 @@ "label": "context.name", "signature": "`context.name`", "apiSymbol": "context.name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#contextname_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#contextname_1", "nodeStability": { "index": "2", "level": 2, @@ -63360,14 +67645,12 @@ "priority": "high", "tiers": { "static": { - "status": "partial", - "action": "audit-partial", - "verification": "test-backed", - "confidence": "high", - "source": "compiler-dedicated:context.name", - "tests": [ - "tests/harness/node-test.test.ts" - ] + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] } } }, @@ -63377,7 +67660,57 @@ "label": "signal", "signature": "`signal` Type: {AbortSignal}", "apiSymbol": "signal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#class-suitecontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-suitecontext", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] + } + } + }, + { + "id": "test:9af04b8cf499", + "chapter": "test", + "label": "passed", + "signature": "`passed` Type: {boolean}", + "apiSymbol": "passed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-suitecontext", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] + } + } + }, + { + "id": "test:ab6d3613f62b", + "chapter": "test", + "label": "attempt", + "signature": "`attempt` Type: {number}", + "apiSymbol": "attempt", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#class-suitecontext", "nodeStability": { "index": "2", "level": 2, @@ -63402,7 +67735,7 @@ "label": "run([options])", "signature": "`run([options])`", "apiSymbol": "run", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#runoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#runoptions", "nodeStability": { "index": "2", "level": 2, @@ -63427,7 +67760,7 @@ "label": "suite([name][, options][, fn])", "signature": "`suite([name][, options][, fn])`", "apiSymbol": "suite", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#suitename-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#suitename-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63454,7 +67787,7 @@ "label": "suite.skip([name][, options][, fn])", "signature": "`suite.skip([name][, options][, fn])`", "apiSymbol": "suite.skip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#suiteskipname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#suiteskipname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63479,7 +67812,7 @@ "label": "suite.todo([name][, options][, fn])", "signature": "`suite.todo([name][, options][, fn])`", "apiSymbol": "suite.todo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#suitetodoname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#suitetodoname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63504,7 +67837,7 @@ "label": "suite.only([name][, options][, fn])", "signature": "`suite.only([name][, options][, fn])`", "apiSymbol": "suite.only", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#suiteonlyname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#suiteonlyname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63529,7 +67862,7 @@ "label": "test([name][, options][, fn])", "signature": "`test([name][, options][, fn])`", "apiSymbol": "test", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#testname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#testname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63556,7 +67889,7 @@ "label": "test.skip([name][, options][, fn])", "signature": "`test.skip([name][, options][, fn])`", "apiSymbol": "test.skip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#testskipname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#testskipname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63583,7 +67916,7 @@ "label": "test.todo([name][, options][, fn])", "signature": "`test.todo([name][, options][, fn])`", "apiSymbol": "test.todo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#testtodoname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#testtodoname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63610,7 +67943,7 @@ "label": "test.only([name][, options][, fn])", "signature": "`test.only([name][, options][, fn])`", "apiSymbol": "test.only", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#testonlyname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#testonlyname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63637,7 +67970,7 @@ "label": "describe([name][, options][, fn])", "signature": "`describe([name][, options][, fn])`", "apiSymbol": "describe", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#describename-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#describename-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63664,7 +67997,7 @@ "label": "describe.skip([name][, options][, fn])", "signature": "`describe.skip([name][, options][, fn])`", "apiSymbol": "describe.skip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#describeskipname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#describeskipname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63689,7 +68022,7 @@ "label": "describe.todo([name][, options][, fn])", "signature": "`describe.todo([name][, options][, fn])`", "apiSymbol": "describe.todo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#describetodoname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#describetodoname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63714,7 +68047,7 @@ "label": "describe.only([name][, options][, fn])", "signature": "`describe.only([name][, options][, fn])`", "apiSymbol": "describe.only", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#describeonlyname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#describeonlyname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63739,7 +68072,7 @@ "label": "it([name][, options][, fn])", "signature": "`it([name][, options][, fn])`", "apiSymbol": "it", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#itname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#itname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63766,7 +68099,7 @@ "label": "it.skip([name][, options][, fn])", "signature": "`it.skip([name][, options][, fn])`", "apiSymbol": "it.skip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#itskipname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#itskipname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63791,7 +68124,7 @@ "label": "it.todo([name][, options][, fn])", "signature": "`it.todo([name][, options][, fn])`", "apiSymbol": "it.todo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#ittodoname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#ittodoname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63816,7 +68149,7 @@ "label": "it.only([name][, options][, fn])", "signature": "`it.only([name][, options][, fn])`", "apiSymbol": "it.only", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#itonlyname-options-fn", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#itonlyname-options-fn", "nodeStability": { "index": "2", "level": 2, @@ -63841,7 +68174,7 @@ "label": "before([fn][, options])", "signature": "`before([fn][, options])`", "apiSymbol": "before", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#beforefn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#beforefn-options", "nodeStability": { "index": "2", "level": 2, @@ -63868,7 +68201,7 @@ "label": "after([fn][, options])", "signature": "`after([fn][, options])`", "apiSymbol": "after", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#afterfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#afterfn-options", "nodeStability": { "index": "2", "level": 2, @@ -63895,7 +68228,7 @@ "label": "beforeEach([fn][, options])", "signature": "`beforeEach([fn][, options])`", "apiSymbol": "beforeEach", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#beforeeachfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#beforeeachfn-options", "nodeStability": { "index": "2", "level": 2, @@ -63922,7 +68255,7 @@ "label": "afterEach([fn][, options])", "signature": "`afterEach([fn][, options])`", "apiSymbol": "afterEach", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/test.html#aftereachfn-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#aftereachfn-options", "nodeStability": { "index": "2", "level": 2, @@ -63943,13 +68276,38 @@ } } }, + { + "id": "test:079e32fafea1", + "chapter": "test", + "label": "getTestContext()", + "signature": "`getTestContext()`", + "apiSymbol": "getTestContext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/test.html#gettestcontext", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:test", + "tests": [] + } + } + }, { "id": "timers:c166edf2e065", "chapter": "timers", "label": "setImmediate(callback[, ...args])", "signature": "`setImmediate(callback[, ...args])`", "apiSymbol": "setImmediate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#setimmediatecallback-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#setimmediatecallback-args", "nodeStability": { "index": "2", "level": 2, @@ -63979,7 +68337,7 @@ "label": "setInterval(callback[, delay[, ...args]])", "signature": "`setInterval(callback[, delay[, ...args]])`", "apiSymbol": "setInterval", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#setintervalcallback-delay-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#setintervalcallback-delay-args", "nodeStability": { "index": "2", "level": 2, @@ -64009,7 +68367,7 @@ "label": "setTimeout(callback[, delay[, ...args]])", "signature": "`setTimeout(callback[, delay[, ...args]])`", "apiSymbol": "setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#settimeoutcallback-delay-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#settimeoutcallback-delay-args", "nodeStability": { "index": "2", "level": 2, @@ -64039,7 +68397,7 @@ "label": "clearImmediate(immediate)", "signature": "`clearImmediate(immediate)`", "apiSymbol": "clearImmediate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#clearimmediateimmediate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#clearimmediateimmediate", "nodeStability": { "index": "2", "level": 2, @@ -64069,7 +68427,7 @@ "label": "clearInterval(timeout)", "signature": "`clearInterval(timeout)`", "apiSymbol": "clearInterval", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#clearintervaltimeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#clearintervaltimeout", "nodeStability": { "index": "2", "level": 2, @@ -64099,7 +68457,7 @@ "label": "clearTimeout(timeout)", "signature": "`clearTimeout(timeout)`", "apiSymbol": "clearTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#cleartimeouttimeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#cleartimeouttimeout", "nodeStability": { "index": "2", "level": 2, @@ -64129,7 +68487,7 @@ "label": "timersPromises.setTimeout([delay[, value[, options]]])", "signature": "`timersPromises.setTimeout([delay[, value[, options]]])`", "apiSymbol": "timersPromises.setTimeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#timerspromisessettimeoutdelay-value-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#timerspromisessettimeoutdelay-value-options", "nodeStability": { "index": "2", "level": 2, @@ -64159,7 +68517,7 @@ "label": "timersPromises.setImmediate([value[, options]])", "signature": "`timersPromises.setImmediate([value[, options]])`", "apiSymbol": "timersPromises.setImmediate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#timerspromisessetimmediatevalue-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#timerspromisessetimmediatevalue-options", "nodeStability": { "index": "2", "level": 2, @@ -64189,7 +68547,7 @@ "label": "timersPromises.setInterval([delay[, value[, options]]])", "signature": "`timersPromises.setInterval([delay[, value[, options]]])`", "apiSymbol": "timersPromises.setInterval", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#timerspromisessetintervaldelay-value-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#timerspromisessetintervaldelay-value-options", "nodeStability": { "index": "2", "level": 2, @@ -64219,7 +68577,7 @@ "label": "timersPromises.scheduler.wait(delay[, options])", "signature": "`timersPromises.scheduler.wait(delay[, options])`", "apiSymbol": "timersPromises.scheduler.wait", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#timerspromisesschedulerwaitdelay-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#timerspromisesschedulerwaitdelay-options", "nodeStability": { "index": "1", "level": 1, @@ -64244,7 +68602,7 @@ "label": "timersPromises.scheduler.yield()", "signature": "`timersPromises.scheduler.yield()`", "apiSymbol": "timersPromises.scheduler.yield", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#timerspromisesscheduleryield", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#timerspromisesscheduleryield", "nodeStability": { "index": "1", "level": 1, @@ -64269,7 +68627,7 @@ "label": "Immediate", "signature": "Class: `Immediate`", "apiSymbol": "Immediate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#class-immediate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#class-immediate", "nodeStability": { "index": "2", "level": 2, @@ -64294,7 +68652,7 @@ "label": "immediate.hasRef()", "signature": "`immediate.hasRef()`", "apiSymbol": "immediate.hasRef", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#immediatehasref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#immediatehasref", "nodeStability": { "index": "2", "level": 2, @@ -64324,7 +68682,7 @@ "label": "immediate.ref()", "signature": "`immediate.ref()`", "apiSymbol": "immediate.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#immediateref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#immediateref", "nodeStability": { "index": "2", "level": 2, @@ -64354,7 +68712,7 @@ "label": "immediate.unref()", "signature": "`immediate.unref()`", "apiSymbol": "immediate.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#immediateunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#immediateunref", "nodeStability": { "index": "2", "level": 2, @@ -64384,7 +68742,7 @@ "label": "immediate[Symbol.dispose]()", "signature": "`immediate[Symbol.dispose]()`", "apiSymbol": "immediate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#immediatesymboldispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#immediatesymboldispose", "nodeStability": { "index": "2", "level": 2, @@ -64411,7 +68769,7 @@ "label": "Timeout", "signature": "Class: `Timeout`", "apiSymbol": "Timeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#class-timeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#class-timeout", "nodeStability": { "index": "2", "level": 2, @@ -64436,7 +68794,7 @@ "label": "timeout.close()", "signature": "`timeout.close()`", "apiSymbol": "timeout.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#timeoutclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#timeoutclose", "nodeStability": { "index": "3", "level": 3, @@ -64461,7 +68819,7 @@ "label": "timeout.hasRef()", "signature": "`timeout.hasRef()`", "apiSymbol": "timeout.hasRef", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#timeouthasref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#timeouthasref", "nodeStability": { "index": "2", "level": 2, @@ -64491,7 +68849,7 @@ "label": "timeout.ref()", "signature": "`timeout.ref()`", "apiSymbol": "timeout.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#timeoutref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#timeoutref", "nodeStability": { "index": "2", "level": 2, @@ -64521,7 +68879,7 @@ "label": "timeout.refresh()", "signature": "`timeout.refresh()`", "apiSymbol": "timeout.refresh", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#timeoutrefresh", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#timeoutrefresh", "nodeStability": { "index": "2", "level": 2, @@ -64551,7 +68909,7 @@ "label": "timeout.unref()", "signature": "`timeout.unref()`", "apiSymbol": "timeout.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#timeoutunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#timeoutunref", "nodeStability": { "index": "2", "level": 2, @@ -64581,7 +68939,7 @@ "label": "timeout[Symbol.toPrimitive]()", "signature": "`timeout[Symbol.toPrimitive]()`", "apiSymbol": "timeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#timeoutsymboltoprimitive", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#timeoutsymboltoprimitive", "nodeStability": { "index": "2", "level": 2, @@ -64610,7 +68968,7 @@ "label": "timeout[Symbol.dispose]()", "signature": "`timeout[Symbol.dispose]()`", "apiSymbol": "timeout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/timers.html#timeoutsymboldispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/timers.html#timeoutsymboldispose", "nodeStability": { "index": "2", "level": 2, @@ -64637,7 +68995,7 @@ "label": "tls.Server", "signature": "Class: `tls.Server`", "apiSymbol": "tls.Server", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#class-tlsserver", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#class-tlsserver", "nodeStability": { "index": "2", "level": 2, @@ -64662,7 +69020,7 @@ "label": "server.addContext(hostname, context)", "signature": "`server.addContext(hostname, context)`", "apiSymbol": "server.addContext", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#serveraddcontexthostname-context", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#serveraddcontexthostname-context", "nodeStability": { "index": "2", "level": 2, @@ -64687,7 +69045,7 @@ "label": "server.address()", "signature": "`server.address()`", "apiSymbol": "server.address", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#serveraddress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#serveraddress", "nodeStability": { "index": "2", "level": 2, @@ -64715,7 +69073,7 @@ "label": "server.close([callback])", "signature": "`server.close([callback])`", "apiSymbol": "server.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#serverclosecallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#serverclosecallback", "nodeStability": { "index": "2", "level": 2, @@ -64743,7 +69101,7 @@ "label": "server.getTicketKeys()", "signature": "`server.getTicketKeys()`", "apiSymbol": "server.getTicketKeys", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#servergetticketkeys", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#servergetticketkeys", "nodeStability": { "index": "2", "level": 2, @@ -64768,7 +69126,7 @@ "label": "server.listen()", "signature": "`server.listen()`", "apiSymbol": "server.listen", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#serverlisten", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#serverlisten", "nodeStability": { "index": "2", "level": 2, @@ -64796,7 +69154,7 @@ "label": "server.setSecureContext(options)", "signature": "`server.setSecureContext(options)`", "apiSymbol": "server.setSecureContext", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#serversetsecurecontextoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#serversetsecurecontextoptions", "nodeStability": { "index": "2", "level": 2, @@ -64821,7 +69179,7 @@ "label": "server.setTicketKeys(keys)", "signature": "`server.setTicketKeys(keys)`", "apiSymbol": "server.setTicketKeys", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#serversetticketkeyskeys", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#serversetticketkeyskeys", "nodeStability": { "index": "2", "level": 2, @@ -64846,7 +69204,7 @@ "label": "'connection'", "signature": "Event: `'connection'`", "apiSymbol": "'connection'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#event-connection", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#event-connection", "nodeStability": { "index": "2", "level": 2, @@ -64871,7 +69229,7 @@ "label": "'keylog'", "signature": "Event: `'keylog'`", "apiSymbol": "'keylog'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#event-keylog", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#event-keylog", "nodeStability": { "index": "2", "level": 2, @@ -64896,7 +69254,7 @@ "label": "'newSession'", "signature": "Event: `'newSession'`", "apiSymbol": "'newSession'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#event-newsession", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#event-newsession", "nodeStability": { "index": "2", "level": 2, @@ -64921,7 +69279,7 @@ "label": "'OCSPRequest'", "signature": "Event: `'OCSPRequest'`", "apiSymbol": "'OCSPRequest'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#event-ocsprequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#event-ocsprequest", "nodeStability": { "index": "2", "level": 2, @@ -64946,7 +69304,7 @@ "label": "'resumeSession'", "signature": "Event: `'resumeSession'`", "apiSymbol": "'resumeSession'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#event-resumesession", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#event-resumesession", "nodeStability": { "index": "2", "level": 2, @@ -64971,7 +69329,7 @@ "label": "'secureConnection'", "signature": "Event: `'secureConnection'`", "apiSymbol": "'secureConnection'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#event-secureconnection", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#event-secureconnection", "nodeStability": { "index": "2", "level": 2, @@ -64996,7 +69354,7 @@ "label": "'tlsClientError'", "signature": "Event: `'tlsClientError'`", "apiSymbol": "'tlsClientError'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#event-tlsclienterror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#event-tlsclienterror", "nodeStability": { "index": "2", "level": 2, @@ -65021,7 +69379,7 @@ "label": "tls.TLSSocket", "signature": "Class: `tls.TLSSocket`", "apiSymbol": "tls.TLSSocket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#class-tlstlssocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#class-tlstlssocket", "nodeStability": { "index": "2", "level": 2, @@ -65046,7 +69404,7 @@ "label": "tlsSocket.address()", "signature": "`tlsSocket.address()`", "apiSymbol": "tlsSocket.address", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketaddress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketaddress", "nodeStability": { "index": "2", "level": 2, @@ -65071,7 +69429,7 @@ "label": "tlsSocket.disableRenegotiation()", "signature": "`tlsSocket.disableRenegotiation()`", "apiSymbol": "tlsSocket.disableRenegotiation", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketdisablerenegotiation", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketdisablerenegotiation", "nodeStability": { "index": "2", "level": 2, @@ -65096,7 +69454,7 @@ "label": "tlsSocket.enableTrace()", "signature": "`tlsSocket.enableTrace()`", "apiSymbol": "tlsSocket.enableTrace", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketenabletrace", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketenabletrace", "nodeStability": { "index": "2", "level": 2, @@ -65121,7 +69479,7 @@ "label": "tlsSocket.exportKeyingMaterial(length, label[, context])", "signature": "`tlsSocket.exportKeyingMaterial(length, label[, context])`", "apiSymbol": "tlsSocket.exportKeyingMaterial", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketexportkeyingmateriallength-label-context", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketexportkeyingmateriallength-label-context", "nodeStability": { "index": "2", "level": 2, @@ -65146,7 +69504,7 @@ "label": "tlsSocket.getCertificate()", "signature": "`tlsSocket.getCertificate()`", "apiSymbol": "tlsSocket.getCertificate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketgetcertificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketgetcertificate", "nodeStability": { "index": "2", "level": 2, @@ -65171,7 +69529,7 @@ "label": "tlsSocket.getCipher()", "signature": "`tlsSocket.getCipher()`", "apiSymbol": "tlsSocket.getCipher", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketgetcipher", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketgetcipher", "nodeStability": { "index": "2", "level": 2, @@ -65196,7 +69554,7 @@ "label": "tlsSocket.getEphemeralKeyInfo()", "signature": "`tlsSocket.getEphemeralKeyInfo()`", "apiSymbol": "tlsSocket.getEphemeralKeyInfo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketgetephemeralkeyinfo", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketgetephemeralkeyinfo", "nodeStability": { "index": "2", "level": 2, @@ -65221,7 +69579,7 @@ "label": "tlsSocket.getFinished()", "signature": "`tlsSocket.getFinished()`", "apiSymbol": "tlsSocket.getFinished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketgetfinished", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketgetfinished", "nodeStability": { "index": "2", "level": 2, @@ -65246,7 +69604,7 @@ "label": "tlsSocket.getPeerCertificate([detailed])", "signature": "`tlsSocket.getPeerCertificate([detailed])`", "apiSymbol": "tlsSocket.getPeerCertificate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketgetpeercertificatedetailed", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketgetpeercertificatedetailed", "nodeStability": { "index": "2", "level": 2, @@ -65271,7 +69629,7 @@ "label": "tlsSocket.getPeerFinished()", "signature": "`tlsSocket.getPeerFinished()`", "apiSymbol": "tlsSocket.getPeerFinished", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketgetpeerfinished", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketgetpeerfinished", "nodeStability": { "index": "2", "level": 2, @@ -65296,7 +69654,7 @@ "label": "tlsSocket.getPeerX509Certificate()", "signature": "`tlsSocket.getPeerX509Certificate()`", "apiSymbol": "tlsSocket.getPeerX509Certificate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketgetpeerx509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketgetpeerx509certificate", "nodeStability": { "index": "2", "level": 2, @@ -65321,7 +69679,7 @@ "label": "tlsSocket.getProtocol()", "signature": "`tlsSocket.getProtocol()`", "apiSymbol": "tlsSocket.getProtocol", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketgetprotocol", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketgetprotocol", "nodeStability": { "index": "2", "level": 2, @@ -65346,7 +69704,7 @@ "label": "tlsSocket.getSession()", "signature": "`tlsSocket.getSession()`", "apiSymbol": "tlsSocket.getSession", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketgetsession", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketgetsession", "nodeStability": { "index": "2", "level": 2, @@ -65371,7 +69729,7 @@ "label": "tlsSocket.getSharedSigalgs()", "signature": "`tlsSocket.getSharedSigalgs()`", "apiSymbol": "tlsSocket.getSharedSigalgs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketgetsharedsigalgs", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketgetsharedsigalgs", "nodeStability": { "index": "2", "level": 2, @@ -65396,7 +69754,7 @@ "label": "tlsSocket.getTLSTicket()", "signature": "`tlsSocket.getTLSTicket()`", "apiSymbol": "tlsSocket.getTLSTicket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketgettlsticket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketgettlsticket", "nodeStability": { "index": "2", "level": 2, @@ -65421,7 +69779,7 @@ "label": "tlsSocket.getX509Certificate()", "signature": "`tlsSocket.getX509Certificate()`", "apiSymbol": "tlsSocket.getX509Certificate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketgetx509certificate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketgetx509certificate", "nodeStability": { "index": "2", "level": 2, @@ -65446,7 +69804,7 @@ "label": "tlsSocket.isSessionReused()", "signature": "`tlsSocket.isSessionReused()`", "apiSymbol": "tlsSocket.isSessionReused", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketissessionreused", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketissessionreused", "nodeStability": { "index": "2", "level": 2, @@ -65471,7 +69829,7 @@ "label": "tlsSocket.renegotiate(options, callback)", "signature": "`tlsSocket.renegotiate(options, callback)`", "apiSymbol": "tlsSocket.renegotiate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketrenegotiateoptions-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketrenegotiateoptions-callback", "nodeStability": { "index": "2", "level": 2, @@ -65496,7 +69854,7 @@ "label": "tlsSocket.setKeyCert(context)", "signature": "`tlsSocket.setKeyCert(context)`", "apiSymbol": "tlsSocket.setKeyCert", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketsetkeycertcontext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketsetkeycertcontext", "nodeStability": { "index": "2", "level": 2, @@ -65521,7 +69879,32 @@ "label": "tlsSocket.setMaxSendFragment(size)", "signature": "`tlsSocket.setMaxSendFragment(size)`", "apiSymbol": "tlsSocket.setMaxSendFragment", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketsetmaxsendfragmentsize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketsetmaxsendfragmentsize", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:tls", + "tests": [] + } + } + }, + { + "id": "tls:0961fd354257", + "chapter": "tls", + "label": "alpnProtocol", + "signature": "`alpnProtocol` Type: {string|boolean|null}", + "apiSymbol": "alpnProtocol", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#class-tlstlssocket", "nodeStability": { "index": "2", "level": 2, @@ -65546,7 +69929,7 @@ "label": "tlsSocket.authorizationError", "signature": "`tlsSocket.authorizationError`", "apiSymbol": "tlsSocket.authorizationError", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketauthorizationerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketauthorizationerror", "nodeStability": { "index": "2", "level": 2, @@ -65571,7 +69954,7 @@ "label": "authorized", "signature": "`authorized` Type: {boolean}", "apiSymbol": "authorized", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#class-tlstlssocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#class-tlstlssocket", "nodeStability": { "index": "2", "level": 2, @@ -65596,7 +69979,7 @@ "label": "tlsSocket.encrypted", "signature": "`tlsSocket.encrypted`", "apiSymbol": "tlsSocket.encrypted", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssocketencrypted", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssocketencrypted", "nodeStability": { "index": "2", "level": 2, @@ -65621,7 +70004,7 @@ "label": "localAddress", "signature": "`localAddress` Type: {string}", "apiSymbol": "localAddress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#class-tlstlssocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#class-tlstlssocket", "nodeStability": { "index": "2", "level": 2, @@ -65646,7 +70029,7 @@ "label": "localPort", "signature": "`localPort` Type: {integer}", "apiSymbol": "localPort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#class-tlstlssocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#class-tlstlssocket", "nodeStability": { "index": "2", "level": 2, @@ -65671,7 +70054,7 @@ "label": "remoteAddress", "signature": "`remoteAddress` Type: {string}", "apiSymbol": "remoteAddress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#class-tlstlssocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#class-tlstlssocket", "nodeStability": { "index": "2", "level": 2, @@ -65696,7 +70079,7 @@ "label": "remoteFamily", "signature": "`remoteFamily` Type: {string}", "apiSymbol": "remoteFamily", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#class-tlstlssocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#class-tlstlssocket", "nodeStability": { "index": "2", "level": 2, @@ -65721,7 +70104,32 @@ "label": "remotePort", "signature": "`remotePort` Type: {integer}", "apiSymbol": "remotePort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#class-tlstlssocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#class-tlstlssocket", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:tls", + "tests": [] + } + } + }, + { + "id": "tls:66d9155a5c20", + "chapter": "tls", + "label": "servername", + "signature": "`servername` Type: {string|boolean|null}", + "apiSymbol": "servername", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#class-tlstlssocket", "nodeStability": { "index": "2", "level": 2, @@ -65746,7 +70154,7 @@ "label": "'keylog'", "signature": "Event: `'keylog'`", "apiSymbol": "'keylog'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#event-keylog_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#event-keylog_1", "nodeStability": { "index": "2", "level": 2, @@ -65771,7 +70179,7 @@ "label": "'OCSPResponse'", "signature": "Event: `'OCSPResponse'`", "apiSymbol": "'OCSPResponse'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#event-ocspresponse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#event-ocspresponse", "nodeStability": { "index": "2", "level": 2, @@ -65796,7 +70204,7 @@ "label": "'secure'", "signature": "Event: `'secure'`", "apiSymbol": "'secure'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#event-secure", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#event-secure", "nodeStability": { "index": "2", "level": 2, @@ -65821,7 +70229,7 @@ "label": "'secureConnect'", "signature": "Event: `'secureConnect'`", "apiSymbol": "'secureConnect'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#event-secureconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#event-secureconnect", "nodeStability": { "index": "2", "level": 2, @@ -65846,7 +70254,7 @@ "label": "'session'", "signature": "Event: `'session'`", "apiSymbol": "'session'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#event-session", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#event-session", "nodeStability": { "index": "2", "level": 2, @@ -65871,7 +70279,7 @@ "label": "tls.checkServerIdentity(hostname, cert)", "signature": "`tls.checkServerIdentity(hostname, cert)`", "apiSymbol": "tls.checkServerIdentity", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlscheckserveridentityhostname-cert", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlscheckserveridentityhostname-cert", "nodeStability": { "index": "2", "level": 2, @@ -65896,7 +70304,7 @@ "label": "tls.connect(options[, callback])", "signature": "`tls.connect(options[, callback])`", "apiSymbol": "tls.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlsconnectoptions-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlsconnectoptions-callback", "nodeStability": { "index": "2", "level": 2, @@ -65921,7 +70329,7 @@ "label": "tls.connect(path[, options][, callback])", "signature": "`tls.connect(path[, options][, callback])`", "apiSymbol": "tls.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlsconnectpath-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlsconnectpath-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -65946,7 +70354,7 @@ "label": "tls.connect(port[, host][, options][, callback])", "signature": "`tls.connect(port[, host][, options][, callback])`", "apiSymbol": "tls.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlsconnectport-host-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlsconnectport-host-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -65971,7 +70379,7 @@ "label": "tls.createSecureContext([options])", "signature": "`tls.createSecureContext([options])`", "apiSymbol": "tls.createSecureContext", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlscreatesecurecontextoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlscreatesecurecontextoptions", "nodeStability": { "index": "2", "level": 2, @@ -65996,7 +70404,7 @@ "label": "tls.createServer([options][, secureConnectionListener])", "signature": "`tls.createServer([options][, secureConnectionListener])`", "apiSymbol": "tls.createServer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlscreateserveroptions-secureconnectionlistener", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlscreateserveroptions-secureconnectionlistener", "nodeStability": { "index": "2", "level": 2, @@ -66021,7 +70429,7 @@ "label": "tls.setDefaultCACertificates(certs)", "signature": "`tls.setDefaultCACertificates(certs)`", "apiSymbol": "tls.setDefaultCACertificates", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlssetdefaultcacertificatescerts", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlssetdefaultcacertificatescerts", "nodeStability": { "index": "2", "level": 2, @@ -66049,7 +70457,7 @@ "label": "tls.getCACertificates([type])", "signature": "`tls.getCACertificates([type])`", "apiSymbol": "tls.getCACertificates", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlsgetcacertificatestype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlsgetcacertificatestype", "nodeStability": { "index": "2", "level": 2, @@ -66077,7 +70485,32 @@ "label": "tls.getCiphers()", "signature": "`tls.getCiphers()`", "apiSymbol": "tls.getCiphers", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlsgetciphers", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlsgetciphers", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:tls", + "tests": [] + } + } + }, + { + "id": "tls:5a3cdc74e2b5", + "chapter": "tls", + "label": "tls.getCertificateCompressionAlgorithms()", + "signature": "`tls.getCertificateCompressionAlgorithms()`", + "apiSymbol": "tls.getCertificateCompressionAlgorithms", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlsgetcertificatecompressionalgorithms", "nodeStability": { "index": "2", "level": 2, @@ -66102,7 +70535,7 @@ "label": "rootCertificates", "signature": "`rootCertificates` Type: {string\\[]}", "apiSymbol": "rootCertificates", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html", "nodeStability": { "index": "2", "level": 2, @@ -66130,7 +70563,7 @@ "label": "tls.DEFAULT_ECDH_CURVE", "signature": "`tls.DEFAULT_ECDH_CURVE`", "apiSymbol": "tls.DEFAULT_ECDH_CURVE", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html#tlsdefault_ecdh_curve", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html#tlsdefault_ecdh_curve", "nodeStability": { "index": "2", "level": 2, @@ -66155,7 +70588,7 @@ "label": "DEFAULT_MAX_VERSION", "signature": "`DEFAULT_MAX_VERSION` Type: {string} The default value of the `maxVersion` option of [`tls.createSecureContext()`][]. It can be assigned any of the supported TLS protocol versions, `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. **Default:** `'TLSv1.3'`, unless changed using CLI options. Using `--tls-max-v1.2` sets the default to `'TLSv1.2'`. Using `--tls-max-v1.3` sets the default to `'TLSv1.3'`. If multiple of the options are provided, the highest maximum is used.", "apiSymbol": "DEFAULT_MAX_VERSION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html", "nodeStability": { "index": "2", "level": 2, @@ -66180,7 +70613,7 @@ "label": "DEFAULT_MIN_VERSION", "signature": "`DEFAULT_MIN_VERSION` Type: {string} The default value of the `minVersion` option of [`tls.createSecureContext()`][]. It can be assigned any of the supported TLS protocol versions, `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Versions before TLSv1.2 may require downgrading the [OpenSSL Security Level][]. **Default:** `'TLSv1.2'`, unless changed using CLI options. Using `--tls-min-v1.0` sets the default to `'TLSv1'`. Using `--tls-min-v1.1` sets the default to `'TLSv1.1'`. Using `--tls-min-v1.3` sets the default to `'TLSv1.3'`. If multiple of the options are provided, the lowest minimum is used.", "apiSymbol": "DEFAULT_MIN_VERSION", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html", "nodeStability": { "index": "2", "level": 2, @@ -66205,7 +70638,7 @@ "label": "DEFAULT_CIPHERS", "signature": "`DEFAULT_CIPHERS` Type: {string} The default value of the `ciphers` option of [`tls.createSecureContext()`][]. It can be assigned any of the supported OpenSSL ciphers. Defaults to the content of `crypto.constants.defaultCoreCipherList`, unless changed using CLI options using `--tls-default-ciphers`.", "apiSymbol": "DEFAULT_CIPHERS", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tls.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tls.html", "nodeStability": { "index": "2", "level": 2, @@ -66230,7 +70663,7 @@ "label": "The node:trace_events module", "signature": "The `node:trace_events` module", "apiSymbol": "node:trace_events", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tracing.html#the-nodetrace_events-module", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tracing.html#the-nodetrace_events-module", "nodeStability": { "index": "1", "level": 1, @@ -66255,7 +70688,7 @@ "label": "Tracing", "signature": "`Tracing` object", "apiSymbol": "Tracing", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tracing.html#tracing-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tracing.html#tracing-object", "nodeStability": { "index": "1", "level": 1, @@ -66280,7 +70713,7 @@ "label": "tracing.disable()", "signature": "`tracing.disable()`", "apiSymbol": "tracing.disable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tracing.html#tracingdisable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tracing.html#tracingdisable", "nodeStability": { "index": "1", "level": 1, @@ -66305,7 +70738,7 @@ "label": "tracing.enable()", "signature": "`tracing.enable()`", "apiSymbol": "tracing.enable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tracing.html#tracingenable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tracing.html#tracingenable", "nodeStability": { "index": "1", "level": 1, @@ -66330,7 +70763,7 @@ "label": "categories", "signature": "`categories` Type: {string}", "apiSymbol": "categories", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tracing.html#tracing-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tracing.html#tracing-object", "nodeStability": { "index": "1", "level": 1, @@ -66355,7 +70788,7 @@ "label": "enabled", "signature": "`enabled` Type: {boolean} `true` only if the `Tracing` object has been enabled.", "apiSymbol": "enabled", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tracing.html#tracing-object", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tracing.html#tracing-object", "nodeStability": { "index": "1", "level": 1, @@ -66380,7 +70813,7 @@ "label": "trace_events.createTracing(options)", "signature": "`trace_events.createTracing(options)`", "apiSymbol": "trace_events.createTracing", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tracing.html#trace_eventscreatetracingoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tracing.html#trace_eventscreatetracingoptions", "nodeStability": { "index": "1", "level": 1, @@ -66405,7 +70838,7 @@ "label": "trace_events.getEnabledCategories()", "signature": "`trace_events.getEnabledCategories()`", "apiSymbol": "trace_events.getEnabledCategories", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tracing.html#trace_eventsgetenabledcategories", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tracing.html#trace_eventsgetenabledcategories", "nodeStability": { "index": "1", "level": 1, @@ -66430,7 +70863,7 @@ "label": "tty.ReadStream", "signature": "Class: `tty.ReadStream`", "apiSymbol": "tty.ReadStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#class-ttyreadstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#class-ttyreadstream", "nodeStability": { "index": "2", "level": 2, @@ -66455,7 +70888,7 @@ "label": "readStream.setRawMode(mode)", "signature": "`readStream.setRawMode(mode)`", "apiSymbol": "readStream.setRawMode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#readstreamsetrawmodemode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#readstreamsetrawmodemode", "nodeStability": { "index": "2", "level": 2, @@ -66480,7 +70913,7 @@ "label": "readStream.isRaw", "signature": "`readStream.isRaw`", "apiSymbol": "readStream.isRaw", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#readstreamisraw", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#readstreamisraw", "nodeStability": { "index": "2", "level": 2, @@ -66505,7 +70938,7 @@ "label": "readStream.isTTY", "signature": "`readStream.isTTY`", "apiSymbol": "readStream.isTTY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#readstreamistty", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#readstreamistty", "nodeStability": { "index": "2", "level": 2, @@ -66530,13 +70963,38 @@ } } }, + { + "id": "tty:85fc0b85d933", + "chapter": "tty", + "label": "rawMode", + "signature": "`rawMode` {boolean|string}", + "apiSymbol": "rawMode", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#class-ttyreadstream", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:tty", + "tests": [] + } + } + }, { "id": "tty:cdef680b84c7", "chapter": "tty", "label": "tty.WriteStream", "signature": "Class: `tty.WriteStream`", "apiSymbol": "tty.WriteStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#class-ttywritestream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#class-ttywritestream", "nodeStability": { "index": "2", "level": 2, @@ -66561,7 +71019,7 @@ "label": "writeStream.clearLine(dir[, callback])", "signature": "`writeStream.clearLine(dir[, callback])`", "apiSymbol": "writeStream.clearLine", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#writestreamclearlinedir-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#writestreamclearlinedir-callback", "nodeStability": { "index": "2", "level": 2, @@ -66586,7 +71044,7 @@ "label": "writeStream.clearScreenDown([callback])", "signature": "`writeStream.clearScreenDown([callback])`", "apiSymbol": "writeStream.clearScreenDown", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#writestreamclearscreendowncallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#writestreamclearscreendowncallback", "nodeStability": { "index": "2", "level": 2, @@ -66611,7 +71069,7 @@ "label": "writeStream.cursorTo(x[, y][, callback])", "signature": "`writeStream.cursorTo(x[, y][, callback])`", "apiSymbol": "writeStream.cursorTo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#writestreamcursortox-y-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#writestreamcursortox-y-callback", "nodeStability": { "index": "2", "level": 2, @@ -66636,7 +71094,7 @@ "label": "writeStream.getColorDepth([env])", "signature": "`writeStream.getColorDepth([env])`", "apiSymbol": "writeStream.getColorDepth", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#writestreamgetcolordepthenv", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#writestreamgetcolordepthenv", "nodeStability": { "index": "2", "level": 2, @@ -66661,7 +71119,7 @@ "label": "writeStream.getWindowSize()", "signature": "`writeStream.getWindowSize()`", "apiSymbol": "writeStream.getWindowSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#writestreamgetwindowsize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#writestreamgetwindowsize", "nodeStability": { "index": "2", "level": 2, @@ -66692,7 +71150,7 @@ "label": "writeStream.hasColors([count][, env])", "signature": "`writeStream.hasColors([count][, env])`", "apiSymbol": "writeStream.hasColors", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#writestreamhascolorscount-env", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#writestreamhascolorscount-env", "nodeStability": { "index": "2", "level": 2, @@ -66717,7 +71175,7 @@ "label": "writeStream.moveCursor(dx, dy[, callback])", "signature": "`writeStream.moveCursor(dx, dy[, callback])`", "apiSymbol": "writeStream.moveCursor", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#writestreammovecursordx-dy-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#writestreammovecursordx-dy-callback", "nodeStability": { "index": "2", "level": 2, @@ -66742,7 +71200,7 @@ "label": "writeStream.columns", "signature": "`writeStream.columns`", "apiSymbol": "writeStream.columns", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#writestreamcolumns", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#writestreamcolumns", "nodeStability": { "index": "2", "level": 2, @@ -66773,7 +71231,7 @@ "label": "writeStream.isTTY", "signature": "`writeStream.isTTY`", "apiSymbol": "writeStream.isTTY", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#writestreamistty", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#writestreamistty", "nodeStability": { "index": "2", "level": 2, @@ -66804,7 +71262,7 @@ "label": "writeStream.rows", "signature": "`writeStream.rows`", "apiSymbol": "writeStream.rows", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#writestreamrows", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#writestreamrows", "nodeStability": { "index": "2", "level": 2, @@ -66835,7 +71293,7 @@ "label": "'resize'", "signature": "Event: `'resize'`", "apiSymbol": "'resize'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#event-resize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#event-resize", "nodeStability": { "index": "2", "level": 2, @@ -66860,7 +71318,7 @@ "label": "tty.isatty(fd)", "signature": "`tty.isatty(fd)`", "apiSymbol": "tty.isatty", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/tty.html#ttyisattyfd", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/tty.html#ttyisattyfd", "nodeStability": { "index": "2", "level": 2, @@ -66891,7 +71349,7 @@ "label": "node:dgram", "signature": "`node:dgram` module functions", "apiSymbol": "node:dgram", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#nodedgram-module-functions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#nodedgram-module-functions", "nodeStability": { "index": "2", "level": 2, @@ -66916,7 +71374,7 @@ "label": "dgram.createSocket(options[, callback])", "signature": "`dgram.createSocket(options[, callback])`", "apiSymbol": "dgram.createSocket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#dgramcreatesocketoptions-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#dgramcreatesocketoptions-callback", "nodeStability": { "index": "2", "level": 2, @@ -66943,7 +71401,7 @@ "label": "dgram.createSocket(type[, callback])", "signature": "`dgram.createSocket(type[, callback])`", "apiSymbol": "dgram.createSocket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#dgramcreatesockettype-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#dgramcreatesockettype-callback", "nodeStability": { "index": "2", "level": 2, @@ -66970,7 +71428,7 @@ "label": "dgram.Socket", "signature": "Class: `dgram.Socket`", "apiSymbol": "dgram.Socket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#class-dgramsocket", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#class-dgramsocket", "nodeStability": { "index": "2", "level": 2, @@ -66995,7 +71453,7 @@ "label": "socket.addMembership(multicastAddress[, multicastInterface])", "signature": "`socket.addMembership(multicastAddress[, multicastInterface])`", "apiSymbol": "socket.addMembership", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketaddmembershipmulticastaddress-multicastinterface", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketaddmembershipmulticastaddress-multicastinterface", "nodeStability": { "index": "2", "level": 2, @@ -67020,7 +71478,7 @@ "label": "socket.addSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])", "signature": "`socket.addSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])`", "apiSymbol": "socket.addSourceSpecificMembership", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketaddsourcespecificmembershipsourceaddress-groupaddress-multicastinterface", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketaddsourcespecificmembershipsourceaddress-groupaddress-multicastinterface", "nodeStability": { "index": "2", "level": 2, @@ -67045,7 +71503,7 @@ "label": "socket.address()", "signature": "`socket.address()`", "apiSymbol": "socket.address", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketaddress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketaddress", "nodeStability": { "index": "2", "level": 2, @@ -67072,7 +71530,7 @@ "label": "socket.bind([port][, address][, callback])", "signature": "`socket.bind([port][, address][, callback])`", "apiSymbol": "socket.bind", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketbindport-address-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketbindport-address-callback", "nodeStability": { "index": "2", "level": 2, @@ -67099,7 +71557,7 @@ "label": "socket.bind(options[, callback])", "signature": "`socket.bind(options[, callback])`", "apiSymbol": "socket.bind", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketbindoptions-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketbindoptions-callback", "nodeStability": { "index": "2", "level": 2, @@ -67120,13 +71578,38 @@ } } }, + { + "id": "dgram:283dec88737f", + "chapter": "dgram", + "label": "socket.bindSync([options])", + "signature": "`socket.bindSync([options])`", + "apiSymbol": "socket.bindSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketbindsyncoptions", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:dgram", + "tests": [] + } + } + }, { "id": "dgram:40eeb2e82c2b", "chapter": "dgram", "label": "socket.close([callback])", "signature": "`socket.close([callback])`", "apiSymbol": "socket.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketclosecallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketclosecallback", "nodeStability": { "index": "2", "level": 2, @@ -67153,7 +71636,7 @@ "label": "socket[Symbol.asyncDispose]()", "signature": "`socket[Symbol.asyncDispose]()`", "apiSymbol": "socket", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketsymbolasyncdispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketsymbolasyncdispose", "nodeStability": { "index": "2", "level": 2, @@ -67178,7 +71661,7 @@ "label": "socket.connect(port[, address][, callback])", "signature": "`socket.connect(port[, address][, callback])`", "apiSymbol": "socket.connect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketconnectport-address-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketconnectport-address-callback", "nodeStability": { "index": "2", "level": 2, @@ -67199,13 +71682,38 @@ } } }, + { + "id": "dgram:e4bb4d698b04", + "chapter": "dgram", + "label": "socket.connectSync(port[, address])", + "signature": "`socket.connectSync(port[, address])`", + "apiSymbol": "socket.connectSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketconnectsyncport-address", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:dgram", + "tests": [] + } + } + }, { "id": "dgram:c2008af7f485", "chapter": "dgram", "label": "socket.disconnect()", "signature": "`socket.disconnect()`", "apiSymbol": "socket.disconnect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketdisconnect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketdisconnect", "nodeStability": { "index": "2", "level": 2, @@ -67230,7 +71738,7 @@ "label": "socket.dropMembership(multicastAddress[, multicastInterface])", "signature": "`socket.dropMembership(multicastAddress[, multicastInterface])`", "apiSymbol": "socket.dropMembership", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketdropmembershipmulticastaddress-multicastinterface", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketdropmembershipmulticastaddress-multicastinterface", "nodeStability": { "index": "2", "level": 2, @@ -67255,7 +71763,7 @@ "label": "socket.dropSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])", "signature": "`socket.dropSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])`", "apiSymbol": "socket.dropSourceSpecificMembership", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketdropsourcespecificmembershipsourceaddress-groupaddress-multicastinterface", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketdropsourcespecificmembershipsourceaddress-groupaddress-multicastinterface", "nodeStability": { "index": "2", "level": 2, @@ -67280,7 +71788,7 @@ "label": "socket.getRecvBufferSize()", "signature": "`socket.getRecvBufferSize()`", "apiSymbol": "socket.getRecvBufferSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketgetrecvbuffersize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketgetrecvbuffersize", "nodeStability": { "index": "2", "level": 2, @@ -67305,7 +71813,7 @@ "label": "socket.getSendBufferSize()", "signature": "`socket.getSendBufferSize()`", "apiSymbol": "socket.getSendBufferSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketgetsendbuffersize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketgetsendbuffersize", "nodeStability": { "index": "2", "level": 2, @@ -67330,7 +71838,7 @@ "label": "socket.getSendQueueSize()", "signature": "`socket.getSendQueueSize()`", "apiSymbol": "socket.getSendQueueSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketgetsendqueuesize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketgetsendqueuesize", "nodeStability": { "index": "2", "level": 2, @@ -67355,7 +71863,7 @@ "label": "socket.getSendQueueCount()", "signature": "`socket.getSendQueueCount()`", "apiSymbol": "socket.getSendQueueCount", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketgetsendqueuecount", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketgetsendqueuecount", "nodeStability": { "index": "2", "level": 2, @@ -67380,7 +71888,7 @@ "label": "socket.ref()", "signature": "`socket.ref()`", "apiSymbol": "socket.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketref", "nodeStability": { "index": "2", "level": 2, @@ -67407,7 +71915,7 @@ "label": "socket.remoteAddress()", "signature": "`socket.remoteAddress()`", "apiSymbol": "socket.remoteAddress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketremoteaddress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketremoteaddress", "nodeStability": { "index": "2", "level": 2, @@ -67434,7 +71942,7 @@ "label": "socket.send(msg[, offset, length][, port][, address][, callback])", "signature": "`socket.send(msg[, offset, length][, port][, address][, callback])`", "apiSymbol": "socket.send", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketsendmsg-offset-length-port-address-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketsendmsg-offset-length-port-address-callback", "nodeStability": { "index": "2", "level": 2, @@ -67461,7 +71969,7 @@ "label": "socket.setBroadcast(flag)", "signature": "`socket.setBroadcast(flag)`", "apiSymbol": "socket.setBroadcast", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketsetbroadcastflag", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketsetbroadcastflag", "nodeStability": { "index": "2", "level": 2, @@ -67486,7 +71994,7 @@ "label": "socket.setMulticastInterface(multicastInterface)", "signature": "`socket.setMulticastInterface(multicastInterface)`", "apiSymbol": "socket.setMulticastInterface", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketsetmulticastinterfacemulticastinterface", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketsetmulticastinterfacemulticastinterface", "nodeStability": { "index": "2", "level": 2, @@ -67511,7 +72019,7 @@ "label": "socket.setMulticastLoopback(flag)", "signature": "`socket.setMulticastLoopback(flag)`", "apiSymbol": "socket.setMulticastLoopback", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketsetmulticastloopbackflag", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketsetmulticastloopbackflag", "nodeStability": { "index": "2", "level": 2, @@ -67536,7 +72044,7 @@ "label": "socket.setMulticastTTL(ttl)", "signature": "`socket.setMulticastTTL(ttl)`", "apiSymbol": "socket.setMulticastTTL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketsetmulticastttlttl", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketsetmulticastttlttl", "nodeStability": { "index": "2", "level": 2, @@ -67561,7 +72069,7 @@ "label": "socket.setRecvBufferSize(size)", "signature": "`socket.setRecvBufferSize(size)`", "apiSymbol": "socket.setRecvBufferSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketsetrecvbuffersizesize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketsetrecvbuffersizesize", "nodeStability": { "index": "2", "level": 2, @@ -67586,7 +72094,7 @@ "label": "socket.setSendBufferSize(size)", "signature": "`socket.setSendBufferSize(size)`", "apiSymbol": "socket.setSendBufferSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketsetsendbuffersizesize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketsetsendbuffersizesize", "nodeStability": { "index": "2", "level": 2, @@ -67611,7 +72119,7 @@ "label": "socket.setTTL(ttl)", "signature": "`socket.setTTL(ttl)`", "apiSymbol": "socket.setTTL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketsetttlttl", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketsetttlttl", "nodeStability": { "index": "2", "level": 2, @@ -67636,7 +72144,7 @@ "label": "socket.unref()", "signature": "`socket.unref()`", "apiSymbol": "socket.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#socketunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#socketunref", "nodeStability": { "index": "2", "level": 2, @@ -67663,7 +72171,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#event-close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#event-close", "nodeStability": { "index": "2", "level": 2, @@ -67688,7 +72196,7 @@ "label": "'connect'", "signature": "Event: `'connect'`", "apiSymbol": "'connect'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#event-connect", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#event-connect", "nodeStability": { "index": "2", "level": 2, @@ -67713,7 +72221,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#event-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#event-error", "nodeStability": { "index": "2", "level": 2, @@ -67738,7 +72246,7 @@ "label": "'listening'", "signature": "Event: `'listening'`", "apiSymbol": "'listening'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#event-listening", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#event-listening", "nodeStability": { "index": "2", "level": 2, @@ -67763,7 +72271,7 @@ "label": "'message'", "signature": "Event: `'message'`", "apiSymbol": "'message'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/dgram.html#event-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/dgram.html#event-message", "nodeStability": { "index": "2", "level": 2, @@ -67788,7 +72296,7 @@ "label": "URL", "signature": "Class: `URL`", "apiSymbol": "URL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -67818,7 +72326,7 @@ "label": "url.toString()", "signature": "`url.toString()`", "apiSymbol": "url.toString", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urltostring", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urltostring", "nodeStability": { "index": "2", "level": 2, @@ -67848,7 +72356,7 @@ "label": "url.toJSON()", "signature": "`url.toJSON()`", "apiSymbol": "url.toJSON", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urltojson", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urltojson", "nodeStability": { "index": "2", "level": 2, @@ -67878,7 +72386,7 @@ "label": "URL.createObjectURL(blob)", "signature": "`URL.createObjectURL(blob)`", "apiSymbol": "URL.createObjectURL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlcreateobjecturlblob", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlcreateobjecturlblob", "nodeStability": { "index": "2", "level": 2, @@ -67903,7 +72411,7 @@ "label": "URL.revokeObjectURL(id)", "signature": "`URL.revokeObjectURL(id)`", "apiSymbol": "URL.revokeObjectURL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlrevokeobjecturlid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlrevokeobjecturlid", "nodeStability": { "index": "2", "level": 2, @@ -67928,7 +72436,7 @@ "label": "URL.canParse(input[, base])", "signature": "`URL.canParse(input[, base])`", "apiSymbol": "URL.canParse", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlcanparseinput-base", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlcanparseinput-base", "nodeStability": { "index": "2", "level": 2, @@ -67958,7 +72466,7 @@ "label": "URL.parse(input[, base])", "signature": "`URL.parse(input[, base])`", "apiSymbol": "URL.parse", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlparseinput-base", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlparseinput-base", "nodeStability": { "index": "2", "level": 2, @@ -67988,7 +72496,7 @@ "label": "hash", "signature": "`hash` Type: {string}", "apiSymbol": "hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -68017,7 +72525,7 @@ "label": "host", "signature": "`host` Type: {string}", "apiSymbol": "host", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -68046,7 +72554,7 @@ "label": "hostname", "signature": "`hostname` Type: {string}", "apiSymbol": "hostname", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -68075,7 +72583,7 @@ "label": "href", "signature": "`href` Type: {string}", "apiSymbol": "href", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -68104,7 +72612,7 @@ "label": "origin", "signature": "`origin` Type: {string}", "apiSymbol": "origin", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -68129,7 +72637,7 @@ "label": "password", "signature": "`password` Type: {string}", "apiSymbol": "password", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -68158,7 +72666,7 @@ "label": "pathname", "signature": "`pathname` Type: {string}", "apiSymbol": "pathname", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -68187,7 +72695,7 @@ "label": "port", "signature": "`port` Type: {string}", "apiSymbol": "port", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -68216,7 +72724,7 @@ "label": "protocol", "signature": "`protocol` Type: {string}", "apiSymbol": "protocol", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -68245,7 +72753,7 @@ "label": "search", "signature": "`search` Type: {string}", "apiSymbol": "search", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -68274,7 +72782,7 @@ "label": "searchParams", "signature": "`searchParams` Type: {URLSearchParams}", "apiSymbol": "searchParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -68299,7 +72807,7 @@ "label": "username", "signature": "`username` Type: {string}", "apiSymbol": "username", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-url", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-url", "nodeStability": { "index": "2", "level": 2, @@ -68328,7 +72836,7 @@ "label": "URLPattern", "signature": "Class: `URLPattern`", "apiSymbol": "URLPattern", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-urlpattern", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-urlpattern", "nodeStability": { "index": "1", "level": 1, @@ -68353,7 +72861,7 @@ "label": "urlPattern.exec(input[, baseURL])", "signature": "`urlPattern.exec(input[, baseURL])`", "apiSymbol": "urlPattern.exec", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlpatternexecinput-baseurl", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlpatternexecinput-baseurl", "nodeStability": { "index": "1", "level": 1, @@ -68378,7 +72886,7 @@ "label": "urlPattern.test(input[, baseURL])", "signature": "`urlPattern.test(input[, baseURL])`", "apiSymbol": "urlPattern.test", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlpatterntestinput-baseurl", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlpatterntestinput-baseurl", "nodeStability": { "index": "1", "level": 1, @@ -68403,7 +72911,7 @@ "label": "URLSearchParams", "signature": "Class: `URLSearchParams`", "apiSymbol": "URLSearchParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#class-urlsearchparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#class-urlsearchparams", "nodeStability": { "index": "2", "level": 2, @@ -68428,7 +72936,7 @@ "label": "urlSearchParams.append(name, value)", "signature": "`urlSearchParams.append(name, value)`", "apiSymbol": "urlSearchParams.append", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamsappendname-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamsappendname-value", "nodeStability": { "index": "2", "level": 2, @@ -68453,7 +72961,7 @@ "label": "urlSearchParams.delete(name[, value])", "signature": "`urlSearchParams.delete(name[, value])`", "apiSymbol": "urlSearchParams.delete", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamsdeletename-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamsdeletename-value", "nodeStability": { "index": "2", "level": 2, @@ -68478,7 +72986,7 @@ "label": "urlSearchParams.entries()", "signature": "`urlSearchParams.entries()`", "apiSymbol": "urlSearchParams.entries", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamsentries", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamsentries", "nodeStability": { "index": "2", "level": 2, @@ -68503,7 +73011,7 @@ "label": "urlSearchParams.forEach(fn[, thisArg])", "signature": "`urlSearchParams.forEach(fn[, thisArg])`", "apiSymbol": "urlSearchParams.forEach", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamsforeachfn-thisarg", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamsforeachfn-thisarg", "nodeStability": { "index": "2", "level": 2, @@ -68528,7 +73036,7 @@ "label": "urlSearchParams.get(name)", "signature": "`urlSearchParams.get(name)`", "apiSymbol": "urlSearchParams.get", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamsgetname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamsgetname", "nodeStability": { "index": "2", "level": 2, @@ -68553,7 +73061,7 @@ "label": "urlSearchParams.getAll(name)", "signature": "`urlSearchParams.getAll(name)`", "apiSymbol": "urlSearchParams.getAll", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamsgetallname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamsgetallname", "nodeStability": { "index": "2", "level": 2, @@ -68578,7 +73086,7 @@ "label": "urlSearchParams.has(name[, value])", "signature": "`urlSearchParams.has(name[, value])`", "apiSymbol": "urlSearchParams.has", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamshasname-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamshasname-value", "nodeStability": { "index": "2", "level": 2, @@ -68603,7 +73111,7 @@ "label": "urlSearchParams.keys()", "signature": "`urlSearchParams.keys()`", "apiSymbol": "urlSearchParams.keys", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamskeys", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamskeys", "nodeStability": { "index": "2", "level": 2, @@ -68628,7 +73136,7 @@ "label": "urlSearchParams.set(name, value)", "signature": "`urlSearchParams.set(name, value)`", "apiSymbol": "urlSearchParams.set", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamssetname-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamssetname-value", "nodeStability": { "index": "2", "level": 2, @@ -68653,7 +73161,7 @@ "label": "urlSearchParams.sort()", "signature": "`urlSearchParams.sort()`", "apiSymbol": "urlSearchParams.sort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamssort", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamssort", "nodeStability": { "index": "2", "level": 2, @@ -68678,7 +73186,7 @@ "label": "urlSearchParams.toString()", "signature": "`urlSearchParams.toString()`", "apiSymbol": "urlSearchParams.toString", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamstostring", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamstostring", "nodeStability": { "index": "2", "level": 2, @@ -68703,7 +73211,7 @@ "label": "urlSearchParams.values()", "signature": "`urlSearchParams.values()`", "apiSymbol": "urlSearchParams.values", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamsvalues", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamsvalues", "nodeStability": { "index": "2", "level": 2, @@ -68728,7 +73236,7 @@ "label": "urlSearchParams[Symbol.iterator]()", "signature": "`urlSearchParams[Symbol.iterator]()`", "apiSymbol": "urlSearchParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamssymboliterator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamssymboliterator", "nodeStability": { "index": "2", "level": 2, @@ -68753,7 +73261,7 @@ "label": "urlSearchParams.size", "signature": "`urlSearchParams.size`", "apiSymbol": "urlSearchParams.size", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlsearchparamssize", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlsearchparamssize", "nodeStability": { "index": "2", "level": 2, @@ -68778,7 +73286,7 @@ "label": "url.domainToASCII(domain)", "signature": "`url.domainToASCII(domain)`", "apiSymbol": "url.domainToASCII", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urldomaintoasciidomain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urldomaintoasciidomain", "nodeStability": { "index": "2", "level": 2, @@ -68807,7 +73315,7 @@ "label": "url.domainToUnicode(domain)", "signature": "`url.domainToUnicode(domain)`", "apiSymbol": "url.domainToUnicode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urldomaintounicodedomain", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urldomaintounicodedomain", "nodeStability": { "index": "2", "level": 2, @@ -68836,7 +73344,7 @@ "label": "url.fileURLToPath(url[, options])", "signature": "`url.fileURLToPath(url[, options])`", "apiSymbol": "url.fileURLToPath", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlfileurltopathurl-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlfileurltopathurl-options", "nodeStability": { "index": "2", "level": 2, @@ -68866,7 +73374,7 @@ "label": "url.fileURLToPathBuffer(url[, options])", "signature": "`url.fileURLToPathBuffer(url[, options])`", "apiSymbol": "url.fileURLToPathBuffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlfileurltopathbufferurl-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlfileurltopathbufferurl-options", "nodeStability": { "index": "2", "level": 2, @@ -68896,7 +73404,7 @@ "label": "url.format(URL[, options])", "signature": "`url.format(URL[, options])`", "apiSymbol": "url.format", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlformaturl-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlformaturl-options", "nodeStability": { "index": "2", "level": 2, @@ -68928,7 +73436,7 @@ "label": "url.pathToFileURL(path[, options])", "signature": "`url.pathToFileURL(path[, options])`", "apiSymbol": "url.pathToFileURL", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlpathtofileurlpath-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlpathtofileurlpath-options", "nodeStability": { "index": "2", "level": 2, @@ -68958,7 +73466,7 @@ "label": "url.urlToHttpOptions(url)", "signature": "`url.urlToHttpOptions(url)`", "apiSymbol": "url.urlToHttpOptions", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlurltohttpoptionsurl", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlurltohttpoptionsurl", "nodeStability": { "index": "2", "level": 2, @@ -68983,7 +73491,7 @@ "label": "Legacy urlObject", "signature": "Legacy `urlObject`", "apiSymbol": "urlObject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#legacy-urlobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#legacy-urlobject", "nodeStability": { "index": "3", "level": 3, @@ -69014,7 +73522,7 @@ "label": "urlObject.auth", "signature": "`urlObject.auth`", "apiSymbol": "urlObject.auth", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlobjectauth", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlobjectauth", "nodeStability": { "index": "3", "level": 3, @@ -69045,7 +73553,7 @@ "label": "urlObject.hash", "signature": "`urlObject.hash`", "apiSymbol": "urlObject.hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlobjecthash", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlobjecthash", "nodeStability": { "index": "3", "level": 3, @@ -69076,7 +73584,7 @@ "label": "urlObject.host", "signature": "`urlObject.host`", "apiSymbol": "urlObject.host", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlobjecthost", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlobjecthost", "nodeStability": { "index": "3", "level": 3, @@ -69107,7 +73615,7 @@ "label": "urlObject.hostname", "signature": "`urlObject.hostname`", "apiSymbol": "urlObject.hostname", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlobjecthostname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlobjecthostname", "nodeStability": { "index": "3", "level": 3, @@ -69138,7 +73646,7 @@ "label": "urlObject.href", "signature": "`urlObject.href`", "apiSymbol": "urlObject.href", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlobjecthref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlobjecthref", "nodeStability": { "index": "3", "level": 3, @@ -69169,7 +73677,7 @@ "label": "urlObject.path", "signature": "`urlObject.path`", "apiSymbol": "urlObject.path", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlobjectpath", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlobjectpath", "nodeStability": { "index": "3", "level": 3, @@ -69200,7 +73708,7 @@ "label": "urlObject.pathname", "signature": "`urlObject.pathname`", "apiSymbol": "urlObject.pathname", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlobjectpathname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlobjectpathname", "nodeStability": { "index": "3", "level": 3, @@ -69231,7 +73739,7 @@ "label": "urlObject.port", "signature": "`urlObject.port`", "apiSymbol": "urlObject.port", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlobjectport", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlobjectport", "nodeStability": { "index": "3", "level": 3, @@ -69262,7 +73770,7 @@ "label": "urlObject.protocol", "signature": "`urlObject.protocol`", "apiSymbol": "urlObject.protocol", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlobjectprotocol", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlobjectprotocol", "nodeStability": { "index": "3", "level": 3, @@ -69293,7 +73801,7 @@ "label": "urlObject.query", "signature": "`urlObject.query`", "apiSymbol": "urlObject.query", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlobjectquery", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlobjectquery", "nodeStability": { "index": "3", "level": 3, @@ -69324,7 +73832,7 @@ "label": "urlObject.search", "signature": "`urlObject.search`", "apiSymbol": "urlObject.search", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlobjectsearch", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlobjectsearch", "nodeStability": { "index": "3", "level": 3, @@ -69355,7 +73863,7 @@ "label": "urlObject.slashes", "signature": "`urlObject.slashes`", "apiSymbol": "urlObject.slashes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlobjectslashes", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlobjectslashes", "nodeStability": { "index": "3", "level": 3, @@ -69386,7 +73894,7 @@ "label": "url.format(urlObject)", "signature": "`url.format(urlObject)`", "apiSymbol": "url.format", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlformaturlobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlformaturlobject", "nodeStability": { "index": "3", "level": 3, @@ -69418,7 +73926,7 @@ "label": "url.format(urlString)", "signature": "`url.format(urlString)`", "apiSymbol": "url.format", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlformaturlstring", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlformaturlstring", "nodeStability": { "index": "0", "level": 0, @@ -69450,7 +73958,7 @@ "label": "url.parse(urlString[, parseQueryString[, slashesDenoteHost]])", "signature": "`url.parse(urlString[, parseQueryString[, slashesDenoteHost]])`", "apiSymbol": "url.parse", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlparseurlstring-parsequerystring-slashesdenotehost", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlparseurlstring-parsequerystring-slashesdenotehost", "nodeStability": { "index": "0", "level": 0, @@ -69484,7 +73992,7 @@ "label": "url.resolve(from, to)", "signature": "`url.resolve(from, to)`", "apiSymbol": "url.resolve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/url.html#urlresolvefrom-to", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/url.html#urlresolvefrom-to", "nodeStability": { "index": "0", "level": 0, @@ -69515,7 +74023,7 @@ "label": "util._extend(target, source)", "signature": "`util._extend(target, source)`", "apiSymbol": "util._extend", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#util_extendtarget-source", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#util_extendtarget-source", "nodeStability": { "index": "0", "level": 0, @@ -69540,7 +74048,7 @@ "label": "util.isArray(object)", "signature": "`util.isArray(object)`", "apiSymbol": "util.isArray", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilisarrayobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilisarrayobject", "nodeStability": { "index": "0", "level": 0, @@ -69565,7 +74073,7 @@ "label": "util.MIMEType", "signature": "Class: `util.MIMEType`", "apiSymbol": "util.MIMEType", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#class-utilmimetype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#class-utilmimetype", "nodeStability": { "index": "2", "level": 2, @@ -69590,7 +74098,7 @@ "label": "mime.toString()", "signature": "`mime.toString()`", "apiSymbol": "mime.toString", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#mimetostring", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#mimetostring", "nodeStability": { "index": "2", "level": 2, @@ -69615,7 +74123,32 @@ "label": "mime.toJSON()", "signature": "`mime.toJSON()`", "apiSymbol": "mime.toJSON", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#mimetojson", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#mimetojson", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:util", + "tests": [] + } + } + }, + { + "id": "util:78d79ebcd11e", + "chapter": "util", + "label": "MIMEType.parse(string)", + "signature": "`MIMEType.parse(string)`", + "apiSymbol": "MIMEType.parse", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#mimetypeparsestring", "nodeStability": { "index": "2", "level": 2, @@ -69640,7 +74173,7 @@ "label": "type", "signature": "`type` Type: {string}", "apiSymbol": "type", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#class-utilmimetype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#class-utilmimetype", "nodeStability": { "index": "2", "level": 2, @@ -69665,7 +74198,7 @@ "label": "subtype", "signature": "`subtype` Type: {string}", "apiSymbol": "subtype", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#class-utilmimetype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#class-utilmimetype", "nodeStability": { "index": "2", "level": 2, @@ -69690,7 +74223,7 @@ "label": "essence", "signature": "`essence` Type: {string}", "apiSymbol": "essence", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#class-utilmimetype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#class-utilmimetype", "nodeStability": { "index": "2", "level": 2, @@ -69715,7 +74248,7 @@ "label": "params", "signature": "`params` Type: {MIMEParams}", "apiSymbol": "params", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#class-utilmimetype", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#class-utilmimetype", "nodeStability": { "index": "2", "level": 2, @@ -69740,7 +74273,7 @@ "label": "util.MIMEParams", "signature": "Class: `util.MIMEParams`", "apiSymbol": "util.MIMEParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#class-utilmimeparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#class-utilmimeparams", "nodeStability": { "index": "2", "level": 2, @@ -69765,7 +74298,7 @@ "label": "mimeParams.delete(name)", "signature": "`mimeParams.delete(name)`", "apiSymbol": "mimeParams.delete", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#mimeparamsdeletename", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#mimeparamsdeletename", "nodeStability": { "index": "2", "level": 2, @@ -69790,7 +74323,7 @@ "label": "mimeParams.entries()", "signature": "`mimeParams.entries()`", "apiSymbol": "mimeParams.entries", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#mimeparamsentries", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#mimeparamsentries", "nodeStability": { "index": "2", "level": 2, @@ -69815,7 +74348,7 @@ "label": "mimeParams.get(name)", "signature": "`mimeParams.get(name)`", "apiSymbol": "mimeParams.get", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#mimeparamsgetname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#mimeparamsgetname", "nodeStability": { "index": "2", "level": 2, @@ -69840,7 +74373,7 @@ "label": "mimeParams.has(name)", "signature": "`mimeParams.has(name)`", "apiSymbol": "mimeParams.has", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#mimeparamshasname", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#mimeparamshasname", "nodeStability": { "index": "2", "level": 2, @@ -69865,7 +74398,7 @@ "label": "mimeParams.keys()", "signature": "`mimeParams.keys()`", "apiSymbol": "mimeParams.keys", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#mimeparamskeys", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#mimeparamskeys", "nodeStability": { "index": "2", "level": 2, @@ -69890,7 +74423,7 @@ "label": "mimeParams.set(name, value)", "signature": "`mimeParams.set(name, value)`", "apiSymbol": "mimeParams.set", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#mimeparamssetname-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#mimeparamssetname-value", "nodeStability": { "index": "2", "level": 2, @@ -69915,7 +74448,7 @@ "label": "mimeParams.values()", "signature": "`mimeParams.values()`", "apiSymbol": "mimeParams.values", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#mimeparamsvalues", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#mimeparamsvalues", "nodeStability": { "index": "2", "level": 2, @@ -69940,7 +74473,7 @@ "label": "mimeParams[Symbol.iterator]()", "signature": "`mimeParams[Symbol.iterator]()`", "apiSymbol": "mimeParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#mimeparamssymboliterator", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#mimeparamssymboliterator", "nodeStability": { "index": "2", "level": 2, @@ -69965,7 +74498,7 @@ "label": "util.TextDecoder", "signature": "Class: `util.TextDecoder`", "apiSymbol": "util.TextDecoder", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#class-utiltextdecoder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#class-utiltextdecoder", "nodeStability": { "index": "2", "level": 2, @@ -69995,7 +74528,7 @@ "label": "Encodings supported when Node.js is built with the small-icu option", "signature": "Encodings supported when Node.js is built with the `small-icu` option", "apiSymbol": "small-icu", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#encodings-supported-when-nodejs-is-built-with-the-small-icu-option", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#encodings-supported-when-nodejs-is-built-with-the-small-icu-option", "nodeStability": { "index": "2", "level": 2, @@ -70020,7 +74553,7 @@ "label": "textDecoder.decode([input[, options]])", "signature": "`textDecoder.decode([input[, options]])`", "apiSymbol": "textDecoder.decode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#textdecoderdecodeinput-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#textdecoderdecodeinput-options", "nodeStability": { "index": "2", "level": 2, @@ -70050,7 +74583,7 @@ "label": "encoding", "signature": "`encoding` Type: {string}", "apiSymbol": "encoding", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#class-utiltextdecoder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#class-utiltextdecoder", "nodeStability": { "index": "2", "level": 2, @@ -70078,7 +74611,7 @@ "label": "fatal", "signature": "`fatal` Type: {boolean}", "apiSymbol": "fatal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#class-utiltextdecoder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#class-utiltextdecoder", "nodeStability": { "index": "2", "level": 2, @@ -70106,7 +74639,7 @@ "label": "ignoreBOM", "signature": "`ignoreBOM` Type: {boolean}", "apiSymbol": "ignoreBOM", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#class-utiltextdecoder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#class-utiltextdecoder", "nodeStability": { "index": "2", "level": 2, @@ -70134,7 +74667,7 @@ "label": "util.TextEncoder", "signature": "Class: `util.TextEncoder`", "apiSymbol": "util.TextEncoder", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#class-utiltextencoder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#class-utiltextencoder", "nodeStability": { "index": "2", "level": 2, @@ -70164,7 +74697,7 @@ "label": "textEncoder.encode([input])", "signature": "`textEncoder.encode([input])`", "apiSymbol": "textEncoder.encode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#textencoderencodeinput", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#textencoderencodeinput", "nodeStability": { "index": "2", "level": 2, @@ -70194,7 +74727,7 @@ "label": "textEncoder.encodeInto(src, dest)", "signature": "`textEncoder.encodeInto(src, dest)`", "apiSymbol": "textEncoder.encodeInto", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#textencoderencodeintosrc-dest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#textencoderencodeintosrc-dest", "nodeStability": { "index": "2", "level": 2, @@ -70223,7 +74756,7 @@ "label": "encoding", "signature": "`encoding` Type: {string}", "apiSymbol": "encoding", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#class-utiltextencoder", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#class-utiltextencoder", "nodeStability": { "index": "2", "level": 2, @@ -70252,7 +74785,7 @@ "label": "util.callbackify(original)", "signature": "`util.callbackify(original)`", "apiSymbol": "util.callbackify", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilcallbackifyoriginal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilcallbackifyoriginal", "nodeStability": { "index": "2", "level": 2, @@ -70281,7 +74814,7 @@ "label": "util.convertProcessSignalToExitCode(signal)", "signature": "`util.convertProcessSignalToExitCode(signal)`", "apiSymbol": "util.convertProcessSignalToExitCode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilconvertprocesssignaltoexitcodesignal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilconvertprocesssignaltoexitcodesignal", "nodeStability": { "index": "2", "level": 2, @@ -70306,7 +74839,7 @@ "label": "util.debuglog(section[, callback])", "signature": "`util.debuglog(section[, callback])`", "apiSymbol": "util.debuglog", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utildebuglogsection-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utildebuglogsection-callback", "nodeStability": { "index": "2", "level": 2, @@ -70335,7 +74868,7 @@ "label": "debuglog().enabled", "signature": "`debuglog().enabled`", "apiSymbol": "debuglog", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#debuglogenabled", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#debuglogenabled", "nodeStability": { "index": "2", "level": 2, @@ -70364,7 +74897,7 @@ "label": "util.debug(section)", "signature": "`util.debug(section)`", "apiSymbol": "util.debug", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utildebugsection", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utildebugsection", "nodeStability": { "index": "2", "level": 2, @@ -70392,7 +74925,7 @@ "label": "util.deprecate(fn, msg[, code[, options]])", "signature": "`util.deprecate(fn, msg[, code[, options]])`", "apiSymbol": "util.deprecate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utildeprecatefn-msg-code-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utildeprecatefn-msg-code-options", "nodeStability": { "index": "2", "level": 2, @@ -70416,13 +74949,63 @@ } } }, + { + "id": "util:90257f3f102f", + "chapter": "util", + "label": "util.debounce(fn, wait[, options])", + "signature": "`util.debounce(fn, wait[, options])`", + "apiSymbol": "util.debounce", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utildebouncefn-wait-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:util", + "tests": [] + } + } + }, + { + "id": "util:0cc4a80eb7db", + "chapter": "util", + "label": "util.throttle(fn, limit, interval[, options])", + "signature": "`util.throttle(fn, limit, interval[, options])`", + "apiSymbol": "util.throttle", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilthrottlefn-limit-interval-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:util", + "tests": [] + } + } + }, { "id": "util:dd79eb4f9e99", "chapter": "util", "label": "util.diff(actual, expected)", "signature": "`util.diff(actual, expected)`", "apiSymbol": "util.diff", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utildiffactual-expected", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utildiffactual-expected", "nodeStability": { "index": "1", "level": 1, @@ -70447,7 +75030,7 @@ "label": "util.format(format[, ...args])", "signature": "`util.format(format[, ...args])`", "apiSymbol": "util.format", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilformatformat-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilformatformat-args", "nodeStability": { "index": "2", "level": 2, @@ -70472,7 +75055,7 @@ "label": "util.formatWithOptions(inspectOptions, format[, ...args])", "signature": "`util.formatWithOptions(inspectOptions, format[, ...args])`", "apiSymbol": "util.formatWithOptions", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilformatwithoptionsinspectoptions-format-args", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilformatwithoptionsinspectoptions-format-args", "nodeStability": { "index": "2", "level": 2, @@ -70497,7 +75080,7 @@ "label": "util.getCallSites([frameCount][, options])", "signature": "`util.getCallSites([frameCount][, options])`", "apiSymbol": "util.getCallSites", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilgetcallsitesframecount-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilgetcallsitesframecount-options", "nodeStability": { "index": "1.1", "level": 1, @@ -70522,7 +75105,7 @@ "label": "util.getSystemErrorName(err)", "signature": "`util.getSystemErrorName(err)`", "apiSymbol": "util.getSystemErrorName", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilgetsystemerrornameerr", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilgetsystemerrornameerr", "nodeStability": { "index": "2", "level": 2, @@ -70552,7 +75135,7 @@ "label": "util.getSystemErrorMap()", "signature": "`util.getSystemErrorMap()`", "apiSymbol": "util.getSystemErrorMap", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilgetsystemerrormap", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilgetsystemerrormap", "nodeStability": { "index": "2", "level": 2, @@ -70582,7 +75165,7 @@ "label": "util.getSystemErrorMessage(err)", "signature": "`util.getSystemErrorMessage(err)`", "apiSymbol": "util.getSystemErrorMessage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilgetsystemerrormessageerr", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilgetsystemerrormessageerr", "nodeStability": { "index": "2", "level": 2, @@ -70612,7 +75195,7 @@ "label": "util.setTraceSigInt(enable)", "signature": "`util.setTraceSigInt(enable)`", "apiSymbol": "util.setTraceSigInt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilsettracesigintenable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilsettracesigintenable", "nodeStability": { "index": "2", "level": 2, @@ -70637,7 +75220,7 @@ "label": "util.inherits(constructor, superConstructor)", "signature": "`util.inherits(constructor, superConstructor)`", "apiSymbol": "util.inherits", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilinheritsconstructor-superconstructor", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilinheritsconstructor-superconstructor", "nodeStability": { "index": "3", "level": 3, @@ -70666,7 +75249,7 @@ "label": "util.inspect(object[, options])", "signature": "`util.inspect(object[, options])`", "apiSymbol": "util.inspect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilinspectobject-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilinspectobject-options", "nodeStability": { "index": "2", "level": 2, @@ -70691,7 +75274,7 @@ "label": "util.inspect(object[, showHidden[, depth[, colors]]])", "signature": "`util.inspect(object[, showHidden[, depth[, colors]]])`", "apiSymbol": "util.inspect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilinspectobject-showhidden-depth-colors", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilinspectobject-showhidden-depth-colors", "nodeStability": { "index": "2", "level": 2, @@ -70716,7 +75299,7 @@ "label": "custom", "signature": "`custom` Type: {symbol} that can be used to declare custom inspect functions.", "apiSymbol": "custom", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilinspectobject-showhidden-depth-colors", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilinspectobject-showhidden-depth-colors", "nodeStability": { "index": "2", "level": 2, @@ -70741,7 +75324,7 @@ "label": "util.inspect.defaultOptions", "signature": "`util.inspect.defaultOptions`", "apiSymbol": "util.inspect.defaultOptions", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilinspectdefaultoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilinspectdefaultoptions", "nodeStability": { "index": "2", "level": 2, @@ -70766,7 +75349,7 @@ "label": "Customizing util.inspect colors", "signature": "Customizing `util.inspect` colors", "apiSymbol": "util.inspect", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#customizing-utilinspect-colors", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#customizing-utilinspect-colors", "nodeStability": { "index": "2", "level": 2, @@ -70791,7 +75374,7 @@ "label": "util.isDeepStrictEqual(val1, val2[, options])", "signature": "`util.isDeepStrictEqual(val1, val2[, options])`", "apiSymbol": "util.isDeepStrictEqual", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilisdeepstrictequalval1-val2-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilisdeepstrictequalval1-val2-options", "nodeStability": { "index": "2", "level": 2, @@ -70816,13 +75399,38 @@ } } }, + { + "id": "util:e9e90e65a33a", + "chapter": "util", + "label": "util.markPromiseAsHandled(promise)", + "signature": "`util.markPromiseAsHandled(promise)`", + "apiSymbol": "util.markPromiseAsHandled", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilmarkpromiseashandledpromise", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:util", + "tests": [] + } + } + }, { "id": "util:96bd98b2e0c0", "chapter": "util", "label": "util.parseArgs([config])", "signature": "`util.parseArgs([config])`", "apiSymbol": "util.parseArgs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilparseargsconfig", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilparseargsconfig", "nodeStability": { "index": "2", "level": 2, @@ -70850,7 +75458,7 @@ "label": "parseArgs", "signature": "`parseArgs` `tokens`", "apiSymbol": "parseArgs", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#parseargs-tokens", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#parseargs-tokens", "nodeStability": { "index": "2", "level": 2, @@ -70878,7 +75486,7 @@ "label": "util.parseEnv(content)", "signature": "`util.parseEnv(content)`", "apiSymbol": "util.parseEnv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilparseenvcontent", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilparseenvcontent", "nodeStability": { "index": "2", "level": 2, @@ -70909,7 +75517,7 @@ "label": "util.promisify(original)", "signature": "`util.promisify(original)`", "apiSymbol": "util.promisify", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilpromisifyoriginal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilpromisifyoriginal", "nodeStability": { "index": "2", "level": 2, @@ -70938,7 +75546,7 @@ "label": "custom", "signature": "`custom` Type: {symbol} that can be used to declare custom promisified variants of functions, see [Custom promisified functions][].", "apiSymbol": "custom", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilpromisifyoriginal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilpromisifyoriginal", "nodeStability": { "index": "2", "level": 2, @@ -70963,7 +75571,7 @@ "label": "util.stripVTControlCharacters(str)", "signature": "`util.stripVTControlCharacters(str)`", "apiSymbol": "util.stripVTControlCharacters", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilstripvtcontrolcharactersstr", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilstripvtcontrolcharactersstr", "nodeStability": { "index": "2", "level": 2, @@ -70994,7 +75602,7 @@ "label": "util.styleText(format, text[, options])", "signature": "`util.styleText(format, text[, options])`", "apiSymbol": "util.styleText", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilstyletextformat-text-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilstyletextformat-text-options", "nodeStability": { "index": "2", "level": 2, @@ -71025,7 +75633,7 @@ "label": "util.toUSVString(string)", "signature": "`util.toUSVString(string)`", "apiSymbol": "util.toUSVString", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltousvstringstring", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltousvstringstring", "nodeStability": { "index": "2", "level": 2, @@ -71056,7 +75664,7 @@ "label": "util.transferableAbortController()", "signature": "`util.transferableAbortController()`", "apiSymbol": "util.transferableAbortController", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltransferableabortcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltransferableabortcontroller", "nodeStability": { "index": "2", "level": 2, @@ -71081,7 +75689,7 @@ "label": "util.transferableAbortSignal(signal)", "signature": "`util.transferableAbortSignal(signal)`", "apiSymbol": "util.transferableAbortSignal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltransferableabortsignalsignal", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltransferableabortsignalsignal", "nodeStability": { "index": "2", "level": 2, @@ -71106,7 +75714,7 @@ "label": "util.aborted(signal, resource)", "signature": "`util.aborted(signal, resource)`", "apiSymbol": "util.aborted", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utilabortedsignal-resource", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utilabortedsignal-resource", "nodeStability": { "index": "2", "level": 2, @@ -71131,7 +75739,7 @@ "label": "util.types", "signature": "`util.types`", "apiSymbol": "util.types", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypes", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypes", "nodeStability": { "index": "2", "level": 2, @@ -71161,7 +75769,7 @@ "label": "util.types.isAnyArrayBuffer(value)", "signature": "`util.types.isAnyArrayBuffer(value)`", "apiSymbol": "util.types.isAnyArrayBuffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisanyarraybuffervalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisanyarraybuffervalue", "nodeStability": { "index": "2", "level": 2, @@ -71191,7 +75799,7 @@ "label": "util.types.isArrayBufferView(value)", "signature": "`util.types.isArrayBufferView(value)`", "apiSymbol": "util.types.isArrayBufferView", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisarraybufferviewvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisarraybufferviewvalue", "nodeStability": { "index": "2", "level": 2, @@ -71221,7 +75829,7 @@ "label": "util.types.isArgumentsObject(value)", "signature": "`util.types.isArgumentsObject(value)`", "apiSymbol": "util.types.isArgumentsObject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisargumentsobjectvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisargumentsobjectvalue", "nodeStability": { "index": "2", "level": 2, @@ -71246,7 +75854,7 @@ "label": "util.types.isArrayBuffer(value)", "signature": "`util.types.isArrayBuffer(value)`", "apiSymbol": "util.types.isArrayBuffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisarraybuffervalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisarraybuffervalue", "nodeStability": { "index": "2", "level": 2, @@ -71276,7 +75884,7 @@ "label": "util.types.isAsyncFunction(value)", "signature": "`util.types.isAsyncFunction(value)`", "apiSymbol": "util.types.isAsyncFunction", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisasyncfunctionvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisasyncfunctionvalue", "nodeStability": { "index": "2", "level": 2, @@ -71306,7 +75914,7 @@ "label": "util.types.isBigInt64Array(value)", "signature": "`util.types.isBigInt64Array(value)`", "apiSymbol": "util.types.isBigInt64Array", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisbigint64arrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisbigint64arrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -71331,7 +75939,7 @@ "label": "util.types.isBigIntObject(value)", "signature": "`util.types.isBigIntObject(value)`", "apiSymbol": "util.types.isBigIntObject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisbigintobjectvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisbigintobjectvalue", "nodeStability": { "index": "2", "level": 2, @@ -71356,7 +75964,7 @@ "label": "util.types.isBigUint64Array(value)", "signature": "`util.types.isBigUint64Array(value)`", "apiSymbol": "util.types.isBigUint64Array", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisbiguint64arrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisbiguint64arrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -71381,7 +75989,7 @@ "label": "util.types.isBooleanObject(value)", "signature": "`util.types.isBooleanObject(value)`", "apiSymbol": "util.types.isBooleanObject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisbooleanobjectvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisbooleanobjectvalue", "nodeStability": { "index": "2", "level": 2, @@ -71406,7 +76014,7 @@ "label": "util.types.isBoxedPrimitive(value)", "signature": "`util.types.isBoxedPrimitive(value)`", "apiSymbol": "util.types.isBoxedPrimitive", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisboxedprimitivevalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisboxedprimitivevalue", "nodeStability": { "index": "2", "level": 2, @@ -71431,7 +76039,7 @@ "label": "util.types.isCryptoKey(value)", "signature": "`util.types.isCryptoKey(value)`", "apiSymbol": "util.types.isCryptoKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesiscryptokeyvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesiscryptokeyvalue", "nodeStability": { "index": "2", "level": 2, @@ -71456,7 +76064,7 @@ "label": "util.types.isDataView(value)", "signature": "`util.types.isDataView(value)`", "apiSymbol": "util.types.isDataView", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisdataviewvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisdataviewvalue", "nodeStability": { "index": "2", "level": 2, @@ -71486,7 +76094,7 @@ "label": "util.types.isDate(value)", "signature": "`util.types.isDate(value)`", "apiSymbol": "util.types.isDate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisdatevalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisdatevalue", "nodeStability": { "index": "2", "level": 2, @@ -71511,7 +76119,7 @@ "label": "util.types.isExternal(value)", "signature": "`util.types.isExternal(value)`", "apiSymbol": "util.types.isExternal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisexternalvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisexternalvalue", "nodeStability": { "index": "2", "level": 2, @@ -71536,7 +76144,7 @@ "label": "util.types.isFloat16Array(value)", "signature": "`util.types.isFloat16Array(value)`", "apiSymbol": "util.types.isFloat16Array", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisfloat16arrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisfloat16arrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -71561,7 +76169,7 @@ "label": "util.types.isFloat32Array(value)", "signature": "`util.types.isFloat32Array(value)`", "apiSymbol": "util.types.isFloat32Array", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisfloat32arrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisfloat32arrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -71591,7 +76199,7 @@ "label": "util.types.isFloat64Array(value)", "signature": "`util.types.isFloat64Array(value)`", "apiSymbol": "util.types.isFloat64Array", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisfloat64arrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisfloat64arrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -71621,7 +76229,7 @@ "label": "util.types.isGeneratorFunction(value)", "signature": "`util.types.isGeneratorFunction(value)`", "apiSymbol": "util.types.isGeneratorFunction", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisgeneratorfunctionvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisgeneratorfunctionvalue", "nodeStability": { "index": "2", "level": 2, @@ -71651,7 +76259,7 @@ "label": "util.types.isGeneratorObject(value)", "signature": "`util.types.isGeneratorObject(value)`", "apiSymbol": "util.types.isGeneratorObject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisgeneratorobjectvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisgeneratorobjectvalue", "nodeStability": { "index": "2", "level": 2, @@ -71681,7 +76289,7 @@ "label": "util.types.isInt8Array(value)", "signature": "`util.types.isInt8Array(value)`", "apiSymbol": "util.types.isInt8Array", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisint8arrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisint8arrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -71711,7 +76319,7 @@ "label": "util.types.isInt16Array(value)", "signature": "`util.types.isInt16Array(value)`", "apiSymbol": "util.types.isInt16Array", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisint16arrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisint16arrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -71741,7 +76349,7 @@ "label": "util.types.isInt32Array(value)", "signature": "`util.types.isInt32Array(value)`", "apiSymbol": "util.types.isInt32Array", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisint32arrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisint32arrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -71771,7 +76379,7 @@ "label": "util.types.isKeyObject(value)", "signature": "`util.types.isKeyObject(value)`", "apiSymbol": "util.types.isKeyObject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesiskeyobjectvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesiskeyobjectvalue", "nodeStability": { "index": "2", "level": 2, @@ -71796,7 +76404,7 @@ "label": "util.types.isMap(value)", "signature": "`util.types.isMap(value)`", "apiSymbol": "util.types.isMap", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesismapvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesismapvalue", "nodeStability": { "index": "2", "level": 2, @@ -71826,7 +76434,7 @@ "label": "util.types.isMapIterator(value)", "signature": "`util.types.isMapIterator(value)`", "apiSymbol": "util.types.isMapIterator", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesismapiteratorvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesismapiteratorvalue", "nodeStability": { "index": "2", "level": 2, @@ -71851,7 +76459,7 @@ "label": "util.types.isModuleNamespaceObject(value)", "signature": "`util.types.isModuleNamespaceObject(value)`", "apiSymbol": "util.types.isModuleNamespaceObject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesismodulenamespaceobjectvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesismodulenamespaceobjectvalue", "nodeStability": { "index": "2", "level": 2, @@ -71876,7 +76484,7 @@ "label": "util.types.isNativeError(value)", "signature": "`util.types.isNativeError(value)`", "apiSymbol": "util.types.isNativeError", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisnativeerrorvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisnativeerrorvalue", "nodeStability": { "index": "0", "level": 0, @@ -71906,7 +76514,7 @@ "label": "util.types.isNumberObject(value)", "signature": "`util.types.isNumberObject(value)`", "apiSymbol": "util.types.isNumberObject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisnumberobjectvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisnumberobjectvalue", "nodeStability": { "index": "2", "level": 2, @@ -71931,7 +76539,7 @@ "label": "util.types.isPromise(value)", "signature": "`util.types.isPromise(value)`", "apiSymbol": "util.types.isPromise", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesispromisevalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesispromisevalue", "nodeStability": { "index": "2", "level": 2, @@ -71961,7 +76569,7 @@ "label": "util.types.isProxy(value)", "signature": "`util.types.isProxy(value)`", "apiSymbol": "util.types.isProxy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisproxyvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisproxyvalue", "nodeStability": { "index": "2", "level": 2, @@ -71991,7 +76599,7 @@ "label": "util.types.isRegExp(value)", "signature": "`util.types.isRegExp(value)`", "apiSymbol": "util.types.isRegExp", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisregexpvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisregexpvalue", "nodeStability": { "index": "2", "level": 2, @@ -72021,7 +76629,7 @@ "label": "util.types.isSet(value)", "signature": "`util.types.isSet(value)`", "apiSymbol": "util.types.isSet", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesissetvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesissetvalue", "nodeStability": { "index": "2", "level": 2, @@ -72051,7 +76659,7 @@ "label": "util.types.isSetIterator(value)", "signature": "`util.types.isSetIterator(value)`", "apiSymbol": "util.types.isSetIterator", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesissetiteratorvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesissetiteratorvalue", "nodeStability": { "index": "2", "level": 2, @@ -72076,7 +76684,7 @@ "label": "util.types.isSharedArrayBuffer(value)", "signature": "`util.types.isSharedArrayBuffer(value)`", "apiSymbol": "util.types.isSharedArrayBuffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesissharedarraybuffervalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesissharedarraybuffervalue", "nodeStability": { "index": "2", "level": 2, @@ -72101,7 +76709,7 @@ "label": "util.types.isStringObject(value)", "signature": "`util.types.isStringObject(value)`", "apiSymbol": "util.types.isStringObject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisstringobjectvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisstringobjectvalue", "nodeStability": { "index": "2", "level": 2, @@ -72126,7 +76734,7 @@ "label": "util.types.isSymbolObject(value)", "signature": "`util.types.isSymbolObject(value)`", "apiSymbol": "util.types.isSymbolObject", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesissymbolobjectvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesissymbolobjectvalue", "nodeStability": { "index": "2", "level": 2, @@ -72151,7 +76759,7 @@ "label": "util.types.isTypedArray(value)", "signature": "`util.types.isTypedArray(value)`", "apiSymbol": "util.types.isTypedArray", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesistypedarrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesistypedarrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -72181,7 +76789,7 @@ "label": "util.types.isUint8Array(value)", "signature": "`util.types.isUint8Array(value)`", "apiSymbol": "util.types.isUint8Array", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisuint8arrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisuint8arrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -72211,7 +76819,7 @@ "label": "util.types.isUint8ClampedArray(value)", "signature": "`util.types.isUint8ClampedArray(value)`", "apiSymbol": "util.types.isUint8ClampedArray", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisuint8clampedarrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisuint8clampedarrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -72241,7 +76849,7 @@ "label": "util.types.isUint16Array(value)", "signature": "`util.types.isUint16Array(value)`", "apiSymbol": "util.types.isUint16Array", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisuint16arrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisuint16arrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -72271,7 +76879,7 @@ "label": "util.types.isUint32Array(value)", "signature": "`util.types.isUint32Array(value)`", "apiSymbol": "util.types.isUint32Array", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisuint32arrayvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisuint32arrayvalue", "nodeStability": { "index": "2", "level": 2, @@ -72301,7 +76909,7 @@ "label": "util.types.isWeakMap(value)", "signature": "`util.types.isWeakMap(value)`", "apiSymbol": "util.types.isWeakMap", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisweakmapvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisweakmapvalue", "nodeStability": { "index": "2", "level": 2, @@ -72331,7 +76939,7 @@ "label": "util.types.isWeakSet(value)", "signature": "`util.types.isWeakSet(value)`", "apiSymbol": "util.types.isWeakSet", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/util.html#utiltypesisweaksetvalue", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/util.html#utiltypesisweaksetvalue", "nodeStability": { "index": "2", "level": 2, @@ -72361,7 +76969,7 @@ "label": "before(promise)", "signature": "`before(promise)`", "apiSymbol": "before", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/v8.html#beforepromise", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/v8.html#beforepromise", "nodeStability": null, "priority": "normal", "tiers": { @@ -72383,7 +76991,7 @@ "label": "after(promise)", "signature": "`after(promise)`", "apiSymbol": "after", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/v8.html#afterpromise", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/v8.html#afterpromise", "nodeStability": null, "priority": "normal", "tiers": { @@ -72405,7 +77013,7 @@ "label": "Algorithm", "signature": "Class: `Algorithm`", "apiSymbol": "Algorithm", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-algorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-algorithm", "nodeStability": { "index": "2", "level": 2, @@ -72430,7 +77038,7 @@ "label": "name", "signature": "`name` Type: {string}", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-algorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-algorithm", "nodeStability": { "index": "2", "level": 2, @@ -72455,7 +77063,7 @@ "label": "AeadParams", "signature": "Class: `AeadParams`", "apiSymbol": "AeadParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aeadparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aeadparams", "nodeStability": { "index": "2", "level": 2, @@ -72480,7 +77088,7 @@ "label": "additionalData", "signature": "`additionalData` Type: {ArrayBuffer|TypedArray|DataView|Buffer|undefined}", "apiSymbol": "additionalData", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aeadparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aeadparams", "nodeStability": { "index": "2", "level": 2, @@ -72505,7 +77113,7 @@ "label": "iv", "signature": "`iv` Type: {ArrayBuffer|TypedArray|DataView|Buffer}", "apiSymbol": "iv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aeadparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aeadparams", "nodeStability": { "index": "2", "level": 2, @@ -72530,7 +77138,7 @@ "label": "name", "signature": "`name` Type: {string} Must be `'AES-GCM'`, `'AES-OCB'`, or `'ChaCha20-Poly1305'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aeadparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aeadparams", "nodeStability": { "index": "2", "level": 2, @@ -72555,7 +77163,7 @@ "label": "tagLength", "signature": "`tagLength` Type: {number} The size in bits of the generated authentication tag.", "apiSymbol": "tagLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aeadparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aeadparams", "nodeStability": { "index": "2", "level": 2, @@ -72580,7 +77188,7 @@ "label": "AesDerivedKeyParams", "signature": "Class: `AesDerivedKeyParams`", "apiSymbol": "AesDerivedKeyParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aesderivedkeyparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aesderivedkeyparams", "nodeStability": { "index": "2", "level": 2, @@ -72605,7 +77213,7 @@ "label": "name", "signature": "`name` Type: {string} Must be one of `'AES-CBC'`, `'AES-CTR'`, `'AES-GCM'`, `'AES-OCB'`, or `'AES-KW'`", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aesderivedkeyparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aesderivedkeyparams", "nodeStability": { "index": "2", "level": 2, @@ -72630,7 +77238,7 @@ "label": "length", "signature": "`length` Type: {number}", "apiSymbol": "length", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aesderivedkeyparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aesderivedkeyparams", "nodeStability": { "index": "2", "level": 2, @@ -72655,7 +77263,7 @@ "label": "AesCbcParams", "signature": "Class: `AesCbcParams`", "apiSymbol": "AesCbcParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aescbcparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aescbcparams", "nodeStability": { "index": "2", "level": 2, @@ -72680,7 +77288,7 @@ "label": "iv", "signature": "`iv` Type: {ArrayBuffer|TypedArray|DataView|Buffer}", "apiSymbol": "iv", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aescbcparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aescbcparams", "nodeStability": { "index": "2", "level": 2, @@ -72705,7 +77313,7 @@ "label": "name", "signature": "`name` Type: {string} Must be `'AES-CBC'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aescbcparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aescbcparams", "nodeStability": { "index": "2", "level": 2, @@ -72730,7 +77338,7 @@ "label": "AesCtrParams", "signature": "Class: `AesCtrParams`", "apiSymbol": "AesCtrParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aesctrparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aesctrparams", "nodeStability": { "index": "2", "level": 2, @@ -72755,7 +77363,7 @@ "label": "counter", "signature": "`counter` Type: {ArrayBuffer|TypedArray|DataView|Buffer}", "apiSymbol": "counter", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aesctrparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aesctrparams", "nodeStability": { "index": "2", "level": 2, @@ -72780,7 +77388,7 @@ "label": "length", "signature": "`length` Type: {number} The number of bits in the `aesCtrParams.counter` that are to be used as the counter.", "apiSymbol": "length", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aesctrparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aesctrparams", "nodeStability": { "index": "2", "level": 2, @@ -72805,7 +77413,7 @@ "label": "name", "signature": "`name` Type: {string} Must be `'AES-CTR'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aesctrparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aesctrparams", "nodeStability": { "index": "2", "level": 2, @@ -72830,7 +77438,7 @@ "label": "AesKeyAlgorithm", "signature": "Class: `AesKeyAlgorithm`", "apiSymbol": "AesKeyAlgorithm", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aeskeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aeskeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -72855,7 +77463,7 @@ "label": "length", "signature": "`length` Type: {number}", "apiSymbol": "length", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aeskeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aeskeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -72880,7 +77488,7 @@ "label": "name", "signature": "`name` Type: {string}", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aeskeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aeskeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -72905,7 +77513,7 @@ "label": "AesKeyGenParams", "signature": "Class: `AesKeyGenParams`", "apiSymbol": "AesKeyGenParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aeskeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aeskeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -72930,7 +77538,7 @@ "label": "length", "signature": "`length` Type: {number}", "apiSymbol": "length", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aeskeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aeskeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -72955,7 +77563,7 @@ "label": "name", "signature": "`name` Type: {string} Must be one of `'AES-CBC'`, `'AES-CTR'`, `'AES-GCM'`, or `'AES-KW'`", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-aeskeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-aeskeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -72980,7 +77588,7 @@ "label": "Argon2Params", "signature": "Class: `Argon2Params`", "apiSymbol": "Argon2Params", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-argon2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-argon2params", "nodeStability": { "index": "2", "level": 2, @@ -73005,7 +77613,7 @@ "label": "associatedData", "signature": "`associatedData` Type: {ArrayBuffer|TypedArray|DataView|Buffer}", "apiSymbol": "associatedData", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-argon2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-argon2params", "nodeStability": { "index": "2", "level": 2, @@ -73030,7 +77638,7 @@ "label": "memory", "signature": "`memory` Type: {number}", "apiSymbol": "memory", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-argon2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-argon2params", "nodeStability": { "index": "2", "level": 2, @@ -73055,7 +77663,7 @@ "label": "name", "signature": "`name` Type: {string} Must be one of `'Argon2d'`, `'Argon2i'`, or `'Argon2id'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-argon2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-argon2params", "nodeStability": { "index": "2", "level": 2, @@ -73080,7 +77688,7 @@ "label": "nonce", "signature": "`nonce` Type: {ArrayBuffer|TypedArray|DataView|Buffer}", "apiSymbol": "nonce", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-argon2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-argon2params", "nodeStability": { "index": "2", "level": 2, @@ -73105,7 +77713,7 @@ "label": "parallelism", "signature": "`parallelism` Type: {number}", "apiSymbol": "parallelism", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-argon2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-argon2params", "nodeStability": { "index": "2", "level": 2, @@ -73130,7 +77738,7 @@ "label": "passes", "signature": "`passes` Type: {number}", "apiSymbol": "passes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-argon2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-argon2params", "nodeStability": { "index": "2", "level": 2, @@ -73155,7 +77763,7 @@ "label": "secretValue", "signature": "`secretValue` Type: {ArrayBuffer|TypedArray|DataView|Buffer}", "apiSymbol": "secretValue", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-argon2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-argon2params", "nodeStability": { "index": "2", "level": 2, @@ -73180,7 +77788,7 @@ "label": "version", "signature": "`version` Type: {number}", "apiSymbol": "version", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-argon2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-argon2params", "nodeStability": { "index": "2", "level": 2, @@ -73205,7 +77813,7 @@ "label": "ContextParams", "signature": "Class: `ContextParams`", "apiSymbol": "ContextParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-contextparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-contextparams", "nodeStability": { "index": "2", "level": 2, @@ -73225,12 +77833,12 @@ } }, { - "id": "webcrypto:348599f69c92", + "id": "webcrypto:f03c4c689ade", "chapter": "webcrypto", "label": "name", - "signature": "`name` Type: {string} Must be `Ed448`[^secure-curves], `'ML-DSA-44'`[^modern-algos], `'ML-DSA-65'`[^modern-algos], or `'ML-DSA-87'`[^modern-algos].", + "signature": "`name` Type: {string} Must be `'Ed448'`[^secure-curves], `'ML-DSA-44'`[^modern-algos], `'ML-DSA-65'`[^modern-algos], or `'ML-DSA-87'`[^modern-algos].", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-contextparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-contextparams", "nodeStability": { "index": "2", "level": 2, @@ -73255,7 +77863,7 @@ "label": "context", "signature": "`context` Type: {ArrayBuffer|TypedArray|DataView|Buffer|undefined}", "apiSymbol": "context", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-contextparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-contextparams", "nodeStability": { "index": "2", "level": 2, @@ -73280,7 +77888,7 @@ "label": "CShakeParams", "signature": "Class: `CShakeParams`", "apiSymbol": "CShakeParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-cshakeparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-cshakeparams", "nodeStability": { "index": "2", "level": 2, @@ -73300,12 +77908,12 @@ } }, { - "id": "webcrypto:e97ed4559769", + "id": "webcrypto:fbbc457c6c6e", "chapter": "webcrypto", "label": "name", - "signature": "`name` Type: {string} Must be `'cSHAKE128'`[^modern-algos] or `'cSHAKE256'`[^modern-algos]", + "signature": "`name` Type: {string} Must be `'cSHAKE128'`[^modern-algos] or `'cSHAKE256'`[^modern-algos].", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-cshakeparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-cshakeparams", "nodeStability": { "index": "2", "level": 2, @@ -73330,7 +77938,7 @@ "label": "outputLength", "signature": "`outputLength` Type: {number} represents the requested output length in bits.", "apiSymbol": "outputLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-cshakeparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-cshakeparams", "nodeStability": { "index": "2", "level": 2, @@ -73355,7 +77963,7 @@ "label": "functionName", "signature": "`functionName` Type: {ArrayBuffer|TypedArray|DataView|Buffer|undefined}", "apiSymbol": "functionName", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-cshakeparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-cshakeparams", "nodeStability": { "index": "2", "level": 2, @@ -73380,7 +77988,7 @@ "label": "customization", "signature": "`customization` Type: {ArrayBuffer|TypedArray|DataView|Buffer|undefined}", "apiSymbol": "customization", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-cshakeparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-cshakeparams", "nodeStability": { "index": "2", "level": 2, @@ -73405,7 +78013,7 @@ "label": "EcdhKeyDeriveParams", "signature": "Class: `EcdhKeyDeriveParams`", "apiSymbol": "EcdhKeyDeriveParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-ecdhkeyderiveparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-ecdhkeyderiveparams", "nodeStability": { "index": "2", "level": 2, @@ -73430,7 +78038,7 @@ "label": "name", "signature": "`name` Type: {string} Must be `'ECDH'`, `'X25519'`, or `'X448'`[^secure-curves].", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-ecdhkeyderiveparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-ecdhkeyderiveparams", "nodeStability": { "index": "2", "level": 2, @@ -73455,7 +78063,7 @@ "label": "public", "signature": "`public` Type: {CryptoKey}", "apiSymbol": "public", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-ecdhkeyderiveparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-ecdhkeyderiveparams", "nodeStability": { "index": "2", "level": 2, @@ -73480,7 +78088,7 @@ "label": "EcdsaParams", "signature": "Class: `EcdsaParams`", "apiSymbol": "EcdsaParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-ecdsaparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-ecdsaparams", "nodeStability": { "index": "2", "level": 2, @@ -73505,7 +78113,7 @@ "label": "hash", "signature": "`hash` Type: {string|Algorithm}", "apiSymbol": "hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-ecdsaparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-ecdsaparams", "nodeStability": { "index": "2", "level": 2, @@ -73540,7 +78148,7 @@ "label": "name", "signature": "`name` Type: {string} Must be `'ECDSA'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-ecdsaparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-ecdsaparams", "nodeStability": { "index": "2", "level": 2, @@ -73565,7 +78173,7 @@ "label": "EcKeyAlgorithm", "signature": "Class: `EcKeyAlgorithm`", "apiSymbol": "EcKeyAlgorithm", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-eckeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-eckeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -73590,7 +78198,7 @@ "label": "name", "signature": "`name` Type: {string}", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-eckeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-eckeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -73615,7 +78223,7 @@ "label": "namedCurve", "signature": "`namedCurve` Type: {string}", "apiSymbol": "namedCurve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-eckeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-eckeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -73640,7 +78248,7 @@ "label": "EcKeyGenParams", "signature": "Class: `EcKeyGenParams`", "apiSymbol": "EcKeyGenParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-eckeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-eckeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -73665,7 +78273,7 @@ "label": "name", "signature": "`name` Type: {string} Must be one of `'ECDSA'` or `'ECDH'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-eckeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-eckeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -73690,7 +78298,7 @@ "label": "namedCurve", "signature": "`namedCurve` Type: {string} Must be one of `'P-256'`, `'P-384'`, `'P-521'`.", "apiSymbol": "namedCurve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-eckeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-eckeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -73715,7 +78323,7 @@ "label": "EcKeyImportParams", "signature": "Class: `EcKeyImportParams`", "apiSymbol": "EcKeyImportParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-eckeyimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-eckeyimportparams", "nodeStability": { "index": "2", "level": 2, @@ -73740,7 +78348,7 @@ "label": "name", "signature": "`name` Type: {string} Must be one of `'ECDSA'` or `'ECDH'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-eckeyimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-eckeyimportparams", "nodeStability": { "index": "2", "level": 2, @@ -73765,7 +78373,7 @@ "label": "namedCurve", "signature": "`namedCurve` Type: {string} Must be one of `'P-256'`, `'P-384'`, `'P-521'`.", "apiSymbol": "namedCurve", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-eckeyimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-eckeyimportparams", "nodeStability": { "index": "2", "level": 2, @@ -73790,7 +78398,7 @@ "label": "EncapsulatedBits", "signature": "Class: `EncapsulatedBits`", "apiSymbol": "EncapsulatedBits", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-encapsulatedbits", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-encapsulatedbits", "nodeStability": { "index": "2", "level": 2, @@ -73815,7 +78423,7 @@ "label": "ciphertext", "signature": "`ciphertext` Type: {ArrayBuffer}", "apiSymbol": "ciphertext", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-encapsulatedbits", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-encapsulatedbits", "nodeStability": { "index": "2", "level": 2, @@ -73840,7 +78448,7 @@ "label": "sharedKey", "signature": "`sharedKey` Type: {ArrayBuffer}", "apiSymbol": "sharedKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-encapsulatedbits", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-encapsulatedbits", "nodeStability": { "index": "2", "level": 2, @@ -73865,7 +78473,7 @@ "label": "EncapsulatedKey", "signature": "Class: `EncapsulatedKey`", "apiSymbol": "EncapsulatedKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-encapsulatedkey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-encapsulatedkey", "nodeStability": { "index": "2", "level": 2, @@ -73890,7 +78498,7 @@ "label": "ciphertext", "signature": "`ciphertext` Type: {ArrayBuffer}", "apiSymbol": "ciphertext", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-encapsulatedkey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-encapsulatedkey", "nodeStability": { "index": "2", "level": 2, @@ -73915,7 +78523,7 @@ "label": "sharedKey", "signature": "`sharedKey` Type: {CryptoKey}", "apiSymbol": "sharedKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-encapsulatedkey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-encapsulatedkey", "nodeStability": { "index": "2", "level": 2, @@ -73940,7 +78548,7 @@ "label": "HkdfParams", "signature": "Class: `HkdfParams`", "apiSymbol": "HkdfParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hkdfparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hkdfparams", "nodeStability": { "index": "2", "level": 2, @@ -73965,7 +78573,7 @@ "label": "hash", "signature": "`hash` Type: {string|Algorithm}", "apiSymbol": "hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hkdfparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hkdfparams", "nodeStability": { "index": "2", "level": 2, @@ -74000,7 +78608,7 @@ "label": "info", "signature": "`info` Type: {ArrayBuffer|TypedArray|DataView|Buffer}", "apiSymbol": "info", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hkdfparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hkdfparams", "nodeStability": { "index": "2", "level": 2, @@ -74025,7 +78633,7 @@ "label": "name", "signature": "`name` Type: {string} Must be `'HKDF'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hkdfparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hkdfparams", "nodeStability": { "index": "2", "level": 2, @@ -74050,7 +78658,7 @@ "label": "salt", "signature": "`salt` Type: {ArrayBuffer|TypedArray|DataView|Buffer}", "apiSymbol": "salt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hkdfparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hkdfparams", "nodeStability": { "index": "2", "level": 2, @@ -74075,7 +78683,7 @@ "label": "HmacImportParams", "signature": "Class: `HmacImportParams`", "apiSymbol": "HmacImportParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hmacimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hmacimportparams", "nodeStability": { "index": "2", "level": 2, @@ -74100,7 +78708,7 @@ "label": "hash", "signature": "`hash` Type: {string|Algorithm}", "apiSymbol": "hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hmacimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hmacimportparams", "nodeStability": { "index": "2", "level": 2, @@ -74135,7 +78743,7 @@ "label": "length", "signature": "`length` Type: {number}", "apiSymbol": "length", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hmacimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hmacimportparams", "nodeStability": { "index": "2", "level": 2, @@ -74160,7 +78768,7 @@ "label": "name", "signature": "`name` Type: {string} Must be `'HMAC'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hmacimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hmacimportparams", "nodeStability": { "index": "2", "level": 2, @@ -74185,7 +78793,7 @@ "label": "HmacKeyAlgorithm", "signature": "Class: `HmacKeyAlgorithm`", "apiSymbol": "HmacKeyAlgorithm", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hmackeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hmackeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -74210,7 +78818,7 @@ "label": "hash", "signature": "`hash` Type: {Algorithm}", "apiSymbol": "hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hmackeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hmackeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -74245,7 +78853,7 @@ "label": "length", "signature": "`length` Type: {number}", "apiSymbol": "length", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hmackeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hmackeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -74270,7 +78878,7 @@ "label": "name", "signature": "`name` Type: {string}", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hmackeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hmackeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -74295,7 +78903,7 @@ "label": "HmacKeyGenParams", "signature": "Class: `HmacKeyGenParams`", "apiSymbol": "HmacKeyGenParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hmackeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hmackeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -74320,7 +78928,7 @@ "label": "hash", "signature": "`hash` Type: {string|Algorithm}", "apiSymbol": "hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hmackeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hmackeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -74355,7 +78963,7 @@ "label": "length", "signature": "`length` Type: {number}", "apiSymbol": "length", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hmackeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hmackeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -74380,7 +78988,7 @@ "label": "name", "signature": "`name` Type: {string} Must be `'HMAC'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-hmackeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-hmackeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -74405,7 +79013,7 @@ "label": "KeyAlgorithm", "signature": "Class: `KeyAlgorithm`", "apiSymbol": "KeyAlgorithm", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-keyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-keyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -74430,7 +79038,107 @@ "label": "name", "signature": "`name` Type: {string}", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-keyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-keyalgorithm", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:webcrypto", + "tests": [] + } + } + }, + { + "id": "webcrypto:2bc7e9909260", + "chapter": "webcrypto", + "label": "KangarooTwelveParams", + "signature": "Class: `KangarooTwelveParams`", + "apiSymbol": "KangarooTwelveParams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kangarootwelveparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:webcrypto", + "tests": [] + } + } + }, + { + "id": "webcrypto:2f2a2546b394", + "chapter": "webcrypto", + "label": "customization", + "signature": "`customization` Type: {ArrayBuffer|TypedArray|DataView|Buffer|undefined}", + "apiSymbol": "customization", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kangarootwelveparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:webcrypto", + "tests": [] + } + } + }, + { + "id": "webcrypto:f70b118f8060", + "chapter": "webcrypto", + "label": "name", + "signature": "`name` Type: {string} Must be `'KT128'`[^modern-algos] or `'KT256'`[^modern-algos]", + "apiSymbol": "name", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kangarootwelveparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:webcrypto", + "tests": [] + } + } + }, + { + "id": "webcrypto:0c10b01b7537", + "chapter": "webcrypto", + "label": "outputLength", + "signature": "`outputLength` Type: {number} represents the requested output length in bits.", + "apiSymbol": "outputLength", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kangarootwelveparams", "nodeStability": { "index": "2", "level": 2, @@ -74455,7 +79163,7 @@ "label": "KmacImportParams", "signature": "Class: `KmacImportParams`", "apiSymbol": "KmacImportParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmacimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmacimportparams", "nodeStability": { "index": "2", "level": 2, @@ -74480,7 +79188,7 @@ "label": "length", "signature": "`length` Type: {number}", "apiSymbol": "length", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmacimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmacimportparams", "nodeStability": { "index": "2", "level": 2, @@ -74505,7 +79213,7 @@ "label": "name", "signature": "`name` Type: {string} Must be `'KMAC128'` or `'KMAC256'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmacimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmacimportparams", "nodeStability": { "index": "2", "level": 2, @@ -74530,7 +79238,7 @@ "label": "KmacKeyAlgorithm", "signature": "Class: `KmacKeyAlgorithm`", "apiSymbol": "KmacKeyAlgorithm", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmackeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmackeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -74555,7 +79263,7 @@ "label": "length", "signature": "`length` Type: {number}", "apiSymbol": "length", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmackeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmackeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -74580,7 +79288,7 @@ "label": "name", "signature": "`name` Type: {string}", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmackeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmackeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -74605,7 +79313,7 @@ "label": "KmacKeyGenParams", "signature": "Class: `KmacKeyGenParams`", "apiSymbol": "KmacKeyGenParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmackeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmackeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -74630,7 +79338,7 @@ "label": "length", "signature": "`length` Type: {number}", "apiSymbol": "length", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmackeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmackeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -74655,7 +79363,7 @@ "label": "name", "signature": "`name` Type: {string} Must be `'KMAC128'` or `'KMAC256'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmackeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmackeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -74680,7 +79388,7 @@ "label": "KmacParams", "signature": "Class: `KmacParams`", "apiSymbol": "KmacParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmacparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmacparams", "nodeStability": { "index": "2", "level": 2, @@ -74705,7 +79413,7 @@ "label": "algorithm", "signature": "`algorithm` Type: {string} Must be `'KMAC128'` or `'KMAC256'`.", "apiSymbol": "algorithm", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmacparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmacparams", "nodeStability": { "index": "2", "level": 2, @@ -74725,12 +79433,12 @@ } }, { - "id": "webcrypto:82fe1baefa90", + "id": "webcrypto:02a1dd7526a6", "chapter": "webcrypto", "label": "outputLength", - "signature": "`outputLength` Type: {number}", + "signature": "`outputLength` Type: {number} represents the requested output length in bits.", "apiSymbol": "outputLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmacparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmacparams", "nodeStability": { "index": "2", "level": 2, @@ -74755,7 +79463,7 @@ "label": "customization", "signature": "`customization` Type: {ArrayBuffer|TypedArray|DataView|Buffer|undefined}", "apiSymbol": "customization", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-kmacparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-kmacparams", "nodeStability": { "index": "2", "level": 2, @@ -74780,7 +79488,7 @@ "label": "Pbkdf2Params", "signature": "Class: `Pbkdf2Params`", "apiSymbol": "Pbkdf2Params", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-pbkdf2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-pbkdf2params", "nodeStability": { "index": "2", "level": 2, @@ -74805,7 +79513,7 @@ "label": "hash", "signature": "`hash` Type: {string|Algorithm}", "apiSymbol": "hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-pbkdf2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-pbkdf2params", "nodeStability": { "index": "2", "level": 2, @@ -74840,7 +79548,7 @@ "label": "iterations", "signature": "`iterations` Type: {number}", "apiSymbol": "iterations", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-pbkdf2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-pbkdf2params", "nodeStability": { "index": "2", "level": 2, @@ -74865,7 +79573,7 @@ "label": "name", "signature": "`name` Type: {string} Must be `'PBKDF2'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-pbkdf2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-pbkdf2params", "nodeStability": { "index": "2", "level": 2, @@ -74890,7 +79598,7 @@ "label": "salt", "signature": "`salt` Type: {ArrayBuffer|TypedArray|DataView|Buffer}", "apiSymbol": "salt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-pbkdf2params", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-pbkdf2params", "nodeStability": { "index": "2", "level": 2, @@ -74915,7 +79623,7 @@ "label": "RsaHashedImportParams", "signature": "Class: `RsaHashedImportParams`", "apiSymbol": "RsaHashedImportParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedimportparams", "nodeStability": { "index": "2", "level": 2, @@ -74940,7 +79648,7 @@ "label": "hash", "signature": "`hash` Type: {string|Algorithm}", "apiSymbol": "hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedimportparams", "nodeStability": { "index": "2", "level": 2, @@ -74975,7 +79683,7 @@ "label": "name", "signature": "`name` Type: {string} Must be one of `'RSASSA-PKCS1-v1_5'`, `'RSA-PSS'`, or `'RSA-OAEP'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedimportparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedimportparams", "nodeStability": { "index": "2", "level": 2, @@ -75000,7 +79708,7 @@ "label": "RsaHashedKeyAlgorithm", "signature": "Class: `RsaHashedKeyAlgorithm`", "apiSymbol": "RsaHashedKeyAlgorithm", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedkeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedkeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -75025,7 +79733,7 @@ "label": "hash", "signature": "`hash` Type: {Algorithm}", "apiSymbol": "hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedkeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedkeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -75060,7 +79768,7 @@ "label": "modulusLength", "signature": "`modulusLength` Type: {number}", "apiSymbol": "modulusLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedkeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedkeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -75085,7 +79793,7 @@ "label": "name", "signature": "`name` Type: {string}", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedkeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedkeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -75110,7 +79818,7 @@ "label": "publicExponent", "signature": "`publicExponent` Type: {Uint8Array}", "apiSymbol": "publicExponent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedkeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedkeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -75135,7 +79843,7 @@ "label": "RsaHashedKeyGenParams", "signature": "Class: `RsaHashedKeyGenParams`", "apiSymbol": "RsaHashedKeyGenParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedkeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedkeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -75160,7 +79868,7 @@ "label": "hash", "signature": "`hash` Type: {string|Algorithm}", "apiSymbol": "hash", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedkeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedkeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -75195,7 +79903,7 @@ "label": "modulusLength", "signature": "`modulusLength` Type: {number}", "apiSymbol": "modulusLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedkeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedkeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -75220,7 +79928,7 @@ "label": "name", "signature": "`name` Type: {string} Must be one of `'RSASSA-PKCS1-v1_5'`, `'RSA-PSS'`, or `'RSA-OAEP'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedkeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedkeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -75245,7 +79953,7 @@ "label": "publicExponent", "signature": "`publicExponent` Type: {Uint8Array}", "apiSymbol": "publicExponent", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsahashedkeygenparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsahashedkeygenparams", "nodeStability": { "index": "2", "level": 2, @@ -75270,7 +79978,7 @@ "label": "RsaOaepParams", "signature": "Class: `RsaOaepParams`", "apiSymbol": "RsaOaepParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsaoaepparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsaoaepparams", "nodeStability": { "index": "2", "level": 2, @@ -75295,7 +80003,7 @@ "label": "label", "signature": "`label` Type: {ArrayBuffer|TypedArray|DataView|Buffer}", "apiSymbol": "label", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsaoaepparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsaoaepparams", "nodeStability": { "index": "2", "level": 2, @@ -75320,7 +80028,7 @@ "label": "name", "signature": "`name` Type: {string} must be `'RSA-OAEP'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsaoaepparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsaoaepparams", "nodeStability": { "index": "2", "level": 2, @@ -75345,7 +80053,7 @@ "label": "RsaPssParams", "signature": "Class: `RsaPssParams`", "apiSymbol": "RsaPssParams", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsapssparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsapssparams", "nodeStability": { "index": "2", "level": 2, @@ -75370,7 +80078,7 @@ "label": "name", "signature": "`name` Type: {string} Must be `'RSA-PSS'`.", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsapssparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsapssparams", "nodeStability": { "index": "2", "level": 2, @@ -75395,7 +80103,107 @@ "label": "saltLength", "signature": "`saltLength` Type: {number}", "apiSymbol": "saltLength", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-rsapssparams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-rsapssparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:webcrypto", + "tests": [] + } + } + }, + { + "id": "webcrypto:077e576b19c6", + "chapter": "webcrypto", + "label": "TurboShakeParams", + "signature": "Class: `TurboShakeParams`", + "apiSymbol": "TurboShakeParams", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-turboshakeparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:webcrypto", + "tests": [] + } + } + }, + { + "id": "webcrypto:080709a8f851", + "chapter": "webcrypto", + "label": "domainSeparation", + "signature": "`domainSeparation` Type: {number|undefined}", + "apiSymbol": "domainSeparation", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-turboshakeparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:webcrypto", + "tests": [] + } + } + }, + { + "id": "webcrypto:ba3db2b61ce3", + "chapter": "webcrypto", + "label": "name", + "signature": "`name` Type: {string} Must be `'TurboSHAKE128'`[^modern-algos] or `'TurboSHAKE256'`[^modern-algos]", + "apiSymbol": "name", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-turboshakeparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "priority": "high", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:webcrypto", + "tests": [] + } + } + }, + { + "id": "webcrypto:0797ed062eb1", + "chapter": "webcrypto", + "label": "outputLength", + "signature": "`outputLength` Type: {number} represents the requested output length in bits.", + "apiSymbol": "outputLength", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-turboshakeparams", "nodeStability": { "index": "2", "level": 2, @@ -75420,7 +80228,7 @@ "label": "Crypto", "signature": "Class: `Crypto`", "apiSymbol": "Crypto", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-crypto", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-crypto", "nodeStability": { "index": "2", "level": 2, @@ -75445,7 +80253,7 @@ "label": "crypto.getRandomValues(typedArray)", "signature": "`crypto.getRandomValues(typedArray)`", "apiSymbol": "crypto.getRandomValues", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#cryptogetrandomvaluestypedarray", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#cryptogetrandomvaluestypedarray", "nodeStability": { "index": "2", "level": 2, @@ -75470,7 +80278,7 @@ "label": "crypto.randomUUID()", "signature": "`crypto.randomUUID()`", "apiSymbol": "crypto.randomUUID", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#cryptorandomuuid", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#cryptorandomuuid", "nodeStability": { "index": "2", "level": 2, @@ -75505,7 +80313,7 @@ "label": "subtle", "signature": "`subtle` Type: {SubtleCrypto}", "apiSymbol": "subtle", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-crypto", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-crypto", "nodeStability": { "index": "2", "level": 2, @@ -75530,7 +80338,7 @@ "label": "CryptoKey", "signature": "Class: `CryptoKey`", "apiSymbol": "CryptoKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-cryptokey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-cryptokey", "nodeStability": { "index": "2", "level": 2, @@ -75555,7 +80363,7 @@ "label": "cryptoKey.algorithm", "signature": "`cryptoKey.algorithm`", "apiSymbol": "cryptoKey.algorithm", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#cryptokeyalgorithm", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#cryptokeyalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -75580,7 +80388,7 @@ "label": "extractable", "signature": "`extractable` Type: {boolean}", "apiSymbol": "extractable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-cryptokey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-cryptokey", "nodeStability": { "index": "2", "level": 2, @@ -75605,7 +80413,7 @@ "label": "type", "signature": "`type` Type: {string} One of `'secret'`, `'private'`, or `'public'`.", "apiSymbol": "type", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-cryptokey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-cryptokey", "nodeStability": { "index": "2", "level": 2, @@ -75630,7 +80438,7 @@ "label": "usages", "signature": "`usages` Type: {string\\[]}", "apiSymbol": "usages", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-cryptokey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-cryptokey", "nodeStability": { "index": "2", "level": 2, @@ -75655,7 +80463,7 @@ "label": "CryptoKeyPair", "signature": "Class: `CryptoKeyPair`", "apiSymbol": "CryptoKeyPair", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-cryptokeypair", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-cryptokeypair", "nodeStability": { "index": "2", "level": 2, @@ -75680,7 +80488,7 @@ "label": "privateKey", "signature": "`privateKey` Type: {CryptoKey} A {CryptoKey} whose `type` will be `'private'`.", "apiSymbol": "privateKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-cryptokeypair", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-cryptokeypair", "nodeStability": { "index": "2", "level": 2, @@ -75705,7 +80513,7 @@ "label": "publicKey", "signature": "`publicKey` Type: {CryptoKey} A {CryptoKey} whose `type` will be `'public'`.", "apiSymbol": "publicKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-cryptokeypair", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-cryptokeypair", "nodeStability": { "index": "2", "level": 2, @@ -75730,7 +80538,7 @@ "label": "SubtleCrypto", "signature": "Class: `SubtleCrypto`", "apiSymbol": "SubtleCrypto", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#class-subtlecrypto", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#class-subtlecrypto", "nodeStability": { "index": "2", "level": 2, @@ -75755,7 +80563,7 @@ "label": "subtle.decapsulateBits(decapsulationAlgorithm, decapsulationKey, ciphertext)", "signature": "`subtle.decapsulateBits(decapsulationAlgorithm, decapsulationKey, ciphertext)`", "apiSymbol": "subtle.decapsulateBits", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtledecapsulatebitsdecapsulationalgorithm-decapsulationkey-ciphertext", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtledecapsulatebitsdecapsulationalgorithm-decapsulationkey-ciphertext", "nodeStability": { "index": "1.1", "level": 1, @@ -75775,12 +80583,12 @@ } }, { - "id": "webcrypto:d8f38474b5e5", + "id": "webcrypto:282fa1aa9829", "chapter": "webcrypto", - "label": "subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, usages)", - "signature": "`subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, usages)`", + "label": "subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, keyUsages)", + "signature": "`subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, keyUsages)`", "apiSymbol": "subtle.decapsulateKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtledecapsulatekeydecapsulationalgorithm-decapsulationkey-ciphertext-sharedkeyalgorithm-extractable-usages", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtledecapsulatekeydecapsulationalgorithm-decapsulationkey-ciphertext-sharedkeyalgorithm-extractable-keyusages", "nodeStability": { "index": "1.1", "level": 1, @@ -75805,7 +80613,7 @@ "label": "subtle.decrypt(algorithm, key, data)", "signature": "`subtle.decrypt(algorithm, key, data)`", "apiSymbol": "subtle.decrypt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtledecryptalgorithm-key-data", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtledecryptalgorithm-key-data", "nodeStability": { "index": "2", "level": 2, @@ -75830,7 +80638,7 @@ "label": "subtle.deriveBits(algorithm, baseKey[, length])", "signature": "`subtle.deriveBits(algorithm, baseKey[, length])`", "apiSymbol": "subtle.deriveBits", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtlederivebitsalgorithm-basekey-length", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtlederivebitsalgorithm-basekey-length", "nodeStability": { "index": "2", "level": 2, @@ -75850,12 +80658,12 @@ } }, { - "id": "webcrypto:8618a4716426", + "id": "webcrypto:3790d3167cb1", "chapter": "webcrypto", - "label": "subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)", - "signature": "`subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)`", + "label": "subtle.deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages)", + "signature": "`subtle.deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages)`", "apiSymbol": "subtle.deriveKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtlederivekeyalgorithm-basekey-derivedkeyalgorithm-extractable-keyusages", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtlederivekeyalgorithm-basekey-derivedkeytype-extractable-keyusages", "nodeStability": { "index": "2", "level": 2, @@ -75880,7 +80688,7 @@ "label": "subtle.digest(algorithm, data)", "signature": "`subtle.digest(algorithm, data)`", "apiSymbol": "subtle.digest", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtledigestalgorithm-data", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtledigestalgorithm-data", "nodeStability": { "index": "2", "level": 2, @@ -75905,7 +80713,7 @@ "label": "subtle.encapsulateBits(encapsulationAlgorithm, encapsulationKey)", "signature": "`subtle.encapsulateBits(encapsulationAlgorithm, encapsulationKey)`", "apiSymbol": "subtle.encapsulateBits", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtleencapsulatebitsencapsulationalgorithm-encapsulationkey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtleencapsulatebitsencapsulationalgorithm-encapsulationkey", "nodeStability": { "index": "1.1", "level": 1, @@ -75925,12 +80733,12 @@ } }, { - "id": "webcrypto:5e146a8a6347", + "id": "webcrypto:097ba43bcee4", "chapter": "webcrypto", - "label": "subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, usages)", - "signature": "`subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, usages)`", + "label": "subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, keyUsages)", + "signature": "`subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, keyUsages)`", "apiSymbol": "subtle.encapsulateKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtleencapsulatekeyencapsulationalgorithm-encapsulationkey-sharedkeyalgorithm-extractable-usages", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtleencapsulatekeyencapsulationalgorithm-encapsulationkey-sharedkeyalgorithm-extractable-keyusages", "nodeStability": { "index": "1.1", "level": 1, @@ -75955,7 +80763,7 @@ "label": "subtle.encrypt(algorithm, key, data)", "signature": "`subtle.encrypt(algorithm, key, data)`", "apiSymbol": "subtle.encrypt", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtleencryptalgorithm-key-data", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtleencryptalgorithm-key-data", "nodeStability": { "index": "2", "level": 2, @@ -75980,7 +80788,7 @@ "label": "subtle.exportKey(format, key)", "signature": "`subtle.exportKey(format, key)`", "apiSymbol": "subtle.exportKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtleexportkeyformat-key", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtleexportkeyformat-key", "nodeStability": { "index": "2", "level": 2, @@ -76005,7 +80813,7 @@ "label": "subtle.getPublicKey(key, keyUsages)", "signature": "`subtle.getPublicKey(key, keyUsages)`", "apiSymbol": "subtle.getPublicKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtlegetpublickeykey-keyusages", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtlegetpublickeykey-keyusages", "nodeStability": { "index": "1.1", "level": 1, @@ -76030,7 +80838,7 @@ "label": "subtle.generateKey(algorithm, extractable, keyUsages)", "signature": "`subtle.generateKey(algorithm, extractable, keyUsages)`", "apiSymbol": "subtle.generateKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtlegeneratekeyalgorithm-extractable-keyusages", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtlegeneratekeyalgorithm-extractable-keyusages", "nodeStability": { "index": "2", "level": 2, @@ -76055,7 +80863,7 @@ "label": "subtle.importKey(format, keyData, algorithm, extractable, keyUsages)", "signature": "`subtle.importKey(format, keyData, algorithm, extractable, keyUsages)`", "apiSymbol": "subtle.importKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtleimportkeyformat-keydata-algorithm-extractable-keyusages", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtleimportkeyformat-keydata-algorithm-extractable-keyusages", "nodeStability": { "index": "2", "level": 2, @@ -76080,7 +80888,7 @@ "label": "subtle.sign(algorithm, key, data)", "signature": "`subtle.sign(algorithm, key, data)`", "apiSymbol": "subtle.sign", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtlesignalgorithm-key-data", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtlesignalgorithm-key-data", "nodeStability": { "index": "2", "level": 2, @@ -76100,12 +80908,12 @@ } }, { - "id": "webcrypto:67f9b9466d2c", + "id": "webcrypto:4109de4ba359", "chapter": "webcrypto", - "label": "subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgo, unwrappedKeyAlgo, extractable, keyUsages)", - "signature": "`subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgo, unwrappedKeyAlgo, extractable, keyUsages)`", + "label": "subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages)", + "signature": "`subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages)`", "apiSymbol": "subtle.unwrapKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtleunwrapkeyformat-wrappedkey-unwrappingkey-unwrapalgo-unwrappedkeyalgo-extractable-keyusages", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtleunwrapkeyformat-wrappedkey-unwrappingkey-unwrapalgorithm-unwrappedkeyalgorithm-extractable-keyusages", "nodeStability": { "index": "2", "level": 2, @@ -76130,7 +80938,7 @@ "label": "subtle.verify(algorithm, key, signature, data)", "signature": "`subtle.verify(algorithm, key, signature, data)`", "apiSymbol": "subtle.verify", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtleverifyalgorithm-key-signature-data", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtleverifyalgorithm-key-signature-data", "nodeStability": { "index": "2", "level": 2, @@ -76150,12 +80958,12 @@ } }, { - "id": "webcrypto:62ec6d9ec96a", + "id": "webcrypto:25faa11630ae", "chapter": "webcrypto", - "label": "subtle.wrapKey(format, key, wrappingKey, wrapAlgo)", - "signature": "`subtle.wrapKey(format, key, wrappingKey, wrapAlgo)`", + "label": "subtle.wrapKey(format, key, wrappingKey, wrapAlgorithm)", + "signature": "`subtle.wrapKey(format, key, wrappingKey, wrapAlgorithm)`", "apiSymbol": "subtle.wrapKey", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webcrypto.html#subtlewrapkeyformat-key-wrappingkey-wrapalgo", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webcrypto.html#subtlewrapkeyformat-key-wrappingkey-wrapalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -76180,7 +80988,7 @@ "label": "streamConsumers.arrayBuffer(stream)", "signature": "`streamConsumers.arrayBuffer(stream)`", "apiSymbol": "streamConsumers.arrayBuffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#streamconsumersarraybufferstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#streamconsumersarraybufferstream", "nodeStability": { "index": "2", "level": 2, @@ -76207,7 +81015,7 @@ "label": "streamConsumers.blob(stream)", "signature": "`streamConsumers.blob(stream)`", "apiSymbol": "streamConsumers.blob", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#streamconsumersblobstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#streamconsumersblobstream", "nodeStability": { "index": "2", "level": 2, @@ -76232,7 +81040,7 @@ "label": "streamConsumers.buffer(stream)", "signature": "`streamConsumers.buffer(stream)`", "apiSymbol": "streamConsumers.buffer", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#streamconsumersbufferstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#streamconsumersbufferstream", "nodeStability": { "index": "2", "level": 2, @@ -76260,7 +81068,7 @@ "label": "streamConsumers.bytes(stream)", "signature": "`streamConsumers.bytes(stream)`", "apiSymbol": "streamConsumers.bytes", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#streamconsumersbytesstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#streamconsumersbytesstream", "nodeStability": { "index": "2", "level": 2, @@ -76285,7 +81093,7 @@ "label": "streamConsumers.json(stream)", "signature": "`streamConsumers.json(stream)`", "apiSymbol": "streamConsumers.json", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#streamconsumersjsonstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#streamconsumersjsonstream", "nodeStability": { "index": "2", "level": 2, @@ -76313,7 +81121,7 @@ "label": "streamConsumers.text(stream)", "signature": "`streamConsumers.text(stream)`", "apiSymbol": "streamConsumers.text", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#streamconsumerstextstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#streamconsumerstextstream", "nodeStability": { "index": "2", "level": 2, @@ -76341,7 +81149,7 @@ "label": "ReadableStream", "signature": "Class: `ReadableStream`", "apiSymbol": "ReadableStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablestream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablestream", "nodeStability": { "index": "2", "level": 2, @@ -76366,7 +81174,7 @@ "label": "Transferring with postMessage()", "signature": "Transferring with `postMessage()`", "apiSymbol": "postMessage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#transferring-with-postmessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#transferring-with-postmessage", "nodeStability": { "index": "2", "level": 2, @@ -76391,7 +81199,7 @@ "label": "readableStream.cancel([reason])", "signature": "`readableStream.cancel([reason])`", "apiSymbol": "readableStream.cancel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreamcancelreason", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreamcancelreason", "nodeStability": { "index": "2", "level": 2, @@ -76416,7 +81224,7 @@ "label": "readableStream.getReader([options])", "signature": "`readableStream.getReader([options])`", "apiSymbol": "readableStream.getReader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreamgetreaderoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreamgetreaderoptions", "nodeStability": { "index": "2", "level": 2, @@ -76441,7 +81249,7 @@ "label": "readableStream.pipeThrough(transform[, options])", "signature": "`readableStream.pipeThrough(transform[, options])`", "apiSymbol": "readableStream.pipeThrough", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreampipethroughtransform-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreampipethroughtransform-options", "nodeStability": { "index": "2", "level": 2, @@ -76466,7 +81274,7 @@ "label": "readableStream.pipeTo(destination[, options])", "signature": "`readableStream.pipeTo(destination[, options])`", "apiSymbol": "readableStream.pipeTo", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreampipetodestination-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreampipetodestination-options", "nodeStability": { "index": "2", "level": 2, @@ -76491,7 +81299,7 @@ "label": "readableStream.tee()", "signature": "`readableStream.tee()`", "apiSymbol": "readableStream.tee", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreamtee", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreamtee", "nodeStability": { "index": "2", "level": 2, @@ -76516,7 +81324,7 @@ "label": "readableStream.values([options])", "signature": "`readableStream.values([options])`", "apiSymbol": "readableStream.values", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreamvaluesoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreamvaluesoptions", "nodeStability": { "index": "2", "level": 2, @@ -76543,7 +81351,7 @@ "label": "locked", "signature": "`locked` Type: {boolean} Set to `true` if there is an active reader for this {ReadableStream}.", "apiSymbol": "locked", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablestream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablestream", "nodeStability": { "index": "2", "level": 2, @@ -76568,7 +81376,7 @@ "label": "ReadableStreamDefaultReader", "signature": "Class: `ReadableStreamDefaultReader`", "apiSymbol": "ReadableStreamDefaultReader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablestreamdefaultreader", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablestreamdefaultreader", "nodeStability": { "index": "2", "level": 2, @@ -76593,7 +81401,7 @@ "label": "readableStreamDefaultReader.cancel([reason])", "signature": "`readableStreamDefaultReader.cancel([reason])`", "apiSymbol": "readableStreamDefaultReader.cancel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreamdefaultreadercancelreason", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreamdefaultreadercancelreason", "nodeStability": { "index": "2", "level": 2, @@ -76618,7 +81426,7 @@ "label": "readableStreamDefaultReader.read()", "signature": "`readableStreamDefaultReader.read()`", "apiSymbol": "readableStreamDefaultReader.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreamdefaultreaderread", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreamdefaultreaderread", "nodeStability": { "index": "2", "level": 2, @@ -76643,7 +81451,7 @@ "label": "readableStreamDefaultReader.releaseLock()", "signature": "`readableStreamDefaultReader.releaseLock()`", "apiSymbol": "readableStreamDefaultReader.releaseLock", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreamdefaultreaderreleaselock", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreamdefaultreaderreleaselock", "nodeStability": { "index": "2", "level": 2, @@ -76668,7 +81476,7 @@ "label": "closed", "signature": "`closed` Type: {Promise} Fulfilled with `undefined` when the associated {ReadableStream} is closed or rejected if the stream errors or the reader's lock is released before the stream finishes closing.", "apiSymbol": "closed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablestreamdefaultreader", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablestreamdefaultreader", "nodeStability": { "index": "2", "level": 2, @@ -76693,7 +81501,7 @@ "label": "ReadableStreamBYOBReader", "signature": "Class: `ReadableStreamBYOBReader`", "apiSymbol": "ReadableStreamBYOBReader", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablestreambyobreader", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablestreambyobreader", "nodeStability": { "index": "2", "level": 2, @@ -76718,7 +81526,7 @@ "label": "readableStreamBYOBReader.cancel([reason])", "signature": "`readableStreamBYOBReader.cancel([reason])`", "apiSymbol": "readableStreamBYOBReader.cancel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreambyobreadercancelreason", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreambyobreadercancelreason", "nodeStability": { "index": "2", "level": 2, @@ -76743,7 +81551,7 @@ "label": "readableStreamBYOBReader.read(view[, options])", "signature": "`readableStreamBYOBReader.read(view[, options])`", "apiSymbol": "readableStreamBYOBReader.read", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreambyobreaderreadview-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreambyobreaderreadview-options", "nodeStability": { "index": "2", "level": 2, @@ -76768,7 +81576,7 @@ "label": "readableStreamBYOBReader.releaseLock()", "signature": "`readableStreamBYOBReader.releaseLock()`", "apiSymbol": "readableStreamBYOBReader.releaseLock", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreambyobreaderreleaselock", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreambyobreaderreleaselock", "nodeStability": { "index": "2", "level": 2, @@ -76793,7 +81601,7 @@ "label": "closed", "signature": "`closed` Type: {Promise} Fulfilled with `undefined` when the associated {ReadableStream} is closed or rejected if the stream errors or the reader's lock is released before the stream finishes closing.", "apiSymbol": "closed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablestreambyobreader", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablestreambyobreader", "nodeStability": { "index": "2", "level": 2, @@ -76818,7 +81626,7 @@ "label": "ReadableStreamDefaultController", "signature": "Class: `ReadableStreamDefaultController`", "apiSymbol": "ReadableStreamDefaultController", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablestreamdefaultcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablestreamdefaultcontroller", "nodeStability": { "index": "2", "level": 2, @@ -76843,7 +81651,7 @@ "label": "readableStreamDefaultController.close()", "signature": "`readableStreamDefaultController.close()`", "apiSymbol": "readableStreamDefaultController.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreamdefaultcontrollerclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreamdefaultcontrollerclose", "nodeStability": { "index": "2", "level": 2, @@ -76868,7 +81676,7 @@ "label": "readableStreamDefaultController.enqueue([chunk])", "signature": "`readableStreamDefaultController.enqueue([chunk])`", "apiSymbol": "readableStreamDefaultController.enqueue", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreamdefaultcontrollerenqueuechunk", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreamdefaultcontrollerenqueuechunk", "nodeStability": { "index": "2", "level": 2, @@ -76893,7 +81701,7 @@ "label": "readableStreamDefaultController.error([error])", "signature": "`readableStreamDefaultController.error([error])`", "apiSymbol": "readableStreamDefaultController.error", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreamdefaultcontrollererrorerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreamdefaultcontrollererrorerror", "nodeStability": { "index": "2", "level": 2, @@ -76918,7 +81726,7 @@ "label": "desiredSize", "signature": "`desiredSize` Type: {number}", "apiSymbol": "desiredSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablestreamdefaultcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablestreamdefaultcontroller", "nodeStability": { "index": "2", "level": 2, @@ -76943,7 +81751,7 @@ "label": "ReadableByteStreamController", "signature": "Class: `ReadableByteStreamController`", "apiSymbol": "ReadableByteStreamController", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablebytestreamcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablebytestreamcontroller", "nodeStability": { "index": "2", "level": 2, @@ -76968,7 +81776,7 @@ "label": "readableByteStreamController.close()", "signature": "`readableByteStreamController.close()`", "apiSymbol": "readableByteStreamController.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablebytestreamcontrollerclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablebytestreamcontrollerclose", "nodeStability": { "index": "2", "level": 2, @@ -76993,7 +81801,7 @@ "label": "readableByteStreamController.enqueue(chunk)", "signature": "`readableByteStreamController.enqueue(chunk)`", "apiSymbol": "readableByteStreamController.enqueue", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablebytestreamcontrollerenqueuechunk", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablebytestreamcontrollerenqueuechunk", "nodeStability": { "index": "2", "level": 2, @@ -77018,7 +81826,7 @@ "label": "readableByteStreamController.error([error])", "signature": "`readableByteStreamController.error([error])`", "apiSymbol": "readableByteStreamController.error", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablebytestreamcontrollererrorerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablebytestreamcontrollererrorerror", "nodeStability": { "index": "2", "level": 2, @@ -77043,7 +81851,7 @@ "label": "byobRequest", "signature": "`byobRequest` Type: {ReadableStreamBYOBRequest}", "apiSymbol": "byobRequest", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablebytestreamcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablebytestreamcontroller", "nodeStability": { "index": "2", "level": 2, @@ -77068,7 +81876,7 @@ "label": "desiredSize", "signature": "`desiredSize` Type: {number}", "apiSymbol": "desiredSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablebytestreamcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablebytestreamcontroller", "nodeStability": { "index": "2", "level": 2, @@ -77093,7 +81901,7 @@ "label": "ReadableStreamBYOBRequest", "signature": "Class: `ReadableStreamBYOBRequest`", "apiSymbol": "ReadableStreamBYOBRequest", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablestreambyobrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablestreambyobrequest", "nodeStability": { "index": "2", "level": 2, @@ -77118,7 +81926,7 @@ "label": "readableStreamBYOBRequest.respond(bytesWritten)", "signature": "`readableStreamBYOBRequest.respond(bytesWritten)`", "apiSymbol": "readableStreamBYOBRequest.respond", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreambyobrequestrespondbyteswritten", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreambyobrequestrespondbyteswritten", "nodeStability": { "index": "2", "level": 2, @@ -77143,7 +81951,7 @@ "label": "readableStreamBYOBRequest.respondWithNewView(view)", "signature": "`readableStreamBYOBRequest.respondWithNewView(view)`", "apiSymbol": "readableStreamBYOBRequest.respondWithNewView", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreambyobrequestrespondwithnewviewview", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreambyobrequestrespondwithnewviewview", "nodeStability": { "index": "2", "level": 2, @@ -77168,7 +81976,7 @@ "label": "view", "signature": "`view` Type: {Buffer|TypedArray|DataView}", "apiSymbol": "view", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-readablestreambyobrequest", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-readablestreambyobrequest", "nodeStability": { "index": "2", "level": 2, @@ -77193,7 +82001,7 @@ "label": "WritableStream", "signature": "Class: `WritableStream`", "apiSymbol": "WritableStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-writablestream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-writablestream", "nodeStability": { "index": "2", "level": 2, @@ -77218,7 +82026,7 @@ "label": "writableStream.abort([reason])", "signature": "`writableStream.abort([reason])`", "apiSymbol": "writableStream.abort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#writablestreamabortreason", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#writablestreamabortreason", "nodeStability": { "index": "2", "level": 2, @@ -77243,7 +82051,7 @@ "label": "writableStream.close()", "signature": "`writableStream.close()`", "apiSymbol": "writableStream.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#writablestreamclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#writablestreamclose", "nodeStability": { "index": "2", "level": 2, @@ -77268,7 +82076,7 @@ "label": "writableStream.getWriter()", "signature": "`writableStream.getWriter()`", "apiSymbol": "writableStream.getWriter", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#writablestreamgetwriter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#writablestreamgetwriter", "nodeStability": { "index": "2", "level": 2, @@ -77293,7 +82101,7 @@ "label": "locked", "signature": "`locked` Type: {boolean}", "apiSymbol": "locked", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-writablestream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-writablestream", "nodeStability": { "index": "2", "level": 2, @@ -77318,7 +82126,7 @@ "label": "WritableStreamDefaultWriter", "signature": "Class: `WritableStreamDefaultWriter`", "apiSymbol": "WritableStreamDefaultWriter", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-writablestreamdefaultwriter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-writablestreamdefaultwriter", "nodeStability": { "index": "2", "level": 2, @@ -77343,7 +82151,7 @@ "label": "writableStreamDefaultWriter.abort([reason])", "signature": "`writableStreamDefaultWriter.abort([reason])`", "apiSymbol": "writableStreamDefaultWriter.abort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#writablestreamdefaultwriterabortreason", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#writablestreamdefaultwriterabortreason", "nodeStability": { "index": "2", "level": 2, @@ -77368,7 +82176,7 @@ "label": "writableStreamDefaultWriter.close()", "signature": "`writableStreamDefaultWriter.close()`", "apiSymbol": "writableStreamDefaultWriter.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#writablestreamdefaultwriterclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#writablestreamdefaultwriterclose", "nodeStability": { "index": "2", "level": 2, @@ -77393,7 +82201,7 @@ "label": "writableStreamDefaultWriter.releaseLock()", "signature": "`writableStreamDefaultWriter.releaseLock()`", "apiSymbol": "writableStreamDefaultWriter.releaseLock", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#writablestreamdefaultwriterreleaselock", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#writablestreamdefaultwriterreleaselock", "nodeStability": { "index": "2", "level": 2, @@ -77418,7 +82226,7 @@ "label": "writableStreamDefaultWriter.write([chunk])", "signature": "`writableStreamDefaultWriter.write([chunk])`", "apiSymbol": "writableStreamDefaultWriter.write", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#writablestreamdefaultwriterwritechunk", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#writablestreamdefaultwriterwritechunk", "nodeStability": { "index": "2", "level": 2, @@ -77443,7 +82251,7 @@ "label": "closed", "signature": "`closed` Type: {Promise} Fulfilled with `undefined` when the associated {WritableStream} is closed or rejected if the stream errors or the writer's lock is released before the stream finishes closing.", "apiSymbol": "closed", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-writablestreamdefaultwriter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-writablestreamdefaultwriter", "nodeStability": { "index": "2", "level": 2, @@ -77468,7 +82276,7 @@ "label": "desiredSize", "signature": "`desiredSize` Type: {number}", "apiSymbol": "desiredSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-writablestreamdefaultwriter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-writablestreamdefaultwriter", "nodeStability": { "index": "2", "level": 2, @@ -77493,7 +82301,7 @@ "label": "ready", "signature": "`ready` Type: {Promise} Fulfilled with `undefined` when the writer is ready to be used.", "apiSymbol": "ready", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-writablestreamdefaultwriter", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-writablestreamdefaultwriter", "nodeStability": { "index": "2", "level": 2, @@ -77518,7 +82326,7 @@ "label": "WritableStreamDefaultController", "signature": "Class: `WritableStreamDefaultController`", "apiSymbol": "WritableStreamDefaultController", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-writablestreamdefaultcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-writablestreamdefaultcontroller", "nodeStability": { "index": "2", "level": 2, @@ -77543,7 +82351,7 @@ "label": "writableStreamDefaultController.error([error])", "signature": "`writableStreamDefaultController.error([error])`", "apiSymbol": "writableStreamDefaultController.error", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#writablestreamdefaultcontrollererrorerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#writablestreamdefaultcontrollererrorerror", "nodeStability": { "index": "2", "level": 2, @@ -77568,7 +82376,7 @@ "label": "signal", "signature": "`signal` Type: {AbortSignal} An `AbortSignal` that can be used to cancel pending write or close operations when a {WritableStream} is aborted.", "apiSymbol": "signal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-writablestreamdefaultcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-writablestreamdefaultcontroller", "nodeStability": { "index": "2", "level": 2, @@ -77593,7 +82401,7 @@ "label": "TransformStream", "signature": "Class: `TransformStream`", "apiSymbol": "TransformStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-transformstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-transformstream", "nodeStability": { "index": "2", "level": 2, @@ -77618,7 +82426,7 @@ "label": "readable", "signature": "`readable` Type: {ReadableStream}", "apiSymbol": "readable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-transformstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-transformstream", "nodeStability": { "index": "2", "level": 2, @@ -77643,7 +82451,7 @@ "label": "writable", "signature": "`writable` Type: {WritableStream}", "apiSymbol": "writable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-transformstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-transformstream", "nodeStability": { "index": "2", "level": 2, @@ -77668,7 +82476,7 @@ "label": "TransformStreamDefaultController", "signature": "Class: `TransformStreamDefaultController`", "apiSymbol": "TransformStreamDefaultController", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-transformstreamdefaultcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-transformstreamdefaultcontroller", "nodeStability": { "index": "2", "level": 2, @@ -77693,7 +82501,7 @@ "label": "transformStreamDefaultController.enqueue([chunk])", "signature": "`transformStreamDefaultController.enqueue([chunk])`", "apiSymbol": "transformStreamDefaultController.enqueue", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#transformstreamdefaultcontrollerenqueuechunk", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#transformstreamdefaultcontrollerenqueuechunk", "nodeStability": { "index": "2", "level": 2, @@ -77718,7 +82526,7 @@ "label": "transformStreamDefaultController.error([reason])", "signature": "`transformStreamDefaultController.error([reason])`", "apiSymbol": "transformStreamDefaultController.error", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#transformstreamdefaultcontrollererrorreason", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#transformstreamdefaultcontrollererrorreason", "nodeStability": { "index": "2", "level": 2, @@ -77743,7 +82551,7 @@ "label": "transformStreamDefaultController.terminate()", "signature": "`transformStreamDefaultController.terminate()`", "apiSymbol": "transformStreamDefaultController.terminate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#transformstreamdefaultcontrollerterminate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#transformstreamdefaultcontrollerterminate", "nodeStability": { "index": "2", "level": 2, @@ -77768,7 +82576,7 @@ "label": "desiredSize", "signature": "`desiredSize` Type: {number}", "apiSymbol": "desiredSize", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-transformstreamdefaultcontroller", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-transformstreamdefaultcontroller", "nodeStability": { "index": "2", "level": 2, @@ -77793,7 +82601,7 @@ "label": "ByteLengthQueuingStrategy", "signature": "Class: `ByteLengthQueuingStrategy`", "apiSymbol": "ByteLengthQueuingStrategy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-bytelengthqueuingstrategy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-bytelengthqueuingstrategy", "nodeStability": { "index": "2", "level": 2, @@ -77818,7 +82626,7 @@ "label": "highWaterMark", "signature": "`highWaterMark` Type: {number}", "apiSymbol": "highWaterMark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-bytelengthqueuingstrategy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-bytelengthqueuingstrategy", "nodeStability": { "index": "2", "level": 2, @@ -77843,7 +82651,7 @@ "label": "size", "signature": "`size` Type: {Function}", "apiSymbol": "size", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-bytelengthqueuingstrategy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-bytelengthqueuingstrategy", "nodeStability": { "index": "2", "level": 2, @@ -77868,7 +82676,7 @@ "label": "CountQueuingStrategy", "signature": "Class: `CountQueuingStrategy`", "apiSymbol": "CountQueuingStrategy", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-countqueuingstrategy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-countqueuingstrategy", "nodeStability": { "index": "2", "level": 2, @@ -77893,7 +82701,7 @@ "label": "highWaterMark", "signature": "`highWaterMark` Type: {number}", "apiSymbol": "highWaterMark", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-countqueuingstrategy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-countqueuingstrategy", "nodeStability": { "index": "2", "level": 2, @@ -77918,7 +82726,7 @@ "label": "size", "signature": "`size` Type: {Function}", "apiSymbol": "size", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-countqueuingstrategy", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-countqueuingstrategy", "nodeStability": { "index": "2", "level": 2, @@ -77943,7 +82751,7 @@ "label": "TextEncoderStream", "signature": "Class: `TextEncoderStream`", "apiSymbol": "TextEncoderStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-textencoderstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-textencoderstream", "nodeStability": { "index": "2", "level": 2, @@ -77968,7 +82776,7 @@ "label": "encoding", "signature": "`encoding` Type: {string}", "apiSymbol": "encoding", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-textencoderstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-textencoderstream", "nodeStability": { "index": "2", "level": 2, @@ -77993,7 +82801,7 @@ "label": "readable", "signature": "`readable` Type: {ReadableStream}", "apiSymbol": "readable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-textencoderstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-textencoderstream", "nodeStability": { "index": "2", "level": 2, @@ -78018,7 +82826,7 @@ "label": "writable", "signature": "`writable` Type: {WritableStream}", "apiSymbol": "writable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-textencoderstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-textencoderstream", "nodeStability": { "index": "2", "level": 2, @@ -78043,7 +82851,7 @@ "label": "TextDecoderStream", "signature": "Class: `TextDecoderStream`", "apiSymbol": "TextDecoderStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-textdecoderstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-textdecoderstream", "nodeStability": { "index": "2", "level": 2, @@ -78068,7 +82876,7 @@ "label": "encoding", "signature": "`encoding` Type: {string}", "apiSymbol": "encoding", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-textdecoderstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-textdecoderstream", "nodeStability": { "index": "2", "level": 2, @@ -78093,7 +82901,7 @@ "label": "fatal", "signature": "`fatal` Type: {boolean}", "apiSymbol": "fatal", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-textdecoderstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-textdecoderstream", "nodeStability": { "index": "2", "level": 2, @@ -78118,7 +82926,7 @@ "label": "ignoreBOM", "signature": "`ignoreBOM` Type: {boolean}", "apiSymbol": "ignoreBOM", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-textdecoderstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-textdecoderstream", "nodeStability": { "index": "2", "level": 2, @@ -78143,7 +82951,7 @@ "label": "readable", "signature": "`readable` Type: {ReadableStream}", "apiSymbol": "readable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-textdecoderstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-textdecoderstream", "nodeStability": { "index": "2", "level": 2, @@ -78168,7 +82976,7 @@ "label": "writable", "signature": "`writable` Type: {WritableStream}", "apiSymbol": "writable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-textdecoderstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-textdecoderstream", "nodeStability": { "index": "2", "level": 2, @@ -78193,7 +83001,7 @@ "label": "CompressionStream", "signature": "Class: `CompressionStream`", "apiSymbol": "CompressionStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-compressionstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-compressionstream", "nodeStability": { "index": "2", "level": 2, @@ -78218,7 +83026,7 @@ "label": "readable", "signature": "`readable` Type: {ReadableStream}", "apiSymbol": "readable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-compressionstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-compressionstream", "nodeStability": { "index": "2", "level": 2, @@ -78243,7 +83051,7 @@ "label": "writable", "signature": "`writable` Type: {WritableStream}", "apiSymbol": "writable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-compressionstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-compressionstream", "nodeStability": { "index": "2", "level": 2, @@ -78268,7 +83076,7 @@ "label": "DecompressionStream", "signature": "Class: `DecompressionStream`", "apiSymbol": "DecompressionStream", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-decompressionstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-decompressionstream", "nodeStability": { "index": "2", "level": 2, @@ -78293,7 +83101,7 @@ "label": "readable", "signature": "`readable` Type: {ReadableStream}", "apiSymbol": "readable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-decompressionstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-decompressionstream", "nodeStability": { "index": "2", "level": 2, @@ -78318,7 +83126,7 @@ "label": "writable", "signature": "`writable` Type: {WritableStream}", "apiSymbol": "writable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#class-decompressionstream", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#class-decompressionstream", "nodeStability": { "index": "2", "level": 2, @@ -78337,13 +83145,38 @@ } } }, + { + "id": "webstreams:5a92c91c4929", + "chapter": "webstreams", + "label": "ReadableStreamTee(stream[, cloneForBranch2])", + "signature": "`ReadableStreamTee(stream[, cloneForBranch2])`", + "apiSymbol": "ReadableStreamTee", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreamteestream-cloneforbranch2", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:webstreams", + "tests": [] + } + } + }, { "id": "webstreams:4c7d9f984091", "chapter": "webstreams", "label": "ReadableStream.from(iterable)", "signature": "`ReadableStream.from(iterable)`", "apiSymbol": "ReadableStream.from", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/webstreams.html#readablestreamfromiterable", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/webstreams.html#readablestreamfromiterable", "nodeStability": { "index": "2", "level": 2, @@ -78370,7 +83203,7 @@ "label": "BroadcastChannel extends EventTarget", "signature": "Class: `BroadcastChannel extends EventTarget`", "apiSymbol": "BroadcastChannel extends EventTarget", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-broadcastchannel-extends-eventtarget", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-broadcastchannel-extends-eventtarget", "nodeStability": { "index": "2", "level": 2, @@ -78395,7 +83228,7 @@ "label": "broadcastChannel.close()", "signature": "`broadcastChannel.close()`", "apiSymbol": "broadcastChannel.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#broadcastchannelclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#broadcastchannelclose", "nodeStability": { "index": "2", "level": 2, @@ -78420,7 +83253,7 @@ "label": "broadcastChannel.postMessage(message)", "signature": "`broadcastChannel.postMessage(message)`", "apiSymbol": "broadcastChannel.postMessage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#broadcastchannelpostmessagemessage", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#broadcastchannelpostmessagemessage", "nodeStability": { "index": "2", "level": 2, @@ -78445,7 +83278,7 @@ "label": "broadcastChannel.ref()", "signature": "`broadcastChannel.ref()`", "apiSymbol": "broadcastChannel.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#broadcastchannelref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#broadcastchannelref", "nodeStability": { "index": "2", "level": 2, @@ -78470,7 +83303,7 @@ "label": "broadcastChannel.unref()", "signature": "`broadcastChannel.unref()`", "apiSymbol": "broadcastChannel.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#broadcastchannelunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#broadcastchannelunref", "nodeStability": { "index": "2", "level": 2, @@ -78495,7 +83328,7 @@ "label": "onmessage", "signature": "`onmessage` Type: {Function} Invoked with a single `MessageEvent` argument when a message is received.", "apiSymbol": "onmessage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-broadcastchannel-extends-eventtarget", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-broadcastchannel-extends-eventtarget", "nodeStability": { "index": "2", "level": 2, @@ -78520,7 +83353,7 @@ "label": "onmessageerror", "signature": "`onmessageerror` Type: {Function} Invoked with a received message cannot be deserialized.", "apiSymbol": "onmessageerror", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-broadcastchannel-extends-eventtarget", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-broadcastchannel-extends-eventtarget", "nodeStability": { "index": "2", "level": 2, @@ -78545,7 +83378,7 @@ "label": "MessageChannel", "signature": "Class: `MessageChannel`", "apiSymbol": "MessageChannel", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-messagechannel", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-messagechannel", "nodeStability": { "index": "2", "level": 2, @@ -78570,7 +83403,7 @@ "label": "MessagePort", "signature": "Class: `MessagePort`", "apiSymbol": "MessagePort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-messageport", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-messageport", "nodeStability": { "index": "2", "level": 2, @@ -78599,7 +83432,7 @@ "label": "port.close()", "signature": "`port.close()`", "apiSymbol": "port.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#portclose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#portclose", "nodeStability": { "index": "2", "level": 2, @@ -78626,7 +83459,7 @@ "label": "port.postMessage(value[, transferList])", "signature": "`port.postMessage(value[, transferList])`", "apiSymbol": "port.postMessage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#portpostmessagevalue-transferlist", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#portpostmessagevalue-transferlist", "nodeStability": { "index": "2", "level": 2, @@ -78656,7 +83489,7 @@ "label": "port.hasRef()", "signature": "`port.hasRef()`", "apiSymbol": "port.hasRef", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#porthasref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#porthasref", "nodeStability": { "index": "2", "level": 2, @@ -78683,7 +83516,7 @@ "label": "port.ref()", "signature": "`port.ref()`", "apiSymbol": "port.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#portref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#portref", "nodeStability": { "index": "2", "level": 2, @@ -78710,7 +83543,7 @@ "label": "port.start()", "signature": "`port.start()`", "apiSymbol": "port.start", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#portstart", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#portstart", "nodeStability": { "index": "2", "level": 2, @@ -78737,7 +83570,7 @@ "label": "port.unref()", "signature": "`port.unref()`", "apiSymbol": "port.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#portunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#portunref", "nodeStability": { "index": "2", "level": 2, @@ -78764,7 +83597,7 @@ "label": "'close'", "signature": "Event: `'close'`", "apiSymbol": "'close'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#event-close", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#event-close", "nodeStability": { "index": "2", "level": 2, @@ -78792,7 +83625,7 @@ "label": "'message'", "signature": "Event: `'message'`", "apiSymbol": "'message'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#event-message", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#event-message", "nodeStability": { "index": "2", "level": 2, @@ -78820,7 +83653,7 @@ "label": "'messageerror'", "signature": "Event: `'messageerror'`", "apiSymbol": "'messageerror'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#event-messageerror", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#event-messageerror", "nodeStability": { "index": "2", "level": 2, @@ -78845,7 +83678,7 @@ "label": "Worker", "signature": "Class: `Worker`", "apiSymbol": "Worker", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-worker", "nodeStability": { "index": "2", "level": 2, @@ -78875,7 +83708,7 @@ "label": "worker.cpuUsage([prev])", "signature": "`worker.cpuUsage([prev])`", "apiSymbol": "worker.cpuUsage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#workercpuusageprev", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#workercpuusageprev", "nodeStability": { "index": "2", "level": 2, @@ -78900,7 +83733,7 @@ "label": "worker.getHeapSnapshot([options])", "signature": "`worker.getHeapSnapshot([options])`", "apiSymbol": "worker.getHeapSnapshot", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#workergetheapsnapshotoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#workergetheapsnapshotoptions", "nodeStability": { "index": "2", "level": 2, @@ -78925,7 +83758,7 @@ "label": "worker.getHeapStatistics()", "signature": "`worker.getHeapStatistics()`", "apiSymbol": "worker.getHeapStatistics", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#workergetheapstatistics", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#workergetheapstatistics", "nodeStability": { "index": "2", "level": 2, @@ -78950,7 +83783,7 @@ "label": "worker.postMessage(value[, transferList])", "signature": "`worker.postMessage(value[, transferList])`", "apiSymbol": "worker.postMessage", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#workerpostmessagevalue-transferlist", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#workerpostmessagevalue-transferlist", "nodeStability": { "index": "2", "level": 2, @@ -78980,7 +83813,7 @@ "label": "worker.ref()", "signature": "`worker.ref()`", "apiSymbol": "worker.ref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#workerref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#workerref", "nodeStability": { "index": "2", "level": 2, @@ -79007,7 +83840,7 @@ "label": "worker.startCpuProfile()", "signature": "`worker.startCpuProfile()`", "apiSymbol": "worker.startCpuProfile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#workerstartcpuprofile", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#workerstartcpuprofile", "nodeStability": { "index": "2", "level": 2, @@ -79032,7 +83865,7 @@ "label": "worker.startHeapProfile()", "signature": "`worker.startHeapProfile()`", "apiSymbol": "worker.startHeapProfile", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#workerstartheapprofile", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#workerstartheapprofile", "nodeStability": { "index": "2", "level": 2, @@ -79057,7 +83890,7 @@ "label": "worker.terminate()", "signature": "`worker.terminate()`", "apiSymbol": "worker.terminate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#workerterminate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#workerterminate", "nodeStability": { "index": "2", "level": 2, @@ -79087,7 +83920,7 @@ "label": "worker.unref()", "signature": "`worker.unref()`", "apiSymbol": "worker.unref", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#workerunref", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#workerunref", "nodeStability": { "index": "2", "level": 2, @@ -79114,7 +83947,7 @@ "label": "worker[Symbol.asyncDispose]()", "signature": "`worker[Symbol.asyncDispose]()`", "apiSymbol": "worker", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#workersymbolasyncdispose", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#workersymbolasyncdispose", "nodeStability": { "index": "2", "level": 2, @@ -79139,7 +83972,7 @@ "label": "worker.performance", "signature": "`worker.performance`", "apiSymbol": "worker.performance", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#workerperformance", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#workerperformance", "nodeStability": { "index": "2", "level": 2, @@ -79164,7 +83997,7 @@ "label": "performance.eventLoopUtilization([utilization1[, utilization2]])", "signature": "`performance.eventLoopUtilization([utilization1[, utilization2]])`", "apiSymbol": "performance.eventLoopUtilization", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#performanceeventlooputilizationutilization1-utilization2", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#performanceeventlooputilizationutilization1-utilization2", "nodeStability": { "index": "2", "level": 2, @@ -79189,7 +84022,7 @@ "label": "resourceLimits", "signature": "`resourceLimits` Type: {Object}", "apiSymbol": "resourceLimits", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-worker", "nodeStability": { "index": "2", "level": 2, @@ -79214,7 +84047,7 @@ "label": "stderr", "signature": "`stderr` Type: {stream.Readable}", "apiSymbol": "stderr", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-worker", "nodeStability": { "index": "2", "level": 2, @@ -79239,7 +84072,7 @@ "label": "stdin", "signature": "`stdin` Type: {null|stream.Writable}", "apiSymbol": "stdin", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-worker", "nodeStability": { "index": "2", "level": 2, @@ -79264,7 +84097,7 @@ "label": "stdout", "signature": "`stdout` Type: {stream.Readable}", "apiSymbol": "stdout", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-worker", "nodeStability": { "index": "2", "level": 2, @@ -79289,7 +84122,7 @@ "label": "threadId", "signature": "`threadId` Type: {integer}", "apiSymbol": "threadId", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-worker", "nodeStability": { "index": "2", "level": 2, @@ -79318,7 +84151,7 @@ "label": "threadName", "signature": "`threadName` {string|null}", "apiSymbol": "threadName", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-worker", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-worker", "nodeStability": { "index": "2", "level": 2, @@ -79343,7 +84176,7 @@ "label": "'error'", "signature": "Event: `'error'`", "apiSymbol": "'error'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#event-error", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#event-error", "nodeStability": { "index": "2", "level": 2, @@ -79372,7 +84205,7 @@ "label": "'exit'", "signature": "Event: `'exit'`", "apiSymbol": "'exit'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#event-exit", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#event-exit", "nodeStability": { "index": "2", "level": 2, @@ -79401,7 +84234,7 @@ "label": "'message'", "signature": "Event: `'message'`", "apiSymbol": "'message'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#event-message_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#event-message_1", "nodeStability": { "index": "2", "level": 2, @@ -79430,7 +84263,7 @@ "label": "'messageerror'", "signature": "Event: `'messageerror'`", "apiSymbol": "'messageerror'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#event-messageerror_1", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#event-messageerror_1", "nodeStability": { "index": "2", "level": 2, @@ -79455,7 +84288,7 @@ "label": "'online'", "signature": "Event: `'online'`", "apiSymbol": "'online'", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#event-online", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#event-online", "nodeStability": { "index": "2", "level": 2, @@ -79484,7 +84317,7 @@ "label": "worker_threads.getEnvironmentData(key)", "signature": "`worker_threads.getEnvironmentData(key)`", "apiSymbol": "worker_threads.getEnvironmentData", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#worker_threadsgetenvironmentdatakey", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#worker_threadsgetenvironmentdatakey", "nodeStability": { "index": "2", "level": 2, @@ -79509,7 +84342,7 @@ "label": "worker_threads.markAsUntransferable(object)", "signature": "`worker_threads.markAsUntransferable(object)`", "apiSymbol": "worker_threads.markAsUntransferable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#worker_threadsmarkasuntransferableobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#worker_threadsmarkasuntransferableobject", "nodeStability": { "index": "2", "level": 2, @@ -79534,7 +84367,7 @@ "label": "worker_threads.isMarkedAsUntransferable(object)", "signature": "`worker_threads.isMarkedAsUntransferable(object)`", "apiSymbol": "worker_threads.isMarkedAsUntransferable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#worker_threadsismarkedasuntransferableobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#worker_threadsismarkedasuntransferableobject", "nodeStability": { "index": "2", "level": 2, @@ -79559,7 +84392,7 @@ "label": "worker_threads.markAsUncloneable(object)", "signature": "`worker_threads.markAsUncloneable(object)`", "apiSymbol": "worker_threads.markAsUncloneable", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#worker_threadsmarkasuncloneableobject", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#worker_threadsmarkasuncloneableobject", "nodeStability": { "index": "2", "level": 2, @@ -79584,7 +84417,7 @@ "label": "worker_threads.moveMessagePortToContext(port, contextifiedSandbox)", "signature": "`worker_threads.moveMessagePortToContext(port, contextifiedSandbox)`", "apiSymbol": "worker_threads.moveMessagePortToContext", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#worker_threadsmovemessageporttocontextport-contextifiedsandbox", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#worker_threadsmovemessageporttocontextport-contextifiedsandbox", "nodeStability": { "index": "2", "level": 2, @@ -79609,7 +84442,7 @@ "label": "worker_threads.postMessageToThread(threadId, value[, transferList][, timeout])", "signature": "`worker_threads.postMessageToThread(threadId, value[, transferList][, timeout])`", "apiSymbol": "worker_threads.postMessageToThread", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#worker_threadspostmessagetothreadthreadid-value-transferlist-timeout", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#worker_threadspostmessagetothreadthreadid-value-transferlist-timeout", "nodeStability": { "index": "1.1", "level": 1, @@ -79634,7 +84467,7 @@ "label": "worker_threads.receiveMessageOnPort(port)", "signature": "`worker_threads.receiveMessageOnPort(port)`", "apiSymbol": "worker_threads.receiveMessageOnPort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#worker_threadsreceivemessageonportport", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#worker_threadsreceivemessageonportport", "nodeStability": { "index": "2", "level": 2, @@ -79659,7 +84492,7 @@ "label": "worker_threads.setEnvironmentData(key[, value])", "signature": "`worker_threads.setEnvironmentData(key[, value])`", "apiSymbol": "worker_threads.setEnvironmentData", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#worker_threadssetenvironmentdatakey-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#worker_threadssetenvironmentdatakey-value", "nodeStability": { "index": "2", "level": 2, @@ -79684,7 +84517,7 @@ "label": "isInternalThread", "signature": "`isInternalThread` Type: {boolean}", "apiSymbol": "isInternalThread", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html", "nodeStability": { "index": "2", "level": 2, @@ -79709,7 +84542,7 @@ "label": "isMainThread", "signature": "`isMainThread` Type: {boolean}", "apiSymbol": "isMainThread", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html", "nodeStability": { "index": "2", "level": 2, @@ -79738,7 +84571,7 @@ "label": "parentPort", "signature": "`parentPort` Type: {null|MessagePort}", "apiSymbol": "parentPort", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html", "nodeStability": { "index": "2", "level": 2, @@ -79767,7 +84600,7 @@ "label": "resourceLimits", "signature": "`resourceLimits` Type: {Object}", "apiSymbol": "resourceLimits", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html", "nodeStability": { "index": "2", "level": 2, @@ -79792,7 +84625,7 @@ "label": "SHARE_ENV", "signature": "`SHARE_ENV` Type: {symbol}", "apiSymbol": "SHARE_ENV", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html", "nodeStability": { "index": "2", "level": 2, @@ -79817,7 +84650,7 @@ "label": "threadId", "signature": "`threadId` Type: {integer}", "apiSymbol": "threadId", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html", "nodeStability": { "index": "2", "level": 2, @@ -79846,7 +84679,7 @@ "label": "threadName", "signature": "`threadName` {string|null}", "apiSymbol": "threadName", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html", "nodeStability": { "index": "2", "level": 2, @@ -79871,7 +84704,7 @@ "label": "worker_threads.workerData", "signature": "`worker_threads.workerData`", "apiSymbol": "worker_threads.workerData", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#worker_threadsworkerdata", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#worker_threadsworkerdata", "nodeStability": { "index": "2", "level": 2, @@ -79900,7 +84733,7 @@ "label": "locks", "signature": "`locks` {LockManager}", "apiSymbol": "locks", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html", "nodeStability": { "index": "1", "level": 1, @@ -79925,7 +84758,7 @@ "label": "Lock", "signature": "Class: `Lock`", "apiSymbol": "Lock", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-lock", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-lock", "nodeStability": { "index": "1", "level": 1, @@ -79950,7 +84783,7 @@ "label": "name", "signature": "`name` {string}", "apiSymbol": "name", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-lock", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-lock", "nodeStability": { "index": "1", "level": 1, @@ -79975,7 +84808,7 @@ "label": "mode", "signature": "`mode` {string}", "apiSymbol": "mode", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-lock", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-lock", "nodeStability": { "index": "1", "level": 1, @@ -80000,7 +84833,7 @@ "label": "LockManager", "signature": "Class: `LockManager`", "apiSymbol": "LockManager", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#class-lockmanager", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#class-lockmanager", "nodeStability": { "index": "1", "level": 1, @@ -80025,7 +84858,7 @@ "label": "locks.request(name[, options], callback)", "signature": "`locks.request(name[, options], callback)`", "apiSymbol": "locks.request", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#locksrequestname-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#locksrequestname-options-callback", "nodeStability": { "index": "1", "level": 1, @@ -80050,7 +84883,7 @@ "label": "locks.query()", "signature": "`locks.query()`", "apiSymbol": "locks.query", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/worker_threads.html#locksquery", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/worker_threads.html#locksquery", "nodeStability": { "index": "1", "level": 1, @@ -80069,13 +84902,413 @@ } } }, + { + "id": "zlib:b33e2218a29a", + "chapter": "zlib", + "label": "compressBrotli([options])", + "signature": "`compressBrotli([options])`", + "apiSymbol": "compressBrotli", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#compressbrotlioptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:f52bcb0441b4", + "chapter": "zlib", + "label": "compressBrotliSync([options])", + "signature": "`compressBrotliSync([options])`", + "apiSymbol": "compressBrotliSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#compressbrotlisyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:5d9b6e75680e", + "chapter": "zlib", + "label": "compressDeflate([options])", + "signature": "`compressDeflate([options])`", + "apiSymbol": "compressDeflate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#compressdeflateoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:2f423bd21cab", + "chapter": "zlib", + "label": "compressDeflateSync([options])", + "signature": "`compressDeflateSync([options])`", + "apiSymbol": "compressDeflateSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#compressdeflatesyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:14600f289b64", + "chapter": "zlib", + "label": "compressGzip([options])", + "signature": "`compressGzip([options])`", + "apiSymbol": "compressGzip", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#compressgzipoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:7354fd8fdadf", + "chapter": "zlib", + "label": "compressGzipSync([options])", + "signature": "`compressGzipSync([options])`", + "apiSymbol": "compressGzipSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#compressgzipsyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:c1b6e7dd5506", + "chapter": "zlib", + "label": "compressZstd([options])", + "signature": "`compressZstd([options])`", + "apiSymbol": "compressZstd", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#compresszstdoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:3ed321c39c37", + "chapter": "zlib", + "label": "compressZstdSync([options])", + "signature": "`compressZstdSync([options])`", + "apiSymbol": "compressZstdSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#compresszstdsyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:2c89860f52a5", + "chapter": "zlib", + "label": "decompressBrotli([options])", + "signature": "`decompressBrotli([options])`", + "apiSymbol": "decompressBrotli", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#decompressbrotlioptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:cb37070b5ee0", + "chapter": "zlib", + "label": "decompressBrotliSync([options])", + "signature": "`decompressBrotliSync([options])`", + "apiSymbol": "decompressBrotliSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#decompressbrotlisyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:d829a0b75f6c", + "chapter": "zlib", + "label": "decompressDeflate([options])", + "signature": "`decompressDeflate([options])`", + "apiSymbol": "decompressDeflate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#decompressdeflateoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:f1a96211af38", + "chapter": "zlib", + "label": "decompressDeflateSync([options])", + "signature": "`decompressDeflateSync([options])`", + "apiSymbol": "decompressDeflateSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#decompressdeflatesyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:b1209d1fe9bf", + "chapter": "zlib", + "label": "decompressGzip([options])", + "signature": "`decompressGzip([options])`", + "apiSymbol": "decompressGzip", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#decompressgzipoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:955fb7cb393c", + "chapter": "zlib", + "label": "decompressGzipSync([options])", + "signature": "`decompressGzipSync([options])`", + "apiSymbol": "decompressGzipSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#decompressgzipsyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:d9ea319f8e5e", + "chapter": "zlib", + "label": "decompressZstd([options])", + "signature": "`decompressZstd([options])`", + "apiSymbol": "decompressZstd", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#decompresszstdoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, + { + "id": "zlib:e0d0e947882d", + "chapter": "zlib", + "label": "decompressZstdSync([options])", + "signature": "`decompressZstdSync([options])`", + "apiSymbol": "decompressZstdSync", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#decompresszstdsyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "priority": "low", + "tiers": { + "static": { + "status": "not-implemented", + "action": "verify-gap", + "verification": "registry-gap", + "confidence": "low", + "source": "compiler-unmatched:zlib", + "tests": [] + } + } + }, { "id": "zlib:4b20a6571ae3", "chapter": "zlib", "label": "zlib.BrotliCompress", "signature": "Class: `zlib.BrotliCompress`", "apiSymbol": "zlib.BrotliCompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibbrotlicompress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibbrotlicompress", "nodeStability": { "index": "2", "level": 2, @@ -80100,7 +85333,7 @@ "label": "zlib.BrotliDecompress", "signature": "Class: `zlib.BrotliDecompress`", "apiSymbol": "zlib.BrotliDecompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibbrotlidecompress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibbrotlidecompress", "nodeStability": { "index": "2", "level": 2, @@ -80125,7 +85358,7 @@ "label": "zlib.Deflate", "signature": "Class: `zlib.Deflate`", "apiSymbol": "zlib.Deflate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibdeflate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibdeflate", "nodeStability": { "index": "2", "level": 2, @@ -80150,7 +85383,7 @@ "label": "zlib.DeflateRaw", "signature": "Class: `zlib.DeflateRaw`", "apiSymbol": "zlib.DeflateRaw", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibdeflateraw", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibdeflateraw", "nodeStability": { "index": "2", "level": 2, @@ -80175,7 +85408,7 @@ "label": "zlib.Gunzip", "signature": "Class: `zlib.Gunzip`", "apiSymbol": "zlib.Gunzip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibgunzip", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibgunzip", "nodeStability": { "index": "2", "level": 2, @@ -80200,7 +85433,7 @@ "label": "zlib.Gzip", "signature": "Class: `zlib.Gzip`", "apiSymbol": "zlib.Gzip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibgzip", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibgzip", "nodeStability": { "index": "2", "level": 2, @@ -80225,7 +85458,7 @@ "label": "zlib.Inflate", "signature": "Class: `zlib.Inflate`", "apiSymbol": "zlib.Inflate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibinflate", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibinflate", "nodeStability": { "index": "2", "level": 2, @@ -80250,7 +85483,7 @@ "label": "zlib.InflateRaw", "signature": "Class: `zlib.InflateRaw`", "apiSymbol": "zlib.InflateRaw", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibinflateraw", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibinflateraw", "nodeStability": { "index": "2", "level": 2, @@ -80275,7 +85508,7 @@ "label": "zlib.Unzip", "signature": "Class: `zlib.Unzip`", "apiSymbol": "zlib.Unzip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibunzip", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibunzip", "nodeStability": { "index": "2", "level": 2, @@ -80300,7 +85533,7 @@ "label": "zlib.ZlibBase", "signature": "Class: `zlib.ZlibBase`", "apiSymbol": "zlib.ZlibBase", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibzlibbase", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibzlibbase", "nodeStability": { "index": "2", "level": 2, @@ -80325,7 +85558,7 @@ "label": "zlib.close([callback])", "signature": "`zlib.close([callback])`", "apiSymbol": "zlib.close", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibclosecallback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibclosecallback", "nodeStability": { "index": "2", "level": 2, @@ -80350,7 +85583,7 @@ "label": "zlib.flush([kind, ]callback)", "signature": "`zlib.flush([kind, ]callback)`", "apiSymbol": "zlib.flush", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibflushkind-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibflushkind-callback", "nodeStability": { "index": "2", "level": 2, @@ -80375,7 +85608,7 @@ "label": "zlib.params(level, strategy, callback)", "signature": "`zlib.params(level, strategy, callback)`", "apiSymbol": "zlib.params", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibparamslevel-strategy-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibparamslevel-strategy-callback", "nodeStability": { "index": "2", "level": 2, @@ -80400,7 +85633,7 @@ "label": "zlib.reset()", "signature": "`zlib.reset()`", "apiSymbol": "zlib.reset", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibreset", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibreset", "nodeStability": { "index": "2", "level": 2, @@ -80425,7 +85658,7 @@ "label": "bytesWritten", "signature": "`bytesWritten` Type: {number}", "apiSymbol": "bytesWritten", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibzlibbase", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibzlibbase", "nodeStability": { "index": "2", "level": 2, @@ -80450,7 +85683,7 @@ "label": "zlib.ZstdCompress", "signature": "Class: `zlib.ZstdCompress`", "apiSymbol": "zlib.ZstdCompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibzstdcompress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibzstdcompress", "nodeStability": { "index": "1", "level": 1, @@ -80475,7 +85708,7 @@ "label": "zlib.ZstdDecompress", "signature": "Class: `zlib.ZstdDecompress`", "apiSymbol": "zlib.ZstdDecompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zlibzstddecompress", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zlibzstddecompress", "nodeStability": { "index": "1", "level": 1, @@ -80500,7 +85733,7 @@ "label": "zlib.crc32(data[, value])", "signature": "`zlib.crc32(data[, value])`", "apiSymbol": "zlib.crc32", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibcrc32data-value", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibcrc32data-value", "nodeStability": { "index": "2", "level": 2, @@ -80529,7 +85762,7 @@ "label": "zlib.createBrotliCompress([options])", "signature": "`zlib.createBrotliCompress([options])`", "apiSymbol": "zlib.createBrotliCompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibcreatebrotlicompressoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibcreatebrotlicompressoptions", "nodeStability": { "index": "2", "level": 2, @@ -80554,7 +85787,7 @@ "label": "zlib.createBrotliDecompress([options])", "signature": "`zlib.createBrotliDecompress([options])`", "apiSymbol": "zlib.createBrotliDecompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibcreatebrotlidecompressoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibcreatebrotlidecompressoptions", "nodeStability": { "index": "2", "level": 2, @@ -80579,7 +85812,7 @@ "label": "zlib.createDeflate([options])", "signature": "`zlib.createDeflate([options])`", "apiSymbol": "zlib.createDeflate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibcreatedeflateoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibcreatedeflateoptions", "nodeStability": { "index": "2", "level": 2, @@ -80604,7 +85837,7 @@ "label": "zlib.createDeflateRaw([options])", "signature": "`zlib.createDeflateRaw([options])`", "apiSymbol": "zlib.createDeflateRaw", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibcreatedeflaterawoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibcreatedeflaterawoptions", "nodeStability": { "index": "2", "level": 2, @@ -80629,7 +85862,7 @@ "label": "zlib.createGunzip([options])", "signature": "`zlib.createGunzip([options])`", "apiSymbol": "zlib.createGunzip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibcreategunzipoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibcreategunzipoptions", "nodeStability": { "index": "2", "level": 2, @@ -80654,7 +85887,7 @@ "label": "zlib.createGzip([options])", "signature": "`zlib.createGzip([options])`", "apiSymbol": "zlib.createGzip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibcreategzipoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibcreategzipoptions", "nodeStability": { "index": "2", "level": 2, @@ -80679,7 +85912,7 @@ "label": "zlib.createInflate([options])", "signature": "`zlib.createInflate([options])`", "apiSymbol": "zlib.createInflate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibcreateinflateoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibcreateinflateoptions", "nodeStability": { "index": "2", "level": 2, @@ -80704,7 +85937,7 @@ "label": "zlib.createInflateRaw([options])", "signature": "`zlib.createInflateRaw([options])`", "apiSymbol": "zlib.createInflateRaw", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibcreateinflaterawoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibcreateinflaterawoptions", "nodeStability": { "index": "2", "level": 2, @@ -80729,7 +85962,7 @@ "label": "zlib.createUnzip([options])", "signature": "`zlib.createUnzip([options])`", "apiSymbol": "zlib.createUnzip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibcreateunzipoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibcreateunzipoptions", "nodeStability": { "index": "2", "level": 2, @@ -80754,7 +85987,7 @@ "label": "zlib.createZstdCompress([options])", "signature": "`zlib.createZstdCompress([options])`", "apiSymbol": "zlib.createZstdCompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibcreatezstdcompressoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibcreatezstdcompressoptions", "nodeStability": { "index": "1", "level": 1, @@ -80779,7 +86012,7 @@ "label": "zlib.createZstdDecompress([options])", "signature": "`zlib.createZstdDecompress([options])`", "apiSymbol": "zlib.createZstdDecompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibcreatezstddecompressoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibcreatezstddecompressoptions", "nodeStability": { "index": "1", "level": 1, @@ -80804,7 +86037,7 @@ "label": "zlib.brotliCompress(buffer[, options], callback)", "signature": "`zlib.brotliCompress(buffer[, options], callback)`", "apiSymbol": "zlib.brotliCompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibbrotlicompressbuffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibbrotlicompressbuffer-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -80829,7 +86062,7 @@ "label": "zlib.brotliCompressSync(buffer[, options])", "signature": "`zlib.brotliCompressSync(buffer[, options])`", "apiSymbol": "zlib.brotliCompressSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibbrotlicompresssyncbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibbrotlicompresssyncbuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -80854,7 +86087,7 @@ "label": "zlib.brotliDecompress(buffer[, options], callback)", "signature": "`zlib.brotliDecompress(buffer[, options], callback)`", "apiSymbol": "zlib.brotliDecompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibbrotlidecompressbuffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibbrotlidecompressbuffer-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -80879,7 +86112,7 @@ "label": "zlib.brotliDecompressSync(buffer[, options])", "signature": "`zlib.brotliDecompressSync(buffer[, options])`", "apiSymbol": "zlib.brotliDecompressSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibbrotlidecompresssyncbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibbrotlidecompresssyncbuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -80904,7 +86137,7 @@ "label": "zlib.deflate(buffer[, options], callback)", "signature": "`zlib.deflate(buffer[, options], callback)`", "apiSymbol": "zlib.deflate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibdeflatebuffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibdeflatebuffer-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -80933,7 +86166,7 @@ "label": "zlib.deflateSync(buffer[, options])", "signature": "`zlib.deflateSync(buffer[, options])`", "apiSymbol": "zlib.deflateSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibdeflatesyncbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibdeflatesyncbuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -80962,7 +86195,7 @@ "label": "zlib.deflateRaw(buffer[, options], callback)", "signature": "`zlib.deflateRaw(buffer[, options], callback)`", "apiSymbol": "zlib.deflateRaw", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibdeflaterawbuffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibdeflaterawbuffer-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -80991,7 +86224,7 @@ "label": "zlib.deflateRawSync(buffer[, options])", "signature": "`zlib.deflateRawSync(buffer[, options])`", "apiSymbol": "zlib.deflateRawSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibdeflaterawsyncbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibdeflaterawsyncbuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -81020,7 +86253,7 @@ "label": "zlib.gunzip(buffer[, options], callback)", "signature": "`zlib.gunzip(buffer[, options], callback)`", "apiSymbol": "zlib.gunzip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibgunzipbuffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibgunzipbuffer-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -81049,7 +86282,7 @@ "label": "zlib.gunzipSync(buffer[, options])", "signature": "`zlib.gunzipSync(buffer[, options])`", "apiSymbol": "zlib.gunzipSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibgunzipsyncbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibgunzipsyncbuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -81078,7 +86311,7 @@ "label": "zlib.gzip(buffer[, options], callback)", "signature": "`zlib.gzip(buffer[, options], callback)`", "apiSymbol": "zlib.gzip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibgzipbuffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibgzipbuffer-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -81107,7 +86340,7 @@ "label": "zlib.gzipSync(buffer[, options])", "signature": "`zlib.gzipSync(buffer[, options])`", "apiSymbol": "zlib.gzipSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibgzipsyncbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibgzipsyncbuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -81136,7 +86369,7 @@ "label": "zlib.inflate(buffer[, options], callback)", "signature": "`zlib.inflate(buffer[, options], callback)`", "apiSymbol": "zlib.inflate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibinflatebuffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibinflatebuffer-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -81165,7 +86398,7 @@ "label": "zlib.inflateSync(buffer[, options])", "signature": "`zlib.inflateSync(buffer[, options])`", "apiSymbol": "zlib.inflateSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibinflatesyncbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibinflatesyncbuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -81194,7 +86427,7 @@ "label": "zlib.inflateRaw(buffer[, options], callback)", "signature": "`zlib.inflateRaw(buffer[, options], callback)`", "apiSymbol": "zlib.inflateRaw", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibinflaterawbuffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibinflaterawbuffer-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -81223,7 +86456,7 @@ "label": "zlib.inflateRawSync(buffer[, options])", "signature": "`zlib.inflateRawSync(buffer[, options])`", "apiSymbol": "zlib.inflateRawSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibinflaterawsyncbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibinflaterawsyncbuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -81252,7 +86485,7 @@ "label": "zlib.unzip(buffer[, options], callback)", "signature": "`zlib.unzip(buffer[, options], callback)`", "apiSymbol": "zlib.unzip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibunzipbuffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibunzipbuffer-options-callback", "nodeStability": { "index": "2", "level": 2, @@ -81281,7 +86514,7 @@ "label": "zlib.unzipSync(buffer[, options])", "signature": "`zlib.unzipSync(buffer[, options])`", "apiSymbol": "zlib.unzipSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibunzipsyncbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibunzipsyncbuffer-options", "nodeStability": { "index": "2", "level": 2, @@ -81310,7 +86543,7 @@ "label": "zlib.zstdCompress(buffer[, options], callback)", "signature": "`zlib.zstdCompress(buffer[, options], callback)`", "apiSymbol": "zlib.zstdCompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibzstdcompressbuffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibzstdcompressbuffer-options-callback", "nodeStability": { "index": "1", "level": 1, @@ -81335,7 +86568,7 @@ "label": "zlib.zstdCompressSync(buffer[, options])", "signature": "`zlib.zstdCompressSync(buffer[, options])`", "apiSymbol": "zlib.zstdCompressSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibzstdcompresssyncbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibzstdcompresssyncbuffer-options", "nodeStability": { "index": "1", "level": 1, @@ -81360,14 +86593,14 @@ "label": "zlib.zstdDecompress(buffer[, options], callback)", "signature": "`zlib.zstdDecompress(buffer[, options], callback)`", "apiSymbol": "zlib.zstdDecompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibzstddecompressbuffer-options-callback", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibzstddecompressbuffer-options-callback", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false }, - "priority": "high", + "priority": "low", "tiers": { "static": { "status": "not-implemented", @@ -81385,7 +86618,7 @@ "label": "zlib.zstdDecompressSync(buffer[, options])", "signature": "`zlib.zstdDecompressSync(buffer[, options])`", "apiSymbol": "zlib.zstdDecompressSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibzstddecompresssyncbuffer-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibzstddecompresssyncbuffer-options", "nodeStability": { "index": "1", "level": 1, @@ -81410,7 +86643,7 @@ "label": "zlib.constants", "signature": "`zlib.constants`", "apiSymbol": "zlib.constants", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#zlibconstants", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#zlibconstants", "nodeStability": { "index": "2", "level": 2, @@ -81435,7 +86668,7 @@ "label": "Options", "signature": "Class: `Options`", "apiSymbol": "Options", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-options", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-options", "nodeStability": { "index": "2", "level": 2, @@ -81460,7 +86693,7 @@ "label": "BrotliOptions", "signature": "Class: `BrotliOptions`", "apiSymbol": "BrotliOptions", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-brotlioptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-brotlioptions", "nodeStability": { "index": "2", "level": 2, @@ -81485,7 +86718,7 @@ "label": "ZstdOptions", "signature": "Class: `ZstdOptions`", "apiSymbol": "ZstdOptions", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#class-zstdoptions", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#class-zstdoptions", "nodeStability": { "index": "1", "level": 1, @@ -81510,7 +86743,7 @@ "label": "zlib.brotliCompress(buffer[, options], callback)", "signature": "`zlib.brotliCompress(buffer[, options], callback)`", "apiSymbol": "zlib.brotliCompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81535,7 +86768,7 @@ "label": "zlib.brotliCompressSync(buffer[, options])", "signature": "`zlib.brotliCompressSync(buffer[, options])`", "apiSymbol": "zlib.brotliCompressSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81560,7 +86793,7 @@ "label": "zlib.brotliDecompress(buffer[, options], callback)", "signature": "`zlib.brotliDecompress(buffer[, options], callback)`", "apiSymbol": "zlib.brotliDecompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81585,7 +86818,7 @@ "label": "zlib.brotliDecompressSync(buffer[, options])", "signature": "`zlib.brotliDecompressSync(buffer[, options])`", "apiSymbol": "zlib.brotliDecompressSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81610,7 +86843,7 @@ "label": "zlib.deflate(buffer[, options], callback)", "signature": "`zlib.deflate(buffer[, options], callback)`", "apiSymbol": "zlib.deflate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81639,7 +86872,7 @@ "label": "zlib.deflateSync(buffer[, options])", "signature": "`zlib.deflateSync(buffer[, options])`", "apiSymbol": "zlib.deflateSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81668,7 +86901,7 @@ "label": "zlib.deflateRaw(buffer[, options], callback)", "signature": "`zlib.deflateRaw(buffer[, options], callback)`", "apiSymbol": "zlib.deflateRaw", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81697,7 +86930,7 @@ "label": "zlib.deflateRawSync(buffer[, options])", "signature": "`zlib.deflateRawSync(buffer[, options])`", "apiSymbol": "zlib.deflateRawSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81726,7 +86959,7 @@ "label": "zlib.gunzip(buffer[, options], callback)", "signature": "`zlib.gunzip(buffer[, options], callback)`", "apiSymbol": "zlib.gunzip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81755,7 +86988,7 @@ "label": "zlib.gunzipSync(buffer[, options])", "signature": "`zlib.gunzipSync(buffer[, options])`", "apiSymbol": "zlib.gunzipSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81784,7 +87017,7 @@ "label": "zlib.gzip(buffer[, options], callback)", "signature": "`zlib.gzip(buffer[, options], callback)`", "apiSymbol": "zlib.gzip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81813,7 +87046,7 @@ "label": "zlib.gzipSync(buffer[, options])", "signature": "`zlib.gzipSync(buffer[, options])`", "apiSymbol": "zlib.gzipSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81842,7 +87075,7 @@ "label": "zlib.inflate(buffer[, options], callback)", "signature": "`zlib.inflate(buffer[, options], callback)`", "apiSymbol": "zlib.inflate", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81871,7 +87104,7 @@ "label": "zlib.inflateSync(buffer[, options])", "signature": "`zlib.inflateSync(buffer[, options])`", "apiSymbol": "zlib.inflateSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81900,7 +87133,7 @@ "label": "zlib.inflateRaw(buffer[, options], callback)", "signature": "`zlib.inflateRaw(buffer[, options], callback)`", "apiSymbol": "zlib.inflateRaw", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81929,7 +87162,7 @@ "label": "zlib.inflateRawSync(buffer[, options])", "signature": "`zlib.inflateRawSync(buffer[, options])`", "apiSymbol": "zlib.inflateRawSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81958,7 +87191,7 @@ "label": "zlib.unzip(buffer[, options], callback)", "signature": "`zlib.unzip(buffer[, options], callback)`", "apiSymbol": "zlib.unzip", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -81987,7 +87220,7 @@ "label": "zlib.unzipSync(buffer[, options])", "signature": "`zlib.unzipSync(buffer[, options])`", "apiSymbol": "zlib.unzipSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "2", "level": 2, @@ -82016,7 +87249,7 @@ "label": "zlib.zstdCompress(buffer[, options], callback)", "signature": "`zlib.zstdCompress(buffer[, options], callback)`", "apiSymbol": "zlib.zstdCompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "1", "level": 1, @@ -82041,7 +87274,7 @@ "label": "zlib.zstdCompressSync(buffer[, options])", "signature": "`zlib.zstdCompressSync(buffer[, options])`", "apiSymbol": "zlib.zstdCompressSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "1", "level": 1, @@ -82066,14 +87299,14 @@ "label": "zlib.zstdDecompress(buffer[, options], callback)", "signature": "`zlib.zstdDecompress(buffer[, options], callback)`", "apiSymbol": "zlib.zstdDecompress", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false }, - "priority": "high", + "priority": "low", "tiers": { "static": { "status": "not-implemented", @@ -82091,7 +87324,7 @@ "label": "zlib.zstdDecompressSync(buffer[, options])", "signature": "`zlib.zstdDecompressSync(buffer[, options])`", "apiSymbol": "zlib.zstdDecompressSync", - "docsUrl": "https://nodejs.org/docs/v24.15.0/api/zlib.html#convenience-methods", + "docsUrl": "https://nodejs.org/docs/v24.22.0/api/zlib.html#convenience-methods", "nodeStability": { "index": "1", "level": 1, diff --git a/internal/compatibility/generated/node-v24-internal.json b/internal/compatibility/generated/node-v24-internal.json index 64ab183f78..bf427e071d 100644 --- a/internal/compatibility/generated/node-v24-internal.json +++ b/internal/compatibility/generated/node-v24-internal.json @@ -1,18 +1,18 @@ { "schemaVersion": 5, - "nodeVersion": "24.15.0", - "nodeTag": "v24.15.0", - "nodeCommit": "848430679556aed0bd073f2bc263331ad84fa119", + "nodeVersion": "24.22.0", + "nodeTag": "v24.22.0", + "nodeCommit": "f14cd3aa7bf9ca8df2cc5b8bb14beb0f335b1d93", "sources": { "allJson": { - "url": "https://nodejs.org/download/release/v24.15.0/docs/api/all.json", - "sha256": "ad66cf85ee273e20ede86b6864cc6ecd1ae6d9ea44f2011e75f4427223f7d16c" + "url": "https://nodejs.org/download/release/v24.22.0/docs/api/all.json", + "sha256": "2445f57511c86b2b8129b3fd8423811fd8b32d1eccc1e54d8c747e823f65be27" }, "indexMarkdown": { - "url": "https://nodejs.org/docs/v24.15.0/api/index.md", - "sha256": "616b1d2c1cd02854963db4598c5ce9dcd633464e1534830be3f55ab714e255c4" + "url": "https://nodejs.org/docs/v24.22.0/api/index.md", + "sha256": "c63ecaedc4a35de0823706cc72ce76cd10e712ce50eaca829bb2eefe1fc2ded2" }, - "sourceBaseUrl": "https://github.com/nodejs/node/tree/848430679556aed0bd073f2bc263331ad84fa119" + "sourceBaseUrl": "https://github.com/nodejs/node/tree/f14cd3aa7bf9ca8df2cc5b8bb14beb0f335b1d93" }, "supportManifests": { "compilerSurface": "packages/compiler/surface-manifest.json", @@ -37,13 +37,13 @@ { "slug": "async_context", "title": "Asynchronous context tracking", - "entries": 19, - "apiEntries": 17, + "entries": 22, + "apiEntries": 20, "static": { "supported": 0, "partial": 7, "refused": 0, - "not-implemented": 10, + "not-implemented": 13, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -67,13 +67,13 @@ { "slug": "buffer", "title": "Buffer", - "entries": 103, - "apiEntries": 98, + "entries": 104, + "apiEntries": 99, "static": { "supported": 8, "partial": 4, "refused": 0, - "not-implemented": 86, + "not-implemented": 87, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -97,14 +97,14 @@ { "slug": "n-api", "title": "C/C++ addons with Node-API", - "entries": 242, - "apiEntries": 191, + "entries": 243, + "apiEntries": 192, "static": { "supported": 0, "partial": 0, "refused": 0, "not-implemented": 0, - "by-design": 191, + "by-design": 192, "unreviewed": 0, "not-applicable": 0 } @@ -157,7 +157,7 @@ { "slug": "cli", "title": "Command-line options", - "entries": 237, + "entries": 246, "apiEntries": 1, "static": { "supported": 0, @@ -187,13 +187,13 @@ { "slug": "crypto", "title": "Crypto", - "entries": 167, - "apiEntries": 145, + "entries": 179, + "apiEntries": 152, "static": { "supported": 0, "partial": 22, "refused": 26, - "not-implemented": 97, + "not-implemented": 104, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -202,7 +202,7 @@ { "slug": "debugger", "title": "Debugger", - "entries": 10, + "entries": 18, "apiEntries": 1, "static": { "supported": 0, @@ -217,7 +217,7 @@ { "slug": "deprecations", "title": "Deprecated APIs", - "entries": 205, + "entries": 208, "apiEntries": 1, "static": { "supported": 0, @@ -232,13 +232,13 @@ { "slug": "diagnostics_channel", "title": "Diagnostics Channel", - "entries": 82, - "apiEntries": 69, + "entries": 86, + "apiEntries": 71, "static": { "supported": 0, "partial": 8, "refused": 0, - "not-implemented": 61, + "not-implemented": 63, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -292,13 +292,13 @@ { "slug": "errors", "title": "Errors", - "entries": 475, - "apiEntries": 461, + "entries": 492, + "apiEntries": 478, "static": { "supported": 0, "partial": 8, "refused": 0, - "not-implemented": 453, + "not-implemented": 470, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -322,13 +322,13 @@ { "slug": "fs", "title": "File system", - "entries": 308, - "apiEntries": 276, + "entries": 312, + "apiEntries": 280, "static": { "supported": 7, "partial": 98, "refused": 0, - "not-implemented": 171, + "not-implemented": 175, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -352,13 +352,13 @@ { "slug": "http", "title": "HTTP", - "entries": 176, - "apiEntries": 174, + "entries": 180, + "apiEntries": 176, "static": { "supported": 0, "partial": 131, "refused": 0, - "not-implemented": 43, + "not-implemented": 45, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -367,13 +367,13 @@ { "slug": "http2", "title": "HTTP/2", - "entries": 184, - "apiEntries": 167, + "entries": 188, + "apiEntries": 168, "static": { "supported": 0, "partial": 14, "refused": 2, - "not-implemented": 151, + "not-implemented": 152, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -397,13 +397,13 @@ { "slug": "inspector", "title": "Inspector", - "entries": 39, - "apiEntries": 30, + "entries": 44, + "apiEntries": 35, "static": { "supported": 0, "partial": 0, "refused": 0, - "not-implemented": 30, + "not-implemented": 35, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -424,6 +424,21 @@ "not-applicable": 1 } }, + { + "slug": "stream_iter", + "title": "Iterable Streams API", + "entries": 87, + "apiEntries": 65, + "static": { + "supported": 0, + "partial": 0, + "refused": 0, + "not-implemented": 65, + "by-design": 0, + "unreviewed": 0, + "not-applicable": 0 + } + }, { "slug": "modules", "title": "Modules: CommonJS modules", @@ -442,7 +457,7 @@ { "slug": "esm", "title": "Modules: ECMAScript modules", - "entries": 46, + "entries": 47, "apiEntries": 22, "static": { "supported": 0, @@ -472,7 +487,7 @@ { "slug": "packages", "title": "Modules: Packages", - "entries": 30, + "entries": 37, "apiEntries": 8, "static": { "supported": 0, @@ -502,13 +517,13 @@ { "slug": "net", "title": "Net", - "entries": 102, - "apiEntries": 100, + "entries": 122, + "apiEntries": 119, "static": { "supported": 0, "partial": 34, "refused": 0, - "not-implemented": 66, + "not-implemented": 85, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -547,13 +562,13 @@ { "slug": "perf_hooks", "title": "Performance hooks", - "entries": 106, - "apiEntries": 96, + "entries": 150, + "apiEntries": 131, "static": { "supported": 0, "partial": 19, "refused": 0, - "not-implemented": 77, + "not-implemented": 112, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -562,13 +577,13 @@ { "slug": "permissions", "title": "Permissions", - "entries": 9, - "apiEntries": 3, + "entries": 13, + "apiEntries": 4, "static": { "supported": 0, "partial": 0, "refused": 0, - "not-implemented": 3, + "not-implemented": 4, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -577,13 +592,13 @@ { "slug": "process", "title": "Process", - "entries": 126, - "apiEntries": 119, + "entries": 127, + "apiEntries": 120, "static": { "supported": 0, "partial": 50, "refused": 0, - "not-implemented": 69, + "not-implemented": 70, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -637,7 +652,7 @@ { "slug": "repl", "title": "REPL", - "entries": 30, + "entries": 31, "apiEntries": 14, "static": { "supported": 0, @@ -682,13 +697,13 @@ { "slug": "sqlite", "title": "SQLite", - "entries": 54, - "apiEntries": 48, + "entries": 59, + "apiEntries": 52, "static": { "supported": 0, "partial": 0, "refused": 0, - "not-implemented": 48, + "not-implemented": 52, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -697,13 +712,13 @@ { "slug": "stream", "title": "Stream", - "entries": 167, - "apiEntries": 137, + "entries": 170, + "apiEntries": 140, "static": { "supported": 0, "partial": 38, "refused": 0, - "not-implemented": 99, + "not-implemented": 102, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -727,13 +742,13 @@ { "slug": "test", "title": "Test runner", - "entries": 130, - "apiEntries": 105, + "entries": 151, + "apiEntries": 117, "static": { "supported": 0, - "partial": 21, + "partial": 20, "refused": 0, - "not-implemented": 84, + "not-implemented": 97, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -757,13 +772,13 @@ { "slug": "tls", "title": "TLS/SSL", - "entries": 79, - "apiEntries": 64, + "entries": 82, + "apiEntries": 67, "static": { "supported": 0, "partial": 7, "refused": 4, - "not-implemented": 53, + "not-implemented": 56, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -787,13 +802,13 @@ { "slug": "tty", "title": "TTY", - "entries": 18, - "apiEntries": 18, + "entries": 19, + "apiEntries": 19, "static": { "supported": 0, "partial": 7, "refused": 0, - "not-implemented": 11, + "not-implemented": 12, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -802,13 +817,13 @@ { "slug": "dgram", "title": "UDP/datagram", - "entries": 38, - "apiEntries": 36, + "entries": 40, + "apiEntries": 38, "static": { "supported": 0, "partial": 12, "refused": 0, - "not-implemented": 24, + "not-implemented": 26, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -832,13 +847,13 @@ { "slug": "util", "title": "Utilities", - "entries": 114, - "apiEntries": 105, + "entries": 118, + "apiEntries": 109, "static": { "supported": 0, "partial": 53, "refused": 0, - "not-implemented": 52, + "not-implemented": 56, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -892,13 +907,13 @@ { "slug": "webcrypto", "title": "Web Crypto API", - "entries": 167, - "apiEntries": 148, + "entries": 176, + "apiEntries": 156, "static": { "supported": 0, "partial": 11, "refused": 0, - "not-implemented": 137, + "not-implemented": 145, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -907,13 +922,13 @@ { "slug": "webstreams", "title": "Web Streams API", - "entries": 95, - "apiEntries": 88, + "entries": 96, + "apiEntries": 89, "static": { "supported": 0, "partial": 7, "refused": 1, - "not-implemented": 80, + "not-implemented": 81, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -937,13 +952,13 @@ { "slug": "zlib", "title": "Zlib", - "entries": 98, - "apiEntries": 78, + "entries": 115, + "apiEntries": 94, "static": { "supported": 0, "partial": 30, "refused": 4, - "not-implemented": 44, + "not-implemented": 60, "by-design": 0, "unreviewed": 0, "not-applicable": 0 @@ -2115,6 +2130,29 @@ }, "anchorSource": "exact" }, + { + "id": "async_context:1da031ae1416", + "chapter": "async_context", + "kind": "method", + "name": "withScope", + "signature": "`asyncLocalStorage.withScope(store)`", + "label": "asyncLocalStorage.withScope(store)", + "apiSymbol": "asyncLocalStorage.withScope", + "depth": 2, + "scope": "api", + "anchor": "asynclocalstoragewithscopestore", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:async_context" + }, + "anchorSource": "exact" + }, { "id": "async_context:c3f9e759e7a3", "chapter": "async_context", @@ -2138,6 +2176,52 @@ }, "anchorSource": "ancestor" }, + { + "id": "async_context:f017c310f23c", + "chapter": "async_context", + "kind": "class", + "name": "RunScope", + "signature": "Class: `RunScope`", + "label": "RunScope", + "apiSymbol": "RunScope", + "depth": 1, + "scope": "api", + "anchor": "class-runscope", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:async_context" + }, + "anchorSource": "exact" + }, + { + "id": "async_context:61f0464afb64", + "chapter": "async_context", + "kind": "method", + "name": "dispose", + "signature": "`scope.dispose()`", + "label": "scope.dispose()", + "apiSymbol": "scope.dispose", + "depth": 2, + "scope": "api", + "anchor": "scopedispose", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:async_context" + }, + "anchorSource": "exact" + }, { "id": "async_context:509d8ed918da", "chapter": "async_context", @@ -3668,6 +3752,29 @@ }, "anchorSource": "exact" }, + { + "id": "buffer:00e095984e8b", + "chapter": "buffer", + "kind": "method", + "name": "textStream", + "signature": "`blob.textStream()`", + "label": "blob.textStream()", + "apiSymbol": "blob.textStream", + "depth": 2, + "scope": "api", + "anchor": "blobtextstream", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:buffer" + }, + "anchorSource": "exact" + }, { "id": "buffer:fe2720024378", "chapter": "buffer", @@ -3853,16 +3960,16 @@ "anchorSource": "exact" }, { - "id": "buffer:036238ad6edd", + "id": "buffer:32a0b4015b4d", "chapter": "buffer", "kind": "method", "name": "includes", - "signature": "`buf.includes(value[, byteOffset][, encoding])`", - "label": "buf.includes(value[, byteOffset][, encoding])", + "signature": "`buf.includes(value[, start[, end]][, encoding])`", + "label": "buf.includes(value[, start[, end]][, encoding])", "apiSymbol": "buf.includes", "depth": 2, "scope": "api", - "anchor": "bufincludesvalue-byteoffset-encoding", + "anchor": "bufincludesvalue-start-end-encoding", "nodeStability": { "index": "2", "level": 2, @@ -3876,16 +3983,16 @@ "anchorSource": "exact" }, { - "id": "buffer:4bb2e1c043ab", + "id": "buffer:1b0e4fe87f7d", "chapter": "buffer", "kind": "method", "name": "indexOf", - "signature": "`buf.indexOf(value[, byteOffset][, encoding])`", - "label": "buf.indexOf(value[, byteOffset][, encoding])", + "signature": "`buf.indexOf(value[, start[, end]][, encoding])`", + "label": "buf.indexOf(value[, start[, end]][, encoding])", "apiSymbol": "buf.indexOf", "depth": 2, "scope": "api", - "anchor": "bufindexofvalue-byteoffset-encoding", + "anchor": "bufindexofvalue-start-end-encoding", "nodeStability": { "index": "2", "level": 2, @@ -3922,16 +4029,16 @@ "anchorSource": "exact" }, { - "id": "buffer:0f29211b95db", + "id": "buffer:34a6c0cba92a", "chapter": "buffer", "kind": "method", "name": "lastIndexOf", - "signature": "`buf.lastIndexOf(value[, byteOffset][, encoding])`", - "label": "buf.lastIndexOf(value[, byteOffset][, encoding])", + "signature": "`buf.lastIndexOf(value[, start[, end]][, encoding])`", + "label": "buf.lastIndexOf(value[, start[, end]][, encoding])", "apiSymbol": "buf.lastIndexOf", "depth": 2, "scope": "api", - "anchor": "buflastindexofvalue-byteoffset-encoding", + "anchor": "buflastindexofvalue-start-end-encoding", "nodeStability": { "index": "2", "level": 2, @@ -5196,11 +5303,11 @@ "anchorSource": "exact" }, { - "id": "buffer:a12afe3296c9", + "id": "buffer:06a34306775b", "chapter": "buffer", "kind": "integer", "name": "Type", - "signature": "`poolSize` Type: {integer} **Default:** `8192`", + "signature": "`poolSize` Type: {integer} **Default:** `65536`", "label": "poolSize", "apiSymbol": "poolSize", "depth": 2, @@ -7967,6 +8074,29 @@ }, "anchorSource": "exact" }, + { + "id": "n-api:63a7b5cc3191", + "chapter": "n-api", + "kind": "module", + "name": "`node_api_create_external_sharedarraybuffer`", + "signature": "`node_api_create_external_sharedarraybuffer`", + "label": "node_api_create_external_sharedarraybuffer", + "apiSymbol": "node_api_create_external_sharedarraybuffer", + "depth": 3, + "scope": "api", + "anchor": "node_api_create_external_sharedarraybuffer", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "by-design", + "evidence": "compiler-chapter-policy:n-api" + }, + "anchorSource": "exact" + }, { "id": "n-api:5d9ef3c614d9", "chapter": "n-api", @@ -13552,6 +13682,29 @@ }, "anchorSource": "exact" }, + { + "id": "cli:cca4a6553811", + "chapter": "cli", + "kind": "module", + "name": "`--allow-openssl-store`", + "signature": "`--allow-openssl-store`", + "label": "--allow-openssl-store", + "apiSymbol": "--allow-openssl-store", + "depth": 2, + "scope": "configuration", + "anchor": "--allow-openssl-store", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "configuration" + }, + "anchorSource": "exact" + }, { "id": "cli:c79231d42230", "chapter": "cli", @@ -13886,10 +14039,10 @@ "scope": "configuration", "anchor": "--disable-warningcode-or-type", "nodeStability": { - "index": "1.1", - "level": 1, - "text": "Active development", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-applicable", @@ -13989,6 +14142,29 @@ }, "anchorSource": "exact" }, + { + "id": "cli:293358e0970e", + "chapter": "cli", + "kind": "module", + "name": "`--enable-fips-indicator-events`", + "signature": "`--enable-fips-indicator-events`", + "label": "--enable-fips-indicator-events", + "apiSymbol": "--enable-fips-indicator-events", + "depth": 2, + "scope": "configuration", + "anchor": "--enable-fips-indicator-events", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "configuration" + }, + "anchorSource": "exact" + }, { "id": "cli:c77c57884fa6", "chapter": "cli", @@ -14139,9 +14315,9 @@ "scope": "configuration", "anchor": "--experimental-addon-modules", "nodeStability": { - "index": "1.0", + "index": "1.2", "level": 1, - "text": "Early development", + "text": "Release candidate", "inherited": false }, "static": { @@ -14151,16 +14327,16 @@ "anchorSource": "exact" }, { - "id": "cli:f064fad60fae", + "id": "cli:eb5e15c038bf", "chapter": "cli", "kind": "module", - "name": "`--experimental-config-file=config`", - "signature": "`--experimental-config-file=config`", - "label": "--experimental-config-file=config", + "name": "`--experimental-config-file=path`,_`--experimental-config-file`", + "signature": "`--experimental-config-file=path`, `--experimental-config-file`", + "label": "--experimental-config-file=path", "apiSymbol": "--experimental-config-file", "depth": 2, "scope": "configuration", - "anchor": "--experimental-config-fileconfig", + "anchor": "--experimental-config-filepath---experimental-config-file", "nodeStability": { "index": "1.0", "level": 1, @@ -14242,6 +14418,29 @@ }, "anchorSource": "exact" }, + { + "id": "cli:18bca7579148", + "chapter": "cli", + "kind": "module", + "name": "`--experimental-import-text`", + "signature": "`--experimental-import-text`", + "label": "--experimental-import-text", + "apiSymbol": "--experimental-import-text", + "depth": 2, + "scope": "configuration", + "anchor": "--experimental-import-text", + "nodeStability": { + "index": "1.0", + "level": 1, + "text": "Early development", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "configuration" + }, + "anchorSource": "exact" + }, { "id": "cli:842968df74c9", "chapter": "cli", @@ -14311,6 +14510,29 @@ }, "anchorSource": "exact" }, + { + "id": "cli:f0dfc946e7c8", + "chapter": "cli", + "kind": "module", + "name": "`--experimental-package-map=`", + "signature": "`--experimental-package-map=`", + "label": "--experimental-package-map=", + "apiSymbol": "--experimental-package-map", + "depth": 2, + "scope": "configuration", + "anchor": "--experimental-package-mappath", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "configuration" + }, + "anchorSource": "exact" + }, { "id": "cli:fc6a77b0e751", "chapter": "cli", @@ -14334,6 +14556,29 @@ }, "anchorSource": "exact" }, + { + "id": "cli:cbb183c27bd2", + "chapter": "cli", + "kind": "module", + "name": "`--experimental-quic`", + "signature": "`--experimental-quic`", + "label": "--experimental-quic", + "apiSymbol": "--experimental-quic", + "depth": 2, + "scope": "configuration", + "anchor": "--experimental-quic", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "configuration" + }, + "anchorSource": "exact" + }, { "id": "cli:c7c8b16d47b8", "chapter": "cli", @@ -14380,6 +14625,52 @@ }, "anchorSource": "exact" }, + { + "id": "cli:fcbf3a56b71a", + "chapter": "cli", + "kind": "module", + "name": "`--experimental-storage-inspection`", + "signature": "`--experimental-storage-inspection`", + "label": "--experimental-storage-inspection", + "apiSymbol": "--experimental-storage-inspection", + "depth": 2, + "scope": "configuration", + "anchor": "--experimental-storage-inspection", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active Development", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "configuration" + }, + "anchorSource": "exact" + }, + { + "id": "cli:e02460df59e9", + "chapter": "cli", + "kind": "module", + "name": "`--experimental-stream-iter`", + "signature": "`--experimental-stream-iter`", + "label": "--experimental-stream-iter", + "apiSymbol": "--experimental-stream-iter", + "depth": 2, + "scope": "configuration", + "anchor": "--experimental-stream-iter", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "configuration" + }, + "anchorSource": "exact" + }, { "id": "cli:3181e8e3620c", "chapter": "cli", @@ -14426,6 +14717,29 @@ }, "anchorSource": "exact" }, + { + "id": "cli:50eca11b2be5", + "chapter": "cli", + "kind": "module", + "name": "`--experimental-test-tag-filter=`", + "signature": "`--experimental-test-tag-filter=`", + "label": "--experimental-test-tag-filter=", + "apiSymbol": "--experimental-test-tag-filter", + "depth": 2, + "scope": "configuration", + "anchor": "--experimental-test-tag-filtertag", + "nodeStability": { + "index": "1.0", + "level": 1, + "text": "Early development", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "configuration" + }, + "anchorSource": "exact" + }, { "id": "cli:aa3990200003", "chapter": "cli", @@ -14541,29 +14855,6 @@ }, "anchorSource": "exact" }, - { - "id": "cli:b77431a408ae", - "chapter": "cli", - "kind": "module", - "name": "`--expose-gc`", - "signature": "`--expose-gc`", - "label": "--expose-gc", - "apiSymbol": "--expose-gc", - "depth": 2, - "scope": "configuration", - "anchor": "--expose-gc", - "nodeStability": { - "index": "1", - "level": 1, - "text": "Experimental. This flag is inherited from V8 and is subject to change upstream.", - "inherited": false - }, - "static": { - "status": "not-applicable", - "evidence": "configuration" - }, - "anchorSource": "exact" - }, { "id": "cli:69ce4c329bc6", "chapter": "cli", @@ -14588,16 +14879,16 @@ "anchorSource": "exact" }, { - "id": "cli:8733c070f553", + "id": "cli:7b3fa1a7785c", "chapter": "cli", "kind": "module", - "name": "`--force-fips`", - "signature": "`--force-fips`", - "label": "--force-fips", + "name": "`--force-fips[=mode]`", + "signature": "`--force-fips[=mode]`", + "label": "--force-fips[=mode]", "apiSymbol": "--force-fips", "depth": 2, "scope": "configuration", - "anchor": "--force-fips", + "anchor": "--force-fipsmode", "nodeStability": { "index": "2", "level": 2, @@ -15162,29 +15453,6 @@ }, "anchorSource": "exact" }, - { - "id": "cli:276ecc0e24f9", - "chapter": "cli", - "kind": "module", - "name": "`--napi-modules`", - "signature": "`--napi-modules`", - "label": "--napi-modules", - "apiSymbol": "--napi-modules", - "depth": 2, - "scope": "configuration", - "anchor": "--napi-modules", - "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true - }, - "static": { - "status": "not-applicable", - "evidence": "configuration" - }, - "anchorSource": "exact" - }, { "id": "cli:9148c571df3c", "chapter": "cli", @@ -15714,6 +15982,29 @@ }, "anchorSource": "exact" }, + { + "id": "cli:ee9a6e8d5868", + "chapter": "cli", + "kind": "module", + "name": "`--permission-audit`", + "signature": "`--permission-audit`", + "label": "--permission-audit", + "apiSymbol": "--permission-audit", + "depth": 2, + "scope": "configuration", + "anchor": "--permission-audit", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "configuration" + }, + "anchorSource": "exact" + }, { "id": "cli:181fba1bad2e", "chapter": "cli", @@ -16496,6 +16787,52 @@ }, "anchorSource": "exact" }, + { + "id": "cli:6ace2fff2c4f", + "chapter": "cli", + "kind": "module", + "name": "`--test-random-seed`", + "signature": "`--test-random-seed`", + "label": "--test-random-seed", + "apiSymbol": "--test-random-seed", + "depth": 2, + "scope": "configuration", + "anchor": "--test-random-seed", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "configuration" + }, + "anchorSource": "exact" + }, + { + "id": "cli:ac9476b6a8e8", + "chapter": "cli", + "kind": "module", + "name": "`--test-randomize`", + "signature": "`--test-randomize`", + "label": "--test-randomize", + "apiSymbol": "--test-randomize", + "depth": 2, + "scope": "configuration", + "anchor": "--test-randomize", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "configuration" + }, + "anchorSource": "exact" + }, { "id": "cli:27374445e9d5", "chapter": "cli", @@ -18372,7 +18709,7 @@ "apiSymbol": "--expose-gc", "depth": 2, "scope": "configuration", - "anchor": "--expose-gc_1", + "anchor": "--expose-gc", "nodeStability": null, "static": { "status": "not-applicable", @@ -19621,10 +19958,10 @@ "scope": "api", "anchor": "cryptoargon2algorithm-parameters-callback", "nodeStability": { - "index": "1.2", - "level": 1, - "text": "Release candidate", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-implemented", @@ -19644,10 +19981,10 @@ "scope": "api", "anchor": "cryptoargon2syncalgorithm-parameters", "nodeStability": { - "index": "1.2", - "level": 1, - "text": "Release candidate", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-implemented", @@ -19895,6 +20232,29 @@ }, "anchorSource": "exact" }, + { + "id": "crypto:8139c367e45c", + "chapter": "crypto", + "kind": "method", + "name": "createMac", + "signature": "`crypto.createMac(algorithm, key[, options])`", + "label": "crypto.createMac(algorithm, key[, options])", + "apiSymbol": "crypto.createMac", + "depth": 2, + "scope": "api", + "anchor": "cryptocreatemacalgorithm-key-options", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:crypto" + }, + "anchorSource": "exact" + }, { "id": "crypto:a91640a96ead", "chapter": "crypto", @@ -19918,6 +20278,29 @@ }, "anchorSource": "exact" }, + { + "id": "crypto:9095ebe298f0", + "chapter": "crypto", + "kind": "module", + "name": "private_keys_from_openssl_store_loaders", + "signature": "Private keys from OpenSSL STORE loaders", + "label": "Private keys from OpenSSL STORE loaders", + "apiSymbol": "private_keys_from_openssl_store_loaders", + "depth": 3, + "scope": "documentation", + "anchor": "private-keys-from-openssl-store-loaders", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "crypto:850de15dc8d0", "chapter": "crypto", @@ -20022,10 +20405,10 @@ "scope": "api", "anchor": "cryptodecapsulatekey-ciphertext-callback", "nodeStability": { - "index": "1.2", - "level": 1, - "text": "Release candidate", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-implemented", @@ -20068,10 +20451,10 @@ "scope": "api", "anchor": "cryptoencapsulatekey-callback", "nodeStability": { - "index": "1.2", - "level": 1, - "text": "Release candidate", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-implemented", @@ -20355,6 +20738,29 @@ }, "anchorSource": "exact" }, + { + "id": "crypto:8950ad3041b7", + "chapter": "crypto", + "kind": "method", + "name": "getMacs", + "signature": "`crypto.getMacs()`", + "label": "crypto.getMacs()", + "apiSymbol": "crypto.getMacs", + "depth": 2, + "scope": "api", + "anchor": "cryptogetmacs", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:crypto" + }, + "anchorSource": "exact" + }, { "id": "crypto:2ab8394e29a7", "chapter": "crypto", @@ -20462,6 +20868,29 @@ }, "anchorSource": "exact" }, + { + "id": "crypto:d0b4d9541950", + "chapter": "crypto", + "kind": "method", + "name": "parsePKCS12", + "signature": "`crypto.parsePKCS12(bundle[, options])`", + "label": "crypto.parsePKCS12(bundle[, options])", + "apiSymbol": "crypto.parsePKCS12", + "depth": 2, + "scope": "api", + "anchor": "cryptoparsepkcs12bundle-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:crypto" + }, + "anchorSource": "exact" + }, { "id": "crypto:cb974006b4f5", "chapter": "crypto", @@ -20757,6 +21186,29 @@ }, "anchorSource": "exact" }, + { + "id": "crypto:5fe8e4024b07", + "chapter": "crypto", + "kind": "method", + "name": "randomUUIDv7", + "signature": "`crypto.randomUUIDv7([options])`", + "label": "crypto.randomUUIDv7([options])", + "apiSymbol": "crypto.randomUUIDv7", + "depth": 2, + "scope": "api", + "anchor": "cryptorandomuuidv7options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:crypto" + }, + "anchorSource": "exact" + }, { "id": "crypto:10402b3c70ca", "chapter": "crypto", @@ -20848,10 +21300,10 @@ "scope": "api", "anchor": "cryptosetengineengine-flags", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "0", + "level": 0, + "text": "Deprecated", + "inherited": false }, "static": { "status": "not-implemented", @@ -21163,6 +21615,98 @@ }, "anchorSource": "exact" }, + { + "id": "crypto:adf9f9f6ad5c", + "chapter": "crypto", + "kind": "module", + "name": "cbc-cts_mode", + "signature": "CBC-CTS mode", + "label": "CBC-CTS mode", + "apiSymbol": "cbc-cts_mode", + "depth": 2, + "scope": "documentation", + "anchor": "cbc-cts-mode", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "crypto:216937b5f297", + "chapter": "crypto", + "kind": "module", + "name": "xts_mode", + "signature": "XTS mode", + "label": "XTS mode", + "apiSymbol": "xts_mode", + "depth": 2, + "scope": "documentation", + "anchor": "xts-mode", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "crypto:45856e1f26d9", + "chapter": "crypto", + "kind": "module", + "name": "aes_key_wrap_modes", + "signature": "AES key wrap modes", + "label": "AES key wrap modes", + "apiSymbol": "aes_key_wrap_modes", + "depth": 2, + "scope": "documentation", + "anchor": "aes-key-wrap-modes", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "crypto:8030cbb73eae", + "chapter": "crypto", + "kind": "module", + "name": "siv_and_gcm-siv_modes", + "signature": "SIV and GCM-SIV modes", + "label": "SIV and GCM-SIV modes", + "apiSymbol": "siv_and_gcm-siv_modes", + "depth": 2, + "scope": "documentation", + "anchor": "siv-and-gcm-siv-modes", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "crypto:87bf6a295193", "chapter": "crypto", @@ -22486,6 +23030,75 @@ }, "anchorSource": "ancestor" }, + { + "id": "crypto:f5e3bda9577f", + "chapter": "crypto", + "kind": "class", + "name": "Mac", + "signature": "Class: `Mac`", + "label": "Mac", + "apiSymbol": "Mac", + "depth": 1, + "scope": "api", + "anchor": "class-mac", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:crypto" + }, + "anchorSource": "exact" + }, + { + "id": "crypto:0165406d6a25", + "chapter": "crypto", + "kind": "method", + "name": "final", + "signature": "`mac.final([outputEncoding])`", + "label": "mac.final([outputEncoding])", + "apiSymbol": "mac.final", + "depth": 2, + "scope": "api", + "anchor": "macfinaloutputencoding", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:crypto" + }, + "anchorSource": "exact" + }, + { + "id": "crypto:6a72becb6839", + "chapter": "crypto", + "kind": "method", + "name": "update", + "signature": "`mac.update(data[, inputEncoding])`", + "label": "mac.update(data[, inputEncoding])", + "apiSymbol": "mac.update", + "depth": 2, + "scope": "api", + "anchor": "macupdatedata-inputencoding", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:crypto" + }, + "anchorSource": "exact" + }, { "id": "crypto:1f80502ef093", "chapter": "crypto", @@ -22602,16 +23215,16 @@ "anchorSource": "exact" }, { - "id": "crypto:16511e6f27c0", + "id": "crypto:1376126d8fea", "chapter": "crypto", "kind": "method", "name": "verify", - "signature": "`verify.verify(object, signature[, signatureEncoding])`", - "label": "verify.verify(object, signature[, signatureEncoding])", + "signature": "`verify.verify(key, signature[, signatureEncoding])`", + "label": "verify.verify(key, signature[, signatureEncoding])", "apiSymbol": "verify.verify", "depth": 2, "scope": "api", - "anchor": "verifyverifyobject-signature-signatureencoding", + "anchor": "verifyverifykey-signature-signatureencoding", "nodeStability": { "index": "2", "level": 2, @@ -23315,14 +23928,37 @@ "anchorSource": "chapter" }, { - "id": "debugger:75e91e1776b1", + "id": "debugger:50b76c257aa9", "chapter": "debugger", "kind": "misc", + "name": "interactive_mode", + "signature": "Interactive mode", + "label": "Interactive mode", + "apiSymbol": "interactive_mode", + "depth": 1, + "scope": "documentation", + "anchor": "interactive-mode", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "debugger:8f5c003321ac", + "chapter": "debugger", + "kind": "module", "name": "watchers", "signature": "Watchers", "label": "Watchers", "apiSymbol": "watchers", - "depth": 1, + "depth": 2, "scope": "documentation", "anchor": "watchers", "nodeStability": { @@ -23384,14 +24020,14 @@ "anchorSource": "exact" }, { - "id": "debugger:d36ce15c455a", + "id": "debugger:de66b40eb81c", "chapter": "debugger", "kind": "module", "name": "breakpoints", "signature": "Breakpoints", "label": "Breakpoints", "apiSymbol": "breakpoints", - "depth": 2, + "depth": 3, "scope": "documentation", "anchor": "breakpoints", "nodeStability": { @@ -23407,14 +24043,14 @@ "anchorSource": "exact" }, { - "id": "debugger:00622531ef77", + "id": "debugger:3047ef5b7323", "chapter": "debugger", "kind": "module", "name": "information", "signature": "Information", "label": "Information", "apiSymbol": "information", - "depth": 2, + "depth": 3, "scope": "documentation", "anchor": "information", "nodeStability": { @@ -23430,14 +24066,14 @@ "anchorSource": "exact" }, { - "id": "debugger:b001c5222f48", + "id": "debugger:27064103509d", "chapter": "debugger", "kind": "module", "name": "execution_control", "signature": "Execution control", "label": "Execution control", "apiSymbol": "execution_control", - "depth": 2, + "depth": 3, "scope": "documentation", "anchor": "execution-control", "nodeStability": { @@ -23453,14 +24089,14 @@ "anchorSource": "exact" }, { - "id": "debugger:cef6ad7a5934", + "id": "debugger:1524581b6a8d", "chapter": "debugger", "kind": "module", "name": "various", "signature": "Various", "label": "Various", "apiSymbol": "various", - "depth": 2, + "depth": 3, "scope": "documentation", "anchor": "various", "nodeStability": { @@ -23475,6 +24111,167 @@ }, "anchorSource": "exact" }, + { + "id": "debugger:486c86c1ff09", + "chapter": "debugger", + "kind": "misc", + "name": "probe_mode", + "signature": "Probe mode", + "label": "Probe mode", + "apiSymbol": "probe_mode", + "depth": 1, + "scope": "documentation", + "anchor": "probe-mode", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "debugger:5802921b7cce", + "chapter": "debugger", + "kind": "module", + "name": "probe_output_format", + "signature": "Probe output format", + "label": "Probe output format", + "apiSymbol": "probe_output_format", + "depth": 2, + "scope": "documentation", + "anchor": "probe-output-format", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "debugger:babe06334ea8", + "chapter": "debugger", + "kind": "module", + "name": "output_and_exit_codes", + "signature": "Output and exit codes", + "label": "Output and exit codes", + "apiSymbol": "output_and_exit_codes", + "depth": 2, + "scope": "documentation", + "anchor": "output-and-exit-codes", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "debugger:a8a35ffa75b0", + "chapter": "debugger", + "kind": "module", + "name": "probing_multiple_expressions_at_the_same_execution_point", + "signature": "Probing multiple expressions at the same execution point", + "label": "Probing multiple expressions at the same execution point", + "apiSymbol": "probing_multiple_expressions_at_the_same_execution_point", + "depth": 2, + "scope": "documentation", + "anchor": "probing-multiple-expressions-at-the-same-execution-point", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "debugger:7cb638f01560", + "chapter": "debugger", + "kind": "module", + "name": "selecting_the_probe_location", + "signature": "Selecting the probe location", + "label": "Selecting the probe location", + "apiSymbol": "selecting_the_probe_location", + "depth": 2, + "scope": "documentation", + "anchor": "selecting-the-probe-location", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "debugger:afd0b31c2e18", + "chapter": "debugger", + "kind": "module", + "name": "probe_examples", + "signature": "Probe examples", + "label": "Probe examples", + "apiSymbol": "probe_examples", + "depth": 2, + "scope": "documentation", + "anchor": "probe-examples", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "debugger:343ca28cbdda", + "chapter": "debugger", + "kind": "module", + "name": "probing_a_variable_conditionally", + "signature": "Probing a variable conditionally", + "label": "Probing a variable conditionally", + "apiSymbol": "probing_a_variable_conditionally", + "depth": 3, + "scope": "documentation", + "anchor": "probing-a-variable-conditionally", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "debugger:03040216bb84", "chapter": "debugger", @@ -27272,6 +28069,60 @@ }, "anchorSource": "exact" }, + { + "id": "deprecations:dcbaaa84f6ef", + "chapter": "deprecations", + "kind": "module", + "name": "dep0206:_calling_`digest()`_on_an_already-finalized_`hmac`_instance", + "signature": "DEP0206: Calling `digest()` on an already-finalized `Hmac` instance", + "label": "DEP0206: Calling digest() on an already-finalized Hmac instance", + "apiSymbol": "digest", + "depth": 2, + "scope": "metadata", + "anchor": "dep0206-calling-digest-on-an-already-finalized-hmac-instance", + "nodeStability": null, + "static": { + "status": "not-applicable", + "evidence": "compiler-chapter-policy:deprecations" + }, + "anchorSource": "exact" + }, + { + "id": "deprecations:7f6906e99392", + "chapter": "deprecations", + "kind": "module", + "name": "dep0208:_`server.prototype._listen2`", + "signature": "DEP0208: `Server.prototype._listen2`", + "label": "DEP0208: Server.prototype._listen2", + "apiSymbol": "Server.prototype._listen2", + "depth": 2, + "scope": "metadata", + "anchor": "dep0208-serverprototype_listen2", + "nodeStability": null, + "static": { + "status": "not-applicable", + "evidence": "compiler-chapter-policy:deprecations" + }, + "anchorSource": "exact" + }, + { + "id": "deprecations:67509e71b965", + "chapter": "deprecations", + "kind": "module", + "name": "dep0209:_using_`abortsignal`_to_dispose_of_resources", + "signature": "DEP0209: Using `AbortSignal` to dispose of resources", + "label": "DEP0209: Using AbortSignal to dispose of resources", + "apiSymbol": "AbortSignal", + "depth": 2, + "scope": "metadata", + "anchor": "dep0209-using-abortsignal-to-dispose-of-resources", + "nodeStability": null, + "static": { + "status": "not-applicable", + "evidence": "compiler-chapter-policy:deprecations" + }, + "anchorSource": "exact" + }, { "id": "diagnostics_channel:11bd5c8c605b", "chapter": "diagnostics_channel", @@ -27773,6 +28624,52 @@ }, "anchorSource": "exact" }, + { + "id": "diagnostics_channel:898ec6605561", + "chapter": "diagnostics_channel", + "kind": "module", + "name": "crypto", + "signature": "Crypto", + "label": "Crypto", + "apiSymbol": "crypto", + "depth": 3, + "scope": "documentation", + "anchor": "crypto", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "diagnostics_channel:80f3f937cfe0", + "chapter": "diagnostics_channel", + "kind": "event", + "name": "crypto.fips.indicator", + "signature": "Event: `'crypto.fips.indicator'`", + "label": "'crypto.fips.indicator'", + "apiSymbol": "'crypto.fips.indicator'", + "depth": 4, + "scope": "api", + "anchor": "event-cryptofipsindicator", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:diagnostics_channel" + }, + "anchorSource": "exact" + }, { "id": "diagnostics_channel:007a09e0a6f2", "chapter": "diagnostics_channel", @@ -28280,16 +29177,16 @@ "anchorSource": "exact" }, { - "id": "diagnostics_channel:d1c41884e542", + "id": "diagnostics_channel:bb1dd3918bd5", "chapter": "diagnostics_channel", "kind": "event", - "name": "module.require.start", - "signature": "Event: `'module.require.start'`", - "label": "'module.require.start'", - "apiSymbol": "'module.require.start'", + "name": "tracing:module.require:start", + "signature": "Event: `'tracing:module.require:start'`", + "label": "'tracing:module.require:start'", + "apiSymbol": "'tracing:module.require:start'", "depth": 4, "scope": "api", - "anchor": "event-modulerequirestart", + "anchor": "event-tracingmodulerequirestart", "nodeStability": { "index": "1", "level": 1, @@ -28303,16 +29200,16 @@ "anchorSource": "exact" }, { - "id": "diagnostics_channel:4cd1c32b77c6", + "id": "diagnostics_channel:990ea4c5a9d7", "chapter": "diagnostics_channel", "kind": "event", - "name": "module.require.end", - "signature": "Event: `'module.require.end'`", - "label": "'module.require.end'", - "apiSymbol": "'module.require.end'", + "name": "tracing:module.require:end", + "signature": "Event: `'tracing:module.require:end'`", + "label": "'tracing:module.require:end'", + "apiSymbol": "'tracing:module.require:end'", "depth": 4, "scope": "api", - "anchor": "event-modulerequireend", + "anchor": "event-tracingmodulerequireend", "nodeStability": { "index": "1", "level": 1, @@ -28326,16 +29223,16 @@ "anchorSource": "exact" }, { - "id": "diagnostics_channel:cd31d16f125f", + "id": "diagnostics_channel:494f069b7279", "chapter": "diagnostics_channel", "kind": "event", - "name": "module.require.error", - "signature": "Event: `'module.require.error'`", - "label": "'module.require.error'", - "apiSymbol": "'module.require.error'", + "name": "tracing:module.require:error", + "signature": "Event: `'tracing:module.require:error'`", + "label": "'tracing:module.require:error'", + "apiSymbol": "'tracing:module.require:error'", "depth": 4, "scope": "api", - "anchor": "event-modulerequireerror", + "anchor": "event-tracingmodulerequireerror", "nodeStability": { "index": "1", "level": 1, @@ -28349,16 +29246,16 @@ "anchorSource": "exact" }, { - "id": "diagnostics_channel:a2840f3e48cc", + "id": "diagnostics_channel:24d45c5b63f5", "chapter": "diagnostics_channel", "kind": "event", - "name": "module.import.asyncStart", - "signature": "Event: `'module.import.asyncStart'`", - "label": "'module.import.asyncStart'", - "apiSymbol": "'module.import.asyncStart'", + "name": "tracing:module.import:asyncStart", + "signature": "Event: `'tracing:module.import:asyncStart'`", + "label": "'tracing:module.import:asyncStart'", + "apiSymbol": "'tracing:module.import:asyncStart'", "depth": 4, "scope": "api", - "anchor": "event-moduleimportasyncstart", + "anchor": "event-tracingmoduleimportasyncstart", "nodeStability": { "index": "1", "level": 1, @@ -28372,16 +29269,16 @@ "anchorSource": "exact" }, { - "id": "diagnostics_channel:730d6618877f", + "id": "diagnostics_channel:fd44953e860d", "chapter": "diagnostics_channel", "kind": "event", - "name": "module.import.asyncEnd", - "signature": "Event: `'module.import.asyncEnd'`", - "label": "'module.import.asyncEnd'", - "apiSymbol": "'module.import.asyncEnd'", + "name": "tracing:module.import:asyncEnd", + "signature": "Event: `'tracing:module.import:asyncEnd'`", + "label": "'tracing:module.import:asyncEnd'", + "apiSymbol": "'tracing:module.import:asyncEnd'", "depth": 4, "scope": "api", - "anchor": "event-moduleimportasyncend", + "anchor": "event-tracingmoduleimportasyncend", "nodeStability": { "index": "1", "level": 1, @@ -28395,16 +29292,16 @@ "anchorSource": "exact" }, { - "id": "diagnostics_channel:b94f162dfbad", + "id": "diagnostics_channel:a25388ac262b", "chapter": "diagnostics_channel", "kind": "event", - "name": "module.import.error", - "signature": "Event: `'module.import.error'`", - "label": "'module.import.error'", - "apiSymbol": "'module.import.error'", + "name": "tracing:module.import:error", + "signature": "Event: `'tracing:module.import:error'`", + "label": "'tracing:module.import:error'", + "apiSymbol": "'tracing:module.import:error'", "depth": 4, "scope": "api", - "anchor": "event-moduleimporterror", + "anchor": "event-tracingmoduleimporterror", "nodeStability": { "index": "1", "level": 1, @@ -28648,16 +29545,16 @@ "anchorSource": "exact" }, { - "id": "diagnostics_channel:3e684ab90652", + "id": "diagnostics_channel:990885f7c68c", "chapter": "diagnostics_channel", "kind": "event", - "name": "execve", - "signature": "Event: `'execve'`", - "label": "'execve'", - "apiSymbol": "'execve'", + "name": "process.execve", + "signature": "Event: `'process.execve'`", + "label": "'process.execve'", + "apiSymbol": "'process.execve'", "depth": 4, "scope": "api", - "anchor": "event-execve", + "anchor": "event-processexecve", "nodeStability": { "index": "1", "level": 1, @@ -28831,6 +29728,52 @@ }, "anchorSource": "exact" }, + { + "id": "diagnostics_channel:90f415de0c45", + "chapter": "diagnostics_channel", + "kind": "module", + "name": "sqlite", + "signature": "SQLite", + "label": "SQLite", + "apiSymbol": "sqlite", + "depth": 3, + "scope": "documentation", + "anchor": "sqlite", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "diagnostics_channel:f9ab0dfd2826", + "chapter": "diagnostics_channel", + "kind": "event", + "name": "sqlite.db.query", + "signature": "Event: `'sqlite.db.query'`", + "label": "'sqlite.db.query'", + "apiSymbol": "'sqlite.db.query'", + "depth": 4, + "scope": "api", + "anchor": "event-sqlitedbquery", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:diagnostics_channel" + }, + "anchorSource": "exact" + }, { "id": "diagnostics_channel:e311810f8dca", "chapter": "diagnostics_channel", @@ -31260,6 +32203,24 @@ }, "anchorSource": "exact" }, + { + "id": "errors:7c2e0440b499", + "chapter": "errors", + "kind": "class", + "name": "DOMException", + "signature": "Class: `DOMException`", + "label": "DOMException", + "apiSymbol": "DOMException", + "depth": 1, + "scope": "api", + "anchor": "class-domexception", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, { "id": "errors:2c13de112ff5", "chapter": "errors", @@ -32545,6 +33506,24 @@ }, "anchorSource": "exact" }, + { + "id": "errors:1d435e87eb56", + "chapter": "errors", + "kind": "module", + "name": "`err_crypto_invalid_mac`", + "signature": "`ERR_CRYPTO_INVALID_MAC`", + "label": "ERR_CRYPTO_INVALID_MAC", + "apiSymbol": "ERR_CRYPTO_INVALID_MAC", + "depth": 2, + "scope": "api", + "anchor": "err_crypto_invalid_mac", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, { "id": "errors:f62618221d0d", "chapter": "errors", @@ -32689,6 +33668,60 @@ }, "anchorSource": "exact" }, + { + "id": "errors:d6c1b25e885d", + "chapter": "errors", + "kind": "module", + "name": "`err_crypto_mac_finalized`", + "signature": "`ERR_CRYPTO_MAC_FINALIZED`", + "label": "ERR_CRYPTO_MAC_FINALIZED", + "apiSymbol": "ERR_CRYPTO_MAC_FINALIZED", + "depth": 2, + "scope": "api", + "anchor": "err_crypto_mac_finalized", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, + { + "id": "errors:d0b894204eed", + "chapter": "errors", + "kind": "module", + "name": "`err_crypto_mac_not_supported`", + "signature": "`ERR_CRYPTO_MAC_NOT_SUPPORTED`", + "label": "ERR_CRYPTO_MAC_NOT_SUPPORTED", + "apiSymbol": "ERR_CRYPTO_MAC_NOT_SUPPORTED", + "depth": 2, + "scope": "api", + "anchor": "err_crypto_mac_not_supported", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, + { + "id": "errors:89c3bbbbe04b", + "chapter": "errors", + "kind": "module", + "name": "`err_crypto_mac_update_failed`", + "signature": "`ERR_CRYPTO_MAC_UPDATE_FAILED`", + "label": "ERR_CRYPTO_MAC_UPDATE_FAILED", + "apiSymbol": "ERR_CRYPTO_MAC_UPDATE_FAILED", + "depth": 2, + "scope": "api", + "anchor": "err_crypto_mac_update_failed", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, { "id": "errors:bbb816de6720", "chapter": "errors", @@ -34129,6 +35162,24 @@ }, "anchorSource": "exact" }, + { + "id": "errors:bc2b4b418075", + "chapter": "errors", + "kind": "module", + "name": "`err_http2_too_many_origins`", + "signature": "`ERR_HTTP2_TOO_MANY_ORIGINS`", + "label": "ERR_HTTP2_TOO_MANY_ORIGINS", + "apiSymbol": "ERR_HTTP2_TOO_MANY_ORIGINS", + "depth": 2, + "scope": "api", + "anchor": "err_http2_too_many_origins", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, { "id": "errors:799603ae61ed", "chapter": "errors", @@ -35875,6 +36926,60 @@ }, "anchorSource": "exact" }, + { + "id": "errors:e17495198d37", + "chapter": "errors", + "kind": "module", + "name": "`err_package_map_external_file`", + "signature": "`ERR_PACKAGE_MAP_EXTERNAL_FILE`", + "label": "ERR_PACKAGE_MAP_EXTERNAL_FILE", + "apiSymbol": "ERR_PACKAGE_MAP_EXTERNAL_FILE", + "depth": 2, + "scope": "api", + "anchor": "err_package_map_external_file", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, + { + "id": "errors:ff3640a7d624", + "chapter": "errors", + "kind": "module", + "name": "`err_package_map_invalid`", + "signature": "`ERR_PACKAGE_MAP_INVALID`", + "label": "ERR_PACKAGE_MAP_INVALID", + "apiSymbol": "ERR_PACKAGE_MAP_INVALID", + "depth": 2, + "scope": "api", + "anchor": "err_package_map_invalid", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, + { + "id": "errors:4bc366c6011c", + "chapter": "errors", + "kind": "module", + "name": "`err_package_map_key_not_found`", + "signature": "`ERR_PACKAGE_MAP_KEY_NOT_FOUND`", + "label": "ERR_PACKAGE_MAP_KEY_NOT_FOUND", + "apiSymbol": "ERR_PACKAGE_MAP_KEY_NOT_FOUND", + "depth": 2, + "scope": "api", + "anchor": "err_package_map_key_not_found", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, { "id": "errors:9a703bb883e6", "chapter": "errors", @@ -36129,6 +37234,52 @@ }, "anchorSource": "exact" }, + { + "id": "errors:26e263d339c6", + "chapter": "errors", + "kind": "module", + "name": "`err_quic_stream_aborted`", + "signature": "`ERR_QUIC_STREAM_ABORTED`", + "label": "ERR_QUIC_STREAM_ABORTED", + "apiSymbol": "ERR_QUIC_STREAM_ABORTED", + "depth": 2, + "scope": "api", + "anchor": "err_quic_stream_aborted", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, + { + "id": "errors:a8b44a283f33", + "chapter": "errors", + "kind": "module", + "name": "`err_quic_stream_reset`", + "signature": "`ERR_QUIC_STREAM_RESET`", + "label": "ERR_QUIC_STREAM_RESET", + "apiSymbol": "ERR_QUIC_STREAM_RESET", + "depth": 2, + "scope": "api", + "anchor": "err_quic_stream_reset", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, { "id": "errors:266e07dc7ced", "chapter": "errors", @@ -36234,6 +37385,29 @@ }, "anchorSource": "exact" }, + { + "id": "errors:ad1a5adf2534", + "chapter": "errors", + "kind": "module", + "name": "`err_require_esm_race_condition`", + "signature": "`ERR_REQUIRE_ESM_RACE_CONDITION`", + "label": "ERR_REQUIRE_ESM_RACE_CONDITION", + "apiSymbol": "ERR_REQUIRE_ESM_RACE_CONDITION", + "depth": 2, + "scope": "api", + "anchor": "err_require_esm_race_condition", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental.", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, { "id": "errors:50007aab8780", "chapter": "errors", @@ -36522,6 +37696,24 @@ }, "anchorSource": "exact" }, + { + "id": "errors:7e6c1ed4db94", + "chapter": "errors", + "kind": "module", + "name": "`err_socket_handle_adopted`", + "signature": "`ERR_SOCKET_HANDLE_ADOPTED`", + "label": "ERR_SOCKET_HANDLE_ADOPTED", + "apiSymbol": "ERR_SOCKET_HANDLE_ADOPTED", + "depth": 2, + "scope": "api", + "anchor": "err_socket_handle_adopted", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, { "id": "errors:e1def23be437", "chapter": "errors", @@ -36666,6 +37858,24 @@ }, "anchorSource": "exact" }, + { + "id": "errors:a378bec92079", + "chapter": "errors", + "kind": "module", + "name": "`err_stream_iter_missing_flag`", + "signature": "`ERR_STREAM_ITER_MISSING_FLAG`", + "label": "ERR_STREAM_ITER_MISSING_FLAG", + "apiSymbol": "ERR_STREAM_ITER_MISSING_FLAG", + "depth": 2, + "scope": "api", + "anchor": "err_stream_iter_missing_flag", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, { "id": "errors:b69c141eb822", "chapter": "errors", @@ -36864,6 +38074,24 @@ }, "anchorSource": "exact" }, + { + "id": "errors:e23d44126eae", + "chapter": "errors", + "kind": "module", + "name": "`err_throttled`", + "signature": "`ERR_THROTTLED`", + "label": "ERR_THROTTLED", + "apiSymbol": "ERR_THROTTLED", + "depth": 2, + "scope": "api", + "anchor": "err_throttled", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, { "id": "errors:9b1bacff6b37", "chapter": "errors", @@ -37098,6 +38326,24 @@ }, "anchorSource": "exact" }, + { + "id": "errors:1d4c8b8ea330", + "chapter": "errors", + "kind": "module", + "name": "`err_tls_renegotiation_unsupported`", + "signature": "`ERR_TLS_RENEGOTIATION_UNSUPPORTED`", + "label": "ERR_TLS_RENEGOTIATION_UNSUPPORTED", + "apiSymbol": "ERR_TLS_RENEGOTIATION_UNSUPPORTED", + "depth": 2, + "scope": "api", + "anchor": "err_tls_renegotiation_unsupported", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, { "id": "errors:ebb5c98b76d6", "chapter": "errors", @@ -37800,6 +39046,24 @@ }, "anchorSource": "exact" }, + { + "id": "errors:b5224b626f86", + "chapter": "errors", + "kind": "module", + "name": "`err_worker_handle_not_transferable`", + "signature": "`ERR_WORKER_HANDLE_NOT_TRANSFERABLE`", + "label": "ERR_WORKER_HANDLE_NOT_TRANSFERABLE", + "apiSymbol": "ERR_WORKER_HANDLE_NOT_TRANSFERABLE", + "depth": 2, + "scope": "api", + "anchor": "err_worker_handle_not_transferable", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:errors" + }, + "anchorSource": "exact" + }, { "id": "errors:75ec70605835", "chapter": "errors", @@ -42535,6 +43799,52 @@ }, "anchorSource": "exact" }, + { + "id": "fs:3eddc68c4823", + "chapter": "fs", + "kind": "method", + "name": "pull", + "signature": "`filehandle.pull([...transforms][, options])`", + "label": "filehandle.pull([...transforms][, options])", + "apiSymbol": "filehandle.pull", + "depth": 3, + "scope": "api", + "anchor": "filehandlepulltransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:fs" + }, + "anchorSource": "exact" + }, + { + "id": "fs:236cfefb2bd7", + "chapter": "fs", + "kind": "method", + "name": "pullSync", + "signature": "`filehandle.pullSync([...transforms][, options])`", + "label": "filehandle.pullSync([...transforms][, options])", + "apiSymbol": "filehandle.pullSync", + "depth": 3, + "scope": "api", + "anchor": "filehandlepullsynctransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:fs" + }, + "anchorSource": "exact" + }, { "id": "fs:8bff339d602d", "chapter": "fs", @@ -42955,6 +44265,29 @@ }, "anchorSource": "exact" }, + { + "id": "fs:db142178f3b2", + "chapter": "fs", + "kind": "method", + "name": "writer", + "signature": "`filehandle.writer([options])`", + "label": "filehandle.writer([options])", + "apiSymbol": "filehandle.writer", + "depth": 3, + "scope": "api", + "anchor": "filehandlewriteroptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:fs" + }, + "anchorSource": "exact" + }, { "id": "fs:0eb79d089322", "chapter": "fs", @@ -48496,6 +49829,29 @@ }, "anchorSource": "ancestor" }, + { + "id": "fs:fc5a2ccba935", + "chapter": "fs", + "kind": "number|bigint", + "name": "Type", + "signature": "`frsize` Type: {number|bigint}", + "label": "frsize", + "apiSymbol": "frsize", + "depth": 3, + "scope": "api", + "anchor": "class-fsstatfs", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:fs" + }, + "anchorSource": "ancestor" + }, { "id": "fs:4d046e9b2b75", "chapter": "fs", @@ -52101,6 +53457,29 @@ }, "anchorSource": "exact" }, + { + "id": "http:b8906c1c7fb4", + "chapter": "http", + "kind": "module", + "name": "proxy_security_considerations", + "signature": "Proxy security considerations", + "label": "Proxy security considerations", + "apiSymbol": "proxy_security_considerations", + "depth": 2, + "scope": "documentation", + "anchor": "proxy-security-considerations", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "http:70f736582bdc", "chapter": "http", @@ -52173,6 +53552,29 @@ }, "anchorSource": "exact" }, + { + "id": "http:0e1535c52052", + "chapter": "http", + "kind": "module", + "name": "response_ordering_with_connection_reuse", + "signature": "Response ordering with connection reuse", + "label": "Response ordering with connection reuse", + "apiSymbol": "response_ordering_with_connection_reuse", + "depth": 2, + "scope": "documentation", + "anchor": "response-ordering-with-connection-reuse", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "http:b54cc6bd538f", "chapter": "http", @@ -53042,11 +54444,11 @@ "anchorSource": "ancestor" }, { - "id": "http:faf8578bc834", + "id": "http:3ec3b8b2efa8", "chapter": "http", "kind": "number", "name": "Type", - "signature": "`maxHeadersCount` Type: {number} **Default:** `2000`", + "signature": "`maxHeadersCount` Type: {number} **Default:** `1000`", "label": "maxHeadersCount", "apiSymbol": "maxHeadersCount", "depth": 2, @@ -53169,11 +54571,11 @@ "anchorSource": "ancestor" }, { - "id": "http:9ca269feac75", + "id": "http:e7028cb19b03", "chapter": "http", "kind": "boolean", "name": "Type", - "signature": "`reusedSocket` Type: {boolean} Whether the request is send through a reused socket.", + "signature": "`reusedSocket` Type: {boolean} Whether the request is sent through a reused socket.", "label": "reusedSocket", "apiSymbol": "reusedSocket", "depth": 2, @@ -53766,11 +55168,11 @@ "anchorSource": "ancestor" }, { - "id": "http:2b341e7f7ddb", + "id": "http:d2aac123456e", "chapter": "http", "kind": "number", "name": "Type", - "signature": "`maxHeadersCount` Type: {number} **Default:** `2000`", + "signature": "`maxHeadersCount` Type: {number} **Default:** `1000`", "label": "maxHeadersCount", "apiSymbol": "maxHeadersCount", "depth": 2, @@ -54618,6 +56020,29 @@ }, "anchorSource": "exact" }, + { + "id": "http:3228cdffbf09", + "chapter": "http", + "kind": "method", + "name": "writeInformation", + "signature": "`response.writeInformation(statusCode[, headers][, callback])`", + "label": "response.writeInformation(statusCode[, headers][, callback])", + "apiSymbol": "response.writeInformation", + "depth": 2, + "scope": "api", + "anchor": "responsewriteinformationstatuscode-headers-callback", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:http" + }, + "anchorSource": "exact" + }, { "id": "http:66f1ca12e0bb", "chapter": "http", @@ -55305,6 +56730,29 @@ }, "anchorSource": "ancestor" }, + { + "id": "http:17e4f98aa2fc", + "chapter": "http", + "kind": "AbortSignal", + "name": "Type", + "signature": "`signal` Type: {AbortSignal}", + "label": "signal", + "apiSymbol": "signal", + "depth": 2, + "scope": "api", + "anchor": "class-httpincomingmessage", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:http" + }, + "anchorSource": "ancestor" + }, { "id": "http:63ef1a2fb4c2", "chapter": "http", @@ -59652,6 +61100,75 @@ }, "anchorSource": "exact" }, + { + "id": "http2:354d9f1da10e", + "chapter": "http2", + "kind": "module", + "name": "header_name_constants", + "signature": "Header name constants", + "label": "Header name constants", + "apiSymbol": "header_name_constants", + "depth": 3, + "scope": "documentation", + "anchor": "header-name-constants", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "http2:a4053a1521da", + "chapter": "http2", + "kind": "module", + "name": "pseudo-header_constants", + "signature": "Pseudo-header constants", + "label": "Pseudo-header constants", + "apiSymbol": "pseudo-header_constants", + "depth": 4, + "scope": "documentation", + "anchor": "pseudo-header-constants", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "http2:3e79fdd645bd", + "chapter": "http2", + "kind": "module", + "name": "regular_header_constants", + "signature": "Regular header constants", + "label": "Regular header constants", + "apiSymbol": "regular_header_constants", + "depth": 4, + "scope": "documentation", + "anchor": "regular-header-constants", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "http2:3686f80264d2", "chapter": "http2", @@ -60566,6 +62083,29 @@ }, "anchorSource": "exact" }, + { + "id": "http2:5deaac8d8f97", + "chapter": "http2", + "kind": "method", + "name": "writeInformation", + "signature": "`response.writeInformation(statusCode[, headers])`", + "label": "response.writeInformation(statusCode[, headers])", + "apiSymbol": "response.writeInformation", + "depth": 3, + "scope": "api", + "anchor": "responsewriteinformationstatuscode-headers", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:http2" + }, + "anchorSource": "exact" + }, { "id": "http2:b551a5ca3a62", "chapter": "http2", @@ -61190,11 +62730,11 @@ "anchorSource": "ancestor" }, { - "id": "https:705c007905d2", + "id": "https:2c6b974ec0c1", "chapter": "https", "kind": "number", "name": "Type", - "signature": "`maxHeadersCount` Type: {number} **Default:** `2000`", + "signature": "`maxHeadersCount` Type: {number} **Default:** `1000`", "label": "maxHeadersCount", "apiSymbol": "maxHeadersCount", "depth": 2, @@ -62333,6 +63873,121 @@ }, "anchorSource": "exact" }, + { + "id": "inspector:91e693d16a79", + "chapter": "inspector", + "kind": "Object", + "name": "params", + "signature": "`domStorageItemAdded` `params` {Object}", + "label": "domStorageItemAdded", + "apiSymbol": "domStorageItemAdded", + "depth": 2, + "scope": "api", + "anchor": "integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:inspector" + }, + "anchorSource": "ancestor" + }, + { + "id": "inspector:ac553f71ee67", + "chapter": "inspector", + "kind": "Object", + "name": "params", + "signature": "`domStorageItemRemoved` `params` {Object}", + "label": "domStorageItemRemoved", + "apiSymbol": "domStorageItemRemoved", + "depth": 2, + "scope": "api", + "anchor": "integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:inspector" + }, + "anchorSource": "ancestor" + }, + { + "id": "inspector:551b41cae8b6", + "chapter": "inspector", + "kind": "Object", + "name": "params", + "signature": "`domStorageItemUpdated` `params` {Object}", + "label": "domStorageItemUpdated", + "apiSymbol": "domStorageItemUpdated", + "depth": 2, + "scope": "api", + "anchor": "integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:inspector" + }, + "anchorSource": "ancestor" + }, + { + "id": "inspector:3cba411858f1", + "chapter": "inspector", + "kind": "Object", + "name": "params", + "signature": "`domStorageItemsCleared` `params` {Object}", + "label": "domStorageItemsCleared", + "apiSymbol": "domStorageItemsCleared", + "depth": 2, + "scope": "api", + "anchor": "integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:inspector" + }, + "anchorSource": "ancestor" + }, + { + "id": "inspector:352bce26d961", + "chapter": "inspector", + "kind": "Object", + "name": "params", + "signature": "`registerStorage` `params` {Object}", + "label": "registerStorage", + "apiSymbol": "registerStorage", + "depth": 2, + "scope": "api", + "anchor": "integration-with-devtools", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active development", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:inspector" + }, + "anchorSource": "ancestor" + }, { "id": "inspector:631a4889f729", "chapter": "inspector", @@ -62500,6 +64155,2007 @@ }, "anchorSource": "exact" }, + { + "id": "stream_iter:94e2aeab4df6", + "chapter": "stream_iter", + "kind": "module", + "name": "iterable_streams", + "signature": "Iterable Streams", + "label": "Iterable Streams", + "apiSymbol": "iterable_streams", + "depth": 0, + "scope": "api", + "anchor": "", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "derived:descendants" + }, + "anchorSource": "chapter" + }, + { + "id": "stream_iter:cffdc04672dc", + "chapter": "stream_iter", + "kind": "module", + "name": "concepts", + "signature": "Concepts", + "label": "Concepts", + "apiSymbol": "concepts", + "depth": 1, + "scope": "documentation", + "anchor": "concepts", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:19a40d9dbe08", + "chapter": "stream_iter", + "kind": "module", + "name": "byte_streams", + "signature": "Byte streams", + "label": "Byte streams", + "apiSymbol": "byte_streams", + "depth": 2, + "scope": "documentation", + "anchor": "byte-streams", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:21c6768b5c0c", + "chapter": "stream_iter", + "kind": "module", + "name": "batching", + "signature": "Batching", + "label": "Batching", + "apiSymbol": "batching", + "depth": 2, + "scope": "documentation", + "anchor": "batching", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:b57f0555b2a0", + "chapter": "stream_iter", + "kind": "module", + "name": "transforms", + "signature": "Transforms", + "label": "Transforms", + "apiSymbol": "transforms", + "depth": 2, + "scope": "documentation", + "anchor": "transforms", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:01e6b13e015c", + "chapter": "stream_iter", + "kind": "module", + "name": "pull_vs._push", + "signature": "Pull vs. push", + "label": "Pull vs. push", + "apiSymbol": "pull_vs._push", + "depth": 2, + "scope": "documentation", + "anchor": "pull-vs-push", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:695c8ceb255c", + "chapter": "stream_iter", + "kind": "module", + "name": "backpressure", + "signature": "Backpressure", + "label": "Backpressure", + "apiSymbol": "backpressure", + "depth": 2, + "scope": "documentation", + "anchor": "backpressure", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:ac9787a3e2f7", + "chapter": "stream_iter", + "kind": "module", + "name": "the_two-buffer_model", + "signature": "The two-buffer model", + "label": "The two-buffer model", + "apiSymbol": "the_two-buffer_model", + "depth": 3, + "scope": "documentation", + "anchor": "the-two-buffer-model", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:c42949c0e6e1", + "chapter": "stream_iter", + "kind": "module", + "name": "strict_(default)", + "signature": "Strict (default)", + "label": "Strict (default)", + "apiSymbol": "strict_", + "depth": 3, + "scope": "documentation", + "anchor": "strict-default", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:a49070d1aed5", + "chapter": "stream_iter", + "kind": "module", + "name": "unbounded", + "signature": "Unbounded", + "label": "Unbounded", + "apiSymbol": "unbounded", + "depth": 3, + "scope": "documentation", + "anchor": "unbounded", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:7f9991ae95d5", + "chapter": "stream_iter", + "kind": "module", + "name": "drop-oldest", + "signature": "Drop-oldest", + "label": "Drop-oldest", + "apiSymbol": "drop-oldest", + "depth": 3, + "scope": "documentation", + "anchor": "drop-oldest", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:bc5b9894484f", + "chapter": "stream_iter", + "kind": "module", + "name": "drop-newest", + "signature": "Drop-newest", + "label": "Drop-newest", + "apiSymbol": "drop-newest", + "depth": 3, + "scope": "documentation", + "anchor": "drop-newest", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:175c0dc62f5f", + "chapter": "stream_iter", + "kind": "module", + "name": "writer_interface", + "signature": "Writer interface", + "label": "Writer interface", + "apiSymbol": "writer_interface", + "depth": 2, + "scope": "documentation", + "anchor": "writer-interface", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:74881c7a8ea5", + "chapter": "stream_iter", + "kind": "method", + "name": "end", + "signature": "`writer.end([options])`", + "label": "writer.end([options])", + "apiSymbol": "writer.end", + "depth": 3, + "scope": "api", + "anchor": "writerendoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:25b778a0a19a", + "chapter": "stream_iter", + "kind": "method", + "name": "endSync", + "signature": "`writer.endSync()`", + "label": "writer.endSync()", + "apiSymbol": "writer.endSync", + "depth": 3, + "scope": "api", + "anchor": "writerendsync", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:dd1332b8c7a3", + "chapter": "stream_iter", + "kind": "method", + "name": "fail", + "signature": "`writer.fail(reason)`", + "label": "writer.fail(reason)", + "apiSymbol": "writer.fail", + "depth": 3, + "scope": "api", + "anchor": "writerfailreason", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:9fe673a6f9a0", + "chapter": "stream_iter", + "kind": "method", + "name": "[Symbol.asyncDispose]", + "signature": "`writer[Symbol.asyncDispose]()`", + "label": "writer[Symbol.asyncDispose]()", + "apiSymbol": "writer", + "depth": 3, + "scope": "api", + "anchor": "writersymbolasyncdispose", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:122792b034fd", + "chapter": "stream_iter", + "kind": "method", + "name": "write", + "signature": "`writer.write(chunk[, options])`", + "label": "writer.write(chunk[, options])", + "apiSymbol": "writer.write", + "depth": 3, + "scope": "api", + "anchor": "writerwritechunk-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:70029a8cc441", + "chapter": "stream_iter", + "kind": "method", + "name": "writeSync", + "signature": "`writer.writeSync(chunk)`", + "label": "writer.writeSync(chunk)", + "apiSymbol": "writer.writeSync", + "depth": 3, + "scope": "api", + "anchor": "writerwritesyncchunk", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:75d546da6ee2", + "chapter": "stream_iter", + "kind": "method", + "name": "writev", + "signature": "`writer.writev(chunks[, options])`", + "label": "writer.writev(chunks[, options])", + "apiSymbol": "writer.writev", + "depth": 3, + "scope": "api", + "anchor": "writerwritevchunks-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:9b24338e15dd", + "chapter": "stream_iter", + "kind": "method", + "name": "writevSync", + "signature": "`writer.writevSync(chunks)`", + "label": "writer.writevSync(chunks)", + "apiSymbol": "writer.writevSync", + "depth": 3, + "scope": "api", + "anchor": "writerwritevsyncchunks", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:71e88296da2b", + "chapter": "stream_iter", + "kind": "boolean|null", + "name": "canWrite", + "signature": "`canWrite` {boolean|null}", + "label": "canWrite", + "apiSymbol": "canWrite", + "depth": 3, + "scope": "api", + "anchor": "writer-interface", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "ancestor" + }, + { + "id": "stream_iter:f31bb04ebfd3", + "chapter": "stream_iter", + "kind": "module", + "name": "the_`stream/iter`_module", + "signature": "The `stream/iter` module", + "label": "The stream/iter module", + "apiSymbol": "stream/iter", + "depth": 1, + "scope": "api", + "anchor": "the-streamiter-module", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:b6bc7c29f099", + "chapter": "stream_iter", + "kind": "module", + "name": "sources", + "signature": "Sources", + "label": "Sources", + "apiSymbol": "sources", + "depth": 1, + "scope": "documentation", + "anchor": "sources", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:e81bf2b065dc", + "chapter": "stream_iter", + "kind": "method", + "name": "from", + "signature": "`from(input)`", + "label": "from(input)", + "apiSymbol": "from", + "depth": 2, + "scope": "api", + "anchor": "frominput", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:6f3664ed818c", + "chapter": "stream_iter", + "kind": "method", + "name": "fromSync", + "signature": "`fromSync(input)`", + "label": "fromSync(input)", + "apiSymbol": "fromSync", + "depth": 2, + "scope": "api", + "anchor": "fromsyncinput", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:c5f3a2450455", + "chapter": "stream_iter", + "kind": "module", + "name": "pipelines", + "signature": "Pipelines", + "label": "Pipelines", + "apiSymbol": "pipelines", + "depth": 1, + "scope": "documentation", + "anchor": "pipelines", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:c35641af526f", + "chapter": "stream_iter", + "kind": "method", + "name": "pipeTo", + "signature": "`pipeTo(source[, ...transforms], writer[, options])`", + "label": "pipeTo(source[, ...transforms], writer[, options])", + "apiSymbol": "pipeTo", + "depth": 2, + "scope": "api", + "anchor": "pipetosource-transforms-writer-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:2daa0291481c", + "chapter": "stream_iter", + "kind": "method", + "name": "pipeToSync", + "signature": "`pipeToSync(source[, ...transforms], writer[, options])`", + "label": "pipeToSync(source[, ...transforms], writer[, options])", + "apiSymbol": "pipeToSync", + "depth": 2, + "scope": "api", + "anchor": "pipetosyncsource-transforms-writer-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:00e796148b11", + "chapter": "stream_iter", + "kind": "method", + "name": "pull", + "signature": "`pull(source[, ...transforms][, options])`", + "label": "pull(source[, ...transforms][, options])", + "apiSymbol": "pull", + "depth": 2, + "scope": "api", + "anchor": "pullsource-transforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:f89b0e75e302", + "chapter": "stream_iter", + "kind": "method", + "name": "pullSync", + "signature": "`pullSync(source[, ...transforms])`", + "label": "pullSync(source[, ...transforms])", + "apiSymbol": "pullSync", + "depth": 2, + "scope": "api", + "anchor": "pullsyncsource-transforms", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:282f0d5533ca", + "chapter": "stream_iter", + "kind": "module", + "name": "push_streams", + "signature": "Push streams", + "label": "Push streams", + "apiSymbol": "push_streams", + "depth": 1, + "scope": "documentation", + "anchor": "push-streams", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:ea066cb12f48", + "chapter": "stream_iter", + "kind": "method", + "name": "push", + "signature": "`push([...transforms][, options])`", + "label": "push([...transforms][, options])", + "apiSymbol": "push", + "depth": 2, + "scope": "api", + "anchor": "pushtransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:6c0392408266", + "chapter": "stream_iter", + "kind": "module", + "name": "duplex_channels", + "signature": "Duplex channels", + "label": "Duplex channels", + "apiSymbol": "duplex_channels", + "depth": 1, + "scope": "documentation", + "anchor": "duplex-channels", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:199f13b2e259", + "chapter": "stream_iter", + "kind": "method", + "name": "duplex", + "signature": "`duplex([options])`", + "label": "duplex([options])", + "apiSymbol": "duplex", + "depth": 2, + "scope": "api", + "anchor": "duplexoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:735dea8c74e3", + "chapter": "stream_iter", + "kind": "module", + "name": "consumers", + "signature": "Consumers", + "label": "Consumers", + "apiSymbol": "consumers", + "depth": 1, + "scope": "documentation", + "anchor": "consumers", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:921683aeccfe", + "chapter": "stream_iter", + "kind": "method", + "name": "array", + "signature": "`array(source[, options])`", + "label": "array(source[, options])", + "apiSymbol": "array", + "depth": 2, + "scope": "api", + "anchor": "arraysource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:fbf10b4b189e", + "chapter": "stream_iter", + "kind": "method", + "name": "arrayBuffer", + "signature": "`arrayBuffer(source[, options])`", + "label": "arrayBuffer(source[, options])", + "apiSymbol": "arrayBuffer", + "depth": 2, + "scope": "api", + "anchor": "arraybuffersource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:e0afcafcc6fb", + "chapter": "stream_iter", + "kind": "method", + "name": "arrayBufferSync", + "signature": "`arrayBufferSync(source[, options])`", + "label": "arrayBufferSync(source[, options])", + "apiSymbol": "arrayBufferSync", + "depth": 2, + "scope": "api", + "anchor": "arraybuffersyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:b0128d2ee8ff", + "chapter": "stream_iter", + "kind": "method", + "name": "arraySync", + "signature": "`arraySync(source[, options])`", + "label": "arraySync(source[, options])", + "apiSymbol": "arraySync", + "depth": 2, + "scope": "api", + "anchor": "arraysyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:463c54160f7b", + "chapter": "stream_iter", + "kind": "method", + "name": "bytes", + "signature": "`bytes(source[, options])`", + "label": "bytes(source[, options])", + "apiSymbol": "bytes", + "depth": 2, + "scope": "api", + "anchor": "bytessource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:ee97f670b7fe", + "chapter": "stream_iter", + "kind": "method", + "name": "bytesSync", + "signature": "`bytesSync(source[, options])`", + "label": "bytesSync(source[, options])", + "apiSymbol": "bytesSync", + "depth": 2, + "scope": "api", + "anchor": "bytessyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:64923f0bbaa4", + "chapter": "stream_iter", + "kind": "method", + "name": "text", + "signature": "`text(source[, options])`", + "label": "text(source[, options])", + "apiSymbol": "text", + "depth": 2, + "scope": "api", + "anchor": "textsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:920695b6cf72", + "chapter": "stream_iter", + "kind": "method", + "name": "textSync", + "signature": "`textSync(source[, options])`", + "label": "textSync(source[, options])", + "apiSymbol": "textSync", + "depth": 2, + "scope": "api", + "anchor": "textsyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:1f92afe6a57c", + "chapter": "stream_iter", + "kind": "module", + "name": "utilities", + "signature": "Utilities", + "label": "Utilities", + "apiSymbol": "utilities", + "depth": 1, + "scope": "documentation", + "anchor": "utilities", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:8b98f79752a4", + "chapter": "stream_iter", + "kind": "method", + "name": "ondrain", + "signature": "`ondrain(drainable)`", + "label": "ondrain(drainable)", + "apiSymbol": "ondrain", + "depth": 2, + "scope": "api", + "anchor": "ondraindrainable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:87224fe2c755", + "chapter": "stream_iter", + "kind": "method", + "name": "merge", + "signature": "`merge(...sources[, options])`", + "label": "merge(...sources[, options])", + "apiSymbol": "merge", + "depth": 2, + "scope": "api", + "anchor": "mergesources-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:5fd18544d6db", + "chapter": "stream_iter", + "kind": "method", + "name": "tap", + "signature": "`tap(callback)`", + "label": "tap(callback)", + "apiSymbol": "tap", + "depth": 2, + "scope": "api", + "anchor": "tapcallback", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:b86a9a538ee6", + "chapter": "stream_iter", + "kind": "method", + "name": "tapSync", + "signature": "`tapSync(callback)`", + "label": "tapSync(callback)", + "apiSymbol": "tapSync", + "depth": 2, + "scope": "api", + "anchor": "tapsynccallback", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:21350199279e", + "chapter": "stream_iter", + "kind": "module", + "name": "multi-consumer", + "signature": "Multi-consumer", + "label": "Multi-consumer", + "apiSymbol": "multi-consumer", + "depth": 1, + "scope": "documentation", + "anchor": "multi-consumer", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:942c17d001f2", + "chapter": "stream_iter", + "kind": "module", + "name": "interface:_`shareable`", + "signature": "Interface: `Shareable`", + "label": "Interface: Shareable", + "apiSymbol": "Shareable", + "depth": 2, + "scope": "api", + "anchor": "interface-shareable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:3468fe11b070", + "chapter": "stream_iter", + "kind": "module", + "name": "`sharable[symbol.for('stream.shareprotocol')]`", + "signature": "`sharable[Symbol.for('Stream.shareProtocol')]`", + "label": "sharable[Symbol.for('Stream.shareProtocol')]", + "apiSymbol": "sharable", + "depth": 3, + "scope": "api", + "anchor": "sharablesymbolforstreamshareprotocol", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:4155dfe49484", + "chapter": "stream_iter", + "kind": "module", + "name": "interface:_`syncshareable`", + "signature": "Interface: `SyncShareable`", + "label": "Interface: SyncShareable", + "apiSymbol": "SyncShareable", + "depth": 2, + "scope": "api", + "anchor": "interface-syncshareable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:242fb4da0e1d", + "chapter": "stream_iter", + "kind": "module", + "name": "`sharable[symbol.for('stream.sharesyncprotocol')]`", + "signature": "`sharable[Symbol.for('Stream.shareSyncProtocol')]`", + "label": "sharable[Symbol.for('Stream.shareSyncProtocol')]", + "apiSymbol": "sharable", + "depth": 3, + "scope": "api", + "anchor": "sharablesymbolforstreamsharesyncprotocol", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:c284e9cc071d", + "chapter": "stream_iter", + "kind": "class", + "name": "Share", + "signature": "Class: `Share`", + "label": "Share", + "apiSymbol": "Share", + "depth": 2, + "scope": "api", + "anchor": "class-share", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:699ee25e7836", + "chapter": "stream_iter", + "kind": "method", + "name": "cancel", + "signature": "`share.cancel([reason])`", + "label": "share.cancel([reason])", + "apiSymbol": "share.cancel", + "depth": 3, + "scope": "api", + "anchor": "sharecancelreason", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:8fcfa00b2e13", + "chapter": "stream_iter", + "kind": "method", + "name": "pull", + "signature": "`share.pull([...transforms][, options])`", + "label": "share.pull([...transforms][, options])", + "apiSymbol": "share.pull", + "depth": 3, + "scope": "api", + "anchor": "sharepulltransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:72b6caf2da05", + "chapter": "stream_iter", + "kind": "method", + "name": "[Symbol.dispose]", + "signature": "`share[Symbol.dispose]()`", + "label": "share[Symbol.dispose]()", + "apiSymbol": "share", + "depth": 3, + "scope": "api", + "anchor": "sharesymboldispose", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:ff3d33f63dae", + "chapter": "stream_iter", + "kind": "number", + "name": "consumerCount", + "signature": "`consumerCount` {number}", + "label": "consumerCount", + "apiSymbol": "consumerCount", + "depth": 3, + "scope": "api", + "anchor": "class-share", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "ancestor" + }, + { + "id": "stream_iter:56fab04f6670", + "chapter": "stream_iter", + "kind": "class", + "name": "SyncShare", + "signature": "Class: `SyncShare`", + "label": "SyncShare", + "apiSymbol": "SyncShare", + "depth": 2, + "scope": "api", + "anchor": "class-syncshare", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:738b333def1d", + "chapter": "stream_iter", + "kind": "method", + "name": "cancel", + "signature": "`share.cancel([reason])`", + "label": "share.cancel([reason])", + "apiSymbol": "share.cancel", + "depth": 3, + "scope": "api", + "anchor": "sharecancelreason_1", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:54163998d82f", + "chapter": "stream_iter", + "kind": "method", + "name": "pull", + "signature": "`share.pull([...transforms][, options])`", + "label": "share.pull([...transforms][, options])", + "apiSymbol": "share.pull", + "depth": 3, + "scope": "api", + "anchor": "sharepulltransforms-options_1", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:9947ae5ee9f7", + "chapter": "stream_iter", + "kind": "method", + "name": "[Symbol.dispose]", + "signature": "`share[Symbol.dispose]()`", + "label": "share[Symbol.dispose]()", + "apiSymbol": "share", + "depth": 3, + "scope": "api", + "anchor": "sharesymboldispose_1", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:eb993c0d329d", + "chapter": "stream_iter", + "kind": "number", + "name": "bufferSize", + "signature": "`bufferSize` {number}", + "label": "bufferSize", + "apiSymbol": "bufferSize", + "depth": 3, + "scope": "api", + "anchor": "class-syncshare", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "ancestor" + }, + { + "id": "stream_iter:84388db1cec2", + "chapter": "stream_iter", + "kind": "number", + "name": "consumerCount", + "signature": "`consumerCount` {number}", + "label": "consumerCount", + "apiSymbol": "consumerCount", + "depth": 3, + "scope": "api", + "anchor": "class-syncshare", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "ancestor" + }, + { + "id": "stream_iter:fcc12813a840", + "chapter": "stream_iter", + "kind": "method", + "name": "broadcast", + "signature": "`broadcast([options])`", + "label": "broadcast([options])", + "apiSymbol": "broadcast", + "depth": 2, + "scope": "api", + "anchor": "broadcastoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:7909dd2cdb5d", + "chapter": "stream_iter", + "kind": "method", + "name": "cancel", + "signature": "`broadcast.cancel([reason])`", + "label": "broadcast.cancel([reason])", + "apiSymbol": "broadcast.cancel", + "depth": 3, + "scope": "api", + "anchor": "broadcastcancelreason", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:676e8ecc6237", + "chapter": "stream_iter", + "kind": "method", + "name": "push", + "signature": "`broadcast.push([...transforms][, options])`", + "label": "broadcast.push([...transforms][, options])", + "apiSymbol": "broadcast.push", + "depth": 3, + "scope": "api", + "anchor": "broadcastpushtransforms-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:23f1e2d4c639", + "chapter": "stream_iter", + "kind": "method", + "name": "[Symbol.dispose]", + "signature": "`broadcast[Symbol.dispose]()`", + "label": "broadcast[Symbol.dispose]()", + "apiSymbol": "broadcast", + "depth": 3, + "scope": "api", + "anchor": "broadcastsymboldispose", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:75b743029db1", + "chapter": "stream_iter", + "kind": "number", + "name": "consumerCount", + "signature": "`consumerCount` {number}", + "label": "consumerCount", + "apiSymbol": "consumerCount", + "depth": 3, + "scope": "api", + "anchor": "broadcastoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "ancestor" + }, + { + "id": "stream_iter:fd8809959bcf", + "chapter": "stream_iter", + "kind": "method", + "name": "from", + "signature": "`Broadcast.from(input[, options])`", + "label": "Broadcast.from(input[, options])", + "apiSymbol": "Broadcast.from", + "depth": 2, + "scope": "api", + "anchor": "broadcastfrominput-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:e47f09ec7c74", + "chapter": "stream_iter", + "kind": "method", + "name": "share", + "signature": "`share(source[, options])`", + "label": "share(source[, options])", + "apiSymbol": "share", + "depth": 2, + "scope": "api", + "anchor": "sharesource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:8e955476f8e6", + "chapter": "stream_iter", + "kind": "method", + "name": "shareSync", + "signature": "`shareSync(source[, options])`", + "label": "shareSync(source[, options])", + "apiSymbol": "shareSync", + "depth": 2, + "scope": "api", + "anchor": "sharesyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:8499c28666d8", + "chapter": "stream_iter", + "kind": "module", + "name": "compression_and_decompression_transforms", + "signature": "Compression and decompression transforms", + "label": "Compression and decompression transforms", + "apiSymbol": "compression_and_decompression_transforms", + "depth": 1, + "scope": "documentation", + "anchor": "compression-and-decompression-transforms", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:d333b8936a3f", + "chapter": "stream_iter", + "kind": "module", + "name": "classic_stream_interop", + "signature": "Classic stream interop", + "label": "Classic stream interop", + "apiSymbol": "classic_stream_interop", + "depth": 1, + "scope": "documentation", + "anchor": "classic-stream-interop", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:335f2485e371", + "chapter": "stream_iter", + "kind": "method", + "name": "fromReadable", + "signature": "`fromReadable(readable)`", + "label": "fromReadable(readable)", + "apiSymbol": "fromReadable", + "depth": 2, + "scope": "api", + "anchor": "fromreadablereadable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:58f5bcd9e475", + "chapter": "stream_iter", + "kind": "method", + "name": "fromWritable", + "signature": "`fromWritable(writable[, options])`", + "label": "fromWritable(writable[, options])", + "apiSymbol": "fromWritable", + "depth": 2, + "scope": "api", + "anchor": "fromwritablewritable-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:f2dddb7c0fd6", + "chapter": "stream_iter", + "kind": "method", + "name": "toReadable", + "signature": "`toReadable(source[, options])`", + "label": "toReadable(source[, options])", + "apiSymbol": "toReadable", + "depth": 2, + "scope": "api", + "anchor": "toreadablesource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:980c4eedf78c", + "chapter": "stream_iter", + "kind": "method", + "name": "toReadableSync", + "signature": "`toReadableSync(source[, options])`", + "label": "toReadableSync(source[, options])", + "apiSymbol": "toReadableSync", + "depth": 2, + "scope": "api", + "anchor": "toreadablesyncsource-options", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:0eadccfb86e1", + "chapter": "stream_iter", + "kind": "method", + "name": "toWritable", + "signature": "`toWritable(writer)`", + "label": "toWritable(writer)", + "apiSymbol": "toWritable", + "depth": 2, + "scope": "api", + "anchor": "towritablewriter", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:b45550263aa5", + "chapter": "stream_iter", + "kind": "module", + "name": "protocol_symbols", + "signature": "Protocol symbols", + "label": "Protocol symbols", + "apiSymbol": "protocol_symbols", + "depth": 1, + "scope": "documentation", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "stream_iter:a3fb72adb9d4", + "chapter": "stream_iter", + "kind": "section", + "name": "Value", + "signature": "`broadcastProtocol` Value: `Symbol.for('Stream.broadcastProtocol')`", + "label": "broadcastProtocol", + "apiSymbol": "broadcastProtocol", + "depth": 2, + "scope": "api", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "ancestor" + }, + { + "id": "stream_iter:80709c59ac66", + "chapter": "stream_iter", + "kind": "section", + "name": "Value", + "signature": "`drainableProtocol` Value: `Symbol.for('Stream.drainableProtocol')`", + "label": "drainableProtocol", + "apiSymbol": "drainableProtocol", + "depth": 2, + "scope": "api", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "ancestor" + }, + { + "id": "stream_iter:d6e40713d854", + "chapter": "stream_iter", + "kind": "section", + "name": "Value", + "signature": "`shareProtocol` Value: `Symbol.for('Stream.shareProtocol')`", + "label": "shareProtocol", + "apiSymbol": "shareProtocol", + "depth": 2, + "scope": "api", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "ancestor" + }, + { + "id": "stream_iter:1df144641604", + "chapter": "stream_iter", + "kind": "section", + "name": "Value", + "signature": "`shareSyncProtocol` Value: `Symbol.for('Stream.shareSyncProtocol')`", + "label": "shareSyncProtocol", + "apiSymbol": "shareSyncProtocol", + "depth": 2, + "scope": "api", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "ancestor" + }, + { + "id": "stream_iter:02b320eb031a", + "chapter": "stream_iter", + "kind": "section", + "name": "Value", + "signature": "`toAsyncStreamable` Value: `Symbol.for('Stream.toAsyncStreamable')`", + "label": "toAsyncStreamable", + "apiSymbol": "toAsyncStreamable", + "depth": 2, + "scope": "api", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "ancestor" + }, + { + "id": "stream_iter:870e05b0278a", + "chapter": "stream_iter", + "kind": "section", + "name": "Value", + "signature": "`toStreamable` Value: `Symbol.for('Stream.toStreamable')`", + "label": "toStreamable", + "apiSymbol": "toStreamable", + "depth": 2, + "scope": "api", + "anchor": "protocol-symbols", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental – Enable this API with the [`--experimental-stream-iter`][] CLI flag.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream_iter" + }, + "anchorSource": "ancestor" + }, { "id": "modules:407c51651126", "chapter": "modules", @@ -64431,6 +68087,29 @@ }, "anchorSource": "exact" }, + { + "id": "esm:987c2b8c53cd", + "chapter": "esm", + "kind": "misc", + "name": "text_modules", + "signature": "Text modules", + "label": "Text modules", + "apiSymbol": "text_modules", + "depth": 1, + "scope": "documentation", + "anchor": "text-modules", + "nodeStability": { + "index": "1.0", + "level": 1, + "text": "Early development", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "esm:552288b53cd6", "chapter": "esm", @@ -66385,6 +70064,167 @@ }, "anchorSource": "exact" }, + { + "id": "packages:d511b2f4afdb", + "chapter": "packages", + "kind": "misc", + "name": "package_maps", + "signature": "Package maps", + "label": "Package maps", + "apiSymbol": "package_maps", + "depth": 1, + "scope": "documentation", + "anchor": "package-maps", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental. Enable this API with [`--experimental-package-map`][].", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "packages:d7082b5575d6", + "chapter": "packages", + "kind": "module", + "name": "configuration_file_format", + "signature": "Configuration file format", + "label": "Configuration file format", + "apiSymbol": "configuration_file_format", + "depth": 2, + "scope": "documentation", + "anchor": "configuration-file-format", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental. Enable this API with [`--experimental-package-map`][].", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "packages:7da1a1268c3c", + "chapter": "packages", + "kind": "module", + "name": "resolution_algorithm", + "signature": "Resolution algorithm", + "label": "Resolution algorithm", + "apiSymbol": "resolution_algorithm", + "depth": 2, + "scope": "documentation", + "anchor": "resolution-algorithm", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental. Enable this API with [`--experimental-package-map`][].", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "packages:2f694be89f1f", + "chapter": "packages", + "kind": "module", + "name": "multiple_package_versions", + "signature": "Multiple package versions", + "label": "Multiple package versions", + "apiSymbol": "multiple_package_versions", + "depth": 2, + "scope": "documentation", + "anchor": "multiple-package-versions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental. Enable this API with [`--experimental-package-map`][].", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "packages:17820ea8abf3", + "chapter": "packages", + "kind": "module", + "name": "multiple_packages_for_the_same_url", + "signature": "Multiple packages for the same URL", + "label": "Multiple packages for the same URL", + "apiSymbol": "multiple_packages_for_the_same_url", + "depth": 2, + "scope": "documentation", + "anchor": "multiple-packages-for-the-same-url", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental. Enable this API with [`--experimental-package-map`][].", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "packages:894cc500d3f3", + "chapter": "packages", + "kind": "module", + "name": "interaction_with_other_resolution", + "signature": "Interaction with other resolution", + "label": "Interaction with other resolution", + "apiSymbol": "interaction_with_other_resolution", + "depth": 2, + "scope": "documentation", + "anchor": "interaction-with-other-resolution", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental. Enable this API with [`--experimental-package-map`][].", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "packages:651877f92d7b", + "chapter": "packages", + "kind": "module", + "name": "limitations", + "signature": "Limitations", + "label": "Limitations", + "apiSymbol": "limitations", + "depth": 2, + "scope": "documentation", + "anchor": "limitations", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental. Enable this API with [`--experimental-package-map`][].", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "packages:e3b770c4d8b1", "chapter": "packages", @@ -66900,6 +70740,60 @@ }, "anchorSource": "exact" }, + { + "id": "net:bed278373fec", + "chapter": "net", + "kind": "method", + "name": "addAddresses", + "signature": "`blockList.addAddresses(addresses[, type])`", + "label": "blockList.addAddresses(addresses[, type])", + "apiSymbol": "blockList.addAddresses", + "depth": 2, + "scope": "api", + "anchor": "blocklistaddaddressesaddresses-type", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:3eab1fde8dda", + "chapter": "net", + "kind": "method", + "name": "addCIDR", + "signature": "`blockList.addCIDR(cidr)`", + "label": "blockList.addCIDR(cidr)", + "apiSymbol": "blockList.addCIDR", + "depth": 2, + "scope": "api", + "anchor": "blocklistaddcidrcidr", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:85bb2c28b8b4", + "chapter": "net", + "kind": "method", + "name": "addCIDRs", + "signature": "`blockList.addCIDRs(cidrs)`", + "label": "blockList.addCIDRs(cidrs)", + "apiSymbol": "blockList.addCIDRs", + "depth": 2, + "scope": "api", + "anchor": "blocklistaddcidrscidrs", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, { "id": "net:035828cd10e1", "chapter": "net", @@ -66955,16 +70849,16 @@ "anchorSource": "exact" }, { - "id": "net:4ff6a4c12f52", + "id": "net:e0681ee0179f", "chapter": "net", "kind": "method", - "name": "isBlockList", - "signature": "`BlockList.isBlockList(value)`", - "label": "BlockList.isBlockList(value)", - "apiSymbol": "BlockList.isBlockList", + "name": "clear", + "signature": "`blockList.clear()`", + "label": "blockList.clear()", + "apiSymbol": "blockList.clear", "depth": 2, "scope": "api", - "anchor": "blocklistisblocklistvalue", + "anchor": "blocklistclear", "nodeStability": null, "static": { "status": "not-implemented", @@ -66984,9 +70878,9 @@ "scope": "api", "anchor": "blocklistfromjsonvalue", "nodeStability": { - "index": "1", + "index": "1.2", "level": 1, - "text": "Experimental", + "text": "Release candidate", "inherited": false }, "static": { @@ -66995,6 +70889,96 @@ }, "anchorSource": "exact" }, + { + "id": "net:4ff6a4c12f52", + "chapter": "net", + "kind": "method", + "name": "isBlockList", + "signature": "`BlockList.isBlockList(value)`", + "label": "BlockList.isBlockList(value)", + "apiSymbol": "BlockList.isBlockList", + "depth": 2, + "scope": "api", + "anchor": "blocklistisblocklistvalue", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:6ccaedabc10a", + "chapter": "net", + "kind": "method", + "name": "removeAddress", + "signature": "`blockList.removeAddress(address[, type])`", + "label": "blockList.removeAddress(address[, type])", + "apiSymbol": "blockList.removeAddress", + "depth": 2, + "scope": "api", + "anchor": "blocklistremoveaddressaddress-type", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:03c6467a8162", + "chapter": "net", + "kind": "method", + "name": "removeCIDR", + "signature": "`blockList.removeCIDR(cidr)`", + "label": "blockList.removeCIDR(cidr)", + "apiSymbol": "blockList.removeCIDR", + "depth": 2, + "scope": "api", + "anchor": "blocklistremovecidrcidr", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:8ba4f8ec27e3", + "chapter": "net", + "kind": "method", + "name": "removeRange", + "signature": "`blockList.removeRange(start, end[, type])`", + "label": "blockList.removeRange(start, end[, type])", + "apiSymbol": "blockList.removeRange", + "depth": 2, + "scope": "api", + "anchor": "blocklistremoverangestart-end-type", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:6cc98f6368e6", + "chapter": "net", + "kind": "method", + "name": "removeSubnet", + "signature": "`blockList.removeSubnet(net, prefix[, type])`", + "label": "blockList.removeSubnet(net, prefix[, type])", + "apiSymbol": "blockList.removeSubnet", + "depth": 2, + "scope": "api", + "anchor": "blocklistremovesubnetnet-prefix-type", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, { "id": "net:fb2019fd5533", "chapter": "net", @@ -67007,9 +70991,9 @@ "scope": "api", "anchor": "blocklisttojson", "nodeStability": { - "index": "1", + "index": "1.2", "level": 1, - "text": "Experimental", + "text": "Release candidate", "inherited": false }, "static": { @@ -67018,6 +71002,24 @@ }, "anchorSource": "exact" }, + { + "id": "net:cdbc674629fb", + "chapter": "net", + "kind": "string\\[]", + "name": "Type", + "signature": "`PRIVATE_RANGES` Type: {string\\[]}", + "label": "PRIVATE_RANGES", + "apiSymbol": "PRIVATE_RANGES", + "depth": 2, + "scope": "api", + "anchor": "class-netblocklist", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "ancestor" + }, { "id": "net:044763579a8b", "chapter": "net", @@ -67036,6 +71038,24 @@ }, "anchorSource": "ancestor" }, + { + "id": "net:67046fe1e98b", + "chapter": "net", + "kind": "number", + "name": "Type", + "signature": "`size` Type: {number}", + "label": "size", + "apiSymbol": "size", + "depth": 2, + "scope": "api", + "anchor": "class-netblocklist", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "ancestor" + }, { "id": "net:89343bd5aaf9", "chapter": "net", @@ -67550,6 +71570,24 @@ }, "anchorSource": "exact" }, + { + "id": "net:9f701d43817b", + "chapter": "net", + "kind": "module", + "name": "transferring_tcp_handles_to_other_threads", + "signature": "Transferring TCP handles to other threads", + "label": "Transferring TCP handles to other threads", + "apiSymbol": "transferring_tcp_handles_to_other_threads", + "depth": 2, + "scope": "documentation", + "anchor": "transferring-tcp-handles-to-other-threads", + "nodeStability": null, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "net:0acfadfa8cd9", "chapter": "net", @@ -67823,16 +71861,52 @@ "anchorSource": "exact" }, { - "id": "net:7412f0f2828d", + "id": "net:b6eb2938c348", "chapter": "net", "kind": "method", "name": "setKeepAlive", - "signature": "`socket.setKeepAlive([enable][, initialDelay])`", - "label": "socket.setKeepAlive([enable][, initialDelay])", + "signature": "`socket.setKeepAlive()`", + "label": "socket.setKeepAlive()", "apiSymbol": "socket.setKeepAlive", "depth": 2, "scope": "api", - "anchor": "socketsetkeepaliveenable-initialdelay", + "anchor": "socketsetkeepalive", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:9fb8a064a508", + "chapter": "net", + "kind": "method", + "name": "setKeepAlive", + "signature": "`socket.setKeepAlive([options])`", + "label": "socket.setKeepAlive([options])", + "apiSymbol": "socket.setKeepAlive", + "depth": 3, + "scope": "api", + "anchor": "socketsetkeepaliveoptions", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:50eb33c33a53", + "chapter": "net", + "kind": "method", + "name": "setKeepAlive", + "signature": "`socket.setKeepAlive([enable][, initialDelay][, interval][, count])`", + "label": "socket.setKeepAlive([enable][, initialDelay][, interval][, count])", + "apiSymbol": "socket.setKeepAlive", + "depth": 3, + "scope": "api", + "anchor": "socketsetkeepaliveenable-initialdelay-interval-count", "nodeStability": null, "static": { "status": "not-implemented", @@ -68055,11 +72129,11 @@ "anchorSource": "ancestor" }, { - "id": "net:606071fbf392", + "id": "net:5fb78ca7306f", "chapter": "net", "kind": "boolean", "name": "Type", - "signature": "`destroyed` Type: {boolean} Indicates if the connection is destroyed or not. Once a connection is destroyed no further data can be transferred using it.", + "signature": "`destroyed` Type: {boolean} Indicates if the connection is destroyed or not. No further data can be transferred using a destroyed connection.", "label": "destroyed", "apiSymbol": "destroyed", "depth": 2, @@ -68198,6 +72272,24 @@ }, "anchorSource": "ancestor" }, + { + "id": "net:d1a2a3208778", + "chapter": "net", + "kind": "net.Server|null", + "name": "Type", + "signature": "`server` Type: {net.Server|null}", + "label": "server", + "apiSymbol": "server", + "depth": 2, + "scope": "api", + "anchor": "class-netsocket", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "ancestor" + }, { "id": "net:f96568725a94", "chapter": "net", @@ -68455,6 +72547,114 @@ }, "anchorSource": "exact" }, + { + "id": "net:414417365ac3", + "chapter": "net", + "kind": "class", + "name": "net.BoundSocket", + "signature": "Class: `net.BoundSocket`", + "label": "net.BoundSocket", + "apiSymbol": "net.BoundSocket", + "depth": 1, + "scope": "api", + "anchor": "class-netboundsocket", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:400d8120e3ab", + "chapter": "net", + "kind": "method", + "name": "address", + "signature": "`boundSocket.address()`", + "label": "boundSocket.address()", + "apiSymbol": "boundSocket.address", + "depth": 2, + "scope": "api", + "anchor": "boundsocketaddress", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:ea9d92069057", + "chapter": "net", + "kind": "method", + "name": "fd", + "signature": "`boundSocket.fd()`", + "label": "boundSocket.fd()", + "apiSymbol": "boundSocket.fd", + "depth": 2, + "scope": "api", + "anchor": "boundsocketfd", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:185a5473f064", + "chapter": "net", + "kind": "method", + "name": "close", + "signature": "`boundSocket.close()`", + "label": "boundSocket.close()", + "apiSymbol": "boundSocket.close", + "depth": 2, + "scope": "api", + "anchor": "boundsocketclose", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:9cc281d92386", + "chapter": "net", + "kind": "method", + "name": "[Symbol.dispose]", + "signature": "`boundSocket[Symbol.dispose]()`", + "label": "boundSocket[Symbol.dispose]()", + "apiSymbol": "boundSocket", + "depth": 2, + "scope": "api", + "anchor": "boundsocketsymboldispose", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "exact" + }, + { + "id": "net:66918477ba37", + "chapter": "net", + "kind": "boolean", + "name": "isPipe", + "signature": "`isPipe` {boolean}", + "label": "isPipe", + "apiSymbol": "isPipe", + "depth": 2, + "scope": "api", + "anchor": "class-netboundsocket", + "nodeStability": null, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:net" + }, + "anchorSource": "ancestor" + }, { "id": "net:2d7b6dbbbe2c", "chapter": "net", @@ -70172,6 +74372,332 @@ }, "anchorSource": "chapter" }, + { + "id": "perf_hooks:eac94be4939c", + "chapter": "perf_hooks", + "kind": "module", + "name": "histogram_analysis_examples", + "signature": "Histogram analysis examples", + "label": "Histogram analysis examples", + "apiSymbol": "histogram_analysis_examples", + "depth": 1, + "scope": "documentation", + "anchor": "histogram-analysis-examples", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:f5c281fa8b09", + "chapter": "perf_hooks", + "kind": "module", + "name": "distribution_shape_analysis", + "signature": "Distribution shape analysis", + "label": "Distribution shape analysis", + "apiSymbol": "distribution_shape_analysis", + "depth": 2, + "scope": "documentation", + "anchor": "distribution-shape-analysis", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:553c1f7af064", + "chapter": "perf_hooks", + "kind": "module", + "name": "slo_monitoring_with_cdf", + "signature": "SLO monitoring with CDF", + "label": "SLO monitoring with CDF", + "apiSymbol": "slo_monitoring_with_cdf", + "depth": 2, + "scope": "documentation", + "anchor": "slo-monitoring-with-cdf", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:fda258256029", + "chapter": "perf_hooks", + "kind": "module", + "name": "slo_burn_rate_monitoring", + "signature": "SLO burn rate monitoring", + "label": "SLO burn rate monitoring", + "apiSymbol": "slo_burn_rate_monitoring", + "depth": 2, + "scope": "documentation", + "anchor": "slo-burn-rate-monitoring", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:58a875fd62b3", + "chapter": "perf_hooks", + "kind": "module", + "name": "regression_detection_with_ks_test", + "signature": "Regression detection with KS test", + "label": "Regression detection with KS test", + "apiSymbol": "regression_detection_with_ks_test", + "depth": 2, + "scope": "documentation", + "anchor": "regression-detection-with-ks-test", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:c235fc97bd5b", + "chapter": "perf_hooks", + "kind": "module", + "name": "batch_percentile_queries", + "signature": "Batch percentile queries", + "label": "Batch percentile queries", + "apiSymbol": "batch_percentile_queries", + "depth": 2, + "scope": "documentation", + "anchor": "batch-percentile-queries", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:0ce4292ea129", + "chapter": "perf_hooks", + "kind": "module", + "name": "snapshot_diffing_with_subtract", + "signature": "Snapshot diffing with subtract", + "label": "Snapshot diffing with subtract", + "apiSymbol": "snapshot_diffing_with_subtract", + "depth": 2, + "scope": "documentation", + "anchor": "snapshot-diffing-with-subtract", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:96a1ebff4ee1", + "chapter": "perf_hooks", + "kind": "module", + "name": "benchmark_comparison_with_welch's_t-test", + "signature": "Benchmark comparison with Welch's t-test", + "label": "Benchmark comparison with Welch's t-test", + "apiSymbol": "benchmark_comparison_with_welch's_t-test", + "depth": 2, + "scope": "documentation", + "anchor": "benchmark-comparison-with-welchs-t-test", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:7cf7163e6098", + "chapter": "perf_hooks", + "kind": "module", + "name": "effect_size_with_cliff's_delta", + "signature": "Effect size with Cliff's delta", + "label": "Effect size with Cliff's delta", + "apiSymbol": "effect_size_with_cliff's_delta", + "depth": 2, + "scope": "documentation", + "anchor": "effect-size-with-cliffs-delta", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:7cd8d77c8f3d", + "chapter": "perf_hooks", + "kind": "module", + "name": "measuring_the_duration_of_async_operations", + "signature": "Measuring the duration of async operations", + "label": "Measuring the duration of async operations", + "apiSymbol": "measuring_the_duration_of_async_operations", + "depth": 2, + "scope": "documentation", + "anchor": "measuring-the-duration-of-async-operations", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:ce1b41734d1f", + "chapter": "perf_hooks", + "kind": "module", + "name": "measuring_how_long_it_takes_to_load_dependencies", + "signature": "Measuring how long it takes to load dependencies", + "label": "Measuring how long it takes to load dependencies", + "apiSymbol": "measuring_how_long_it_takes_to_load_dependencies", + "depth": 2, + "scope": "documentation", + "anchor": "measuring-how-long-it-takes-to-load-dependencies", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:d08b033da78b", + "chapter": "perf_hooks", + "kind": "module", + "name": "measuring_how_long_one_http_round-trip_takes", + "signature": "Measuring how long one HTTP round-trip takes", + "label": "Measuring how long one HTTP round-trip takes", + "apiSymbol": "measuring_how_long_one_http_round-trip_takes", + "depth": 2, + "scope": "documentation", + "anchor": "measuring-how-long-one-http-round-trip-takes", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:0f3b0bd30e2d", + "chapter": "perf_hooks", + "kind": "module", + "name": "measuring_how_long_the_`net.connect`_(only_for_tcp)_takes_when_the_connection_is_successful", + "signature": "Measuring how long the `net.connect` (only for TCP) takes when the connection is successful", + "label": "Measuring how long the net.connect (only for TCP) takes when the connection is successful", + "apiSymbol": "net.connect", + "depth": 2, + "scope": "api", + "anchor": "measuring-how-long-the-netconnect-only-for-tcp-takes-when-the-connection-is-successful", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "partial", + "evidence": "compiler-dedicated:net.connect", + "tests": [ + "tests/corpus/2500-net-autosel-timeout.ts", + "tests/corpus/2596-net-arg-ladders.cjs" + ] + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:498f9466e021", + "chapter": "perf_hooks", + "kind": "module", + "name": "measuring_how_long_the_dns_takes_when_the_request_is_successful", + "signature": "Measuring how long the DNS takes when the request is successful", + "label": "Measuring how long the DNS takes when the request is successful", + "apiSymbol": "measuring_how_long_the_dns_takes_when_the_request_is_successful", + "depth": 2, + "scope": "documentation", + "anchor": "measuring-how-long-the-dns-takes-when-the-request-is-successful", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "perf_hooks:4191f3d1f637", "chapter": "perf_hooks", @@ -71128,6 +75654,75 @@ }, "anchorSource": "ancestor" }, + { + "id": "perf_hooks:6af5b39b755a", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`finalResponseHeadersStart` Type: {number}", + "label": "finalResponseHeadersStart", + "apiSymbol": "finalResponseHeadersStart", + "depth": 2, + "scope": "api", + "anchor": "class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "ancestor" + }, + { + "id": "perf_hooks:756cbc84eee9", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`firstInterimResponseStart` Type: {number}", + "label": "firstInterimResponseStart", + "apiSymbol": "firstInterimResponseStart", + "depth": 2, + "scope": "api", + "anchor": "class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "ancestor" + }, + { + "id": "perf_hooks:7869397fdf24", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`responseStart` Type: {number}", + "label": "responseStart", + "apiSymbol": "responseStart", + "depth": 2, + "scope": "api", + "anchor": "class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "ancestor" + }, { "id": "perf_hooks:19c7eaa1d601", "chapter": "perf_hooks", @@ -71220,6 +75815,75 @@ }, "anchorSource": "ancestor" }, + { + "id": "perf_hooks:3d425c5f696c", + "chapter": "perf_hooks", + "kind": "string", + "name": "Type", + "signature": "`renderBlockingStatus` Type: {string}", + "label": "renderBlockingStatus", + "apiSymbol": "renderBlockingStatus", + "depth": 2, + "scope": "api", + "anchor": "class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "ancestor" + }, + { + "id": "perf_hooks:03b62556cc5e", + "chapter": "perf_hooks", + "kind": "string", + "name": "Type", + "signature": "`contentType` Type: {string}", + "label": "contentType", + "apiSymbol": "contentType", + "depth": 2, + "scope": "api", + "anchor": "class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "ancestor" + }, + { + "id": "perf_hooks:29830b9da1a6", + "chapter": "perf_hooks", + "kind": "string", + "name": "Type", + "signature": "`contentEncoding` Type: {string}", + "label": "contentEncoding", + "apiSymbol": "contentEncoding", + "depth": 2, + "scope": "api", + "anchor": "class-performanceresourcetiming", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "ancestor" + }, { "id": "perf_hooks:44c5636e6a4c", "chapter": "perf_hooks", @@ -71450,6 +76114,282 @@ }, "anchorSource": "exact" }, + { + "id": "perf_hooks:759eb564d36d", + "chapter": "perf_hooks", + "kind": "method", + "name": "ccdf", + "signature": "`histogram.ccdf(value)`", + "label": "histogram.ccdf(value)", + "apiSymbol": "histogram.ccdf", + "depth": 2, + "scope": "api", + "anchor": "histogramccdfvalue", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:8d22421f4895", + "chapter": "perf_hooks", + "kind": "method", + "name": "cdf", + "signature": "`histogram.cdf(value)`", + "label": "histogram.cdf(value)", + "apiSymbol": "histogram.cdf", + "depth": 2, + "scope": "api", + "anchor": "histogramcdfvalue", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:7d3698e4b7e1", + "chapter": "perf_hooks", + "kind": "method", + "name": "cliffsD", + "signature": "`histogram.cliffsD(other)`", + "label": "histogram.cliffsD(other)", + "apiSymbol": "histogram.cliffsD", + "depth": 2, + "scope": "api", + "anchor": "histogramcliffsdother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:f6b0fdd4f95c", + "chapter": "perf_hooks", + "kind": "method", + "name": "cohensD", + "signature": "`histogram.cohensD(other)`", + "label": "histogram.cohensD(other)", + "apiSymbol": "histogram.cohensD", + "depth": 2, + "scope": "api", + "anchor": "histogramcohensdother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:32d32caabb57", + "chapter": "perf_hooks", + "kind": "method", + "name": "countAt", + "signature": "`histogram.countAt(value)`", + "label": "histogram.countAt(value)", + "apiSymbol": "histogram.countAt", + "depth": 2, + "scope": "api", + "anchor": "histogramcountatvalue", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:a654b4b820aa", + "chapter": "perf_hooks", + "kind": "method", + "name": "export", + "signature": "`histogram.export()`", + "label": "histogram.export()", + "apiSymbol": "histogram.export", + "depth": 2, + "scope": "api", + "anchor": "histogramexport", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:9eb87d68eed4", + "chapter": "perf_hooks", + "kind": "method", + "name": "burnRate", + "signature": "`histogram.burnRate(sloTarget)`", + "label": "histogram.burnRate(sloTarget)", + "apiSymbol": "histogram.burnRate", + "depth": 2, + "scope": "api", + "anchor": "histogramburnrateslotarget", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:efa4bd467f9d", + "chapter": "perf_hooks", + "kind": "method", + "name": "ksTest", + "signature": "`histogram.ksTest(other)`", + "label": "histogram.ksTest(other)", + "apiSymbol": "histogram.ksTest", + "depth": 2, + "scope": "api", + "anchor": "histogramkstestother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:c0563cf15d0e", + "chapter": "perf_hooks", + "kind": "method", + "name": "linearBuckets", + "signature": "`histogram.linearBuckets(stepSize)`", + "label": "histogram.linearBuckets(stepSize)", + "apiSymbol": "histogram.linearBuckets", + "depth": 2, + "scope": "api", + "anchor": "histogramlinearbucketsstepsize", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:5899ce3fef5c", + "chapter": "perf_hooks", + "kind": "method", + "name": "logBuckets", + "signature": "`histogram.logBuckets(firstBucket, base)`", + "label": "histogram.logBuckets(firstBucket, base)", + "apiSymbol": "histogram.logBuckets", + "depth": 2, + "scope": "api", + "anchor": "histogramlogbucketsfirstbucket-base", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:b477f2eb976a", + "chapter": "perf_hooks", + "kind": "method", + "name": "mannWhitneyTest", + "signature": "`histogram.mannWhitneyTest(other)`", + "label": "histogram.mannWhitneyTest(other)", + "apiSymbol": "histogram.mannWhitneyTest", + "depth": 2, + "scope": "api", + "anchor": "histogrammannwhitneytestother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:57aff1eb8969", + "chapter": "perf_hooks", + "kind": "method", + "name": "meanCI", + "signature": "`histogram.meanCI([options])`", + "label": "histogram.meanCI([options])", + "apiSymbol": "histogram.meanCI", + "depth": 2, + "scope": "api", + "anchor": "histogrammeancioptions", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, { "id": "perf_hooks:831e531b3964", "chapter": "perf_hooks", @@ -71496,6 +76436,75 @@ }, "anchorSource": "exact" }, + { + "id": "perf_hooks:5a5e7386f377", + "chapter": "perf_hooks", + "kind": "method", + "name": "percentileCI", + "signature": "`histogram.percentileCI(percentile[, options])`", + "label": "histogram.percentileCI(percentile[, options])", + "apiSymbol": "histogram.percentileCI", + "depth": 2, + "scope": "api", + "anchor": "histogrampercentilecipercentile-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:e35001d4c8a0", + "chapter": "perf_hooks", + "kind": "method", + "name": "percentilesAt", + "signature": "`histogram.percentilesAt(percentiles)`", + "label": "histogram.percentilesAt(percentiles)", + "apiSymbol": "histogram.percentilesAt", + "depth": 2, + "scope": "api", + "anchor": "histogrampercentilesatpercentiles", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:e8464d875a0d", + "chapter": "perf_hooks", + "kind": "method", + "name": "qrde", + "signature": "`histogram.qrde([options])`", + "label": "histogram.qrde([options])", + "apiSymbol": "histogram.qrde", + "depth": 2, + "scope": "api", + "anchor": "histogramqrdeoptions", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, { "id": "perf_hooks:0c8a168f2d58", "chapter": "perf_hooks", @@ -71519,6 +76528,29 @@ }, "anchorSource": "exact" }, + { + "id": "perf_hooks:355c107f6c4d", + "chapter": "perf_hooks", + "kind": "method", + "name": "welchTest", + "signature": "`histogram.welchTest(other[, options])`", + "label": "histogram.welchTest(other[, options])", + "apiSymbol": "histogram.welchTest", + "depth": 2, + "scope": "api", + "anchor": "histogramwelchtestother-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, { "id": "perf_hooks:c3ade18455b5", "chapter": "perf_hooks", @@ -71611,6 +76643,98 @@ }, "anchorSource": "ancestor" }, + { + "id": "perf_hooks:a6dbb2c261dd", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`ewmaMean` Type: {number}", + "label": "ewmaMean", + "apiSymbol": "ewmaMean", + "depth": 2, + "scope": "api", + "anchor": "class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "ancestor" + }, + { + "id": "perf_hooks:ff01abf35e25", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`ewmaStddev` Type: {number}", + "label": "ewmaStddev", + "apiSymbol": "ewmaStddev", + "depth": 2, + "scope": "api", + "anchor": "class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "ancestor" + }, + { + "id": "perf_hooks:5b140d5efd8a", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`ewmaErrorRate` Type: {number}", + "label": "ewmaErrorRate", + "apiSymbol": "ewmaErrorRate", + "depth": 2, + "scope": "api", + "anchor": "class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "ancestor" + }, + { + "id": "perf_hooks:0b729495c21e", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`kurtosis` Type: {number}", + "label": "kurtosis", + "apiSymbol": "kurtosis", + "depth": 2, + "scope": "api", + "anchor": "class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "ancestor" + }, { "id": "perf_hooks:2a2f8716b952", "chapter": "perf_hooks", @@ -71772,6 +76896,29 @@ }, "anchorSource": "ancestor" }, + { + "id": "perf_hooks:740617c55837", + "chapter": "perf_hooks", + "kind": "number", + "name": "Type", + "signature": "`skewness` Type: {number}", + "label": "skewness", + "apiSymbol": "skewness", + "depth": 2, + "scope": "api", + "anchor": "class-histogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "ancestor" + }, { "id": "perf_hooks:dcfa27e91fad", "chapter": "perf_hooks", @@ -71796,16 +76943,16 @@ "anchorSource": "ancestor" }, { - "id": "perf_hooks:d8033c297e16", + "id": "perf_hooks:8a7e519bbfcf", "chapter": "perf_hooks", "kind": "class", - "name": "IntervalHistogram", - "signature": "Class: `IntervalHistogram extends Histogram`", - "label": "IntervalHistogram extends Histogram", - "apiSymbol": "IntervalHistogram extends Histogram", + "name": "ELDHistogram", + "signature": "Class: `ELDHistogram extends Histogram`", + "label": "ELDHistogram extends Histogram", + "apiSymbol": "ELDHistogram extends Histogram", "depth": 1, "scope": "api", - "anchor": "class-intervalhistogram-extends-histogram", + "anchor": "class-eldhistogram-extends-histogram", "nodeStability": { "index": "2", "level": 2, @@ -71819,16 +76966,16 @@ "anchorSource": "exact" }, { - "id": "perf_hooks:22e7f3f19476", + "id": "perf_hooks:c4fd14c1e628", "chapter": "perf_hooks", "kind": "module", - "name": "cloning_an_`intervalhistogram`", - "signature": "Cloning an `IntervalHistogram`", - "label": "Cloning an IntervalHistogram", - "apiSymbol": "IntervalHistogram", + "name": "cloning_an_`eldhistogram`", + "signature": "Cloning an `ELDHistogram`", + "label": "Cloning an ELDHistogram", + "apiSymbol": "ELDHistogram", "depth": 2, "scope": "api", - "anchor": "cloning-an-intervalhistogram", + "anchor": "cloning-an-eldhistogram", "nodeStability": { "index": "2", "level": 2, @@ -71842,7 +76989,7 @@ "anchorSource": "exact" }, { - "id": "perf_hooks:b164c7ab2b1f", + "id": "perf_hooks:b534ec2912d4", "chapter": "perf_hooks", "kind": "method", "name": "disable", @@ -71865,7 +77012,7 @@ "anchorSource": "exact" }, { - "id": "perf_hooks:651554deb586", + "id": "perf_hooks:6101277d5070", "chapter": "perf_hooks", "kind": "method", "name": "enable", @@ -71888,7 +77035,7 @@ "anchorSource": "exact" }, { - "id": "perf_hooks:e996f640b593", + "id": "perf_hooks:02e07d3a1e87", "chapter": "perf_hooks", "kind": "method", "name": "[Symbol.dispose]", @@ -71933,125 +77080,6 @@ }, "anchorSource": "exact" }, - { - "id": "perf_hooks:76b9cd148368", - "chapter": "perf_hooks", - "kind": "module", - "name": "measuring_the_duration_of_async_operations", - "signature": "Measuring the duration of async operations", - "label": "Measuring the duration of async operations", - "apiSymbol": "measuring_the_duration_of_async_operations", - "depth": 2, - "scope": "documentation", - "anchor": "measuring-the-duration-of-async-operations", - "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true - }, - "static": { - "status": "not-applicable", - "evidence": "documentation" - }, - "anchorSource": "exact" - }, - { - "id": "perf_hooks:b31b279a981b", - "chapter": "perf_hooks", - "kind": "module", - "name": "measuring_how_long_it_takes_to_load_dependencies", - "signature": "Measuring how long it takes to load dependencies", - "label": "Measuring how long it takes to load dependencies", - "apiSymbol": "measuring_how_long_it_takes_to_load_dependencies", - "depth": 2, - "scope": "documentation", - "anchor": "measuring-how-long-it-takes-to-load-dependencies", - "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true - }, - "static": { - "status": "not-applicable", - "evidence": "documentation" - }, - "anchorSource": "exact" - }, - { - "id": "perf_hooks:3195dadda5d7", - "chapter": "perf_hooks", - "kind": "module", - "name": "measuring_how_long_one_http_round-trip_takes", - "signature": "Measuring how long one HTTP round-trip takes", - "label": "Measuring how long one HTTP round-trip takes", - "apiSymbol": "measuring_how_long_one_http_round-trip_takes", - "depth": 2, - "scope": "documentation", - "anchor": "measuring-how-long-one-http-round-trip-takes", - "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true - }, - "static": { - "status": "not-applicable", - "evidence": "documentation" - }, - "anchorSource": "exact" - }, - { - "id": "perf_hooks:07074b77fe50", - "chapter": "perf_hooks", - "kind": "module", - "name": "measuring_how_long_the_`net.connect`_(only_for_tcp)_takes_when_the_connection_is_successful", - "signature": "Measuring how long the `net.connect` (only for TCP) takes when the connection is successful", - "label": "Measuring how long the net.connect (only for TCP) takes when the connection is successful", - "apiSymbol": "net.connect", - "depth": 2, - "scope": "api", - "anchor": "measuring-how-long-the-netconnect-only-for-tcp-takes-when-the-connection-is-successful", - "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true - }, - "static": { - "status": "partial", - "evidence": "compiler-dedicated:net.connect", - "tests": [ - "tests/corpus/2500-net-autosel-timeout.ts", - "tests/corpus/2596-net-arg-ladders.cjs" - ] - }, - "anchorSource": "exact" - }, - { - "id": "perf_hooks:726a43ab240e", - "chapter": "perf_hooks", - "kind": "module", - "name": "measuring_how_long_the_dns_takes_when_the_request_is_successful", - "signature": "Measuring how long the DNS takes when the request is successful", - "label": "Measuring how long the DNS takes when the request is successful", - "apiSymbol": "measuring_how_long_the_dns_takes_when_the_request_is_successful", - "depth": 2, - "scope": "documentation", - "anchor": "measuring-how-long-the-dns-takes-when-the-request-is-successful", - "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true - }, - "static": { - "status": "not-applicable", - "evidence": "documentation" - }, - "anchorSource": "exact" - }, { "id": "perf_hooks:30eb4343b866", "chapter": "perf_hooks", @@ -72121,6 +77149,144 @@ }, "anchorSource": "exact" }, + { + "id": "perf_hooks:7bb1ff7d8dee", + "chapter": "perf_hooks", + "kind": "method", + "name": "recordCorrected", + "signature": "`histogram.recordCorrected(val, expectedInterval)`", + "label": "histogram.recordCorrected(val, expectedInterval)", + "apiSymbol": "histogram.recordCorrected", + "depth": 2, + "scope": "api", + "anchor": "histogramrecordcorrectedval-expectedinterval", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:45ea9ace9906", + "chapter": "perf_hooks", + "kind": "method", + "name": "subtract", + "signature": "`histogram.subtract(other)`", + "label": "histogram.subtract(other)", + "apiSymbol": "histogram.subtract", + "depth": 2, + "scope": "api", + "anchor": "histogramsubtractother", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:f2dbe6996530", + "chapter": "perf_hooks", + "kind": "class", + "name": "SlidingWindowHistogram", + "signature": "Class: `SlidingWindowHistogram`", + "label": "SlidingWindowHistogram", + "apiSymbol": "SlidingWindowHistogram", + "depth": 1, + "scope": "api", + "anchor": "class-slidingwindowhistogram", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:7d8e0c897024", + "chapter": "perf_hooks", + "kind": "method", + "name": "record", + "signature": "`slidingWindowHistogram.record(val)`", + "label": "slidingWindowHistogram.record(val)", + "apiSymbol": "slidingWindowHistogram.record", + "depth": 2, + "scope": "api", + "anchor": "slidingwindowhistogramrecordval", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:dc33b594890e", + "chapter": "perf_hooks", + "kind": "method", + "name": "reset", + "signature": "`slidingWindowHistogram.reset()`", + "label": "slidingWindowHistogram.reset()", + "apiSymbol": "slidingWindowHistogram.reset", + "depth": 2, + "scope": "api", + "anchor": "slidingwindowhistogramreset", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:562f505d25da", + "chapter": "perf_hooks", + "kind": "method", + "name": "snapshot", + "signature": "`slidingWindowHistogram.snapshot()`", + "label": "slidingWindowHistogram.snapshot()", + "apiSymbol": "slidingWindowHistogram.snapshot", + "depth": 2, + "scope": "api", + "anchor": "slidingwindowhistogramsnapshot", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, { "id": "perf_hooks:5ac562207ef9", "chapter": "perf_hooks", @@ -72144,6 +77310,52 @@ }, "anchorSource": "exact" }, + { + "id": "perf_hooks:8d8858b23a7d", + "chapter": "perf_hooks", + "kind": "method", + "name": "createSlidingWindowHistogram", + "signature": "`perf_hooks.createSlidingWindowHistogram(options)`", + "label": "perf_hooks.createSlidingWindowHistogram(options)", + "apiSymbol": "perf_hooks.createSlidingWindowHistogram", + "depth": 1, + "scope": "api", + "anchor": "perf_hookscreateslidingwindowhistogramoptions", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, + { + "id": "perf_hooks:3b65cfa382c4", + "chapter": "perf_hooks", + "kind": "method", + "name": "importHistogram", + "signature": "`perf_hooks.importHistogram(data)`", + "label": "perf_hooks.importHistogram(data)", + "apiSymbol": "perf_hooks.importHistogram", + "depth": 1, + "scope": "api", + "anchor": "perf_hooksimporthistogramdata", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:perf_hooks" + }, + "anchorSource": "exact" + }, { "id": "perf_hooks:0136161053c0", "chapter": "perf_hooks", @@ -72778,6 +77990,52 @@ }, "anchorSource": "exact" }, + { + "id": "permissions:11ad69fabdba", + "chapter": "permissions", + "kind": "method", + "name": "drop", + "signature": "`permission.drop(scope[, reference])`", + "label": "permission.drop(scope[, reference])", + "apiSymbol": "permission.drop", + "depth": 4, + "scope": "api", + "anchor": "permissiondropscope-reference", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-chapter-policy:permissions" + }, + "anchorSource": "exact" + }, + { + "id": "permissions:543276a6fe4d", + "chapter": "permissions", + "kind": "module", + "name": "audit_mode", + "signature": "Audit Mode", + "label": "Audit Mode", + "apiSymbol": "audit_mode", + "depth": 3, + "scope": "documentation", + "anchor": "audit-mode", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "permissions:3b86af66c1d1", "chapter": "permissions", @@ -72801,6 +78059,29 @@ }, "anchorSource": "exact" }, + { + "id": "permissions:3760a8d878a5", + "chapter": "permissions", + "kind": "module", + "name": "configuration_file_support", + "signature": "Configuration file support", + "label": "Configuration file support", + "apiSymbol": "configuration_file_support", + "depth": 3, + "scope": "documentation", + "anchor": "configuration-file-support", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "permissions:bd6544e08561", "chapter": "permissions", @@ -72847,6 +78128,29 @@ }, "anchorSource": "exact" }, + { + "id": "permissions:ead9676e9aee", + "chapter": "permissions", + "kind": "module", + "name": "process._debugprocess()_and_cross-process_inspector_activation", + "signature": "process._debugProcess() and cross-process Inspector activation", + "label": "process._debugProcess() and cross-process Inspector activation", + "apiSymbol": "process._debugprocess", + "depth": 3, + "scope": "documentation", + "anchor": "process_debugprocess-and-cross-process-inspector-activation", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "permissions:08ab82ade467", "chapter": "permissions", @@ -74912,6 +80216,29 @@ }, "anchorSource": "exact" }, + { + "id": "process:1755d174d4bc", + "chapter": "process", + "kind": "method", + "name": "drop", + "signature": "`process.permission.drop(scope[, reference])`", + "label": "process.permission.drop(scope[, reference])", + "apiSymbol": "process.permission.drop", + "depth": 2, + "scope": "api", + "anchor": "processpermissiondropscope-reference", + "nodeStability": { + "index": "1.1", + "level": 1, + "text": "Active Development", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:process" + }, + "anchorSource": "exact" + }, { "id": "process:0fbc1d44adb8", "chapter": "process", @@ -77284,6 +82611,29 @@ }, "anchorSource": "exact" }, + { + "id": "repl:7779da957b5b", + "chapter": "repl", + "kind": "module", + "name": "error_handling", + "signature": "Error handling", + "label": "Error handling", + "apiSymbol": "error_handling", + "depth": 2, + "scope": "documentation", + "anchor": "error-handling", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "repl:ba2bb48c654f", "chapter": "repl", @@ -78596,16 +83946,16 @@ "anchorSource": "exact" }, { - "id": "sqlite:bea9dd7076f9", + "id": "sqlite:e96387cf8afc", "chapter": "sqlite", "kind": "method", "name": "loadExtension", - "signature": "`database.loadExtension(path)`", - "label": "database.loadExtension(path)", + "signature": "`database.loadExtension(path[, entryPoint])`", + "label": "database.loadExtension(path[, entryPoint])", "apiSymbol": "database.loadExtension", "depth": 2, "scope": "api", - "anchor": "databaseloadextensionpath", + "anchor": "databaseloadextensionpath-entrypoint", "nodeStability": { "index": "1.2", "level": 1, @@ -78779,6 +84129,52 @@ }, "anchorSource": "exact" }, + { + "id": "sqlite:1369c16ccdef", + "chapter": "sqlite", + "kind": "method", + "name": "serialize", + "signature": "`database.serialize([dbName])`", + "label": "database.serialize([dbName])", + "apiSymbol": "database.serialize", + "depth": 2, + "scope": "api", + "anchor": "databaseserializedbname", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-chapter-policy:sqlite" + }, + "anchorSource": "exact" + }, + { + "id": "sqlite:eca22e258945", + "chapter": "sqlite", + "kind": "method", + "name": "deserialize", + "signature": "`database.deserialize(buffer[, options])`", + "label": "database.deserialize(buffer[, options])", + "apiSymbol": "database.deserialize", + "depth": 2, + "scope": "api", + "anchor": "databasedeserializebuffer-options", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-chapter-policy:sqlite" + }, + "anchorSource": "exact" + }, { "id": "sqlite:29d553079aa0", "chapter": "sqlite", @@ -79101,6 +84497,29 @@ }, "anchorSource": "exact" }, + { + "id": "sqlite:5c03d54ae8a6", + "chapter": "sqlite", + "kind": "module", + "name": "binding_parameters", + "signature": "Binding parameters", + "label": "Binding parameters", + "apiSymbol": "binding_parameters", + "depth": 2, + "scope": "documentation", + "anchor": "binding-parameters", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "sqlite:85b1aa8ba164", "chapter": "sqlite", @@ -79124,6 +84543,29 @@ }, "anchorSource": "exact" }, + { + "id": "sqlite:bbac258c4b2c", + "chapter": "sqlite", + "kind": "method", + "name": "close", + "signature": "`statement.close()`", + "label": "statement.close()", + "apiSymbol": "statement.close", + "depth": 2, + "scope": "api", + "anchor": "statementclose", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-chapter-policy:sqlite" + }, + "anchorSource": "exact" + }, { "id": "sqlite:8a2767b377e2", "chapter": "sqlite", @@ -79308,6 +84750,29 @@ }, "anchorSource": "exact" }, + { + "id": "sqlite:370aee8447bb", + "chapter": "sqlite", + "kind": "method", + "name": "[Symbol.dispose]", + "signature": "`statement[Symbol.dispose]()`", + "label": "statement[Symbol.dispose]()", + "apiSymbol": "statement", + "depth": 2, + "scope": "api", + "anchor": "statementsymboldispose", + "nodeStability": { + "index": "1.2", + "level": 1, + "text": "Release candidate.", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-chapter-policy:sqlite" + }, + "anchorSource": "exact" + }, { "id": "sqlite:9f7687fa081c", "chapter": "sqlite", @@ -80067,10 +85532,33 @@ "scope": "api", "anchor": "streamcomposestreams", "nodeStability": { - "index": "1", - "level": 1, - "text": "`stream.compose` is experimental.", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream" + }, + "anchorSource": "exact" + }, + { + "id": "stream:8f50ba066613", + "chapter": "stream", + "kind": "method", + "name": "isDestroyed", + "signature": "`stream.isDestroyed(stream)`", + "label": "stream.isDestroyed(stream)", + "apiSymbol": "stream.isDestroyed", + "depth": 1, + "scope": "api", + "anchor": "streamisdestroyedstream", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-implemented", @@ -80366,10 +85854,10 @@ "scope": "api", "anchor": "streamaddabortsignalsignal-stream", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "0", + "level": 0, + "text": "Deprecated. Using [`stream.addAbortSignal()`][] to destroy long-lived stream resources is documentation-only deprecated. See DEP0209.", + "inherited": false }, "static": { "status": "partial", @@ -80619,10 +86107,33 @@ "scope": "api", "anchor": "api-for-stream-consumers", "nodeStability": { - "index": "1", - "level": 1, - "text": "`stream.compose` is experimental.", - "inherited": false + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream" + }, + "anchorSource": "ancestor" + }, + { + "id": "stream:bce99dfc80e7", + "chapter": "stream", + "kind": "method", + "name": "isDestroyed", + "signature": "`stream.isDestroyed(stream)`", + "label": "stream.isDestroyed(stream)", + "apiSymbol": "stream.isDestroyed", + "depth": 2, + "scope": "api", + "anchor": "api-for-stream-consumers", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true }, "static": { "status": "not-implemented", @@ -80918,10 +86429,10 @@ "scope": "api", "anchor": "api-for-stream-consumers", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "0", + "level": 0, + "text": "Deprecated. Using [`stream.addAbortSignal()`][] to destroy long-lived stream resources is documentation-only deprecated. See DEP0209.", + "inherited": false }, "static": { "status": "partial", @@ -81767,6 +87278,29 @@ }, "anchorSource": "exact" }, + { + "id": "stream:e149f8b1cd66", + "chapter": "stream", + "kind": "module", + "name": "`readable[symbol.for('stream.toasyncstreamable')]()`", + "signature": "`readable[Symbol.for('Stream.toAsyncStreamable')]()`", + "label": "readable[Symbol.for('Stream.toAsyncStreamable')]()", + "apiSymbol": "readable", + "depth": 4, + "scope": "api", + "anchor": "readablesymbolforstreamtoasyncstreamable", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:stream" + }, + "anchorSource": "exact" + }, { "id": "stream:fffb9a73545d", "chapter": "stream", @@ -84140,6 +89674,121 @@ }, "anchorSource": "exact" }, + { + "id": "test:12d62747d18e", + "chapter": "test", + "kind": "module", + "name": "test_tags", + "signature": "Test tags", + "label": "Test tags", + "apiSymbol": "test_tags", + "depth": 1, + "scope": "documentation", + "anchor": "test-tags", + "nodeStability": { + "index": "1.0", + "level": 1, + "text": "Early development", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "test:3de7d421b0ba", + "chapter": "test", + "kind": "module", + "name": "authoring_tagged_tests", + "signature": "Authoring tagged tests", + "label": "Authoring tagged tests", + "apiSymbol": "authoring_tagged_tests", + "depth": 2, + "scope": "documentation", + "anchor": "authoring-tagged-tests", + "nodeStability": { + "index": "1.0", + "level": 1, + "text": "Early development", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "test:18c74964b9fd", + "chapter": "test", + "kind": "module", + "name": "filtering_by_tag", + "signature": "Filtering by tag", + "label": "Filtering by tag", + "apiSymbol": "filtering_by_tag", + "depth": 2, + "scope": "documentation", + "anchor": "filtering-by-tag", + "nodeStability": { + "index": "1.0", + "level": 1, + "text": "Early development", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "test:d7e6d7a3eb47", + "chapter": "test", + "kind": "module", + "name": "reading_tags_from_inside_a_test", + "signature": "Reading tags from inside a test", + "label": "Reading tags from inside a test", + "apiSymbol": "reading_tags_from_inside_a_test", + "depth": 2, + "scope": "documentation", + "anchor": "reading-tags-from-inside-a-test", + "nodeStability": { + "index": "1.0", + "level": 1, + "text": "Early development", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "test:1df3c0f86116", + "chapter": "test", + "kind": "module", + "name": "errors", + "signature": "Errors", + "label": "Errors", + "apiSymbol": "errors", + "depth": 2, + "scope": "documentation", + "anchor": "errors", + "nodeStability": { + "index": "1.0", + "level": 1, + "text": "Early development", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "test:ac7afa495086", "chapter": "test", @@ -84232,6 +89881,29 @@ }, "anchorSource": "exact" }, + { + "id": "test:c8aae100ae08", + "chapter": "test", + "kind": "module", + "name": "randomizing_tests_execution_order", + "signature": "Randomizing tests execution order", + "label": "Randomizing tests execution order", + "apiSymbol": "randomizing_tests_execution_order", + "depth": 2, + "scope": "documentation", + "anchor": "randomizing-tests-execution-order", + "nodeStability": { + "index": "1.0", + "level": 1, + "text": "Early development", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "test:8c862b89c7e0", "chapter": "test", @@ -84607,6 +90279,144 @@ }, "anchorSource": "exact" }, + { + "id": "test:1e9bd469e966", + "chapter": "test", + "kind": "module", + "name": "test_instrumentation_and_opentelemetry", + "signature": "Test instrumentation and OpenTelemetry", + "label": "Test instrumentation and OpenTelemetry", + "apiSymbol": "test_instrumentation_and_opentelemetry", + "depth": 1, + "scope": "documentation", + "anchor": "test-instrumentation-and-opentelemetry", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "test:864de1c22a4c", + "chapter": "test", + "kind": "module", + "name": "tracing_events", + "signature": "Tracing events", + "label": "Tracing events", + "apiSymbol": "tracing_events", + "depth": 2, + "scope": "documentation", + "anchor": "tracing-events", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "test:f8e1a11bf73b", + "chapter": "test", + "kind": "module", + "name": "channel:_`'tracing:node.test:start'`", + "signature": "Channel: `'tracing:node.test:start'`", + "label": "Channel: 'tracing:node.test:start'", + "apiSymbol": "'tracing:node.test:start'", + "depth": 3, + "scope": "api", + "anchor": "channel-tracingnodeteststart", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:test" + }, + "anchorSource": "exact" + }, + { + "id": "test:20a82a92c5ee", + "chapter": "test", + "kind": "module", + "name": "channel:_`'tracing:node.test:end'`", + "signature": "Channel: `'tracing:node.test:end'`", + "label": "Channel: 'tracing:node.test:end'", + "apiSymbol": "'tracing:node.test:end'", + "depth": 3, + "scope": "api", + "anchor": "channel-tracingnodetestend", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:test" + }, + "anchorSource": "exact" + }, + { + "id": "test:1c3a160d93a5", + "chapter": "test", + "kind": "module", + "name": "channel:_`'tracing:node.test:error'`", + "signature": "Channel: `'tracing:node.test:error'`", + "label": "Channel: 'tracing:node.test:error'", + "apiSymbol": "'tracing:node.test:error'", + "depth": 3, + "scope": "api", + "anchor": "channel-tracingnodetesterror", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:test" + }, + "anchorSource": "exact" + }, + { + "id": "test:67c55a98f438", + "chapter": "test", + "kind": "module", + "name": "context_propagation_with_`bindstore()`", + "signature": "Context propagation with `bindStore()`", + "label": "Context propagation with bindStore()", + "apiSymbol": "bindStore", + "depth": 2, + "scope": "api", + "anchor": "context-propagation-with-bindstore", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:test" + }, + "anchorSource": "exact" + }, { "id": "test:94ee1fc64cba", "chapter": "test", @@ -85458,6 +91268,29 @@ }, "anchorSource": "exact" }, + { + "id": "test:0d11baf2f28f", + "chapter": "test", + "kind": "module", + "name": "event_lifecycle", + "signature": "Event lifecycle", + "label": "Event lifecycle", + "apiSymbol": "event_lifecycle", + "depth": 2, + "scope": "documentation", + "anchor": "event-lifecycle", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "test:5bc36a9d37e8", "chapter": "test", @@ -85619,6 +91452,29 @@ }, "anchorSource": "exact" }, + { + "id": "test:3b0586b4ebf5", + "chapter": "test", + "kind": "event", + "name": "test:log", + "signature": "Event: `'test:log'`", + "label": "'test:log'", + "apiSymbol": "'test:log'", + "depth": 2, + "scope": "api", + "anchor": "event-testlog", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:test" + }, + "anchorSource": "exact" + }, { "id": "test:89f1682d338d", "chapter": "test", @@ -85937,13 +91793,36 @@ }, "static": { "status": "partial", - "evidence": "compiler-dedicated:context.diagnostic", + "evidence": "compiler-feature:test.context.diagnostic", "tests": [ "tests/harness/node-test.test.ts" ] }, "anchorSource": "exact" }, + { + "id": "test:0c374aa5a4a0", + "chapter": "test", + "kind": "method", + "name": "log", + "signature": "`context.log(message[, data])`", + "label": "context.log(message[, data])", + "apiSymbol": "context.log", + "depth": 2, + "scope": "api", + "anchor": "contextlogmessage-data", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:test" + }, + "anchorSource": "exact" + }, { "id": "test:d5d9833c77e2", "chapter": "test", @@ -86228,7 +92107,7 @@ }, "static": { "status": "partial", - "evidence": "compiler-dedicated:context.name", + "evidence": "compiler-feature:test.context.name", "tests": [ "tests/harness/node-test.test.ts" ] @@ -86304,6 +92183,29 @@ }, "anchorSource": "ancestor" }, + { + "id": "test:1d5db8900faf", + "chapter": "test", + "kind": "string\\[]", + "name": "Type", + "signature": "`tags` Type: {string\\[]}", + "label": "tags", + "apiSymbol": "tags", + "depth": 2, + "scope": "api", + "anchor": "class-testcontext", + "nodeStability": { + "index": "1.0", + "level": 1, + "text": "Early development", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:test" + }, + "anchorSource": "ancestor" + }, { "id": "test:0ee703f51144", "chapter": "test", @@ -86373,6 +92275,52 @@ }, "anchorSource": "exact" }, + { + "id": "test:fc7f1b42c35e", + "chapter": "test", + "kind": "method", + "name": "diagnostic", + "signature": "`context.diagnostic(message)`", + "label": "context.diagnostic(message)", + "apiSymbol": "context.diagnostic", + "depth": 2, + "scope": "api", + "anchor": "contextdiagnosticmessage_1", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:test" + }, + "anchorSource": "exact" + }, + { + "id": "test:eed9c6589bd2", + "chapter": "test", + "kind": "method", + "name": "log", + "signature": "`context.log(message[, data])`", + "label": "context.log(message[, data])", + "apiSymbol": "context.log", + "depth": 2, + "scope": "api", + "anchor": "contextlogmessage-data_1", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:test" + }, + "anchorSource": "exact" + }, { "id": "test:4b1cfc88fc4d", "chapter": "test", @@ -86437,11 +92385,8 @@ "inherited": true }, "static": { - "status": "partial", - "evidence": "compiler-dedicated:context.name", - "tests": [ - "tests/harness/node-test.test.ts" - ] + "status": "not-implemented", + "evidence": "compiler-unmatched:test" }, "anchorSource": "exact" }, @@ -86468,6 +92413,52 @@ }, "anchorSource": "ancestor" }, + { + "id": "test:9af04b8cf499", + "chapter": "test", + "kind": "boolean", + "name": "Type", + "signature": "`passed` Type: {boolean}", + "label": "passed", + "apiSymbol": "passed", + "depth": 2, + "scope": "api", + "anchor": "class-suitecontext", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:test" + }, + "anchorSource": "ancestor" + }, + { + "id": "test:ab6d3613f62b", + "chapter": "test", + "kind": "number", + "name": "Type", + "signature": "`attempt` Type: {number}", + "label": "attempt", + "apiSymbol": "attempt", + "depth": 2, + "scope": "api", + "anchor": "class-suitecontext", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:test" + }, + "anchorSource": "ancestor" + }, { "id": "test:674c7aed221a", "chapter": "test", @@ -86984,6 +92975,29 @@ }, "anchorSource": "exact" }, + { + "id": "test:079e32fafea1", + "chapter": "test", + "kind": "method", + "name": "getTestContext", + "signature": "`getTestContext()`", + "label": "getTestContext()", + "apiSymbol": "getTestContext", + "depth": 1, + "scope": "api", + "anchor": "gettestcontext", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:test" + }, + "anchorSource": "exact" + }, { "id": "timers:958d8284adff", "chapter": "timers", @@ -88959,6 +94973,29 @@ }, "anchorSource": "exact" }, + { + "id": "tls:0961fd354257", + "chapter": "tls", + "kind": "string|boolean|null", + "name": "Type", + "signature": "`alpnProtocol` Type: {string|boolean|null}", + "label": "alpnProtocol", + "apiSymbol": "alpnProtocol", + "depth": 2, + "scope": "api", + "anchor": "class-tlstlssocket", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:tls" + }, + "anchorSource": "ancestor" + }, { "id": "tls:f2e0cdec5975", "chapter": "tls", @@ -89143,6 +95180,29 @@ }, "anchorSource": "ancestor" }, + { + "id": "tls:66d9155a5c20", + "chapter": "tls", + "kind": "string|boolean|null", + "name": "Type", + "signature": "`servername` Type: {string|boolean|null}", + "label": "servername", + "apiSymbol": "servername", + "depth": 2, + "scope": "api", + "anchor": "class-tlstlssocket", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:tls" + }, + "anchorSource": "ancestor" + }, { "id": "tls:c5970763c4f8", "chapter": "tls", @@ -89473,6 +95533,29 @@ }, "anchorSource": "exact" }, + { + "id": "tls:5a3cdc74e2b5", + "chapter": "tls", + "kind": "method", + "name": "getCertificateCompressionAlgorithms", + "signature": "`tls.getCertificateCompressionAlgorithms()`", + "label": "tls.getCertificateCompressionAlgorithms()", + "apiSymbol": "tls.getCertificateCompressionAlgorithms", + "depth": 1, + "scope": "api", + "anchor": "tlsgetcertificatecompressionalgorithms", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:tls" + }, + "anchorSource": "exact" + }, { "id": "tls:df163bf0e931", "chapter": "tls", @@ -89951,6 +96034,29 @@ }, "anchorSource": "exact" }, + { + "id": "tty:85fc0b85d933", + "chapter": "tty", + "kind": "boolean|string", + "name": "rawMode", + "signature": "`rawMode` {boolean|string}", + "label": "rawMode", + "apiSymbol": "rawMode", + "depth": 2, + "scope": "api", + "anchor": "class-ttyreadstream", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:tty" + }, + "anchorSource": "ancestor" + }, { "id": "tty:cdef680b84c7", "chapter": "tty", @@ -90533,6 +96639,29 @@ }, "anchorSource": "exact" }, + { + "id": "dgram:283dec88737f", + "chapter": "dgram", + "kind": "method", + "name": "bindSync", + "signature": "`socket.bindSync([options])`", + "label": "socket.bindSync([options])", + "apiSymbol": "socket.bindSync", + "depth": 2, + "scope": "api", + "anchor": "socketbindsyncoptions", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:dgram" + }, + "anchorSource": "exact" + }, { "id": "dgram:40eeb2e82c2b", "chapter": "dgram", @@ -90608,6 +96737,29 @@ }, "anchorSource": "exact" }, + { + "id": "dgram:e4bb4d698b04", + "chapter": "dgram", + "kind": "method", + "name": "connectSync", + "signature": "`socket.connectSync(port[, address])`", + "label": "socket.connectSync(port[, address])", + "apiSymbol": "socket.connectSync", + "depth": 2, + "scope": "api", + "anchor": "socketconnectsyncport-address", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:dgram" + }, + "anchorSource": "exact" + }, { "id": "dgram:c2008af7f485", "chapter": "dgram", @@ -93285,6 +99437,29 @@ }, "anchorSource": "exact" }, + { + "id": "util:78d79ebcd11e", + "chapter": "util", + "kind": "method", + "name": "parse", + "signature": "`MIMEType.parse(string)`", + "label": "MIMEType.parse(string)", + "apiSymbol": "MIMEType.parse", + "depth": 2, + "scope": "api", + "anchor": "mimetypeparsestring", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:util" + }, + "anchorSource": "exact" + }, { "id": "util:f1c74a06ab01", "chapter": "util", @@ -94092,6 +100267,52 @@ }, "anchorSource": "exact" }, + { + "id": "util:90257f3f102f", + "chapter": "util", + "kind": "method", + "name": "debounce", + "signature": "`util.debounce(fn, wait[, options])`", + "label": "util.debounce(fn, wait[, options])", + "apiSymbol": "util.debounce", + "depth": 1, + "scope": "api", + "anchor": "utildebouncefn-wait-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:util" + }, + "anchorSource": "exact" + }, + { + "id": "util:0cc4a80eb7db", + "chapter": "util", + "kind": "method", + "name": "throttle", + "signature": "`util.throttle(fn, limit, interval[, options])`", + "label": "util.throttle(fn, limit, interval[, options])", + "apiSymbol": "util.throttle", + "depth": 1, + "scope": "api", + "anchor": "utilthrottlefn-limit-interval-options", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:util" + }, + "anchorSource": "exact" + }, { "id": "util:dd79eb4f9e99", "chapter": "util", @@ -94559,6 +100780,29 @@ }, "anchorSource": "exact" }, + { + "id": "util:e9e90e65a33a", + "chapter": "util", + "kind": "method", + "name": "markPromiseAsHandled", + "signature": "`util.markPromiseAsHandled(promise)`", + "label": "util.markPromiseAsHandled(promise)", + "apiSymbol": "util.markPromiseAsHandled", + "depth": 1, + "scope": "api", + "anchor": "utilmarkpromiseashandledpromise", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:util" + }, + "anchorSource": "exact" + }, { "id": "util:96bd98b2e0c0", "chapter": "util", @@ -98902,16 +105146,16 @@ "anchorSource": "exact" }, { - "id": "webcrypto:b34b2a6fe4f9", + "id": "webcrypto:19f209cafe39", "chapter": "webcrypto", "kind": "module", - "name": "algorithm_matrix", - "signature": "Algorithm matrix", - "label": "Algorithm matrix", - "apiSymbol": "algorithm_matrix", + "name": "algorithm_support", + "signature": "Algorithm support", + "label": "Algorithm support", + "apiSymbol": "algorithm_support", "depth": 1, "scope": "documentation", - "anchor": "algorithm-matrix", + "anchor": "algorithm-support", "nodeStability": { "index": "2", "level": 2, @@ -98925,7 +105169,7 @@ "anchorSource": "exact" }, { - "id": "webcrypto:2917f860df84", + "id": "webcrypto:0e7eea40c076", "chapter": "webcrypto", "kind": "module", "name": "key_management_apis", @@ -98948,7 +105192,7 @@ "anchorSource": "exact" }, { - "id": "webcrypto:bbae106c5fe6", + "id": "webcrypto:e534d5813eba", "chapter": "webcrypto", "kind": "module", "name": "crypto_operation_apis", @@ -98970,6 +105214,29 @@ }, "anchorSource": "exact" }, + { + "id": "webcrypto:c5dff73ecd37", + "chapter": "webcrypto", + "kind": "module", + "name": "key_formats", + "signature": "Key Formats", + "label": "Key Formats", + "apiSymbol": "key_formats", + "depth": 2, + "scope": "documentation", + "anchor": "key-formats", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, { "id": "webcrypto:14503f1ca3b6", "chapter": "webcrypto", @@ -99753,11 +106020,11 @@ "anchorSource": "exact" }, { - "id": "webcrypto:348599f69c92", + "id": "webcrypto:f03c4c689ade", "chapter": "webcrypto", "kind": "string", "name": "Type", - "signature": "`name` Type: {string} Must be `Ed448`[^secure-curves], `'ML-DSA-44'`[^modern-algos], `'ML-DSA-65'`[^modern-algos], or `'ML-DSA-87'`[^modern-algos].", + "signature": "`name` Type: {string} Must be `'Ed448'`[^secure-curves], `'ML-DSA-44'`[^modern-algos], `'ML-DSA-65'`[^modern-algos], or `'ML-DSA-87'`[^modern-algos].", "label": "name", "apiSymbol": "name", "depth": 3, @@ -99822,11 +106089,11 @@ "anchorSource": "exact" }, { - "id": "webcrypto:e97ed4559769", + "id": "webcrypto:fbbc457c6c6e", "chapter": "webcrypto", "kind": "string", "name": "Type", - "signature": "`name` Type: {string} Must be `'cSHAKE128'`[^modern-algos] or `'cSHAKE256'`[^modern-algos]", + "signature": "`name` Type: {string} Must be `'cSHAKE128'`[^modern-algos] or `'cSHAKE256'`[^modern-algos].", "label": "name", "apiSymbol": "name", "depth": 3, @@ -100888,6 +107155,98 @@ }, "anchorSource": "ancestor" }, + { + "id": "webcrypto:2bc7e9909260", + "chapter": "webcrypto", + "kind": "class", + "name": "KangarooTwelveParams", + "signature": "Class: `KangarooTwelveParams`", + "label": "KangarooTwelveParams", + "apiSymbol": "KangarooTwelveParams", + "depth": 2, + "scope": "api", + "anchor": "class-kangarootwelveparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:webcrypto" + }, + "anchorSource": "exact" + }, + { + "id": "webcrypto:2f2a2546b394", + "chapter": "webcrypto", + "kind": "ArrayBuffer|TypedArray|DataView|Buffer|undefined", + "name": "Type", + "signature": "`customization` Type: {ArrayBuffer|TypedArray|DataView|Buffer|undefined}", + "label": "customization", + "apiSymbol": "customization", + "depth": 3, + "scope": "api", + "anchor": "class-kangarootwelveparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:webcrypto" + }, + "anchorSource": "ancestor" + }, + { + "id": "webcrypto:f70b118f8060", + "chapter": "webcrypto", + "kind": "string", + "name": "Type", + "signature": "`name` Type: {string} Must be `'KT128'`[^modern-algos] or `'KT256'`[^modern-algos]", + "label": "name", + "apiSymbol": "name", + "depth": 3, + "scope": "api", + "anchor": "class-kangarootwelveparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:webcrypto" + }, + "anchorSource": "ancestor" + }, + { + "id": "webcrypto:0c10b01b7537", + "chapter": "webcrypto", + "kind": "number", + "name": "Type", + "signature": "`outputLength` Type: {number} represents the requested output length in bits.", + "label": "outputLength", + "apiSymbol": "outputLength", + "depth": 3, + "scope": "api", + "anchor": "class-kangarootwelveparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:webcrypto" + }, + "anchorSource": "ancestor" + }, { "id": "webcrypto:fd89bc275372", "chapter": "webcrypto", @@ -101142,11 +107501,11 @@ "anchorSource": "ancestor" }, { - "id": "webcrypto:82fe1baefa90", + "id": "webcrypto:02a1dd7526a6", "chapter": "webcrypto", "kind": "number", "name": "Type", - "signature": "`outputLength` Type: {number}", + "signature": "`outputLength` Type: {number} represents the requested output length in bits.", "label": "outputLength", "apiSymbol": "outputLength", "depth": 3, @@ -101783,6 +108142,98 @@ }, "anchorSource": "ancestor" }, + { + "id": "webcrypto:077e576b19c6", + "chapter": "webcrypto", + "kind": "class", + "name": "TurboShakeParams", + "signature": "Class: `TurboShakeParams`", + "label": "TurboShakeParams", + "apiSymbol": "TurboShakeParams", + "depth": 2, + "scope": "api", + "anchor": "class-turboshakeparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:webcrypto" + }, + "anchorSource": "exact" + }, + { + "id": "webcrypto:080709a8f851", + "chapter": "webcrypto", + "kind": "number|undefined", + "name": "Type", + "signature": "`domainSeparation` Type: {number|undefined}", + "label": "domainSeparation", + "apiSymbol": "domainSeparation", + "depth": 3, + "scope": "api", + "anchor": "class-turboshakeparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:webcrypto" + }, + "anchorSource": "ancestor" + }, + { + "id": "webcrypto:ba3db2b61ce3", + "chapter": "webcrypto", + "kind": "string", + "name": "Type", + "signature": "`name` Type: {string} Must be `'TurboSHAKE128'`[^modern-algos] or `'TurboSHAKE256'`[^modern-algos]", + "label": "name", + "apiSymbol": "name", + "depth": 3, + "scope": "api", + "anchor": "class-turboshakeparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:webcrypto" + }, + "anchorSource": "ancestor" + }, + { + "id": "webcrypto:0797ed062eb1", + "chapter": "webcrypto", + "kind": "number", + "name": "Type", + "signature": "`outputLength` Type: {number} represents the requested output length in bits.", + "label": "outputLength", + "apiSymbol": "outputLength", + "depth": 3, + "scope": "api", + "anchor": "class-turboshakeparams", + "nodeStability": { + "index": "2", + "level": 2, + "text": "Stable", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:webcrypto" + }, + "anchorSource": "ancestor" + }, { "id": "webcrypto:92a3a1223e3b", "chapter": "webcrypto", @@ -102117,16 +108568,16 @@ "anchorSource": "exact" }, { - "id": "webcrypto:d8f38474b5e5", + "id": "webcrypto:282fa1aa9829", "chapter": "webcrypto", "kind": "method", "name": "decapsulateKey", - "signature": "`subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, usages)`", - "label": "subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, usages)", + "signature": "`subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, keyUsages)`", + "label": "subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, keyUsages)", "apiSymbol": "subtle.decapsulateKey", "depth": 2, "scope": "api", - "anchor": "subtledecapsulatekeydecapsulationalgorithm-decapsulationkey-ciphertext-sharedkeyalgorithm-extractable-usages", + "anchor": "subtledecapsulatekeydecapsulationalgorithm-decapsulationkey-ciphertext-sharedkeyalgorithm-extractable-keyusages", "nodeStability": { "index": "1.1", "level": 1, @@ -102186,16 +108637,16 @@ "anchorSource": "exact" }, { - "id": "webcrypto:8618a4716426", + "id": "webcrypto:3790d3167cb1", "chapter": "webcrypto", "kind": "method", "name": "deriveKey", - "signature": "`subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)`", - "label": "subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)", + "signature": "`subtle.deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages)`", + "label": "subtle.deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages)", "apiSymbol": "subtle.deriveKey", "depth": 2, "scope": "api", - "anchor": "subtlederivekeyalgorithm-basekey-derivedkeyalgorithm-extractable-keyusages", + "anchor": "subtlederivekeyalgorithm-basekey-derivedkeytype-extractable-keyusages", "nodeStability": { "index": "2", "level": 2, @@ -102255,16 +108706,16 @@ "anchorSource": "exact" }, { - "id": "webcrypto:5e146a8a6347", + "id": "webcrypto:097ba43bcee4", "chapter": "webcrypto", "kind": "method", "name": "encapsulateKey", - "signature": "`subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, usages)`", - "label": "subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, usages)", + "signature": "`subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, keyUsages)`", + "label": "subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, keyUsages)", "apiSymbol": "subtle.encapsulateKey", "depth": 2, "scope": "api", - "anchor": "subtleencapsulatekeyencapsulationalgorithm-encapsulationkey-sharedkeyalgorithm-extractable-usages", + "anchor": "subtleencapsulatekeyencapsulationalgorithm-encapsulationkey-sharedkeyalgorithm-extractable-keyusages", "nodeStability": { "index": "1.1", "level": 1, @@ -102416,16 +108867,16 @@ "anchorSource": "exact" }, { - "id": "webcrypto:67f9b9466d2c", + "id": "webcrypto:4109de4ba359", "chapter": "webcrypto", "kind": "method", "name": "unwrapKey", - "signature": "`subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgo, unwrappedKeyAlgo, extractable, keyUsages)`", - "label": "subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgo, unwrappedKeyAlgo, extractable, keyUsages)", + "signature": "`subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages)`", + "label": "subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages)", "apiSymbol": "subtle.unwrapKey", "depth": 2, "scope": "api", - "anchor": "subtleunwrapkeyformat-wrappedkey-unwrappingkey-unwrapalgo-unwrappedkeyalgo-extractable-keyusages", + "anchor": "subtleunwrapkeyformat-wrappedkey-unwrappingkey-unwrapalgorithm-unwrappedkeyalgorithm-extractable-keyusages", "nodeStability": { "index": "2", "level": 2, @@ -102462,16 +108913,16 @@ "anchorSource": "exact" }, { - "id": "webcrypto:62ec6d9ec96a", + "id": "webcrypto:25faa11630ae", "chapter": "webcrypto", "kind": "method", "name": "wrapKey", - "signature": "`subtle.wrapKey(format, key, wrappingKey, wrapAlgo)`", - "label": "subtle.wrapKey(format, key, wrappingKey, wrapAlgo)", + "signature": "`subtle.wrapKey(format, key, wrappingKey, wrapAlgorithm)`", + "label": "subtle.wrapKey(format, key, wrappingKey, wrapAlgorithm)", "apiSymbol": "subtle.wrapKey", "depth": 2, "scope": "api", - "anchor": "subtlewrapkeyformat-key-wrappingkey-wrapalgo", + "anchor": "subtlewrapkeyformat-key-wrappingkey-wrapalgorithm", "nodeStability": { "index": "2", "level": 2, @@ -104671,6 +111122,29 @@ }, "anchorSource": "ancestor" }, + { + "id": "webstreams:5a92c91c4929", + "chapter": "webstreams", + "kind": "method", + "name": "ReadableStreamTee", + "signature": "`ReadableStreamTee(stream[, cloneForBranch2])`", + "label": "ReadableStreamTee(stream[, cloneForBranch2])", + "apiSymbol": "ReadableStreamTee", + "depth": 2, + "scope": "api", + "anchor": "readablestreamteestream-cloneforbranch2", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:webstreams" + }, + "anchorSource": "exact" + }, { "id": "webstreams:4c7d9f984091", "chapter": "webstreams", @@ -106548,6 +113022,397 @@ }, "anchorSource": "exact" }, + { + "id": "zlib:119c9a57b1fb", + "chapter": "zlib", + "kind": "module", + "name": "iterable_compression", + "signature": "Iterable Compression", + "label": "Iterable Compression", + "apiSymbol": "iterable_compression", + "depth": 1, + "scope": "documentation", + "anchor": "iterable-compression", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false + }, + "static": { + "status": "not-applicable", + "evidence": "documentation" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:b33e2218a29a", + "chapter": "zlib", + "kind": "method", + "name": "compressBrotli", + "signature": "`compressBrotli([options])`", + "label": "compressBrotli([options])", + "apiSymbol": "compressBrotli", + "depth": 2, + "scope": "api", + "anchor": "compressbrotlioptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:f52bcb0441b4", + "chapter": "zlib", + "kind": "method", + "name": "compressBrotliSync", + "signature": "`compressBrotliSync([options])`", + "label": "compressBrotliSync([options])", + "apiSymbol": "compressBrotliSync", + "depth": 2, + "scope": "api", + "anchor": "compressbrotlisyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:5d9b6e75680e", + "chapter": "zlib", + "kind": "method", + "name": "compressDeflate", + "signature": "`compressDeflate([options])`", + "label": "compressDeflate([options])", + "apiSymbol": "compressDeflate", + "depth": 2, + "scope": "api", + "anchor": "compressdeflateoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:2f423bd21cab", + "chapter": "zlib", + "kind": "method", + "name": "compressDeflateSync", + "signature": "`compressDeflateSync([options])`", + "label": "compressDeflateSync([options])", + "apiSymbol": "compressDeflateSync", + "depth": 2, + "scope": "api", + "anchor": "compressdeflatesyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:14600f289b64", + "chapter": "zlib", + "kind": "method", + "name": "compressGzip", + "signature": "`compressGzip([options])`", + "label": "compressGzip([options])", + "apiSymbol": "compressGzip", + "depth": 2, + "scope": "api", + "anchor": "compressgzipoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:7354fd8fdadf", + "chapter": "zlib", + "kind": "method", + "name": "compressGzipSync", + "signature": "`compressGzipSync([options])`", + "label": "compressGzipSync([options])", + "apiSymbol": "compressGzipSync", + "depth": 2, + "scope": "api", + "anchor": "compressgzipsyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:c1b6e7dd5506", + "chapter": "zlib", + "kind": "method", + "name": "compressZstd", + "signature": "`compressZstd([options])`", + "label": "compressZstd([options])", + "apiSymbol": "compressZstd", + "depth": 2, + "scope": "api", + "anchor": "compresszstdoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:3ed321c39c37", + "chapter": "zlib", + "kind": "method", + "name": "compressZstdSync", + "signature": "`compressZstdSync([options])`", + "label": "compressZstdSync([options])", + "apiSymbol": "compressZstdSync", + "depth": 2, + "scope": "api", + "anchor": "compresszstdsyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:2c89860f52a5", + "chapter": "zlib", + "kind": "method", + "name": "decompressBrotli", + "signature": "`decompressBrotli([options])`", + "label": "decompressBrotli([options])", + "apiSymbol": "decompressBrotli", + "depth": 2, + "scope": "api", + "anchor": "decompressbrotlioptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:cb37070b5ee0", + "chapter": "zlib", + "kind": "method", + "name": "decompressBrotliSync", + "signature": "`decompressBrotliSync([options])`", + "label": "decompressBrotliSync([options])", + "apiSymbol": "decompressBrotliSync", + "depth": 2, + "scope": "api", + "anchor": "decompressbrotlisyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:d829a0b75f6c", + "chapter": "zlib", + "kind": "method", + "name": "decompressDeflate", + "signature": "`decompressDeflate([options])`", + "label": "decompressDeflate([options])", + "apiSymbol": "decompressDeflate", + "depth": 2, + "scope": "api", + "anchor": "decompressdeflateoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:f1a96211af38", + "chapter": "zlib", + "kind": "method", + "name": "decompressDeflateSync", + "signature": "`decompressDeflateSync([options])`", + "label": "decompressDeflateSync([options])", + "apiSymbol": "decompressDeflateSync", + "depth": 2, + "scope": "api", + "anchor": "decompressdeflatesyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:b1209d1fe9bf", + "chapter": "zlib", + "kind": "method", + "name": "decompressGzip", + "signature": "`decompressGzip([options])`", + "label": "decompressGzip([options])", + "apiSymbol": "decompressGzip", + "depth": 2, + "scope": "api", + "anchor": "decompressgzipoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:955fb7cb393c", + "chapter": "zlib", + "kind": "method", + "name": "decompressGzipSync", + "signature": "`decompressGzipSync([options])`", + "label": "decompressGzipSync([options])", + "apiSymbol": "decompressGzipSync", + "depth": 2, + "scope": "api", + "anchor": "decompressgzipsyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:d9ea319f8e5e", + "chapter": "zlib", + "kind": "method", + "name": "decompressZstd", + "signature": "`decompressZstd([options])`", + "label": "decompressZstd([options])", + "apiSymbol": "decompressZstd", + "depth": 2, + "scope": "api", + "anchor": "decompresszstdoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, + { + "id": "zlib:e0d0e947882d", + "chapter": "zlib", + "kind": "method", + "name": "decompressZstdSync", + "signature": "`decompressZstdSync([options])`", + "label": "decompressZstdSync([options])", + "apiSymbol": "decompressZstdSync", + "depth": 2, + "scope": "api", + "anchor": "decompresszstdsyncoptions", + "nodeStability": { + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": true + }, + "static": { + "status": "not-implemented", + "evidence": "compiler-unmatched:zlib" + }, + "anchorSource": "exact" + }, { "id": "zlib:4b20a6571ae3", "chapter": "zlib", @@ -107762,10 +114627,10 @@ "scope": "api", "anchor": "zlibzstddecompressbuffer-options-callback", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false }, "static": { "status": "not-implemented", @@ -108821,10 +115686,10 @@ "scope": "api", "anchor": "convenience-methods", "nodeStability": { - "index": "2", - "level": 2, - "text": "Stable", - "inherited": true + "index": "1", + "level": 1, + "text": "Experimental", + "inherited": false }, "static": { "status": "not-implemented", @@ -108857,8 +115722,8 @@ } ], "anchors": { - "verified": 3929, - "ancestorFallback": 608, + "verified": 4188, + "ancestorFallback": 654, "chapterFallback": 91 } } diff --git a/internal/compatibility/node-v24.json b/internal/compatibility/node-v24.json index 310aa62ae4..bac4b00bde 100644 --- a/internal/compatibility/node-v24.json +++ b/internal/compatibility/node-v24.json @@ -1,12 +1,12 @@ { "schemaVersion": 1, - "version": "24.15.0", - "tag": "v24.15.0", - "commit": "848430679556aed0bd073f2bc263331ad84fa119", - "allJsonUrl": "https://nodejs.org/download/release/v24.15.0/docs/api/all.json", - "indexMarkdownUrl": "https://nodejs.org/docs/v24.15.0/api/index.md", - "markdownBaseUrl": "https://nodejs.org/docs/v24.15.0/api/", - "sourceBaseUrl": "https://github.com/nodejs/node/tree/848430679556aed0bd073f2bc263331ad84fa119", + "version": "24.22.0", + "tag": "v24.22.0", + "commit": "f14cd3aa7bf9ca8df2cc5b8bb14beb0f335b1d93", + "allJsonUrl": "https://nodejs.org/download/release/v24.22.0/docs/api/all.json", + "indexMarkdownUrl": "https://nodejs.org/docs/v24.22.0/api/index.md", + "markdownBaseUrl": "https://nodejs.org/docs/v24.22.0/api/", + "sourceBaseUrl": "https://github.com/nodejs/node/tree/f14cd3aa7bf9ca8df2cc5b8bb14beb0f335b1d93", "chapterModules": { "assert": ["assert", "assert/strict"], "async_context": ["async_hooks"], @@ -37,6 +37,7 @@ "repl": ["repl"], "sqlite": ["sqlite"], "stream": ["stream", "stream/promises", "stream/consumers", "stream/web"], + "stream_iter": ["stream/iter"], "string_decoder": ["string_decoder"], "test": ["test", "test/reporters"], "timers": ["timers", "timers/promises"], diff --git a/internal/compatibility/src/generate.mjs b/internal/compatibility/src/generate.mjs index b4771169b5..28e552e214 100644 --- a/internal/compatibility/src/generate.mjs +++ b/internal/compatibility/src/generate.mjs @@ -1008,8 +1008,8 @@ function checkLocal() { ); } const ctx = classificationContext(); - if (snapshot.chapters.length !== 62) - throw new Error(`expected 62 pinned Node API chapters, found ${snapshot.chapters.length}`); + if (snapshot.chapters.length !== 63) + throw new Error(`expected 63 pinned Node API chapters, found ${snapshot.chapters.length}`); const ancestors = []; for (const row of snapshot.rows) { if (row.depth === 0) { diff --git a/internal/compatibility/static-support.json b/internal/compatibility/static-support.json index 6776b362a7..e47df93a34 100644 --- a/internal/compatibility/static-support.json +++ b/internal/compatibility/static-support.json @@ -238,7 +238,7 @@ { "chapter": "http", "parent": "Class: `http.Agent`", "signatures": ["`agent.destroy()`", "`agent.getName([options])`", "`freeSockets` Type: {Object}", "`maxFreeSockets` Type: {number}", "`maxSockets` Type: {number}", "`requests` Type: {Object}", "`sockets` Type: {Object}"], "status": "partial", "evidence": ["tests/corpus/2973-http-static-agent.ts"] }, { "chapter": "http", "signatures": ["`METHODS` Type: {string\\[]}", "`STATUS_CODES` Type: {Object}", "`maxHeaderSize` Type: {number}"], "status": "partial", "evidence": ["tests/corpus/2974-http-static-module-values.ts"] }, { "chapter": "http", "signatures": ["`request.setNoDelay([noDelay])`"], "status": "partial", "evidence": ["tests/corpus/2975-http-static-client-controls.ts"] }, - { "chapter": "http", "parent": "Class: `http.ClientRequest`", "signatures": ["`finished` Type: {boolean}", "`reusedSocket` Type: {boolean} Whether the request is send through a reused socket."], "status": "partial", "evidence": ["tests/corpus/2975-http-static-client-controls.ts"] }, + { "chapter": "http", "parent": "Class: `http.ClientRequest`", "signatures": ["`finished` Type: {boolean}", "`reusedSocket` Type: {boolean} Whether the request is sent through a reused socket."], "status": "partial", "evidence": ["tests/corpus/2975-http-static-client-controls.ts"] }, { "chapter": "http", "parent": "Class: `http.IncomingMessage`", "signatures": ["`message.setTimeout(msecs[, callback])`"], "status": "partial", "evidence": ["tests/corpus/2976-http-static-incoming-state.ts", "tests/corpus/2977-http-static-incoming-timeout.ts", "tests/corpus/2987-http-static-timeout-errors.ts"] }, { "chapter": "http", "parent": "Class: `http.IncomingMessage`", "signatures": ["`aborted` Type: {boolean}", "`message.connection`", "`headers` Type: {Object}", "`socket` Type: {stream.Duplex}", "`statusMessage` Type: {string}", "Event: `'close'`"], "status": "partial", "evidence": ["tests/corpus/2976-http-static-incoming-state.ts"] }, { "chapter": "http", "parent": "Class: `http.ServerResponse`", "signatures": ["`finished` Type: {boolean}", "Event: `'close'`", "Event: `'finish'`"], "status": "partial", "evidence": ["tests/corpus/2976-http-static-incoming-state.ts"] }, @@ -298,6 +298,7 @@ { "chapter": "url", "parent": "Class: `URL`", "signatures": ["`href` Type: {string}", "`pathname` Type: {string}", "`search` Type: {string}", "`hash` Type: {string}"], "status": "partial", "evidence": ["tests/corpus/node24-url-mutation.ts", "tests/corpus/node24-url-mutation-coercion.js", "tests/fixtures/node-types/url-mutation.ts"] }, { "chapter": "url", "signatures": ["`port` Type: {string}"], "status": "partial", "evidence": ["tests/corpus/2946-url-port-hash.ts"] }, { "chapter": "url", "signatures": ["Legacy `urlObject`", "`urlObject.auth`", "`urlObject.hash`", "`urlObject.host`", "`urlObject.hostname`", "`urlObject.href`", "`urlObject.path`", "`urlObject.pathname`", "`urlObject.port`", "`urlObject.protocol`", "`urlObject.query`", "`urlObject.search`", "`urlObject.slashes`"], "status": "partial", "evidence": ["tests/corpus/5221-url-parse-shapes.ts", "tests/corpus/5222-url-parse-hosts.ts", "tests/corpus/5223-url-parse-query.ts", "tests/corpus/5224-url-format-objects.ts", "tests/fixtures/node-types/url-legacy.ts"] }, + { "chapter": "test", "parent": "Class: `TestContext`", "symbols": ["context.diagnostic", "context.name"], "status": "partial", "evidence": ["tests/harness/node-test.test.ts"] }, { "chapter": "util", "signatures": ["`util.promisify(original)`"], "status": "partial", "evidence": ["tests/corpus/1473-promisify-execfile.ts", "tests/corpus/1573-promisify-execfile-env-spread.ts", "tests/corpus/2912-promisify-fs-readfile.ts"] }, { "chapter": "typescript", "symbols": ["type"], "status": "supported", "evidence": ["tests/corpus/2702-type-import-link-static/main.ts", "tests/corpus/2703-type-import-link-static-reexport/main.ts", "tests/corpus/2704-type-import-link-static-success/main.ts", "tests/corpus/2707-type-import-link-static-default-reexport/main.ts", "tests/harness/errors.test.ts"] } ], @@ -321,7 +322,7 @@ { "symbols": ["net.createServer", "net.connect", "net.createConnection", "net.getDefaultAutoSelectFamilyAttemptTimeout", "net.setDefaultAutoSelectFamilyAttemptTimeout", "server.address", "server.close", "server.listen", "socket.destroy", "socket.end", "socket.pause", "socket.resume", "socket.setEncoding", "socket.setTimeout", "socket.write"], "status": "partial", "evidence": ["tests/corpus/2500-net-autosel-timeout.ts", "tests/corpus/2596-net-arg-ladders.cjs"] }, { "symbols": ["dgram.createSocket", "socket.address", "socket.bind", "socket.close", "socket.connect", "socket.ref", "socket.remoteAddress", "socket.send", "socket.unref"], "status": "partial", "evidence": ["tests/corpus/2597-dgram-send-ladders.cjs"] }, { "symbols": ["readline.createInterface", "rl.close"], "status": "partial", "evidence": ["tests/corpus/1475-readline-closed-stdin.ts"] }, - { "symbols": ["test", "it", "test.skip", "test.todo", "test.only", "describe", "suite", "before", "after", "beforeEach", "afterEach", "context.test", "context.skip", "context.todo", "context.diagnostic", "context.name", "context.assert"], "status": "partial", "evidence": ["tests/harness/node-test.test.ts"] }, + { "symbols": ["test", "it", "test.skip", "test.todo", "test.only", "describe", "suite", "before", "after", "beforeEach", "afterEach", "context.test", "context.skip", "context.todo", "context.assert"], "status": "partial", "evidence": ["tests/harness/node-test.test.ts"] }, { "symbols": ["http.request", "http.get", "http.createServer", "https.request", "https.get", "https.createServer", "request.end", "request.destroy", "request.setTimeout", "request.write", "response.end", "response.getHeader", "response.hasHeader", "response.removeHeader", "response.setHeader", "response.write", "response.writeHead", "headersTimeout", "requestTimeout", "timeout", "keepAliveTimeout", "keepAliveTimeoutBuffer"], "status": "partial", "evidence": ["tests/corpus/1780-http-res-surface.ts", "tests/corpus/2672-http-request-response-callback.ts", "tests/corpus/2689-http-server-timeout-properties.ts"] } ] } diff --git a/packages/compiler/src/backend/llvm/lib-network.ts b/packages/compiler/src/backend/llvm/lib-network.ts index 3741b73144..19e9d1c13d 100644 --- a/packages/compiler/src/backend/llvm/lib-network.ts +++ b/packages/compiler/src/backend/llvm/lib-network.ts @@ -326,12 +326,14 @@ export function emitNetworkHttpLibCall(host: LlvmEmitterContext, e: LibCallExpr) host.moveTemp(args[2]!); cb = args[2]!.name; } - host.declare(`declare ptr @scr_net_connect(double, ptr, ptr)`); + host.declare(`declare ptr @scr_net_connect_checked(double, ptr, ptr)`); const t = B.tmp(); B.line( - `${t} = call ptr @scr_net_connect(double ${args[0]!.name}, ptr ${args[1]!.name}, ptr ${cb})`, + `${t} = call ptr @scr_net_connect_checked(double ${args[0]!.name}, ptr ${args[1]!.name}, ptr ${cb})`, ); - return host.own({ name: t, type: e.type }); + const out = host.own({ name: t, type: e.type }); + host.emitPendingCheck(); + return out; } if (e.fn === "net.sockOnData" || e.fn === "http.reqOnData") { const cbT = e.args[1]!.type; @@ -602,11 +604,13 @@ export function emitNetworkHttpLibCall(host: LlvmEmitterContext, e: LibCallExpr) ); return { name: "", type: e.type }; } - if (e.fn === "http.resOnFinish") { + if (e.fn === "http.resOnFinish" || e.fn === "http.resOnEndCallback") { const args = e.args.map((a) => host.emitExpr(a)); host.moveTemp(args[1]!); - host.declare(`declare void @scr_http_res_on_finish(ptr, ptr)`); - B.line(`call void @scr_http_res_on_finish(ptr ${args[0]!.name}, ptr ${args[1]!.name})`); + const entry = + e.fn === "http.resOnFinish" ? "scr_http_res_on_finish" : "scr_http_res_on_end_callback"; + host.declare(`declare void @${entry}(ptr, ptr)`); + B.line(`call void @${entry}(ptr ${args[0]!.name}, ptr ${args[1]!.name})`); return { name: "", type: e.type }; } if (e.fn === "http.resSetTimeoutCb" || e.fn === "http.reqSetTimeoutCb") { diff --git a/packages/compiler/src/compat/fetch-profile.ts b/packages/compiler/src/compat/fetch-profile.ts index 95a84e13b9..366de7986a 100644 --- a/packages/compiler/src/compat/fetch-profile.ts +++ b/packages/compiler/src/compat/fetch-profile.ts @@ -158,8 +158,8 @@ const metadataExclusion = export const NODE24_FETCH_COMPAT_PROFILE = { schemaVersion: 1, target: { - node: "24.15.0", - undici: "7.24.4", + node: "24.22.0", + undici: "7.29.1", }, requestInit: [ { diff --git a/packages/compiler/src/frontend/lowering/builtins/process.ts b/packages/compiler/src/frontend/lowering/builtins/process.ts index 7518f4973b..d5ca29c7f9 100644 --- a/packages/compiler/src/frontend/lowering/builtins/process.ts +++ b/packages/compiler/src/frontend/lowering/builtins/process.ts @@ -30,8 +30,8 @@ import { lowerDiagnosticsSubscriber, lowerTracingArguments } from "./async-conte /** The pinned Node release the runtime reports as process.versions.node * (packages/runtime/src/scr_lib.c SCR_NODE_COMPAT_VERSION, kept equal to - * internal/compatibility/node-v24.json by a package test). */ -export const NODE_COMPAT_VERSION = "24.15.0"; + * internal/compatibility/node-v24.json by test/node-pin.test.ts). */ +export const NODE_COMPAT_VERSION = "24.22.0"; /** Method calls on first-class process-stream receivers (procStream — * a WritableStream-typed value like prefixStream's `output` param): diff --git a/packages/compiler/src/frontend/lowering/crypto-tables.ts b/packages/compiler/src/frontend/lowering/crypto-tables.ts index 6f95d56dfa..659ccbf05d 100644 --- a/packages/compiler/src/frontend/lowering/crypto-tables.ts +++ b/packages/compiler/src/frontend/lowering/crypto-tables.ts @@ -1,4 +1,4 @@ -/* node:crypto introspection tables — Node v24.15.0 answers, generated with +/* node:crypto introspection tables — Node v24.22.0 answers, generated with * node -p "require('crypto').constants" (and getCiphers/getHashes/getCurves) * crypto.constants bakes as literals at every access site (the http2.constants * precedent — the object itself never materializes at runtime); the three name @@ -6,7 +6,7 @@ * and defaultCoreCipherList are strings; every other member is a number. */ export const CRYPTO_CONSTANTS: Record = { - "OPENSSL_VERSION_NUMBER": 810549328, + "OPENSSL_VERSION_NUMBER": 810549376, "SSL_OP_ALL": 2147485776, "SSL_OP_ALLOW_NO_DHE_KEX": 1024, "SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION": 262144, @@ -46,6 +46,7 @@ export const CRYPTO_CONSTANTS: Record = { "DH_UNABLE_TO_CHECK_GENERATOR": 4, "DH_NOT_SUITABLE_GENERATOR": 8, "RSA_PKCS1_PADDING": 1, + "RSA_SSLV23_PADDING": 2, "RSA_NO_PADDING": 3, "RSA_PKCS1_OAEP_PADDING": 4, "RSA_X931_PADDING": 5, @@ -66,9 +67,10 @@ export const CRYPTO_CONSTANTS: Record = { "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA256:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA", }; -/** crypto.getCiphers() — Node v24.15.0 (OpenSSL 3.x) cipher names, sorted like Node answers them. */ +/** crypto.getCiphers() — Node v24.22.0 (OpenSSL 3.x) cipher names, sorted like Node answers them. */ export const CRYPTO_CIPHERS: readonly string[] = [ "aes-128-cbc", + "aes-128-cbc-cts", "aes-128-ccm", "aes-128-cfb", "aes-128-cfb1", @@ -76,10 +78,17 @@ export const CRYPTO_CIPHERS: readonly string[] = [ "aes-128-ctr", "aes-128-ecb", "aes-128-gcm", + "aes-128-gcm-siv", "aes-128-ocb", "aes-128-ofb", + "aes-128-siv", + "aes-128-wrap", + "aes-128-wrap-inv", + "aes-128-wrap-pad", + "aes-128-wrap-pad-inv", "aes-128-xts", "aes-192-cbc", + "aes-192-cbc-cts", "aes-192-ccm", "aes-192-cfb", "aes-192-cfb1", @@ -87,9 +96,16 @@ export const CRYPTO_CIPHERS: readonly string[] = [ "aes-192-ctr", "aes-192-ecb", "aes-192-gcm", + "aes-192-gcm-siv", "aes-192-ocb", "aes-192-ofb", + "aes-192-siv", + "aes-192-wrap", + "aes-192-wrap-inv", + "aes-192-wrap-pad", + "aes-192-wrap-pad-inv", "aes-256-cbc", + "aes-256-cbc-cts", "aes-256-ccm", "aes-256-cfb", "aes-256-cfb1", @@ -97,18 +113,30 @@ export const CRYPTO_CIPHERS: readonly string[] = [ "aes-256-ctr", "aes-256-ecb", "aes-256-gcm", + "aes-256-gcm-siv", "aes-256-ocb", "aes-256-ofb", + "aes-256-siv", + "aes-256-wrap", + "aes-256-wrap-inv", + "aes-256-wrap-pad", + "aes-256-wrap-pad-inv", "aes-256-xts", "aes128", "aes128-wrap", + "aes128-wrap-inv", "aes128-wrap-pad", + "aes128-wrap-pad-inv", "aes192", "aes192-wrap", + "aes192-wrap-inv", "aes192-wrap-pad", + "aes192-wrap-pad-inv", "aes256", "aes256-wrap", + "aes256-wrap-inv", "aes256-wrap-pad", + "aes256-wrap-pad-inv", "aria-128-cbc", "aria-128-ccm", "aria-128-cfb", @@ -140,6 +168,7 @@ export const CRYPTO_CIPHERS: readonly string[] = [ "aria192", "aria256", "camellia-128-cbc", + "camellia-128-cbc-cts", "camellia-128-cfb", "camellia-128-cfb1", "camellia-128-cfb8", @@ -147,6 +176,7 @@ export const CRYPTO_CIPHERS: readonly string[] = [ "camellia-128-ecb", "camellia-128-ofb", "camellia-192-cbc", + "camellia-192-cbc-cts", "camellia-192-cfb", "camellia-192-cfb1", "camellia-192-cfb8", @@ -154,6 +184,7 @@ export const CRYPTO_CIPHERS: readonly string[] = [ "camellia-192-ecb", "camellia-192-ofb", "camellia-256-cbc", + "camellia-256-cbc-cts", "camellia-256-cfb", "camellia-256-cfb1", "camellia-256-cfb8", @@ -179,28 +210,33 @@ export const CRYPTO_CIPHERS: readonly string[] = [ "des-ede3-ofb", "des3", "des3-wrap", - "id-aes128-CCM", - "id-aes128-GCM", + "id-aes128-ccm", + "id-aes128-gcm", "id-aes128-wrap", "id-aes128-wrap-pad", - "id-aes192-CCM", - "id-aes192-GCM", + "id-aes192-ccm", + "id-aes192-gcm", "id-aes192-wrap", "id-aes192-wrap-pad", - "id-aes256-CCM", - "id-aes256-GCM", + "id-aes256-ccm", + "id-aes256-gcm", "id-aes256-wrap", "id-aes256-wrap-pad", - "id-smime-alg-CMS3DESwrap", + "id-smime-alg-cms3deswrap", "sm4", "sm4-cbc", + "sm4-ccm", "sm4-cfb", + "sm4-cfb128", "sm4-ctr", "sm4-ecb", + "sm4-gcm", "sm4-ofb", + "sm4-ofb128", + "sm4-xts", ]; -/** crypto.getHashes() — Node v24.15.0 digest names. */ +/** crypto.getHashes() — Node v24.22.0 digest names. */ export const CRYPTO_HASHES: readonly string[] = [ "RSA-MD5", "RSA-RIPEMD160", @@ -217,24 +253,51 @@ export const CRYPTO_HASHES: readonly string[] = [ "RSA-SHA512/224", "RSA-SHA512/256", "RSA-SM3", + "blake2b-512", "blake2b512", + "blake2s-256", "blake2s256", "id-rsassa-pkcs1-v1_5-with-sha3-224", "id-rsassa-pkcs1-v1_5-with-sha3-256", "id-rsassa-pkcs1-v1_5-with-sha3-384", "id-rsassa-pkcs1-v1_5-with-sha3-512", + "keccak-224", + "keccak-256", + "keccak-384", + "keccak-512", + "keccak-kmac-128", + "keccak-kmac-256", + "keccak-kmac128", + "keccak-kmac256", "md5", "md5-sha1", "md5WithRSAEncryption", "ripemd", + "ripemd-160", "ripemd160", "ripemd160WithRSA", "rmd160", + "sha-1", + "sha-224", + "sha-256", + "sha-256/192", + "sha-384", + "sha-512", + "sha-512/224", + "sha-512/256", "sha1", "sha1WithRSAEncryption", + "sha2-224", + "sha2-256", + "sha2-256/192", + "sha2-384", + "sha2-512", + "sha2-512/224", + "sha2-512/256", "sha224", "sha224WithRSAEncryption", "sha256", + "sha256-192", "sha256WithRSAEncryption", "sha3-224", "sha3-256", @@ -248,6 +311,8 @@ export const CRYPTO_HASHES: readonly string[] = [ "sha512-256", "sha512-256WithRSAEncryption", "sha512WithRSAEncryption", + "shake-128", + "shake-256", "shake128", "shake256", "sm3", @@ -256,7 +321,7 @@ export const CRYPTO_HASHES: readonly string[] = [ "ssl3-sha1", ]; -/** crypto.getCurves() — Node v24.15.0 EC curve names. */ +/** crypto.getCurves() — Node v24.22.0 EC curve names. */ export const CRYPTO_CURVES: readonly string[] = [ "Oakley-EC2N-3", "Oakley-EC2N-4", diff --git a/packages/compiler/src/frontend/lowering/http2-constants.ts b/packages/compiler/src/frontend/lowering/http2-constants.ts index aec70d4986..1d8e5285e9 100644 --- a/packages/compiler/src/frontend/lowering/http2-constants.ts +++ b/packages/compiler/src/frontend/lowering/http2-constants.ts @@ -1,4 +1,4 @@ -/* node:http2 constants — the full table Node v24.15.0 exposes as +/* node:http2 constants — the full table Node v24.22.0 exposes as * http2.constants (240 members: NGHTTP2_* protocol codes, NGHTTP2_ERR_* * library codes, HTTP2_HEADER_* names, HTTP2_METHOD_* verbs, and the * HTTP_STATUS_* table), generated with diff --git a/packages/compiler/src/frontend/lowering/lower-server.ts b/packages/compiler/src/frontend/lowering/lower-server.ts index 31a00d8cb9..19918d6e45 100644 --- a/packages/compiler/src/frontend/lowering/lower-server.ts +++ b/packages/compiler/src/frontend/lowering/lower-server.ts @@ -1967,11 +1967,11 @@ function lowerNetSocketMethodCall( if (name === "write" || name === "end") { requireStatementPosition(lowerer, call, `socket.${name}(...)`); // write(chunk, encoding) — the two-argument encoding form: 'buffer' - // beside a string chunk is Node's stream_base typecheck ("Second - // argument must be a buffer", thrown synchronously on an established - // socket — the invalid-input probes' shape); utf8 spellings are the - // plain write (that IS the encoding written); a Buffer chunk ignores - // the encoding like Node does. Other encodings keep the fence. + // beside a string chunk is Writable's encoding check (a synchronous + // ERR_UNKNOWN_ENCODING TypeError, "Unknown encoding: buffer" — the + // invalid-input probes' shape); utf8 spellings are the plain write + // (that IS the encoding written); a Buffer chunk ignores the encoding + // like Node does. Other encodings keep the fence. if (name === "write" && args.length === 2) { const encT = lowerer.typeOf(args[1]!); const chunkT = lowerer.mapTypeOf(lowerer.typeOf(args[0]!)); @@ -1982,13 +1982,7 @@ function lowerNetSocketMethodCall( isJsSourceFile(call.getSourceFile()) ) { lowerer.lowerExpr(args[0]!); // evaluation order (effect-free in practice) - return nodeThrowExpr( - 1, - "ERR_INVALID_ARG_TYPE", - "Second argument must be a buffer", - VOID, - loc, - ); + return nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", "Unknown encoding: buffer", VOID, loc); } const passthrough = (chunkT.kind === "string" && (encT.value === "utf8" || encT.value === "utf-8")) || @@ -6791,9 +6785,9 @@ function lowerHttpResMethodCall( } const receiver = coerceToHandle(lowerer, access.expression, HTTPRES_T); // end's callback forms — end(cb) / end(data, cb): the callback fires - // deferred once the body went out (Node's 'finish' emit), through - // the resOnFinish slot registered just before the end call in an - // interned composing helper. + // deferred once the body went out (just before Node's 'finish' emit), + // through the resOnEndCallback slot registered just before the end + // call in an interned composing helper. let cbArg: IrExpr | null = null; let dataNode: ts.Expression | undefined = args[0]; if (name === "end" && args.length === 2) { @@ -6855,7 +6849,7 @@ function lowerHttpResMethodCall( kind: "exprStmt", expr: { kind: "libCall", - fn: "http.resOnFinish", + fn: "http.resOnEndCallback", args: [ varRef(params[0]!.localId, params[0]!.type, loc), varRef(params[all.length - 1]!.localId, params[all.length - 1]!.type, loc), diff --git a/packages/compiler/src/frontend/lowering/surfaces.ts b/packages/compiler/src/frontend/lowering/surfaces.ts index 8c91572529..4c7602f86a 100644 --- a/packages/compiler/src/frontend/lowering/surfaces.ts +++ b/packages/compiler/src/frontend/lowering/surfaces.ts @@ -221,6 +221,7 @@ export const HTTP_CLIENT_DOCUMENTED_OPTIONS: ReadonlySet = new Set([ "hints", "host", "hostname", + "httpValidation", "insecureHTTPParser", "joinDuplicateHeaders", "localAddress", @@ -251,6 +252,7 @@ export const HTTP_SERVER_DOCUMENTED_OPTIONS: ReadonlySet = new Set([ "connectionsCheckingInterval", "headersTimeout", "highWaterMark", + "httpValidation", "insecureHTTPParser", "joinDuplicateHeaders", "keepAlive", @@ -289,6 +291,7 @@ export const HTTPS_CLIENT_DOCUMENTED_OPTIONS: ReadonlySet = new Set([ ...HTTP_CLIENT_DOCUMENTED_OPTIONS, "ca", "cert", + "certificateCompression", "checkServerIdentity", "ciphers", "clientCertEngine", @@ -325,6 +328,7 @@ export const TLS_SERVER_DOCUMENTED_OPTIONS: ReadonlySet = new Set([ "allowHalfOpen", "ca", "cert", + "certificateCompression", "ciphers", "clientCertEngine", "crl", diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index f086c1cebd..7b53dee03a 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -615,6 +615,11 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "fs.accessSync", "fs.readFdSync", "fs.readFdSyncBytes", + // dns.lookup and net.connect throw ERR_INVALID_ARG_VALUE for a host with + // null bytes. + "dns.lookup", + "net.connect", + "net.connectCb", // node:dgram state errors (Node throws synchronously): bind on a bound // socket, connect on a connected one, send/close/address on a closed or // never-bound one. diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index 371dbbbc71..c0ab297d20 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -1335,8 +1335,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ /** The ServerResponse member surface: statusCode/statusMessage reads * and assignments (Node's writable properties), the header CRUD trio * (getHeader answers `string | undefined` like reqHeader), and - * end(cb)'s finish slot (resOnFinish registers, the end call follows — - * the callback fires deferred, Node's 'finish' emit). writeHead's + * end(cb)'s callback slot (resOnEndCallback registers, the end call + * follows — the callback fires deferred, just before Node's 'finish' + * emit; resOnFinish is the 'finish' listener slot). writeHead's * statusMessage forms compose in interned helpers: resStatusMsgSet * then the ordinary writeHead entry. */ "http.resStatusGet": { argTypes: [HTTPRES_T], result: F64 }, @@ -1367,6 +1368,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ argTypes: [HTTPRES_T, { kind: "func", params: [], ret: VOID }], result: VOID, }, + "http.resOnEndCallback": { + argTypes: [HTTPRES_T, { kind: "func", params: [], ret: VOID }], + result: VOID, + }, "http.reqUrl": { argTypes: [HTTPREQ_T], result: STRING }, "http.reqMethod": { argTypes: [HTTPREQ_T], result: STRING }, "http.reqHeader": { argTypes: [HTTPREQ_T, STRING], result: VOID }, diff --git a/packages/compiler/surface-manifest.json b/packages/compiler/surface-manifest.json index 64d6346ed7..4302c7514a 100644 --- a/packages/compiler/surface-manifest.json +++ b/packages/compiler/surface-manifest.json @@ -7,7 +7,7 @@ "The ambient-nondeterminism and ambient-authority surfaces the library sidecar's determinism attestation scans ARE projected even where they lower through dedicated code paths — the Date compositions (stdlib.date.*), perf_hooks' performance.now, and the process global's ambient reads and authority calls (node-builtin.process.*) — so a determinism fence can name every surface the attestation demotes on.", "stdlib and node-builtin member entries name surface whose LOWERED call forms are constrained (arity, argument shapes); declared call forms outside the lowered set are refused per site, with code SC2020 for standard-library and node-builtin surface.", "Entries with status 'unsupported' describe where the named code is raised: forms of the construct outside the supported subset are refused with that code — not that every form of the named feature is refused. Supported forms appear as their own static entries where a table projects them.", - "The engine-free fetch projection targets Node 24.15.0 with bundled Undici 7.24.4. Each projected row names the differential evidence that guards it; changing the pinned Node or Undici version is an explicit profile update.", + "The engine-free fetch projection targets Node 24.22.0 with bundled Undici 7.29.1. Each projected row names the differential evidence that guards it; changing the pinned Node or Undici version is an explicit profile update.", "The fetch profile also contains a runtime-reflected census of the selected fetch, abort, Headers, and readable-stream interfaces plus RequestInit/ResponseInit dictionary reads. Static and unsupported census rows are projected here; its explicitly out-of-scope metadata rows and adjacent-interface exclusions remain in the profile so absence is deliberate rather than ambiguous.", "Process-level diagnostic codes are not surface entries: SC0001-SC0004 are preflight gates, SC1110 is a comptime evaluation failure, SC3001/SC3002 are backend/target tier refusals, SC9001/SC9002 are internal errors.", "Entry statuses are projected for the desktop targets. The mobile targets (aarch64-apple-ios, aarch64-apple-ios-simulator, aarch64-linux-android) compile library-mode archives only: the library-admissible surface (what SC4005's async_free requirement and the library link set admit) is supported there, the executable lane refuses those triples with SC3002, and no entry outside the library-admissible surface carries a mobile support claim. iOS archives build for iOS 15.0 on darwin hosts; Android archives build against NDK API level 26.", @@ -2652,49 +2652,49 @@ "kind": "stdlib", "name": "AbortController.abort", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: callback-order, identity, liveness, state-machine, surplus-arguments; differential evidence: fixture:static-controller" + "note": "Node 24.22.0 / Undici 7.29.1; facets: callback-order, identity, liveness, state-machine, surplus-arguments; differential evidence: fixture:static-controller" }, { "id": "stdlib.abort-controller.constructor", "kind": "stdlib", "name": "AbortController constructor", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: argument-evaluation, identity, state-machine, surplus-arguments; differential evidence: fixture:static-controller" + "note": "Node 24.22.0 / Undici 7.29.1; facets: argument-evaluation, identity, state-machine, surplus-arguments; differential evidence: fixture:static-controller" }, { "id": "stdlib.abort-controller.signal", "kind": "stdlib", "name": "AbortController.signal", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: identity, property-read, state-machine; differential evidence: fixture:static-controller" + "note": "Node 24.22.0 / Undici 7.29.1; facets: identity, property-read, state-machine; differential evidence: fixture:static-controller" }, { "id": "stdlib.abort-signal.abort", "kind": "stdlib", "name": "AbortSignal.abort", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: identity, liveness, surplus-arguments, property-read; differential evidence: generated:webidl-operations, fixture:static-stream-this" + "note": "Node 24.22.0 / Undici 7.29.1; facets: identity, liveness, surplus-arguments, property-read; differential evidence: generated:webidl-operations, fixture:static-stream-this" }, { "id": "stdlib.abort-signal.aborted", "kind": "stdlib", "name": "AbortSignal.aborted", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read; differential evidence: generated:webidl-operations" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read; differential evidence: generated:webidl-operations" }, { "id": "stdlib.abort-signal.add-event-listener", "kind": "stdlib", "name": "AbortSignal.addEventListener", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, identity, callback-order, callback-this; differential evidence: generated:abort-events, fixture:static-listener-this, fixture:static-listener-noncallable" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, identity, callback-order, callback-this; differential evidence: generated:abort-events, fixture:static-listener-this, fixture:static-listener-noncallable" }, { "id": "stdlib.abort-signal.any", "kind": "stdlib", "name": "AbortSignal.any", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, missing-arguments, surplus-arguments, property-read; differential evidence: generated:webidl-operations, fixture:static-stream-this" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, missing-arguments, surplus-arguments, property-read; differential evidence: generated:webidl-operations, fixture:static-stream-this" }, { "id": "stdlib.abort-signal.constructor", @@ -2702,49 +2702,49 @@ "name": "AbortSignal constructor", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; Node exposes the interface object but constructing it throws; the compiler does not preserve that constructor behavior" + "note": "Node 24.22.0 / Undici 7.29.1; Node exposes the interface object but constructing it throws; the compiler does not preserve that constructor behavior" }, { "id": "stdlib.abort-signal.dispatch-event", "kind": "stdlib", "name": "AbortSignal.dispatchEvent", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: callback-order, callback-this, error-shape; differential evidence: fixture:static-dispatch-throw" + "note": "Node 24.22.0 / Undici 7.29.1; facets: callback-order, callback-this, error-shape; differential evidence: fixture:static-dispatch-throw" }, { "id": "stdlib.abort-signal.onabort", "kind": "stdlib", "name": "AbortSignal.onabort", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: callback-order, callback-this, mutation, property-read; differential evidence: generated:abort-events, fixture:static-listener-this" + "note": "Node 24.22.0 / Undici 7.29.1; facets: callback-order, callback-this, mutation, property-read; differential evidence: generated:abort-events, fixture:static-listener-this" }, { "id": "stdlib.abort-signal.reason", "kind": "stdlib", "name": "AbortSignal.reason", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: identity, liveness, property-read; differential evidence: generated:webidl-operations, fixture:static-stream-this" + "note": "Node 24.22.0 / Undici 7.29.1; facets: identity, liveness, property-read; differential evidence: generated:webidl-operations, fixture:static-stream-this" }, { "id": "stdlib.abort-signal.remove-event-listener", "kind": "stdlib", "name": "AbortSignal.removeEventListener", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, identity, callback-order; differential evidence: generated:abort-events, fixture:static-stream-this" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, identity, callback-order; differential evidence: generated:abort-events, fixture:static-stream-this" }, { "id": "stdlib.abort-signal.throw-if-aborted", "kind": "stdlib", "name": "AbortSignal.throwIfAborted", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: identity, error-shape; differential evidence: generated:webidl-operations, fixture:static-abort-throw" + "note": "Node 24.22.0 / Undici 7.29.1; facets: identity, error-shape; differential evidence: generated:webidl-operations, fixture:static-abort-throw" }, { "id": "stdlib.abort-signal.timeout", "kind": "stdlib", "name": "AbortSignal.timeout", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, missing-arguments, surplus-arguments, error-shape; differential evidence: generated:webidl-operations, fixture:static-stream-this" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, missing-arguments, surplus-arguments, error-shape; differential evidence: generated:webidl-operations, fixture:static-stream-this" }, { "id": "stdlib.array.at", @@ -3089,14 +3089,14 @@ "kind": "stdlib", "name": "fetch", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: argument-evaluation, webidl-conversion, surplus-arguments, promise-settlement, transport, error-shape; differential evidence: fixture:static, fixture:static-coercion, fixture:static-network-error" + "note": "Node 24.22.0 / Undici 7.29.1; facets: argument-evaluation, webidl-conversion, surplus-arguments, promise-settlement, transport, error-shape; differential evidence: fixture:static, fixture:static-coercion, fixture:static-network-error" }, { "id": "stdlib.fetch.request-init.body", "kind": "stdlib", "name": "RequestInit.body", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; conversion: string, Uint8Array, ReadableStream, or null; differential evidence: fixture:static, fixture:static-stream, fixture:static-coercion" + "note": "Node 24.22.0 / Undici 7.29.1; conversion: string, Uint8Array, ReadableStream, or null; differential evidence: fixture:static, fixture:static-stream, fixture:static-coercion" }, { "id": "stdlib.fetch.request-init.cache", @@ -3104,7 +3104,7 @@ "name": "RequestInit.cache", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the compiler does not preserve this RequestInit member's conversion or transport behavior" + "note": "Node 24.22.0 / Undici 7.29.1; the compiler does not preserve this RequestInit member's conversion or transport behavior" }, { "id": "stdlib.fetch.request-init.credentials", @@ -3112,7 +3112,7 @@ "name": "RequestInit.credentials", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the compiler does not preserve this RequestInit member's conversion or transport behavior" + "note": "Node 24.22.0 / Undici 7.29.1; the compiler does not preserve this RequestInit member's conversion or transport behavior" }, { "id": "stdlib.fetch.request-init.dispatcher", @@ -3120,21 +3120,21 @@ "name": "RequestInit.dispatcher", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; custom dispatchers are unsupported; native environment-proxy routing uses NODE_USE_ENV_PROXY" + "note": "Node 24.22.0 / Undici 7.29.1; custom dispatchers are unsupported; native environment-proxy routing uses NODE_USE_ENV_PROXY" }, { "id": "stdlib.fetch.request-init.duplex", "kind": "stdlib", "name": "RequestInit.duplex", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; conversion: WebIDL enum; 'half' required for streaming bodies; differential evidence: fixture:static-stream, fixture:static-coercion" + "note": "Node 24.22.0 / Undici 7.29.1; conversion: WebIDL enum; 'half' required for streaming bodies; differential evidence: fixture:static-stream, fixture:static-coercion" }, { "id": "stdlib.fetch.request-init.headers", "kind": "stdlib", "name": "RequestInit.headers", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; conversion: Headers, record, or sequence-of-pairs snapshot; differential evidence: fixture:static, fixture:static-coercion" + "note": "Node 24.22.0 / Undici 7.29.1; conversion: Headers, record, or sequence-of-pairs snapshot; differential evidence: fixture:static, fixture:static-coercion" }, { "id": "stdlib.fetch.request-init.integrity", @@ -3142,7 +3142,7 @@ "name": "RequestInit.integrity", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the compiler does not preserve this RequestInit member's conversion or transport behavior" + "note": "Node 24.22.0 / Undici 7.29.1; the compiler does not preserve this RequestInit member's conversion or transport behavior" }, { "id": "stdlib.fetch.request-init.keepalive", @@ -3150,14 +3150,14 @@ "name": "RequestInit.keepalive", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the compiler does not preserve this RequestInit member's conversion or transport behavior" + "note": "Node 24.22.0 / Undici 7.29.1; the compiler does not preserve this RequestInit member's conversion or transport behavior" }, { "id": "stdlib.fetch.request-init.method", "kind": "stdlib", "name": "RequestInit.method", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; conversion: WebIDL ByteString after all call arguments evaluate; differential evidence: fixture:static-coercion" + "note": "Node 24.22.0 / Undici 7.29.1; conversion: WebIDL ByteString after all call arguments evaluate; differential evidence: fixture:static-coercion" }, { "id": "stdlib.fetch.request-init.mode", @@ -3165,7 +3165,7 @@ "name": "RequestInit.mode", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the compiler does not preserve this RequestInit member's conversion or transport behavior" + "note": "Node 24.22.0 / Undici 7.29.1; the compiler does not preserve this RequestInit member's conversion or transport behavior" }, { "id": "stdlib.fetch.request-init.priority", @@ -3173,14 +3173,14 @@ "name": "RequestInit.priority", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the compiler does not preserve this RequestInit member's conversion or transport behavior" + "note": "Node 24.22.0 / Undici 7.29.1; the compiler does not preserve this RequestInit member's conversion or transport behavior" }, { "id": "stdlib.fetch.request-init.redirect", "kind": "stdlib", "name": "RequestInit.redirect", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; conversion: WebIDL enum: follow, error, or manual; differential evidence: fixture:static, fixture:static-coercion" + "note": "Node 24.22.0 / Undici 7.29.1; conversion: WebIDL enum: follow, error, or manual; differential evidence: fixture:static, fixture:static-coercion" }, { "id": "stdlib.fetch.request-init.referrer", @@ -3188,7 +3188,7 @@ "name": "RequestInit.referrer", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the compiler does not preserve this RequestInit member's conversion or transport behavior" + "note": "Node 24.22.0 / Undici 7.29.1; the compiler does not preserve this RequestInit member's conversion or transport behavior" }, { "id": "stdlib.fetch.request-init.referrerPolicy", @@ -3196,14 +3196,14 @@ "name": "RequestInit.referrerPolicy", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the compiler does not preserve this RequestInit member's conversion or transport behavior" + "note": "Node 24.22.0 / Undici 7.29.1; the compiler does not preserve this RequestInit member's conversion or transport behavior" }, { "id": "stdlib.fetch.request-init.signal", "kind": "stdlib", "name": "RequestInit.signal", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; conversion: native AbortSignal handle or absent; differential evidence: fixture:static, fixture:static-abort-throw" + "note": "Node 24.22.0 / Undici 7.29.1; conversion: native AbortSignal handle or absent; differential evidence: fixture:static, fixture:static-abort-throw" }, { "id": "stdlib.fetch.request-init.window", @@ -3211,28 +3211,28 @@ "name": "RequestInit.window", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the compiler does not preserve this RequestInit member's conversion or transport behavior" + "note": "Node 24.22.0 / Undici 7.29.1; the compiler does not preserve this RequestInit member's conversion or transport behavior" }, { "id": "stdlib.headers.append", "kind": "stdlib", "name": "Headers.append", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, mutation, error-shape; differential evidence: fixture:static, fixture:static-coercion" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, mutation, error-shape; differential evidence: fixture:static, fixture:static-coercion" }, { "id": "stdlib.headers.constructor", "kind": "stdlib", "name": "Headers constructor", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, mutation, identity; supported scope: Record and iterable header pairs, including copying native Headers; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, mutation, identity; supported scope: Record and iterable header pairs, including copying native Headers; differential evidence: fixture:static-request" }, { "id": "stdlib.headers.delete", "kind": "stdlib", "name": "Headers.delete", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, mutation, error-shape; differential evidence: fixture:static, fixture:static-coercion" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, mutation, error-shape; differential evidence: fixture:static, fixture:static-coercion" }, { "id": "stdlib.headers.entries", @@ -3240,35 +3240,35 @@ "name": "Headers.entries", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; native Headers iteration does not yet expose a static iterator handle" + "note": "Node 24.22.0 / Undici 7.29.1; native Headers iteration does not yet expose a static iterator handle" }, { "id": "stdlib.headers.forEach", "kind": "stdlib", "name": "Headers.forEach", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: callback-order, callback-this, mutation; differential evidence: fixture:static, fixture:static-coercion" + "note": "Node 24.22.0 / Undici 7.29.1; facets: callback-order, callback-this, mutation; differential evidence: fixture:static, fixture:static-coercion" }, { "id": "stdlib.headers.get", "kind": "stdlib", "name": "Headers.get", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, missing-arguments, property-read; differential evidence: fixture:static, fixture:static-coercion" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, missing-arguments, property-read; differential evidence: fixture:static, fixture:static-coercion" }, { "id": "stdlib.headers.getSetCookie", "kind": "stdlib", "name": "Headers.getSetCookie", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, mutation, error-shape; differential evidence: fixture:static, fixture:static-coercion" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, mutation, error-shape; differential evidence: fixture:static, fixture:static-coercion" }, { "id": "stdlib.headers.has", "kind": "stdlib", "name": "Headers.has", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, missing-arguments, property-read; differential evidence: fixture:static, fixture:static-coercion" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, missing-arguments, property-read; differential evidence: fixture:static, fixture:static-coercion" }, { "id": "stdlib.headers.keys", @@ -3276,14 +3276,14 @@ "name": "Headers.keys", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; native Headers iteration does not yet expose a static iterator handle" + "note": "Node 24.22.0 / Undici 7.29.1; native Headers iteration does not yet expose a static iterator handle" }, { "id": "stdlib.headers.set", "kind": "stdlib", "name": "Headers.set", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, mutation, error-shape; differential evidence: fixture:static, fixture:static-coercion" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, mutation, error-shape; differential evidence: fixture:static, fixture:static-coercion" }, { "id": "stdlib.headers.symbol.iterator", @@ -3291,7 +3291,7 @@ "name": "Headers.[Symbol.iterator]", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; native Headers iteration does not expose an engine-free iterator handle" + "note": "Node 24.22.0 / Undici 7.29.1; native Headers iteration does not expose an engine-free iterator handle" }, { "id": "stdlib.headers.values", @@ -3299,7 +3299,7 @@ "name": "Headers.values", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; native Headers iteration does not yet expose a static iterator handle" + "note": "Node 24.22.0 / Undici 7.29.1; native Headers iteration does not yet expose a static iterator handle" }, { "id": "stdlib.map.clear", @@ -3685,7 +3685,7 @@ "kind": "stdlib", "name": "ReadableStreamDefaultController.close", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: state-machine, error-shape; differential evidence: generated:stream-traces, fixture:static-stream" + "note": "Node 24.22.0 / Undici 7.29.1; facets: state-machine, error-shape; differential evidence: generated:stream-traces, fixture:static-stream" }, { "id": "stdlib.readable-stream-default-controller.constructor", @@ -3693,42 +3693,42 @@ "name": "ReadableStreamDefaultController constructor", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; controller handles come from underlying-source callbacks; the constructor object is unsupported" + "note": "Node 24.22.0 / Undici 7.29.1; controller handles come from underlying-source callbacks; the constructor object is unsupported" }, { "id": "stdlib.readable-stream-default-controller.desired-size", "kind": "stdlib", "name": "ReadableStreamDefaultController.desiredSize", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; differential evidence: generated:stream-traces" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; differential evidence: generated:stream-traces" }, { "id": "stdlib.readable-stream-default-controller.enqueue", "kind": "stdlib", "name": "ReadableStreamDefaultController.enqueue", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: identity, liveness, state-machine, error-shape; differential evidence: generated:stream-traces, fixture:static-stream" + "note": "Node 24.22.0 / Undici 7.29.1; facets: identity, liveness, state-machine, error-shape; differential evidence: generated:stream-traces, fixture:static-stream" }, { "id": "stdlib.readable-stream-default-controller.error", "kind": "stdlib", "name": "ReadableStreamDefaultController.error", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: identity, promise-settlement, state-machine; differential evidence: generated:stream-traces, fixture:static-stream" + "note": "Node 24.22.0 / Undici 7.29.1; facets: identity, promise-settlement, state-machine; differential evidence: generated:stream-traces, fixture:static-stream" }, { "id": "stdlib.readable-stream-default-reader.cancel", "kind": "stdlib", "name": "ReadableStreamDefaultReader.cancel", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: identity, promise-settlement, state-machine; differential evidence: generated:stream-traces, fixture:static-stream" + "note": "Node 24.22.0 / Undici 7.29.1; facets: identity, promise-settlement, state-machine; differential evidence: generated:stream-traces, fixture:static-stream" }, { "id": "stdlib.readable-stream-default-reader.closed", "kind": "stdlib", "name": "ReadableStreamDefaultReader.closed", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: promise-settlement, property-read, state-machine; differential evidence: generated:stream-traces, fixture:static-stream" + "note": "Node 24.22.0 / Undici 7.29.1; facets: promise-settlement, property-read, state-machine; differential evidence: generated:stream-traces, fixture:static-stream" }, { "id": "stdlib.readable-stream-default-reader.constructor", @@ -3736,56 +3736,56 @@ "name": "ReadableStreamDefaultReader constructor", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; reader handles come from ReadableStream.getReader(); the constructor object is unsupported" + "note": "Node 24.22.0 / Undici 7.29.1; reader handles come from ReadableStream.getReader(); the constructor object is unsupported" }, { "id": "stdlib.readable-stream-default-reader.read", "kind": "stdlib", "name": "ReadableStreamDefaultReader.read", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: identity, promise-settlement, state-machine; differential evidence: generated:stream-traces, fixture:static-stream" + "note": "Node 24.22.0 / Undici 7.29.1; facets: identity, promise-settlement, state-machine; differential evidence: generated:stream-traces, fixture:static-stream" }, { "id": "stdlib.readable-stream-default-reader.release-lock", "kind": "stdlib", "name": "ReadableStreamDefaultReader.releaseLock", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: promise-settlement, state-machine, error-shape; differential evidence: generated:stream-traces, fixture:static-stream" + "note": "Node 24.22.0 / Undici 7.29.1; facets: promise-settlement, state-machine, error-shape; differential evidence: generated:stream-traces, fixture:static-stream" }, { "id": "stdlib.readable-stream.cancel", "kind": "stdlib", "name": "ReadableStream.cancel", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: identity, promise-settlement, state-machine; differential evidence: generated:stream-traces, fixture:static-stream" + "note": "Node 24.22.0 / Undici 7.29.1; facets: identity, promise-settlement, state-machine; differential evidence: generated:stream-traces, fixture:static-stream" }, { "id": "stdlib.readable-stream.constructor", "kind": "stdlib", "name": "ReadableStream constructor", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, callback-this, callback-order, state-machine; differential evidence: generated:stream-traces, fixture:static-stream-this" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, callback-this, callback-order, state-machine; differential evidence: generated:stream-traces, fixture:static-stream-this" }, { "id": "stdlib.readable-stream.from", "kind": "stdlib", "name": "ReadableStream.from", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, missing-arguments, surplus-arguments, liveness; differential evidence: generated:webidl-operations, generated:stream-traces" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, missing-arguments, surplus-arguments, liveness; differential evidence: generated:webidl-operations, generated:stream-traces" }, { "id": "stdlib.readable-stream.get-reader", "kind": "stdlib", "name": "ReadableStream.getReader", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, identity, state-machine, error-shape; differential evidence: generated:stream-traces, fixture:static-stream" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, identity, state-machine, error-shape; differential evidence: generated:stream-traces, fixture:static-stream" }, { "id": "stdlib.readable-stream.locked", "kind": "stdlib", "name": "ReadableStream.locked", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; differential evidence: generated:stream-traces" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; differential evidence: generated:stream-traces" }, { "id": "stdlib.readable-stream.pipeThrough", @@ -3793,7 +3793,7 @@ "name": "ReadableStream.pipeThrough", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the wider Web Streams graph is outside the native readable-stream slice" + "note": "Node 24.22.0 / Undici 7.29.1; the wider Web Streams graph is outside the native readable-stream slice" }, { "id": "stdlib.readable-stream.pipeTo", @@ -3801,7 +3801,7 @@ "name": "ReadableStream.pipeTo", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; this operation is outside the native readable-stream implementation" + "note": "Node 24.22.0 / Undici 7.29.1; this operation is outside the native readable-stream implementation" }, { "id": "stdlib.readable-stream.symbol.asyncIterator", @@ -3809,7 +3809,7 @@ "name": "ReadableStream.[Symbol.asyncIterator]", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; direct for-await consumption compiles statically; explicit symbol access and stored iterator handles have no compiler lowering" + "note": "Node 24.22.0 / Undici 7.29.1; direct for-await consumption compiles statically; explicit symbol access and stored iterator handles have no compiler lowering" }, { "id": "stdlib.readable-stream.tee", @@ -3817,7 +3817,7 @@ "name": "ReadableStream.tee", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; this operation is outside the native readable-stream implementation" + "note": "Node 24.22.0 / Undici 7.29.1; this operation is outside the native readable-stream implementation" }, { "id": "stdlib.readable-stream.values", @@ -3825,14 +3825,14 @@ "name": "ReadableStream.values", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; direct for-await consumption compiles statically; storing or driving the first-class iterator handle is unsupported" + "note": "Node 24.22.0 / Undici 7.29.1; direct for-await consumption compiles statically; storing or driving the first-class iterator handle is unsupported" }, { "id": "stdlib.request.arrayBuffer", "kind": "stdlib", "name": "Request.arrayBuffer", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static-request" }, { "id": "stdlib.request.attribute", @@ -3840,7 +3840,7 @@ "name": "Request.attribute", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; typed source has no compiler bridge for this interface" + "note": "Node 24.22.0 / Undici 7.29.1; typed source has no compiler bridge for this interface" }, { "id": "stdlib.request.blob", @@ -3848,35 +3848,35 @@ "name": "Request.blob", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; typed source has no compiler bridge for this interface" + "note": "Node 24.22.0 / Undici 7.29.1; typed source has no compiler bridge for this interface" }, { "id": "stdlib.request.body", "kind": "stdlib", "name": "Request.body", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.bodyUsed", "kind": "stdlib", "name": "Request.bodyUsed", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.bytes", "kind": "stdlib", "name": "Request.bytes", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static-request" }, { "id": "stdlib.request.cache", "kind": "stdlib", "name": "Request.cache", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.clone", @@ -3884,35 +3884,35 @@ "name": "Request.clone", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; typed source has no compiler bridge for this interface" + "note": "Node 24.22.0 / Undici 7.29.1; typed source has no compiler bridge for this interface" }, { "id": "stdlib.request.constructor", "kind": "stdlib", "name": "Request constructor", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, body-consumption, error-shape; supported scope: Absolute URLs with method, headers, body, duplex, redirect, and signal; other RequestInit members retain explicit fences; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, body-consumption, error-shape; supported scope: Absolute URLs with method, headers, body, duplex, redirect, and signal; other RequestInit members retain explicit fences; differential evidence: fixture:static-request" }, { "id": "stdlib.request.credentials", "kind": "stdlib", "name": "Request.credentials", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.destination", "kind": "stdlib", "name": "Request.destination", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.duplex", "kind": "stdlib", "name": "Request.duplex", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.formData", @@ -3920,133 +3920,133 @@ "name": "Request.formData", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; typed source has no compiler bridge for this interface" + "note": "Node 24.22.0 / Undici 7.29.1; typed source has no compiler bridge for this interface" }, { "id": "stdlib.request.headers", "kind": "stdlib", "name": "Request.headers", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.integrity", "kind": "stdlib", "name": "Request.integrity", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.isHistoryNavigation", "kind": "stdlib", "name": "Request.isHistoryNavigation", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.isReloadNavigation", "kind": "stdlib", "name": "Request.isReloadNavigation", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.json", "kind": "stdlib", "name": "Request.json", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static-request" }, { "id": "stdlib.request.keepalive", "kind": "stdlib", "name": "Request.keepalive", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.method", "kind": "stdlib", "name": "Request.method", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.mode", "kind": "stdlib", "name": "Request.mode", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.redirect", "kind": "stdlib", "name": "Request.redirect", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.referrer", "kind": "stdlib", "name": "Request.referrer", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.referrerPolicy", "kind": "stdlib", "name": "Request.referrerPolicy", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.signal", "kind": "stdlib", "name": "Request.signal", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.request.text", "kind": "stdlib", "name": "Request.text", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static-request" }, { "id": "stdlib.request.url", "kind": "stdlib", "name": "Request.url", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read, state-machine; supported scope: Reads on native Requests within the constructor's supported RequestInit subset; differential evidence: fixture:static-request" }, { "id": "stdlib.response-init.headers", "kind": "stdlib", "name": "ResponseInit.headers", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; conversion: Headers, record, or sequence-of-pairs snapshot; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; conversion: Headers, record, or sequence-of-pairs snapshot; differential evidence: fixture:static" }, { "id": "stdlib.response-init.status", "kind": "stdlib", "name": "ResponseInit.status", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; conversion: WebIDL unsigned-short conversion followed by the 200–599 range check; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; conversion: WebIDL unsigned-short conversion followed by the 200–599 range check; differential evidence: fixture:static" }, { "id": "stdlib.response-init.statusText", "kind": "stdlib", "name": "ResponseInit.statusText", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; conversion: WebIDL ByteString with HTTP reason-phrase validation; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; conversion: WebIDL ByteString with HTTP reason-phrase validation; differential evidence: fixture:static" }, { "id": "stdlib.response.arrayBuffer", "kind": "stdlib", "name": "Response.arrayBuffer", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static" }, { "id": "stdlib.response.blob", @@ -4054,28 +4054,28 @@ "name": "Response.blob", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the native fetch runtime does not implement this Response operation" + "note": "Node 24.22.0 / Undici 7.29.1; the native fetch runtime does not implement this Response operation" }, { "id": "stdlib.response.body", "kind": "stdlib", "name": "Response.body", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read; differential evidence: fixture:static" }, { "id": "stdlib.response.bodyUsed", "kind": "stdlib", "name": "Response.bodyUsed", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read; differential evidence: fixture:static" }, { "id": "stdlib.response.bytes", "kind": "stdlib", "name": "Response.bytes", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static, fixture:static-stream" + "note": "Node 24.22.0 / Undici 7.29.1; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static, fixture:static-stream" }, { "id": "stdlib.response.clone", @@ -4083,14 +4083,14 @@ "name": "Response.clone", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the native fetch runtime does not implement this Response operation" + "note": "Node 24.22.0 / Undici 7.29.1; the native fetch runtime does not implement this Response operation" }, { "id": "stdlib.response.constructor", "kind": "stdlib", "name": "Response constructor", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: webidl-conversion, body-consumption, state-machine, error-shape; supported scope: BodyInit is string, Uint8Array/Buffer, ReadableStream, null/undefined, or a checked-dynamic value that follows the supported WebIDL string conversion; ResponseInit is headers/status/statusText; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; facets: webidl-conversion, body-consumption, state-machine, error-shape; supported scope: BodyInit is string, Uint8Array/Buffer, ReadableStream, null/undefined, or a checked-dynamic value that follows the supported WebIDL string conversion; ResponseInit is headers/status/statusText; differential evidence: fixture:static" }, { "id": "stdlib.response.formData", @@ -4098,35 +4098,35 @@ "name": "Response.formData", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the native fetch runtime does not implement this Response operation" + "note": "Node 24.22.0 / Undici 7.29.1; the native fetch runtime does not implement this Response operation" }, { "id": "stdlib.response.headers", "kind": "stdlib", "name": "Response.headers", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read; differential evidence: fixture:static" }, { "id": "stdlib.response.json", "kind": "stdlib", "name": "Response.json", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static, fixture:static-stream" + "note": "Node 24.22.0 / Undici 7.29.1; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static, fixture:static-stream" }, { "id": "stdlib.response.ok", "kind": "stdlib", "name": "Response.ok", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read; differential evidence: fixture:static" }, { "id": "stdlib.response.redirected", "kind": "stdlib", "name": "Response.redirected", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read; differential evidence: fixture:static" }, { "id": "stdlib.response.static.error", @@ -4134,7 +4134,7 @@ "name": "Response.error", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; Response static constructor-object operations have no compiler lowering" + "note": "Node 24.22.0 / Undici 7.29.1; Response static constructor-object operations have no compiler lowering" }, { "id": "stdlib.response.static.json", @@ -4142,7 +4142,7 @@ "name": "Response.json", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; Response static constructor-object operations have no compiler lowering" + "note": "Node 24.22.0 / Undici 7.29.1; Response static constructor-object operations have no compiler lowering" }, { "id": "stdlib.response.static.redirect", @@ -4150,28 +4150,28 @@ "name": "Response.redirect", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; Response static constructor-object operations have no compiler lowering" + "note": "Node 24.22.0 / Undici 7.29.1; Response static constructor-object operations have no compiler lowering" }, { "id": "stdlib.response.status", "kind": "stdlib", "name": "Response.status", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read; differential evidence: fixture:static" }, { "id": "stdlib.response.statusText", "kind": "stdlib", "name": "Response.statusText", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read; differential evidence: fixture:static" }, { "id": "stdlib.response.text", "kind": "stdlib", "name": "Response.text", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static, fixture:static-stream" + "note": "Node 24.22.0 / Undici 7.29.1; facets: body-consumption, promise-settlement, state-machine, error-shape; differential evidence: fixture:static, fixture:static-stream" }, { "id": "stdlib.response.type", @@ -4179,14 +4179,14 @@ "name": "Response.type", "status": "unsupported", "code": "SC2020", - "note": "Node 24.15.0 / Undici 7.24.4; the member is outside the native static handle projection" + "note": "Node 24.22.0 / Undici 7.29.1; the member is outside the native static handle projection" }, { "id": "stdlib.response.url", "kind": "stdlib", "name": "Response.url", "status": "static", - "note": "Node 24.15.0 / Undici 7.24.4; facets: property-read; differential evidence: fixture:static" + "note": "Node 24.22.0 / Undici 7.29.1; facets: property-read; differential evidence: fixture:static" }, { "id": "stdlib.set.add", diff --git a/packages/compiler/test/node-pin.test.ts b/packages/compiler/test/node-pin.test.ts new file mode 100644 index 0000000000..9b9e709684 --- /dev/null +++ b/packages/compiler/test/node-pin.test.ts @@ -0,0 +1,31 @@ +/* Every Node pin names the same release: .node-version (the + * differential oracle), Dockerfile.sandbox, the compatibility pin, the fetch + * profile, the docs matrix fallback, and the version the compiled binary + * reports. */ +import { readFileSync } from "node:fs"; +import { join } from "node:path"; +import { expect, test } from "vitest"; +import { NODE24_FETCH_COMPAT_PROFILE } from "../src/compat/fetch-profile.js"; +import { NODE_COMPAT_VERSION } from "../src/frontend/lowering/builtins/process.js"; + +const repoRoot = join(import.meta.dirname, "../../.."); +const read = (path: string): string => readFileSync(join(repoRoot, path), "utf8"); + +test("the Node pins agree", () => { + const pinned = read(".node-version").trim(); + const compat = JSON.parse(read("internal/compatibility/node-v24.json")) as { + version: string; + tag: string; + }; + expect(compat.version).toBe(pinned); + expect(compat.tag).toBe(`v${pinned}`); + expect(read("Dockerfile.sandbox")).toMatch(new RegExp(`^ARG NODE_VERSION=${pinned}$`, "m")); + expect(NODE_COMPAT_VERSION).toBe(pinned); + expect(NODE24_FETCH_COMPAT_PROFILE.target.node).toBe(pinned); + expect(read("packages/runtime/src/scr_lib.c")).toContain( + `#define SCR_NODE_COMPAT_VERSION "${pinned}"`, + ); + expect(read("docs/src/components/node-compatibility-matrix.tsx")).toContain( + `snapshot?.nodeVersion ?? "${pinned}"`, + ); +}); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5275-http-end-callback-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5275-http-end-callback-order.ts.json new file mode 100644 index 0000000000..c46af6bf49 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5275-http-end-callback-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5275-http-end-callback-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5276-style-text-hex-colors.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5276-style-text-hex-colors.cjs.json new file mode 100644 index 0000000000..526b4b1c12 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5276-style-text-hex-colors.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5276-style-text-hex-colors.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5277-fs-read-file-buffer-option.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5277-fs-read-file-buffer-option.cjs.json new file mode 100644 index 0000000000..713aad2062 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5277-fs-read-file-buffer-option.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5277-fs-read-file-buffer-option.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5278-host-null-bytes.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5278-host-null-bytes.cjs.json new file mode 100644 index 0000000000..0f75f271f6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5278-host-null-bytes.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5278-host-null-bytes.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5279-search-params-null-init.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5279-search-params-null-init.cjs.json new file mode 100644 index 0000000000..8c1b30cfcc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5279-search-params-null-init.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5279-search-params-null-init.cjs" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_bytes_io.c b/packages/runtime/src/scr_bytes_io.c index 780ded5f15..cef6d1181e 100644 --- a/packages/runtime/src/scr_bytes_io.c +++ b/packages/runtime/src/scr_bytes_io.c @@ -194,6 +194,27 @@ static bool scr_fs_cb_refuse_option(const ScrDyn *options, const char *name) { return present; } +/* readFile's options.buffer: validateReadFileBufferOptions' type check + * (any value other than undefined, a function, or an ArrayBufferView + * throws ERR_INVALID_ARG_TYPE), then a refusal for the valid forms. False + * with the exception pending in both cases. */ +static bool scr_fs_cb_read_buffer_option(const ScrDyn *options) { + ScrDyn *value = scr_fs_cb_option(options, "buffer"); + if (!value) return false; + bool absent = value->kind == SCR_DYN_UNDEF; + if (!absent) { + if (value->kind != SCR_DYN_FUNC && value->kind != SCR_DYN_BYTES) { + scr_dyn_prop_type_fail("options.buffer", + "of type function or an instance of Buffer, TypedArray, or DataView", value); + } else { + static const char message[] = "Filesystem callback option 'buffer' has no native lowering"; + scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); + } + } + scr_dyn_release(value); + return absent; +} + static bool scr_fs_cb_signal(const ScrDyn *options) { ScrDyn *signal = scr_fs_cb_option(options, "signal"); if (!signal) return false; @@ -752,7 +773,8 @@ static ScrDyn *scr_fs_cb_invoke(ScrStr *member, ScrDyn *const *args, size_t argc if (!scr_fs_cb_chk(callback, fileCallback || vector || timestamp ? "cb" : "callback")) { scr_arr_release(vectors); return NULL; } size_t count = timestamp ? argc : argc - 1; #define ARG(index) scr_fs_cb_arg(args, count, index) - if (!strcmp(op, "readFile") && !scr_fs_encoding_chk(ARG(1))) return NULL; + if (!strcmp(op, "readFile") && (!scr_fs_encoding_chk(ARG(1)) || + (ARG(1)->kind != SCR_DYN_STR && !scr_fs_cb_read_buffer_option(ARG(1))))) return NULL; if (!strcmp(op, "read") && count >= 4 && !scr_fs_read_validate(ARG(0), ARG(1), ARG(2), ARG(3), ARG(4))) return NULL; bool descriptor = timestamp_fd || vector || newControl || !strcmp(op, "close") || !strcmp(op, "fstat") || !strcmp(op, "fsync") || !strcmp(op, "read") || !strcmp(op, "write"); ScrStr *path = descriptor ? NULL : timestamp ? scr_fs_timestamp_path(ARG(0)) : scr_fs_cb_path(ARG(0), !strcmp(op, "mkdtemp") ? "prefix" : "path"); @@ -1545,6 +1567,16 @@ static bool scr_fs_read_validate(const ScrDyn *fd, const ScrDyn *buffer, const S if (!scr_fs_int_range_chk(offset, "offset", 0, buflen, range)) return false; } } + if (!scr_fs_dyn_absent(position)) { + if (position->kind != SCR_DYN_NUM) { + scr_dyn_arg_type_fail("position", "of type bigint or integer", position); + return false; + } + if (!scr_fs_int_range_chk(position, "position", -1, 9007199254740991.0, + ">= -1 && <= 9007199254740991")) { + return false; + } + } double off = offset->kind == SCR_DYN_NUM ? offset->v.num : 0; if (!scr_fs_dyn_absent(length)) { if (length->kind != SCR_DYN_NUM || !(isfinite(length->v.num) && trunc(length->v.num) == length->v.num) || @@ -1574,16 +1606,6 @@ static bool scr_fs_read_validate(const ScrDyn *fd, const ScrDyn *buffer, const S return false; } } - if (!scr_fs_dyn_absent(position)) { - if (position->kind != SCR_DYN_NUM) { - scr_dyn_arg_type_fail("position", "of type bigint or integer", position); - return false; - } - if (!scr_fs_int_range_chk(position, "position", -1, 9007199254740991.0, - ">= -1 && <= 9007199254740991")) { - return false; - } - } return true; } diff --git a/packages/runtime/src/scr_dgram.c b/packages/runtime/src/scr_dgram.c index b96012012f..eb2a7ca30c 100644 --- a/packages/runtime/src/scr_dgram.c +++ b/packages/runtime/src/scr_dgram.c @@ -808,6 +808,21 @@ static void scr_dgram_read(ScrDgramSocket *s) { void scr_dns_lookup(ScrStr *hostname, double family, ScrClosure *cb, ScrDnsLookupFn fn) { (void)family; /* the frontend pinned 4; AF_INET below IS that pin */ + if (memchr(hostname->data, '\0', hostname->len) != NULL) { + /* validateStringWithoutNullBytes: a synchronous ERR_INVALID_ARG_VALUE + * TypeError before any lookup runs; the callback never fires. */ + scr_closure_release(cb); + ScrStr *shown = scr_str_inspect_quoted(hostname, true); + ScrJsonBuf msg; + scr_jb_init(&msg); + scr_jb_puts(&msg, "The argument 'hostname' must be a string without null bytes. Received "); + scr_jb_put_str(&msg, shown); + scr_str_release(shown); + ScrStr *text = scr_jb_finish(&msg); + scr_throw_error_msg_code(SCR_ERR_TYPE, text->data, text->len, "ERR_INVALID_ARG_VALUE"); + scr_str_release(text); + return; + } #ifdef _WIN32 /* getaddrinfo needs winsock started (WSANOTINITIALISED otherwise); the * poller owns WSAStartup on this arm, so a lookup-only program rides diff --git a/packages/runtime/src/scr_fetch.c b/packages/runtime/src/scr_fetch.c index 05bc29fee2..467fa74809 100644 --- a/packages/runtime/src/scr_fetch.c +++ b/packages/runtime/src/scr_fetch.c @@ -562,7 +562,7 @@ static void sf_any_source_abort(SfSignalWatch *w, SfSignal *source) { ScrDyn *scr_fetch_abort_any(ScrDyn *signals) { if (!signals || signals->kind != SCR_DYN_ARR) { static const char message[] = - "signals can not be converted to sequence."; + "signals cannot be converted to sequence."; scr_throw_error_msg_code(SCR_ERR_TYPE, message, sizeof message - 1, "ERR_INVALID_ARG_TYPE"); return NULL; diff --git a/packages/runtime/src/scr_http.c b/packages/runtime/src/scr_http.c index e58ae6fec0..9616b5fc57 100644 --- a/packages/runtime/src/scr_http.c +++ b/packages/runtime/src/scr_http.c @@ -76,7 +76,7 @@ static bool scr_http_timeout_valid(double ms) { return false; } -/* Node v24.15.0's STATUS_CODES table, shared by the module export and the +/* Node v24.22.0's STATUS_CODES table, shared by the module export and the * default ServerResponse reason phrase. */ static const struct { int code; const char *reason; } scr_http_status_codes_table[] = { {100, "Continue"}, {101, "Switching Protocols"}, {102, "Processing"}, @@ -226,6 +226,7 @@ struct ScrHttpReq { struct ScrHttpClientReq *pipe_client; ScrNetSocket *pipe_sock; bool ended; /* body complete (or connection dead): data/end drop */ + bool end_consumed; /* 'end' fired on a body read through data listeners or a pipe */ bool enc_utf8; /* setEncoding('utf8'): 'data' delivers strings */ bool http10; /* the parsed request/status line's version (httpVersion) */ bool http2; /* an h2 compat request (httpVersion "2.0") */ @@ -712,6 +713,7 @@ static void scr_http_req_finish(ScrHttpReq *r, bool fire) { return; } r->ended = true; + r->end_consumed = fire && (r->data_ls.n > 0 || r->pipe_res || r->pipe_client || r->pipe_sock); if (fire) scr_net_fire0_this(&r->end_ls, r, SCR_DYNH_HTTP_REQ); scr_net_ls_drop(&r->data_ls); scr_net_ls_drop(&r->end_ls); @@ -906,8 +908,10 @@ struct ScrHttpRes { ScrHttpReq *req_ref; bool req_cleared; ScrNetLs close_ls, timeout_ls; - ScrNetLs finish_ls; /* res.end(cb) — fires deferred once the body went out */ + ScrNetLs finish_ls; /* res.on('finish') — fires deferred once the body went out */ + ScrNetLs endcb_ls; /* res.end(cb) — fires just before the 'finish' listeners */ ScrNetLs wcb_ls; /* res.write(chunk, cb) — fires from the queue */ + bool writable_finished; /* set where Node emits 'finish' (writableFinished) */ bool finish_queued; bool wcb_queued; bool close_queued; @@ -933,6 +937,7 @@ void scr_http_res_release(ScrHttpRes *r) { scr_net_ls_drop(&r->close_ls); scr_net_ls_drop(&r->timeout_ls); scr_net_ls_drop(&r->finish_ls); + scr_net_ls_drop(&r->endcb_ls); scr_net_ls_drop(&r->wcb_ls); free(r->cork_buf); if (r->req_ref) scr_http_req_release(r->req_ref); @@ -958,7 +963,11 @@ ScrHttpReq *scr_http_res_request(ScrHttpRes *r) { return scr_http_req_retain(r-> ScrNetSocket *scr_http_res_socket(ScrHttpRes *r) { return r->sock && !r->socket_detached ? scr_net_sock_retain(r->sock) : NULL; } -bool scr_http_res_writable_finished(ScrHttpRes *r) { return r->finished; } +/* HTTP/1 writableFinished turns true where 'finish' is emitted, not when + * end() returns; the h2 compat response keeps its stream's answer. */ +bool scr_http_res_writable_finished(ScrHttpRes *r) { + return r->h2_stream != NULL ? r->finished : r->writable_finished; +} static bool scr_http_res_has_header(ScrHttpRes *r, const char *name); @@ -1961,15 +1970,36 @@ static void scr_http_queue_res_finish(ScrHttpRes *res) { scr_http_emit_push(SCR_HTTP_EMIT_RES_FINISH, scr_http_res_retain(res)); } -/* res.end(cb)'s callback slot: registered just before the end call; a - * response that already finished (a second end) still fires it deferred - * — Node errbacks ERR_STREAM_ALREADY_FINISHED there (divergence: this - * surface's callbacks take no arguments, so it fires plainly). */ +/* res.on('finish', cb): fires deferred once the body went out, after the + * end(cb) callbacks and after the response detached its socket. */ void scr_http_res_on_finish(ScrHttpRes *r, ScrClosure *cb /*moves*/) { scr_net_ls_add(&r->finish_ls, cb, NULL, true); if (r->finished) scr_http_queue_res_finish(r); } +/* res.end(cb)'s callback slot: registered just before the end call. The + * callbacks run where Node's OutgoingMessage flushes its end callbacks: + * after writableFinished turns true and before the 'finish' listeners, + * with the socket still attached. A callback registered after the + * response finished runs synchronously, where Node passes + * ERR_STREAM_ALREADY_FINISHED (this surface's callbacks take no + * arguments). The h2 compat response keeps the 'finish' listener order. */ +void scr_http_res_on_end_callback(ScrHttpRes *r, ScrClosure *cb /*moves*/) { + if (r->h2_stream != NULL) { + scr_http_res_on_finish(r, cb); + return; + } + if (r->writable_finished) { + ScrNetLs now = {0}; + scr_net_ls_add(&now, cb, NULL, true); + scr_net_fire0_this(&now, r, SCR_DYNH_HTTP_RES); + scr_net_ls_drop(&now); + return; + } + scr_net_ls_add(&r->endcb_ls, cb, NULL, true); + if (r->finished) scr_http_queue_res_finish(r); +} + /* res.write(chunk, cb): the callback fires from the queue (this surface * flushes synchronously into the socket buffer — the deferral keeps the * cb off the writing stack, Node's contract). */ @@ -2061,9 +2091,14 @@ static void scr_http_proto_sweep(void) { break; case SCR_HTTP_EMIT_RES_FINISH: { ScrHttpRes *res = (ScrHttpRes *)e.h; - res->finish_queued = false; /* a later end(cb) on the finished res re-queues */ + res->finish_queued = false; /* a later on('finish') on the finished res re-queues */ + res->writable_finished = true; + ScrNetLs endcbs = res->endcb_ls; + res->endcb_ls = (ScrNetLs){0}; + scr_net_fire0_this(&endcbs, res, SCR_DYNH_HTTP_RES); + scr_net_ls_drop(&endcbs); res->socket_detached = true; - scr_net_fire0_this(&res->finish_ls, res, SCR_DYNH_HTTP_RES); + if (!scr_exc_pending()) scr_net_fire0_this(&res->finish_ls, res, SCR_DYNH_HTTP_RES); break; } } @@ -2248,7 +2283,10 @@ void scr_http1_ctx_on_upgrade(void *p, ScrClosure *cb /*moves*/, ScrHttpUpgradeF void scr_http1_ctx_settle(void *p) { scr_http_srv_ctx_settle(p); } static void scr_http_conn_drop_request(ScrHttpConn *conn, bool fire_end) { - /* the deferred 'close' emits: res before req, Node's order */ + /* the deferred 'close' emits: a request whose body was read to 'end' + * was destroyed then and closes first; otherwise res before req (Node + * ends an unread request after the response finishes) */ + if (conn->req && conn->req->end_consumed) scr_http_queue_req_close(conn->req); if (conn->res) scr_http_queue_res_close(conn->res); if (conn->req) scr_http_queue_req_close(conn->req); if (conn->req) { @@ -5128,7 +5166,7 @@ static ScrDyn *scr_http_dynh_res_invoke(void *h, ScrDyn *self, const char *metho scr_http_dynh_unsupported("ServerResponse", "end", "this argument shape is not modeled"); return NULL; } - if (cb) scr_http_res_on_finish(r, scr_dyn_listener_closure0(cb)); + if (cb) scr_http_res_on_end_callback(r, scr_dyn_listener_closure0(cb)); if (decoded != NULL) { scr_http_res_end_bytes(r, decoded); scr_bytes_release(decoded); @@ -5375,7 +5413,7 @@ static ScrDyn *scr_http_dynh_res_get(void *h, const char *key, size_t key_len) { return scr_dyn_new_handle(r->req_ref, SCR_DYNH_HTTP_REQ); } if (strcmp(key, "writableCorked") == 0) return scr_dyn_new_num(scr_http_res_writable_corked(r)); - if (strcmp(key, "writableFinished") == 0) return scr_dyn_new_bool(r->finished); + if (strcmp(key, "writableFinished") == 0) return scr_dyn_new_bool(scr_http_res_writable_finished(r)); if (strcmp(key, "writableHighWaterMark") == 0) { /* Node's default socket highWaterMark — a constant here (backpressure * is not modeled; SEMANTICS.md) */ diff --git a/packages/runtime/src/scr_idna.c b/packages/runtime/src/scr_idna.c index e7b1707c09..34c9e3882a 100644 --- a/packages/runtime/src/scr_idna.c +++ b/packages/runtime/src/scr_idna.c @@ -207,10 +207,9 @@ static int32_t puny_adapt(int32_t d, int32_t n, bool first) { return k + (((PUNY_BASE - PUNY_TMIN + 1) * d) / (d + PUNY_SKEW)); } -/* Decodes the label after its "xn--" prefix. `out` may be NULL to only - * verify. A second "xn--" prefix fails (whatwg/url#803). */ +/* Decodes the label after its "xn--" prefix into `out`. A decoded label + * that itself begins with "xn--" fails (whatwg/url#803). */ static bool puny_decode(const char *p, size_t n, IdnaBuf *out) { - if (n >= 4 && memcmp(p, "xn--", 4) == 0) return false; int32_t written = 0; uint32_t code = 128; int32_t i = 0; @@ -226,7 +225,7 @@ static bool puny_decode(const char *p, size_t n, IdnaBuf *out) { if (dash != n) { for (size_t k = 0; k < dash; k++) { if ((unsigned char)p[k] >= 0x80) return false; - if (out) ib32_push(out, (unsigned char)p[k]); + ib32_push(out, (unsigned char)p[k]); written++; } pos = dash + 1; @@ -250,11 +249,12 @@ static bool puny_decode(const char *p, size_t n, IdnaBuf *out) { code += (uint32_t)(i / (written + 1)); i %= written + 1; if (code < 0x80) return false; - if (out) ib32_insert(out, (size_t)i, code); + ib32_insert(out, (size_t)i, code); written++; i++; } - return true; + return !(out->len >= 4 && out->data[0] == 'x' && out->data[1] == 'n' && out->data[2] == '-' && + out->data[3] == '-'); } static bool puny_encode(const uint32_t *in, size_t n, ScrJsonBuf *out) { @@ -310,7 +310,9 @@ static bool puny_encode(const uint32_t *in, size_t n, ScrJsonBuf *out) { * virama passes, a ZWNJ otherwise needs a left- or dual-joining character * somewhere before it and a right- or dual-joining one somewhere after); * otherwise a label holding an R, AL or AN character follows the RFC 5893 - * rule for the direction of its first character. */ + * rule for the direction of its first character: an L label allows only + * L, EN, ES, CS, ET, ON, BN and NSM and ends (before trailing NSMs) in L + * or EN; any other label must start with R or AL. */ static bool idna_label_valid(const uint32_t *label, size_t n) { if (n == 0) return true; if (IDNA_LOOKUP(scr_idna_marks, label[0])) return false; @@ -345,14 +347,17 @@ static bool idna_label_valid(const uint32_t *label, size_t n) { } if (!rtl) return true; if (idna_bidi(label[0]) == SCR_BIDI_L) { - for (size_t k = 0; k < last; k++) { + for (size_t k = 0; k <= last; k++) { uint8_t d = idna_bidi(label[k]); if (!(d == SCR_BIDI_L || d == SCR_BIDI_EN || d == SCR_BIDI_ES || d == SCR_BIDI_CS || d == SCR_BIDI_ET || d == SCR_BIDI_ON || d == SCR_BIDI_BN || d == SCR_BIDI_NSM)) return false; } - return true; + uint8_t end = idna_bidi(label[last]); + return end == SCR_BIDI_L || end == SCR_BIDI_EN; } + uint8_t first = idna_bidi(label[0]); + if (first != SCR_BIDI_R && first != SCR_BIDI_AL) return false; bool has_an = false, has_en = false; for (size_t k = 0; k <= last; k++) { uint8_t d = idna_bidi(label[k]); @@ -374,8 +379,9 @@ static bool idna_label_valid(const uint32_t *label, size_t n) { } /* An "xn--" label's Punycode must decode to a non-ASCII label that the - * mapping and NFC leave unchanged and that passes the validity checks. */ -static bool idna_check_puny_label(const char *p, size_t n) { + * mapping and NFC leave unchanged and that passes the validity checks. + * `decoded_out` (nullable) receives the decoded code points when it passes. */ +static bool idna_check_puny_label(const char *p, size_t n, IdnaBuf *decoded_out) { IdnaBuf decoded = {0}, mapped = {0}; bool ok = puny_decode(p, n, &decoded); if (ok) { @@ -394,7 +400,11 @@ static bool idna_check_puny_label(const char *p, size_t n) { idna_label_valid(mapped.data, mapped.len); free(normal.data); } - free(decoded.data); + if (ok && decoded_out) { + *decoded_out = decoded; + } else { + free(decoded.data); + } free(mapped.data); return ok; } @@ -406,35 +416,23 @@ static ScrStr *idna_fail(ScrJsonBuf *b) { /* ── ToASCII / ToUnicode ───────────────────────────────────────────── */ +/* Inputs longer than this many bytes fail ToASCII and pass ToUnicode + * through unchanged. */ +#define IDNA_MAX_INPUT_BYTES 16384u + ScrStr *scr_idna_to_ascii(const char *p, size_t n) { - bool ascii = true; - for (size_t i = 0; i < n && ascii; i++) ascii = (unsigned char)p[i] < 0x80; ScrJsonBuf out; scr_jb_init(&out); + if (n > IDNA_MAX_INPUT_BYTES) return idna_fail(&out); + bool ascii = true; + for (size_t i = 0; i < n && ascii; i++) ascii = (unsigned char)p[i] < 0x80; if (ascii) { - /* ASCII input maps by lowercasing alone; only Punycode labels need - * the full check. */ - char *lower = malloc(n ? n : 1); - if (!lower) scr_trap("scriptc: out of memory\n"); + /* An ASCII domain is the input lowercased, whatever its labels hold + * (the URL Standard's domain to ASCII with beStrict false). */ for (size_t i = 0; i < n; i++) { char c = p[i]; - lower[i] = c >= 'A' && c <= 'Z' ? (char)(c + 32) : c; + scr_jb_putc(&out, c >= 'A' && c <= 'Z' ? (char)(c + 32) : c); } - for (size_t start = 0; start < n;) { - const char *dot = memchr(lower + start, '.', n - start); - size_t end = dot ? (size_t)(dot - lower) : n; - size_t len = end - start; - if (len >= 4 && memcmp(lower + start, "xn--", 4) == 0 && - !idna_check_puny_label(lower + start + 4, len - 4)) { - free(lower); - return idna_fail(&out); - } - scr_jb_write_utf8(&out, lower + start, len); - if (!dot) break; - scr_jb_putc(&out, '.'); - start = end + 1; - } - free(lower); return scr_jb_finish(&out); } IdnaBuf input = {0}, mapped = {0}; @@ -461,7 +459,7 @@ ScrStr *scr_idna_to_ascii(const char *p, size_t n) { char *bytes = malloc(len); if (!bytes) scr_trap("scriptc: out of memory\n"); for (size_t k = 0; k < len; k++) bytes[k] = (char)label[k]; - ok = idna_check_puny_label(bytes + 4, len - 4); + ok = idna_check_puny_label(bytes + 4, len - 4, NULL); if (ok) scr_jb_write_utf8(&out, bytes, len); free(bytes); } else if (label_ascii) { @@ -480,7 +478,10 @@ ScrStr *scr_idna_to_ascii(const char *p, size_t n) { return ok ? scr_jb_finish(&out) : idna_fail(&out); } +/* ToUnicode never fails: an "xn--" label decodes only when it passes the + * same checks ToASCII applies to it; any other label stays as given. */ ScrStr *scr_idna_to_unicode(const char *p, size_t n) { + if (n > IDNA_MAX_INPUT_BYTES) return scr_str_new(p, n); ScrJsonBuf out; scr_jb_init(&out); for (size_t start = 0; start < n;) { @@ -491,20 +492,18 @@ ScrStr *scr_idna_to_unicode(const char *p, size_t n) { bool ascii = true; for (size_t k = 0; k < len && ascii; k++) ascii = (unsigned char)label[k] < 0x80; bool decoded = false; + IdnaBuf cps = {0}; if (ascii && len >= 4 && memcmp(label, "xn--", 4) == 0 && - puny_decode(label + 4, len - 4, NULL)) { - IdnaBuf cps = {0}; - if (puny_decode(label + 4, len - 4, &cps)) { - bool scalar = true; - for (size_t k = 0; k < cps.len && scalar; k++) - scalar = cps.data[k] <= 0x10FFFF && (cps.data[k] < 0xD800 || cps.data[k] >= 0xE000); - if (scalar) { - for (size_t k = 0; k < cps.len; k++) idna_put_utf8(&out, cps.data[k]); - decoded = true; - } + idna_check_puny_label(label + 4, len - 4, &cps)) { + bool scalar = true; + for (size_t k = 0; k < cps.len && scalar; k++) + scalar = cps.data[k] <= 0x10FFFF && (cps.data[k] < 0xD800 || cps.data[k] >= 0xE000); + if (scalar) { + for (size_t k = 0; k < cps.len; k++) idna_put_utf8(&out, cps.data[k]); + decoded = true; } - free(cps.data); } + free(cps.data); if (!decoded) scr_jb_write(&out, label, len); if (!dot) break; scr_jb_putc(&out, '.'); diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index 0f712ca4ab..b8c9ed8d79 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -2624,7 +2624,7 @@ bool scr_dyn_util_type_is(const ScrDyn *value, const ScrStr *probe) { /* Node's JavaScript wrappers have names/arity; engine-native probes are * anonymous with length zero. Keep their native closure identity intact. */ ScrDyn *scr_dyn_util_type_value(const ScrDyn *value, const ScrStr *probe) { - static const char *const named[] = { "isTypedArray", "isUint8Array", "isUint8ClampedArray", "isUint16Array", "isUint32Array", + static const char *const named[] = { "isDataView", "isTypedArray", "isUint8Array", "isUint8ClampedArray", "isUint16Array", "isUint32Array", "isInt8Array", "isInt16Array", "isInt32Array", "isFloat32Array", "isFloat64Array" }; const char *name = ""; if (probe->len == 17 && memcmp(probe->data, "isArrayBufferView", 17) == 0) name = "isView"; @@ -3209,6 +3209,76 @@ const char *scr_dyn_inspect_lite(const ScrDyn *v, char *buf, size_t cap) { } } +/* util.inspect's string rendering (inspect.js strEscape): single quotes + * unless the string contains one, then double quotes or backticks when the + * string has none of those; C0 controls, the active quote, backslashes, + * U+007F-U+009F, and unpaired surrogates are escaped. The ERR_INVALID_ARG_* + * messages print it truncated to 128 UTF-16 units plus "...". Lives in the + * dyn core so validators in optional units can render without the inspect + * unit. */ +ScrStr *scr_str_inspect_quoted(const ScrStr *s, bool truncate) { + static const char *const c0[32] = { + "\\x00", "\\x01", "\\x02", "\\x03", "\\x04", "\\x05", "\\x06", "\\x07", + "\\b", "\\t", "\\n", "\\x0B", "\\f", "\\r", "\\x0E", "\\x0F", + "\\x10", "\\x11", "\\x12", "\\x13", "\\x14", "\\x15", "\\x16", "\\x17", + "\\x18", "\\x19", "\\x1A", "\\x1B", "\\x1C", "\\x1D", "\\x1E", "\\x1F", + }; + const unsigned char *p = (const unsigned char *)s->data; + size_t n = s->len; + char quote = '\''; + if (memchr(p, '\'', n) != NULL) { + bool brace = false; + for (size_t i = 0; i + 1 < n && !brace; i++) brace = p[i] == '$' && p[i + 1] == '{'; + if (memchr(p, '"', n) == NULL) quote = '"'; + else if (memchr(p, '`', n) == NULL && !brace) quote = '`'; + } + ScrJsonBuf out; + scr_jb_init(&out); + scr_jb_putc(&out, quote); + for (size_t i = 0; i < n;) { + unsigned char c = p[i]; + char hex[8]; + if (c < 0x20) { + scr_jb_puts(&out, c0[c]); + i++; + } else if (c == '\\') { + scr_jb_puts(&out, "\\\\"); + i++; + } else if (c == '\'' && quote == '\'') { + scr_jb_puts(&out, "\\'"); + i++; + } else if (c == 0x7f) { + scr_jb_puts(&out, "\\x7F"); + i++; + } else if (c == 0xc2 && i + 1 < n && p[i + 1] >= 0x80 && p[i + 1] <= 0x9f) { + snprintf(hex, sizeof hex, "\\x%02X", p[i + 1]); + scr_jb_puts(&out, hex); + i += 2; + } else if (c == 0xed && i + 2 < n && p[i + 1] >= 0xa0 && p[i + 1] <= 0xbf) { + /* a WTF-8 surrogate code unit: paired surrogates arrive as one + * four-byte sequence, so this one is unpaired */ + unsigned unit = 0xd000u | ((unsigned)(p[i + 1] & 0x3f) << 6) | (p[i + 2] & 0x3f); + snprintf(hex, sizeof hex, "\\u%04x", unit); + scr_jb_puts(&out, hex); + i += 3; + } else { + scr_jb_putc(&out, (char)c); + i++; + } + } + scr_jb_putc(&out, quote); + ScrStr *text = scr_jb_finish(&out); + if (truncate && scr_str_utf16_len(text) > 128) { + ScrStr *head = scr_str_slice(text, 0, 128); + ScrStr *dots = scr_str_new("...", 3); + scr_str_release(text); + text = scr_str_concat(head, dots); + scr_str_release(head); + scr_str_release(dots); + } + return text; +} + /* Node's ERR_INVALID_ARG_VALUE thrower: "The '' * . Received " — the argument/property choice follows * errors.js (a dotted name is a property path). `reason` defaults to @@ -7764,7 +7834,7 @@ void scr_sc_validate_options(const ScrDyn *options) { if (transferView) tr = transferView; if (tr->kind != SCR_DYN_ARR) { static const char msg[] = - "Failed to execute 'structuredClone': transfer in Options can not be converted to sequence."; + "Failed to execute 'structuredClone': transfer in Options cannot be converted to sequence."; scr_throw_error_msg_code(SCR_ERR_TYPE, msg, sizeof msg - 1, "ERR_INVALID_ARG_TYPE"); scr_dyn_release(transferView); return; diff --git a/packages/runtime/src/scr_lib.c b/packages/runtime/src/scr_lib.c index ea1c4d2d7f..2e27ad724e 100644 --- a/packages/runtime/src/scr_lib.c +++ b/packages/runtime/src/scr_lib.c @@ -625,7 +625,7 @@ ScrStr *scr_process_arch(void) { * is no Node under a compiled binary; this is the version whose semantics * SEMANTICS.md verifies the runtime against (divergence 60, the execPath * stance: answer for the world that actually exists). */ -#define SCR_NODE_COMPAT_VERSION "24.15.0" +#define SCR_NODE_COMPAT_VERSION "24.22.0" ScrStr *scr_process_versions_node(void) { if (!scr_versions_node_str) { scr_versions_node_str = @@ -644,7 +644,7 @@ ScrStr *scr_process_versions_node(void) { * sites). Reading undefined here made every hasCrypto test self-skip — * measuring nothing (SEMANTICS.md; the divergence entry documents that * the string names the compat target's OpenSSL, not a linked library). */ -#define SCR_OPENSSL_COMPAT_VERSION "3.5.5" +#define SCR_OPENSSL_COMPAT_VERSION "3.5.8" ScrStr *scr_process_versions_openssl(void) { if (!scr_versions_openssl_str) { scr_versions_openssl_str = @@ -3579,7 +3579,7 @@ static DWORD scr_fs_set_path_times(WCHAR *path, double atime, double mtime, bool return error; } #else -/* Match the pinned libuv conversion: microsecond truncation, normalized +/* Match the pinned libuv conversion: nanosecond truncation, normalized * negative fractions, and the special current/unchanged time sentinels. */ static bool scr_fs_timespec(double time, struct timespec *out) { if (isinf(time)) { *out = (struct timespec){ 0, UTIME_NOW }; return true; } @@ -3587,7 +3587,6 @@ static bool scr_fs_timespec(double time, struct timespec *out) { if (time < -9223372036854775808.0 || time >= 9223372036854775808.0) return false; out->tv_sec = (time_t)time; out->tv_nsec = (long)((time - (double)out->tv_sec) * 1000000000.0); - out->tv_nsec -= out->tv_nsec % 1000; if (out->tv_nsec < 0) { out->tv_nsec += 1000000000; out->tv_sec--; } return true; } @@ -3968,8 +3967,26 @@ double scr_fs_read_sync(double fd, ScrBytes *buf, double offset, double length, scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE"); return 0; } - /* Node returns after offset's intrinsic validation when the requested - * length normalizes to zero: buffer-window bounds, position, and fd are + if (!(isfinite(position) && trunc(position) == position)) { + char recv[48]; + scr_num_received(position, recv); + mlen = snprintf(msg, sizeof msg, + "The value of \"position\" is out of range. It must be an integer. Received %s", + recv); + scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE"); + return 0; + } + if (position < -1 || position > 9007199254740991.0) { + char recv[48]; + scr_num_received(position, recv); + mlen = snprintf(msg, sizeof msg, + "The value of \"position\" is out of range. It must be >= -1 && <= 9007199254740991. Received %s", + recv); + scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE"); + return 0; + } + /* Node returns after the offset and position validation when the + * requested length normalizes to zero: buffer-window bounds and fd are * not consulted. Preserve the existing size_t coercion's [0, 1) case. */ if (length >= 0 && length < 1) return 0; if (offset > (double)bytelen) { @@ -3990,24 +4007,6 @@ double scr_fs_read_sync(double fd, ScrBytes *buf, double offset, double length, return 0; } size_t want = (size_t)length; - if (!(isfinite(position) && trunc(position) == position)) { - char recv[48]; - scr_num_received(position, recv); - mlen = snprintf(msg, sizeof msg, - "The value of \"position\" is out of range. It must be an integer. Received %s", - recv); - scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE"); - return 0; - } - if (position < -1 || position > 9007199254740991.0) { - char recv[48]; - scr_num_received(position, recv); - mlen = snprintf(msg, sizeof msg, - "The value of \"position\" is out of range. It must be >= -1 && <= 9007199254740991. Received %s", - recv); - scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE"); - return 0; - } uint8_t *bounce = buf->shared ? malloc(want ? want : 1) : NULL; if (buf->shared && !bounce) scr_trap("scriptc: out of memory\n"); uint8_t *destination = bounce ? bounce : buf->data + off; @@ -5241,37 +5240,55 @@ void scr_fs_symlink(ScrStr *target, ScrStr *destination, int kind) { /* Keep the unsigned libuv statfs representation before selecting Number or * BigInt. Free-space counts are live snapshots, not cached volume metadata. */ ScrDyn *scr_fs_statfs(ScrStr *path, bool bigint) { - uint64_t fields[7]; + uint64_t fields[8]; #if defined(_WIN32) ScrStr *syscall_path = scr_path_win32_to_namespaced_path(path); WCHAR *wide = scr_fs_win_wide(syscall_path); scr_str_release(syscall_path); if (!wide) { scr_fs_throw(scr_fs_win_errno(GetLastError()), "statfs", path); return NULL; } - DWORD sectors, bytes, free_clusters, total_clusters; - BOOL ok = GetDiskFreeSpaceW(wide, §ors, &bytes, &free_clusters, &total_clusters); - DWORD error = ok ? 0 : GetLastError(); - if (!ok && error == ERROR_DIRECTORY) { - /* libuv retries a file path's parent once, preserving the original path - * in errors. GetFullPathName also expands relative and drive paths. */ - DWORD size = GetFullPathNameW(wide, 0, NULL, NULL); - WCHAR *absolute = size ? malloc((size_t)size * sizeof *absolute) : NULL; - if (size && !absolute) scr_trap("scriptc: out of memory\n"); - WCHAR *part = NULL; - DWORD length = absolute ? GetFullPathNameW(wide, size, absolute, &part) : 0; - if (length && length < size) { - if (part) *part = L'\0'; - ok = GetDiskFreeSpaceW(absolute, §ors, &bytes, &free_clusters, &total_clusters); - if (!ok) error = GetLastError(); - } - free(absolute); - } + /* libuv opens the path and reads FileFsFullSizeInformation from the + * volume that holds it; files and directories both resolve that way. */ + HANDLE handle = CreateFileW(wide, FILE_READ_ATTRIBUTES, + FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, NULL); free(wide); - if (!ok) { scr_fs_throw(scr_fs_win_errno(error), "statfs", path); return NULL; } + if (handle == INVALID_HANDLE_VALUE) { + scr_fs_throw(scr_fs_win_errno(GetLastError()), "statfs", path); + return NULL; + } + struct { + LARGE_INTEGER total; + LARGE_INTEGER caller_available; + LARGE_INTEGER actual_available; + ULONG sectors_per_unit; + ULONG bytes_per_sector; + } info; + struct { + union { LONG status; PVOID pointer; } u; + ULONG_PTR information; + } io_status; + typedef LONG(NTAPI * QueryVolumeFn)(HANDLE, void *, void *, ULONG, int); + typedef ULONG(NTAPI * StatusToDosFn)(LONG); + HMODULE ntdll = GetModuleHandleA("ntdll.dll"); + QueryVolumeFn query = + ntdll ? (QueryVolumeFn)(void *)GetProcAddress(ntdll, "NtQueryVolumeInformationFile") : NULL; + StatusToDosFn to_dos = + ntdll ? (StatusToDosFn)(void *)GetProcAddress(ntdll, "RtlNtStatusToDosError") : NULL; + /* FileFsFullSizeInformation is FS_INFORMATION_CLASS value 7. */ + LONG status = query ? query(handle, &io_status, &info, (ULONG)sizeof info, 7) : (LONG)0xC0000002L; + CloseHandle(handle); + /* NT_ERROR: the two severity bits are both set. */ + if (((ULONG)status >> 30) == 3) { + DWORD error = to_dos ? (DWORD)to_dos(status) : ERROR_NOT_SUPPORTED; + scr_fs_throw(scr_fs_win_errno(error), "statfs", path); + return NULL; + } fields[0] = 0; - fields[1] = (DWORD)(bytes * sectors); - fields[2] = total_clusters; - fields[3] = fields[4] = free_clusters; - fields[5] = fields[6] = 0; + fields[1] = fields[2] = (uint64_t)info.sectors_per_unit * info.bytes_per_sector; + fields[3] = (uint64_t)info.total.QuadPart; + fields[4] = (uint64_t)info.actual_available.QuadPart; + fields[5] = (uint64_t)info.caller_available.QuadPart; + fields[6] = fields[7] = 0; #elif defined(__wasi__) (void)path; (void)bigint; static const char message[] = "Filesystem capacity queries have no native WASI syscall"; @@ -5288,15 +5305,21 @@ ScrDyn *scr_fs_statfs(ScrStr *path, bool bigint) { fields[0] = 0; #endif fields[1] = (uint64_t)snapshot.f_bsize; - fields[2] = (uint64_t)snapshot.f_blocks; - fields[3] = (uint64_t)snapshot.f_bfree; - fields[4] = (uint64_t)snapshot.f_bavail; - fields[5] = (uint64_t)snapshot.f_files; - fields[6] = (uint64_t)snapshot.f_ffree; + /* libuv reports f_frsize on Linux and repeats f_bsize elsewhere. */ +#if defined(__linux__) + fields[2] = (uint64_t)snapshot.f_frsize; +#else + fields[2] = (uint64_t)snapshot.f_bsize; #endif - static const char *names[] = { "type", "bsize", "blocks", "bfree", "bavail", "files", "ffree" }; + fields[3] = (uint64_t)snapshot.f_blocks; + fields[4] = (uint64_t)snapshot.f_bfree; + fields[5] = (uint64_t)snapshot.f_bavail; + fields[6] = (uint64_t)snapshot.f_files; + fields[7] = (uint64_t)snapshot.f_ffree; +#endif + static const char *names[] = { "type", "bsize", "frsize", "blocks", "bfree", "bavail", "files", "ffree" }; ScrDyn *result = scr_dyn_new_obj(); - for (size_t i = 0; i < 7; i++) { + for (size_t i = 0; i < 8; i++) { ScrDyn *value; if (bigint) { ScrBigInt *number = scr_bigint_from_u64(fields[i]); diff --git a/packages/runtime/src/scr_net.c b/packages/runtime/src/scr_net.c index 3f13c7f4fe..225391c351 100644 --- a/packages/runtime/src/scr_net.c +++ b/packages/runtime/src/scr_net.c @@ -1890,6 +1890,23 @@ static void scr_net_sock_dial_peer(ScrNetSocket *s) { } } +/* lookupAndConnect's validateStringWithoutNullBytes(host, 'options.host'): + * a host with a null byte throws ERR_INVALID_ARG_VALUE before any lookup. + * False with the exception pending. */ +bool scr_net_host_chk(const ScrStr *host /*borrowed, nullable*/) { + if (host == NULL || memchr(host->data, '\0', host->len) == NULL) return true; + ScrStr *shown = scr_str_inspect_quoted(host, true); + ScrJsonBuf msg; + scr_jb_init(&msg); + scr_jb_puts(&msg, "The property 'options.host' must be a string without null bytes. Received "); + scr_jb_put_str(&msg, shown); + scr_str_release(shown); + ScrStr *text = scr_jb_finish(&msg); + scr_throw_error_msg_code(SCR_ERR_TYPE, text->data, text->len, "ERR_INVALID_ARG_VALUE"); + scr_str_release(text); + return false; +} + ScrNetSocket *scr_net_connect(double port, ScrStr *host /*borrowed, nullable*/, ScrClosure *cb /*moves, nullable*/) { ScrNetSocket *s = scr_net_sock_new(); @@ -1944,9 +1961,21 @@ static bool scr_net_attempt_timeout_chk(const ScrDyn *t, const char *name) { * autoSelectFamily flag already takes. NULL with the throw pending. */ ScrNetSocket *scr_net_connect_attempt(double port, ScrStr *host, const ScrDyn *t) { if (!scr_net_attempt_timeout_chk(t, "options.autoSelectFamilyAttemptTimeout")) return NULL; + if (!scr_net_host_chk(host)) return NULL; return scr_net_connect(port, host, NULL); } +/* net.connect/createConnection from compiled code: the host check, then + * the dial. NULL with the exception pending when the host is rejected. */ +ScrNetSocket *scr_net_connect_checked(double port, ScrStr *host /*borrowed, nullable*/, + ScrClosure *cb /*moves, nullable*/) { + if (!scr_net_host_chk(host)) { + scr_closure_release(cb); + return NULL; + } + return scr_net_connect(port, host, cb); +} + static bool scr_net_dyn_truthy(const ScrDyn *v) { switch (v->kind) { case SCR_DYN_UNDEF: @@ -2130,6 +2159,10 @@ static void scr_net_sock_dial_next(ScrNetSocket *s) { ScrNetSocket *scr_net_connect_lookup(double port, ScrStr *host /*borrowed*/, ScrClosure *lookup /*moves*/, void *answer_fn) { + if (!scr_net_host_chk(host)) { + scr_closure_release(lookup); + return NULL; + } ScrNetSocket *s = scr_net_sock_new(); s->peer_port = (int)port; snprintf(s->peer_ip, sizeof s->peer_ip, "%.*s", diff --git a/packages/runtime/src/scr_regex.c b/packages/runtime/src/scr_regex.c index 75430efe60..572484bd52 100644 --- a/packages/runtime/src/scr_regex.c +++ b/packages/runtime/src/scr_regex.c @@ -1355,12 +1355,11 @@ ScrStr *scr_regex_replace_callback(ScrStr *s, ScrRegex *re, ScrDyn *callback, bo * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. - * Keep the pattern equivalent to Node v24.15.0 internal/util/inspect.js. */ -#define SCR_VT_PATTERN "[\\u001B\\u009B][[\\]()#;?]*" \ - "(?:(?:(?:(?:;[-a-zA-Z\\d\\/\\#&.:=?%@~_]+)*" \ - "|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/\\#&.:=?%@~_]*)*)?" \ - "(?:\\u0007|\\u001B\\u005C|\\u009C))" \ - "|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))" + * Keep the pattern equivalent to Node v24.22.0 internal/util/inspect.js. */ +#define SCR_VT_PATTERN "(?:\\u001B\\][\\s\\S]*?(?:\\u0007|\\u001B\\u005C|\\u009C))" \ + "|[\\u001B\\u009B][[\\]()#;?]*" \ + "(?:\\d{1,4}(?:[;:]\\d{0,4})*)?" \ + "[\\dA-PR-TZcf-nq-uy=><~]" ScrStr *scr_util_strip_vt(const ScrDyn *input) { if (!input || input->kind != SCR_DYN_STR) { diff --git a/packages/runtime/src/scr_runtime.h b/packages/runtime/src/scr_runtime.h index 4d0b60ca9b..576b44ccd8 100644 --- a/packages/runtime/src/scr_runtime.h +++ b/packages/runtime/src/scr_runtime.h @@ -5881,6 +5881,7 @@ SCR_COLD void scr_dyn_arg_value_fail(const char *name, const char *reason, const /* The ERR_INVALID_ARG_VALUE/%j "Received" renderer (inspect-lite: * strings quote, scalars print plain, deep shapes sketch). */ const char *scr_dyn_inspect_lite(const ScrDyn *v, char *buf, size_t cap); +ScrStr *scr_str_inspect_quoted(const ScrStr *s, bool truncate); /* A ladder's post-validation refuse: throws the compiler-rendered SC2020 * statement-fence text verbatim (Node's validation errors run first). */ SCR_COLD void scr_throw_lowering_fence(const ScrStr *msg); @@ -7682,6 +7683,8 @@ void scr_net_server_on_connection(ScrNetServer *s, ScrClosure *cb /*moves*/, Scr * server never fires it, like Node). */ void scr_net_server_on_secure_connection(ScrNetServer *s, ScrClosure *cb /*moves*/, ScrNetConnFn fn, bool once); ScrNetSocket *scr_net_connect(double port, ScrStr *host /*borrowed, nullable*/, ScrClosure *cb /*moves, nullable*/); /* +1 */ +ScrNetSocket *scr_net_connect_checked(double port, ScrStr *host /*borrowed, nullable*/, ScrClosure *cb /*moves, nullable*/); /* +1 */ +bool scr_net_host_chk(const ScrStr *host /*borrowed, nullable*/); /* connect with a validated autoSelectFamilyAttemptTimeout option: the * budget runs Node's validateInt32-from-1 ladder (ERR_OUT_OF_RANGE / * ERR_INVALID_ARG_TYPE) and is then inert — the single dial has nothing @@ -8134,6 +8137,7 @@ ScrDyn *scr_http_res_get_headers(ScrHttpRes *r); /* +1 */ bool scr_http_res_has_header_named(ScrHttpRes *r, ScrStr *name /*borrowed*/); void scr_http_res_remove_header(ScrHttpRes *r, ScrStr *name /*borrowed*/); void scr_http_res_on_finish(ScrHttpRes *r, ScrClosure *cb /*moves*/); +void scr_http_res_on_end_callback(ScrHttpRes *r, ScrClosure *cb /*moves*/); /* createServer({ joinDuplicateHeaders: true }): repeated request-header * names read back joined ", " (Node's option; the default keeps first). */ void scr_http_server_join_duplicate_headers(ScrNetServer *s); diff --git a/packages/runtime/src/scr_system_errors.h b/packages/runtime/src/scr_system_errors.h index 8997f12e7b..3ef542e678 100644 --- a/packages/runtime/src/scr_system_errors.h +++ b/packages/runtime/src/scr_system_errors.h @@ -22,7 +22,7 @@ #ifndef SCR_NODE_UV_ERRNO_H_ #define SCR_NODE_UV_ERRNO_H_ -/* Node v24.15.0, commit 848430679556aed0bd073f2bc263331ad84fa119. +/* Node v24.22.0, commit f14cd3aa7bf9ca8df2cc5b8bb14beb0f335b1d93. * libuv errno values and messages are part of node:util's observable API. * Kept independent of libuv so native binaries need no additional library. */ #include diff --git a/packages/runtime/src/scr_text_decoder_data.h b/packages/runtime/src/scr_text_decoder_data.h index 631026d780..ebf0602a33 100644 --- a/packages/runtime/src/scr_text_decoder_data.h +++ b/packages/runtime/src/scr_text_decoder_data.h @@ -1,4 +1,4 @@ -/* Generated by scripts/gen-text-decoder-tables.mjs with v24.15.0. Do not edit by hand. */ +/* Generated by scripts/gen-text-decoder-tables.mjs with v24.22.0. Do not edit by hand. */ #ifndef SCR_TEXT_DECODER_DATA_H #define SCR_TEXT_DECODER_DATA_H diff --git a/packages/runtime/src/scr_tls.c b/packages/runtime/src/scr_tls.c index fe1819350f..984be63f6e 100644 --- a/packages/runtime/src/scr_tls.c +++ b/packages/runtime/src/scr_tls.c @@ -1173,7 +1173,7 @@ ScrBytes *scr_tls_pem_from_dyn(const ScrDyn *v, const char *what) { * that changes Node-observable behavior must work or fence instead of * being dropped without an error. Undocumented keys drop, exactly Node. */ static const char *const SCR_TLS_SRV_FENCED_OPTIONS[] = { - "ALPNProtocols", "ALPNCallback", "allowHalfOpen", "ciphers", + "ALPNProtocols", "ALPNCallback", "allowHalfOpen", "certificateCompression", "ciphers", "clientCertEngine", "crl", "dhparam", "ecdhCurve", "enableTrace", "handshakeTimeout", "highWaterMark", "honorCipherOrder", "keepAlive", "keepAliveInitialDelay", "maxVersion", "minVersion", "noDelay", @@ -1472,7 +1472,7 @@ ScrNetServer *scr_https_create_server_dyn(const ScrDyn *opts /*borrowed*/, * throws (the server walk's stance). */ static const char *const SCR_TLS_CONNECT_FENCED_OPTIONS[] = { "ALPNProtocols", "allowHalfOpen", "autoSelectFamily", - "autoSelectFamilyAttemptTimeout", "cert", "checkServerIdentity", + "autoSelectFamilyAttemptTimeout", "cert", "certificateCompression", "checkServerIdentity", "ciphers", "clientCertEngine", "crl", "dhparam", "ecdhCurve", "enableTrace", "family", "fd", "hints", "highWaterMark", "honorCipherOrder", "keepAlive", "keepAliveInitialDelay", "key", @@ -1569,12 +1569,13 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable scr_dyn_arg_type_fail("options.port", "of type number", scr_dyn_undefined()); ok = false; } + ScrStr *dial_host = (ScrStr *)(host != NULL && host->len > 0 ? host : opt_host); + if (ok && !scr_net_host_chk(dial_host)) ok = false; if (!ok) { scr_bytes_release(ca); scr_closure_release(cb); return NULL; } - ScrStr *dial_host = (ScrStr *)(host != NULL && host->len > 0 ? host : opt_host); /* SNI + verification see the servername when given, the host name * otherwise (Node's servername default). */ ScrStr *verify_host = (ScrStr *)(servername != NULL ? servername : dial_host); diff --git a/packages/runtime/src/scr_url.c b/packages/runtime/src/scr_url.c index 9540e16412..28daf0f8d2 100644 --- a/packages/runtime/src/scr_url.c +++ b/packages/runtime/src/scr_url.c @@ -667,7 +667,6 @@ ScrUrl *scr_url_new(ScrStr *input) { u->query = query; u->fragment = fragment; u->has_authority = has_authority; - u->host_path_escape = false; u->sp_cache = NULL; u->sp_reload = NULL; return u; @@ -827,7 +826,7 @@ ScrStr *scr_url_pathname(ScrUrl *u) { return scr_str_retain(u->path); } * normalized form findRoute-style authority compares want (lowercased * host, no default :443/:80). */ ScrStr *scr_url_host(ScrUrl *u) { - if (u->port->len == 0 && !u->host_path_escape) return scr_str_retain(u->host); + if (u->port->len == 0) return scr_str_retain(u->host); UrlBuf b; ub_init(&b); ub_append(&b, u->host->data, u->host->len); @@ -835,7 +834,6 @@ ScrStr *scr_url_host(ScrUrl *u) { ub_push(&b, ':'); ub_append(&b, u->port->data, u->port->len); } - if (u->host_path_escape) ub_append(&b, "/.", 2); return ub_take(&b); } @@ -913,7 +911,7 @@ ScrStr *scr_url_href(ScrUrl *u) { } /* A host-less hierarchical path starting with // must not serialize * as an authority (the URL Standard's /. escape). */ - if (u->host_path_escape || (!u->has_authority && u->path->len >= 2 && !memcmp(u->path->data, "//", 2))) ub_append(&b, "/.", 2); + if (!u->has_authority && u->path->len >= 2 && !memcmp(u->path->data, "//", 2)) ub_append(&b, "/.", 2); ub_append(&b, u->path->data, u->path->len); ub_append(&b, u->query->data, u->query->len); ub_append(&b, u->fragment->data, u->fragment->len); @@ -946,7 +944,6 @@ static void url_copy_fields(ScrUrl *u, ScrUrl *next) { scr_str_release(u->query); u->query = scr_str_retain(next->query); scr_str_release(u->fragment); u->fragment = scr_str_retain(next->fragment); u->has_authority = next->has_authority; - u->host_path_escape = next->host_path_escape; } static bool url_file(ScrUrl *u) { @@ -999,9 +996,9 @@ static bool url_set_protocol(ScrUrl *u, const char *raw, size_t len) { if (is_special_scheme(u->scheme->data, u->scheme->len) != special || (file && (u->userinfo->len || u->port->len)) || (url_file(u) && !u->host->len)) { scr_str_release(scheme); - /* Ada reports a successful unchanged URL for non-special targets, - * so these writes still replace the pre-conversion snapshot in Node. */ - return !special; + /* Ada reports these state-override rejections as failed writes, so the + * live URL keeps its pre-conversion snapshot in Node. */ + return false; } scr_str_release(u->scheme); u->scheme = scheme; @@ -1057,10 +1054,7 @@ static bool url_set_host(ScrUrl *u, const char *raw, size_t len, bool hostname) scr_str_release(u->host); u->host = host; if (host->len || escaped_path) u->has_authority = true; - if (colon) { - u->host_path_escape = escaped_path; - if (end + 1 < len) url_set_port(u, raw + end + 1, len - end - 1, false); - } + if (colon && end + 1 < len) url_set_port(u, raw + end + 1, len - end - 1, false); return true; } @@ -1148,8 +1142,8 @@ bool scr_url_set_component(ScrUrl *u, ScrStr *field, ScrStr *value) { } if (field->len == 4 && !memcmp(field->data, "href", 4)) return url_apply_component(u, field, value); /* Node's binding reparses the captured href before applying an override. - * This matters after protocol writes to file://localhost and for the - * host-to-port serialization escape. Ignored overrides retain the live URL. */ + * This matters after protocol writes to file://localhost, which the + * reparse turns into an empty host. Ignored overrides retain the live URL. */ ScrStr *href = scr_url_href(u); ScrUrl *next = scr_url_new(href); scr_str_release(href); @@ -1342,7 +1336,6 @@ static ScrUrl *scr_url_new_file(ScrStr *host, ScrStr *encoded_path) { u->query = scr_str_new("", 0); u->fragment = scr_str_new("", 0); u->has_authority = true; - u->host_path_escape = false; u->sp_cache = NULL; u->sp_reload = NULL; return u; @@ -1701,8 +1694,10 @@ ScrSearchParams *scr_dyn_native_search_params_check(const ScrDyn *value, const S return scr_sp_retain(value->v.handle.ptr); } +/* new URLSearchParams(init): only undefined is the empty init; null takes + * the string branch like any other primitive ("null" parses as one key). */ ScrSearchParams *scr_sp_new_checked(const ScrDyn *value) { - if (!value || value->kind == SCR_DYN_UNDEF || value->kind == SCR_DYN_NULL) return scr_sp_new(); + if (!value || value->kind == SCR_DYN_UNDEF) return scr_sp_new(); if (scr_dyn_native_search_params_is(value)) return scr_sp_copy(value->v.handle.ptr); if (value->kind == SCR_DYN_OBJ || value->kind == SCR_DYN_ARR || value->kind == SCR_DYN_TYPED_REF) { ScrDyn *iterator = scr_dyn_iterator_optional(value); diff --git a/packages/runtime/src/scr_url_internal.h b/packages/runtime/src/scr_url_internal.h index 405bb89427..633cba79cd 100644 --- a/packages/runtime/src/scr_url_internal.h +++ b/packages/runtime/src/scr_url_internal.h @@ -18,9 +18,6 @@ struct ScrUrl { ScrStr *query; /* "" or "?..." */ ScrStr *fragment; /* "" or "#..." */ bool has_authority; - /* Node 24 preserves the /. serialization escape when a host setter - * enters port state from a host-less // path; pathname excludes it. */ - bool host_path_escape; /* The LIVE searchParams view (NULL until first read). NON-owning: the * view retains its URL, so a URL with a live view never dies; the view * clears this back-pointer when it releases. Every `u.searchParams` diff --git a/packages/runtime/src/scr_util_style.c b/packages/runtime/src/scr_util_style.c index 78e3a9b5f7..b41e90add0 100644 --- a/packages/runtime/src/scr_util_style.c +++ b/packages/runtime/src/scr_util_style.c @@ -101,7 +101,7 @@ static bool util_style_none(const ScrDyn *key) { !memcmp(key->v.str->data, "none", 4); } -static void util_style_invalid(const ScrDyn *key) { +static void util_style_invalid(const ScrDyn *key, bool hex) { ScrDyn *view = util_style_view(key); if (!view) return; ScrStr *shown = scr_insp_dyn(view, 0, 2); @@ -109,12 +109,16 @@ static void util_style_invalid(const ScrDyn *key) { if (!shown) return; ScrJsonBuf message; scr_jb_init(&message); - scr_jb_puts(&message, "The argument 'format' must be one of: "); - for (size_t i = 0; i < sizeof util_text_styles / sizeof util_text_styles[0]; i++) { - if (i) scr_jb_puts(&message, ", "); - scr_jb_putc(&message, '\''); - scr_jb_puts(&message, util_text_styles[i].name); - scr_jb_putc(&message, '\''); + if (hex) { + scr_jb_puts(&message, "The argument 'format' must be a valid hex color (#RGB or #RRGGBB)"); + } else { + scr_jb_puts(&message, "The argument 'format' must be one of: "); + for (size_t i = 0; i < sizeof util_text_styles / sizeof util_text_styles[0]; i++) { + if (i) scr_jb_puts(&message, ", "); + scr_jb_putc(&message, '\''); + scr_jb_puts(&message, util_text_styles[i].name); + scr_jb_putc(&message, '\''); + } } scr_jb_puts(&message, ". Received "); scr_jb_put_str(&message, shown); @@ -123,6 +127,29 @@ static void util_style_invalid(const ScrDyn *key) { scr_str_release(text); scr_str_release(shown); } +/* A string format starting with '#' names a 24-bit foreground color: + * 1 writes its open sequence for #RGB/#RRGGBB, -1 rejects other '#' + * strings, and 0 leaves every other format to the named styles. */ +static int util_style_hex(const ScrDyn *key, char open[32]) { + if (key->kind != SCR_DYN_STR || key->v.str->len == 0 || key->v.str->data[0] != '#') return 0; + const char *hex = key->v.str->data + 1; + size_t digits = key->v.str->len - 1; + if (digits != 3 && digits != 6) return -1; + unsigned value[6]; + for (size_t i = 0; i < digits; i++) { + char c = hex[i]; + if (c >= '0' && c <= '9') value[i] = (unsigned)(c - '0'); + else if (c >= 'a' && c <= 'f') value[i] = (unsigned)(c - 'a' + 10); + else if (c >= 'A' && c <= 'F') value[i] = (unsigned)(c - 'A' + 10); + else return -1; + } + unsigned rgb[3]; + for (size_t i = 0; i < 3; i++) + rgb[i] = digits == 3 ? value[i] * 17 : value[2 * i] * 16 + value[2 * i + 1]; + snprintf(open, 32, "\x1b[38;2;%u;%u;%um", rgb[0], rgb[1], rgb[2]); + return 1; +} + /* Reopen an outer style when a nested fragment closes it. Bold and dim * share 22, so preserve that reset before restoring either attribute. * A close at the very end is kept intact, matching Node's replacement. */ @@ -255,6 +282,19 @@ ScrStr *scr_util_style_text(const ScrDyn *format, const ScrDyn *text, const ScrD if (!scr_dyn_truthy(validate) && format->kind == SCR_DYN_STR && text->kind == SCR_DYN_STR) { if (util_style_none(format)) { scr_dyn_release(validate); return scr_str_retain(text->v.str); } fast = util_style_lookup(format); + char open[32]; + if (!fast && util_style_hex(format, open) == 1) { + static const char close[] = "\x1b[39m"; + ScrStr *processed = util_style_replace(text->v.str, close, open, false); + ScrJsonBuf styled; + scr_jb_init(&styled); + scr_jb_puts(&styled, open); + scr_jb_put_str(&styled, processed); + scr_jb_puts(&styled, close); + scr_str_release(processed); + scr_dyn_release(validate); + return scr_jb_finish(&styled); + } } bool colorize = true; ScrDyn *view = NULL, *stream = NULL; @@ -307,21 +347,33 @@ ScrStr *scr_util_style_text(const ScrDyn *format, const ScrDyn *text, const ScrD for (size_t i = 0; i < count; i++) { const ScrDyn *key = view->kind == SCR_DYN_ARR ? view->v.arr.items[i] : view; if (util_style_none(key)) continue; - const ScrTextStyle *style = util_style_lookup(key); - if (!style) { - if (!scr_exc_pending()) util_style_invalid(key); + char open[32], close[16]; + int hex = util_style_hex(key, open); + if (hex < 0) { + util_style_invalid(key, true); scr_str_release(scr_jb_finish(&opens)); scr_str_release(scr_jb_finish(&closes)); goto done; } - char open[16], close[16]; - snprintf(open, sizeof open, "\x1b[%um", style->open); - snprintf(close, sizeof close, "\x1b[%um", style->close); + const ScrTextStyle *style = hex ? NULL : util_style_lookup(key); + if (hex) { + /* Node skips a hex color's sequences when the stream does not + * colorize; later formats are still validated. */ + if (!colorize) continue; + snprintf(close, sizeof close, "\x1b[39m"); + } else if (!style) { + if (!scr_exc_pending()) util_style_invalid(key, false); + scr_str_release(scr_jb_finish(&opens)); scr_str_release(scr_jb_finish(&closes)); goto done; + } else { + snprintf(open, sizeof open, "\x1b[%um", style->open); + snprintf(close, sizeof close, "\x1b[%um", style->close); + } scr_jb_puts(&opens, open); size_t n = strlen(close); scr_jb_puts(&closes, close); /* Prepend each closing sequence so the outer formats close last. */ memmove(closes.data + n, closes.data, closes.len - n); memcpy(closes.data, close, n); - ScrStr *next = util_style_replace(processed, close, open, style->open == 1 || style->open == 2); + ScrStr *next = util_style_replace(processed, close, open, + style != NULL && (style->open == 1 || style->open == 2)); scr_str_release(processed); processed = next; } if (colorize) { diff --git a/packages/runtime/test/url-legacy-cases.txt b/packages/runtime/test/url-legacy-cases.txt index 2867f62507..55fc05ad23 100644 --- a/packages/runtime/test/url-legacy-cases.txt +++ b/packages/runtime/test/url-legacy-cases.txt @@ -28,12 +28,12 @@ a -x.com -x.com u -x.com -x.com a x-.com x-.com u x-.com x-.com -a xn--.com -u xn--.com -a xn--a.com -u xn--a.com -a xn--xn--a.com -u xn--xn--a.com +a xn--.com xn--.com +u xn--.com xn--.com +a xn--a.com xn--a.com +u xn--a.com xn--a.com +a xn--xn--a.com xn--xn--a.com +u xn--xn--a.com xn--xn--a.com a xn--ls8h.la xn--ls8h.la u xn--ls8h.la \ud83d\udca9.la a \ud83d\udca9.la xn--ls8h.la @@ -50,12 +50,12 @@ a \u0628.com xn--ngb.com u \u0628.com \u0628.com a \u05d0\u05d1.com xn--4dbc.com u \u05d0\u05d1.com \u05d0\u05d1.com -a a\u05d0.com xn--a-0hc.com -u a\u05d0.com a\u05d0.com +a a\u05d0.com +u a\u05d0.com a \u05d01.com xn--1-zhc.com u \u05d01.com \u05d01.com -a 1\u05d0.com xn--1-0hc.com -u 1\u05d0.com 1\u05d0.com +a 1\u05d0.com +u 1\u05d0.com a \u0628\u06611.com u \u0628\u06611.com a \u0301a.com @@ -654,11 +654,11 @@ p 1 http://a%20b/ {"protocol":"http:","slashes":true,"auth":null,"host":"a","por p 2 http://a%20b/ {"protocol":"http:","slashes":true,"auth":null,"host":"a","port":null,"hostname":"a","hash":null,"search":null,"query":null,"pathname":"%20b/","path":"%20b/","href":"http://a/%20b/"} p 3 http://a%20b/ {"protocol":"http:","slashes":true,"auth":null,"host":"a","port":null,"hostname":"a","hash":null,"search":null,"query":{},"pathname":"%20b/","path":"%20b/","href":"http://a/%20b/"} f http://a%20b/ http://a/%20b/ -p 0 http://xn--zz/ E:ERR_INVALID_URL -p 1 http://xn--zz/ E:ERR_INVALID_URL -p 2 http://xn--zz/ E:ERR_INVALID_URL -p 3 http://xn--zz/ E:ERR_INVALID_URL -f http://xn--zz/ E:ERR_INVALID_URL +p 0 http://xn--zz/ {"protocol":"http:","slashes":true,"auth":null,"host":"xn--zz","port":null,"hostname":"xn--zz","hash":null,"search":null,"query":null,"pathname":"/","path":"/","href":"http://xn--zz/"} +p 1 http://xn--zz/ {"protocol":"http:","slashes":true,"auth":null,"host":"xn--zz","port":null,"hostname":"xn--zz","hash":null,"search":null,"query":{},"pathname":"/","path":"/","href":"http://xn--zz/"} +p 2 http://xn--zz/ {"protocol":"http:","slashes":true,"auth":null,"host":"xn--zz","port":null,"hostname":"xn--zz","hash":null,"search":null,"query":null,"pathname":"/","path":"/","href":"http://xn--zz/"} +p 3 http://xn--zz/ {"protocol":"http:","slashes":true,"auth":null,"host":"xn--zz","port":null,"hostname":"xn--zz","hash":null,"search":null,"query":{},"pathname":"/","path":"/","href":"http://xn--zz/"} +f http://xn--zz/ http://xn--zz/ p 0 http://xn--espaol-zwa.com/ {"protocol":"http:","slashes":true,"auth":null,"host":"xn--espaol-zwa.com","port":null,"hostname":"xn--espaol-zwa.com","hash":null,"search":null,"query":null,"pathname":"/","path":"/","href":"http://xn--espaol-zwa.com/"} p 1 http://xn--espaol-zwa.com/ {"protocol":"http:","slashes":true,"auth":null,"host":"xn--espaol-zwa.com","port":null,"hostname":"xn--espaol-zwa.com","hash":null,"search":null,"query":{},"pathname":"/","path":"/","href":"http://xn--espaol-zwa.com/"} p 2 http://xn--espaol-zwa.com/ {"protocol":"http:","slashes":true,"auth":null,"host":"xn--espaol-zwa.com","port":null,"hostname":"xn--espaol-zwa.com","hash":null,"search":null,"query":null,"pathname":"/","path":"/","href":"http://xn--espaol-zwa.com/"} @@ -2095,8 +2095,8 @@ a xn--fiq228ca\ufb00] u xn--fiq228ca\ufb00] a \ud83d\udca9\u200d u \ud83d\udca9\u200d -a xn--_ -u xn--_ +a xn--_ xn--_ +u xn--_ xn--_ a \u0301 u \u0301 a \u200d\u0915256xn--fiq228c @@ -2141,8 +2141,8 @@ a 256/xn--\uff21\u4e2d 0.0.1.0 u 256/xn--\uff21\u4e2d 0.0.1.0 a 0x.]\u2488 u 0x.]\u2488 -a xn--zz -u xn--zz +a xn--zz xn--zz +u xn--zz xn--zz a %41 a u %41 a a %2e . @@ -2225,8 +2225,8 @@ a \u3002\u00e9:\ufb00#- u \u3002\u00e9:\ufb00#- a \u05d0\ud83d\udca91 xn--1-zhc75119a u \u05d0\ud83d\udca91 \u05d0\ud83d\udca91 -a \u00df0x_\u0661 xn--0x_-4ka761e -u \u00df0x_\u0661 \u00df0x_\u0661 +a \u00df0x_\u0661 +u \u00df0x_\u0661 a \ud800[0x\u05d0B u \ud800[0x\u05d0B a 255256\u00ad%41\u05d0B @@ -2293,8 +2293,8 @@ a u a B\u05d0\u4e2d:%41 u B\u05d0\u4e2d:%41 -a \u00df\u0628\u0301 xn--zca60if4d -u \u00df\u0628\u0301 \u00df\u0628\u0301 +a \u00df\u0628\u0301 +u \u00df\u0628\u0301 a :0x1%41. u :0x1%41. a 1.: @@ -2319,8 +2319,8 @@ a 1\u0009255\u0301/\ud83d\udca9\u0628 xn--1255-yvc u 1\u0009255\u0301/\ud83d\udca9\u0628 1255\u0301 a :- u :- -a xn-- -u xn-- +a xn-- xn-- +u xn-- xn-- a 2560x\ufb00\u0915\u0915%2e\u094d%41 u 2560x\ufb00\u0915\u0915%2e\u094d%41 a %2exn--fiq228c\u0628\u0628::255\u00e9a @@ -2359,12 +2359,12 @@ a /256 u /256 a @-256@ u @-256@ -a xn--?:\u3002[?B -u xn--?:\u3002[?B +a xn--?:\u3002[?B xn-- +u xn--?:\u3002[?B xn-- a _\u00e9256\u1e9e% u _\u00e9256\u1e9e% -a \u00df\u05d0??? xn--zca44w -u \u00df\u05d0??? \u00df\u05d0 +a \u00df\u05d0??? +u \u00df\u05d0??? a [\u1e9exn-- u [\u1e9exn-- a \u0009xn--\u4e2d\u200cxn--fiq228c\u00df @@ -2425,10 +2425,10 @@ a #::? u #::? a \u0628 xn--ngb u \u0628 \u0628 -a xn--zz/\u0628xn--fiq228c\ufb00256_] -u xn--zz/\u0628xn--fiq228c\ufb00256_] +a xn--zz/\u0628xn--fiq228c\ufb00256_] xn--zz +u xn--zz/\u0628xn--fiq228c\ufb00256_] xn--zz a \u00dfxn--%4111\u0915\u0009 xn--xn--a11-zva930q -u \u00dfxn--%4111\u0915\u0009 xn--xn--a11-zva930q +u \u00dfxn--%4111\u0915\u0009 \u00dfxn--a11\u0915 a :1?::\u3002\u05d0 u :1?::\u3002\u05d0 a a\u200d## @@ -2582,7 +2582,7 @@ u \u0628\u09150x/ a /a[%\u3002\u200d u /a[%\u3002\u200d a \u4e2dxn--zz#\u094d@ xn--xn--zz-9v7i -u \u4e2dxn--zz#\u094d@ xn--xn--zz-9v7i +u \u4e2dxn--zz#\u094d@ \u4e2dxn--zz a 1%41\u4e2d%2e\ud800_ u 1%41\u4e2d%2e\ud800_ a \u4e2d\u00e9\u05d0\u4e2d\u3002[\u4e2dxn-- @@ -2661,8 +2661,8 @@ a \u00df\ud83d\udca9 xn--zca6007w u \u00df\ud83d\udca9 \u00df\ud83d\udca9 a \u200d255xn--fiq228c? u \u200d255xn--fiq228c? -a \u1e9e\u00e9_\u05d0\u3002\u0009a xn--_-pfa4a303b.a -u \u1e9e\u00e9_\u05d0\u3002\u0009a \u00df\u00e9_\u05d0.a +a \u1e9e\u00e9_\u05d0\u3002\u0009a +u \u1e9e\u00e9_\u05d0\u3002\u0009a a 0x\u0301 \uff21::\u0915\u200d\u05d0 u 0x\u0301 \uff21::\u0915\u200d\u05d0 a 256\u200c- @@ -2717,8 +2717,8 @@ a 1\u00e9#]]B xn--1-bga u 1\u00e9#]]B 1\u00e9 a ?%2e]\u2488%41xn--fiq228ca/ u ?%2e]\u2488%41xn--fiq228ca/ -a \u4e2d\u0628 xn--ngb7897a -u \u4e2d\u0628 \u4e2d\u0628 +a \u4e2d\u0628 +u \u4e2d\u0628 a ? u ? a 1\u05d0\uff21 @@ -2773,8 +2773,8 @@ a xn--B::%41:]. u xn--B::%41:]. a 255\u2488\ufb00\u05d0 u 255\u2488\ufb00\u05d0 -a \u0661 xn--9hb -u \u0661 \u0661 +a \u0661 +u \u0661 a ::xn--fiq228c%41%2e[]xn--fiq228c\ud800 u ::xn--fiq228c%41%2e[]xn--fiq228c\ud800 a 256//255\u1e9e\u1e9e?255 0.0.1.0 @@ -2824,13 +2824,13 @@ u \u3002%:a. a -1 -1 u -1 -1 a \u1e9exn--zz\u00dfxn--1 xn--xn--zzxn--1-u6ag -u \u1e9exn--zz\u00dfxn--1 xn--xn--zzxn--1-u6ag +u \u1e9exn--zz\u00dfxn--1 \u00dfxn--zz\u00dfxn--1 a 0x256xn--fiq228cxn--fiq228c%# [ u 0x256xn--fiq228cxn--fiq228c%# [ a \u00091a \u0301_ u \u00091a \u0301_ -a \ud83d\udca9\ud83d\udca9\u05d0/%-\u0915 xn--4db5744wa -u \ud83d\udca9\ud83d\udca9\u05d0/%-\u0915 \ud83d\udca9\ud83d\udca9\u05d0 +a \ud83d\udca9\ud83d\udca9\u05d0/%-\u0915 +u \ud83d\udca9\ud83d\udca9\u05d0/%-\u0915 a %41xn--fiq228c256\u0915\u200c\ud83d\udca9 u %41xn--fiq228c256\u0915\u200c\ud83d\udca9 a \u00df__/-B xn--__-fia @@ -2905,8 +2905,8 @@ a \u06280xxn--zza u \u06280xxn--zza a \u2488#\u05d0 u \u2488#\u05d0 -a \u0661#\u200c\u0009::\ud83d\udca9 xn--9hb -u \u0661#\u200c\u0009::\ud83d\udca9 \u0661 +a \u0661#\u200c\u0009::\ud83d\udca9 +u \u0661#\u200c\u0009::\ud83d\udca9 a 0x\u0661 u 0x\u0661 a @\u00e9-\u3002\u05d0\u200c: @@ -2920,7 +2920,7 @@ u .\u00092561. a ?\ud83d\udca9]\u00e9\u00ad u ?\ud83d\udca9]\u00e9\u00ad a \u1e9exn-- xn--xn---una -u \u1e9exn-- xn--xn---una +u \u1e9exn-- \u00dfxn-- a \u094d-\u1e9e\u0009\u200c u \u094d-\u1e9e\u0009\u200c a \u0301255256%[\u00df\u05d0 @@ -2960,7 +2960,7 @@ u \u200c\u0661 a \ufb00\u0915xn--- xn--ffxn----imo u \ufb00\u0915xn--- ff\u0915xn--- a \uff21\u3002\ud83d\udca9\u0301xn--fiq228c\uff21? a.xn--xn--fiq228ca-d2g31749o -u \uff21\u3002\ud83d\udca9\u0301xn--fiq228c\uff21? a.xn--xn--fiq228ca-d2g31749o +u \uff21\u3002\ud83d\udca9\u0301xn--fiq228c\uff21? a.\ud83d\udca9\u0301xn--fiq228ca a \u0661xn--\u4e2d u \u0661xn--\u4e2d a /\u00e9 @@ -3105,8 +3105,8 @@ a \u00ad_xn--/1\ud800xn--fiq228c _xn-- u \u00ad_xn--/1\ud800xn--fiq228c _xn-- a xn--\u0915_a u xn--\u0915_a -a a\u05d0 xn--a-0hc -u a\u05d0 a\u05d0 +a a\u05d0 +u a\u05d0 a BB\u00e9..\u0628@ u BB\u00e9..\u0628@ a \ud83d\udca9%\ud83d\udca9\u200dxn--1\ud83d\udca9\ud800 @@ -3159,8 +3159,8 @@ a \u094d1:\u0915\u200c::a u \u094d1:\u0915\u200c::a a \u3002\u0628xn--zz@\u0009% u \u3002\u0628xn--zz@\u0009% -a xn--zz?\u0301\u2488\u094d\u00df1 -u xn--zz?\u0301\u2488\u094d\u00df1 +a xn--zz?\u0301\u2488\u094d\u00df1 xn--zz +u xn--zz?\u0301\u2488\u094d\u00df1 xn--zz a \u0009\u2488 u \u0009\u2488 a \ufb00\u0301[:: @@ -3249,8 +3249,8 @@ a _%41\u06610x u _%41\u06610x a 0x/1#\u200c#\u200c\u3002 0.0.0.0 u 0x/1#\u200c#\u200c\u3002 0.0.0.0 -a xn--fiq228cxn--zz -u xn--fiq228cxn--zz +a xn--fiq228cxn--zz xn--fiq228cxn--zz +u xn--fiq228cxn--zz xn--fiq228cxn--zz a 1\u0661_? u 1\u0661_? a 255\u1e9e%41256\uff21@\uff21 @@ -3273,14 +3273,14 @@ a \u0915a1xn--fiq228c xn--a1xn--fiq228c-2dz u \u0915a1xn--fiq228c \u0915a1xn--fiq228c a xn--fiq228c\u0301\u0009 u xn--fiq228c\u0301\u0009 -a \u0661.\ud83d\udca9\u0628/10x xn--9hb.xn--ngb9924w -u \u0661.\ud83d\udca9\u0628/10x \u0661.\ud83d\udca9\u0628 +a \u0661.\ud83d\udca9\u0628/10x +u \u0661.\ud83d\udca9\u0628/10x a 1%41 1a u 1%41 1a a \u00df\u00ad\ud8000x\u0301\u0301- u \u00df\u00ad\ud8000x\u0301\u0301- -a \u0661\u0009 xn--9hb -u \u0661\u0009 \u0661 +a \u0661\u0009 +u \u0661\u0009 a .256\u200c u .256\u200c a \u4e2d\u200cB@ \u4e2d\u00e9 @@ -3395,8 +3395,8 @@ a 256\u2488 u 256\u2488 a \u30021\ud83d\udca9\ud83d\udca9 .xn--1-xb3sa u \u30021\ud83d\udca9\ud83d\udca9 .1\ud83d\udca9\ud83d\udca9 -a \u00df\u0915B255\u00df\u00ad\u0628 xn--b255-unae585gb5f -u \u00df\u0915B255\u00df\u00ad\u0628 \u00df\u0915b255\u00df\u0628 +a \u00df\u0915B255\u00df\u00ad\u0628 +u \u00df\u0915B255\u00df\u00ad\u0628 a \ud800-.\u4e2d#/ u \ud800-.\u4e2d#/ a %41\u03011\u3002%41\u2488\u30021 @@ -3549,8 +3549,8 @@ a \u0301\u00ad u \u0301\u00ad a 0x\ud800\u200d\uff21 u 0x\ud800\u200d\uff21 -a xn--1 -u xn--1 +a xn--1 xn--1 +u xn--1 xn--1 a \u094d\u094d%41.\u0301\u00df u \u094d\u094d%41.\u0301\u00df a @ \u0009:256.\ud83d\udca91 @@ -3673,8 +3673,8 @@ a ?\u0915B u ?\u0915B a \u00e9\u00e9\ud800\u0628- u \u00e9\u00e9\ud800\u0628- -a \u0661. xn--9hb. -u \u0661. \u0661. +a \u0661. +u \u0661. a .xn--fiq228c]\ufb00\u00ad\u4e2d\u1e9e u .xn--fiq228c]\ufb00\u00ad\u4e2d\u1e9e a xn--zz\u0628 @@ -3708,7 +3708,7 @@ u \u0301.xn-- a ]0x. u ]0x. a \u0915xn--xn--fiq228c1xn--fiq228cB255 xn--xn--xn--fiq228c1xn--fiq228cb255-yn1d -u \u0915xn--xn--fiq228c1xn--fiq228cB255 xn--xn--xn--fiq228c1xn--fiq228cb255-yn1d +u \u0915xn--xn--fiq228c1xn--fiq228cB255 \u0915xn--xn--fiq228c1xn--fiq228cb255 a \u200c[\u3002%2e\u3002@ u \u200c[\u3002%2e\u3002@ a \ud83d\udca9xn--fiq228c\u0661\u1e9e @@ -3723,8 +3723,8 @@ a %41 \u2488\u094d\u0661 u %41 \u2488\u094d\u0661 a -\u2488/:_\u00ad1] u -\u2488/:_\u00ad1] -a %2e\u0661 .xn--9hb -u %2e\u0661 .\u0661 +a %2e\u0661 +u %2e\u0661 a ?\u3002a%2e% u ?\u3002a%2e% a xn--fiq228c\u094d [\u0661\u0661\u094d @@ -3757,16 +3757,16 @@ a \u0628255%2eB xn--255-rze.b u \u0628255%2eB \u0628255.b a %41B\uff21 aba u %41B\uff21 aba -a \uff21\u05d0\u00ad xn--a-0hc -u \uff21\u05d0\u00ad a\u05d0 +a \uff21\u05d0\u00ad +u \uff21\u05d0\u00ad a xn--\u00df_\u4e2d\u4e2d]\u2488 u xn--\u00df_\u4e2d\u4e2d]\u2488 -a \u0915\u0009\u0915\u0628?_\ud83d\udca9 xn--ngb11ma -u \u0915\u0009\u0915\u0628?_\ud83d\udca9 \u0915\u0915\u0628 +a \u0915\u0009\u0915\u0628?_\ud83d\udca9 +u \u0915\u0009\u0915\u0628?_\ud83d\udca9 a \u00df\u00df\u00ad xn--zcaa u \u00df\u00df\u00ad \u00df\u00df a \uff21%2e\u4e2dxn-- a.xn--xn---zf5f -u \uff21%2e\u4e2dxn-- a.xn--xn---zf5f +u \uff21%2e\u4e2dxn-- a.\u4e2dxn-- a 1\u094d\u094d\ud83d\udca9::256 u 1\u094d\u094d\ud83d\udca9::256 a \u3002-\u200d\u2488\u00ad\u094d @@ -3863,8 +3863,8 @@ a \u05d0[a/ u \u05d0[a/ a %2e\uff21\uff21..xn--fiq228c .aa..xn--fiq228c u %2e\uff21\uff21..xn--fiq228c .aa..\u4e2d\u6587 -a xn--zz/\u200dxn--a -u xn--zz/\u200dxn--a +a xn--zz/\u200dxn--a xn--zz +u xn--zz/\u200dxn--a xn--zz a \u3002\u05d0?/ .xn--4db u \u3002\u05d0?/ .\u05d0 a \u0301::\u0915\u00ad\u094d @@ -3985,8 +3985,8 @@ a 256\u3002\u00091\u0301 256.xn--1-xbb u 256\u3002\u00091\u0301 256.1\u0301 a \u00df\uff21.1#\u0301\u0628 u \u00df\uff21.1#\u0301\u0628 -a xn--fiq228c1 -u xn--fiq228c1 +a xn--fiq228c1 xn--fiq228c1 +u xn--fiq228c1 xn--fiq228c1 a %41\ud83d\udca9-@:\u094d u %41\ud83d\udca9-@:\u094d a axn--zz axn--zz @@ -4121,8 +4121,8 @@ a ?B u ?B a \u00e9@?\u1e9e/\uff210x u \u00e9@?\u1e9e/\uff210x -a \u0661\u3002\u3002\u4e2d\u00df\u0009255_ xn--9hb..xn--255_-una3589i -u \u0661\u3002\u3002\u4e2d\u00df\u0009255_ \u0661..\u4e2d\u00df255_ +a \u0661\u3002\u3002\u4e2d\u00df\u0009255_ +u \u0661\u3002\u3002\u4e2d\u00df\u0009255_ a 0x\u094d xn--0x-gsf u 0x\u094d 0x\u094d a xn--zz\u05d0\u24880x0x @@ -4141,8 +4141,8 @@ a \u00e9 u \u00e9 a \u200c0xxn--%2e%41\u05d01 u \u200c0xxn--%2e%41\u05d01 -a xn--zz255 -u xn--zz255 +a xn--zz255 xn--zz255 +u xn--zz255 xn--zz255 a xn--]\u4e2d \u00df/: u xn--]\u4e2d \u00df/: a \u00ad\u0628xn--1\ufb00\u094d? @@ -4295,8 +4295,8 @@ a xn--fiq228c%41 - u xn--fiq228c%41 - a :::\u0661:: u :::\u0661:: -a xn--/ -u xn--/ +a xn--/ xn-- +u xn--/ xn-- a 1255\u0009a 1255a u 1255\u0009a 1255a a \u0301-\u0661\ud800[\u1e9e::xn--fiq228c @@ -4447,8 +4447,8 @@ a ..\u0009 .. u ..\u0009 .. a /xn--fiq228c\u4e2d\u200c? u /xn--fiq228c\u4e2d\u200c? -a \u00e9\u05d0\u0301?_256\u0628\u0628 xn--9ca68hv9c -u \u00e9\u05d0\u0301?_256\u0628\u0628 \u00e9\u05d0\u0301 +a \u00e9\u05d0\u0301?_256\u0628\u0628 +u \u00e9\u05d0\u0301?_256\u0628\u0628 a \u05d0\u200c::0xB\uff21\u0301 u \u05d0\u200c::0xB\uff21\u0301 a ::1xn--fiq228c0x255?? @@ -4457,12 +4457,12 @@ a \u4e2dxn--zz\u0301 \uff21 u \u4e2dxn--zz\u0301 \uff21 a [\u0915\u0915\u0009\u200d\u0009\u0661? u [\u0915\u0915\u0009\u200d\u0009\u0661? -a BB\u0628 xn--bb-gtd -u BB\u0628 bb\u0628 +a BB\u0628 +u BB\u0628 a 25510x0x\u1e9e xn--25510x0x-xya u 25510x0x\u1e9e 25510x0x\u00df -a \u1e9e\u05d0 xn--zca44w -u \u1e9e\u05d0 \u00df\u05d0 +a \u1e9e\u05d0 +u \u1e9e\u05d0 a \u094d.axn--zz256 u \u094d.axn--zz256 a \u00e9?\u05d0\u3002\ufb00\u2488\u4e2d\u00df xn--9ca @@ -4537,8 +4537,8 @@ a _B#B _b u _B#B _b a :1 -\u00df u :1 -\u00df -a \u00df\ufb00\u05d0 xn--ff-fia671c -u \u00df\ufb00\u05d0 \u00dfff\u05d0 +a \u00df\ufb00\u05d0 +u \u00df\ufb00\u05d0 a xn--fiq228c\u1e9e\u1e9e\u0628::\u200d u xn--fiq228c\u1e9e\u1e9e\u0628::\u200d a xn--zz]a\u200c\uff21 @@ -4593,8 +4593,8 @@ a ::[\u00dfxn--zz u ::[\u00dfxn--zz a %41/\u3002\u00df\u4e2d::B a u %41/\u3002\u00df\u4e2d::B a -a 256\u0628 xn--256-uze -u 256\u0628 256\u0628 +a 256\u0628 +u 256\u0628 a \u00df/\u094d\u4e2d%41 xn--zca u \u00df/\u094d\u4e2d%41 \u00df a #\u09151\ufb00\u00df\u06280x\u0915 @@ -4655,8 +4655,8 @@ a @%2eB\u0915\u00df.\u094d u @%2eB\u0915\u00df.\u094d a :\u0301255:\u094d\u00df\u094d u :\u0301255:\u094d\u00df\u094d -a \ufb00\u00e9-\u0628 xn--ff--cma038d -u \ufb00\u00e9-\u0628 ff\u00e9-\u0628 +a \ufb00\u00e9-\u0628 +u \ufb00\u00e9-\u0628 a \u06611\u05d01@:0x u \u06611\u05d01@:0x a \u3002\u094d @@ -4669,8 +4669,8 @@ a .\uff21\u00df\ud83d\udca9- .xn--a--gia89822c u .\uff21\u00df\ud83d\udca9- .a\u00df\ud83d\udca9- a a256\ud83d\udca9\u094d:\u200d u a256\ud83d\udca9\u094d:\u200d -a xn--zz11 -u xn--zz11 +a xn--zz11 xn--zz11 +u xn--zz11 xn--zz11 a \u200c.%\u00ad1 \ud800 u \u200c.%\u00ad1 \ud800 a \u1e9e_\ud83d\udca9/]\u0915 xn--_-pfa35949a @@ -6336,11 +6336,11 @@ p 1 [\ud83d\udca9foo:\ud800%C3%A9foo:?%\u05d0 {"protocol":null,"slashes":null,"a p 2 [\ud83d\udca9foo:\ud800%C3%A9foo:?%\u05d0 {"protocol":null,"slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":"?%\u05d0","query":"%\u05d0","pathname":"[\ud83d\udca9foo:\u005cud800%C3%A9foo:","path":"[\ud83d\udca9foo:\u005cud800%C3%A9foo:?%\u05d0","href":"[\ud83d\udca9foo:\u005cud800%C3%A9foo:?%\u05d0"} p 3 [\ud83d\udca9foo:\ud800%C3%A9foo:?%\u05d0 {"protocol":null,"slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":"?%\u05d0","query":{"%\u05d0":""},"pathname":"[\ud83d\udca9foo:\u005cud800%C3%A9foo:","path":"[\ud83d\udca9foo:\u005cud800%C3%A9foo:?%\u05d0","href":"[\ud83d\udca9foo:\u005cud800%C3%A9foo:?%\u05d0"} f [\ud83d\udca9foo:\ud800%C3%A9foo:?%\u05d0 [\ud83d\udca9foo:\ud800%C3%A9foo:?%\u05d0 -p 0 +http:\ud83d\udca9\u06281.2.3.4>#\u0009\u0301 {"protocol":"+http:","slashes":null,"auth":null,"host":"xn--1-0mc29809a.2.3.4","port":null,"hostname":"xn--1-0mc29809a.2.3.4","hash":"#%09\u0301","search":null,"query":null,"pathname":"%3E","path":"%3E","href":"+http:xn--1-0mc29809a.2.3.4%3E#%09\u0301"} -p 1 +http:\ud83d\udca9\u06281.2.3.4>#\u0009\u0301 {"protocol":"+http:","slashes":null,"auth":null,"host":"xn--1-0mc29809a.2.3.4","port":null,"hostname":"xn--1-0mc29809a.2.3.4","hash":"#%09\u0301","search":null,"query":{},"pathname":"%3E","path":"%3E","href":"+http:xn--1-0mc29809a.2.3.4%3E#%09\u0301"} -p 2 +http:\ud83d\udca9\u06281.2.3.4>#\u0009\u0301 {"protocol":"+http:","slashes":null,"auth":null,"host":"xn--1-0mc29809a.2.3.4","port":null,"hostname":"xn--1-0mc29809a.2.3.4","hash":"#%09\u0301","search":null,"query":null,"pathname":"%3E","path":"%3E","href":"+http:xn--1-0mc29809a.2.3.4%3E#%09\u0301"} -p 3 +http:\ud83d\udca9\u06281.2.3.4>#\u0009\u0301 {"protocol":"+http:","slashes":null,"auth":null,"host":"xn--1-0mc29809a.2.3.4","port":null,"hostname":"xn--1-0mc29809a.2.3.4","hash":"#%09\u0301","search":null,"query":{},"pathname":"%3E","path":"%3E","href":"+http:xn--1-0mc29809a.2.3.4%3E#%09\u0301"} -f +http:\ud83d\udca9\u06281.2.3.4>#\u0009\u0301 +http:xn--1-0mc29809a.2.3.4%3E#%09\u0301 +p 0 +http:\ud83d\udca9\u06281.2.3.4>#\u0009\u0301 E:ERR_INVALID_URL +p 1 +http:\ud83d\udca9\u06281.2.3.4>#\u0009\u0301 E:ERR_INVALID_URL +p 2 +http:\ud83d\udca9\u06281.2.3.4>#\u0009\u0301 E:ERR_INVALID_URL +p 3 +http:\ud83d\udca9\u06281.2.3.4>#\u0009\u0301 E:ERR_INVALID_URL +f +http:\ud83d\udca9\u06281.2.3.4>#\u0009\u0301 E:ERR_INVALID_URL p 0 ;http:x-y%C3%A9\u0009file: {"protocol":null,"slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":null,"pathname":";http:x-y%C3%A9%09file:","path":";http:x-y%C3%A9%09file:","href":";http:x-y%C3%A9%09file:"} p 1 ;http:x-y%C3%A9\u0009file: {"protocol":null,"slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":{},"pathname":";http:x-y%C3%A9%09file:","path":";http:x-y%C3%A9%09file:","href":";http:x-y%C3%A9%09file:"} p 2 ;http:x-y%C3%A9\u0009file: {"protocol":null,"slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":null,"pathname":";http:x-y%C3%A9%09file:","path":";http:x-y%C3%A9%09file:","href":";http:x-y%C3%A9%09file:"} @@ -6611,11 +6611,11 @@ p 1 \u00e9::1c.com%C3%A9.[\u00df&\u4e2d {"protocol":null,"slashes":null,"auth":n p 2 \u00e9::1c.com%C3%A9.[\u00df&\u4e2d {"protocol":null,"slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":null,"pathname":"\u00e9::1c.com%C3%A9.[\u00df&\u4e2d","path":"\u00e9::1c.com%C3%A9.[\u00df&\u4e2d","href":"\u00e9::1c.com%C3%A9.[\u00df&\u4e2d"} p 3 \u00e9::1c.com%C3%A9.[\u00df&\u4e2d {"protocol":null,"slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":{},"pathname":"\u00e9::1c.com%C3%A9.[\u00df&\u4e2d","path":"\u00e9::1c.com%C3%A9.[\u00df&\u4e2d","href":"\u00e9::1c.com%C3%A9.[\u00df&\u4e2d"} f \u00e9::1c.com%C3%A9.[\u00df&\u4e2d \u00e9::1c.com%C3%A9.[\u00df&\u4e2d -p 0 xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df= E:ERR_INVALID_URL -p 1 xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df= E:ERR_INVALID_URL -p 2 xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df= E:ERR_INVALID_URL -p 3 xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df= E:ERR_INVALID_URL -f xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df= E:ERR_INVALID_URL +p 0 xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df= {"protocol":"xn--fiq228cws:","slashes":null,"auth":null,"host":"xn--","port":null,"hostname":"xn--","hash":null,"search":"?\u00e9%zzxn--fiq228c\u00df=","query":"\u00e9%zzxn--fiq228c\u00df=","pathname":null,"path":"?\u00e9%zzxn--fiq228c\u00df=","href":"xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df="} +p 1 xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df= {"protocol":"xn--fiq228cws:","slashes":null,"auth":null,"host":"xn--","port":null,"hostname":"xn--","hash":null,"search":"?\u00e9%zzxn--fiq228c\u00df=","query":{"\u00e9%zzxn--fiq228c\u00df":""},"pathname":null,"path":"?\u00e9%zzxn--fiq228c\u00df=","href":"xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df="} +p 2 xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df= {"protocol":"xn--fiq228cws:","slashes":null,"auth":null,"host":"xn--","port":null,"hostname":"xn--","hash":null,"search":"?\u00e9%zzxn--fiq228c\u00df=","query":"\u00e9%zzxn--fiq228c\u00df=","pathname":null,"path":"?\u00e9%zzxn--fiq228c\u00df=","href":"xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df="} +p 3 xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df= {"protocol":"xn--fiq228cws:","slashes":null,"auth":null,"host":"xn--","port":null,"hostname":"xn--","hash":null,"search":"?\u00e9%zzxn--fiq228c\u00df=","query":{"\u00e9%zzxn--fiq228c\u00df":""},"pathname":null,"path":"?\u00e9%zzxn--fiq228c\u00df=","href":"xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df="} +f xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df= xn--fiq228cws:xn--?\u00e9%zzxn--fiq228c\u00df= p 0 \u3000}};xn-- "%41 {"protocol":null,"slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":null,"pathname":"\u3000%7D%7D;xn--%20%22%41","path":"\u3000%7D%7D;xn--%20%22%41","href":"\u3000%7D%7D;xn--%20%22%41"} p 1 \u3000}};xn-- "%41 {"protocol":null,"slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":{},"pathname":"\u3000%7D%7D;xn--%20%22%41","path":"\u3000%7D%7D;xn--%20%22%41","href":"\u3000%7D%7D;xn--%20%22%41"} p 2 \u3000}};xn-- "%41 {"protocol":null,"slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":null,"pathname":"\u3000%7D%7D;xn--%20%22%41","path":"\u3000%7D%7D;xn--%20%22%41","href":"\u3000%7D%7D;xn--%20%22%41"} @@ -8356,11 +8356,11 @@ p 1 \u000a%41\ud83d\udca9 {"protocol":null,"slashes":null,"auth":null,"host":nul p 2 \u000a%41\ud83d\udca9 {"protocol":null,"slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":null,"pathname":"%41\ud83d\udca9","path":"%41\ud83d\udca9","href":"%41\ud83d\udca9"} p 3 \u000a%41\ud83d\udca9 {"protocol":null,"slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":{},"pathname":"%41\ud83d\udca9","path":"%41\ud83d\udca9","href":"%41\ud83d\udca9"} f \u000a%41\ud83d\udca9 %41\ud83d\udca9 -p 0 c.comHTTP:xn--%%C3%A9x-yhttp: E:ERR_INVALID_URL -p 1 c.comHTTP:xn--%%C3%A9x-yhttp: E:ERR_INVALID_URL -p 2 c.comHTTP:xn--%%C3%A9x-yhttp: E:ERR_INVALID_URL -p 3 c.comHTTP:xn--%%C3%A9x-yhttp: E:ERR_INVALID_URL -f c.comHTTP:xn--%%C3%A9x-yhttp: E:ERR_INVALID_URL +p 0 c.comHTTP:xn--%%C3%A9x-yhttp: {"protocol":"c.comhttp:","slashes":null,"auth":null,"host":"xn--","port":null,"hostname":"xn--","hash":null,"search":null,"query":null,"pathname":"%%C3%A9x-yhttp:","path":"%%C3%A9x-yhttp:","href":"c.comhttp:xn--%%C3%A9x-yhttp:"} +p 1 c.comHTTP:xn--%%C3%A9x-yhttp: {"protocol":"c.comhttp:","slashes":null,"auth":null,"host":"xn--","port":null,"hostname":"xn--","hash":null,"search":null,"query":{},"pathname":"%%C3%A9x-yhttp:","path":"%%C3%A9x-yhttp:","href":"c.comhttp:xn--%%C3%A9x-yhttp:"} +p 2 c.comHTTP:xn--%%C3%A9x-yhttp: {"protocol":"c.comhttp:","slashes":null,"auth":null,"host":"xn--","port":null,"hostname":"xn--","hash":null,"search":null,"query":null,"pathname":"%%C3%A9x-yhttp:","path":"%%C3%A9x-yhttp:","href":"c.comhttp:xn--%%C3%A9x-yhttp:"} +p 3 c.comHTTP:xn--%%C3%A9x-yhttp: {"protocol":"c.comhttp:","slashes":null,"auth":null,"host":"xn--","port":null,"hostname":"xn--","hash":null,"search":null,"query":{},"pathname":"%%C3%A9x-yhttp:","path":"%%C3%A9x-yhttp:","href":"c.comhttp:xn--%%C3%A9x-yhttp:"} +f c.comHTTP:xn--%%C3%A9x-yhttp: c.comhttp:xn--%%C3%A9x-yhttp: p 0 file:B=[B`::1HTTP: {"protocol":"file:","slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":null,"pathname":"B=[B%60::1HTTP:","path":"B=[B%60::1HTTP:","href":"file://B=[B%60::1HTTP:"} p 1 file:B=[B`::1HTTP: {"protocol":"file:","slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":{},"pathname":"B=[B%60::1HTTP:","path":"B=[B%60::1HTTP:","href":"file://B=[B%60::1HTTP:"} p 2 file:B=[B`::1HTTP: {"protocol":"file:","slashes":null,"auth":null,"host":null,"port":null,"hostname":null,"hash":null,"search":null,"query":null,"pathname":"B=[B%60::1HTTP:","path":"B=[B%60::1HTTP:","href":"file://B=[B%60::1HTTP:"} @@ -12119,7 +12119,7 @@ r https://a.com/b ^\u00df{/ https://a.com/%5E\u00df%7B/ r http://a.com/b/c %41@xn--fiq228c\ud83d\udca9 http://a.com/b/%41@xn--fiq228c\ud83d\udca9 r https://a.com/b http:HTTP:>'\ud800 http://HTTP:%3E%27\ud800/ r foo://a/b \u000a{\u200d foo://a/%7B\u200d -r file:///a/b c.comjavascript:xn--}1.2.3.4x-y E:ERR_INVALID_URL +r file:///a/b c.comjavascript:xn--}1.2.3.4x-y c.comjavascript:xn--%7D1.2.3.4x-y r mailto:local1@domain1 >::1 mailto:local1@%3E::1 r /a/b/c c.com /a/b/c.com r /a/b/c ws:mailto:#8080\u000a ws://mailto:/#8080 @@ -13081,7 +13081,7 @@ r foo:a/b '>\u0301\ud800< foo:a/%27%3E\u0301\ud800%3C r http://[::1]/a /ws: http://[::1]/ws: r mailto:a@b/c a1.2.3.4 javascript:\ud83d\udca9%3Ea1.2.3.4 r http://[::1]/a \u05d0foo:>\u05d0x-y http://[::1]/\u05d0foo:%3E\u05d0x-y diff --git a/tests/corpus/1640-fd-read-decode.ts b/tests/corpus/1640-fd-read-decode.ts index 230dad92e8..266e110d87 100644 --- a/tests/corpus/1640-fd-read-decode.ts +++ b/tests/corpus/1640-fd-read-decode.ts @@ -36,10 +36,16 @@ console.log( parenthesizedNull.toString("utf8"), ); console.log(fs.readSync(fdPositioned, positioned, 0, 5, 9999)); -// Node returns after intrinsic offset validation but before checking the -// buffer window, position, or descriptor when the requested window is empty. -console.log(fs.readSync(fdPositioned, positioned, 0, 0, 1.5)); -console.log(fs.readSync(-123, positioned, 9999, 0, 1.5)); +// Node returns after offset and position validation but before checking +// the buffer window or descriptor when the requested window is empty. +console.log(fs.readSync(fdPositioned, positioned, 0, 0, 1)); +console.log(fs.readSync(-123, positioned, 9999, 0, null)); +try { + fs.readSync(-123, positioned, 9999, 0, 1.5); +} catch (e) { + console.log("empty window position caught:", (e as Error).name); + console.log((e as Error).message); +} try { fs.readSync(fdPositioned, positioned, 0.5, 0, 0); } catch (e) { diff --git a/tests/corpus/2283-structured-clone.cjs b/tests/corpus/2283-structured-clone.cjs index df33eb31cb..5eeb7e6452 100644 --- a/tests/corpus/2283-structured-clone.cjs +++ b/tests/corpus/2283-structured-clone.cjs @@ -8,7 +8,7 @@ const assert = require('assert'); assert.throws(() => structuredClone(), { code: 'ERR_MISSING_ARGS' }); assert.throws(() => structuredClone(undefined, ''), { code: 'ERR_INVALID_ARG_TYPE', message: "Failed to execute 'structuredClone': Options cannot be converted to a dictionary" }); assert.throws(() => structuredClone(undefined, 1), { code: 'ERR_INVALID_ARG_TYPE' }); -assert.throws(() => structuredClone(undefined, { transfer: 1 }), { code: 'ERR_INVALID_ARG_TYPE', message: "Failed to execute 'structuredClone': transfer in Options can not be converted to sequence." }); +assert.throws(() => structuredClone(undefined, { transfer: 1 }), { code: 'ERR_INVALID_ARG_TYPE', message: "Failed to execute 'structuredClone': transfer in Options cannot be converted to sequence." }); assert.throws(() => structuredClone(undefined, { transfer: null }), { code: 'ERR_INVALID_ARG_TYPE' }); assert.strictEqual(structuredClone(undefined), undefined); assert.strictEqual(structuredClone(undefined, null), undefined); diff --git a/tests/corpus/2599-stream-arg-ladders.cjs b/tests/corpus/2599-stream-arg-ladders.cjs index 6297d203f8..41577f9ec3 100644 --- a/tests/corpus/2599-stream-arg-ladders.cjs +++ b/tests/corpus/2599-stream-arg-ladders.cjs @@ -1,11 +1,10 @@ // The stream-surface validation ladders: finished() over a provably-non- // stream value answers Node's isNodeStream ERR_INVALID_ARG_TYPE (the // watcher never registers), socket write's two-argument encoding form -// implements Node's stream_base typecheck — write(string, 'buffer') is -// the synchronous "Second argument must be a buffer" TypeError on an -// established socket, utf8 spellings are the plain write — and -// Readable.toWeb's `type` option answers Node's one-of ladder before any -// web-stream machinery. +// implements Writable's encoding check — write(string, 'buffer') is +// the synchronous ERR_UNKNOWN_ENCODING TypeError, utf8 spellings are the +// plain write — and Readable.toWeb's `type` option answers Node's one-of +// ladder before any web-stream machinery. 'use strict'; const net = require('net'); const { Duplex, Readable, finished } = require('stream'); diff --git a/tests/corpus/3136-fs-file-handle-options.ts b/tests/corpus/3136-fs-file-handle-options.ts index f4a7d7ec63..65a710aec6 100644 --- a/tests/corpus/3136-fs-file-handle-options.ts +++ b/tests/corpus/3136-fs-file-handle-options.ts @@ -32,8 +32,13 @@ async function main(): Promise { order = ""; const accessorOptions = { buffer, get position() { return number("p", 0); }, get offset() { return number("o", 1); }, get length() { return number("l", 2); } }; console.log("getter options:", (await handle.read(accessorOptions)).bytesRead, order); - const nothing = await handle.read({ buffer, offset: 99, length: 0, position: -2 }); + const nothing = await handle.read({ buffer, offset: 99, length: 0, position: -1 }); console.log("zero length:", nothing.bytesRead, nothing.buffer === buffer); + try { + await handle.read({ buffer, offset: 99, length: 0, position: -2 }); + } catch (e) { + console.log("zero length position:", (e as Error).name, (e as Error).message); + } } finally { await handle.close(); fs.unlinkSync(scratch); } } main(); diff --git a/tests/corpus/5275-http-end-callback-order.ts b/tests/corpus/5275-http-end-callback-order.ts new file mode 100644 index 0000000000..271b6f30d8 --- /dev/null +++ b/tests/corpus/5275-http-end-callback-order.ts @@ -0,0 +1,72 @@ +// ServerResponse end callbacks and 'finish': writableFinished reads false +// right after end() and true from the finish point; end(cb) callbacks run +// before the 'finish' listeners while the socket is still attached; a +// second end(cb) before the finish joins the same callback list. A request +// read to 'end' closes before its response; an unread one closes after. +import { createServer, request, type IncomingMessage, type ServerResponse } from "node:http"; + +type Handler = (req: IncomingMessage, res: ServerResponse) => void; + +const handlers: Handler[] = [ + (req, res) => { + req.on("data", () => {}); + req.on("end", () => { + res.end("ok", () => { + console.log("end callback", res.writableFinished, res.socket !== null); + }); + console.log("after end", res.writableEnded, res.writableFinished); + }); + }, + (req, res) => { + res.end("ok"); + res.end(() => { + console.log("second end callback", res.writableFinished, res.socket !== null); + }); + console.log("after end", res.writableEnded, res.writableFinished); + }, + (req, res) => { + res.write("a"); + res.end(() => { + console.log("empty end callback", res.writableFinished, res.socket !== null); + }); + }, +]; + +function exchange(index: number): Promise { + return new Promise((done) => { + const server = createServer((req, res) => { + res.on("finish", () => { + console.log("finish listener", res.writableFinished, res.socket === null); + }); + res.on("close", () => { + console.log("response close"); + }); + req.on("close", () => { + console.log("request close"); + }); + handlers[index]!(req, res); + }); + server.listen(0, () => { + const address = server.address(); + const port = typeof address === "object" && address !== null ? address.port : 0; + const outbound = request({ port, method: "POST", agent: false }, (response) => { + response.resume(); + response.on("end", () => { + setTimeout(() => { + server.close(); + done(); + }, 20); + }); + }); + outbound.end("ping"); + }); + }); +} + +async function main(): Promise { + for (let i = 0; i < handlers.length; i++) { + console.log("exchange", i); + await exchange(i); + } +} +main(); diff --git a/tests/corpus/5276-style-text-hex-colors.cjs b/tests/corpus/5276-style-text-hex-colors.cjs new file mode 100644 index 0000000000..04ddb69c55 --- /dev/null +++ b/tests/corpus/5276-style-text-hex-colors.cjs @@ -0,0 +1,28 @@ +// util.styleText hex colors: '#RGB' and '#RRGGBB' formats open a 24-bit +// foreground sequence (38;2;r;g;b) and close with 39, alone or mixed with +// named formats; nested closes reopen the color. Other '#' strings throw +// ERR_INVALID_ARG_VALUE, before or after the stream check. +'use strict'; +const { styleText } = require('node:util'); +const show = (label, fn) => { + try { + console.log(label, JSON.stringify(fn())); + } catch (e) { + console.log(label, e.name, e.code, e.message); + } +}; +const raw = { validateStream: false }; +show('six', () => styleText('#ff8000', 'orange', raw)); +show('three', () => styleText('#0Fa', 'mint', raw)); +show('upper', () => styleText('#ABCDEF', 'x', raw)); +show('mixed', () => styleText(['bold', '#00f', 'underline'], 'text', raw)); +show('nested close', () => styleText('#123456', 'a\u001b[39mb\u001b[39m', raw)); +show('named after hex', () => styleText(['#abc', 'red'], 'a\u001b[39mb', raw)); +show('bad digits', () => styleText('#zz0', 'bad', raw)); +show('bad length', () => styleText('#12345', 'bad', raw)); +show('bare hash', () => styleText('#', 'bad', raw)); +show('bad in array', () => styleText(['red', '#1234567'], 'bad', raw)); +show('bad then unknown', () => styleText(['#12', 'nope'], 'bad', raw)); +show('unknown after hex', () => styleText(['#123', 'nope'], 'bad', raw)); +show('validated stream', () => styleText('#123', 'plain')); +show('validated bad', () => styleText('#xyz', 'plain')); diff --git a/tests/corpus/5277-fs-read-file-buffer-option.cjs b/tests/corpus/5277-fs-read-file-buffer-option.cjs new file mode 100644 index 0000000000..bc877cc3be --- /dev/null +++ b/tests/corpus/5277-fs-read-file-buffer-option.cjs @@ -0,0 +1,28 @@ +// fs.readFile's options.buffer accepts a function or an ArrayBufferView; +// any other value other than undefined throws ERR_INVALID_ARG_TYPE +// synchronously, before the path is validated and before the callback +// could run. An undefined buffer reads normally. +'use strict'; +const fs = require('node:fs'); +const os = require('node:os'); +const path = require('node:path'); +const file = path.join(os.tmpdir(), `scr-5277-${process.pid}.txt`); +fs.writeFileSync(file, 'hello'); +const show = (label, fn) => { + try { + fn(); + console.log(label, 'accepted'); + } catch (e) { + console.log(label, e.name, e.code, e.message); + } +}; +const never = () => console.log('callback ran'); +show('number', () => fs.readFile(file, { buffer: 5 }, never)); +show('string', () => fs.readFile(file, { encoding: 'utf8', buffer: 'abc' }, never)); +show('null', () => fs.readFile(file, { buffer: null }, never)); +show('object', () => fs.readFile(file, { buffer: {} }, never)); +show('bad path first', () => fs.readFile(42.5, { buffer: true }, never)); +fs.readFile(file, { encoding: 'utf8', buffer: undefined }, (err, data) => { + console.log('undefined buffer', err, data); + fs.unlinkSync(file); +}); diff --git a/tests/corpus/5278-host-null-bytes.cjs b/tests/corpus/5278-host-null-bytes.cjs new file mode 100644 index 0000000000..fec9f5a0c5 --- /dev/null +++ b/tests/corpus/5278-host-null-bytes.cjs @@ -0,0 +1,28 @@ +// Hostnames with null bytes: dns.lookup throws ERR_INVALID_ARG_VALUE for +// 'hostname'; net.connect, net.createConnection, and tls.connect throw it +// for 'options.host', synchronously and before any lookup or dial. The +// callbacks never run. +'use strict'; +const dns = require('node:dns'); +const net = require('node:net'); +const tls = require('node:tls'); +const show = (label, fn) => { + try { + fn(); + console.log(label, 'accepted'); + } catch (e) { + console.log(label, e.name, e.code, e.message); + } +}; +show('lookup', () => dns.lookup('local\u0000host', { family: 4 }, () => console.log('lookup callback ran'))); +show('lookup trailing', () => dns.lookup('example.com\u0000', { family: 4 }, () => console.log('lookup callback ran'))); +// The received value prints like util.inspect: quote choice, escapes, and +// truncation after 128 characters. +show('lookup quotes', () => dns.lookup("it's \"q\"\u0000", { family: 4 }, () => {})); +show('lookup escapes', () => dns.lookup('a\\b\u0000\u007f\u0085\t\ud800', { family: 4 }, () => {})); +show('lookup long', () => dns.lookup('\u0000' + 'x'.repeat(140), { family: 4 }, () => {})); +show('connect', () => net.connect(9, 'a\u0000b', () => console.log('connect callback ran'))); +show('createConnection', () => net.createConnection(9, '\u0000')); +show('tls connect', () => tls.connect(9, 'a\u0000b', () => console.log('tls callback ran'))); +show('tls options', () => tls.connect({ port: 9, host: 'x\u0000' })); +console.log('done'); diff --git a/tests/corpus/5279-search-params-null-init.cjs b/tests/corpus/5279-search-params-null-init.cjs new file mode 100644 index 0000000000..0a4f7d5a6f --- /dev/null +++ b/tests/corpus/5279-search-params-null-init.cjs @@ -0,0 +1,16 @@ +// new URLSearchParams(init) treats only undefined as an empty init. A null +// init takes the string branch like other primitives, so "null" parses as +// one key with an empty value. +'use strict'; +const fromJson = (text) => JSON.parse(text); +const show = (label, init) => { + const params = new URLSearchParams(init); + console.log(label, JSON.stringify(params.toString()), params.size, params.has('null')); +}; +show('null', fromJson('null')); +show('nested null', fromJson('{"init":null}').init); +show('undefined', fromJson('{}').init); +show('number', fromJson('5')); +show('boolean', fromJson('false')); +show('string', fromJson('"a=1&null"')); +show('object', fromJson('{"null":"x"}')); From 022ac6eba946afee8b8372e796ab61e26b42f85f Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 14 Oct 2026 17:38:02 -0500 Subject: [PATCH 4/7] Store arrays of interface values natively and read interface fields directly Arrays whose elements are class-backed interface values are native arrays of the element capsules, so iteration, indexing and most array methods no longer go through the checked-dynamic array, and method calls receive a receiver they can dispatch. Methods without a native form for these elements run on the array's live dynamic view. A read of an interface property signature has the property's static type and reads the field of an implementing class directly. Accessors, object literals and JavaScript classes keep the checked property read. --- docs/content/docs/limitations.mdx | 2 +- .../lowering/class-dynamic-dispatch.ts | 10 +- .../lowering/class-protocol-dispatch.ts | 152 +++++++++++++++++- .../lowering/containers/array-methods.ts | 41 +++++ .../src/frontend/lowering/lower-exprs.ts | 7 + packages/compiler/src/frontend/type-mapper.ts | 6 +- .../corpus/5180-interface-arrays.ts.json | 6 + .../5181-interface-array-methods.ts.json | 6 + .../5182-interface-array-boundaries.ts.json | 6 + .../5183-interface-property-reads.ts.json | 6 + .../5184-interface-property-objects.ts.json | 6 + tests/corpus/5180-interface-arrays.ts | 79 +++++++++ tests/corpus/5181-interface-array-methods.ts | 76 +++++++++ .../corpus/5182-interface-array-boundaries.ts | 70 ++++++++ tests/corpus/5183-interface-property-reads.ts | 70 ++++++++ .../corpus/5184-interface-property-objects.ts | 53 ++++++ tests/harness/interface-dispatch.test.ts | 38 +++++ 17 files changed, 627 insertions(+), 7 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5180-interface-arrays.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5181-interface-array-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5182-interface-array-boundaries.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5183-interface-property-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5184-interface-property-objects.ts.json create mode 100644 tests/corpus/5180-interface-arrays.ts create mode 100644 tests/corpus/5181-interface-array-methods.ts create mode 100644 tests/corpus/5182-interface-array-boundaries.ts create mode 100644 tests/corpus/5183-interface-property-reads.ts create mode 100644 tests/corpus/5184-interface-property-objects.ts diff --git a/docs/content/docs/limitations.mdx b/docs/content/docs/limitations.mdx index eb8d9c570f..db83eb619a 100644 --- a/docs/content/docs/limitations.mdx +++ b/docs/content/docs/limitations.mdx @@ -28,7 +28,7 @@ The following sections describe what compiles and what doesn't, area by area. Th ### Types and class definitions - **BigInt:** `BigInt64Array`, `BigUint64Array`, BigInt filesystem stats are unsupported. Arbitrary-precision BigInts otherwise support literals, operators, conversions, arrays, records, classes, closures, unions, promises, typed Map keys and Set elements, Buffer 64-bit reads/writes, and DataView 64-bit access. Native `unknown` and JavaScript `any` storage preserve BigInts, including checked Map keys and Set elements. JSON serialization throws a `TypeError` unless a replacer converts the value. -- **Interfaces:** Interfaces explicitly implemented by compiled classes retain live object identity through checked native values. Method-signature interfaces and callable-property interfaces structurally implemented by class methods use the same representation. A call to a method signature of such an interface calls the class's method directly when the receiver is an instance of a compiled class; object literals, and methods the program replaces on an instance or prototype, use dynamic property lookup. Other data interfaces retain native record layouts and their copy-coercion rules. Generic methods require a statically resolved body; a `const` interface binding initialized directly with `new` can keep the concrete class for specialization. Unsupported member representations produce diagnostics. +- **Interfaces:** Interfaces explicitly implemented by compiled classes retain live object identity through checked native values. Method-signature interfaces and callable-property interfaces structurally implemented by class methods use the same representation. A call to a method signature of such an interface calls the class's method directly when the receiver is an instance of a compiled class, and a read of a property signature reads the class's field directly; object literals, accessors, and methods the program replaces on an instance or prototype use dynamic property lookup. Arrays of such interface values are native arrays whose elements keep their identity; methods without a native form for them run on the array's dynamic view, which shares its elements. Other data interfaces retain native record layouts and their copy-coercion rules. Generic methods require a statically resolved body; a `const` interface binding initialized directly with `new` can keep the concrete class for specialization. Unsupported member representations produce diagnostics. - **Record shapes:** Records use exact native layouts. Passing `{ a, b }` where `{ a }` is expected can produce `SC2002`. Accepted flows into a strict field-subset shape copy the record; see [Record identity and property order](#record-identity-and-property-order). - **Unions:** Narrow a union before an operation whose members require incompatible native representations, such as reading `u.length` on `string | string[]`. Some union-to-union widening and unions combining function and data members are unsupported. Same-representation methods on class unions, `map` and `forEach` on array unions, and shared or joinable field reads compile. `console.log(u)` supports printing a whole union. - **Null and optional values:** `undefined` and `null` compile as standalone values and union members. Optional record and class fields and optional, default, and rest parameters also compile. diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts index cc2f2d7cbf..d937d0d9b9 100644 --- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts +++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts @@ -63,7 +63,7 @@ import { CaughtValueDispatch } from "./caught-value-dispatch.js"; import { refreshDescriptorGuards } from "./class-descriptors.js"; import { ClassConstructionDispatch } from "./class-construction.js"; import { emitterRooted } from "./lower-event-emitter.js"; -import { protocolArm } from "./class-protocol-dispatch.js"; +import { protocolArm, protocolFieldArm } from "./class-protocol-dispatch.js"; const STREAM_METHODS = new Set([ "on", @@ -2258,15 +2258,17 @@ export class ClassDynamicDispatch { for (const plan of this.propertyReceivers(lowerer)) { if ( plan.info !== plan.capsule || - !candidates(dispatch.method).includes(plan.info) || - dispatch.classes.has(plan.key) + dispatch.classes.has(plan.key) || + (!dispatch.field && !candidates(dispatch.method).includes(plan.info)) ) continue; dispatch.classes.add(plan.key); const loc = dispatch.fn.loc; const type: IrType = { kind: "object", className: plan.info.def.name }; const receiver: IrExpr = { kind: "dynCheck", value: varRef("p.0", DYN, loc), type, loc }; - const arm = protocolArm(lowerer, dispatch, plan.info, receiver, this.asyncFree); + const arm = dispatch.field + ? protocolFieldArm(lowerer, dispatch, plan.info, receiver) + : protocolArm(lowerer, dispatch, plan.info, receiver, this.asyncFree); if (!arm) continue; const condition = (): IrExpr => ({ kind: "libCall", diff --git a/packages/compiler/src/frontend/lowering/class-protocol-dispatch.ts b/packages/compiler/src/frontend/lowering/class-protocol-dispatch.ts index a064709130..3c067828fe 100644 --- a/packages/compiler/src/frontend/lowering/class-protocol-dispatch.ts +++ b/packages/compiler/src/frontend/lowering/class-protocol-dispatch.ts @@ -2,6 +2,8 @@ import { dynUndefinedExpr, varRef } from "../../ir/build.js"; import { DYN, STRING, + isDynTypedRefType, + isUnitType, canConvertToDyn, canDynCheckTo, typeEquals, @@ -11,11 +13,12 @@ import { type IrStmt, type IrType, } from "../../ir/ir.js"; -import { locOf } from "../program.js"; +import { isJsSourceFile, locOf } from "../program.js"; import * as ts from "../ts7/adapter.js"; import { type Lowerer } from "./lowerer.js"; import { findMethodOn, upcastTo, type ClassInfo } from "./lower-classes.js"; import { isClassCallback } from "./class-callbacks.js"; +import { tryLowerExpression } from "./expressions/try-lower-expression.js"; /** A method call through a class-backed protocol (`s.area()` with * `s: Shape`) that keeps its static signature. ClassDynamicDispatch adds @@ -37,6 +40,9 @@ export interface ProtocolDispatch { * implementations may still return a value. */ result: IrType; returnsVoid: boolean; + /** A property read (`s.name`) rather than a method call: arms read the + * implementing class's field. */ + field: boolean; classes: Set; } @@ -330,6 +336,7 @@ export function lowerProtocolMethodCall( params, result, returnsVoid, + field: false, classes: new Set(), }; lowerer.protocolDispatches.set(key, dispatch); @@ -434,3 +441,146 @@ export function protocolArm( else lowerer.noteEdge(callee); return body; } + +/** Static results that the checked fallback converts without copying: the + * value keeps its identity whichever path produced it. */ +function identityResult(lowerer: Lowerer, type: IrType): boolean { + if (type.kind === "f64" || type.kind === "bool" || type.kind === "string") return true; + if (isDynTypedRefType(type)) return true; + if (type.kind !== "union") return false; + return ( + lowerer.unions + .get(type.unionId) + ?.arms.every( + (arm) => + arm.kind === "f64" || + arm.kind === "bool" || + arm.kind === "string" || + isUnitType(arm) || + isDynTypedRefType(arm), + ) ?? false + ); +} + +/** `s.name` on a class-backed protocol receiver, where `name` is a property + * signature: the read has the property's static type, and receivers that + * are instances of a boxed class declaring the field read it directly. */ +export function lowerProtocolPropertyRead( + lowerer: Lowerer, + access: ts.PropertyAccessExpression, +): IrExpr | null { + if (isJsSourceFile(access.getSourceFile())) return null; + const receiverType = lowerer.typeOf(access.expression); + if (!lowerer.classImplementedProtocol(receiverType)) return null; + const name = access.name.text; + const property = lowerer.checker.getPropertyOfType(receiverType, name); + const declarations = property ? lowerer.checker.declarationsOf(property) : []; + if (declarations.length === 0 || !declarations.every((decl) => ts.isPropertySignature(decl))) + return null; + const result = lowerer.mapTypeOf(lowerer.typeOf(access)); + if ( + !result || + !identityResult(lowerer, result) || + !canDynCheckTo( + result, + (id) => lowerer.shapes.get(id), + (id) => lowerer.unions.get(id), + ) + ) + return null; + const recv = tryLowerExpression(lowerer, access.expression); + if (recv?.type.kind !== "dyn") return null; + const loc = locOf(access); + const key = JSON.stringify(["get", name, typeKey(result)]); + let dispatch = lowerer.protocolDispatches.get(key); + if (!dispatch) { + const index = lowerer.protocolDispatches.size; + const params = [{ localId: "p.0", name: "receiver", type: DYN }]; + const locals = () => [{ id: "p.0", name: "receiver", type: DYN, mutable: false }]; + const read: IrExpr = { + kind: "dynKeyGet", + value: varRef("p.0", DYN, loc), + key: { kind: "strLit", value: name, type: STRING, loc }, + type: DYN, + loc, + }; + const fallback: IrFunction = { + name: `%dyn.class.protocol.fallback.${index}`, + params, + returnType: result, + locals: locals(), + body: [{ kind: "return", value: lowerer.coerceToExpected(read, result), loc }], + loc, + }; + const fn: IrFunction = { + name: `%dyn.class.protocol.${index}`, + params, + returnType: result, + locals: locals(), + body: [ + { + kind: "return", + value: { + kind: "call", + callee: fallback.name, + args: [varRef("p.0", DYN, loc)], + type: result, + loc, + }, + loc, + }, + ], + loc, + }; + dispatch = { + method: name, + fn, + fallback, + probe: null, + params: [], + result, + returnsVoid: false, + field: true, + classes: new Set(), + }; + lowerer.protocolDispatches.set(key, dispatch); + lowerer.liftedFns.push(fn, fallback); + } + return { kind: "call", callee: dispatch.fn.name, args: [recv], type: result, loc }; +} + +/** The field arm for receivers of `info`: a declared field of the read's + * type. Accessors and fields of JavaScript classes, which an own property + * can replace, keep the checked read. */ +export function protocolFieldArm( + lowerer: Lowerer, + dispatch: ProtocolDispatch, + info: ClassInfo, + receiver: IrExpr, +): IrStmt[] | null { + if ( + info.def.runtime || + info.builtinError || + info.builtinEmitter || + info.builtinStream || + info.def.tracksOwnFields + ) + return null; + const field = info.fields.get(dispatch.method); + if (!field || !typeEquals(field, dispatch.result)) return null; + const loc = dispatch.fn.loc; + return [ + { + kind: "return", + value: { + kind: "fieldGet", + obj: receiver, + className: info.def.name, + field: dispatch.method, + type: field, + loc, + }, + loc, + }, + ]; +} diff --git a/packages/compiler/src/frontend/lowering/containers/array-methods.ts b/packages/compiler/src/frontend/lowering/containers/array-methods.ts index b80057fb34..ea821f0068 100644 --- a/packages/compiler/src/frontend/lowering/containers/array-methods.ts +++ b/packages/compiler/src/frontend/lowering/containers/array-methods.ts @@ -280,6 +280,35 @@ function lowerArrayJoinSeparator( * direct call of a synthetic loop function (see lowerArrayHofCall and * friends). Null when this isn't an ambient array method call. tsc has * already checked arity and argument types against ambient/scriptc.d.ts. */ +/** Methods with native lowerings for arrays of checked-dynamic elements. */ +const DYN_ELEMENT_METHODS = new Set([ + "copyWithin", + "every", + "fill", + "filter", + "findIndex", + "findLastIndex", + "flatMap", + "forEach", + "join", + "map", + "pop", + "push", + "reduce", + "reduceRight", + "reverse", + "shift", + "slice", + "some", + "sort", + "splice", + "toReversed", + "toSorted", + "toSpliced", + "unshift", + "with", +]); + export function lowerArrayMethodCall( lowerer: Lowerer, call: ts.CallExpression, @@ -399,6 +428,18 @@ export function lowerArrayMethodCall( receiverIr = receiver.type; elem = receiver.type.elem; } + // Arrays of checked-dynamic elements (arrays of class-backed protocol + // values) lower natively for the methods below. Other methods run on the + // array's live checked-dynamic view, which shares its storage. + if (elem.kind === "dyn" && !DYN_ELEMENT_METHODS.has(name)) { + const view = lowerer.coerceInto(access.expression, receiver, DYN); + const dispatched = lowerDynDispatchMethodCall(lowerer, call, access, view, true); + if (!dispatched) return null; + const result = lowerer.mapTypeOf(lowerer.typeOf(call)); + return result && result.kind !== "void" && result.kind !== "dyn" + ? lowerer.coerceInto(call, dispatched, result) + : dispatched; + } } if (name === "sort" || name === "toSorted") { return lowerArraySortCall(lowerer, call, access, elem, receiverIr); diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index 74d5d723d4..6fecf58fd1 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -1,3 +1,4 @@ +import { lowerProtocolPropertyRead } from "./class-protocol-dispatch.js"; import { generatorDrain } from "./iterator-adapters.js"; import { lowerEventStaticProperty } from "./builtins/numbers.js"; import { lowerUnionEquality, tagEqualityMayMissAlias } from "./strict-equality.js"; @@ -2127,6 +2128,12 @@ function lowerExprInner(lowerer: Lowerer, expr: ts.Expression): IrExpr { const tm = lowerCjsExportTableThisMember(lowerer, expr); if (tm) return tm; } + // Property signatures of class-backed protocols read implementing + // classes' fields directly. + if (!hasOptionalChainGuard(expr.expression)) { + const typed = lowerProtocolPropertyRead(lowerer, expr); + if (typed) return typed; + } const handled = lowerer.lowerProcessEnvGet(expr) ?? lowerer.lowerServerProperty(expr) ?? diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index 7c8b2cb8a8..42dacb6194 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -1607,7 +1607,11 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { // changing this public representation. This is dynFallbackType's JS stance promoted into // the mapping itself; construction sites build dynArrLit (the checked-dynamic tree // array literal) and typed sources convert per element at the slot. - if (elem.kind === "dyn") return DYN; + // Arrays of class-backed protocol values are the exception: each + // element is one checked-dynamic value (a class capsule or an object), + // so a native array of them keeps every element's identity and passes + // method calls a receiver they can dispatch. + if (elem.kind === "dyn") return ctx.classImplementedProtocol?.(elemTs) ? arrayOf(DYN) : DYN; // The shared predicate is the runtime/backend storage contract. In // particular, valid standalone values such as Date and opaque // handles do not automatically have an array element representation. diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5180-interface-arrays.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5180-interface-arrays.ts.json new file mode 100644 index 0000000000..105e4aa9ea --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5180-interface-arrays.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5180-interface-arrays.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5181-interface-array-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5181-interface-array-methods.ts.json new file mode 100644 index 0000000000..7753717370 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5181-interface-array-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5181-interface-array-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5182-interface-array-boundaries.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5182-interface-array-boundaries.ts.json new file mode 100644 index 0000000000..db03414e35 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5182-interface-array-boundaries.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5182-interface-array-boundaries.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5183-interface-property-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5183-interface-property-reads.ts.json new file mode 100644 index 0000000000..6e6a0f820b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5183-interface-property-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5183-interface-property-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5184-interface-property-objects.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5184-interface-property-objects.ts.json new file mode 100644 index 0000000000..8e24019594 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5184-interface-property-objects.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5184-interface-property-objects.ts" + ], + "diags": [] +} diff --git a/tests/corpus/5180-interface-arrays.ts b/tests/corpus/5180-interface-arrays.ts new file mode 100644 index 0000000000..573a9cd2a4 --- /dev/null +++ b/tests/corpus/5180-interface-arrays.ts @@ -0,0 +1,79 @@ +// Arrays of interface values implemented by program classes and object +// literals: construction, index reads and writes, length, iteration, +// element identity, nested arrays, and calls through each element. +interface Shape { + area(): number; + name(): string; +} + +class Circle implements Shape { + r: number; + constructor(r: number) { + this.r = r; + } + area(): number { + return 3 * this.r * this.r; + } + name(): string { + return `circle ${this.r}`; + } +} + +class Square implements Shape { + side: number; + constructor(side: number) { + this.side = side; + } + area(): number { + return this.side * this.side; + } + name(): string { + return `square ${this.side}`; + } +} + +const literal: Shape = { + area(): number { + return 100; + }, + name(): string { + return "literal"; + }, +}; + +const first = new Circle(1); +const shapes: Shape[] = [first, new Square(2), literal]; +console.log(shapes.length, shapes[0] === first, shapes[2] === literal); +for (const shape of shapes) console.log(shape.name(), shape.area()); +for (let i = 0; i < shapes.length; i++) console.log(i, shapes[i]!.name()); + +shapes[1] = new Circle(4); +shapes.push(new Square(5)); +console.log(shapes.map((s) => s.name()).join(", ")); + +const empty: Shape[] = []; +console.log(empty.length, empty[0] === undefined); +empty[2] = literal; +console.log(empty.length, empty[0] === undefined, empty[2] === literal); + +const grid: Shape[][] = [shapes, [literal, first]]; +console.log(grid.length, grid[1]![1] === first, grid[0]![3]!.name()); + +let total = 0; +for (let round = 0; round < 100; round++) for (const shape of shapes) total += shape.area(); +console.log(total); + +function largest(list: Shape[]): Shape | undefined { + let best: Shape | undefined; + for (const shape of list) if (best === undefined || shape.area() > best.area()) best = shape; + return best; +} +const big = largest(shapes); +console.log(big === undefined ? "none" : big.name(), largest([]) === undefined); + +function build(count: number): Shape[] { + const out: Shape[] = []; + for (let i = 1; i <= count; i++) out.push(i % 2 === 0 ? new Square(i) : new Circle(i)); + return out; +} +console.log(build(4).map((s) => s.area()).join(" ")); diff --git a/tests/corpus/5181-interface-array-methods.ts b/tests/corpus/5181-interface-array-methods.ts new file mode 100644 index 0000000000..e70754ca98 --- /dev/null +++ b/tests/corpus/5181-interface-array-methods.ts @@ -0,0 +1,76 @@ +// Array methods on arrays of interface values: searches compare element +// identity, sorting and splicing move the same objects, copies share +// elements with the source, and iterator methods yield the elements. +interface Shape { + area(): number; + name(): string; +} + +class Circle implements Shape { + r: number; + constructor(r: number) { + this.r = r; + } + area(): number { + return 3 * this.r * this.r; + } + name(): string { + return `c${this.r}`; + } +} + +class Square implements Shape { + side: number; + constructor(side: number) { + this.side = side; + } + area(): number { + return this.side * this.side; + } + name(): string { + return `s${this.side}`; + } +} + +const literal: Shape = { area: () => 50, name: () => "lit" }; +const a = new Circle(1); +const b = new Square(3); +const shapes: Shape[] = [a, b, literal, new Circle(2)]; +const names = (list: Shape[]): string => list.map((s) => s.name()).join(" "); + +console.log(shapes.indexOf(b), shapes.indexOf(new Square(3)), shapes.lastIndexOf(a)); +console.log(shapes.includes(literal), shapes.includes(new Circle(1))); +const found = shapes.find((s) => s.area() > 10); +console.log(found === undefined ? "none" : found.name(), shapes.findIndex((s) => s === literal)); +console.log(shapes.findLastIndex((s) => s.area() < 20)); +console.log(shapes.filter((s) => s.area() < 20).map((s) => s.name()).join(",")); +console.log(shapes.some((s) => s === b), shapes.every((s) => s.area() > 1)); +console.log(shapes.reduce((sum, s) => sum + s.area(), 0), shapes.reduceRight((acc, s) => acc + s.name(), "")); +const last = shapes.at(-1); +console.log(last === undefined ? "none" : last.name()); + +const sorted = shapes.toSorted((x, y) => x.area() - y.area()); +console.log(names(sorted), names(shapes), sorted[0] === a); +shapes.sort((x, y) => y.area() - x.area()); +console.log(names(shapes)); +console.log(names(shapes.toReversed()), names(shapes.slice(1, 3))); +console.log(names(shapes.with(0, literal)), names(shapes.toSpliced(1, 2))); +const removed = shapes.splice(1, 1, new Square(7), new Square(8)); +console.log(names(removed), names(shapes)); +console.log(names(shapes.concat([a], [literal]))); +shapes.reverse(); +const shifted = shapes.shift(); +const popped = shapes.pop(); +console.log(names(shapes), shifted === undefined ? "none" : shifted.name(), popped === undefined ? "none" : popped.name()); +shapes.unshift(b); +console.log(names(shapes), shapes.length); +console.log(shapes.flatMap((s) => [s.name(), s.area()]).join("|")); +for (const [i, s] of shapes.entries()) console.log(i, s.name()); +for (const s of shapes.values()) console.log(s.area()); +console.log([...shapes.keys()].join(",")); +const copy = [...shapes, literal]; +const [head, ...rest] = copy; +console.log(head === shapes[0], rest.length, names(copy)); +shapes.fill(literal, 1, 2); +shapes.copyWithin(0, 2); +console.log(names(shapes)); diff --git a/tests/corpus/5182-interface-array-boundaries.ts b/tests/corpus/5182-interface-array-boundaries.ts new file mode 100644 index 0000000000..0663f89f41 --- /dev/null +++ b/tests/corpus/5182-interface-array-boundaries.ts @@ -0,0 +1,70 @@ +// Arrays of interface values crossing into untyped code and JSON, and +// stored in class fields and records: the untyped view is the same array, +// writes through either side are visible to the other, and elements keep +// their identity. +interface Shape { + area(): number; +} + +class Circle implements Shape { + r: number; + constructor(r: number) { + this.r = r; + } + area(): number { + return 3 * this.r * this.r; + } +} + +class Square implements Shape { + side: number; + constructor(side: number) { + this.side = side; + } + area(): number { + return this.side * this.side; + } +} + +const shapes: Shape[] = [new Circle(1), new Square(2)]; +const view: unknown = shapes; +console.log(Array.isArray(view), view === shapes); +const untyped = view as unknown[]; +untyped.push(new Square(3)); +console.log(shapes.length, shapes[2]!.area()); +shapes.push(new Circle(2)); +console.log(untyped.length); + +function describe(value: unknown): string { + return JSON.stringify(value); +} +console.log(describe(shapes)); +console.log(JSON.stringify({ shapes })); + +class Scene { + items: Shape[] = []; + add(shape: Shape): this { + this.items.push(shape); + return this; + } + total(): number { + let sum = 0; + for (const item of this.items) sum += item.area(); + return sum; + } +} +const scene = new Scene().add(shapes[0]!).add(new Square(4)); +console.log(scene.items.length, scene.total(), scene.items[0] === shapes[0]); +scene.items = shapes; +console.log(scene.total(), scene.items === shapes); + +type Layer = { name: string; shapes: Shape[] }; +const layer: Layer = { name: "base", shapes }; +layer.shapes.push(new Square(1)); +console.log(shapes.length, layer.shapes === shapes); + +const parsed = JSON.parse("[1, 2]") as unknown[]; +console.log(parsed.length); + +shapes.length = 1; +console.log(shapes.length, (view as unknown[]).length); diff --git a/tests/corpus/5183-interface-property-reads.ts b/tests/corpus/5183-interface-property-reads.ts new file mode 100644 index 0000000000..a727c87b80 --- /dev/null +++ b/tests/corpus/5183-interface-property-reads.ts @@ -0,0 +1,70 @@ +// Property reads through interfaces implemented by program classes: fields +// of number, string, boolean and union types, inherited and initialized +// fields, getters, object-literal implementations, writes followed by +// reads, and a missing receiver. +interface Item { + id: number; + label: string; + active: boolean; + tag: string | number; +} + +class Basic implements Item { + id: number; + label = "basic"; + active = true; + tag: string | number = "t"; + constructor(id: number) { + this.id = id; + } +} + +class Derived extends Basic { + extra = 1; + constructor(id: number) { + super(id); + this.label = "derived"; + this.tag = id * 2; + } +} + +class Computed implements Item { + id = 3; + active = false; + tag: string | number = 0; + get label(): string { + return `computed ${this.id}`; + } +} + +const literal: Item = { id: 9, label: "literal", active: true, tag: "x" }; +const items: Item[] = [new Basic(1), new Derived(2), new Computed(), literal]; + +for (const item of items) { + const id: number = item.id; + const label: string = item.label; + const active: boolean = item.active; + console.log(id, label, active, item.tag, label.length + id); +} + +let sum = 0; +let chars = 0; +for (let i = 0; i < 400; i++) { + const item = items[i % items.length]!; + sum += item.id; + chars += item.label.length; + if (item.active) sum += 1; +} +console.log(sum, chars); + +const first: Item = items[0]!; +first.label = "renamed"; +first.id = 10; +console.log(first.label, first.id, (items[0] as Basic).label); + +const missing = undefined as unknown as Item; +try { + console.log(missing.label); +} catch (error) { + console.log((error as Error).name, (error as Error).message); +} diff --git a/tests/corpus/5184-interface-property-objects.ts b/tests/corpus/5184-interface-property-objects.ts new file mode 100644 index 0000000000..109eb1e9d8 --- /dev/null +++ b/tests/corpus/5184-interface-property-objects.ts @@ -0,0 +1,53 @@ +// Property reads through interfaces that return class instances, optional +// values and nested interface values: reads return the stored objects, and +// a read after a write sees the new value. +class Owner { + name: string; + constructor(name: string) { + this.name = name; + } +} + +interface Node { + value: number; + owner: Owner; + next: Node | null; +} + +class ListNode implements Node { + value: number; + owner: Owner; + next: Node | null = null; + constructor(value: number, owner: Owner) { + this.value = value; + this.owner = owner; + } +} + +class Sentinel implements Node { + value = -1; + owner = new Owner("sentinel"); + next: Node | null = null; +} + +const ann = new Owner("ann"); +const head: Node = new ListNode(1, ann); +const second = new ListNode(2, ann); +head.next = second; +second.next = new Sentinel(); +console.log(head.owner === ann, head.owner.name, head.next === second); + +let total = 0; +let names = ""; +for (let node: Node | null = head; node !== null; node = node.next) { + total += node.value; + names += node.owner.name + ";"; +} +console.log(total, names); + +head.owner = new Owner("bob"); +console.log(head.owner.name, second.owner.name); + +const literal: Node = { value: 5, owner: ann, next: head }; +const linked = literal.next; +console.log(literal.owner === ann, linked === head, linked === null ? -1 : linked.value); diff --git a/tests/harness/interface-dispatch.test.ts b/tests/harness/interface-dispatch.test.ts index 921bbfe371..d0e0bf7231 100644 --- a/tests/harness/interface-dispatch.test.ts +++ b/tests/harness/interface-dispatch.test.ts @@ -79,6 +79,44 @@ describe("interface method dispatch", () => { expect(dispatch).toMatch(/call double @sc_bf__x25_Rect_scale\(ptr [^,]+, double/); }); + test("arrays of interface values iterate natively and pass typed receivers", async () => { + const llvm = await emittedLlvm( + "array", + shapes(`function sum(list: Shape[]): number { + let t = 0; + for (const s of list) t += s.scale(2); + return t; +} +console.log(sum([circle, new Rect(1)]));`), + ); + const sum = bodies(llvm, "sc_bf_sum"); + expect(sum).toMatch(/call double @sc_bf__x25_dyn_class_protocol_\d+/); + expect(sum).not.toContain("@scr_dyn_iterator"); + expect(sum).not.toContain("@sc_bf__x25_dyn_class_computed_"); + }); + + test("property reads through an interface read the implementing field", async () => { + const llvm = await emittedLlvm( + "field", + `interface Sized { + size: number; +} +class Box implements Sized { + size = 3; +} +function size(s: Sized): number { + return s.size + 1; +} +console.log(size(new Box())); +`, + ); + expect(bodies(llvm, "sc_bf_size")).not.toContain("@sc_bf__x25_dyn_class_property_"); + const helper = llvm.indexOf("; %dyn.class.protocol.0"); + expect(llvm.slice(helper, llvm.indexOf("\n}\n", helper))).toMatch( + /getelementptr inbounds %sc_o_Box, ptr [^,]+, i64 0, i32 \d+/, + ); + }); + test("a method an instance can replace keeps the checked dynamic call", async () => { const llvm = await emittedLlvm( "replaced", From d2a84e4a41b7c7a3cca8c0e4fcb41ff1cbb33587 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 14 Oct 2026 18:05:50 -0500 Subject: [PATCH 5/7] Write typed JSON.stringify arrays from their slots and append fixed text inline The emitted JSON writers read each array element through scr_arr_state and scr_arr_get_ref, retaining and releasing it, and appended every bracket, comma and key through a runtime call. Arrays whose indices below the length all hold values now serialize from their slots (scr_arr_dense_slots) with borrowed elements; other arrays keep the element walk. Fixed text is stored inline when it fits the buffer's spare capacity, booleans write their literal inline, and numbers are formatted directly into the buffer. --- packages/compiler/src/backend/llvm/walkers.ts | 137 ++++++++++++++++-- .../5305-json-stringify-typed-arrays.ts.json | 6 + packages/runtime/src/scr_array.c | 11 ++ packages/runtime/src/scr_json.c | 7 +- packages/runtime/src/scr_runtime.h | 9 ++ packages/runtime/test/test_array.c | 42 ++++++ .../5305-json-stringify-typed-arrays.ts | 114 +++++++++++++++ tests/harness/self-hosting-emission-cases.ts | 2 +- tests/harness/wasi-differential.test.ts | 2 + 9 files changed, 316 insertions(+), 14 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5305-json-stringify-typed-arrays.ts.json create mode 100644 tests/corpus/5305-json-stringify-typed-arrays.ts diff --git a/packages/compiler/src/backend/llvm/walkers.ts b/packages/compiler/src/backend/llvm/walkers.ts index f0f74a9e75..469b6405ba 100644 --- a/packages/compiler/src/backend/llvm/walkers.ts +++ b/packages/compiler/src/backend/llvm/walkers.ts @@ -17,6 +17,7 @@ import { InternalCompilerError } from "../../errors.js"; import type { IrRecordShape, IrType, IrUnionDef } from "../../ir/ir.js"; import { isRefCounted, typeKey } from "../../ir/ir.js"; import { jsonObjectKeyLabel } from "../json-literal.js"; +import { llvmBytes, wtf8Bytes } from "../literals.js"; import { mangleRecordStruct } from "../mangle.js"; import { BlockBuilder } from "./blocks.js"; import { llvmCommentText } from "./common.js"; @@ -73,17 +74,61 @@ export class LlWalkers { /* ── the byte plumbing shared by every walker ─────────────────────────── */ private putc(B: BlockBuilder, buf: string, byte: string): void { - this.host.declare(`declare void @scr_jb_putc(ptr, i8)`); - B.line(`call void @scr_jb_putc(ptr ${buf}, i8 ${byte})`); + this.appendBytes(B, buf, String.fromCharCode(Number(byte)), () => { + this.host.declare(`declare void @scr_jb_putc(ptr, i8)`); + B.line(`call void @scr_jb_putc(ptr ${buf}, i8 ${byte})`); + }); } /** Fixed text and JSON tokens hold no lone surrogate, so they append * without the builder's surrogate-pair seam check. */ private puts(B: BlockBuilder, buf: string, text: string): void { - this.host.declare(`declare void @scr_jb_write_utf8(ptr, ptr, ${this.S})`); + this.appendBytes(B, buf, text, () => { + this.host.declare(`declare void @scr_jb_write_utf8(ptr, ptr, ${this.S})`); + B.line( + `call void @scr_jb_write_utf8(ptr ${buf}, ptr ${this.host.cstr(text)}, ${this.S} ${Buffer.byteLength(text, "utf8")}) ; ${JSON.stringify(text)}`, + ); + }); + } + + /** Appends constant text: stored inline when it fits the buffer's spare + * capacity, else through `grow`, the runtime append that reallocates. + * ScrJsonBuf starts with { char *data; size_t len; size_t cap; }; an + * unallocated buffer has cap 0 and always takes the runtime append. */ + private appendBytes(B: BlockBuilder, buf: string, text: string, grow: () => void): void { + const bytes = wtf8Bytes(text); + const S = this.S; + const header = `{ ptr, ${S}, ${S} }`; + const lenp = B.tmp(), + len = B.tmp(), + capp = B.tmp(), + cap = B.tmp(), + end = B.tmp(), + fits = B.tmp(); + B.line(`${lenp} = getelementptr inbounds ${header}, ptr ${buf}, i32 0, i32 1`); + B.line(`${len} = load ${S}, ptr ${lenp}`); + B.line(`${capp} = getelementptr inbounds ${header}, ptr ${buf}, i32 0, i32 2`); + B.line(`${cap} = load ${S}, ptr ${capp}`); + B.line(`${end} = add nuw ${S} ${len}, ${bytes.length}`); + B.line(`${fits} = icmp ule ${S} ${end}, ${cap}`); + const inline = B.newLabel("jb.put"), + slow = B.newLabel("jb.grow"), + done = B.newLabel("jb.done"); + B.condBr(fits, inline, slow); + B.startBlock(inline); + const data = B.tmp(), + at = B.tmp(); + B.line(`${data} = load ptr, ptr ${buf}`); + B.line(`${at} = getelementptr inbounds i8, ptr ${data}, ${S} ${len}`); B.line( - `call void @scr_jb_write_utf8(ptr ${buf}, ptr ${this.host.cstr(text)}, ${this.S} ${Buffer.byteLength(text, "utf8")}) ; ${JSON.stringify(text)}`, + `store [${bytes.length} x i8] c"${llvmBytes(bytes, false)}", ptr ${at}, align 1 ; ${JSON.stringify(text)}`, ); + B.line(`store ${S} ${end}, ptr ${lenp}`); + B.br(done); + B.startBlock(slow); + grow(); + B.br(done); + B.startBlock(done); } /** Appends a borrowed string, including embedded NUL bytes, in one write. */ @@ -155,12 +200,17 @@ export class LlWalkers { ); break; case "bool": { - const s = B.tmp(); - this.host.declare(`declare void @scr_jb_puts(ptr, ptr)`); - B.line( - `${s} = select i1 %v, ptr ${this.host.cstr("true")}, ptr ${this.host.cstr("false")}`, - ); - B.line(`call void @scr_jb_puts(ptr %b, ptr ${s})`); + const yes = B.newLabel("jwb.t"), + no = B.newLabel("jwb.f"), + done = B.newLabel("jwb.d"); + B.condBr("%v", yes, no); + B.startBlock(yes); + this.puts(B, "%b", "true"); + B.br(done); + B.startBlock(no); + this.puts(B, "%b", "false"); + B.br(done); + B.startBlock(done); break; } case "string": @@ -455,6 +505,8 @@ export class LlWalkers { // like a cycle-capable record. if (cyclic) this.jbEnter(B, true); this.putc(B, "%b", "91"); // '[' + const finish = B.newLabel("jwa.end"); + if (elem.kind !== "bool") this.emitDenseArrayElements(B, elem, w, cyclic, finish); const len = B.tmp(); B.line(`${len} = call double @scr_arr_len(ptr %v)`); B.countedLoop(len, (i) => { @@ -506,10 +558,75 @@ export class LlWalkers { B.br(doneBlock); B.startBlock(doneBlock); }); + B.br(finish); + B.startBlock(finish); this.putc(B, "%b", "93"); // ']' if (cyclic) this.jbLeave(B); } + /** Writes the elements of an array whose indices below its length all + * hold values in dense storage straight from its 8-byte slots, borrowing + * each element (serialization runs no script code, so nothing can + * change the array), then branches to `finish`. Other arrays continue + * in the current block with the general element walk. */ + private emitDenseArrayElements( + B: BlockBuilder, + elem: IrType, + w: string, + cyclic: boolean, + finish: string, + ): void { + const S = this.S; + this.host.declare(`declare ptr @scr_arr_dense_slots(ptr, ptr)`); + const lenSlot = B.slot(), + indexSlot = B.slot(); + B.entryAllocas.push(`${lenSlot} = alloca ${S}`, `${indexSlot} = alloca ${S}`); + const slots = B.tmp(), + dense = B.tmp(); + B.line(`${slots} = call ptr @scr_arr_dense_slots(ptr %v, ptr ${lenSlot})`); + B.line(`${dense} = icmp ne ptr ${slots}, null`); + const start = B.newLabel("jwd.start"), + general = B.newLabel("jwd.general"), + check = B.newLabel("jwd.c"), + body = B.newLabel("jwd.b"); + B.condBr(dense, start, general); + B.startBlock(start); + const len = B.tmp(); + B.line(`${len} = load ${S}, ptr ${lenSlot}`); + B.line(`store ${S} 0, ptr ${indexSlot}`); + B.br(check); + B.startBlock(check); + const i = B.tmp(), + more = B.tmp(); + B.line(`${i} = load ${S}, ptr ${indexSlot}`); + B.line(`${more} = icmp ult ${S} ${i}, ${len}`); + B.condBr(more, body, finish); + B.startBlock(body); + const later = B.tmp(), + comma = B.newLabel("jwd.cm"), + value = B.newLabel("jwd.v"); + B.line(`${later} = icmp ne ${S} ${i}, 0`); + B.condBr(later, comma, value); + B.startBlock(comma); + this.putc(B, "%b", "44"); // ',' + B.br(value); + B.startBlock(value); + if (cyclic) this.jbEdgeIdx(B, i); + const at = B.tmp(), + raw = B.tmp(), + v = B.tmp(); + B.line(`${at} = getelementptr inbounds i64, ptr ${slots}, ${S} ${i}`); + B.line(`${raw} = load i64, ptr ${at}`); + if (elem.kind === "f64") B.line(`${v} = bitcast i64 ${raw} to double`); + else B.line(`${v} = inttoptr i64 ${raw} to ptr`); + B.line(`call void @${w}(ptr %b, ${this.valTy(elem)} ${v}) ; borrowed`); + const next = B.tmp(); + B.line(`${next} = add nuw ${S} ${i}, 1`); + B.line(`store ${S} ${next}, ptr ${indexSlot}`); + B.br(check); + B.startBlock(general); + } + private emitUnionWriter(B: BlockBuilder, unionId: string): void { const def = this.host.unionsById.get(unionId); if (!def) diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5305-json-stringify-typed-arrays.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5305-json-stringify-typed-arrays.ts.json new file mode 100644 index 0000000000..26be4a4122 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5305-json-stringify-typed-arrays.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5305-json-stringify-typed-arrays.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_array.c b/packages/runtime/src/scr_array.c index e51a85a59a..5b534ee81a 100644 --- a/packages/runtime/src/scr_array.c +++ b/packages/runtime/src/scr_array.c @@ -3390,6 +3390,17 @@ static bool scr_arr_dense_values(const ScrArr *a) { return all; } +/* The 8-byte slots of `a` when every index below its length holds a value + * in dense storage, with the length in *len; NULL for holes, + * storage-level undefined, a sparse tail, an empty array, or boolean + * elements (stored in 1-byte slots). The slots are borrowed and stay valid + * while nothing writes the array. */ +const uint64_t *scr_arr_dense_slots(const ScrArr *a, size_t *len) { + if (a->len == 0 || a->elem == SCR_ELEM_BOOL || !scr_arr_dense_values(a)) return NULL; + *len = a->len; + return a->data; +} + /* The dense comparator sort: `a.sort(f)` (or, with `owned`, the private copy * of `a.toSorted(f)`) when every index below the length holds a value. * Returns false, having run no user code, when the array has holes, diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index 0f712ca4ab..2780583a38 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -237,9 +237,10 @@ void scr_jb_put_str(ScrJsonBuf *b, const ScrStr *s) { void scr_jb_puts(ScrJsonBuf *b, const char *s) { scr_jb_write(b, s, strlen(s)); } void scr_jb_put_number(ScrJsonBuf *b, double v) { - char buf[32]; - size_t n = scr_f64_to_str(v, buf); - scr_jb_write_utf8(b, buf, n); /* number text is ASCII */ + /* scr_f64_to_str writes at most 31 ASCII bytes and a NUL into the + * buffer's spare capacity; the NUL is not counted. */ + scr_jb_grow(b, 32); + b->len += scr_f64_to_str(v, b->data + b->len); } void scr_jb_put_f64(ScrJsonBuf *b, double v) { diff --git a/packages/runtime/src/scr_runtime.h b/packages/runtime/src/scr_runtime.h index 4d0b60ca9b..f7c9cb60ce 100644 --- a/packages/runtime/src/scr_runtime.h +++ b/packages/runtime/src/scr_runtime.h @@ -2064,6 +2064,10 @@ void scr_arr_sort_values(ScrArr *a, double count, struct ScrClosure *f, uint32_t * published; the caller then sorts a compacted snapshot. Otherwise sorts * and returns true; a pending exception from `f` leaves a shared `a` * unwritten (an owned copy then holds a permutation of its values). */ +/* The borrowed 8-byte slots of `a` when every index below its length holds + * a value in dense storage (length in *len); NULL for holes, storage-level + * undefined, sparse tails, empty arrays and boolean elements. */ +const uint64_t *scr_arr_dense_slots(const ScrArr *a, size_t *len); bool scr_arr_sort_dense(ScrArr *a, struct ScrClosure *f, uint32_t arity, bool owned, int32_t order, struct ScrClosure *key); @@ -5928,6 +5932,11 @@ typedef struct { size_t seen_len; size_t seen_cap; } ScrJsonBuf; +/* Emitted JSON writers append constant text inline (llvm/walkers.ts + * appendBytes) through this prefix. */ +_Static_assert(offsetof(ScrJsonBuf, data) == 0 && offsetof(ScrJsonBuf, len) == sizeof(char *) && + offsetof(ScrJsonBuf, cap) == sizeof(char *) + sizeof(size_t), + "LLVM backend expects ScrJsonBuf to start with { data, len, cap }"); void scr_jb_init(ScrJsonBuf *b); /* Append a borrowed byte span verbatim, including embedded NUL bytes. */ diff --git a/packages/runtime/test/test_array.c b/packages/runtime/test/test_array.c index f19024e132..c0f5b2e71c 100644 --- a/packages/runtime/test/test_array.c +++ b/packages/runtime/test/test_array.c @@ -1831,6 +1831,47 @@ static void test_typed_sort(void) { scr_bytes_release(three); } +/* scr_arr_dense_slots: the borrowed slots of hole-free dense arrays. */ +static void test_dense_slots(void) { + size_t len = 0; + ScrArr *nums = scr_arr_new(SCR_ELEM_F64, 0); + check(scr_arr_dense_slots(nums, &len) == NULL, "an empty array has no dense slots"); + for (int i = 0; i < 5; i++) scr_arr_push_f64(nums, i * 1.5); + const uint64_t *slots = scr_arr_dense_slots(nums, &len); + bool values = slots != NULL && len == 5; + for (size_t i = 0; values && i < len; i++) { + double v; + memcpy(&v, &slots[i], sizeof v); + values = v == (double)i * 1.5; + } + check(values, "dense number slots hold the values in order"); + scr_arr_set_undefined(nums, 2); + check(scr_arr_dense_slots(nums, &len) == NULL, "storage-level undefined has no dense slots"); + ScrArr *holes = scr_arr_new(SCR_ELEM_F64, 0); + scr_arr_push_f64(holes, 1); + scr_arr_set_f64(holes, 3, 2); + check(scr_arr_dense_slots(holes, &len) == NULL, "holes have no dense slots"); + ScrArr *flags = scr_arr_new(SCR_ELEM_BOOL, 0); + scr_arr_push_bool(flags, true); + check(scr_arr_dense_slots(flags, &len) == NULL, "boolean arrays have no 8-byte slots"); + ScrArr *words = scr_arr_new(SCR_ELEM_STR, 0); + ScrStr *word = scr_str_new("w", 1); + scr_arr_push_ref(words, scr_str_retain(word)); + slots = scr_arr_dense_slots(words, &len); + check(slots != NULL && len == 1 && (void *)(uintptr_t)slots[0] == word, + "dense reference slots hold borrowed pointers"); + ScrArr *wide = scr_arr_new(SCR_ELEM_F64, 0); + scr_arr_push_f64(wide, 1); + scr_arr_set_f64(wide, 3000000, 2); + check(scr_arr_dense_slots(wide, &len) == NULL, "a sparse tail has no dense slots"); + scr_str_release(word); + scr_arr_release(wide); + scr_arr_release(words); + scr_arr_release(flags); + scr_arr_release(holes); + scr_arr_release(nums); +} + int main(int argc, char **argv) { if (argc > 1) { ScrArr *a = scr_arr_new(SCR_ELEM_F64, 0); @@ -1856,6 +1897,7 @@ int main(int argc, char **argv) { test_primitive_sort(); test_comparator_sort(); test_keyed_sort(); + test_dense_slots(); test_typed_sort(); test_dense_comparator_sort(); test_f64_basics(); diff --git a/tests/corpus/5305-json-stringify-typed-arrays.ts b/tests/corpus/5305-json-stringify-typed-arrays.ts new file mode 100644 index 0000000000..a53d4c8b8e --- /dev/null +++ b/tests/corpus/5305-json-stringify-typed-arrays.ts @@ -0,0 +1,114 @@ +// JSON.stringify of typed values: dense and non-dense arrays of every +// element kind, nested arrays, special numbers, optional and union +// elements, tuples, non-ASCII keys, and output large enough to grow the +// buffer many times. +interface Item { + sku: string; + quantity: number; + price: number; + flags: boolean[]; +} +interface Order { + id: number; + "ключ": string; + "emoji 😀": number; + items: Item[]; + tags: string[]; + matrix: number[][]; + pair: [string, number]; + maybe: (string | null)[]; + note?: string; +} +interface Tree { + value: number; + children: Tree[]; +} + +let seed = 77; +function random(): number { + seed = (Math.imul(seed, 1103515245) + 12345) >>> 0; + return seed / 4294967296; +} + +function makeOrder(i: number, special: boolean): Order { + const items: Item[] = []; + for (let j = 0; j < 1 + (i % 4); j++) + items.push({ + sku: "sku-" + Math.floor(random() * 50), + quantity: j, + price: Math.round(random() * 10000) / 100, + flags: j % 2 === 0 ? [true, false] : [], + }); + return { + id: i, + "ключ": "значение " + i, + "emoji 😀": i * 0.5, + items, + tags: i % 3 === 0 ? [] : ["a\"b", "tab\there", "ü"], + matrix: special ? [[i, -0], [NaN, Infinity, -Infinity], []] : [[i, i * 2], []], + pair: ["p" + i, i / 3], + maybe: [null, "x", null], + note: i % 2 === 1 ? "odd" : undefined, + }; +} + +// Small values in full. +console.log(JSON.stringify(makeOrder(0, true))); +console.log(JSON.stringify(makeOrder(1, true))); +console.log(JSON.stringify([1, 2.5, -0, NaN, 1e21, 1e-7, -123.456])); +console.log(JSON.stringify([true, false, true]), JSON.stringify([] as number[]), JSON.stringify([[]] as number[][])); +console.log(JSON.stringify(["", "\u0000", "
", "\ud800", "naïve"])); + +// Holes, storage-level undefined and sparse tails take the general walk. +const holes: number[] = [1, 2, 3]; +holes[6] = 7; +console.log(JSON.stringify(holes)); +const strings: string[] = ["a"]; +strings[3] = "d"; +console.log(JSON.stringify(strings)); +const records: Item[] = []; +records[2] = { sku: "late", quantity: 1, price: 2, flags: [] }; +console.log(JSON.stringify(records)); +const optional: (number | undefined)[] = [1, undefined, 3]; +console.log(JSON.stringify(optional)); +const shrunk: number[] = [1, 2, 3, 4, 5]; +shrunk.length = 2; +console.log(JSON.stringify(shrunk)); +const sparse: number[] = []; +sparse[2000000] = 1; +sparse[0] = 5; +const sparseText = JSON.stringify(sparse); +console.log(sparseText.length, sparseText.slice(0, 12), sparseText.slice(-12)); + +// Large outputs grow the buffer at many different offsets. +const orders: Order[] = []; +for (let i = 0; i < 4000; i++) orders.push(makeOrder(i, false)); +const text = JSON.stringify(orders); +let hash = 0; +for (let i = 0; i < text.length; i += 7) hash = (Math.imul(hash, 31) + text.charCodeAt(i)) | 0; +console.log(text.length, hash, text.slice(0, 80)); +const parsed = JSON.parse(text) as Order[]; +console.log(parsed.length, parsed[3999]!.items.length, parsed[3999]!["ключ"], JSON.stringify(parsed) === text); +for (let size = 0; size < 300; size += 37) { + const values: number[] = []; + for (let i = 0; i < size; i++) values.push(i % 5 === 0 ? -i : i / 4); + console.log(size, JSON.stringify(values).length); +} + +// Recursive values: deep arrays of records, and a cycle through an array. +function tree(depth: number): Tree { + const node: Tree = { value: depth, children: [] }; + if (depth > 0) for (let i = 0; i < 3; i++) node.children.push(tree(depth - 1)); + return node; +} +const deep = JSON.stringify(tree(6)); +console.log(deep.length, deep.slice(0, 60)); +const root: Tree = { value: 1, children: [] }; +root.children.push({ value: 2, children: [root] }); +try { + JSON.stringify(root); +} catch (error) { + console.log((error as Error).name, (error as Error).message.split("\n")[0]); +} +const shared: Tree = { value: 3, children: [] }; +console.log(JSON.stringify({ value: 0, children: [shared, shared] } as Tree)); diff --git a/tests/harness/self-hosting-emission-cases.ts b/tests/harness/self-hosting-emission-cases.ts index 5e13f08d9b..53a307f881 100644 --- a/tests/harness/self-hosting-emission-cases.ts +++ b/tests/harness/self-hosting-emission-cases.ts @@ -369,7 +369,7 @@ export function emissionCases(): EmissionCase[] { add( "recursive JSON writers and indentation", writer, - ["@scr_jb_enter", "@scr_jb_put_f64"], + ["@scr_jb_enter", "@scr_jb_put_f64", "@scr_arr_dense_slots"], writerRequest, ); diff --git a/tests/harness/wasi-differential.test.ts b/tests/harness/wasi-differential.test.ts index 5b7c1669f2..96352d114a 100644 --- a/tests/harness/wasi-differential.test.ts +++ b/tests/harness/wasi-differential.test.ts @@ -238,6 +238,8 @@ describe.skipIf(!zigOnPath())("wasm32-wasi differential", () => { "5317-map-iterate-while-mutating.ts", "5318-set-iterate-after-deletes.ts", "5319-map-iteration-values.ts", + // JSON writers read array slots as pointers. + "5305-json-stringify-typed-arrays.ts", ])("the LLVM target runs %s byte-identically to Node", async (fixture) => { const entry = join(repoRoot, "tests/corpus", fixture); const outDir = await mkdtemp("/tmp/scriptc-wasi-"); From f7390b4f057419c4680e0fc5fbca8c713df38ab6 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 14 Oct 2026 18:12:09 -0500 Subject: [PATCH 6/7] Match Node 24.22 HTTP write coalescing, fetch connection headers and crypto.constants OutgoingMessage now corks the message for a tick like Node 24.22, so chunked writes in one tick (and a corked end(chunk)) go out as one chunk, for server responses and client requests. Fetch accepts a connection header that is a comma list of tokens, as Undici 7.29.1 does. The crypto.constants declaration matches the Node 24.22 table, with a pin test. --- .../ambient/scriptc-node-fallback.d.ts | 3 +- packages/compiler/test/node-pin.test.ts | 14 +++ packages/runtime/src/scr_fetch.c | 46 +++++--- packages/runtime/src/scr_http.c | 111 +++++++++++++++++- .../server/cases/http-client-chunked/main.ts | 39 ++++++ 5 files changed, 190 insertions(+), 23 deletions(-) create mode 100644 tests/fixtures/server/cases/http-client-chunked/main.ts diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts index 06833c8ade..166d7e57b6 100644 --- a/packages/compiler/ambient/scriptc-node-fallback.d.ts +++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts @@ -2291,7 +2291,7 @@ declare module "crypto" { * stance). Every ACCESS bakes as its literal at lowering; the object * itself never materializes (bare crypto.constants value uses fence). */ export interface CryptoConstants { - readonly OPENSSL_VERSION_NUMBER: 810549328; + readonly OPENSSL_VERSION_NUMBER: 810549376; readonly SSL_OP_ALL: 2147485776; readonly SSL_OP_ALLOW_NO_DHE_KEX: 1024; readonly SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: 262144; @@ -2331,6 +2331,7 @@ declare module "crypto" { readonly DH_UNABLE_TO_CHECK_GENERATOR: 4; readonly DH_NOT_SUITABLE_GENERATOR: 8; readonly RSA_PKCS1_PADDING: 1; + readonly RSA_SSLV23_PADDING: 2; readonly RSA_NO_PADDING: 3; readonly RSA_PKCS1_OAEP_PADDING: 4; readonly RSA_X931_PADDING: 5; diff --git a/packages/compiler/test/node-pin.test.ts b/packages/compiler/test/node-pin.test.ts index 9b9e709684..41861e8ea1 100644 --- a/packages/compiler/test/node-pin.test.ts +++ b/packages/compiler/test/node-pin.test.ts @@ -7,6 +7,7 @@ import { join } from "node:path"; import { expect, test } from "vitest"; import { NODE24_FETCH_COMPAT_PROFILE } from "../src/compat/fetch-profile.js"; import { NODE_COMPAT_VERSION } from "../src/frontend/lowering/builtins/process.js"; +import { CRYPTO_CONSTANTS } from "../src/frontend/lowering/crypto-tables.js"; const repoRoot = join(import.meta.dirname, "../../.."); const read = (path: string): string => readFileSync(join(repoRoot, path), "utf8"); @@ -29,3 +30,16 @@ test("the Node pins agree", () => { `snapshot?.nodeVersion ?? "${pinned}"`, ); }); + +test("the crypto.constants declaration matches the baked table", () => { + const dts = read("packages/compiler/ambient/scriptc-node-fallback.d.ts"); + const start = dts.indexOf("export interface CryptoConstants {"); + const body = dts.slice(start, dts.indexOf("\n }\n", start)); + const declared = Object.fromEntries( + [...body.matchAll(/readonly (\w+): (-?\d+|"[^"]*");/g)].map(([, name, value]) => [ + name!, + JSON.parse(value!) as number | string, + ]), + ); + expect(declared).toEqual(CRYPTO_CONSTANTS); +}); diff --git a/packages/runtime/src/scr_fetch.c b/packages/runtime/src/scr_fetch.c index 467fa74809..fb8d67f4ca 100644 --- a/packages/runtime/src/scr_fetch.c +++ b/packages/runtime/src/scr_fetch.c @@ -3204,26 +3204,28 @@ static bool sf_header_name_ci( return true; } -static bool sf_header_value_ci(const ScrStr *value, const char *want) { +/* Undici's connection rule: a comma list whose trimmed entries are all + * HTTP tokens. Answers whether one of them is "close" in *close. */ +static bool sf_connection_tokens(const ScrStr *value, bool *close) { + *close = false; size_t start = 0; - size_t end = value->len; - while (start < end && - (value->data[start] == ' ' || value->data[start] == '\t')) { - start++; + for (size_t i = 0; i <= value->len; i++) { + if (i < value->len && value->data[i] != ',') continue; + size_t a = start, b = i; + while (a < b && (value->data[a] == ' ' || value->data[a] == '\t')) a++; + while (b > a && (value->data[b - 1] == ' ' || value->data[b - 1] == '\t')) b--; + if (!sf_header_name_ok(value->data + a, b - a)) return false; + if (sf_header_name_ci(value->data + a, b - a, "close")) *close = true; + start = i + 1; } - while (end > start && - (value->data[end - 1] == ' ' || value->data[end - 1] == '\t')) { - end--; - } - return sf_header_name_ci( - value->data + start, end - start, want); + return true; } static bool sf_request_header_ok( const char *name, size_t name_len, const ScrStr *value) { if (sf_header_name_ci(name, name_len, "connection")) { - return sf_header_value_ci(value, "close") || - sf_header_value_ci(value, "keep-alive"); + bool close; + return sf_connection_tokens(value, &close); } return !sf_header_name_ci(name, name_len, "transfer-encoding") && @@ -4186,13 +4188,25 @@ static bool sf_start_hop(SfTransfer *t) { } sf_push_header_text(headers, "host", authority, (size_t)authority_len); - if (!sf_pairs_have(t->headers, "connection")) { - sf_push_header_text(headers, "connection", "keep-alive", 10); + /* The user's connection header only chooses close over keep-alive (a + * "close" token); the transport writes its own value after host. */ + bool connection_close = false; + for (size_t i = 0; i + 1 < user_len; i += 2) { + ScrStr *name = scr_arr_get_ref(t->headers, (double)i); + if (sf_eq_ci(name, "connection")) { + ScrStr *value = scr_arr_get_ref(t->headers, (double)(i + 1)); + bool close; + if (sf_connection_tokens(value, &close) && close) connection_close = true; + scr_str_release(value); + } + scr_str_release(name); } + if (connection_close) sf_push_header_text(headers, "connection", "close", 5); + else sf_push_header_text(headers, "connection", "keep-alive", 10); for (size_t i = 0; i + 1 < user_len; i += 2) { ScrStr *name = scr_arr_get_ref(t->headers, (double)i); ScrStr *value = scr_arr_get_ref(t->headers, (double)(i + 1)); - if (sf_eq_ci(name, "host")) { + if (sf_eq_ci(name, "host") || sf_eq_ci(name, "connection")) { scr_str_release(name); scr_str_release(value); continue; diff --git a/packages/runtime/src/scr_http.c b/packages/runtime/src/scr_http.c index 9616b5fc57..d9c2f75ee8 100644 --- a/packages/runtime/src/scr_http.c +++ b/packages/runtime/src/scr_http.c @@ -902,6 +902,10 @@ struct ScrHttpRes { int corked; char *cork_buf; size_t cork_len, cork_cap; + /* A write while corked commits the head (headersSent, Node's implicit + * header) and holds its bytes here until the flush sends them first. */ + char *held_head; + size_t held_head_len, held_head_cap; /* res.req: the paired request (+1; req never points back — no cycle). * A `res.req = null` write clears the READ (req_cleared) — Node's * plain-property write. */ @@ -940,6 +944,7 @@ void scr_http_res_release(ScrHttpRes *r) { scr_net_ls_drop(&r->endcb_ls); scr_net_ls_drop(&r->wcb_ls); free(r->cork_buf); + free(r->held_head); if (r->req_ref) scr_http_req_release(r->req_ref); if (r->sock) scr_net_sock_release(r->sock); if (r->h2_stream) scr_http_h2_ops->release(r->h2_stream); @@ -1568,6 +1573,15 @@ static void scr_http_cork_buffer(char **buf, size_t *held_len, size_t *held_cap, static void scr_http_res_write_raw(ScrHttpRes *r, const char *data, size_t len) { if (r->finished) return; if (r->corked > 0) { + /* Node's write_() builds the implicit head even while corked */ + if (!r->head_sent && r->h2_stream == NULL) { + ScrHttpBuf held = {NULL, 0, 0}; + if (!scr_http_res_build_head(r, -1, &held)) return; + r->held_head = held.data; + r->held_head_len = held.len; + r->held_head_cap = held.cap; + } + if (scr_exc_pending()) return; scr_http_cork_buffer(&r->cork_buf, &r->cork_len, &r->cork_cap, data, len); return; } @@ -1579,12 +1593,32 @@ static void scr_http_res_write_raw(ScrHttpRes *r, const char *data, size_t len) } /* streaming: the implicit head (chunked unless the user fixed the * length) leaves with this first chunk */ - ScrHttpBuf head = {NULL, 0, 0}; + ScrHttpBuf head = {r->held_head, r->held_head_len, r->held_head_cap}; + r->held_head = NULL; + r->held_head_len = r->held_head_cap = 0; if (!r->head_sent && !scr_http_res_build_head(r, -1, &head)) return; if (!scr_exc_pending()) scr_http_res_emit(r, &head, data, len, false); free(head.data); } +/* Node 24.22's write_(): a write with the socket uncorked corks the + * message and uncorks it on the next tick, so the chunked writes of one + * tick go out as one chunk. */ +static void scr_http_res_autocork_nt(ScrClosure *cb) { + ScrHttpRes *r = scr_box_get_ref(cb->caps[0]); + if (r->corked > 0) scr_http_res_uncork(r); + scr_http_res_release(r); +} + +static void scr_http_res_autocork(ScrHttpRes *r) { + if (r->finished || r->h2_stream != NULL || r->sock == NULL || r->corked > 0) return; + r->corked++; + ScrClosure *cb = scr_closure_new((void *)&scr_http_res_autocork_nt, 1); + cb->caps[0] = scr_box_new_obj(&scr_http_res_retain_v, &scr_http_res_release_v, NULL); + scr_box_set_ref(cb->caps[0], scr_http_res_retain(r)); + scr_next_tick(cb); +} + void scr_http_res_write_str(ScrHttpRes *r, ScrStr *data /*borrowed*/) { double expected; if (r->head_sent && scr_http_res_expected_length(r, &expected) && @@ -1595,6 +1629,7 @@ void scr_http_res_write_str(ScrHttpRes *r, ScrStr *data /*borrowed*/) { return; } if (r->strict_content_length) r->strict_bytes_written += data->len; + scr_http_res_autocork(r); char *owned; const char *bytes = scr_str_utf8(data, &owned); scr_http_res_write_raw(r, bytes, data->len); @@ -1612,6 +1647,7 @@ void scr_http_res_write_bytes(ScrHttpRes *r, ScrBytes *data /*borrowed*/) { return; } if (r->strict_content_length) r->strict_bytes_written += (data->len * scr_bytes_elem_size(data->elem)); + scr_http_res_autocork(r); scr_http_res_write_raw(r, (const char *)data->data, (data->len * scr_bytes_elem_size(data->elem))); } @@ -1669,7 +1705,7 @@ static void scr_http_queue_res_finish(ScrHttpRes *res); /* Flush corked bytes as one write (corked already zero, or forced by * end()). */ static void scr_http_res_cork_flush(ScrHttpRes *r) { - if (r->cork_len == 0) return; + if (r->cork_len == 0 && r->held_head_len == 0) return; char *held = r->cork_buf; size_t held_len = r->cork_len; r->cork_buf = NULL; @@ -1689,9 +1725,15 @@ static void scr_http_res_end_raw(ScrHttpRes *r, const char *data, size_t len) { return; } if (r->strict_content_length) r->strict_bytes_written += len; - if (r->corked > 0 || r->cork_len > 0) { + if (r->corked > 0 || r->cork_len > 0 || r->held_head_len > 0) { /* end() flushes every cork level (Node) — the body streamed, so the - * framing below takes the already-committed streaming path */ + * framing below takes the already-committed streaming path. A corked + * chunked message buffers end()'s chunk too: one chunk goes out. */ + if (r->corked > 0 && r->head_sent && r->chunked && r->h2_stream == NULL && len > 0) { + scr_http_cork_buffer(&r->cork_buf, &r->cork_len, &r->cork_cap, data, len); + data = ""; + len = 0; + } r->corked = 0; scr_http_res_cork_flush(r); if (scr_exc_pending()) return; @@ -3303,6 +3345,10 @@ struct ScrHttpClientReq { int corked; char *cork_buf; size_t cork_len, cork_cap; + /* the head a corked write committed, sent first at the flush */ + char *held_head; + size_t held_head_len, held_head_cap; + bool hold_head; bool ended; bool destroyed; bool aborted; @@ -3354,6 +3400,7 @@ void scr_http_client_release(ScrHttpClientReq *c) { free(c->hvalues); scr_http_trailers_clear(&c->trailers); free(c->cork_buf); + free(c->held_head); if (c->res) scr_http_req_release(c->res); if (c->sock) scr_net_sock_release(c->sock); #ifdef SCR_RC_AUDIT @@ -3662,18 +3709,42 @@ static void scr_http_client_send_head(ScrHttpClientReq *c, long long body_len) { } scr_http_buf_str(&b, "\r\n"); c->head_sent = true; + if (c->hold_head) { + c->held_head = b.data; + c->held_head_len = b.len; + c->held_head_cap = b.cap; + return; + } if (c->sock) scr_net_sock_write_native(c->sock, b.data, b.len); free(b.data); } +static void scr_http_client_send_held_head(ScrHttpClientReq *c) { + if (c->held_head == NULL) return; + char *head = c->held_head; + size_t len = c->held_head_len; + c->held_head = NULL; + c->held_head_len = c->held_head_cap = 0; + if (c->sock) scr_net_sock_write_native(c->sock, head, len); + free(head); +} + static void scr_http_client_write_raw(ScrHttpClientReq *c, const char *data, size_t len) { if (c->ended || c->destroyed || c->close_emitted) return; /* write-after-end drops (divergence 48's stance) */ if (c->corked > 0) { + /* Node's write_() builds the implicit head even while corked */ + if (!c->head_sent) { + c->hold_head = true; + scr_http_client_send_head(c, -1); + c->hold_head = false; + if (scr_exc_pending()) return; + } scr_http_cork_buffer(&c->cork_buf, &c->cork_len, &c->cork_cap, data, len); return; } if (!c->head_sent) scr_http_client_send_head(c, -1); /* streaming: chunked */ if (scr_exc_pending()) return; + scr_http_client_send_held_head(c); if (!c->sock || len == 0) return; if (c->chunked) { char size[32]; @@ -3686,7 +3757,28 @@ static void scr_http_client_write_raw(ScrHttpClientReq *c, const char *data, siz } } +/* Node 24.22's write_(): once the request has its socket, a write with the + * socket uncorked corks the message and uncorks it on the next tick, so the + * chunked writes of one tick go out as one chunk. */ +static void scr_http_client_autocork_nt(ScrClosure *cb) { + ScrHttpClientReq *c = scr_box_get_ref(cb->caps[0]); + if (c->corked > 0) scr_http_client_uncork(c); + scr_http_client_release(c); +} + +static void scr_http_client_autocork(ScrHttpClientReq *c) { + if (c->ended || c->destroyed || c->close_emitted || !c->socket_emitted || c->sock == NULL || + c->corked > 0) + return; + c->corked++; + ScrClosure *cb = scr_closure_new((void *)&scr_http_client_autocork_nt, 1); + cb->caps[0] = scr_box_new_obj(&scr_http_client_retain_v, &scr_http_client_release_v, NULL); + scr_box_set_ref(cb->caps[0], scr_http_client_retain(c)); + scr_next_tick(cb); +} + void scr_http_client_write_str(ScrHttpClientReq *c, ScrStr *data /*borrowed*/) { + scr_http_client_autocork(c); char *owned; const char *bytes = scr_str_utf8(data, &owned); scr_http_client_write_raw(c, bytes, data->len); @@ -3695,11 +3787,12 @@ void scr_http_client_write_str(ScrHttpClientReq *c, ScrStr *data /*borrowed*/) { void scr_http_client_write_bytes(ScrHttpClientReq *c, ScrBytes *data /*borrowed*/) { SCR_BYTES_SNAPSHOT(data); + scr_http_client_autocork(c); scr_http_client_write_raw(c, (const char *)data->data, (data->len * scr_bytes_elem_size(data->elem))); } static void scr_http_client_cork_flush(ScrHttpClientReq *c) { - if (c->cork_len == 0) return; + if (c->cork_len == 0 && c->held_head == NULL) return; char *held = c->cork_buf; size_t held_len = c->cork_len; c->cork_buf = NULL; @@ -3719,7 +3812,13 @@ double scr_http_client_writable_corked(ScrHttpClientReq *c) { return (double)c-> static void scr_http_client_end_raw(ScrHttpClientReq *c, const char *data, size_t len) { if (c->ended || c->destroyed || c->close_emitted) return; - if (c->corked > 0 || c->cork_len > 0) { + if (c->corked > 0 || c->cork_len > 0 || c->held_head != NULL) { + /* A corked chunked request buffers end()'s chunk too: one chunk. */ + if (c->corked > 0 && c->head_sent && c->chunked && len > 0) { + scr_http_cork_buffer(&c->cork_buf, &c->cork_len, &c->cork_cap, data, len); + data = ""; + len = 0; + } c->corked = 0; scr_http_client_cork_flush(c); if (scr_exc_pending()) return; diff --git a/tests/fixtures/server/cases/http-client-chunked/main.ts b/tests/fixtures/server/cases/http-client-chunked/main.ts new file mode 100644 index 0000000000..d5cb508f18 --- /dev/null +++ b/tests/fixtures/server/cases/http-client-chunked/main.ts @@ -0,0 +1,39 @@ +/* A client request's chunked writes: once the request has its socket, the + * writes of one tick (and an end() chunk) go out as one chunk; writes made + * before the 'socket' event keep a chunk each. The raw server prints the body as + * it arrived on the wire. */ +import { createServer } from "node:net"; +import { request } from "node:http"; + +const server = createServer((socket) => { + let data = ""; + socket.on("data", (chunk: Buffer) => { + data += chunk.toString("latin1"); + if (data.endsWith("0\r\n\r\n")) { + console.log(JSON.stringify(data.slice(data.indexOf("\r\n\r\n") + 4))); + socket.end("HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"); + server.close(); + } + }); +}); + +server.listen(0, "127.0.0.1", () => { + const port = (server.address() as { port: number }).port; + const req = request( + { host: "127.0.0.1", port, method: "POST", headers: { "transfer-encoding": "chunked" } }, + (res) => { + res.resume(); + res.on("end", () => console.log("response", res.statusCode)); + }, + ); + req.write("a"); + req.write("b"); + req.on("socket", () => { + req.write("c"); + req.write("d"); + setImmediate(() => { + req.write("e"); + req.end("f"); + }); + }); +}); From b710e74acbe1fd8869009c6f7b7b7a89d0d9e8c6 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 14 Oct 2026 18:25:05 -0500 Subject: [PATCH 7/7] Lower value-position writes to the writable Event accessors Assignments to returnValue and cancelBubble on a typed Event subclass receiver lower in value position as well as in statements: an initializer (`const r = (ev.returnValue = false)`), a call argument, and a chained assignment write the accessor through event.set and yield the assigned value. The short-circuit forms (&&=, ||=, ??=) read the accessor through event.get and write it only on the branch that assigns. The receiver now evaluates before the assigned value, as in Node. --- .../expressions/nullish-assignment.ts | 13 +++ .../frontend/lowering/lower-event-target.ts | 88 ++++++++++++++----- .../src/frontend/lowering/lower-exprs.ts | 8 +- tests/corpus/5241-event-subclass.ts | 31 +++++++ tests/corpus/5244-event-target-subclass.js | 4 + 5 files changed, 121 insertions(+), 23 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/expressions/nullish-assignment.ts b/packages/compiler/src/frontend/lowering/expressions/nullish-assignment.ts index dad2dfb549..5ef3991da2 100644 --- a/packages/compiler/src/frontend/lowering/expressions/nullish-assignment.ts +++ b/packages/compiler/src/frontend/lowering/expressions/nullish-assignment.ts @@ -18,6 +18,11 @@ import { arrayNumberRead, arrayValueRead, arrayValueStore } from "../array-value import { fenceNodeModuleMutation } from "../lower-node-module.js"; import { globalSymbolKey } from "./global-symbols.js"; import { tryLowerExpression } from "./try-lower-expression.js"; +import { + eventAccessorRead, + eventAccessorWrite, + isEventWritableAccessor, +} from "../lower-event-target.js"; /** Element kinds whose present values are never null or undefined. */ const NON_NULLISH_ELEMENTS: ReadonlySet = new Set([ @@ -80,6 +85,14 @@ export function lowerShortCircuitAssignment(lowerer: Lowerer, expr: ts.BinaryExp expr: { kind: "libCall", fn: "dyn.globalSymbolSet", args: [key, value], type: VOID, loc }, loc, }); + } else if (ts.isPropertyAccessExpression(target) && isEventWritableAccessor(lowerer, target)) { + // returnValue/cancelBubble on an Event subclass instance: the + // accessors read and write the event. + const receiver = save(lowerer.lowerExpr(target.expression), "%shortCircuitReceiver"); + const name = target.name.text; + storage = BOOL; + read = eventAccessorRead(receiver, name, lowerer, loc); + write = (value) => eventAccessorWrite(receiver, name, value, lowerer, loc); } else if (ts.isPropertyAccessExpression(target)) { const probed = tryLowerExpression(lowerer, target.expression); if (probed?.type.kind === "dyn") { diff --git a/packages/compiler/src/frontend/lowering/lower-event-target.ts b/packages/compiler/src/frontend/lowering/lower-event-target.ts index 8088e690d5..e6230009d2 100644 --- a/packages/compiler/src/frontend/lowering/lower-event-target.ts +++ b/packages/compiler/src/frontend/lowering/lower-event-target.ts @@ -344,42 +344,86 @@ export function lowerEventObjectProperty( return typedResult(lowerer, expr, value); } +/** Whether `target` is `returnValue` or `cancelBubble` (the two writable + * accessors) on a typed receiver of an Event subclass. */ +export function isEventWritableAccessor( + lowerer: Lowerer, + target: ts.PropertyAccessExpression, +): boolean { + const name = target.name.text; + if (name !== "returnValue" && name !== "cancelBubble") return false; + if (target.questionDotToken) return false; + const recvT = lowerer.mapTypeOf(lowerer.typeOf(target.expression)); + if (recvT?.kind !== "object") return false; + return eventTargetRootOf(lowerer.classes.get(recvT.className)) === "event"; +} + +/** The event.set write of an Event subclass's writable accessor. */ +export function eventAccessorWrite( + receiver: IrExpr, + name: string, + value: IrExpr, + lowerer: Lowerer, + loc: SrcLoc, +): IrStmt { + return { + kind: "exprStmt", + expr: { + kind: "libCall", + fn: "event.set", + args: [receiver, strLit(name, loc), lowerer.coerceToExpected(value, DYN)], + type: VOID, + loc, + }, + loc, + }; +} + +/** The event.get read of an Event subclass's writable accessor, typed as + * the accessor's boolean. */ +export function eventAccessorRead( + receiver: IrExpr, + name: string, + lowerer: Lowerer, + loc: SrcLoc, +): IrExpr { + return lowerer.coerceToExpected( + { kind: "libCall", fn: "event.get", args: [receiver, strLit(name, loc)], type: DYN, loc }, + BOOL, + ); +} + /** `event.returnValue = v` / `event.cancelBubble = v` on a typed receiver - * (the two writable accessors), or null when the target is not one. */ + * of an Event subclass, in statement or value position, or null when the + * target is not one. The receiver evaluates before the value, and the + * expression's value is the assigned one, whatever the setter does. */ export function lowerEventObjectPropertyWrite( lowerer: Lowerer, target: ts.PropertyAccessExpression, value: ts.Expression, ): IrExpr | null { - const name = target.name.text; - if (name !== "returnValue" && name !== "cancelBubble") return null; - const recvT = lowerer.mapTypeOf(lowerer.typeOf(target.expression)); - if (recvT?.kind !== "object") return null; - if (eventTargetRootOf(lowerer.classes.get(recvT.className)) !== "event") return null; + if (!isEventWritableAccessor(lowerer, target)) return null; const loc = locOf(target); const receiver = lowerer.lowerExpr(target.expression); - const assigned = lowerer.lowerExprExpecting(value, DYN); - // The assignment's value is the assigned one, whatever the setter does. - const local = lowerer.declareHiddenLocal("%eventAssigned", DYN); - const ref: IrExpr = { kind: "varRef", localId: local.id, type: DYN, loc }; + const receiverLocal = lowerer.declareHiddenLocal("%eventReceiver", receiver.type); + const receiverRef: IrExpr = { + kind: "varRef", + localId: receiverLocal.id, + type: receiver.type, + loc, + }; + const assigned = lowerer.lowerExpr(value); + const local = lowerer.declareHiddenLocal("%eventAssigned", assigned.type); + const ref: IrExpr = { kind: "varRef", localId: local.id, type: assigned.type, loc }; return { kind: "seqExpr", stmts: [ + { kind: "varDecl", localId: receiverLocal.id, init: receiver, loc }, { kind: "varDecl", localId: local.id, init: assigned, loc }, - { - kind: "exprStmt", - expr: { - kind: "libCall", - fn: "event.set", - args: [receiver, strLit(name, loc), ref], - type: VOID, - loc, - }, - loc, - }, + eventAccessorWrite(receiverRef, target.name.text, ref, lowerer, loc), ], result: ref, - type: DYN, + type: assigned.type, loc, }; } diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index 730fa46edf..601c5cada1 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -1,5 +1,5 @@ import { generatorDrain } from "./iterator-adapters.js"; -import { lowerEventObjectProperty } from "./lower-event-target.js"; +import { lowerEventObjectProperty, lowerEventObjectPropertyWrite } from "./lower-event-target.js"; import { lowerEventStaticProperty } from "./builtins/numbers.js"; import { lowerUnionEquality, tagEqualityMayMissAlias } from "./strict-equality.js"; import { isOptionalProcessStreamProperty } from "./builtins/process.js"; @@ -9306,6 +9306,12 @@ export function lowerBinary(lowerer: Lowerer, expr: ts.BinaryExpression): IrExpr if (ts.isPropertyAccessExpression(expr.left) || ts.isElementAccessExpression(expr.left)) { fenceNodeModuleMutation(lowerer, expr.left, "assignment"); } + // The writable Event accessors on Event subclass instances, in value + // position (`const r = (event.returnValue = false)`). + if (op === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(expr.left)) { + const eventWrite = lowerEventObjectPropertyWrite(lowerer, expr.left, expr.right); + if (eventWrite) return eventWrite; + } // `x = e` in EXPRESSION position (`while ((idx = s.indexOf("\n")) !== -1)`, // `f(x = v)`): evaluate e once, write the binding, yield the assigned // value — JS evaluation order. Variable targets only (locals and module diff --git a/tests/corpus/5241-event-subclass.ts b/tests/corpus/5241-event-subclass.ts index 5e3a8862df..fbe655637a 100644 --- a/tests/corpus/5241-event-subclass.ts +++ b/tests/corpus/5241-event-subclass.ts @@ -38,6 +38,37 @@ const third = new Ping(3, true); third.returnValue = false; console.log(third.defaultPrevented, third.returnValue); +// An assignment to a writable accessor in value position yields the +// assigned value; the receiver evaluates before the value. +const order: string[] = []; +const fourth = new Ping(5, true); +const pick = (): Ping => { + order.push("receiver"); + return fourth; +}; +const flag = (value: boolean): boolean => { + order.push("value"); + return value; +}; +const assigned = (pick().returnValue = flag(false)); +console.log(assigned, fourth.defaultPrevented, fourth.returnValue, order.join(" ")); +const show = (value: boolean): string => `shown ${value}`; +console.log(show((fourth.cancelBubble = true)), fourth.cancelBubble); +const fifth = new Ping(6, true); +let chained: boolean; +chained = fifth.returnValue = false; +console.log(chained, fifth.defaultPrevented); +// returnValue = true after preventDefault keeps the event canceled; the +// expression still yields true. +console.log((fifth.returnValue = true), fifth.returnValue); +// The short-circuit forms read the accessor and write only when selected. +const sixth = new Ping(7, true); +console.log((sixth.returnValue &&= false), sixth.defaultPrevented); +console.log((sixth.returnValue ||= true), sixth.returnValue); +console.log((sixth.returnValue ??= true), sixth.cancelBubble); +console.log((sixth.cancelBubble ||= true), sixth.cancelBubble); +console.log((sixth.cancelBubble &&= false), sixth.cancelBubble); + // stopImmediatePropagation skips the remaining listeners. const quiet = new EventTarget(); quiet.addEventListener("ping", (event: Event) => { diff --git a/tests/corpus/5244-event-target-subclass.js b/tests/corpus/5244-event-target-subclass.js index 963c41decc..3f48195fa7 100644 --- a/tests/corpus/5244-event-target-subclass.js +++ b/tests/corpus/5244-event-target-subclass.js @@ -61,6 +61,10 @@ const plainTarget = new EventTarget(); console.log(typeof plainEvent.preventDefault, plainEvent.preventDefault === job.preventDefault); console.log(plainTarget.addEventListener === queue.addEventListener, typeof plainTarget.dispatchEvent); +// Writable accessors assigned in value position. +const held = new Job("held", 0); +console.log((held.returnValue = false), held.defaultPrevented, (held.cancelBubble ||= true), held.cancelBubble); + // A class instance listener: its handleEvent method runs with the instance // as `this`, and an own property replacing it is what later dispatches call. class Handler {