@holo-js/kernel 0.3.27 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Holo-JS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.

package/dist/.holo-build-fingerprint

@@ -0,0 +1 @@
+9eb8051fbe40b02e51b66e4640091d67d598fe4ce40e80d8d7454e882cb62bc6

package/dist/chunk-CGVSGOEO.mjs

@@ -0,0 +1,185 @@
+// src/requestBody.ts
+var DEFAULT_MAX_REQUEST_BODY_BYTES = 1024 * 1024;
+var DEFAULT_MAX_UPLOAD_BODY_BYTES = 8 * 1024 * 1024;
+var maxRequestBodyBytes = DEFAULT_MAX_REQUEST_BODY_BYTES;
+var maxUploadBodyBytes = DEFAULT_MAX_UPLOAD_BODY_BYTES;
+function isMultipartContentType(contentType) {
+  return contentType?.split(";", 1)[0]?.trim().toLowerCase() === "multipart/form-data";
+}
+function requestBodyLimitFor(contentType) {
+  return isMultipartContentType(contentType) ? maxUploadBodyBytes : maxRequestBodyBytes;
+}
+var HoloRequestBodyTooLargeError = class extends Error {
+  status = 413;
+  constructor(limit) {
+    super(`[@holo-js/kernel] Request body exceeds the ${limit}-byte limit.`);
+    this.name = "HoloRequestBodyTooLargeError";
+  }
+};
+function resolveLimit(maxBytes) {
+  return maxBytes ?? maxRequestBodyBytes;
+}
+function concatChunks(chunks, total) {
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+async function readBoundedRequestBody(request, maxBytes) {
+  const limit = maxBytes ?? requestBodyLimitFor(request.headers.get("content-type"));
+  const declared = request.headers.get("content-length");
+  if (declared !== null && Number(declared) > limit) {
+    throw new HoloRequestBodyTooLargeError(limit);
+  }
+  if (!request.body) {
+    return new Uint8Array(0);
+  }
+  const reader = request.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > limit) {
+        throw new HoloRequestBodyTooLargeError(limit);
+      }
+      chunks.push(value);
+    }
+  } catch (error) {
+    void reader.cancel(error).catch(() => void 0);
+    throw error;
+  }
+  return concatChunks(chunks, total);
+}
+function isWebReadableStream(value) {
+  return typeof value === "object" && value !== null && typeof value.getReader === "function";
+}
+function isPlainBufferedObject(value) {
+  return typeof value === "object" && value !== null && value.constructor === Object;
+}
+async function readWebStreamBounded(stream, limit) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > limit) {
+        throw new HoloRequestBodyTooLargeError(limit);
+      }
+      chunks.push(value);
+    }
+  } catch (error) {
+    void reader.cancel(error).catch(() => void 0);
+    throw error;
+  }
+  return concatChunks(chunks, total);
+}
+async function readBoundedCachedBody(cached, maxBytes) {
+  return (await readBoundedBufferedBody(cached, maxBytes))?.bytes;
+}
+async function readBoundedBufferedBody(cached, maxBytes) {
+  const value = await cached;
+  const limit = resolveLimit(maxBytes);
+  if (value instanceof Uint8Array) {
+    if (value.byteLength > limit) {
+      throw new HoloRequestBodyTooLargeError(limit);
+    }
+    return { bytes: new Uint8Array(value) };
+  }
+  if (value instanceof ArrayBuffer) {
+    if (value.byteLength > limit) {
+      throw new HoloRequestBodyTooLargeError(limit);
+    }
+    return { bytes: new Uint8Array(value.slice(0)) };
+  }
+  if (typeof value === "string" || value instanceof URLSearchParams) {
+    const bytes = new TextEncoder().encode(value.toString());
+    if (bytes.byteLength > limit) {
+      throw new HoloRequestBodyTooLargeError(limit);
+    }
+    return { bytes };
+  }
+  if (typeof FormData !== "undefined" && value instanceof FormData) {
+    const encoded = new Response(value);
+    const bytes = new Uint8Array(await encoded.arrayBuffer());
+    if (bytes.byteLength > limit) {
+      throw new HoloRequestBodyTooLargeError(limit);
+    }
+    return { bytes, contentType: encoded.headers.get("content-type") ?? void 0 };
+  }
+  if (isWebReadableStream(value)) {
+    return { bytes: await readWebStreamBounded(value, limit) };
+  }
+  if (typeof value === "object" && value !== null && Symbol.asyncIterator in value) {
+    return { bytes: await readBoundedNodeRequestBody(value, limit) };
+  }
+  if (isPlainBufferedObject(value)) {
+    const bytes = new TextEncoder().encode(JSON.stringify(value));
+    if (bytes.byteLength > limit) {
+      throw new HoloRequestBodyTooLargeError(limit);
+    }
+    return { bytes };
+  }
+  return void 0;
+}
+async function readBoundedRequestText(request, maxBytes) {
+  return new TextDecoder().decode(await readBoundedRequestBody(request, maxBytes));
+}
+async function readBoundedRequestJson(request, maxBytes) {
+  return JSON.parse(await readBoundedRequestText(request, maxBytes));
+}
+async function readBoundedRequestFormData(request, maxBytes) {
+  const bytes = await readBoundedRequestBody(request, maxBytes);
+  return new Response(bytes, { headers: { "content-type": request.headers.get("content-type") ?? "" } }).formData();
+}
+async function readBoundedNodeRequestBody(stream, maxBytes, declaredLength) {
+  const limit = resolveLimit(maxBytes);
+  if (declaredLength != null && Number(declaredLength) > limit) {
+    throw new HoloRequestBodyTooLargeError(limit);
+  }
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of stream) {
+    const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk;
+    total += bytes.byteLength;
+    if (total > limit) {
+      throw new HoloRequestBodyTooLargeError(limit);
+    }
+    chunks.push(bytes);
+  }
+  return concatChunks(chunks, total);
+}
+var requestBodyInternals = Object.freeze({
+  configureMaxRequestBodyBytes(bytes) {
+    maxRequestBodyBytes = bytes ?? DEFAULT_MAX_REQUEST_BODY_BYTES;
+  },
+  configureMaxUploadBodyBytes(bytes) {
+    maxUploadBodyBytes = bytes ?? DEFAULT_MAX_UPLOAD_BODY_BYTES;
+  },
+  getMaxRequestBodyBytes() {
+    return maxRequestBodyBytes;
+  }
+});
+
+export {
+  DEFAULT_MAX_REQUEST_BODY_BYTES,
+  DEFAULT_MAX_UPLOAD_BODY_BYTES,
+  requestBodyLimitFor,
+  HoloRequestBodyTooLargeError,
+  readBoundedRequestBody,
+  readBoundedCachedBody,
+  readBoundedBufferedBody,
+  readBoundedRequestText,
+  readBoundedRequestJson,
+  readBoundedRequestFormData,
+  readBoundedNodeRequestBody,
+  requestBodyInternals
+};

package/dist/chunk-K4RCM65I.mjs

@@ -0,0 +1,13 @@
+// src/imageDecoding.ts
+var imageDecodingLimits = Object.freeze({
+  maximumDecodedPixels: 4e7,
+  maximumFrames: 1e3
+});
+async function verifyDecodedImage(_contents, _mimeType, _aspectRatios = []) {
+  throw new Error("[@holo-js/kernel] Server-side image validation must run on Node.js, where images can be fully decoded.");
+}
+
+export {
+  imageDecodingLimits,
+  verifyDecodedImage
+};

package/dist/chunk-QQ5YD7HZ.mjs

@@ -0,0 +1,52 @@
+// src/errorReporting.ts
+function errorReportingState() {
+  const runtime = globalThis;
+  runtime.__holoErrorReporting__ ??= {};
+  return runtime.__holoErrorReporting__;
+}
+function describeContext(context) {
+  return `[holo:${context.capability}] ${context.operation}`;
+}
+function logReporterFailure(error, context, reporterError) {
+  console.error(describeContext(context), error, reporterError);
+}
+function isUnreported(error, exceptions) {
+  return exceptions.dontReport?.some((errorClass) => error instanceof errorClass) ?? false;
+}
+function deliver(exceptions, error, context) {
+  if (exceptions && isUnreported(error, exceptions)) return;
+  if (!exceptions?.report) {
+    console.error(describeContext(context), error);
+    return;
+  }
+  void Promise.resolve(exceptions.report(error, context)).catch((reporterError) => logReporterFailure(error, context, reporterError));
+}
+function reportWith(exceptions, error, context) {
+  try {
+    deliver(exceptions, error, context);
+  } catch (reporterError) {
+    logReporterFailure(error, context, reporterError);
+  }
+}
+function configure(exceptions) {
+  const state = errorReportingState();
+  const previous = state.exceptions;
+  state.exceptions = exceptions;
+  return previous;
+}
+function reportError(error, context) {
+  reportWith(errorReportingState().exceptions, error, context);
+}
+function captureErrorReporter() {
+  const exceptions = errorReportingState().exceptions;
+  return (error, context) => reportWith(exceptions, error, context);
+}
+var errorReportingInternals = {
+  configure
+};
+
+export {
+  reportError,
+  captureErrorReporter,
+  errorReportingInternals
+};

package/dist/error-reporting.d.ts

@@ -0,0 +1,19 @@
+interface HoloErrorReportContext {
+    readonly capability: string;
+    readonly operation: string;
+}
+type HoloUnreportedErrorClass = new (...args: never[]) => Error;
+interface HoloExceptionsConfig {
+    report?(error: unknown, context: HoloErrorReportContext): void | Promise<void>;
+    dontReport?: readonly HoloUnreportedErrorClass[];
+}
+type HoloErrorReporter = (error: unknown, context: HoloErrorReportContext) => void;
+declare function configure(exceptions: HoloExceptionsConfig | undefined): HoloExceptionsConfig | undefined;
+declare function reportError(error: unknown, context: HoloErrorReportContext): void;
+declare function captureErrorReporter(): HoloErrorReporter;
+declare const errorReportingInternals: {
+    configure: typeof configure;
+};
+
+export { captureErrorReporter, errorReportingInternals, reportError };
+export type { HoloErrorReportContext, HoloErrorReporter, HoloExceptionsConfig, HoloUnreportedErrorClass };

package/dist/error-reporting.mjs

@@ -0,0 +1,10 @@
+import {
+  captureErrorReporter,
+  errorReportingInternals,
+  reportError
+} from "./chunk-QQ5YD7HZ.mjs";
+export {
+  captureErrorReporter,
+  errorReportingInternals,
+  reportError
+};

package/dist/file-content.d.ts

@@ -0,0 +1,10 @@
+type FileContentInspection = {
+    readonly mimeType: string | null;
+    readonly passive: boolean;
+};
+declare const fileContentSampleBytes = 65536;
+declare function mimeTypeFromFileName(fileName: string): string | null;
+declare function inspectFileContent(sample: Uint8Array, fileName?: string): Promise<FileContentInspection>;
+
+export { fileContentSampleBytes, inspectFileContent, mimeTypeFromFileName };
+export type { FileContentInspection };

package/dist/file-content.mjs

@@ -0,0 +1,54 @@
+// src/fileContent.ts
+var fileContentSampleBytes = 65536;
+var mimeTypesByExtension = Object.freeze({
+  avif: "image/avif",
+  css: "text/css",
+  csv: "text/csv",
+  gif: "image/gif",
+  htm: "text/html",
+  html: "text/html",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  json: "application/json",
+  md: "text/markdown",
+  mp3: "audio/mpeg",
+  pdf: "application/pdf",
+  png: "image/png",
+  svg: "image/svg+xml",
+  txt: "text/plain",
+  webp: "image/webp",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  xml: "application/xml"
+});
+var passiveDocumentMimeTypes = /* @__PURE__ */ new Set([
+  "application/json",
+  "application/pdf",
+  "text/css",
+  "text/csv",
+  "text/markdown",
+  "text/plain"
+]);
+function isPassiveMimeType(mimeType) {
+  if (!mimeType) return false;
+  return passiveDocumentMimeTypes.has(mimeType) || /^(?:image|audio|video|font)\//u.test(mimeType) && !mimeType.endsWith("+xml");
+}
+function mimeTypeFromFileName(fileName) {
+  const baseName = fileName.slice(Math.max(fileName.lastIndexOf("/"), fileName.lastIndexOf("\\")) + 1);
+  const separator = baseName.lastIndexOf(".");
+  if (separator < 1) return null;
+  return mimeTypesByExtension[baseName.slice(separator + 1).toLowerCase()] ?? null;
+}
+async function inspectFileContent(sample, fileName) {
+  const { fileTypeFromBuffer, supportedMimeTypes } = await import("file-type");
+  const detectableMimeTypes = supportedMimeTypes;
+  const detected = await fileTypeFromBuffer(sample.subarray(0, fileContentSampleBytes)).catch(() => void 0);
+  const named = fileName ? mimeTypeFromFileName(fileName) : null;
+  const mimeType = detected?.mime ?? (named && !detectableMimeTypes.has(named) ? named : null);
+  return { mimeType, passive: isPassiveMimeType(mimeType) };
+}
+export {
+  fileContentSampleBytes,
+  inspectFileContent,
+  mimeTypeFromFileName
+};

package/dist/http-errors.d.ts

@@ -8,4 +8,5 @@ type NormalizedHoloHttpError = {
 declare function isHoloHttpErrorStatus(status: number): status is HoloHttpErrorStatus;
 declare function normalizeHoloHttpError(error: unknown): NormalizedHoloHttpError | undefined;
 
-export { type HoloHttpErrorStatus, type NormalizedHoloHttpError, isHoloHttpErrorStatus, normalizeHoloHttpError };
+export { isHoloHttpErrorStatus, normalizeHoloHttpError };
+export type { HoloHttpErrorStatus, NormalizedHoloHttpError };

package/dist/image-decoding.browser.d.ts

@@ -0,0 +1,6 @@
+import { DecodedImageVerification } from './image-decoding.js';
+export { imageDecodingLimits } from './image-decoding.js';
+
+declare function verifyDecodedImage(_contents: Uint8Array, _mimeType: string, aspectRatios?: readonly (readonly number[])[]): Promise<DecodedImageVerification>;
+
+export { verifyDecodedImage };

package/dist/image-decoding.browser.mjs

@@ -0,0 +1,12 @@
+import {
+  imageDecodingLimits
+} from "./chunk-K4RCM65I.mjs";
+
+// src/imageDecoding.browser.ts
+async function verifyDecodedImage(_contents, _mimeType, aspectRatios = []) {
+  return { valid: true, aspectRatios: aspectRatios.map(() => true) };
+}
+export {
+  imageDecodingLimits,
+  verifyDecodedImage
+};

package/dist/image-decoding.d.ts

@@ -0,0 +1,12 @@
+declare const imageDecodingLimits: Readonly<{
+    maximumDecodedPixels: 40000000;
+    maximumFrames: 1000;
+}>;
+interface DecodedImageVerification {
+    readonly valid: boolean;
+    readonly aspectRatios: readonly boolean[];
+}
+declare function verifyDecodedImage(_contents: Uint8Array, _mimeType: string, _aspectRatios?: readonly (readonly number[])[]): Promise<DecodedImageVerification>;
+
+export { imageDecodingLimits, verifyDecodedImage };
+export type { DecodedImageVerification };

package/dist/image-decoding.mjs

@@ -0,0 +1,8 @@
+import {
+  imageDecodingLimits,
+  verifyDecodedImage
+} from "./chunk-K4RCM65I.mjs";
+export {
+  imageDecodingLimits,
+  verifyDecodedImage
+};

package/dist/image-decoding.node.d.ts

@@ -0,0 +1,6 @@
+import { DecodedImageVerification } from './image-decoding.js';
+export { imageDecodingLimits } from './image-decoding.js';
+
+declare function verifyDecodedImage(contents: Uint8Array, mimeType: string, aspectRatios?: readonly (readonly number[])[]): Promise<DecodedImageVerification>;
+
+export { verifyDecodedImage };

package/dist/image-decoding.node.mjs

@@ -0,0 +1,81 @@
+import {
+  imageDecodingLimits
+} from "./chunk-K4RCM65I.mjs";
+
+// src/imageDecoding.node.ts
+var decodedFormatMatchers = Object.freeze({
+  "image/avif": (metadata) => metadata.format === "heif" && metadata.compression === "av1",
+  "image/gif": (metadata) => metadata.format === "gif",
+  "image/jpeg": (metadata) => metadata.format === "jpeg",
+  "image/png": (metadata) => metadata.format === "png",
+  "image/tiff": (metadata) => metadata.format === "tiff",
+  "image/webp": (metadata) => metadata.format === "webp"
+});
+function isMissingModule(error) {
+  if (!(error instanceof Error)) return false;
+  const code = error.code;
+  return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || isMissingModule(error.cause);
+}
+async function loadSharp() {
+  try {
+    return (await import("sharp")).default;
+  } catch (error) {
+    if (!isMissingModule(error)) throw error;
+    throw new Error('[@holo-js/kernel] Server-side image validation requires the optional "sharp" package. Install sharp in your application.', { cause: error });
+  }
+}
+function skipSubBlocks(bytes, start) {
+  let offset = start;
+  while (offset < bytes.length) {
+    const size = bytes[offset] ?? 0;
+    offset += 1;
+    if (size === 0) return offset;
+    offset += size;
+  }
+  return null;
+}
+function colorTableBytes(flags) {
+  return (flags & 128) === 0 ? 0 : 3 * (1 << (flags & 7) + 1);
+}
+function hasCompleteGifStructure(bytes) {
+  let offset = 13 + colorTableBytes(bytes[10] ?? 0);
+  while (offset !== null && offset < bytes.length) {
+    const introducer = bytes[offset];
+    if (introducer === 59) return true;
+    if (introducer === 33) {
+      offset = skipSubBlocks(bytes, offset + 2);
+    } else if (introducer === 44) {
+      offset = skipSubBlocks(bytes, offset + 10 + colorTableBytes(bytes[offset + 9] ?? 0) + 1);
+    } else {
+      return false;
+    }
+  }
+  return false;
+}
+async function verifyDecodedImage(contents, mimeType, aspectRatios = []) {
+  const invalid = { valid: false, aspectRatios: [] };
+  const matchesDecodedFormat = decodedFormatMatchers[mimeType];
+  if (!matchesDecodedFormat) return invalid;
+  if (mimeType === "image/gif" && !hasCompleteGifStructure(contents)) return invalid;
+  const decode = await loadSharp();
+  try {
+    const image = decode(contents, { animated: true, failOn: "warning", limitInputPixels: imageDecodingLimits.maximumDecodedPixels });
+    const metadata = await image.metadata();
+    if (!matchesDecodedFormat(metadata) || (metadata.pages ?? 1) > imageDecodingLimits.maximumFrames) return invalid;
+    await image.stats();
+    const width = metadata.width;
+    const height = metadata.pageHeight ?? metadata.height;
+    if (!width || !height) return invalid;
+    const precision = 1 / (Math.max((width + height) / 2, height) + 1);
+    return {
+      valid: true,
+      aspectRatios: aspectRatios.map((ratios) => ratios.some((ratio) => Math.abs(ratio - width / height) <= precision))
+    };
+  } catch {
+    return invalid;
+  }
+}
+export {
+  imageDecodingLimits,
+  verifyDecodedImage
+};

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { HoloHttpErrorStatus, NormalizedHoloHttpError, isHoloHttpErrorStatus, normalizeHoloHttpError } from './http-errors.js';
+export { BufferedRequestBody, DEFAULT_MAX_REQUEST_BODY_BYTES, DEFAULT_MAX_UPLOAD_BODY_BYTES, HoloRequestBodyTooLargeError, readBoundedBufferedBody, readBoundedCachedBody, readBoundedNodeRequestBody, readBoundedRequestBody, readBoundedRequestFormData, readBoundedRequestJson, readBoundedRequestText, requestBodyInternals, requestBodyLimitFor } from './request-body.js';
 
 interface RuntimeLifecycleContext {
     readonly projectRoot: string;
@@ -409,4 +410,78 @@ declare function resolveNormalizedRedisConnection(config: NormalizedHoloRedisCon
 declare function normalizeRedisConfig(config?: HoloRedisConfig): NormalizedHoloRedisConfig;
 declare function defineRedisConfig<TConfig extends HoloRedisConfig>(config: TConfig): Readonly<TConfig>;
 
-export { type ConcurrencyOptions, DEFAULT_HOLO_PROJECT_PATHS, DEFAULT_REDIS_CONNECTION, DEFAULT_REDIS_DB, DEFAULT_REDIS_HOST, DEFAULT_REDIS_PORT, type DatabaseLogger, HOLO_PROJECT_PREPARE_API_VERSION, type HoloDatabaseDriver, type HoloGeneratedProjectArtifact, type HoloManagedProjectArtifact, type HoloPluginBroadcastContributions, type HoloPluginCacheContributions, type HoloPluginCliContributions, type HoloPluginConfigContributions, type HoloPluginContributions, type HoloPluginDefinition, type HoloPluginDependencyContributions, type HoloPluginFrameworkContribution, type HoloPluginFrameworkTsconfigKind, type HoloPluginMailContributions, type HoloPluginMigrationContributions, type HoloPluginNotificationContributions, type HoloPluginPackageManager, type HoloPluginProjectContributions, type HoloPluginQueueContributions, type HoloPluginRuntimeContributions, type HoloPluginRuntimeMapContributions, type HoloPluginRuntimeModule, type HoloProjectArtifactContents, type HoloProjectConfig, type HoloProjectConnectionConfig, type HoloProjectDatabaseConfig, type HoloProjectPaths, type HoloProjectPrepareChange, type HoloProjectPrepareChangeKind, type HoloProjectPrepareCommand, type HoloProjectPrepareContext, type HoloProjectPrepareDiagnostic, HoloProjectPrepareError, type HoloProjectPrepareFailure, type HoloProjectPrepareFramework, type HoloProjectPrepareFullRetry, type HoloProjectPrepareLogger, type HoloProjectPrepareModule, type HoloProjectPreparePlugin, type HoloProjectPrepareResult, type HoloProjectPrepareRun, type HoloProjectPrepareSource, type HoloProjectPrepareWatch, type HoloProjectPreparedResult, type HoloProjectPreparer, type HoloRedisClusterNodeConfig, type HoloRedisConfig, type HoloRedisConnectionConfig, type LoadedHoloPluginDefinition, type MigrationErrorLog, type MigrationStartLog, type MigrationSuccessLog, type NormalizedHoloProjectConfig, type NormalizedHoloRedisClusterNodeConfig, type NormalizedHoloRedisConfig, type NormalizedHoloRedisConnectionConfig, type PluginLoadOptions, type QueryErrorLog, type QueryStartLog, type QuerySuccessLog, type RuntimeContribution, RuntimeLifecycle, type RuntimeLifecycleContext, type SeederErrorLog, type SeederStartLog, type SeederSuccessLog, type TransactionLog, type TransactionScopeKind, createRuntimeLifecycle, defineHoloPlugin, defineHoloProject, defineHoloProjectPreparer, defineRedisConfig, holoRedisDefaults, loadHoloPluginBootModules, loadHoloPluginContributionModules, loadHoloPluginDefinitions, normalizeHoloPluginDefinition, normalizeHoloProjectConfig, normalizeRedisConfig, resolveHoloPluginModulePath, resolveNormalizedRedisConnection };
+type HoloRequestHeaders = Headers | ReadonlyArray<readonly [string, string]> | Record<string, string | readonly string[] | undefined> | {
+    readonly get?: (name: string) => string | null | undefined;
+    readonly forEach?: (callback: (value: string, key: string) => void) => void;
+    readonly entries?: () => Iterable<readonly [string, string]>;
+};
+type RequestUrlParts = {
+    readonly url?: string | URL;
+    readonly path?: string;
+    readonly headers?: HoloRequestHeaders;
+};
+type HoloRequestInput = RequestUrlParts & {
+    readonly request?: Request;
+    readonly req?: RequestUrlParts;
+    readonly node?: {
+        readonly req?: RequestUrlParts;
+    };
+    readonly web?: {
+        readonly request?: RequestUrlParts;
+    };
+};
+type HoloForwardedRequest = {
+    readonly address?: string;
+    readonly protocol?: string;
+    readonly host?: string;
+    readonly port?: string;
+    readonly prefix?: string;
+};
+type HoloForwardedRequestResolver = (readHeader: (name: string) => string | undefined, connectionAddress: string | undefined) => HoloForwardedRequest;
+type HoloConnectionAddressProvider = () => string | undefined;
+declare function configureForwardedRequestResolver(resolver: HoloForwardedRequestResolver | undefined): void;
+declare function provideConnectionAddress(provider: HoloConnectionAddressProvider | undefined): void;
+declare function currentConnectionAddress(): string | undefined;
+declare class HoloRequestUrlError extends TypeError {
+    readonly status = 400;
+    constructor(message: string);
+}
+declare function resolveRequestUrl(input: HoloRequestInput): URL;
+declare function resolveRoutedRequestUrl(input: HoloRequestInput): URL;
+declare function resolveClientAddress(input: HoloRequestInput): string | undefined;
+declare const requestUrlInternals: Readonly<{
+    configureForwardedRequestResolver: typeof configureForwardedRequestResolver;
+    currentConnectionAddress: typeof currentConnectionAddress;
+    provideConnectionAddress: typeof provideConnectionAddress;
+    resolveClientAddress: typeof resolveClientAddress;
+    resolveRoutedRequestUrl: typeof resolveRoutedRequestUrl;
+}>;
+declare function sameOriginRedirectPath(path: string | undefined): string;
+
+declare function encryptCookieValue(name: string, value: string, appKey: string | undefined): string;
+declare function decryptCookieValue(name: string, value: string, appKey: string | undefined): string | undefined;
+declare const cookieEncryptionInternals: Readonly<{
+    decryptCookieValue: typeof decryptCookieValue;
+    encryptCookieValue: typeof encryptCookieValue;
+}>;
+
+declare function windowsStorageNameProblem(name: string): string | null;
+declare function segmentProblem(segment: string): string | null;
+declare function assertValidSegment(segment: string): void;
+declare function splitLocalStoragePath(path: string): string[];
+declare function isReservedLocalStorageName(name: string | undefined): boolean;
+declare const localStoragePathInternals: {
+    assertValidSegment: typeof assertValidSegment;
+    isReservedLocalStorageName: typeof isReservedLocalStorageName;
+    segmentProblem: typeof segmentProblem;
+    splitLocalStoragePath: typeof splitLocalStoragePath;
+    windowsStorageNameProblem: typeof windowsStorageNameProblem;
+};
+
+declare const COOKIE_WRITE_UNAVAILABLE = "cookie_write_unavailable";
+declare function createCookieWriteUnavailableError(message: string, cause?: unknown): Error;
+
+declare function resolveRetryBackoffSeconds(backoff: number | readonly number[], attempt: number): number;
+
+export { COOKIE_WRITE_UNAVAILABLE, DEFAULT_HOLO_PROJECT_PATHS, DEFAULT_REDIS_CONNECTION, DEFAULT_REDIS_DB, DEFAULT_REDIS_HOST, DEFAULT_REDIS_PORT, HOLO_PROJECT_PREPARE_API_VERSION, HoloProjectPrepareError, HoloRequestUrlError, RuntimeLifecycle, cookieEncryptionInternals, createCookieWriteUnavailableError, createRuntimeLifecycle, defineHoloPlugin, defineHoloProject, defineHoloProjectPreparer, defineRedisConfig, holoRedisDefaults, loadHoloPluginBootModules, loadHoloPluginContributionModules, loadHoloPluginDefinitions, localStoragePathInternals, normalizeHoloPluginDefinition, normalizeHoloProjectConfig, normalizeRedisConfig, requestUrlInternals, resolveHoloPluginModulePath, resolveNormalizedRedisConnection, resolveRequestUrl, resolveRetryBackoffSeconds, sameOriginRedirectPath };
+export type { ConcurrencyOptions, DatabaseLogger, HoloConnectionAddressProvider, HoloDatabaseDriver, HoloForwardedRequest, HoloForwardedRequestResolver, HoloGeneratedProjectArtifact, HoloManagedProjectArtifact, HoloPluginBroadcastContributions, HoloPluginCacheContributions, HoloPluginCliContributions, HoloPluginConfigContributions, HoloPluginContributions, HoloPluginDefinition, HoloPluginDependencyContributions, HoloPluginFrameworkContribution, HoloPluginFrameworkTsconfigKind, HoloPluginMailContributions, HoloPluginMigrationContributions, HoloPluginNotificationContributions, HoloPluginPackageManager, HoloPluginProjectContributions, HoloPluginQueueContributions, HoloPluginRuntimeContributions, HoloPluginRuntimeMapContributions, HoloPluginRuntimeModule, HoloProjectArtifactContents, HoloProjectConfig, HoloProjectConnectionConfig, HoloProjectDatabaseConfig, HoloProjectPaths, HoloProjectPrepareChange, HoloProjectPrepareChangeKind, HoloProjectPrepareCommand, HoloProjectPrepareContext, HoloProjectPrepareDiagnostic, HoloProjectPrepareFailure, HoloProjectPrepareFramework, HoloProjectPrepareFullRetry, HoloProjectPrepareLogger, HoloProjectPrepareModule, HoloProjectPreparePlugin, HoloProjectPrepareResult, HoloProjectPrepareRun, HoloProjectPrepareSource, HoloProjectPrepareWatch, HoloProjectPreparedResult, HoloProjectPreparer, HoloRedisClusterNodeConfig, HoloRedisConfig, HoloRedisConnectionConfig, HoloRequestHeaders, HoloRequestInput, LoadedHoloPluginDefinition, MigrationErrorLog, MigrationStartLog, MigrationSuccessLog, NormalizedHoloProjectConfig, NormalizedHoloRedisClusterNodeConfig, NormalizedHoloRedisConfig, NormalizedHoloRedisConnectionConfig, PluginLoadOptions, QueryErrorLog, QueryStartLog, QuerySuccessLog, RuntimeContribution, RuntimeLifecycleContext, SeederErrorLog, SeederStartLog, SeederSuccessLog, TransactionLog, TransactionScopeKind };

package/dist/index.mjs

@@ -2,6 +2,20 @@ import {
   isHoloHttpErrorStatus,
   normalizeHoloHttpError
 } from "./chunk-UIGMROG3.mjs";
+import {
+  DEFAULT_MAX_REQUEST_BODY_BYTES,
+  DEFAULT_MAX_UPLOAD_BODY_BYTES,
+  HoloRequestBodyTooLargeError,
+  readBoundedBufferedBody,
+  readBoundedCachedBody,
+  readBoundedNodeRequestBody,
+  readBoundedRequestBody,
+  readBoundedRequestFormData,
+  readBoundedRequestJson,
+  readBoundedRequestText,
+  requestBodyInternals,
+  requestBodyLimitFor
+} from "./chunk-CGVSGOEO.mjs";
 
 // src/lifecycle.ts
 function orderContributions(contributions) {
@@ -51,7 +65,7 @@ var RuntimeLifecycle = class {
       try {
         await this.dispose(context);
       } catch (cleanupError) {
-        throw new AggregateError([error, cleanupError], "[Holo Runtime] Initialization and rollback both failed.");
+        throw new AggregateError([error, cleanupError], "[Holo Runtime] Initialization and rollback both failed.", { cause: cleanupError });
       }
       throw error;
     }
@@ -168,7 +182,7 @@ async function loadHoloPluginDefinitions(projectRoot, packageNames, options = {}
     try {
       manifest = JSON.parse(await readFile(packageJsonPath, "utf8"));
     } catch (error) {
-      if (isRecord(error) && error.code === "ENOENT") throw new Error(`Cannot find module '${packageName}/package.json'`);
+      if (isRecord(error) && error.code === "ENOENT") throw new Error(`Cannot find module '${packageName}/package.json'`, { cause: error });
       throw error;
     }
     if (!isRecord(manifest.holo) || !normalizeString(manifest.holo.plugin)) {
@@ -325,7 +339,7 @@ function normalizeUrl(value, label) {
     if (error instanceof Error && error.message.startsWith("[Holo Redis]")) {
       throw error;
     }
-    throw new Error(`[Holo Redis] ${label} must be a valid redis:// or rediss:// URL.`);
+    throw new Error(`[Holo Redis] ${label} must be a valid redis:// or rediss:// URL.`, { cause: error });
   }
   return normalized;
 }
@@ -426,15 +440,264 @@ function normalizeRedisConfig(config = {}) {
 function defineRedisConfig(config) {
   return Object.freeze({ ...config });
 }
+
+// src/requestUrl.ts
+function requestForwardingState() {
+  const runtime = globalThis;
+  runtime.__holoRequestForwarding__ ??= {};
+  return runtime.__holoRequestForwarding__;
+}
+function configureForwardedRequestResolver(resolver) {
+  requestForwardingState().resolveForwardedRequest = resolver;
+}
+function provideConnectionAddress(provider) {
+  requestForwardingState().connectionAddress = provider;
+}
+function currentConnectionAddress() {
+  try {
+    return requestForwardingState().connectionAddress?.();
+  } catch {
+    return void 0;
+  }
+}
+function isHeaderTuples(headers) {
+  return Array.isArray(headers);
+}
+function readHeader(headers, name) {
+  if (!headers) return void 0;
+  if (isHeaderTuples(headers)) {
+    return headers.find(([key]) => key.toLowerCase() === name)?.[1];
+  }
+  if ("get" in headers && typeof headers.get === "function") return headers.get(name) ?? void 0;
+  if ("entries" in headers && typeof headers.entries === "function") {
+    for (const [key, value] of headers.entries()) {
+      if (key.toLowerCase() === name) return value;
+    }
+    return void 0;
+  }
+  if ("forEach" in headers && typeof headers.forEach === "function") {
+    let result;
+    headers.forEach((value, key) => {
+      if (key.toLowerCase() === name) result = value;
+    });
+    return result;
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === name) {
+      return typeof value === "string" ? value : Array.isArray(value) ? value.join(",") : void 0;
+    }
+  }
+  return void 0;
+}
+var HoloRequestUrlError = class extends TypeError {
+  status = 400;
+  constructor(message) {
+    super(`[@holo-js/kernel] ${message}`);
+    this.name = "HoloRequestUrlError";
+  }
+};
+var invalidRequestHostMessage = "Request hosts must be a valid hostname and optional port.";
+var invalidRequestPortMessage = "Request ports must be a number from 0 to 65535.";
+var invalidRequestPrefixMessage = 'Request prefixes must be a path starting with a single "/".';
+function validForwardedPort(port) {
+  if (!/^\d{1,5}$/u.test(port) || Number(port) > 65535) throw new HoloRequestUrlError(invalidRequestPortMessage);
+  return port;
+}
+function validForwardedPrefix(prefix) {
+  const trimmed = prefix.replace(/\/+$/u, "");
+  if (trimmed && (!trimmed.startsWith("/") || trimmed.startsWith("//") || /[\s?#\\]/u.test(trimmed))) {
+    throw new HoloRequestUrlError(invalidRequestPrefixMessage);
+  }
+  return trimmed;
+}
+function parseRequestUrl(value, invalidMessage) {
+  if (!URL.canParse(String(value), "http://localhost")) throw new HoloRequestUrlError(invalidMessage);
+  return new URL(value, "http://localhost");
+}
+function nestedRequest(input) {
+  return input instanceof Request ? void 0 : input.request ?? input.web?.request ?? input.req ?? input.node?.req;
+}
+function requestHeaders(input) {
+  return input.headers ?? nestedRequest(input)?.headers;
+}
+function resolveForwardedRequest(headers) {
+  return requestForwardingState().resolveForwardedRequest?.((name) => readHeader(headers, name), currentConnectionAddress());
+}
+function resolveUrl(input, applyPrefix) {
+  const nested = nestedRequest(input);
+  const headers = requestHeaders(input);
+  const value = input.url ?? nested?.url ?? input.path ?? (nested && "path" in nested ? nested.path : void 0) ?? "/";
+  const invalidUrlMessage = "Request URLs must use http or https without credentials.";
+  const url = parseRequestUrl(value, invalidUrlMessage);
+  if (url.username || url.password || url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new HoloRequestUrlError(invalidUrlMessage);
+  }
+  const forwarded = resolveForwardedRequest(headers);
+  const protocol = (forwarded?.protocol ?? url.protocol.slice(0, -1)).toLowerCase();
+  if (protocol !== "http" && protocol !== "https") {
+    throw new HoloRequestUrlError("Request protocols must be http or https.");
+  }
+  const host = forwarded?.host ?? readHeader(headers, "host") ?? url.host;
+  if (!host || /[\s,/@\\?#]/u.test(host)) {
+    throw new HoloRequestUrlError(invalidRequestHostMessage);
+  }
+  const origin = parseRequestUrl(`${protocol}://${host}`, invalidRequestHostMessage);
+  if (origin.pathname !== "/" || origin.username || origin.password || origin.search || origin.hash) {
+    throw new HoloRequestUrlError(invalidRequestHostMessage);
+  }
+  if (forwarded?.port !== void 0) origin.port = validForwardedPort(forwarded.port);
+  url.protocol = origin.protocol;
+  url.host = origin.host;
+  url.port = origin.port;
+  const prefix = forwarded?.prefix === void 0 ? "" : validForwardedPrefix(forwarded.prefix);
+  if (applyPrefix) url.pathname = `${prefix}${url.pathname}`;
+  return url;
+}
+function resolveRequestUrl(input) {
+  return resolveUrl(input, true);
+}
+function resolveRoutedRequestUrl(input) {
+  return resolveUrl(input, false);
+}
+function resolveClientAddress(input) {
+  if (!requestForwardingState().resolveForwardedRequest) return currentConnectionAddress();
+  return resolveForwardedRequest(requestHeaders(input))?.address;
+}
+var requestUrlInternals = Object.freeze({
+  configureForwardedRequestResolver,
+  currentConnectionAddress,
+  provideConnectionAddress,
+  resolveClientAddress,
+  resolveRoutedRequestUrl
+});
+function hasControlCharacter(value) {
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+function sameOriginRedirectPath(path) {
+  if (!path || !path.startsWith("/") || path.startsWith("//") || path.includes("\\") || hasControlCharacter(path)) {
+    return "/";
+  }
+  return path;
+}
+
+// src/cookieEncryption.ts
+import { createCipheriv, createDecipheriv, createHmac, randomBytes } from "crypto";
+var IV_BYTES = 12;
+var TAG_BYTES = 16;
+function cookieEncryptionKey(appKey) {
+  const key = appKey?.trim();
+  if (!key) {
+    throw new Error('[@holo-js/kernel] Holo cookies are encrypted with the application key. Set APP_KEY or run "holo key:generate".');
+  }
+  return createHmac("sha256", key).update("holo-js:cookie-encryption").digest();
+}
+function encryptCookieValue(name, value, appKey) {
+  const iv = randomBytes(IV_BYTES);
+  const cipher = createCipheriv("aes-256-gcm", cookieEncryptionKey(appKey), iv);
+  cipher.setAAD(Buffer.from(name, "utf8"));
+  const encrypted = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
+  return Buffer.concat([iv, cipher.getAuthTag(), encrypted]).toString("base64url");
+}
+function decryptCookieValue(name, value, appKey) {
+  const key = cookieEncryptionKey(appKey);
+  const payload = Buffer.from(value, "base64url");
+  if (payload.toString("base64url") !== value) return void 0;
+  if (payload.length < IV_BYTES + TAG_BYTES) return void 0;
+  try {
+    const decipher = createDecipheriv("aes-256-gcm", key, payload.subarray(0, IV_BYTES));
+    decipher.setAAD(Buffer.from(name, "utf8"));
+    decipher.setAuthTag(payload.subarray(IV_BYTES, IV_BYTES + TAG_BYTES));
+    return Buffer.concat([decipher.update(payload.subarray(IV_BYTES + TAG_BYTES)), decipher.final()]).toString("utf8");
+  } catch {
+    return void 0;
+  }
+}
+var cookieEncryptionInternals = Object.freeze({ decryptCookieValue, encryptCookieValue });
+
+// src/localStoragePath.ts
+var WINDOWS_DEVICE_NAMES = /* @__PURE__ */ new Set([
+  "CON",
+  "PRN",
+  "AUX",
+  "NUL",
+  ...["COM", "LPT"].flatMap((device) => ["1", "2", "3", "4", "5", "6", "7", "8", "9", "\xB9", "\xB2", "\xB3"].map((digit) => `${device}${digit}`))
+]);
+function windowsStorageNameProblem(name) {
+  const hasControlCharacter2 = Array.from(name).some((character) => character.charCodeAt(0) < 32);
+  if (hasControlCharacter2 || /[<>:"|?*]/u.test(name)) {
+    return 'Windows file names cannot contain < > : " | ? * or control characters';
+  }
+  if (/[. ]$/u.test(name)) {
+    return "Windows file names cannot end with a dot or a space";
+  }
+  const baseName = (name.split(".", 1)[0] ?? "").replace(/ +$/u, "").toUpperCase();
+  if (WINDOWS_DEVICE_NAMES.has(baseName)) {
+    return "Windows reserves this device name";
+  }
+  return null;
+}
+function segmentProblem(segment) {
+  if (segment === "..") {
+    return 'Storage paths must not contain ".." segments';
+  }
+  if (segment === "" || segment === "." || /[\\/]/u.test(segment) || segment.includes("\0")) {
+    return "Storage path segments must be file or folder names";
+  }
+  return process.platform === "win32" ? windowsStorageNameProblem(segment) : null;
+}
+function assertValidSegment(segment) {
+  const problem = segmentProblem(segment);
+  if (problem) throw new Error(`[Holo Storage] ${problem}.`);
+}
+function splitLocalStoragePath(path) {
+  return path.trimStart().replace(/\\/g, "/").split("/").filter(Boolean);
+}
+function isReservedLocalStorageName(name) {
+  return name?.endsWith("$") === true;
+}
+var localStoragePathInternals = {
+  assertValidSegment,
+  isReservedLocalStorageName,
+  segmentProblem,
+  splitLocalStoragePath,
+  windowsStorageNameProblem
+};
+
+// src/cookieWriteUnavailable.ts
+var COOKIE_WRITE_UNAVAILABLE = "cookie_write_unavailable";
+function createCookieWriteUnavailableError(message, cause) {
+  return Object.assign(new Error(message, { cause }), {
+    code: COOKIE_WRITE_UNAVAILABLE
+  });
+}
+
+// src/retryBackoff.ts
+function resolveRetryBackoffSeconds(backoff, attempt) {
+  if (typeof backoff === "number") {
+    return backoff;
+  }
+  return backoff[Math.min(Math.max(attempt - 1, 0), backoff.length - 1)] ?? 0;
+}
 export {
+  COOKIE_WRITE_UNAVAILABLE,
   DEFAULT_HOLO_PROJECT_PATHS,
+  DEFAULT_MAX_REQUEST_BODY_BYTES,
+  DEFAULT_MAX_UPLOAD_BODY_BYTES,
   DEFAULT_REDIS_CONNECTION,
   DEFAULT_REDIS_DB,
   DEFAULT_REDIS_HOST,
   DEFAULT_REDIS_PORT,
   HOLO_PROJECT_PREPARE_API_VERSION,
   HoloProjectPrepareError,
+  HoloRequestBodyTooLargeError,
+  HoloRequestUrlError,
   RuntimeLifecycle,
+  cookieEncryptionInternals,
+  createCookieWriteUnavailableError,
   createRuntimeLifecycle,
   defineHoloPlugin,
   defineHoloProject,
@@ -445,10 +708,24 @@ export {
   loadHoloPluginBootModules,
   loadHoloPluginContributionModules,
   loadHoloPluginDefinitions,
+  localStoragePathInternals,
   normalizeHoloHttpError,
   normalizeHoloPluginDefinition,
   normalizeHoloProjectConfig,
   normalizeRedisConfig,
+  readBoundedBufferedBody,
+  readBoundedCachedBody,
+  readBoundedNodeRequestBody,
+  readBoundedRequestBody,
+  readBoundedRequestFormData,
+  readBoundedRequestJson,
+  readBoundedRequestText,
+  requestBodyInternals,
+  requestBodyLimitFor,
+  requestUrlInternals,
   resolveHoloPluginModulePath,
-  resolveNormalizedRedisConnection
+  resolveNormalizedRedisConnection,
+  resolveRequestUrl,
+  resolveRetryBackoffSeconds,
+  sameOriginRedirectPath
 };

package/dist/managed-resources.d.ts

@@ -0,0 +1,24 @@
+declare function throwCapabilityFailures(failures: readonly unknown[]): void;
+interface ReleasableResource {
+    close?(): void | Promise<void>;
+    disconnect?(): void | Promise<void>;
+}
+interface HeldResource {
+    hold<TResult>(operation: () => TResult): TResult;
+}
+interface ResourceLease<TValue> extends HeldResource {
+    readonly value: TValue;
+}
+interface ManagedResources<TConfig, TValue extends ReleasableResource> {
+    acquire(config: TConfig, create: (config: TConfig) => TValue): Promise<ResourceLease<TValue>>;
+    commit(): Promise<void>;
+    discard(): Promise<void>;
+    dispose(): Promise<void>;
+}
+declare function createManagedResources<TConfig, TValue extends ReleasableResource>(options?: {
+    readonly connect?: (value: TValue) => void | Promise<void>;
+}): ManagedResources<TConfig, TValue>;
+declare function holdOperations<TTarget extends object>(target: TTarget, lease: HeldResource): TTarget;
+
+export { createManagedResources, holdOperations, throwCapabilityFailures };
+export type { HeldResource, ManagedResources, ReleasableResource, ResourceLease };

package/dist/managed-resources.mjs

@@ -0,0 +1,155 @@
+import {
+  reportError
+} from "./chunk-QQ5YD7HZ.mjs";
+
+// src/managedResources.ts
+import { isDeepStrictEqual } from "util";
+function throwCapabilityFailures(failures) {
+  if (failures.length === 1) throw failures[0];
+  if (failures.length > 1) throw new AggregateError(failures, "Optional capability cleanup failed.");
+}
+async function releaseManagedResources(adapters) {
+  const failures = [];
+  for (const adapter of [...new Set(adapters)].reverse()) {
+    try {
+      if (adapter.close) await adapter.close();
+      else await adapter.disconnect?.();
+    } catch (error) {
+      failures.push(error);
+    }
+  }
+  throwCapabilityFailures(failures);
+}
+function createManagedResources(options = {}) {
+  let active = [];
+  let retained = [];
+  let claimed = [];
+  let opened = [];
+  let disposing = false;
+  let disposalFailures = [];
+  const releasing = /* @__PURE__ */ new Set();
+  const findSameConfig = (entries, config) => entries.find((entry) => isDeepStrictEqual(entry.config, config));
+  const track = (promise) => {
+    releasing.add(promise);
+    promise.then(() => releasing.delete(promise));
+  };
+  const reportReplacedResourceFailure = (error) => reportError(error, {
+    capability: "runtime",
+    operation: "releaseReplacedResource"
+  });
+  const startClose = (entry, onFailure) => {
+    entry.state = "closing";
+    retained = retained.filter((candidate) => candidate !== entry);
+    return releaseManagedResources([entry.value]).catch(onFailure).finally(() => entry.onDrained?.());
+  };
+  const retireEntry = (entry, onFailure) => {
+    if (entry.pending === 0) return startClose(entry, onFailure);
+    entry.state = "draining";
+    entry.onFailure = onFailure;
+    return new Promise((resolve) => {
+      entry.onDrained = resolve;
+    });
+  };
+  const finishOperation = (entry) => {
+    entry.pending -= 1;
+    if (entry.pending !== 0 || entry.state === "closing") return;
+    const awaitingClose = entry.state === "draining" || retained.includes(entry) && !claimed.includes(entry);
+    if (awaitingClose) track(startClose(entry, entry.onFailure ?? reportReplacedResourceFailure));
+  };
+  const createEntry = (config, value) => {
+    const entry = {
+      config,
+      value,
+      pending: 0,
+      state: "open",
+      lease: {
+        value,
+        hold(operation) {
+          if (entry.state === "closing") throw new Error("[@holo-js/kernel] The managed resource is closed.");
+          entry.pending += 1;
+          let result;
+          try {
+            result = operation();
+          } catch (error) {
+            finishOperation(entry);
+            throw error;
+          }
+          if (result instanceof Promise) {
+            result.finally(() => finishOperation(entry)).catch(() => void 0);
+          } else {
+            finishOperation(entry);
+          }
+          return result;
+        }
+      }
+    };
+    return entry;
+  };
+  return {
+    async acquire(config, create) {
+      if (disposing) throw new Error("[@holo-js/kernel] Managed resources are disposed; acquire a new registry instead.");
+      const reusable = findSameConfig(claimed, config) ?? findSameConfig(active, config) ?? findSameConfig(retained, config);
+      if (reusable) {
+        if (!claimed.includes(reusable)) claimed.push(reusable);
+        return reusable.lease;
+      }
+      const entry = createEntry(config, create(config));
+      opened.push(entry);
+      await options.connect?.(entry.value);
+      claimed.push(entry);
+      return entry.lease;
+    },
+    async commit() {
+      const previouslyOpen = [...active, ...retained];
+      active = claimed;
+      claimed = [];
+      opened = [];
+      retained = previouslyOpen.filter((entry) => !active.includes(entry));
+      const idle = retained.filter((entry) => entry.pending === 0);
+      retained = retained.filter((entry) => entry.pending > 0);
+      await Promise.all(idle.map((entry) => retireEntry(entry, reportReplacedResourceFailure)));
+    },
+    async discard() {
+      const revivedIdle = claimed.filter((entry) => retained.includes(entry) && entry.pending === 0);
+      retained = retained.filter((entry) => !revivedIdle.includes(entry));
+      const entries = [...opened, ...revivedIdle];
+      claimed = [];
+      opened = [];
+      const failures = [];
+      await Promise.all(entries.map((entry) => retireEntry(entry, (error) => {
+        failures.push(error);
+      })));
+      throwCapabilityFailures(failures);
+    },
+    async dispose() {
+      disposing = true;
+      disposalFailures = [];
+      const entries = /* @__PURE__ */ new Set([...active, ...retained, ...claimed, ...opened]);
+      active = [];
+      retained = [];
+      claimed = [];
+      opened = [];
+      for (const entry of entries) {
+        track(retireEntry(entry, (error) => {
+          disposalFailures.push(error);
+        }));
+      }
+      while (releasing.size > 0) await Promise.all([...releasing]);
+      throwCapabilityFailures(disposalFailures);
+    }
+  };
+}
+function holdOperations(target, lease) {
+  return new Proxy(target, {
+    get(source, property) {
+      const value = Reflect.get(source, property, source);
+      if (typeof value !== "function") return value;
+      return (...args) => lease.hold(() => Reflect.apply(value, source, args));
+    }
+  });
+}
+export {
+  createManagedResources,
+  holdOperations,
+  throwCapabilityFailures
+};

package/dist/request-body.d.ts

@@ -0,0 +1,26 @@
+declare const DEFAULT_MAX_REQUEST_BODY_BYTES: number;
+declare const DEFAULT_MAX_UPLOAD_BODY_BYTES: number;
+declare function requestBodyLimitFor(contentType: string | null | undefined): number;
+declare class HoloRequestBodyTooLargeError extends Error {
+    readonly status = 413;
+    constructor(limit: number);
+}
+declare function readBoundedRequestBody(request: Request, maxBytes?: number): Promise<Uint8Array<ArrayBuffer>>;
+type BufferedRequestBody = {
+    readonly bytes: Uint8Array<ArrayBuffer>;
+    readonly contentType?: string;
+};
+declare function readBoundedCachedBody(cached: unknown, maxBytes?: number): Promise<Uint8Array<ArrayBuffer> | undefined>;
+declare function readBoundedBufferedBody(cached: unknown, maxBytes?: number): Promise<BufferedRequestBody | undefined>;
+declare function readBoundedRequestText(request: Request, maxBytes?: number): Promise<string>;
+declare function readBoundedRequestJson(request: Request, maxBytes?: number): Promise<unknown>;
+declare function readBoundedRequestFormData(request: Request, maxBytes?: number): Promise<FormData>;
+declare function readBoundedNodeRequestBody(stream: AsyncIterable<Uint8Array | string>, maxBytes?: number, declaredLength?: string | null): Promise<Uint8Array<ArrayBuffer>>;
+declare const requestBodyInternals: Readonly<{
+    configureMaxRequestBodyBytes(bytes: number | undefined): void;
+    configureMaxUploadBodyBytes(bytes: number | undefined): void;
+    getMaxRequestBodyBytes(): number;
+}>;
+
+export { DEFAULT_MAX_REQUEST_BODY_BYTES, DEFAULT_MAX_UPLOAD_BODY_BYTES, HoloRequestBodyTooLargeError, readBoundedBufferedBody, readBoundedCachedBody, readBoundedNodeRequestBody, readBoundedRequestBody, readBoundedRequestFormData, readBoundedRequestJson, readBoundedRequestText, requestBodyInternals, requestBodyLimitFor };
+export type { BufferedRequestBody };

package/dist/request-body.mjs

@@ -0,0 +1,28 @@
+import {
+  DEFAULT_MAX_REQUEST_BODY_BYTES,
+  DEFAULT_MAX_UPLOAD_BODY_BYTES,
+  HoloRequestBodyTooLargeError,
+  readBoundedBufferedBody,
+  readBoundedCachedBody,
+  readBoundedNodeRequestBody,
+  readBoundedRequestBody,
+  readBoundedRequestFormData,
+  readBoundedRequestJson,
+  readBoundedRequestText,
+  requestBodyInternals,
+  requestBodyLimitFor
+} from "./chunk-CGVSGOEO.mjs";
+export {
+  DEFAULT_MAX_REQUEST_BODY_BYTES,
+  DEFAULT_MAX_UPLOAD_BODY_BYTES,
+  HoloRequestBodyTooLargeError,
+  readBoundedBufferedBody,
+  readBoundedCachedBody,
+  readBoundedNodeRequestBody,
+  readBoundedRequestBody,
+  readBoundedRequestFormData,
+  readBoundedRequestJson,
+  readBoundedRequestText,
+  requestBodyInternals,
+  requestBodyLimitFor
+};

package/package.json

@@ -1,25 +1,57 @@
 {
   "name": "@holo-js/kernel",
-  "version": "0.3.27",
-  "description": "Holo-JS Framework - dependency-free contracts, plugins, and runtime lifecycle",
+  "version": "0.4.0",
+  "description": "Holo-JS Framework - contracts, plugins, and runtime lifecycle",
   "type": "module",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cobraprojects/holo-js.git",
+    "directory": "packages/kernel"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./error-reporting": {
+      "types": "./dist/error-reporting.d.ts",
+      "import": "./dist/error-reporting.mjs",
+      "default": "./dist/error-reporting.mjs"
+    },
     "./http-errors": {
       "types": "./dist/http-errors.d.ts",
       "import": "./dist/http-errors.mjs",
       "default": "./dist/http-errors.mjs"
+    },
+    "./managed-resources": {
+      "types": "./dist/managed-resources.d.ts",
+      "import": "./dist/managed-resources.mjs",
+      "default": "./dist/managed-resources.mjs"
+    },
+    "./file-content": {
+      "types": "./dist/file-content.d.ts",
+      "import": "./dist/file-content.mjs",
+      "default": "./dist/file-content.mjs"
+    },
+    "./request-body": {
+      "types": "./dist/request-body.d.ts",
+      "import": "./dist/request-body.mjs",
+      "default": "./dist/request-body.mjs"
+    },
+    "./image-decoding": {
+      "types": "./dist/image-decoding.d.ts",
+      "browser": "./dist/image-decoding.browser.mjs",
+      "node": "./dist/image-decoding.node.mjs",
+      "default": "./dist/image-decoding.mjs"
     }
   },
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
   "scripts": {
     "build": "tsup",
@@ -27,13 +59,25 @@
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest --run"
   },
+  "dependencies": {
+    "file-type": "^22.2.0"
+  },
   "devDependencies": {
-    "@types/node": "^22.10.2",
-    "tsup": "^8.3.5",
-    "typescript": "^5.7.2",
-    "vitest": "^4.1.5"
+    "@types/node": "^22.20.5",
+    "sharp": "^0.35.5",
+    "tsup": "^9.0.0",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.5"
   },
   "engines": {
-    "node": "^22.12.0 || ^24.0.0 || ^26.0.0"
+    "node": "^22.18.0 || ^24.0.0 || ^26.0.0"
+  },
+  "peerDependencies": {
+    "sharp": "^0.35.5"
+  },
+  "peerDependenciesMeta": {
+    "sharp": {
+      "optional": true
+    }
   }
 }