From 92c2239aa88a1543c842303dd81fe9276bf9bc2a Mon Sep 17 00:00:00 2001 From: jdalton Date: Fri, 9 Oct 2026 13:38:08 -0400 Subject: [PATCH] fix(deps): refresh action bundle --- dist/main.js | 436 +++++++++++++++++++++++++++++++++----------- pnpm-lock.yaml | 12 +- pnpm-workspace.yaml | 6 +- 3 files changed, 340 insertions(+), 114 deletions(-) diff --git a/dist/main.js b/dist/main.js index 3abb866..a2e70b0 100644 --- a/dist/main.js +++ b/dist/main.js @@ -4364,10 +4364,67 @@ var require_request$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { return false; } } - onUpgrade(statusCode, headers, socket) { + /** + * @param {number|null} statusCode + * @param {Buffer[]|null} headers + * @param {import('node:stream').Duplex} socket + * @param {string} [statusText] + */ + onUpgrade(statusCode, headers, socket, statusText = "") { + this.onFinally(); assert$25(!this.aborted); assert$25(!this.completed); - return this[kHandler].onUpgrade(statusCode, headers, socket); + if (statusCode !== null) this.#publishUpgradeHeaders(statusCode, headers, statusText); + const result = this[kHandler].onUpgrade(statusCode, headers, socket); + if (!this.aborted) { + this.completed = true; + if (statusCode !== null) this.#publishUpgradeTrailers(); + } + return result; + } + /** + * @param {number} statusCode + * @param {import('node:http2').IncomingHttpHeaders} headers + * @param {(headers: import('node:http2').IncomingHttpHeaders) => Buffer[]} parseHeaders + * @param {string} [statusText] + */ + onUpgradeResponse(statusCode, headers, parseHeaders, statusText = "") { + assert$25(!this.aborted); + assert$25(this.completed); + if (channels.headers.hasSubscribers) this.#publishUpgradeHeaders(statusCode, parseHeaders(headers), statusText); + this.#publishUpgradeTrailers(); + } + /** + * @param {Error} error + */ + onUpgradeError(error) { + assert$25(!this.aborted); + assert$25(this.completed); + if (channels.error.hasSubscribers) channels.error.publish({ + request: this, + error + }); + } + /** + * @param {number} statusCode + * @param {Buffer[]} headers + * @param {string} statusText + */ + #publishUpgradeHeaders(statusCode, headers, statusText) { + if (channels.headers.hasSubscribers) channels.headers.publish({ + request: this, + response: { + statusCode, + headers, + statusText + } + }); + } + #publishUpgradeTrailers() { + if (channels.trailers.hasSubscribers) channels.trailers.publish({ + request: this, + trailers: [] + }); } onComplete(trailers) { this.onFinally(); @@ -8115,7 +8172,7 @@ var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { if (this.headersSize >= this.headersMaxSize) util.destroy(this.socket, new HeadersOverflowError()); } onUpgrade(head) { - const { upgrade, client, socket, headers, statusCode } = this; + const { upgrade, client, socket, headers, statusCode, statusText } = this; assert$19(upgrade); assert$19(client[kSocket] === socket); assert$19(!socket.destroyed); @@ -8140,9 +8197,10 @@ var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { client[kQueue][client[kRunningIdx]++] = null; client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade")); try { - request.onUpgrade(statusCode, headers, socket); - } catch (err) { - util.destroy(socket, err); + request.onUpgrade(statusCode, headers, socket, statusText); + } catch (error) { + util.errorRequest(client, request, error); + util.destroy(socket, error); } client[kResume](); } @@ -8383,19 +8441,18 @@ var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { } function clearIdleSocketValidation(socket) { if (socket[kIdleSocketValidationTimeout]) { - clearTimeout(socket[kIdleSocketValidationTimeout]); + clearImmediate(socket[kIdleSocketValidationTimeout]); socket[kIdleSocketValidationTimeout] = null; } socket[kIdleSocketValidation] = 0; } function scheduleIdleSocketValidation(client, socket) { socket[kIdleSocketValidation] = 1; - socket[kIdleSocketValidationTimeout] = setTimeout(() => { + socket[kIdleSocketValidationTimeout] = setImmediate(() => { socket[kIdleSocketValidationTimeout] = null; socket[kIdleSocketValidation] = 2; if (client[kSocket] === socket && !socket.destroyed) client[kResume](); - }, 0); - socket[kIdleSocketValidationTimeout].unref?.(); + }); } /** * @param {import('./client.js')} client @@ -8478,9 +8535,16 @@ var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { } const socket = client[kSocket]; clearIdleSocketValidation(socket); - const abort = (err) => { - if (request.aborted || request.completed) return; - util.errorRequest(client, request, err || new RequestAbortedError()); + /** + * @param {Error} [error] + */ + const abort = (error) => { + if (request.aborted) return; + if (request.completed) { + if (request.upgrade || request.method === "CONNECT") util.destroy(socket, new InformationalError("aborted")); + return; + } + util.errorRequest(client, request, error || new RequestAbortedError()); util.destroy(body); util.destroy(socket, new InformationalError("aborted")); }; @@ -8730,6 +8794,7 @@ var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { var require_client_h2 = /* @__PURE__ */ __commonJSMin(((exports, module) => { const assert$18 = __require("node:assert"); + const { errorMonitor } = __require("node:events"); const { pipeline: pipeline$2 } = __require("node:stream"); const util = require_util$7(); const { RequestContentLengthMismatchError, RequestAbortedError, SocketError, InformationalError } = require_errors(); @@ -8751,6 +8816,14 @@ var require_client_h2 = /* @__PURE__ */ __commonJSMin(((exports, module) => { else result.push(Buffer.from(name), Buffer.from(value)); return result; } + /** + * @param {import('node:http2').IncomingHttpHeaders} headers + * @returns {Buffer[]} + */ + function parseH2ResponseHeaders(headers) { + const { [HTTP2_HEADER_STATUS]: _statusCode, ...realHeaders } = headers; + return parseH2Headers(realHeaders); + } async function connectH2(client, socket) { client[kSocket] = socket; if (!h2ExperimentalWarned) { @@ -8905,12 +8978,19 @@ var require_client_h2 = /* @__PURE__ */ __commonJSMin(((exports, module) => { const { hostname, port } = client[kUrl]; headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ""}`; headers[HTTP2_HEADER_METHOD] = method; - const abort = (err) => { - if (request.aborted || request.completed) return; - err = err || new RequestAbortedError(); - util.errorRequest(client, request, err); - if (stream != null) util.destroy(stream, err); - util.destroy(body, err); + /** + * @param {Error} [error] + */ + const abort = (error) => { + if (request.aborted) return; + if (request.completed) { + if (method === "CONNECT" && stream != null) util.destroy(stream, error || new RequestAbortedError()); + return; + } + error = error || new RequestAbortedError(); + util.errorRequest(client, request, error); + if (stream != null) util.destroy(stream, error); + util.destroy(body, error); client[kQueue][client[kRunningIdx]++] = null; client[kResume](); }; @@ -8926,16 +9006,46 @@ var require_client_h2 = /* @__PURE__ */ __commonJSMin(((exports, module) => { endStream: false, signal }); - if (stream.id && !stream.pending) { - request.onUpgrade(null, null, stream); - ++session[kOpenStreams]; - client[kQueue][client[kRunningIdx]++] = null; - } else stream.once("ready", () => { - request.onUpgrade(null, null, stream); - ++session[kOpenStreams]; + let upgradeResponseFinished = false; + /** + * @param {import('node:http2').IncomingHttpHeaders} headers + */ + const onResponse = (headers) => { + upgradeResponseFinished = true; + stream.off(errorMonitor, onUpgradeError); + request.onUpgradeResponse(Number(headers[HTTP2_HEADER_STATUS]), headers, parseH2ResponseHeaders); + }; + /** + * @param {Error} error + */ + const onUpgradeError = (error) => { + upgradeResponseFinished = true; + stream.off("response", onResponse); + request.onUpgradeError(error); + }; + const onReady = () => { + try { + request.onUpgrade(null, null, stream); + } catch (error) { + stream.off("response", onResponse); + abort(error); + return; + } + if (request.aborted) return; + stream.off("error", abort); + stream.once(errorMonitor, onUpgradeError); client[kQueue][client[kRunningIdx]++] = null; - }); + }; + stream.once("response", onResponse); + stream.once("error", abort); + ++session[kOpenStreams]; + onReady(); stream.once("close", () => { + if (!upgradeResponseFinished && request.completed) { + stream.off("response", onResponse); + stream.off(errorMonitor, onUpgradeError); + request.onUpgradeError(new InformationalError(`HTTP/2: "stream error" received - code ${stream.rstCode}`)); + } session[kOpenStreams] -= 1; if (session[kOpenStreams] === 0) session.unref(); }); @@ -10423,12 +10533,21 @@ var require_retry_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => this.end = null; this.etag = null; this.resume = null; + this.headersSent = false; this.handler.onConnect((reason) => { this.aborted = true; if (this.abort) this.abort(reason); else this.reason = reason; }); } + checkpointResponseEnd(headers, resume) { + if (this.end == null && this.opts.method !== "HEAD") { + const contentLength = headers["content-length"]; + this.end = contentLength != null ? Number(contentLength) - 1 : null; + assert$15(this.end == null || Number.isFinite(this.end), "invalid content-length"); + } + this.resume = this.end != null ? resume : null; + } onRequestSent() { if (this.handler.onRequestSent) this.handler.onRequestSent(); } @@ -10475,8 +10594,11 @@ var require_retry_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => const headers = parseHeaders(rawHeaders); this.retryCount += 1; if (statusCode >= 300) { - if (this.retryOpts.statusCodes.includes(statusCode) === false) return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage); - else { + if (!this.headersSent && this.retryOpts.statusCodes.includes(statusCode) === false) { + this.headersSent = true; + this.checkpointResponseEnd(headers, resume); + return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage); + } else { this.abort(new RequestRetryError("Request failed", statusCode, { headers, data: { count: this.retryCount } @@ -10514,15 +10636,23 @@ var require_retry_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => return false; } const { start, size, end = size - 1 } = contentRange; - assert$15(this.start === start, "content-range mismatch"); - assert$15(this.end == null || this.end === end, "content-range mismatch"); + if (this.start !== start || this.end != null && this.end !== end) { + this.abort(new RequestRetryError("Content-Range mismatch", statusCode, { + headers, + data: { count: this.retryCount } + })); + return false; + } this.resume = resume; return true; } if (this.end == null) { if (statusCode === 206) { const range = parseRangeHeader(headers["content-range"]); - if (range == null) return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage); + if (range == null) { + this.headersSent = true; + return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage); + } const contentLengthError = validatePartialResponseContentLength(headers, range, statusCode, this.retryCount); if (contentLengthError != null) { this.abort(contentLengthError); @@ -10541,6 +10671,7 @@ var require_retry_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => assert$15(Number.isFinite(this.start)); assert$15(this.end == null || Number.isFinite(this.end), "invalid content-length"); this.resume = resume; + this.headersSent = true; this.etag = headers.etag != null ? headers.etag : null; if (this.etag != null && this.etag.startsWith("W/")) this.etag = null; return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage); @@ -10561,7 +10692,7 @@ var require_retry_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => return this.handler.onComplete(rawTrailers); } onError(err) { - if (this.aborted || isDisturbed(this.opts.body)) return this.handler.onError(err); + if (this.aborted || isDisturbed(this.opts.body) || this.headersSent && this.resume == null) return this.handler.onError(err); if (this.retryCount - this.retryCountCheckpoint > 0) this.retryCount = this.retryCountCheckpoint + (this.retryCount - this.retryCountCheckpoint); else this.retryCount += 1; this.retryOpts.retry(err, { @@ -16992,7 +17123,8 @@ var require_connection = /* @__PURE__ */ __commonJSMin(((exports, module) => { } const secProtocol = response.headersList.get("Sec-WebSocket-Protocol"); if (secProtocol !== null) { - if (!getDecodeSplit("sec-websocket-protocol", request.headersList).includes(secProtocol)) { + const requestProtocols = getDecodeSplit("sec-websocket-protocol", request.headersList); + if (requestProtocols === null || !requestProtocols.includes(secProtocol)) { failWebsocketConnection(ws, "Protocol was not set in the opening handshake."); return; } @@ -17131,6 +17263,7 @@ var require_permessage_deflate = /* @__PURE__ */ __commonJSMin(((exports, module if (this.#maxPayloadSize > 0 && this.#inflate[kLength] > this.#maxPayloadSize) { callback(new MessageSizeExceededError()); this.#inflate.removeAllListeners(); + this.#inflate.destroy(); this.#inflate = null; return; } @@ -17908,6 +18041,24 @@ var require_eventsource_stream = /* @__PURE__ */ __commonJSMin(((exports, module * @type {32} SPACE */ const SPACE = 32; + const DATA = Buffer.from("data"); + const EVENT = Buffer.from("event"); + const ID = Buffer.from("id"); + const RETRY = Buffer.from("retry"); + function isASCIINumberBytes(buffer, start) { + if (start >= buffer.length) return false; + for (let i = start; i < buffer.length; i++) if (buffer[i] < 48 || buffer[i] > 57) return false; + return true; + } + function isValidLastEventIdBytes(buffer, start) { + for (let i = start; i < buffer.length; i++) if (buffer[i] === 0) return false; + return true; + } + function isFieldName(line, length, field) { + if (length !== field.length) return false; + for (let i = 0; i < length; i++) if (line[i] !== field[i]) return false; + return true; + } /** * @typedef {object} EventSourceStreamEvent * @type {object} @@ -17942,10 +18093,13 @@ var require_eventsource_stream = /* @__PURE__ */ __commonJSMin(((exports, module */ eventEndCheck = false; /** - * @type {Buffer} + * @type {Buffer[]} */ - buffer = null; + chunks = []; + chunkIndex = 0; pos = 0; + lineChunkIndex = 0; + linePos = 0; event = { data: void 0, event: void 0, @@ -17974,68 +18128,42 @@ var require_eventsource_stream = /* @__PURE__ */ __commonJSMin(((exports, module callback(); return; } - if (this.buffer) this.buffer = Buffer.concat([this.buffer, chunk]); - else this.buffer = chunk; - if (this.checkBOM) switch (this.buffer.length) { - case 1: - if (this.buffer[0] === BOM[0]) { - callback(); - return; - } - this.checkBOM = false; + this.chunks.push(chunk); + if (this.checkBOM) { + if (this.handleBOM()) { callback(); return; - case 2: - if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1]) { - callback(); - return; - } - this.checkBOM = false; - break; - case 3: - if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1] && this.buffer[2] === BOM[2]) { - this.buffer = Buffer.alloc(0); - this.checkBOM = false; - callback(); - return; - } - this.checkBOM = false; - break; - default: - if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1] && this.buffer[2] === BOM[2]) this.buffer = this.buffer.subarray(3); - this.checkBOM = false; + } } - while (this.pos < this.buffer.length) { + while (this.hasCurrentByte()) { + const byte = this.currentByte(); if (this.eventEndCheck) { if (this.crlfCheck) { - if (this.buffer[this.pos] === LF) { - this.buffer = this.buffer.subarray(this.pos + 1); - this.pos = 0; + if (byte === LF) { this.crlfCheck = false; + this.consumeCurrentByte(); continue; } this.crlfCheck = false; } - if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) { - if (this.buffer[this.pos] === CR) this.crlfCheck = true; - this.buffer = this.buffer.subarray(this.pos + 1); - this.pos = 0; - if (this.event.data !== void 0 || this.event.event || this.event.id || this.event.retry) this.processEvent(this.event); + if (byte === LF || byte === CR) { + if (byte === CR) this.crlfCheck = true; + this.consumeCurrentByte(); + if (this.hasPendingEvent()) this.processEvent(this.event); this.clearEvent(); continue; } this.eventEndCheck = false; continue; } - if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) { - if (this.buffer[this.pos] === CR) this.crlfCheck = true; - this.parseLine(this.buffer.subarray(0, this.pos), this.event); - this.buffer = this.buffer.subarray(this.pos + 1); - this.pos = 0; + if (byte === LF || byte === CR) { + if (byte === CR) this.crlfCheck = true; + this.parseLine(this.readLine(), this.event); + this.consumeCurrentByte(); this.eventEndCheck = true; continue; } - this.pos++; + this.advanceCursor(); } callback(); } @@ -18047,29 +18175,30 @@ var require_eventsource_stream = /* @__PURE__ */ __commonJSMin(((exports, module if (line.length === 0) return; const colonPosition = line.indexOf(COLON); if (colonPosition === 0) return; - let field = ""; - let value = ""; + let fieldLength = line.length; + let valueStart = line.length; if (colonPosition !== -1) { - field = line.subarray(0, colonPosition).toString("utf8"); - let valueStart = colonPosition + 1; + fieldLength = colonPosition; + valueStart = colonPosition + 1; if (line[valueStart] === SPACE) ++valueStart; - value = line.subarray(valueStart).toString("utf8"); - } else { - field = line.toString("utf8"); - value = ""; } - switch (field) { - case "data": - if (event[field] === void 0) event[field] = value; - else event[field] += `\n${value}`; - break; - case "retry": - if (isASCIINumber(value)) event[field] = value; - break; - case "id": - if (isValidLastEventId(value)) event[field] = value; - break; - case "event": if (value.length > 0) event[field] = value; + if (isFieldName(line, fieldLength, DATA)) { + const value = line.toString("utf8", valueStart); + if (event.data === void 0) event.data = value; + else event.data += `\n${value}`; + return; + } + if (isFieldName(line, fieldLength, RETRY)) { + if (isASCIINumberBytes(line, valueStart)) event.retry = line.toString("utf8", valueStart); + return; + } + if (isFieldName(line, fieldLength, ID)) { + if (isValidLastEventIdBytes(line, valueStart)) event.id = line.toString("utf8", valueStart); + return; + } + if (isFieldName(line, fieldLength, EVENT)) { + const value = line.toString("utf8", valueStart); + if (value.length > 0) event.event = value; } } /** @@ -18088,12 +18217,109 @@ var require_eventsource_stream = /* @__PURE__ */ __commonJSMin(((exports, module }); } clearEvent() { - this.event = { - data: void 0, - event: void 0, - id: void 0, - retry: void 0 - }; + this.event.data = void 0; + this.event.event = void 0; + this.event.id = void 0; + this.event.retry = void 0; + } + hasPendingEvent() { + return this.event.data !== void 0 || this.event.event !== void 0 || this.event.id !== void 0 || this.event.retry !== void 0; + } + hasCurrentByte() { + return this.chunkIndex < this.chunks.length && this.pos < this.chunks[this.chunkIndex].length; + } + currentByte() { + return this.chunks[this.chunkIndex][this.pos]; + } + consumeCurrentByte() { + this.advanceCursor(); + this.syncLineStartToCursor(); + } + advanceCursor() { + this.pos++; + while (this.chunkIndex < this.chunks.length && this.pos >= this.chunks[this.chunkIndex].length) { + this.chunkIndex++; + this.pos = 0; + } + } + syncLineStartToCursor() { + this.lineChunkIndex = this.chunkIndex; + this.linePos = this.pos; + this.dropConsumedChunks(); + } + dropConsumedChunks() { + while (this.lineChunkIndex > 0) { + this.chunks.shift(); + this.lineChunkIndex--; + this.chunkIndex--; + } + if (this.chunkIndex === this.chunks.length) { + this.chunks.length = 0; + this.chunkIndex = 0; + this.pos = 0; + this.lineChunkIndex = 0; + this.linePos = 0; + } + } + readLine() { + if (this.lineChunkIndex === this.chunkIndex) return this.chunks[this.chunkIndex].subarray(this.linePos, this.pos); + const chunks = []; + let length = 0; + for (let i = this.lineChunkIndex; i <= this.chunkIndex; i++) { + const chunk = this.chunks[i]; + const start = i === this.lineChunkIndex ? this.linePos : 0; + const end = i === this.chunkIndex ? this.pos : chunk.length; + const slice = chunk.subarray(start, end); + length += slice.length; + chunks.push(slice); + } + return Buffer.concat(chunks, length); + } + peekBufferedByte(offset) { + let chunkIndex = this.lineChunkIndex; + let pos = this.linePos; + while (chunkIndex < this.chunks.length) { + const chunk = this.chunks[chunkIndex]; + const remaining = chunk.length - pos; + if (offset < remaining) return chunk[pos + offset]; + offset -= remaining; + chunkIndex++; + pos = 0; + } + } + discardLeadingBytes(count) { + while (count > 0 && this.lineChunkIndex < this.chunks.length) { + const remaining = this.chunks[this.lineChunkIndex].length - this.linePos; + if (count < remaining) { + this.linePos += count; + count = 0; + } else { + count -= remaining; + this.lineChunkIndex++; + this.linePos = 0; + } + } + this.chunkIndex = this.lineChunkIndex; + this.pos = this.linePos; + this.dropConsumedChunks(); + } + handleBOM() { + const first = this.peekBufferedByte(0); + const second = this.peekBufferedByte(1); + const third = this.peekBufferedByte(2); + if (second === void 0) { + if (first === BOM[0]) return true; + this.checkBOM = false; + return true; + } + if (third === void 0) { + if (first === BOM[0] && second === BOM[1]) return true; + this.checkBOM = false; + return false; + } + if (first === BOM[0] && second === BOM[1] && third === BOM[2]) this.discardLeadingBytes(3); + this.checkBOM = false; + return !this.hasCurrentByte(); } }; module.exports = { EventSourceStream }; diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index d1aa5e9..7762f19 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -356,7 +356,7 @@ overrides: yaml@2: 2.9.1 '@actions/http-client': 4.0.1 packageurl-js: npm:@socketregistry/packageurl-js@1.5.2 - undici: 6.28.0 + undici: 6.29.0 patchedDependencies: '@polka/url@1.0.0-next.29': 60d82e95c5e67e66c41fe2987ddd4fc3f4992f12158e5c56838e7682e6ef72ea @@ -6569,8 +6569,8 @@ packages: undici-types@8.9.0: resolution: {integrity: sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg==} - undici@6.28.0: - resolution: {integrity: sha512-LIY910g9TI13YS95lrMFrs8Rm/u/irgHeTWoKCoteeJ04CUJ92eEfj0rVn+7VKMPBpUPiUoBKfhNyLI23EE/KA==} + undici@6.29.0: + resolution: {integrity: sha512-R+RODBqp6i2pPflGdq+xIOUkl+RNfGgHwoinecKu/JCuf2uO06cOKoDbI2P7Dn6KcswdKwrczbU6IYJ6K8X+wg==} engines: {node: '>=18.17'} unicorn-magic@0.4.0: @@ -6788,12 +6788,12 @@ snapshots: '@octokit/plugin-rest-endpoint-methods': 17.0.0(@octokit/core@7.0.6) '@octokit/request': 10.0.11 '@octokit/request-error': 7.1.0 - undici: 6.28.0 + undici: 6.29.0 '@actions/http-client@4.0.1': dependencies: tunnel: 0.0.6 - undici: 6.28.0 + undici: 6.29.0 '@actions/io@3.0.2': {} @@ -9232,7 +9232,7 @@ snapshots: undici-types@8.9.0: {} - undici@6.28.0: {} + undici@6.29.0: {} unicorn-magic@0.4.0: {} diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index 96ad07f..ea92606 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -201,9 +201,9 @@ overrides: # attestation while later-published 6.x/7.x/8.x releases do. pnpm's # `trustPolicy: no-downgrade` compares by publish DATE across the whole # package, so any 5.x resolves as a trust downgrade and the install fails. - # 6.28.0 is the version the rest of the fleet pins and keeps the - # ProxyAgent/Agent/fetch surface `@actions/http-client` uses. - 'undici': '6.28.0' + # 6.29.0 keeps the ProxyAgent/Agent/fetch surface `@actions/http-client` + # uses while including the dependency update in the action bundle. + 'undici': '6.29.0' packages: - .claude/hooks/fleet/*