@warlock.js/core 5.30.0 → 5.32.0

package/esm/storage/types.d.mts

@@ -1,13 +1,13 @@
 import { StorageFile } from "./storage-file.mjs";
 import { ScopedStorage } from "./scoped-storage.mjs";
 import { UploadedFile } from "../http/uploaded-file.mjs";
+import "../http/index.mjs";
 import { Readable } from "stream";
-
 //#region ../../packages/core/src/storage/types.d.ts
 /**
  * Options for local storage driver
  */
-type LocalStorageDriverOptions = {
+export type LocalStorageDriverOptions = {
   /**
    * Root path for storage
    * Defaults to storagePath() utility
@@ -43,7 +43,7 @@ type LocalStorageDriverOptions = {
 /**
  * Base options for all S3-compatible cloud storage drivers
  */
-type CloudStorageDriverOptions = {
+export type CloudStorageDriverOptions = {
   /**
    * Bucket name
    */
@@ -99,7 +99,7 @@ type CloudStorageDriverOptions = {
 /**
  * Options specific to Cloudflare R2 driver
  */
-type R2StorageDriverOptions = Omit<CloudStorageDriverOptions, "region"> & {
+export type R2StorageDriverOptions = Omit<CloudStorageDriverOptions, "region"> & {
   /**
    * Cloudflare account ID
    */
@@ -119,7 +119,7 @@ type R2StorageDriverOptions = Omit<CloudStorageDriverOptions, "region"> & {
 /**
  * Base storage file data returned from operations
  */
-type StorageFileData = {
+export type StorageFileData = {
   /**
    * File storage path (relative to storage root)
    */
@@ -148,7 +148,7 @@ type StorageFileData = {
 /**
  * Extended storage file data with cloud-specific metadata
  */
-type CloudStorageFileData = StorageFileData & {
+export type CloudStorageFileData = StorageFileData & {
   /**
    * Cloud storage bucket name
    */
@@ -189,7 +189,7 @@ type CloudStorageFileData = StorageFileData & {
 /**
  * Storage file info for list and metadata operations
  */
-type StorageFileInfo = {
+export type StorageFileInfo = {
   /**
    * File storage path (relative to storage root)
    */
@@ -230,7 +230,7 @@ type StorageFileInfo = {
 /**
  * Options for list operations
  */
-type ListOptions = {
+export type ListOptions = {
   /**
    * Whether to list files recursively
    */
@@ -251,7 +251,7 @@ type ListOptions = {
 /**
  * Options for putDirectory operations
  */
-type PutDirectoryOptions = {
+export type PutDirectoryOptions = {
   /**
    * Max concurrent uploads
    * @default 5
@@ -284,7 +284,7 @@ type PutDirectoryOptions = {
 /**
  * Result of a putDirectory operation
  */
-type PutDirectoryResult = {
+export type PutDirectoryResult = {
   /**
    * Successfully uploaded files
    */
@@ -304,7 +304,7 @@ type PutDirectoryResult = {
 /**
  * Options for presigned URLs
  */
-type PresignedOptions = {
+export type PresignedOptions = {
   /**
    * Expiration time in seconds
    */
@@ -321,7 +321,7 @@ type PresignedOptions = {
  * removed rather than left as a no-op. Enforce size limits server-side (e.g.
  * verify `metadata().size` after upload) or migrate to presigned POST.
  */
-type PresignedUploadOptions = PresignedOptions & {
+export type PresignedUploadOptions = PresignedOptions & {
   /**
    * File content type
    */
@@ -339,7 +339,7 @@ type PresignedUploadOptions = PresignedOptions & {
  * (guards-ON) behaviour: https+http only, private/loopback/metadata hosts
  * denied, a byte cap, and a timeout.
  */
-type PutFromUrlOptions = PutOptions & {
+export type PutFromUrlOptions = PutOptions & {
   /**
    * Allow private / loopback / link-local / cloud-metadata hosts. Default
    * `false` — the SSRF guard is ON.
@@ -348,7 +348,8 @@ type PutFromUrlOptions = PutOptions & {
   /**
    * Maximum downloaded body size in bytes. Default `52_428_800` (50 MiB).
    */
-  maxBytes?: number; /** Per-request timeout in milliseconds. Default `30_000`. */
+  maxBytes?: number;
+  /** Per-request timeout in milliseconds. Default `30_000`. */
   timeoutMs?: number;
   /**
    * URL schemes permitted for the download. Default `["https", "http"]`.
@@ -358,7 +359,7 @@ type PutFromUrlOptions = PutOptions & {
 /**
  * Options for put operations
  */
-type PutOptions = {
+export type PutOptions = {
   /**
    * Explicit MIME type for the file
    * If not provided, will be guessed from file extension
@@ -384,7 +385,7 @@ type PutOptions = {
 /**
  * Payload encoded in temporary URL tokens
  */
-type TemporaryTokenPayload = {
+export type TemporaryTokenPayload = {
   /**
    * Relative file path
    */
@@ -401,11 +402,11 @@ type TemporaryTokenPayload = {
 /**
  * Validation error types
  */
-type TemporaryTokenError = "expired" | "invalid_signature" | "invalid_token" | "missing_key" | "file_not_found";
+export type TemporaryTokenError = "expired" | "invalid_signature" | "invalid_token" | "missing_key" | "file_not_found";
 /**
  * Result of validating a temporary URL token
  */
-type TemporaryTokenValidation = {
+export type TemporaryTokenValidation = {
   /**
    * Whether the token is valid
    */
@@ -446,15 +447,15 @@ type TemporaryTokenValidation = {
 /**
  * File visibility options
  */
-type FileVisibility = "public" | "private";
+export type FileVisibility = "public" | "private";
 /**
  * Storage event types
  */
-type StorageEventType = "beforePut" | "afterPut" | "beforeDelete" | "afterDelete" | "beforeCopy" | "afterCopy" | "beforeMove" | "afterMove";
+export type StorageEventType = "beforePut" | "afterPut" | "beforeDelete" | "afterDelete" | "beforeCopy" | "afterCopy" | "beforeMove" | "afterMove";
 /**
  * Storage event payload base
  */
-type StorageEventPayload = {
+export type StorageEventPayload = {
   /**
    * Storage driver name
    */
@@ -471,7 +472,7 @@ type StorageEventPayload = {
 /**
  * Put event payload
  */
-type StoragePutEventPayload = StorageEventPayload & {
+export type StoragePutEventPayload = StorageEventPayload & {
   /**
    * Storage file data
    */
@@ -488,7 +489,7 @@ type StoragePutEventPayload = StorageEventPayload & {
 /**
  * Copy/Move event payload
  */
-type StorageCopyEventPayload = StorageEventPayload & {
+export type StorageCopyEventPayload = StorageEventPayload & {
   /**
    * Source file storage path
    */
@@ -505,11 +506,11 @@ type StorageCopyEventPayload = StorageEventPayload & {
 /**
  * Storage event handler type
  */
-type StorageEventHandler<T extends StorageEventPayload = StorageEventPayload> = (payload: T) => void | Promise<void>;
+export type StorageEventHandler<T extends StorageEventPayload = StorageEventPayload> = (payload: T) => void | Promise<void>;
 /**
  * Result of a batch delete operation
  */
-type DeleteManyResult = {
+export type DeleteManyResult = {
   /**
    * File storage path (relative to storage root)
    */
@@ -523,12 +524,12 @@ type DeleteManyResult = {
    */
   error?: string;
 };
-type StorageDriverType = "local" | "s3" | "r2" | "spaces";
+export type StorageDriverType = "local" | "s3" | "r2" | "spaces";
 /**
  * Storage driver configuration
  * Used in configuration files
  */
-type StorageDriverConfig = {
+export type StorageDriverConfig = {
   /**
    * Driver type
    */
@@ -598,7 +599,7 @@ type StorageDriverConfig = {
  * }
  * ```
  */
-interface StorageDriverRegistry {}
+export interface StorageDriverRegistry {}
 /**
  * Storage driver name type.
  *
@@ -606,11 +607,11 @@ interface StorageDriverRegistry {}
  * Falls back to `string` if no drivers are registered.
  * Autocomplete provided by generated `.warlock/typings/storage.d.ts`
  */
-type StorageDriverName = keyof StorageDriverRegistry extends never ? string : keyof StorageDriverRegistry;
+export type StorageDriverName = keyof StorageDriverRegistry extends never ? string : keyof StorageDriverRegistry;
 /**
  * Storage configurations
  */
-type StorageConfigurations = {
+export type StorageConfigurations = {
   /**
    * Default driver name
    */
@@ -631,7 +632,7 @@ type StorageConfigurations = {
  * Drivers return raw data objects (`StorageFileData`), while the
  * `ScopedStorage` and `Storage` classes wrap these in `StorageFile` instances.
  */
-interface StorageDriverContract {
+export interface StorageDriverContract {
   /**
    * Driver name identifier (e.g., "local", "s3", "r2", "spaces")
    */
@@ -793,7 +794,7 @@ interface StorageDriverContract {
  * Extends the base contract with cloud-specific functionality
  * like presigned URLs, visibility control, and storage classes.
  */
-interface CloudStorageDriverContract extends StorageDriverContract {
+export interface CloudStorageDriverContract extends StorageDriverContract {
   /**
    * Store a file (returns cloud-specific data)
    */
@@ -864,7 +865,7 @@ interface CloudStorageDriverContract extends StorageDriverContract {
  *
  * This provides the developer-facing API with rich file objects.
  */
-interface ScopedStorageContract {
+export interface ScopedStorageContract {
   /**
    * Driver name identifier
    */
@@ -977,7 +978,7 @@ interface ScopedStorageContract {
  *
  * This is the contract implemented by the `Storage` class.
  */
-interface StorageManagerContract extends ScopedStorageContract {
+export interface StorageManagerContract extends ScopedStorageContract {
   /**
    * Get a scoped storage for a specific driver
    *
@@ -1038,12 +1039,11 @@ interface StorageManagerContract extends ScopedStorageContract {
 /**
  * Event subscription returned by event handlers
  */
-interface EventSubscription {
+export interface EventSubscription {
   /**
    * Unsubscribe from the event
    */
   unsubscribe(): void;
 }
 //#endregion
-export { CloudStorageDriverContract, CloudStorageDriverOptions, CloudStorageFileData, DeleteManyResult, EventSubscription, FileVisibility, ListOptions, LocalStorageDriverOptions, PresignedOptions, PresignedUploadOptions, PutDirectoryOptions, PutDirectoryResult, PutFromUrlOptions, PutOptions, R2StorageDriverOptions, ScopedStorageContract, StorageConfigurations, StorageCopyEventPayload, StorageDriverConfig, StorageDriverContract, StorageDriverName, StorageDriverRegistry, StorageDriverType, StorageEventHandler, StorageEventPayload, StorageEventType, StorageFileData, StorageFileInfo, StorageManagerContract, StoragePutEventPayload, TemporaryTokenError, TemporaryTokenPayload, TemporaryTokenValidation };
 //# sourceMappingURL=types.d.mts.map

package/esm/storage/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/storage/types.ts"],"mappings":"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"}
+{"version":3,"file":"types.d.mts","names":["_$__storage_file0.StorageFile"],"sources":["../../../../../../../../packages/core/src/storage/types.ts"],"mappings":"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"}

package/esm/storage/utils/classify-ip-address.d.mts

@@ -7,7 +7,6 @@
  * by the IPv4 it carries. A non-IP string returns `false` (the caller
  * resolves hostnames via DNS first).
  */
-declare function isPrivateOrReservedIp(ip: string): boolean;
+export declare function isPrivateOrReservedIp(ip: string): boolean;
 //#endregion
-export { isPrivateOrReservedIp };
 //# sourceMappingURL=classify-ip-address.d.mts.map

package/esm/storage/utils/classify-ip-address.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"classify-ip-address.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/classify-ip-address.ts"],"mappings":";;AAwKA;;;;AAAgD;;;iBAAhC,qBAAA,CAAsB,EAAU"}
+{"version":3,"file":"classify-ip-address.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/classify-ip-address.ts"],"mappings":";;;;;;;;;wBAwKgB,sBAAsB"}

package/esm/storage/utils/contain-path.d.mts

@@ -17,7 +17,6 @@
  * @returns The absolute, contained filesystem path.
  * @throws {StorageError} When the location escapes `root`.
  */
-declare function resolveWithinRoot(root: string, location: string): string;
+export declare function resolveWithinRoot(root: string, location: string): string;
 //#endregion
-export { resolveWithinRoot };
 //# sourceMappingURL=contain-path.d.mts.map

package/esm/storage/utils/contain-path.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"contain-path.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/contain-path.ts"],"mappings":";;AAqBA;;;;AAAgE;;;;;;;;;;;;;iBAAhD,iBAAA,CAAkB,IAAA,UAAc,QAAgB"}
+{"version":3,"file":"contain-path.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/contain-path.ts"],"mappings":";;;;;;;;;;;;;;;;;;;wBAqBgB,kBAAkB,cAAc"}

package/esm/storage/utils/mime.d.mts

@@ -5,11 +5,11 @@
  * @param path - File path or extension
  * @returns MIME type or "application/octet-stream" if unknown
  */
-declare function getMimeType(path: string): string;
+export declare function getMimeType(path: string): string;
 /**
  * Common MIME type constants
  */
-declare const MimeTypes: {
+export declare const MimeTypes: {
   readonly jpeg: "image/jpeg";
   readonly png: "image/png";
   readonly gif: "image/gif";
@@ -32,5 +32,4 @@ declare const MimeTypes: {
   readonly binary: "application/octet-stream";
 };
 //#endregion
-export { MimeTypes, getMimeType };
 //# sourceMappingURL=mime.d.mts.map

package/esm/storage/utils/mime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"mime.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/mime.ts"],"mappings":";;AAcA;;;;AAAwC;iBAAxB,WAAA,CAAY,IAAY;;;;cAO3B,SAAA;EAAA"}
+{"version":3,"file":"mime.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/mime.ts"],"mappings":";;;;;;;wBAcgB,YAAY;;;;qBAOf;WAEX;WACA;WACA;WACA;WACA;WACA;WAGA;WACA;WACA;WACA;WACA;WACA;WACA;WAGA;WACA;WAGA;WACA;WACA;WACA;WAGA"}

package/esm/storage/utils/safe-fetch.d.mts

@@ -1,5 +1,4 @@
 import { isPrivateOrReservedIp } from "./classify-ip-address.mjs";
-
 //#region ../../packages/core/src/storage/utils/safe-fetch.d.ts
 /**
  * Options controlling a guarded outbound fetch. Every field is optional;
@@ -8,7 +7,7 @@ import { isPrivateOrReservedIp } from "./classify-ip-address.mjs";
  * 50 MiB cap) so a caller that does not tune them still gets a hardened
  * request.
  */
-type SafeFetchOptions = {
+export type SafeFetchOptions = {
   /**
    * Whether to ALLOW private / loopback / link-local / metadata hosts.
    * Default `false` — the SSRF guard is on (private hosts are denied).
@@ -19,7 +18,8 @@ type SafeFetchOptions = {
    * this fails fast; otherwise the body is read with a running cap and the
    * stream is aborted on overflow. Default `52_428_800` (50 MiB).
    */
-  maxBytes?: number; /** Per-request timeout in milliseconds. Default `30_000`. */
+  maxBytes?: number;
+  /** Per-request timeout in milliseconds. Default `30_000`. */
   timeoutMs?: number;
   /**
    * URL schemes permitted for the request, compared case-insensitively.
@@ -37,7 +37,7 @@ type SafeFetchOptions = {
  * content-type, so callers can derive a MIME type and enforce a non-empty
  * content-type check.
  */
-type SafeFetchResult = {
+export type SafeFetchResult = {
   buffer: Buffer;
   contentType: string | null;
   status: number;
@@ -63,7 +63,7 @@ type SafeFetchResult = {
  * @throws {StorageError} On a blocked URL (initial or redirect target),
  * a redirect-hop bound overflow, timeout, or oversized body.
  */
-declare function safeFetchToBuffer(rawUrl: string, options?: SafeFetchOptions): Promise<SafeFetchResult>;
+export declare function safeFetchToBuffer(rawUrl: string, options?: SafeFetchOptions): Promise<SafeFetchResult>;
 //#endregion
-export { SafeFetchOptions, SafeFetchResult, safeFetchToBuffer };
+export { isPrivateOrReservedIp };
 //# sourceMappingURL=safe-fetch.d.mts.map

package/esm/storage/utils/safe-fetch.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"safe-fetch.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/safe-fetch.ts"],"mappings":";;;;;AAoCA;;;;;KAAY,gBAAA;EAaV;;;;EARA,iBAAA;EAkBoB;AA2GtB;;;;EAvHE,QAAA,WAwHQ;EAtHR,SAAA;EAwHA;;;;EAnHA,cAAA;EA2IoB;;;;EAtIpB,KAAA,UAAe,KAAK;AAAA;;;;;;KA2GV,eAAA;EACV,MAAA,EAAQ,MAAM;EACd,WAAA;EACA,MAAA;EACA,UAAA;EACA,EAAA;AAAA;;;;;;;;;;;;;;;;;;;;iBAsBoB,iBAAA,CACpB,MAAA,UACA,OAAA,GAAS,gBAAA,GACR,OAAA,CAAQ,eAAA"}
+{"version":3,"file":"safe-fetch.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/safe-fetch.ts"],"mappings":";;;;;;;;;YAoCY;;;;;EAKV;;;;;;EAMA;;EAEA;;;;;EAKA;;;;;EAKA,eAAe;;;;;;;YA2GL;EACV,QAAQ;EACR;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;wBAsBoB,kBACpB,gBACA,UAAS,mBACR,QAAQ"}

package/esm/storage/utils/safe-fetch.mjs

@@ -14,7 +14,7 @@ import { isIP } from "node:net";
 * extraction of a shared security package, keep the two copies in sync.
 */
 /** 50 MiB — default cap on a downloaded body (storage files run larger than AI payloads). */
-const DEFAULT_MAX_BYTES = 50 * 1024 * 1024;
+const DEFAULT_MAX_BYTES = 52428800;
 /** 30s — default per-request timeout. */
 const DEFAULT_TIMEOUT_MS = 3e4;
 /**
@@ -24,7 +24,7 @@ const DEFAULT_TIMEOUT_MS = 3e4;
 */
 const DEFAULT_MAX_REDIRECTS = 5;
 /** 3xx statuses whose `Location` a follow re-issues — mirrors ai/src/security/outbound-policy.ts:18. */
-const REDIRECT_STATUSES = new Set([
+const REDIRECT_STATUSES = /* @__PURE__ */ new Set([
 	301,
 	302,
 	303,
@@ -208,5 +208,5 @@ async function readBodyCapped(response, maxBytes, rawUrl) {
 }
 
 //#endregion
-export { safeFetchToBuffer };
+export { isPrivateOrReservedIp, safeFetchToBuffer };
 //# sourceMappingURL=safe-fetch.mjs.map

package/esm/storage/utils/safe-fetch.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"safe-fetch.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/safe-fetch.ts"],"sourcesContent":["import { lookup } from \"node:dns/promises\";\nimport { isIP } from \"node:net\";\nimport { isPrivateOrReservedIp } from \"./classify-ip-address\";\nimport { StorageError } from \"./storage-error\";\n\n/**\n * SSRF / resource-exhaustion guard for storage's outbound downloads\n * (`putFromUrl`).\n *\n * NOTE: this MIRRORS `@warlock.js/ai`'s `src/security/private-ip.ts` and\n * `src/security/outbound-policy.ts`. It is duplicated here intentionally\n * because `@warlock.js/core` cannot depend on `@warlock.js/ai`. Pending\n * extraction of a shared security package, keep the two copies in sync.\n */\n\n/** 50 MiB — default cap on a downloaded body (storage files run larger than AI payloads). */\nconst DEFAULT_MAX_BYTES = 50 * 1024 * 1024;\n/** 30s — default per-request timeout. */\nconst DEFAULT_TIMEOUT_MS = 30_000;\n/**\n * Cap on the number of re-validated redirect hops. Mirrors\n * `@warlock.js/ai`'s `DEFAULT_MAX_REDIRECTS`\n * (ai/src/security/outbound-policy.ts:15).\n */\nconst DEFAULT_MAX_REDIRECTS = 5;\n\n/** 3xx statuses whose `Location` a follow re-issues — mirrors ai/src/security/outbound-policy.ts:18. */\nconst REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);\n\n/**\n * Options controlling a guarded outbound fetch. Every field is optional;\n * {@link resolveFetchPolicy} fills safe defaults. The defaults are\n * deliberately strict (https+http, private-IP deny ON, 30s timeout,\n * 50 MiB cap) so a caller that does not tune them still gets a hardened\n * request.\n */\nexport type SafeFetchOptions = {\n  /**\n   * Whether to ALLOW private / loopback / link-local / metadata hosts.\n   * Default `false` — the SSRF guard is on (private hosts are denied).\n   */\n  allowPrivateHosts?: boolean;\n  /**\n   * Maximum response body size in bytes. A declared `content-length` over\n   * this fails fast; otherwise the body is read with a running cap and the\n   * stream is aborted on overflow. Default `52_428_800` (50 MiB).\n   */\n  maxBytes?: number;\n  /** Per-request timeout in milliseconds. Default `30_000`. */\n  timeoutMs?: number;\n  /**\n   * URL schemes permitted for the request, compared case-insensitively.\n   * Default `[\"https\", \"http\"]`.\n   */\n  allowedSchemes?: string[];\n  /**\n   * Injected `fetch` implementation (for tests or proxies). Defaults to the\n   * global `fetch`.\n   */\n  fetch?: typeof fetch;\n};\n\n/** {@link SafeFetchOptions} with every default resolved — never partial. */\ntype ResolvedFetchPolicy = {\n  allowPrivateHosts: boolean;\n  maxBytes: number;\n  timeoutMs: number;\n  allowedSchemes: string[];\n  fetch: typeof fetch;\n};\n\n/**\n * Fill a {@link SafeFetchOptions} with strict defaults: https+http,\n * private-IP deny on, 30s timeout, 50 MiB cap, global `fetch`.\n */\nfunction resolveFetchPolicy(options: SafeFetchOptions = {}): ResolvedFetchPolicy {\n  return {\n    allowPrivateHosts: options.allowPrivateHosts ?? false,\n    maxBytes: options.maxBytes ?? DEFAULT_MAX_BYTES,\n    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n    allowedSchemes: options.allowedSchemes ?? [\"https\", \"http\"],\n    fetch: options.fetch ?? globalThis.fetch,\n  };\n}\n\nexport { isPrivateOrReservedIp };\n\n/** Strip the `[ ]` IPv6 brackets `URL.hostname` keeps. */\nfunction stripBrackets(host: string): string {\n  return host.startsWith(\"[\") && host.endsWith(\"]\") ? host.slice(1, -1) : host;\n}\n\n/**\n * Reject when `host` is — or resolves to — a private / reserved address.\n * IP literals are checked directly; hostnames are resolved via DNS and every\n * returned address is checked (a public name pointing inward is caught). A\n * resolution failure fails closed.\n */\nasync function assertHostNotPrivate(host: string, rawUrl: string): Promise<void> {\n  if (isIP(host) !== 0) {\n    if (isPrivateOrReservedIp(host)) {\n      throw new StorageError(`outbound request blocked — \"${host}\" is a private/reserved address`, {\n        context: { url: rawUrl, address: host },\n      });\n    }\n    return;\n  }\n\n  let addresses: Array<{ address: string }>;\n  try {\n    addresses = await lookup(host, { all: true });\n  } catch (cause) {\n    throw new StorageError(\n      `outbound request blocked — could not resolve host \"${host}\" to verify it is public`,\n      { cause, context: { url: rawUrl, host } },\n    );\n  }\n\n  for (const { address } of addresses) {\n    if (isPrivateOrReservedIp(address)) {\n      throw new StorageError(\n        `outbound request blocked — host \"${host}\" resolves to a private/reserved address (${address})`,\n        { context: { url: rawUrl, host, address } },\n      );\n    }\n  }\n}\n\n/**\n * Validate a URL against the policy BEFORE any network call: scheme\n * allowlist and (when private hosts are not allowed) a DNS resolution that\n * rejects private / loopback / link-local / metadata addresses — the SSRF\n * guard. Returns the parsed `URL` on success; throws {@link StorageError}\n * otherwise.\n */\nasync function assertUrlAllowed(rawUrl: string, policy: ResolvedFetchPolicy): Promise<URL> {\n  let url: URL;\n  try {\n    url = new URL(rawUrl);\n  } catch {\n    throw new StorageError(`outbound request blocked — invalid URL: ${rawUrl}`, {\n      context: { url: rawUrl },\n    });\n  }\n\n  const scheme = url.protocol.replace(/:$/, \"\").toLowerCase();\n  if (!policy.allowedSchemes.some((s) => s.toLowerCase() === scheme)) {\n    throw new StorageError(\n      `outbound request blocked — scheme \"${scheme}\" is not allowed (allowed: ${policy.allowedSchemes.join(\", \")})`,\n      { context: { url: rawUrl, scheme } },\n    );\n  }\n\n  if (!policy.allowPrivateHosts) {\n    const host = stripBrackets(url.hostname);\n    await assertHostNotPrivate(host, rawUrl);\n  }\n\n  return url;\n}\n\n/**\n * Result of {@link safeFetchToBuffer}: the (capped) body plus the response's\n * content-type, so callers can derive a MIME type and enforce a non-empty\n * content-type check.\n */\nexport type SafeFetchResult = {\n  buffer: Buffer;\n  contentType: string | null;\n  status: number;\n  statusText: string;\n  ok: boolean;\n};\n\n/**\n * SSRF-guarded download: validates the URL (scheme allowlist + post-DNS\n * private-IP deny), performs the request with a timeout via\n * `AbortController`, then streams the body with a hard byte cap — aborting\n * the moment the running total exceeds `maxBytes`. A declared\n * `content-length` over the cap fails fast.\n *\n * Redirects are NEVER delegated to the platform: every hop is issued with\n * `redirect: \"manual\"` and its `Location` is re-run through\n * {@link assertUrlAllowed} — including the DNS-resolution private-IP check\n * — before being followed (capped at {@link DEFAULT_MAX_REDIRECTS}), so a\n * 3xx from an allowed host cannot smuggle the request to a private /\n * metadata target. Mirrors `@warlock.js/ai`'s `guardedFetch`\n * (ai/src/security/outbound-policy.ts:188-284); duplicated per this\n * module's file-header note since core cannot depend on ai.\n *\n * @throws {StorageError} On a blocked URL (initial or redirect target),\n * a redirect-hop bound overflow, timeout, or oversized body.\n */\nexport async function safeFetchToBuffer(\n  rawUrl: string,\n  options: SafeFetchOptions = {},\n): Promise<SafeFetchResult> {\n  const policy = resolveFetchPolicy(options);\n  let url = await assertUrlAllowed(rawUrl, policy);\n\n  const controller = new AbortController();\n  const timer = setTimeout(() => {\n    controller.abort(\n      new StorageError(`outbound request timed out after ${policy.timeoutMs}ms`, {\n        context: { url: rawUrl, timeoutMs: policy.timeoutMs },\n      }),\n    );\n  }, policy.timeoutMs);\n\n  try {\n    let response: Response;\n\n    for (let hop = 0; ; hop++) {\n      response = await policy.fetch(url, { signal: controller.signal, redirect: \"manual\" });\n\n      const location = response.headers.get(\"location\");\n      if (!REDIRECT_STATUSES.has(response.status) || location === null) {\n        break;\n      }\n\n      if (hop >= DEFAULT_MAX_REDIRECTS) {\n        throw new StorageError(\n          `outbound request blocked — more than ${DEFAULT_MAX_REDIRECTS} redirects`,\n          { context: { url: rawUrl, maxRedirects: DEFAULT_MAX_REDIRECTS } },\n        );\n      }\n\n      let target: URL;\n      try {\n        target = new URL(location, url);\n      } catch {\n        throw new StorageError(\n          `outbound request blocked — invalid redirect Location: ${location}`,\n          {\n            context: { url: url.toString(), location },\n          },\n        );\n      }\n\n      // Discard the interim body so the connection can be reused.\n      if (response.body) {\n        await response.body.cancel().catch(() => undefined);\n      }\n\n      // The redirect target gets the SAME scheme + private-IP validation\n      // (incl. DNS resolution) as the initial URL — this is what closes\n      // the redirect-based SSRF bypass: a 302 from an allowed host to\n      // 169.254.169.254 is re-validated here, not blindly followed.\n      url = await assertUrlAllowed(target.toString(), policy);\n    }\n\n    const declared = Number(response.headers.get(\"content-length\"));\n    if (Number.isFinite(declared) && declared > policy.maxBytes) {\n      throw new StorageError(\n        `outbound response body too large — declared ${declared} bytes exceeds the ${policy.maxBytes}-byte cap`,\n        { context: { url: rawUrl, declared, maxBytes: policy.maxBytes } },\n      );\n    }\n\n    const buffer = await readBodyCapped(response, policy.maxBytes, rawUrl);\n\n    return {\n      buffer,\n      contentType: response.headers.get(\"content-type\"),\n      status: response.status,\n      statusText: response.statusText,\n      ok: response.ok,\n    };\n  } finally {\n    clearTimeout(timer);\n  }\n}\n\n/**\n * Read a response body into a Buffer with a hard byte cap. The stream is\n * read chunk-by-chunk and cancelled the moment the running total exceeds\n * `maxBytes`. Throws {@link StorageError} on overflow.\n */\nasync function readBodyCapped(\n  response: Response,\n  maxBytes: number,\n  rawUrl: string,\n): Promise<Buffer> {\n  if (!response.body) {\n    const arrayBuffer = await response.arrayBuffer();\n    if (arrayBuffer.byteLength > maxBytes) {\n      throw new StorageError(`outbound response body exceeded the ${maxBytes}-byte cap`, {\n        context: { url: rawUrl, maxBytes },\n      });\n    }\n    return Buffer.from(arrayBuffer);\n  }\n\n  const reader = response.body.getReader();\n  const chunks: Uint8Array[] = [];\n  let total = 0;\n\n  for (;;) {\n    const { done, value } = await reader.read();\n    if (done) {\n      break;\n    }\n    if (!value) {\n      continue;\n    }\n\n    total += value.byteLength;\n    if (total > maxBytes) {\n      await reader.cancel();\n      throw new StorageError(`outbound response body exceeded the ${maxBytes}-byte cap`, {\n        context: { url: rawUrl, maxBytes },\n      });\n    }\n    chunks.push(value);\n  }\n\n  return Buffer.concat(chunks);\n}\n"],"mappings":"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"}
+{"version":3,"file":"safe-fetch.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/safe-fetch.ts"],"sourcesContent":["import { lookup } from \"node:dns/promises\";\nimport { isIP } from \"node:net\";\nimport { isPrivateOrReservedIp } from \"./classify-ip-address\";\nimport { StorageError } from \"./storage-error\";\n\n/**\n * SSRF / resource-exhaustion guard for storage's outbound downloads\n * (`putFromUrl`).\n *\n * NOTE: this MIRRORS `@warlock.js/ai`'s `src/security/private-ip.ts` and\n * `src/security/outbound-policy.ts`. It is duplicated here intentionally\n * because `@warlock.js/core` cannot depend on `@warlock.js/ai`. Pending\n * extraction of a shared security package, keep the two copies in sync.\n */\n\n/** 50 MiB — default cap on a downloaded body (storage files run larger than AI payloads). */\nconst DEFAULT_MAX_BYTES = 50 * 1024 * 1024;\n/** 30s — default per-request timeout. */\nconst DEFAULT_TIMEOUT_MS = 30_000;\n/**\n * Cap on the number of re-validated redirect hops. Mirrors\n * `@warlock.js/ai`'s `DEFAULT_MAX_REDIRECTS`\n * (ai/src/security/outbound-policy.ts:15).\n */\nconst DEFAULT_MAX_REDIRECTS = 5;\n\n/** 3xx statuses whose `Location` a follow re-issues — mirrors ai/src/security/outbound-policy.ts:18. */\nconst REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);\n\n/**\n * Options controlling a guarded outbound fetch. Every field is optional;\n * {@link resolveFetchPolicy} fills safe defaults. The defaults are\n * deliberately strict (https+http, private-IP deny ON, 30s timeout,\n * 50 MiB cap) so a caller that does not tune them still gets a hardened\n * request.\n */\nexport type SafeFetchOptions = {\n  /**\n   * Whether to ALLOW private / loopback / link-local / metadata hosts.\n   * Default `false` — the SSRF guard is on (private hosts are denied).\n   */\n  allowPrivateHosts?: boolean;\n  /**\n   * Maximum response body size in bytes. A declared `content-length` over\n   * this fails fast; otherwise the body is read with a running cap and the\n   * stream is aborted on overflow. Default `52_428_800` (50 MiB).\n   */\n  maxBytes?: number;\n  /** Per-request timeout in milliseconds. Default `30_000`. */\n  timeoutMs?: number;\n  /**\n   * URL schemes permitted for the request, compared case-insensitively.\n   * Default `[\"https\", \"http\"]`.\n   */\n  allowedSchemes?: string[];\n  /**\n   * Injected `fetch` implementation (for tests or proxies). Defaults to the\n   * global `fetch`.\n   */\n  fetch?: typeof fetch;\n};\n\n/** {@link SafeFetchOptions} with every default resolved — never partial. */\ntype ResolvedFetchPolicy = {\n  allowPrivateHosts: boolean;\n  maxBytes: number;\n  timeoutMs: number;\n  allowedSchemes: string[];\n  fetch: typeof fetch;\n};\n\n/**\n * Fill a {@link SafeFetchOptions} with strict defaults: https+http,\n * private-IP deny on, 30s timeout, 50 MiB cap, global `fetch`.\n */\nfunction resolveFetchPolicy(options: SafeFetchOptions = {}): ResolvedFetchPolicy {\n  return {\n    allowPrivateHosts: options.allowPrivateHosts ?? false,\n    maxBytes: options.maxBytes ?? DEFAULT_MAX_BYTES,\n    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n    allowedSchemes: options.allowedSchemes ?? [\"https\", \"http\"],\n    fetch: options.fetch ?? globalThis.fetch,\n  };\n}\n\nexport { isPrivateOrReservedIp };\n\n/** Strip the `[ ]` IPv6 brackets `URL.hostname` keeps. */\nfunction stripBrackets(host: string): string {\n  return host.startsWith(\"[\") && host.endsWith(\"]\") ? host.slice(1, -1) : host;\n}\n\n/**\n * Reject when `host` is — or resolves to — a private / reserved address.\n * IP literals are checked directly; hostnames are resolved via DNS and every\n * returned address is checked (a public name pointing inward is caught). A\n * resolution failure fails closed.\n */\nasync function assertHostNotPrivate(host: string, rawUrl: string): Promise<void> {\n  if (isIP(host) !== 0) {\n    if (isPrivateOrReservedIp(host)) {\n      throw new StorageError(`outbound request blocked — \"${host}\" is a private/reserved address`, {\n        context: { url: rawUrl, address: host },\n      });\n    }\n    return;\n  }\n\n  let addresses: Array<{ address: string }>;\n  try {\n    addresses = await lookup(host, { all: true });\n  } catch (cause) {\n    throw new StorageError(\n      `outbound request blocked — could not resolve host \"${host}\" to verify it is public`,\n      { cause, context: { url: rawUrl, host } },\n    );\n  }\n\n  for (const { address } of addresses) {\n    if (isPrivateOrReservedIp(address)) {\n      throw new StorageError(\n        `outbound request blocked — host \"${host}\" resolves to a private/reserved address (${address})`,\n        { context: { url: rawUrl, host, address } },\n      );\n    }\n  }\n}\n\n/**\n * Validate a URL against the policy BEFORE any network call: scheme\n * allowlist and (when private hosts are not allowed) a DNS resolution that\n * rejects private / loopback / link-local / metadata addresses — the SSRF\n * guard. Returns the parsed `URL` on success; throws {@link StorageError}\n * otherwise.\n */\nasync function assertUrlAllowed(rawUrl: string, policy: ResolvedFetchPolicy): Promise<URL> {\n  let url: URL;\n  try {\n    url = new URL(rawUrl);\n  } catch {\n    throw new StorageError(`outbound request blocked — invalid URL: ${rawUrl}`, {\n      context: { url: rawUrl },\n    });\n  }\n\n  const scheme = url.protocol.replace(/:$/, \"\").toLowerCase();\n  if (!policy.allowedSchemes.some((s) => s.toLowerCase() === scheme)) {\n    throw new StorageError(\n      `outbound request blocked — scheme \"${scheme}\" is not allowed (allowed: ${policy.allowedSchemes.join(\", \")})`,\n      { context: { url: rawUrl, scheme } },\n    );\n  }\n\n  if (!policy.allowPrivateHosts) {\n    const host = stripBrackets(url.hostname);\n    await assertHostNotPrivate(host, rawUrl);\n  }\n\n  return url;\n}\n\n/**\n * Result of {@link safeFetchToBuffer}: the (capped) body plus the response's\n * content-type, so callers can derive a MIME type and enforce a non-empty\n * content-type check.\n */\nexport type SafeFetchResult = {\n  buffer: Buffer;\n  contentType: string | null;\n  status: number;\n  statusText: string;\n  ok: boolean;\n};\n\n/**\n * SSRF-guarded download: validates the URL (scheme allowlist + post-DNS\n * private-IP deny), performs the request with a timeout via\n * `AbortController`, then streams the body with a hard byte cap — aborting\n * the moment the running total exceeds `maxBytes`. A declared\n * `content-length` over the cap fails fast.\n *\n * Redirects are NEVER delegated to the platform: every hop is issued with\n * `redirect: \"manual\"` and its `Location` is re-run through\n * {@link assertUrlAllowed} — including the DNS-resolution private-IP check\n * — before being followed (capped at {@link DEFAULT_MAX_REDIRECTS}), so a\n * 3xx from an allowed host cannot smuggle the request to a private /\n * metadata target. Mirrors `@warlock.js/ai`'s `guardedFetch`\n * (ai/src/security/outbound-policy.ts:188-284); duplicated per this\n * module's file-header note since core cannot depend on ai.\n *\n * @throws {StorageError} On a blocked URL (initial or redirect target),\n * a redirect-hop bound overflow, timeout, or oversized body.\n */\nexport async function safeFetchToBuffer(\n  rawUrl: string,\n  options: SafeFetchOptions = {},\n): Promise<SafeFetchResult> {\n  const policy = resolveFetchPolicy(options);\n  let url = await assertUrlAllowed(rawUrl, policy);\n\n  const controller = new AbortController();\n  const timer = setTimeout(() => {\n    controller.abort(\n      new StorageError(`outbound request timed out after ${policy.timeoutMs}ms`, {\n        context: { url: rawUrl, timeoutMs: policy.timeoutMs },\n      }),\n    );\n  }, policy.timeoutMs);\n\n  try {\n    let response: Response;\n\n    for (let hop = 0; ; hop++) {\n      response = await policy.fetch(url, { signal: controller.signal, redirect: \"manual\" });\n\n      const location = response.headers.get(\"location\");\n      if (!REDIRECT_STATUSES.has(response.status) || location === null) {\n        break;\n      }\n\n      if (hop >= DEFAULT_MAX_REDIRECTS) {\n        throw new StorageError(\n          `outbound request blocked — more than ${DEFAULT_MAX_REDIRECTS} redirects`,\n          { context: { url: rawUrl, maxRedirects: DEFAULT_MAX_REDIRECTS } },\n        );\n      }\n\n      let target: URL;\n      try {\n        target = new URL(location, url);\n      } catch {\n        throw new StorageError(\n          `outbound request blocked — invalid redirect Location: ${location}`,\n          {\n            context: { url: url.toString(), location },\n          },\n        );\n      }\n\n      // Discard the interim body so the connection can be reused.\n      if (response.body) {\n        await response.body.cancel().catch(() => undefined);\n      }\n\n      // The redirect target gets the SAME scheme + private-IP validation\n      // (incl. DNS resolution) as the initial URL — this is what closes\n      // the redirect-based SSRF bypass: a 302 from an allowed host to\n      // 169.254.169.254 is re-validated here, not blindly followed.\n      url = await assertUrlAllowed(target.toString(), policy);\n    }\n\n    const declared = Number(response.headers.get(\"content-length\"));\n    if (Number.isFinite(declared) && declared > policy.maxBytes) {\n      throw new StorageError(\n        `outbound response body too large — declared ${declared} bytes exceeds the ${policy.maxBytes}-byte cap`,\n        { context: { url: rawUrl, declared, maxBytes: policy.maxBytes } },\n      );\n    }\n\n    const buffer = await readBodyCapped(response, policy.maxBytes, rawUrl);\n\n    return {\n      buffer,\n      contentType: response.headers.get(\"content-type\"),\n      status: response.status,\n      statusText: response.statusText,\n      ok: response.ok,\n    };\n  } finally {\n    clearTimeout(timer);\n  }\n}\n\n/**\n * Read a response body into a Buffer with a hard byte cap. The stream is\n * read chunk-by-chunk and cancelled the moment the running total exceeds\n * `maxBytes`. Throws {@link StorageError} on overflow.\n */\nasync function readBodyCapped(\n  response: Response,\n  maxBytes: number,\n  rawUrl: string,\n): Promise<Buffer> {\n  if (!response.body) {\n    const arrayBuffer = await response.arrayBuffer();\n    if (arrayBuffer.byteLength > maxBytes) {\n      throw new StorageError(`outbound response body exceeded the ${maxBytes}-byte cap`, {\n        context: { url: rawUrl, maxBytes },\n      });\n    }\n    return Buffer.from(arrayBuffer);\n  }\n\n  const reader = response.body.getReader();\n  const chunks: Uint8Array[] = [];\n  let total = 0;\n\n  for (;;) {\n    const { done, value } = await reader.read();\n    if (done) {\n      break;\n    }\n    if (!value) {\n      continue;\n    }\n\n    total += value.byteLength;\n    if (total > maxBytes) {\n      await reader.cancel();\n      throw new StorageError(`outbound response body exceeded the ${maxBytes}-byte cap`, {\n        context: { url: rawUrl, maxBytes },\n      });\n    }\n    chunks.push(value);\n  }\n\n  return Buffer.concat(chunks);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAM,oBAAoB;;AAE1B,MAAM,qBAAqB;;;;;;AAM3B,MAAM,wBAAwB;;AAG9B,MAAM,oCAAoB,IAAI,IAAI;CAAC;CAAK;CAAK;CAAK;CAAK;AAAG,CAAC;;;;;AAgD3D,SAAS,mBAAmB,UAA4B,CAAC,GAAwB;CAC/E,OAAO;EACL,mBAAmB,QAAQ,qBAAqB;EAChD,UAAU,QAAQ,YAAY;EAC9B,WAAW,QAAQ,aAAa;EAChC,gBAAgB,QAAQ,kBAAkB,CAAC,SAAS,MAAM;EAC1D,OAAO,QAAQ,SAAS,WAAW;CACrC;AACF;;AAKA,SAAS,cAAc,MAAsB;CAC3C,OAAO,KAAK,WAAW,GAAG,KAAK,KAAK,SAAS,GAAG,IAAI,KAAK,MAAM,GAAG,EAAE,IAAI;AAC1E;;;;;;;AAQA,eAAe,qBAAqB,MAAc,QAA+B;CAC/E,IAAI,KAAK,IAAI,MAAM,GAAG;EACpB,IAAI,sBAAsB,IAAI,GAC5B,MAAM,IAAI,aAAa,+BAA+B,KAAK,kCAAkC,EAC3F,SAAS;GAAE,KAAK;GAAQ,SAAS;EAAK,EACxC,CAAC;EAEH;CACF;CAEA,IAAI;CACJ,IAAI;EACF,YAAY,MAAM,OAAO,MAAM,EAAE,KAAK,KAAK,CAAC;CAC9C,SAAS,OAAO;EACd,MAAM,IAAI,aACR,sDAAsD,KAAK,2BAC3D;GAAE;GAAO,SAAS;IAAE,KAAK;IAAQ;GAAK;EAAE,CAC1C;CACF;CAEA,KAAK,MAAM,EAAE,aAAa,WACxB,IAAI,sBAAsB,OAAO,GAC/B,MAAM,IAAI,aACR,oCAAoC,KAAK,4CAA4C,QAAQ,IAC7F,EAAE,SAAS;EAAE,KAAK;EAAQ;EAAM;CAAQ,EAAE,CAC5C;AAGN;;;;;;;;AASA,eAAe,iBAAiB,QAAgB,QAA2C;CACzF,IAAI;CACJ,IAAI;EACF,MAAM,IAAI,IAAI,MAAM;CACtB,QAAQ;EACN,MAAM,IAAI,aAAa,2CAA2C,UAAU,EAC1E,SAAS,EAAE,KAAK,OAAO,EACzB,CAAC;CACH;CAEA,MAAM,SAAS,IAAI,SAAS,QAAQ,MAAM,EAAE,CAAC,CAAC,YAAY;CAC1D,IAAI,CAAC,OAAO,eAAe,MAAM,MAAM,EAAE,YAAY,MAAM,MAAM,GAC/D,MAAM,IAAI,aACR,sCAAsC,OAAO,6BAA6B,OAAO,eAAe,KAAK,IAAI,EAAE,IAC3G,EAAE,SAAS;EAAE,KAAK;EAAQ;CAAO,EAAE,CACrC;CAGF,IAAI,CAAC,OAAO,mBAEV,MAAM,qBADO,cAAc,IAAI,QACD,GAAG,MAAM;CAGzC,OAAO;AACT;;;;;;;;;;;;;;;;;;;;AAkCA,eAAsB,kBACpB,QACA,UAA4B,CAAC,GACH;CAC1B,MAAM,SAAS,mBAAmB,OAAO;CACzC,IAAI,MAAM,MAAM,iBAAiB,QAAQ,MAAM;CAE/C,MAAM,aAAa,IAAI,gBAAgB;CACvC,MAAM,QAAQ,iBAAiB;EAC7B,WAAW,MACT,IAAI,aAAa,oCAAoC,OAAO,UAAU,KAAK,EACzE,SAAS;GAAE,KAAK;GAAQ,WAAW,OAAO;EAAU,EACtD,CAAC,CACH;CACF,GAAG,OAAO,SAAS;CAEnB,IAAI;EACF,IAAI;EAEJ,KAAK,IAAI,MAAM,IAAK,OAAO;GACzB,WAAW,MAAM,OAAO,MAAM,KAAK;IAAE,QAAQ,WAAW;IAAQ,UAAU;GAAS,CAAC;GAEpF,MAAM,WAAW,SAAS,QAAQ,IAAI,UAAU;GAChD,IAAI,CAAC,kBAAkB,IAAI,SAAS,MAAM,KAAK,aAAa,MAC1D;GAGF,IAAI,OAAO,uBACT,MAAM,IAAI,aACR,wCAAwC,sBAAsB,aAC9D,EAAE,SAAS;IAAE,KAAK;IAAQ,cAAc;GAAsB,EAAE,CAClE;GAGF,IAAI;GACJ,IAAI;IACF,SAAS,IAAI,IAAI,UAAU,GAAG;GAChC,QAAQ;IACN,MAAM,IAAI,aACR,yDAAyD,YACzD,EACE,SAAS;KAAE,KAAK,IAAI,SAAS;KAAG;IAAS,EAC3C,CACF;GACF;GAGA,IAAI,SAAS,MACX,MAAM,SAAS,KAAK,OAAO,CAAC,CAAC,YAAY,MAAS;GAOpD,MAAM,MAAM,iBAAiB,OAAO,SAAS,GAAG,MAAM;EACxD;EAEA,MAAM,WAAW,OAAO,SAAS,QAAQ,IAAI,gBAAgB,CAAC;EAC9D,IAAI,OAAO,SAAS,QAAQ,KAAK,WAAW,OAAO,UACjD,MAAM,IAAI,aACR,+CAA+C,SAAS,qBAAqB,OAAO,SAAS,YAC7F,EAAE,SAAS;GAAE,KAAK;GAAQ;GAAU,UAAU,OAAO;EAAS,EAAE,CAClE;EAKF,OAAO;GACL,cAHmB,eAAe,UAAU,OAAO,UAAU,MAAM;GAInE,aAAa,SAAS,QAAQ,IAAI,cAAc;GAChD,QAAQ,SAAS;GACjB,YAAY,SAAS;GACrB,IAAI,SAAS;EACf;CACF,UAAU;EACR,aAAa,KAAK;CACpB;AACF;;;;;;AAOA,eAAe,eACb,UACA,UACA,QACiB;CACjB,IAAI,CAAC,SAAS,MAAM;EAClB,MAAM,cAAc,MAAM,SAAS,YAAY;EAC/C,IAAI,YAAY,aAAa,UAC3B,MAAM,IAAI,aAAa,uCAAuC,SAAS,YAAY,EACjF,SAAS;GAAE,KAAK;GAAQ;EAAS,EACnC,CAAC;EAEH,OAAO,OAAO,KAAK,WAAW;CAChC;CAEA,MAAM,SAAS,SAAS,KAAK,UAAU;CACvC,MAAM,SAAuB,CAAC;CAC9B,IAAI,QAAQ;CAEZ,SAAS;EACP,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,KAAK;EAC1C,IAAI,MACF;EAEF,IAAI,CAAC,OACH;EAGF,SAAS,MAAM;EACf,IAAI,QAAQ,UAAU;GACpB,MAAM,OAAO,OAAO;GACpB,MAAM,IAAI,aAAa,uCAAuC,SAAS,YAAY,EACjF,SAAS;IAAE,KAAK;IAAQ;GAAS,EACnC,CAAC;EACH;EACA,OAAO,KAAK,KAAK;CACnB;CAEA,OAAO,OAAO,OAAO,MAAM;AAC7B"}

package/esm/storage/utils/storage-capability-error.d.mts

@@ -1,5 +1,4 @@
 import { StorageError } from "./storage-error.mjs";
-
 //#region ../../packages/core/src/storage/utils/storage-capability-error.d.ts
 /**
  * Thrown when an operation needs an optional driver capability that the
@@ -9,7 +8,7 @@ import { StorageError } from "./storage-error.mjs";
  * Callers can probe first (`storage.supportsPutIfAbsent()`) or branch on
  * `instanceof StorageCapabilityError`.
  */
-declare class StorageCapabilityError extends StorageError {
+export declare class StorageCapabilityError extends StorageError {
   /**
    * The missing capability (e.g. "putIfAbsent").
    */
@@ -21,5 +20,4 @@ declare class StorageCapabilityError extends StorageError {
   constructor(capability: string, driverName: string);
 }
 //#endregion
-export { StorageCapabilityError };
 //# sourceMappingURL=storage-capability-error.d.mts.map

package/esm/storage/utils/storage-capability-error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"storage-capability-error.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/storage-capability-error.ts"],"mappings":";;;;;AAUA;;;;;;cAAa,sBAAA,SAA+B,YAAY;;;;WAItC,UAAA;EAOyC;;;EAAA,SAFzC,UAAA;cAEG,UAAA,UAAoB,UAAA;AAAA"}
+{"version":3,"file":"storage-capability-error.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/storage-capability-error.ts"],"mappings":";;;;;;;;;;qBAUa,+BAA+B;;;;WAI1B;;;;WAKA;EAEhB,YAAmB,oBAAoB"}

package/esm/storage/utils/storage-error.d.mts

@@ -11,7 +11,7 @@
  * mirroring the convention used by `@warlock.js/ai`'s error classes — it is
  * for logs and telemetry, treated as opaque by consumers.
  */
-type StorageErrorOptions = {
+export type StorageErrorOptions = {
   cause?: unknown;
   context?: Record<string, unknown>;
 };
@@ -19,7 +19,7 @@ type StorageErrorOptions = {
  * Error thrown by storage drivers for refused or invalid operations
  * (path-traversal attempts, blocked outbound fetches, oversized downloads).
  */
-declare class StorageError extends Error {
+export declare class StorageError extends Error {
   /**
    * Optional original thrown value preserved through re-wrapping.
    */
@@ -31,5 +31,4 @@ declare class StorageError extends Error {
   constructor(message: string, options?: StorageErrorOptions);
 }
 //#endregion
-export { StorageError, StorageErrorOptions };
 //# sourceMappingURL=storage-error.d.mts.map

package/esm/storage/utils/storage-error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"storage-error.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/storage-error.ts"],"mappings":";;AAYA;;;;;;;;AAEkB;AAOlB;;KATY,mBAAA;EACV,KAAA;EACA,OAAA,GAAU,MAAM;AAAA;;;;;cAOL,YAAA,SAAqB,KAAA;EASN;;;EAAA,SALV,KAAA;EAOoB;;AAA6B;EAA7B,SAFpB,OAAA,GAAU,MAAA;cAEP,OAAA,UAAiB,OAAA,GAAU,mBAAA;AAAA"}
+{"version":3,"file":"storage-error.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/storage-error.ts"],"mappings":";;;;;;;;;;;;;YAYY;EACV;EACA,UAAU;;;;;;qBAOC,qBAAqB;;;;WAIhB;;;;WAKA,UAAU;EAE1B,YAAmB,iBAAiB,UAAU"}

package/esm/storage/utils/storage-not-initialized-error.d.mts

@@ -12,11 +12,12 @@
  * process, so `Storage#init()` was never called and `_driver` stayed
  * `null`. This error names that cause and the fix directly instead.
  */
-declare class StorageNotInitializedError extends Error {
+export declare class StorageNotInitializedError extends Error {
+  /** Stable Warlock error code; `warlock explain WL2006` prints the fix. */
+  readonly code = "WL2006";
   constructor(options?: {
     cause?: unknown;
   });
 }
 //#endregion
-export { StorageNotInitializedError };
 //# sourceMappingURL=storage-not-initialized-error.d.mts.map

package/esm/storage/utils/storage-not-initialized-error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"storage-not-initialized-error.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/storage-not-initialized-error.ts"],"mappings":";;AAaA;;;;;;;;;AACkD;;;cADrC,0BAAA,SAAmC,KAAK;cAChC,OAAA;IAAY,KAAA;EAAA;AAAA"}
+{"version":3,"file":"storage-not-initialized-error.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/storage-not-initialized-error.ts"],"mappings":";;;;;;;;;;;;;;qBAaa,mCAAmC;;WAE9B;EAEhB,YAAmB;IAAY"}

package/esm/storage/utils/storage-not-initialized-error.mjs

@@ -15,6 +15,7 @@
 var StorageNotInitializedError = class extends Error {
 	constructor(options) {
 		super("Storage is not initialized in this process. This happens when the `storage` connector never ran, so `Storage.init()` was never called.\n\nCheck that `src/config/storage.ts` exists. If this is a custom CLI command, add \"storage\" to its `preload.connectors` list so the connector runs before your command's action executes.", options);
+		this.code = "WL2006";
 		this.name = "StorageNotInitializedError";
 	}
 };

package/esm/storage/utils/storage-not-initialized-error.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"storage-not-initialized-error.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/storage-not-initialized-error.ts"],"sourcesContent":["/**\n * Thrown when storage is accessed (e.g. `storage.put(...)`) before it has\n * been initialized in this process — no context driver and no default\n * driver resolved yet.\n *\n * Previously this fell through to a bare `null` `activeDriver`, and the\n * first thing every call site did with it was read `.name` or call a\n * method on it, surfacing as `TypeError: Cannot read properties of null\n * (reading 'name')` deep inside `Storage#put()`. That told the caller\n * nothing about the real cause: the `storage` connector never ran in this\n * process, so `Storage#init()` was never called and `_driver` stayed\n * `null`. This error names that cause and the fix directly instead.\n */\nexport class StorageNotInitializedError extends Error {\n  public constructor(options?: { cause?: unknown }) {\n    super(\n      \"Storage is not initialized in this process. This happens when the `storage` \" +\n        \"connector never ran, so `Storage.init()` was never called.\\n\\n\" +\n        \"Check that `src/config/storage.ts` exists. If this is a custom CLI command, \" +\n        'add \"storage\" to its `preload.connectors` list so the connector runs before ' +\n        \"your command's action executes.\",\n      options,\n    );\n\n    this.name = \"StorageNotInitializedError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,IAAa,6BAAb,cAAgD,MAAM;CACpD,AAAO,YAAY,SAA+B;EAChD,MACE,uUAKA,OACF;EAEA,KAAK,OAAO;CACd;AACF"}
+{"version":3,"file":"storage-not-initialized-error.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/storage/utils/storage-not-initialized-error.ts"],"sourcesContent":["/**\n * Thrown when storage is accessed (e.g. `storage.put(...)`) before it has\n * been initialized in this process — no context driver and no default\n * driver resolved yet.\n *\n * Previously this fell through to a bare `null` `activeDriver`, and the\n * first thing every call site did with it was read `.name` or call a\n * method on it, surfacing as `TypeError: Cannot read properties of null\n * (reading 'name')` deep inside `Storage#put()`. That told the caller\n * nothing about the real cause: the `storage` connector never ran in this\n * process, so `Storage#init()` was never called and `_driver` stayed\n * `null`. This error names that cause and the fix directly instead.\n */\nexport class StorageNotInitializedError extends Error {\n  /** Stable Warlock error code; `warlock explain WL2006` prints the fix. */\n  public readonly code = \"WL2006\";\n\n  public constructor(options?: { cause?: unknown }) {\n    super(\n      \"Storage is not initialized in this process. This happens when the `storage` \" +\n        \"connector never ran, so `Storage.init()` was never called.\\n\\n\" +\n        \"Check that `src/config/storage.ts` exists. If this is a custom CLI command, \" +\n        'add \"storage\" to its `preload.connectors` list so the connector runs before ' +\n        \"your command's action executes.\",\n      options,\n    );\n\n    this.name = \"StorageNotInitializedError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,IAAa,6BAAb,cAAgD,MAAM;CAIpD,AAAO,YAAY,SAA+B;EAChD,MACE,uUAKA,OACF;cAVqB;EAYrB,KAAK,OAAO;CACd;AACF"}