refactor(errors): finish local-limit-error-class and range-error-interpretation guards (#11784)

This commit is contained in:
morluto authored and GitHub committed 2026-11-16 20:55:14 -05:00
1 parent 62f5946ba1
commit 08b63cc8a1
21 files changed
+208 -103

No files matched your search

@@ -1,5 +0,0 @@
{
"src/browser/WebSourceMapFetcher.ts": 1,
"src/domain/firmware/devicetreeParser.ts": 1,
"src/v8/V8CodeCache.errors.ts": 1
}
@@ -1,10 +0,0 @@
{
"src/application/JsonInputFile.ts": 1,
"src/artifacts/nodeSea/NodeSeaBlob.ts": 1,
"src/browser/WebBundleAnalysisWorkerServer.ts": 1,
"src/cli/cliResultOutput.ts": 1,
"src/domain/apiContract/GraphqlDocuments.ts": 1,
"src/domain/apiContract/parseGraphqlContract.ts": 1,
"src/javascript/analysis/JavaScriptAnalysisWorkerServer.ts": 2,
"src/wasm/WabtFailures.ts": 1
}
+3 -2
View File
@@ -41,6 +41,7 @@ import {
AnalysisInputError,
AnalysisResourceConstraintError,
} from "../domain/analysisErrorCore.js";
import { hostRangeErrorKind } from "../domain/parseFailure.js";
import { err, ok, type Result } from "../domain/result.js";
type JsonInputFileFailure =
@@ -527,9 +528,9 @@ const jsonReadFailure = (
)
return cause;
if (
hostRangeErrorKind(cause) === "host-capacity" &&
cause instanceof Error &&
((cause instanceof RangeError &&
cause.message === "Invalid string length") ||
(cause.message === "Invalid string length" ||
("code" in cause && cause.code === "ERR_STRING_TOO_LONG"))
)
return new AnalysisResourceConstraintError(
+5 -4
View File
@@ -16,7 +16,7 @@ import {
type Devicetree,
} from "../../domain/firmware/devicetree.js";
import {
DevicetreeLimitFailure,
devicetreeLimitOf,
parseDevicetree,
} from "../../domain/firmware/devicetreeParser.js";
import { BinaryFormatFailure } from "../../domain/binaryContainer.js";
@@ -569,12 +569,13 @@ const parseFit = (fdt: Buffer, path: string): Devicetree => {
} catch (cause) {
if (cause instanceof BinaryFormatFailure)
throw formatFailure(cause.message);
if (cause instanceof DevicetreeLimitFailure)
const limit = devicetreeLimitOf(cause);
if (limit !== undefined)
throw new ArtifactReaderFailure(
"limit",
`FIT devicetree exceeds the fixed ${cause.limit} allowance`,
`FIT devicetree exceeds the fixed ${limit.limit} allowance`,
{
boundary: cause.limit === "decoded_bytes" ? "memory" : "capacity",
boundary: limit.limit === "decoded_bytes" ? "memory" : "capacity",
cause,
},
);
+2 -1
View File
@@ -9,6 +9,7 @@ import {
DEFAULT_NODE_SEA_READER_LIMITS,
type NodeSeaReaderLimits,
} from "../../domain/artifactReaderLimits.js";
import { hostRangeErrorKind } from "../../domain/parseFailure.js";
import { strictUtf8Decoder } from "../../domain/strictUtf8.js";
/** Node `SeaBlob::kMagic` from `src/node_sea.h` (v24). */
@@ -236,7 +237,7 @@ class BlobCursor {
try {
text = strictUtf8Decoder("preserve").decode(raw);
} catch (cause: unknown) {
if (cause instanceof RangeError)
if (hostRangeErrorKind(cause) === "host-capacity")
throw new ArtifactReaderFailure(
"limit",
"Node SEA UTF-8 text exceeds this runtime's string or memory capacity. Admission budgets do not raise runtime representation limits or reserve host memory.",
+14 -2
View File
@@ -34,6 +34,8 @@ import {
} from "./WebBundleAnalysisWorkerProtocol.js";
import { decodeStrictUtf8 } from "../domain/strictUtf8.js";
import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
import { decodeLimit, isHostLimitFailure } from "../domain/parseFailure.js";
import { isParseLimit } from "../domain/parseFailureAnalysisError.js";
import { errorMessage } from "../kernel/errorMessage.js";
export interface WebBundleScriptAnalyzer {
@@ -46,6 +48,7 @@ export interface WebBundleScriptAnalyzer {
class WebBundleWorkerInputError extends Error {}
class WebBundleWorkerOutputError extends Error {}
const WEB_BUNDLE_RESULT_FORMAT = "web-bundle-worker-result";
const send = async (input: WebBundleWorkerMessage): Promise<void> => {
const value = webBundleWorkerMessageSchema.parse(input);
@@ -192,8 +195,14 @@ const analyzeJob = async (
const chunk = Buffer.from(part);
bytes += chunk.length;
if (bytes > request.result_budget_bytes)
throw new RangeError(
throw decodeLimit(
WEB_BUNDLE_RESULT_FORMAT,
"Web bundle worker result exceeds its admitted byte budget",
{
name: "result_budget_bytes",
maximum: request.result_budget_bytes,
required: bytes,
},
);
hash.update(chunk);
let offset = 0;
@@ -221,7 +230,10 @@ const analyzeJob = async (
} catch (cause: unknown) {
const refusal =
cause instanceof AnalysisResourceConstraintError ? cause : undefined;
const resource = cause instanceof RangeError || refusal !== undefined;
const resource =
isHostLimitFailure(cause) ||
isParseLimit(cause, WEB_BUNDLE_RESULT_FORMAT) ||
refusal !== undefined;
const input = cause instanceof WebBundleWorkerInputError;
const fatalCleanupFailure =
cause instanceof ArtifactReaderFailure &&
+6 -1
View File
@@ -425,7 +425,12 @@ it.each([
if (trigger === "caller-abort") expect(result.error.cause).toBe(reason);
else {
expect(result.error.cause).toMatchObject({
name: "SourceMapSizeLimitError",
name: "ParseFailureError",
failure: {
kind: "limit",
format: "source-map",
limit: { name: "fetch_bytes", maximum: 1 },
},
});
expect(
result.error.secondaryFailures.some(
+18 -12
View File
@@ -321,14 +321,19 @@ class SourceMapCallerAbort extends Error {
const sourceMapCallerReason = (value: unknown): unknown =>
value instanceof SourceMapCallerAbort ? value.reason : value;
class SourceMapSizeLimitError extends Error {
constructor(maxBytes: number) {
super(
`Source-map response exceeded its retained budget. ${sourceMapLimitRecovery("fetch_bytes", maxBytes)}`,
);
this.name = "SourceMapSizeLimitError";
}
}
const sourceMapSizeLimitError = (
maxBytes: number,
): ParseFailureError<"limit"> =>
sourceMapLimitFailure(
"Source-map response exceeded its retained budget.",
"fetch_bytes",
maxBytes,
);
const isSourceMapSizeLimitError = (
cause: unknown,
): cause is ParseFailureError<"limit"> =>
isSourceMapLimit(cause) && cause.failure.limit.name === "fetch_bytes";
class SourceMapRedirectLocationError extends Error {
constructor(url: string, location: string) {
@@ -718,7 +723,8 @@ const fetchOne = async (
const cause =
caught instanceof SourceMapResponseCleanup ? caught.cause : caught;
if (cause instanceof AnalysisError) throw cause;
if (isSourceMapLimit(cause)) throw cause;
if (isSourceMapLimit(cause) && !isSourceMapSizeLimitError(cause))
throw cause;
if (
signal?.aborted === true &&
!(signal.reason instanceof SourceMapDeadlineError)
@@ -728,7 +734,7 @@ const fetchOne = async (
request,
"fetch_failed",
cause instanceof SourceMapRedirectLocationError ||
cause instanceof SourceMapSizeLimitError ||
isSourceMapSizeLimitError(cause) ||
cause instanceof SourceMapDeadlineError
? cause.message
: "Source-map fetch or validation failed.",
@@ -847,7 +853,7 @@ const readBoundedText = async (
if (done) break;
const nextBytes = value?.byteLength ?? 0;
if (budget.retainedBytes + bytes + nextBytes > maxBytes) {
throw new SourceMapSizeLimitError(maxBytes);
throw sourceMapSizeLimitError(maxBytes);
}
if (value !== undefined) chunks.push(value);
bytes += nextBytes;
@@ -879,7 +885,7 @@ const readBoundedText = async (
signal,
sourceMapCallerReason(cause),
);
if (cause instanceof SourceMapSizeLimitError) {
if (isSourceMapSizeLimitError(cause)) {
try {
// Preserve the size-limit item's existing finalization boundary.
const completion = cleanup.completion;
+3 -1
View File
@@ -13,6 +13,7 @@ import {
AnalysisInputError,
AnalysisResourceConstraintError,
} from "../domain/analysisErrorCore.js";
import { hostRangeErrorKind } from "../domain/parseFailure.js";
import { err, ok, type Result } from "../domain/result.js";
import { sliceTextByTokenWindow } from "./tokenWindow.js";
import {
@@ -119,7 +120,8 @@ export const createCliResultOutput = (
if (
completed === undefined ||
handled ||
!(cause instanceof RangeError) ||
hostRangeErrorKind(cause) !== "host-capacity" ||
!(cause instanceof Error) ||
cause.message !== "Invalid string length"
)
return false;
+2 -1
View File
@@ -1,6 +1,7 @@
import { GraphQLError, Source, parse, visit, type DocumentNode } from "graphql";
import { AnalysisResourceConstraintError } from "../analysisErrorCore.js";
import { fixedAllowanceOptions } from "../fixedAllowanceRemediation.js";
import { isHostLimitFailure } from "../parseFailure.js";
import {
API_CONTRACT_OPERATION,
API_CONTRACT_MAX_FILE_BYTES,
@@ -77,7 +78,7 @@ export const parseGraphqlDocument = (
} catch (cause) {
if (cause instanceof GraphQLError)
throw new GraphqlDocumentRefusal(cause, document, role);
if (cause instanceof RangeError)
if (isHostLimitFailure(cause))
throw new AnalysisResourceConstraintError(
API_CONTRACT_OPERATION,
"memory",
@@ -4,6 +4,7 @@ import {
AnalysisInputError,
AnalysisResourceConstraintError,
} from "../analysisErrorCore.js";
import { isHostLimitFailure } from "../parseFailure.js";
import { err, ok, type Result } from "../result.js";
import type { GraphqlContract } from "./graphqlContract.js";
import { API_CONTRACT_OPERATION } from "./apiContract.js";
@@ -41,7 +42,7 @@ export function* parseGraphqlContractSteps(
inventory.roots = roots;
model = constructed;
} catch (cause) {
if (cause instanceof RangeError)
if (isHostLimitFailure(cause))
throw new AnalysisResourceConstraintError(
API_CONTRACT_OPERATION,
"memory",
+7 -3
View File
@@ -4,7 +4,11 @@ import {
devicetreeSchema,
inspectDevicetreeInputSchema,
} from "./devicetree.js";
import { DevicetreeLimitFailure, parseDevicetree } from "./devicetreeParser.js";
import {
DEVICETREE_DECODED_BYTES,
devicetreeLimitFailure,
parseDevicetree,
} from "./devicetreeParser.js";
import {
cells,
devicetreeFixture,
@@ -305,7 +309,7 @@ it.each(["compatible", "status"])(
properties: { [name]: Buffer.alloc(6 * 1024 * 1024) },
});
expect(() => parse(bytes, { max_file_bytes: 16777216 })).toThrow(
new DevicetreeLimitFailure("decoded_bytes"),
devicetreeLimitFailure("decoded_bytes", DEVICETREE_DECODED_BYTES),
);
},
);
@@ -323,7 +327,7 @@ it("accounts for string values serialized again in the summary", () => {
parse(devicetreeFixture({ ...child, name: "" }), {
max_file_bytes: 16777216,
}),
).toThrow(new DevicetreeLimitFailure("decoded_bytes"));
).toThrow(devicetreeLimitFailure("decoded_bytes", DEVICETREE_DECODED_BYTES));
});
it("retains undecodable alias identities and labels the summary derived", () => {
const report = parse(
+49 -20
View File
@@ -1,19 +1,48 @@
import type { Devicetree, InspectDevicetreeInput } from "./devicetree.js";
import { BinaryFormatFailure } from "../binaryContainer.js";
import { decodeLimit, ParseFailureError } from "../parseFailure.js";
export class DevicetreeLimitFailure extends Error {
constructor(
readonly limit:
| keyof Omit<InspectDevicetreeInput, "path">
| "decoded_bytes",
) {
super(
limit === "decoded_bytes"
? "Devicetree exceeds its fixed 32 MiB decoded representation allowance; select a smaller blob. This allowance has no runtime override."
: `Devicetree exceeds ${limit}; raise that caller-selected limit within its schema ceiling or select a smaller blob.`,
);
}
}
/** The ParseFailure format of flattened devicetree blobs. */
export const DEVICETREE_FORMAT = "devicetree";
export const DEVICETREE_DECODED_BYTES = 33554432;
export type DevicetreeLimit =
| keyof Omit<InspectDevicetreeInput, "path">
| "decoded_bytes";
const DEVICETREE_LIMITS = new Set<DevicetreeLimit>([
"max_file_bytes",
"max_nodes",
"max_properties",
"max_depth",
"decoded_bytes",
]);
export const devicetreeLimitFailure = (
limit: DevicetreeLimit,
maximum: number,
): ParseFailureError<"limit"> =>
decodeLimit(
DEVICETREE_FORMAT,
limit === "decoded_bytes"
? "Devicetree exceeds its fixed 32 MiB decoded representation allowance; select a smaller blob. This allowance has no runtime override."
: `Devicetree exceeds ${limit}; raise that caller-selected limit within its schema ceiling or select a smaller blob.`,
{ name: limit, maximum },
);
export const devicetreeLimitOf = (
cause: unknown,
): { readonly limit: DevicetreeLimit; readonly maximum: number } | undefined =>
cause instanceof ParseFailureError &&
cause.failure.kind === "limit" &&
cause.failure.format === DEVICETREE_FORMAT &&
DEVICETREE_LIMITS.has(cause.failure.limit.name as DevicetreeLimit)
? {
limit: cause.failure.limit.name as DevicetreeLimit,
maximum: cause.failure.limit.maximum,
}
: undefined;
const malformed = (message: string): never => {
throw new BinaryFormatFailure("malformed", message);
};
@@ -27,7 +56,7 @@ export const parseDevicetree = (
input: InspectDevicetreeInput,
): Devicetree => {
if (bytes.length > input.max_file_bytes)
throw new DevicetreeLimitFailure("max_file_bytes");
throw devicetreeLimitFailure("max_file_bytes", input.max_file_bytes);
if (bytes.length < 28) malformed("Truncated FDT header");
const u32 = (offset: number) => bytes.readUInt32BE(offset);
if (u32(0) !== 0xd00dfeed)
@@ -66,8 +95,8 @@ export const parseDevicetree = (
let decodedBytes = 0;
const admit = (size: number) => {
decodedBytes += size;
if (decodedBytes > 33554432)
throw new DevicetreeLimitFailure("decoded_bytes");
if (decodedBytes > DEVICETREE_DECODED_BYTES)
throw devicetreeLimitFailure("decoded_bytes", DEVICETREE_DECODED_BYTES);
};
const ranges: { start: number; end: number }[] = [
{ start: 0, end: headerBytes },
@@ -116,7 +145,7 @@ export const parseDevicetree = (
cursor += 16;
if (address === 0n && size === 0n) break;
if (reservations.length >= input.max_properties)
throw new DevicetreeLimitFailure("max_properties");
throw devicetreeLimitFailure("max_properties", input.max_properties);
admit(128);
reservations.push({
offset: cursor - 16,
@@ -158,9 +187,9 @@ export const parseDevicetree = (
cursor += 4;
if (token === 1) {
if (stack.length >= input.max_depth)
throw new DevicetreeLimitFailure("max_depth");
throw devicetreeLimitFailure("max_depth", input.max_depth);
if (nodes.length >= input.max_nodes)
throw new DevicetreeLimitFailure("max_nodes");
throw devicetreeLimitFailure("max_nodes", input.max_nodes);
const name = text(cursor, structEnd);
cursor = align(name.next);
need(0);
@@ -199,7 +228,7 @@ export const parseDevicetree = (
cursor += 8;
need(length);
if (++properties > input.max_properties)
throw new DevicetreeLimitFailure("max_properties");
throw devicetreeLimitFailure("max_properties", input.max_properties);
if (nameoff >= header.size_dt_strings)
malformed("FDT property string offset out of range");
let name = names.get(nameoff);
@@ -23,7 +23,7 @@ import {
import { err, ok } from "../../domain/result.js";
import { DEVICETREE_PROVIDER } from "../../domain/investigationProviders.js";
import {
DevicetreeLimitFailure,
devicetreeLimitOf,
parseDevicetree,
} from "../../domain/firmware/devicetreeParser.js";
@@ -80,15 +80,15 @@ const devicetreeFailurePrimary = (
input: InspectDevicetreeInput,
) => {
const { cause, origin } = facts;
if (cause instanceof DevicetreeLimitFailure)
const limit = devicetreeLimitOf(cause);
if (limit !== undefined && cause instanceof Error)
return new AnalysisResourceConstraintError(
OPERATION,
cause.limit === "decoded_bytes" ? "memory" : "capacity",
limit.limit === "decoded_bytes" ? "memory" : "capacity",
cause.message,
{
limit: cause.limit,
selected:
cause.limit === "decoded_bytes" ? 33554432 : input[cause.limit],
limit: limit.limit,
selected: limit.maximum,
},
{ cause, retryable: false, remediationAction: cause.message },
);
@@ -18,6 +18,7 @@ import {
type BoundedControlLine,
} from "../../process/BoundedControlLines.js";
import { AnalysisResourceConstraintError } from "../../domain/analysisErrorCore.js";
import { isHostLimitFailure } from "../../domain/parseFailure.js";
import { javaScriptRuntime } from "../../domain/runtimeVersion.js";
import type { JavaScriptArtifactFile } from "../../domain/javascript/javascriptArtifactFiles.js";
import type { JavaScriptPackageType } from "../../domain/javascript/javascriptSourceParser.js";
@@ -214,12 +215,12 @@ const analyzeJob = async (
);
await send({ kind: "complete", id: request.id, descriptor });
} catch (cause: unknown) {
const hostLimit = isHostLimitFailure(cause);
await send({
kind: "failure",
id: request.id,
reason:
cause instanceof AnalysisResourceConstraintError ||
cause instanceof RangeError
cause instanceof AnalysisResourceConstraintError || hostLimit
? "resource"
: cause instanceof TypeError
? "output"
@@ -227,7 +228,7 @@ const analyzeJob = async (
resource:
cause instanceof AnalysisResourceConstraintError
? cause.resource
: cause instanceof RangeError
: hostLimit
? "memory"
: null,
limits:
+42 -10
View File
@@ -1,13 +1,45 @@
import { decodeLimit, ParseFailureError } from "../domain/parseFailure.js";
import type { V8CodeCacheInputBudget } from "../domain/v8/v8CodeCacheBudget.js";
/** A caller-selected budget was exceeded while scanning the payload. */
export class V8CodeCacheBudgetFailure extends Error {
constructor(
readonly boundary: keyof V8CodeCacheInputBudget,
readonly limit: number,
message: string,
) {
super(message);
this.name = "V8CodeCacheBudgetFailure";
}
/** The ParseFailure format of V8 code cache containers. */
export const V8_CODE_CACHE_FORMAT = "v8-code-cache";
export type V8CodeCacheBudgetBoundary = keyof V8CodeCacheInputBudget;
export interface V8CodeCacheBudgetLimit {
readonly boundary: V8CodeCacheBudgetBoundary;
readonly limit: number;
readonly message: string;
}
const V8_CODE_CACHE_BUDGET_BOUNDARIES = new Set<V8CodeCacheBudgetBoundary>([
"max_strings",
"min_string_bytes",
]);
/** A caller-selected budget was exceeded while scanning the payload. */
export const v8CodeCacheBudgetFailure = (
boundary: V8CodeCacheBudgetBoundary,
limit: number,
message: string,
): ParseFailureError<"limit"> =>
decodeLimit(V8_CODE_CACHE_FORMAT, message, {
name: boundary,
maximum: limit,
});
export const v8CodeCacheBudgetLimitOf = (
cause: unknown,
): V8CodeCacheBudgetLimit | undefined =>
cause instanceof ParseFailureError &&
cause.failure.kind === "limit" &&
cause.failure.format === V8_CODE_CACHE_FORMAT &&
V8_CODE_CACHE_BUDGET_BOUNDARIES.has(
cause.failure.limit.name as V8CodeCacheBudgetBoundary,
)
? {
boundary: cause.failure.limit.name as V8CodeCacheBudgetBoundary,
limit: cause.failure.limit.maximum,
message: cause.failure.detail,
}
: undefined;
+6 -1
View File
@@ -238,7 +238,12 @@ it("enforces the caller-selected observation budget", () => {
}),
).toThrow(
expect.objectContaining({
name: "V8CodeCacheBudgetFailure",
name: "ParseFailureError",
failure: expect.objectContaining({
kind: "limit",
format: "v8-code-cache",
limit: { name: "max_strings", maximum: 1 },
}),
message: expect.stringContaining("max_strings"),
}),
);
+7 -4
View File
@@ -9,15 +9,18 @@ import {
type V8CodeCache,
} from "../domain/v8/v8CodeCache.js";
import type { V8CodeCacheInputBudget } from "../domain/v8/v8CodeCacheBudget.js";
import { V8CodeCacheBudgetFailure } from "../v8/V8CodeCache.errors.js";
import {
V8_CODE_CACHE_FORMAT,
v8CodeCacheBudgetFailure,
} from "../v8/V8CodeCache.errors.js";
import { malformedInput, unsupportedInput } from "../domain/parseFailure.js";
import { sha256Hex } from "../kernel/sha256Hex.js";
const unsupported = (message: string): never => {
throw unsupportedInput("v8-code-cache", message);
throw unsupportedInput(V8_CODE_CACHE_FORMAT, message);
};
const malformed = (message: string): never => {
throw malformedInput("v8-code-cache", message);
throw malformedInput(V8_CODE_CACHE_FORMAT, message);
};
/**
@@ -120,7 +123,7 @@ export const parseV8CodeCache = (
if (observations.length >= input.max_strings)
// The message states the fact. Recovery advice belongs to the provider, which
// can see whether either budget still has headroom before recommending a retry.
throw new V8CodeCacheBudgetFailure(
throw v8CodeCacheBudgetFailure(
"max_strings",
input.max_strings,
`Payload contains more than ${String(input.max_strings)} printable runs of at least ${String(input.min_string_bytes)} bytes, so the max_strings observation budget was exhausted before the scan finished.`,
+18 -8
View File
@@ -6,7 +6,10 @@ import {
MIN_INSPECT_V8_CODE_CACHE_STRING_BYTES,
inspectV8CodeCacheInputSchema,
} from "../domain/v8/v8CodeCache.js";
import { V8CodeCacheBudgetFailure } from "./V8CodeCache.errors.js";
import {
v8CodeCacheBudgetFailure,
v8CodeCacheBudgetLimitOf,
} from "./V8CodeCache.errors.js";
import {
observationBudgetRecovery,
observationBudgetRemediation,
@@ -28,8 +31,14 @@ const input = (overrides: Record<string, number> = {}) =>
...overrides,
});
const exhausted = (limit: number) =>
new V8CodeCacheBudgetFailure("max_strings", limit, "budget exhausted");
const exhausted = (limit: number) => {
const parsed = v8CodeCacheBudgetLimitOf(
v8CodeCacheBudgetFailure("max_strings", limit, "budget exhausted"),
);
if (parsed === undefined)
throw new Error("Expected V8 code cache budget limit");
return parsed;
};
it("leaves both retries open while both budgets have headroom", () => {
// The default `min_string_bytes` is the schema minimum, so lowering it is not an
@@ -90,13 +99,14 @@ it("drops only the count retry when max_strings is at its ceiling", () => {
});
it("requires a smaller artifact only when the run length cannot drop", () => {
const limit = v8CodeCacheBudgetLimitOf(
v8CodeCacheBudgetFailure("min_string_bytes", 4096, "budget exhausted"),
);
if (limit === undefined)
throw new Error("Expected V8 code cache budget limit");
expect(
observationBudgetRecovery(
new V8CodeCacheBudgetFailure(
"min_string_bytes",
4096,
"budget exhausted",
),
limit,
input({ min_string_bytes: MIN_INSPECT_V8_CODE_CACHE_STRING_BYTES }),
),
).toMatchObject({
+12 -7
View File
@@ -28,7 +28,11 @@ import {
type InspectV8CodeCacheInput,
} from "../domain/v8/v8CodeCache.js";
import { err, ok } from "../domain/result.js";
import { V8CodeCacheBudgetFailure } from "./V8CodeCache.errors.js";
import {
v8CodeCacheBudgetLimitOf,
type V8CodeCacheBudgetBoundary,
type V8CodeCacheBudgetLimit,
} from "./V8CodeCache.errors.js";
import { V8_CODE_CACHE_PROVIDER_IDENTITY } from "./V8CodeCacheProviderIdentity.js";
import { parseV8CodeCache } from "./V8CodeCacheParser.js";
@@ -101,7 +105,7 @@ const inputBudgetRemediation = (
* can read the choice rather than the wording.
*/
export interface ObservationBudgetRecovery {
readonly boundary: V8CodeCacheBudgetFailure["boundary"];
readonly boundary: V8CodeCacheBudgetBoundary;
/** Whether a higher `max_strings` is still within the schema's admitted range. */
readonly canRaiseMaxStrings: boolean;
/** Whether a higher `min_string_bytes` is still within the schema's admitted range. */
@@ -113,7 +117,7 @@ export interface ObservationBudgetRecovery {
}
export const observationBudgetRecovery = (
cause: V8CodeCacheBudgetFailure,
cause: Pick<V8CodeCacheBudgetLimit, "boundary">,
input: InspectV8CodeCacheInput,
): ObservationBudgetRecovery => {
const canRaiseMaxStrings =
@@ -141,7 +145,7 @@ export const observationBudgetRecovery = (
/** Render the recovery choice for one exhausted observation budget. */
export const observationBudgetRemediation = (
cause: V8CodeCacheBudgetFailure,
cause: Pick<V8CodeCacheBudgetLimit, "boundary" | "limit">,
input: InspectV8CodeCacheInput,
): string => {
const recovery = observationBudgetRecovery(cause, input);
@@ -161,11 +165,12 @@ const v8CodeCacheFailurePrimary = (
input: InspectV8CodeCacheInput,
) => {
const { cause, origin } = facts;
if (cause instanceof V8CodeCacheBudgetFailure)
const budgetLimit = v8CodeCacheBudgetLimitOf(cause);
if (budgetLimit !== undefined)
return new AnalysisResourceConstraintError(
OPERATION,
"capacity",
cause.message,
budgetLimit.message,
{
max_strings: input.max_strings,
min_string_bytes: input.min_string_bytes,
@@ -173,7 +178,7 @@ const v8CodeCacheFailurePrimary = (
{
cause,
retryable: false,
remediationAction: observationBudgetRemediation(cause, input),
remediationAction: observationBudgetRemediation(budgetLimit, input),
},
);
const formatFailure = parseFailureAnalysisError(OPERATION, input.path, cause);
+2 -1
View File
@@ -17,6 +17,7 @@ import {
AnalysisResourceConstraintError,
AnalysisCapabilityUnavailableError,
} from "../domain/analysisErrorCore.js";
import { hostRangeErrorKind } from "../domain/parseFailure.js";
import type { ProviderOutcome } from "../process/ProviderOutcome.js";
import type { ProviderFailureDialect } from "../providers/classifyProviderFailure.js";
import {
@@ -177,7 +178,7 @@ const allocationRefused = (cause: unknown): boolean => {
"ERR_MEMORY_ALLOCATION_FAILED",
"ERR_BUFFER_TOO_LARGE",
].includes(String(physical.code))) ||
(physical instanceof RangeError &&
(hostRangeErrorKind(physical) === "host-capacity" &&
physical.message === "Array buffer allocation failed"))
);
};