@holo-js/kernel 0.3.28 → 0.4.1

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 @@
+e3c435dda503d53760a65c69eb04a2a3f39e4e925d8d1a73214a0dd32e254fca

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

@@ -6,4 +6,5 @@ declare const fileContentSampleBytes = 65536;
 declare function mimeTypeFromFileName(fileName: string): string | null;
 declare function inspectFileContent(sample: Uint8Array, fileName?: string): Promise<FileContentInspection>;
 
-export { type FileContentInspection, fileContentSampleBytes, inspectFileContent, mimeTypeFromFileName };
+export { fileContentSampleBytes, inspectFileContent, mimeTypeFromFileName };
+export type { FileContentInspection };

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

@@ -1,3 +1,6 @@
-declare function verifyDecodedImage(_contents: Uint8Array, _mimeType: string): Promise<boolean>;
+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

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

package/dist/image-decoding.d.ts

@@ -1,3 +1,12 @@
-declare function verifyDecodedImage(_contents: Uint8Array, _mimeType: string): Promise<boolean>;
+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 { verifyDecodedImage };
+export { imageDecodingLimits, verifyDecodedImage };
+export type { DecodedImageVerification };

package/dist/image-decoding.mjs

@@ -1,7 +1,8 @@
-// src/imageDecoding.ts
-async function verifyDecodedImage(_contents, _mimeType) {
-  throw new Error("[@holo-js/kernel] Server-side image validation must run on Node.js, where images can be fully decoded.");
-}
+import {
+  imageDecodingLimits,
+  verifyDecodedImage
+} from "./chunk-K4RCM65I.mjs";
 export {
+  imageDecodingLimits,
   verifyDecodedImage
 };

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

@@ -1,3 +1,6 @@
-declare function verifyDecodedImage(contents: Uint8Array, mimeType: string): Promise<boolean>;
+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

@@ -1,6 +1,8 @@
+import {
+  imageDecodingLimits
+} from "./chunk-K4RCM65I.mjs";
+
 // src/imageDecoding.node.ts
-var maximumDecodedPixels = 4e7;
-var maximumFrames = 1e3;
 var decodedFormatMatchers = Object.freeze({
   "image/avif": (metadata) => metadata.format === "heif" && metadata.compression === "av1",
   "image/gif": (metadata) => metadata.format === "gif",
@@ -50,21 +52,30 @@ function hasCompleteGifStructure(bytes) {
   }
   return false;
 }
-async function verifyDecodedImage(contents, mimeType) {
+async function verifyDecodedImage(contents, mimeType, aspectRatios = []) {
+  const invalid = { valid: false, aspectRatios: [] };
   const matchesDecodedFormat = decodedFormatMatchers[mimeType];
-  if (!matchesDecodedFormat) return false;
-  if (mimeType === "image/gif" && !hasCompleteGifStructure(contents)) return false;
+  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: maximumDecodedPixels });
+    const image = decode(contents, { animated: true, failOn: "warning", limitInputPixels: imageDecodingLimits.maximumDecodedPixels });
     const metadata = await image.metadata();
-    if (!matchesDecodedFormat(metadata) || (metadata.pages ?? 1) > maximumFrames) return false;
+    if (!matchesDecodedFormat(metadata) || (metadata.pages ?? 1) > imageDecodingLimits.maximumFrames) return invalid;
     await image.stats();
-    return true;
+    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 false;
+    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;
@@ -429,17 +430,78 @@ type HoloRequestInput = RequestUrlParts & {
         readonly request?: RequestUrlParts;
     };
 };
-type HoloTrustedProxyHeaders = 'x-forwarded' | 'forwarded';
-declare function resolveTrustedProxyHeaders(): HoloTrustedProxyHeaders | null;
-declare function readForwardedParameter(headers: HoloRequestHeaders | undefined, name: string): string | undefined;
+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<{
-    readForwardedParameter: typeof readForwardedParameter;
-    resolveTrustedProxyHeaders: typeof resolveTrustedProxyHeaders;
+    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;
 }>;
 
-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 HoloRequestHeaders, type HoloRequestInput, HoloRequestUrlError, type HoloTrustedProxyHeaders, 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, requestUrlInternals, resolveHoloPluginModulePath, resolveNormalizedRedisConnection, resolveRequestUrl };
+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;
+
+type ResponseCookieOptions = {
+    path: string;
+    domain?: string;
+    maxAge?: number;
+    expires?: Date;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'lax' | 'strict' | 'none';
+    partitioned?: boolean;
+};
+type ParsedResponseCookie = {
+    readonly name: string;
+    readonly value: string;
+    readonly options: ResponseCookieOptions;
+};
+declare function parseResponseCookie(cookie: string): ParsedResponseCookie | null;
+declare const responseCookieInternals: {
+    parseResponseCookie: typeof parseResponseCookie;
+};
+
+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, responseCookieInternals, 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;
 }
@@ -428,11 +442,23 @@ function defineRedisConfig(config) {
 }
 
 // src/requestUrl.ts
-function resolveTrustedProxyHeaders() {
-  const value = typeof process === "undefined" ? void 0 : process.env.HOLO_SECURITY_TRUST_PROXY?.trim().toLowerCase();
-  if (value === "forwarded") return "forwarded";
-  if (value === "x-forwarded" || value === "1" || value === "true" || value === "yes" || value === "on") return "x-forwarded";
-  return null;
+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);
@@ -463,57 +489,6 @@ function readHeader(headers, name) {
   }
   return void 0;
 }
-function firstForwardedValue(value) {
-  return value?.split(",", 1)[0]?.trim().replace(/^"|"$/g, "");
-}
-function firstForwardedElement(value) {
-  const pairs = /* @__PURE__ */ new Map();
-  let key = "";
-  let current = "";
-  let readingValue = false;
-  let quoted = false;
-  let escaped = false;
-  const commit = () => {
-    const name = key.trim().toLowerCase();
-    if (readingValue && name && !pairs.has(name)) pairs.set(name, current.trim());
-    key = "";
-    current = "";
-    readingValue = false;
-  };
-  for (const character of value) {
-    if (escaped) {
-      current += character;
-      escaped = false;
-    } else if (quoted) {
-      if (character === "\\") escaped = true;
-      else if (character === '"') quoted = false;
-      else current += character;
-    } else if (character === ",") {
-      break;
-    } else if (character === ";") {
-      commit();
-    } else if (character === "=" && !readingValue) {
-      readingValue = true;
-    } else if (character === '"' && readingValue) {
-      quoted = true;
-    } else if (readingValue) {
-      current += character;
-    } else {
-      key += character;
-    }
-  }
-  commit();
-  return pairs;
-}
-function readForwardedParameter(headers, name) {
-  const forwarded = readHeader(headers, "forwarded");
-  return forwarded === void 0 ? void 0 : firstForwardedElement(forwarded).get(name);
-}
-function readTrustedProxyValue(headers, trustedProxyHeaders, name) {
-  if (trustedProxyHeaders === "forwarded") return readForwardedParameter(headers, name);
-  if (trustedProxyHeaders === "x-forwarded") return firstForwardedValue(readHeader(headers, `x-forwarded-${name}`));
-  return void 0;
-}
 var HoloRequestUrlError = class extends TypeError {
   status = 400;
   constructor(message) {
@@ -522,25 +497,47 @@ var HoloRequestUrlError = class extends TypeError {
   }
 };
 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 resolveRequestUrl(input) {
-  const nested = input instanceof Request ? void 0 : input.request ?? input.web?.request ?? input.req ?? input.node?.req;
-  const headers = input.headers ?? nested?.headers;
+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 trustedProxyHeaders = resolveTrustedProxyHeaders();
-  const protocol = (readTrustedProxyValue(headers, trustedProxyHeaders, "proto") ?? url.protocol.slice(0, -1)).toLowerCase();
+  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 = readTrustedProxyValue(headers, trustedProxyHeaders, "host") ?? readHeader(headers, "host") ?? url.host;
+  const host = forwarded?.host ?? readHeader(headers, "host") ?? url.host;
   if (!host || /[\s,/@\\?#]/u.test(host)) {
     throw new HoloRequestUrlError(invalidRequestHostMessage);
   }
@@ -548,22 +545,227 @@ function resolveRequestUrl(input) {
   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;
 }
-var requestUrlInternals = Object.freeze({ readForwardedParameter, resolveTrustedProxyHeaders });
+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;
+}
+
+// src/responseCookie.ts
+function safeDecodeCookieSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function parseResponseCookie(cookie) {
+  const [nameValue = "", ...attributes] = cookie.split(";");
+  const separator = nameValue.indexOf("=");
+  if (!nameValue || separator <= 0) {
+    return null;
+  }
+  const options = { path: "/", secure: false, httpOnly: false };
+  for (const rawAttribute of attributes) {
+    const attribute = rawAttribute.trim();
+    if (!attribute) {
+      continue;
+    }
+    const attributeSeparator = attribute.indexOf("=");
+    const key = (attributeSeparator === -1 ? attribute : attribute.slice(0, attributeSeparator)).trim().toLowerCase();
+    const value = attributeSeparator === -1 ? "" : attribute.slice(attributeSeparator + 1).trim();
+    switch (key) {
+      case "path":
+        options.path = value || "/";
+        break;
+      case "domain":
+        options.domain = value;
+        break;
+      case "max-age": {
+        const maxAge = Number(value);
+        if (Number.isFinite(maxAge)) {
+          options.maxAge = maxAge;
+        }
+        break;
+      }
+      case "expires": {
+        const expires = new Date(value);
+        if (!Number.isNaN(expires.getTime())) {
+          options.expires = expires;
+        }
+        break;
+      }
+      case "secure":
+        options.secure = true;
+        break;
+      case "httponly":
+        options.httpOnly = true;
+        break;
+      case "samesite":
+        if (value.toLowerCase() === "lax" || value.toLowerCase() === "strict" || value.toLowerCase() === "none") {
+          options.sameSite = value.toLowerCase();
+        }
+        break;
+      case "partitioned":
+        options.partitioned = value ? value.toLowerCase() === "true" : true;
+        break;
+    }
+  }
+  return {
+    name: safeDecodeCookieSegment(nameValue.slice(0, separator)),
+    value: safeDecodeCookieSegment(nameValue.slice(separator + 1)),
+    options
+  };
+}
+var responseCookieInternals = { parseResponseCookie };
 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,
@@ -574,12 +776,25 @@ export {
   loadHoloPluginBootModules,
   loadHoloPluginContributionModules,
   loadHoloPluginDefinitions,
+  localStoragePathInternals,
   normalizeHoloHttpError,
   normalizeHoloPluginDefinition,
   normalizeHoloProjectConfig,
   normalizeRedisConfig,
+  readBoundedBufferedBody,
+  readBoundedCachedBody,
+  readBoundedNodeRequestBody,
+  readBoundedRequestBody,
+  readBoundedRequestFormData,
+  readBoundedRequestJson,
+  readBoundedRequestText,
+  requestBodyInternals,
+  requestBodyLimitFor,
   requestUrlInternals,
   resolveHoloPluginModulePath,
   resolveNormalizedRedisConnection,
-  resolveRequestUrl
+  resolveRequestUrl,
+  resolveRetryBackoffSeconds,
+  responseCookieInternals,
+  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,45 @@
 {
   "name": "@holo-js/kernel",
-  "version": "0.3.28",
-  "description": "Holo-JS Framework - dependency-free contracts, plugins, and runtime lifecycle",
+  "version": "0.4.1",
+  "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",
@@ -30,7 +50,8 @@
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
   "scripts": {
     "build": "tsup",
@@ -38,25 +59,23 @@
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest --run"
   },
+  "dependencies": {
+    "file-type": "^22.2.0"
+  },
   "devDependencies": {
-    "@types/node": "^22.10.2",
-    "file-type": "^22.2.0",
-    "sharp": "^0.35.4",
-    "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": {
-    "file-type": "^22.2.0",
-    "sharp": "^0.35.4"
+    "sharp": "^0.35.5"
   },
   "peerDependenciesMeta": {
-    "file-type": {
-      "optional": true
-    },
     "sharp": {
       "optional": true
     }