@plasius/gpu-model-runtime 0.2.0 → 0.2.1

package/README.md

@@ -25,7 +25,7 @@ is released.
   statuses, abort signals, optional byte ranges, response content types, and
   SHA-256 integrity checks.
 - `MemoryModelCache` keys loaded output by content hash, adapter format, and
-  stable adapter options. Call `runtime.invalidate()` to clear all entries or
+  stable adapter options and acquisition byte ceiling. Call `runtime.invalidate()` to clear all entries or
   entries for one content hash.
 - Worker execution is opt-in through a `WorkerDispatcher`; consumers that do
   not provide one stay on the main execution path.
@@ -50,6 +50,71 @@ result.canonicalModel;
 result.rendererReady;
 ```
 
+## Bounded source acquisition
+
+Every entrypoint and related resource has a default ceiling of 64 MiB
+(`DEFAULT_MODEL_MAX_BYTES`). `fetchPolicy.maxBytes` applies to URLs, memory,
+Blobs, streams, and injected file reads. Opt into a larger finite positive safe
+integer only after budgeting for that workload:
+
+```ts
+await runtime.loadModel(source, {
+  fetchPolicy: { maxBytes: 128 * 1024 * 1024, timeoutMs: 30_000 },
+  signal: controller.signal,
+});
+// In an adapter, tighten the inherited ceiling for one texture:
+await input.resourceResolver.resolve("textures/albedo.png", {
+  maxBytes: 8 * 1024 * 1024,
+  signal: context.signal,
+});
+```
+
+A per-resolution limit can tighten the inherited ceiling, never enlarge it.
+Known lengths are checked before reading/copying, and actual streamed bytes are
+checked before retention even when a server omits/misstates Content-Length or
+ignores Range. `byteLengthHint` can reject an oversized stream early; an
+underestimate never disables actual-byte checks. Hashes still cover the admitted
+bytes, including a returned range. Limits apply to decoded Fetch body bytes;
+compressed Content-Length is only an additional early check.
+
+Oversize throws `ModelResourceTooLargeError` with code
+`MODEL_RESOURCE_TOO_LARGE` and a fixed message containing no source identifiers.
+It is not retried. Cancellation and acquisition deadlines stop pending reads,
+cancel/release readers, and request iterator cleanup. An uncooperative producer
+cannot delay the rejection, although its own background work cannot be forcibly
+stopped. File-provider callbacks now receive a third `{ maxBytes }` argument;
+they must enforce it incrementally during their own I/O and honor the signal.
+The runtime checks returned file bytes before hashing or adapter use. Existing
+two-argument providers remain callable but need review for pre-allocation limits.
+
+The 30-second default `timeoutMs` now covers local/stream acquisition too;
+for ModelRuntime it includes entrypoint fetching, retries and hashing. Each
+related-resource resolution gets its own deadline and inherits caller abort.
+Direct `fetchResource` retains a deadline per attempt, including retry delay.
+Timeouts must be positive integers no larger than 2,147,483,647 milliseconds.
+
+The ceiling is per resource, not a total process/model budget. Stream storage
+grows geometrically with no per-chunk metadata list; live runtime copy storage
+is at most twice the configured ceiling (excluding producer/network buffers and
+hashing). Many tiny/empty chunks yield to the event loop periodically so timers
+can cancel work. Adapters still own total resource count/bytes, decoded image or
+mesh budgets, concurrency and format validation. ModelResidencyManager separately
+bounds resident CPU/GPU resources. Cache identity includes maxBytes so a model
+loaded with a larger ceiling cannot bypass a later stricter request.
+
+This behavior requires a **minor release in the current 0.x series**: previously
+accepted resources above 64 MiB require an explicit larger budget. The release
+pipeline allocates the version; consumers must wait for a verified npm release.
+Disabling `gpu.model.conversion.enabled` at the consumer prevents conversion and
+restores its tested fallback. Byte limits remain enforced whenever this runtime
+is called; there is no safety-check bypass flag.
+
+The implementation uses browser Web Streams, Blob, AbortController, timers and
+Web Crypto (or injected hashing), with no filesystem dependency. Node 24 tests
+exercise those APIs, streaming/range/integrity semantics and both ESM/CJS builds;
+real-browser integration remains a consumer validation responsibility. See
+[ADR-0008](docs/adrs/adr-0008-bounded-source-acquisition.md).
+
 ## Model residency
 
 `ModelResidencyManager` owns the lifetime of promoted runtime models shared by
@@ -146,3 +211,14 @@ npm pack --dry-run
 ## License
 
 Apache-2.0. See LICENSE, SECURITY.md, and the files under legal/.
+
+<!-- BEGIN PLASIUS RELEASE INTEGRITY -->
+## Release integrity
+
+CI keeps the administrative contributor registry outside Git and npm package
+artifacts using exact, case-normalised path checks. CI runs on explicit
+GitHub-hosted runners. Publication uses the GitHub-hosted `production` job with
+Node 24 and a pinned npm 11.6.2 client. It is token-free and proceeds only while the prepared SHA
+is the exact `main` head after successful push-triggered CI. Do not dispatch CD
+until the npm trusted-publisher binding is verified.
+<!-- END PLASIUS RELEASE INTEGRITY -->

package/dist/index.cjs

@@ -21,9 +21,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AdapterRegistry: () => AdapterRegistry,
+  DEFAULT_MODEL_MAX_BYTES: () => DEFAULT_MODEL_MAX_BYTES,
   MemoryModelCache: () => MemoryModelCache,
   ModelResidencyError: () => ModelResidencyError,
   ModelResidencyManager: () => ModelResidencyManager,
+  ModelResourceTooLargeError: () => ModelResourceTooLargeError,
   ModelRuntime: () => ModelRuntime,
   PackageResourceResolver: () => PackageResourceResolver,
   createModelCacheKey: () => createModelCacheKey,
@@ -68,8 +70,117 @@ function createModelCacheKey(contentHash, formatId, adapterOptions) {
   return `${formatId}:${contentHash}:${JSON.stringify(stableValue(adapterOptions ?? null))}`;
 }
 
+// src/types.ts
+var DEFAULT_MODEL_MAX_BYTES = 64 * 1024 * 1024;
+
+// src/bytes.ts
+var ModelResourceTooLargeError = class extends Error {
+  code = "MODEL_RESOURCE_TOO_LARGE";
+  constructor() {
+    super("Model resource exceeds maxBytes");
+    this.name = "ModelResourceTooLargeError";
+  }
+};
+function byteLimit(value = DEFAULT_MODEL_MAX_BYTES) {
+  if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError("maxBytes must be a positive safe integer");
+  return value;
+}
+function checkSize(size, maxBytes) {
+  if (size > maxBytes) throw new ModelResourceTooLargeError();
+}
+function checkAbort(signal) {
+  if (signal?.aborted) throw new DOMException("The model load was aborted", "AbortError");
+}
+function acquisitionController(signal, timeoutMs = 3e4, parent) {
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {
+    throw new RangeError("timeoutMs must be a positive timer-safe integer");
+  }
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  signal?.addEventListener("abort", abort, { once: true });
+  parent?.addEventListener("abort", abort, { once: true });
+  if (signal?.aborted || parent?.aborted) controller.abort();
+  const timer = setTimeout(abort, timeoutMs);
+  return {
+    signal: controller.signal,
+    dispose() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      parent?.removeEventListener("abort", abort);
+    }
+  };
+}
+async function abortable(work, signal) {
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      signal.removeEventListener("abort", abort);
+      reject(new DOMException("The model load was aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+    work.then(
+      (value) => {
+        signal.removeEventListener("abort", abort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", abort);
+        reject(error);
+      }
+    );
+  });
+}
+function cleanup(work) {
+  try {
+    void Promise.resolve(work()).catch(() => {
+    });
+  } catch {
+  }
+}
+async function readBoundedStream(source, maxBytes, signal) {
+  let bytes = new Uint8Array(0);
+  let length = 0;
+  let chunks = 0;
+  const reader = "getReader" in source ? source.getReader() : void 0;
+  const iterator = reader ? void 0 : source[Symbol.asyncIterator]();
+  try {
+    while (true) {
+      checkAbort(signal);
+      if (++chunks % 256 === 0) await abortable(new Promise((resolve) => setTimeout(resolve, 0)), signal);
+      const next = await abortable(reader ? reader.read() : iterator.next(), signal);
+      checkAbort(signal);
+      if (next.done) break;
+      if (!(next.value instanceof Uint8Array)) throw new TypeError("Model stream chunks must be Uint8Array");
+      const chunk = next.value;
+      if (chunk.byteLength > maxBytes - length) throw new ModelResourceTooLargeError();
+      const required = length + chunk.byteLength;
+      if (required > bytes.length) {
+        const grown = new Uint8Array(Math.min(maxBytes, Math.max(required, bytes.length * 2, 4096)));
+        grown.set(bytes.subarray(0, length));
+        bytes = grown;
+      }
+      bytes.set(chunk, length);
+      length = required;
+    }
+    return bytes.length === length ? bytes : bytes.slice(0, length);
+  } catch (error) {
+    if (reader) cleanup(() => reader.cancel());
+    else cleanup(() => iterator?.return?.());
+    throw error;
+  } finally {
+    reader?.releaseLock();
+  }
+}
+async function boundedBytes(input, maxBytes, signal) {
+  checkAbort(signal);
+  checkSize(input instanceof Blob ? input.size : input.byteLength, maxBytes);
+  if (input instanceof Blob) return readBoundedStream(input.stream(), maxBytes, signal);
+  return new Uint8Array(input);
+}
+
 // src/fetch.ts
 var DEFAULT_POLICY = {
+  maxBytes: DEFAULT_MODEL_MAX_BYTES,
   maxAttempts: 3,
   baseDelayMs: 100,
   maxDelayMs: 1e3,
@@ -100,6 +211,7 @@ async function sha256Hex(bytes) {
 }
 async function fetchResource(url, options) {
   const policy = { ...DEFAULT_POLICY, ...options.policy };
+  const maxBytes = Math.min(byteLimit(policy.maxBytes), byteLimit(options.resolveOptions?.maxBytes ?? policy.maxBytes));
   const headers = new Headers(options.headers);
   if (options.resolveOptions?.range) {
     const { start, end } = options.resolveOptions.range;
@@ -107,13 +219,21 @@ async function fetchResource(url, options) {
   }
   let lastError;
   for (let attempt = 1; attempt <= policy.maxAttempts; attempt += 1) {
-    const controller = createRequestController(options.resolveOptions?.signal, policy.timeoutMs);
+    const controller = acquisitionController(options.resolveOptions?.signal, policy.timeoutMs);
     try {
-      const response = await options.fetch(url, {
+      checkAbort(controller.signal);
+      const response = await abortable(options.fetch(url, {
         headers,
         signal: controller.signal
-      });
+      }).then((response2) => {
+        if (controller.signal.aborted) {
+          cleanup(() => response2.body?.cancel());
+          checkAbort(controller.signal);
+        }
+        return response2;
+      }), controller.signal);
       if (!response.ok) {
+        cleanup(() => response.body?.cancel());
         if (!RETRYABLE_STATUSES.has(response.status)) {
           throw new NonRetryableResourceError(`Model resource request failed with HTTP ${response.status}`);
         }
@@ -121,11 +241,20 @@ async function fetchResource(url, options) {
           throw new NonRetryableResourceError(`Model resource request failed with HTTP ${response.status}`);
         }
         lastError = new Error(`Retryable model resource response: HTTP ${response.status}`);
-        await waitForRetry(options.sleep, attempt, policy, options.resolveOptions?.signal);
+        await waitForRetry(options.sleep, attempt, policy, controller.signal);
         continue;
       }
-      const bytes = new Uint8Array(await response.arrayBuffer());
-      await verifyIntegrity(bytes, options.integrity, options.hashBytes);
+      let bytes;
+      try {
+        const declared = response.headers.get("content-length");
+        if (declared !== null && /^\d+$/u.test(declared)) checkSize(Number(declared), maxBytes);
+        bytes = response.body ? await readBoundedStream(response.body, maxBytes, controller.signal) : new Uint8Array(0);
+        checkAbort(controller.signal);
+      } catch (error) {
+        if (!response.body?.locked) cleanup(() => response.body?.cancel());
+        throw error;
+      }
+      await abortable(verifyIntegrity(bytes, options.integrity, options.hashBytes), controller.signal);
       return {
         bytes,
         contentType: response.headers.get("content-type") ?? void 0,
@@ -135,14 +264,14 @@ async function fetchResource(url, options) {
       if (isAbortError(error) || options.resolveOptions?.signal?.aborted) {
         throw createAbortError();
       }
-      if (error instanceof NonRetryableResourceError) {
+      if (error instanceof NonRetryableResourceError || error instanceof ModelResourceTooLargeError) {
         throw error;
       }
       lastError = error;
       if (attempt === policy.maxAttempts) {
         throw error;
       }
-      await waitForRetry(options.sleep, attempt, policy, options.resolveOptions?.signal);
+      await waitForRetry(options.sleep, attempt, policy, controller.signal);
     } finally {
       controller.dispose();
     }
@@ -179,20 +308,7 @@ function bytesToBase64(bytes) {
 }
 async function waitForRetry(sleep, attempt, policy, signal) {
   const delay = Math.min(policy.maxDelayMs, policy.baseDelayMs * 2 ** (attempt - 1));
-  await sleep(delay, signal);
-}
-function createRequestController(signal, timeoutMs) {
-  const controller = new AbortController();
-  const onAbort = () => controller.abort();
-  signal?.addEventListener("abort", onAbort, { once: true });
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  return {
-    signal: controller.signal,
-    dispose: () => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", onAbort);
-    }
-  };
+  await abortable(sleep(delay, signal), signal);
 }
 function createAbortError() {
   return new DOMException("The model load was aborted", "AbortError");
@@ -228,6 +344,7 @@ var AdapterRegistry = class {
   }
 };
 var PackageResourceResolver = class {
+  parentSignal;
   memoryResources;
   baseUrl;
   sourceKind;
@@ -238,48 +355,58 @@ var PackageResourceResolver = class {
   headers;
   blobStorageUrlResolver;
   constructor(options) {
+    this.parentSignal = options.signal;
     this.sourceKind = options.sourceKind;
     this.baseUrl = options.package?.baseUrl ?? options.baseUrl;
     this.memoryResources = options.package?.resources ?? {};
     this.fetch = options.fetch;
     this.hashBytes = options.hashBytes;
     this.sleep = options.sleep;
-    this.fetchPolicy = options.fetchPolicy;
+    this.fetchPolicy = { ...options.fetchPolicy };
     this.headers = options.headers;
     this.blobStorageUrlResolver = options.blobStorageUrlResolver;
   }
   async resolve(reference, options = {}) {
-    const requested = typeof reference === "string" ? { path: reference } : reference;
-    const memoryKey = normalizePackagePath(requested.path);
-    const memoryResource = this.memoryResources[memoryKey] ?? this.memoryResources[`./${memoryKey}`];
-    if (memoryResource) {
-      const bytes = await toBytes(memoryResource.bytes);
-      await verifyResourceIntegrity(bytes, requested.integrity ?? memoryResource.integrity, this.hashBytes);
+    const inheritedLimit = byteLimit(this.fetchPolicy?.maxBytes);
+    const maxBytes = Math.min(inheritedLimit, byteLimit(options.maxBytes ?? inheritedLimit));
+    const controller = acquisitionController(options.signal, this.fetchPolicy?.timeoutMs, this.parentSignal);
+    try {
+      checkAbort(controller.signal);
+      const requested = typeof reference === "string" ? { path: reference } : reference;
+      const memoryKey = normalizePackagePath(requested.path);
+      const memoryResource = this.memoryResources[memoryKey] ?? this.memoryResources[`./${memoryKey}`];
+      if (memoryResource) {
+        const bytes = await boundedBytes(memoryResource.bytes, maxBytes, controller.signal);
+        await abortable(verifyResourceIntegrity(bytes, requested.integrity ?? memoryResource.integrity, this.hashBytes), controller.signal);
+        return {
+          path: memoryKey,
+          bytes,
+          contentType: requested.contentType ?? memoryResource.contentType,
+          contentHash: await abortable(this.hashBytes(bytes), controller.signal),
+          rangeSupported: false
+        };
+      }
+      const url = await abortable(this.resolveUrl(requested.path), controller.signal);
+      checkAbort(controller.signal);
+      const result = await fetchResource(url, {
+        fetch: this.fetch,
+        hashBytes: this.hashBytes,
+        sleep: this.sleep,
+        headers: this.headers,
+        integrity: requested.integrity,
+        policy: this.fetchPolicy,
+        resolveOptions: { ...options, maxBytes, signal: controller.signal }
+      });
       return {
         path: memoryKey,
-        bytes,
-        contentType: requested.contentType ?? memoryResource.contentType,
-        contentHash: await this.hashBytes(bytes),
-        rangeSupported: false
+        bytes: result.bytes,
+        contentType: requested.contentType ?? result.contentType,
+        contentHash: await abortable(this.hashBytes(result.bytes), controller.signal),
+        rangeSupported: result.rangeSupported
       };
+    } finally {
+      controller.dispose();
     }
-    const url = await this.resolveUrl(requested.path);
-    const result = await fetchResource(url, {
-      fetch: this.fetch,
-      hashBytes: this.hashBytes,
-      sleep: this.sleep,
-      headers: this.headers,
-      integrity: requested.integrity,
-      policy: this.fetchPolicy,
-      resolveOptions: options
-    });
-    return {
-      path: memoryKey,
-      bytes: result.bytes,
-      contentType: requested.contentType ?? result.contentType,
-      contentHash: await this.hashBytes(result.bytes),
-      rangeSupported: result.rangeSupported
-    };
   }
   async resolveUrl(reference) {
     if (/^[a-z][a-z\d+.-]*:/iu.test(reference)) {
@@ -338,7 +465,7 @@ var ModelRuntime = class {
       fileName: input.fileName,
       sourceKind: source.kind
     }, options.formatId);
-    const cacheKey = createModelCacheKey(input.contentHash, adapter.formatId, options.adapterOptions);
+    const cacheKey = createModelCacheKey(input.contentHash, adapter.formatId, { adapterOptions: options.adapterOptions ?? null, maxBytes: byteLimit(options.fetchPolicy?.maxBytes) });
     const useCache = options.useCache ?? true;
     if (useCache) {
       const cached = await this.cache.get(cacheKey);
@@ -384,54 +511,64 @@ var ModelRuntime = class {
     return adapter.load(input, context);
   }
   async resolveSource(source, options) {
-    const fileName = sourceFileName(source);
-    const baseUrl = "url" in source ? source.url : void 0;
-    const headers = "headers" in source ? source.headers : void 0;
-    let bytes;
-    let contentType = "mimeTypeHint" in source ? source.mimeTypeHint : void 0;
-    let rangeSupported = false;
-    if (source.kind === "file-path") {
-      if (!this.readFile) {
-        throw new Error("file-path sources require a readFile dependency");
+    const maxBytes = byteLimit(options.fetchPolicy?.maxBytes);
+    const controller = acquisitionController(options.signal, options.fetchPolicy?.timeoutMs);
+    try {
+      checkAbort(controller.signal);
+      const fileName = sourceFileName(source);
+      const baseUrl = "url" in source ? source.url : void 0;
+      const headers = "headers" in source ? source.headers : void 0;
+      let bytes;
+      let contentType = "mimeTypeHint" in source ? source.mimeTypeHint : void 0;
+      let rangeSupported = false;
+      if (source.kind === "file-path") {
+        if (!this.readFile) {
+          throw new Error("file-path sources require a readFile dependency");
+        }
+        bytes = await abortable(this.readFile(source.path, controller.signal, { maxBytes }), controller.signal);
+        checkSize(bytes.byteLength, maxBytes);
+      } else if (source.kind === "url" || source.kind === "blob-storage-url") {
+        const result = await fetchResource(ensureHttpUrl(source.url), {
+          fetch: this.fetch,
+          hashBytes: this.hashBytes,
+          sleep: this.sleep,
+          headers,
+          integrity: options.integrity,
+          policy: options.fetchPolicy,
+          resolveOptions: { signal: controller.signal }
+        });
+        bytes = result.bytes;
+        contentType ??= result.contentType;
+        rangeSupported = result.rangeSupported;
+      } else {
+        bytes = await sourceToBytes(source, maxBytes, controller.signal);
       }
-      bytes = await this.readFile(source.path, options.signal);
-    } else if (source.kind === "url" || source.kind === "blob-storage-url") {
-      const result = await fetchResource(ensureHttpUrl(source.url), {
+      checkAbort(controller.signal);
+      const contentHash = await abortable(this.hashBytes(bytes), controller.signal);
+      const resourceResolver = new PackageResourceResolver({
+        sourceKind: source.kind,
+        signal: options.signal,
+        baseUrl,
+        package: source.package,
         fetch: this.fetch,
         hashBytes: this.hashBytes,
         sleep: this.sleep,
+        fetchPolicy: options.fetchPolicy,
         headers,
-        integrity: options.integrity,
-        policy: options.fetchPolicy,
-        resolveOptions: { signal: options.signal }
+        blobStorageUrlResolver: this.blobStorageUrlResolver
       });
-      bytes = result.bytes;
-      contentType ??= result.contentType;
-      rangeSupported = result.rangeSupported;
-    } else {
-      bytes = await sourceToBytes(source);
+      return {
+        source,
+        bytes,
+        contentType,
+        fileName,
+        contentHash,
+        rangeSupported,
+        resourceResolver
+      };
+    } finally {
+      controller.dispose();
     }
-    const contentHash = await this.hashBytes(bytes);
-    const resourceResolver = new PackageResourceResolver({
-      sourceKind: source.kind,
-      baseUrl,
-      package: source.package,
-      fetch: this.fetch,
-      hashBytes: this.hashBytes,
-      sleep: this.sleep,
-      fetchPolicy: options.fetchPolicy,
-      headers,
-      blobStorageUrlResolver: this.blobStorageUrlResolver
-    });
-    return {
-      source,
-      bytes,
-      contentType,
-      fileName,
-      contentHash,
-      rangeSupported,
-      resourceResolver
-    };
   }
 };
 function scoreRegistration(registration, input) {
@@ -463,50 +600,11 @@ function normalizePackagePath(path) {
   }
   return segments.join("/");
 }
-async function sourceToBytes(source) {
-  if (source.kind === "blob") {
-    return toBytes(source.blob);
-  }
-  if (source.kind === "array-buffer") {
-    return new Uint8Array(source.bytes);
-  }
-  if (source.kind === "uint8-array") {
-    return new Uint8Array(source.bytes);
-  }
-  const chunks = [];
-  if (Symbol.asyncIterator in Object(source.stream)) {
-    for await (const chunk of source.stream) {
-      chunks.push(new Uint8Array(chunk));
-    }
-  } else {
-    const reader = source.stream.getReader();
-    try {
-      while (true) {
-        const next = await reader.read();
-        if (next.done) break;
-        chunks.push(new Uint8Array(next.value));
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  const length = chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
-  const bytes = new Uint8Array(length);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return bytes;
-}
-async function toBytes(input) {
-  if (input instanceof Blob) {
-    return new Uint8Array(await input.arrayBuffer());
-  }
-  if (input instanceof Uint8Array) {
-    return new Uint8Array(input);
-  }
-  return new Uint8Array(input);
+async function sourceToBytes(source, maxBytes, signal) {
+  if (source.kind === "blob") return boundedBytes(source.blob, maxBytes, signal);
+  if (source.kind === "array-buffer" || source.kind === "uint8-array") return boundedBytes(source.bytes, maxBytes, signal);
+  if (source.byteLengthHint !== void 0) checkSize(source.byteLengthHint, maxBytes);
+  return readBoundedStream(source.stream, maxBytes, signal);
 }
 async function verifyResourceIntegrity(bytes, integrity, hashBytes) {
   if (!integrity) return;
@@ -1186,9 +1284,11 @@ var packageBootstrap = Object.freeze({
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AdapterRegistry,
+  DEFAULT_MODEL_MAX_BYTES,
   MemoryModelCache,
   ModelResidencyError,
   ModelResidencyManager,
+  ModelResourceTooLargeError,
   ModelRuntime,
   PackageResourceResolver,
   createModelCacheKey,