@effect-vfs/core 0.3.0 → 0.4.0

package/dist/VirtualFileSystemError.d.ts

@@ -0,0 +1,54 @@
+import type { FsCode, PathInput } from "./VirtualFileSystem.js";
+declare const FsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FsError";
+} & Readonly<A>;
+/**
+ * An expected filesystem operation failure.
+ *
+ * The `code` distinguishes portable failures while `operation` names the action.
+ * Byte paths are intentionally omitted from the formatted message.
+ *
+ * @example
+ * ```ts
+ * import { VirtualFileSystemError } from "@effect-vfs/core"
+ *
+ * const error = new VirtualFileSystemError.FsError({ code: "NotFound", operation: "readFile" })
+ * console.log(error.code, error.message)
+ * // NotFound readFile failed with NotFound
+ * ```
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class FsError extends FsError_base<{
+    readonly code: FsCode;
+    readonly operation: string;
+    readonly path?: PathInput;
+}> {
+    get message(): string;
+}
+declare const ConfigurationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConfigurationError";
+} & Readonly<A>;
+/**
+ * An invalid volume or caller option, identified by its field name.
+ *
+ * @example
+ * ```ts
+ * import { VirtualFileSystemError } from "@effect-vfs/core"
+ *
+ * const error = new VirtualFileSystemError.ConfigurationError({ field: "maxEntries" })
+ * console.log(error.field, error.message)
+ * // maxEntries Invalid option: maxEntries
+ * ```
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class ConfigurationError extends ConfigurationError_base<{
+    readonly field: string;
+}> {
+    get message(): string;
+}
+export {};
+//# sourceMappingURL=VirtualFileSystemError.d.ts.map

package/dist/VirtualFileSystemError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualFileSystemError.d.ts","sourceRoot":"","sources":["../src/VirtualFileSystemError.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;;;;AAE/D;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,OAAQ,SAAQ,aAA4B;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAA;CAC1B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC7E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}

package/dist/VirtualFileSystemError.js

@@ -0,0 +1,49 @@
+/**
+ * Tagged errors shared by the public filesystem API and its implementation.
+ *
+ * @since 0.1.0
+ */
+import * as Data from "effect/Data";
+/**
+ * An expected filesystem operation failure.
+ *
+ * The `code` distinguishes portable failures while `operation` names the action.
+ * Byte paths are intentionally omitted from the formatted message.
+ *
+ * @example
+ * ```ts
+ * import { VirtualFileSystemError } from "@effect-vfs/core"
+ *
+ * const error = new VirtualFileSystemError.FsError({ code: "NotFound", operation: "readFile" })
+ * console.log(error.code, error.message)
+ * // NotFound readFile failed with NotFound
+ * ```
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export class FsError extends Data.TaggedError("FsError") {
+    get message() {
+        return `${this.operation} failed with ${this.code}`;
+    }
+}
+/**
+ * An invalid volume or caller option, identified by its field name.
+ *
+ * @example
+ * ```ts
+ * import { VirtualFileSystemError } from "@effect-vfs/core"
+ *
+ * const error = new VirtualFileSystemError.ConfigurationError({ field: "maxEntries" })
+ * console.log(error.field, error.message)
+ * // maxEntries Invalid option: maxEntries
+ * ```
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export class ConfigurationError extends Data.TaggedError("ConfigurationError") {
+    get message() {
+        return `Invalid option: ${this.field}`;
+    }
+}

package/dist/index.d.ts

@@ -6,8 +6,22 @@
 /**
  * Virtual filesystem contracts, schemas, errors, and constructors.
  *
- * @category exports
+ * @category re-exports
  * @since 0.1.0
  */
 export * as VirtualFileSystem from "./VirtualFileSystem.js";
+/**
+ * Structured filesystem and configuration failures.
+ *
+ * @category re-exports
+ * @since 0.4.0
+ */
+export * as VirtualFileSystemError from "./VirtualFileSystemError.js";
+/**
+ * Live volume image boundary for storage adapters.
+ *
+ * @category re-exports
+ * @since 0.4.0
+ */
+export * as LiveVolume from "./LiveVolume.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D;;;;;GAKG;AACH,OAAO,KAAK,sBAAsB,MAAM,6BAA6B,CAAA;AAErE;;;;;GAKG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA"}

package/dist/index.js

@@ -6,7 +6,21 @@
 /**
  * Virtual filesystem contracts, schemas, errors, and constructors.
  *
- * @category exports
+ * @category re-exports
  * @since 0.1.0
  */
 export * as VirtualFileSystem from "./VirtualFileSystem.js";
+/**
+ * Structured filesystem and configuration failures.
+ *
+ * @category re-exports
+ * @since 0.4.0
+ */
+export * as VirtualFileSystemError from "./VirtualFileSystemError.js";
+/**
+ * Live volume image boundary for storage adapters.
+ *
+ * @category re-exports
+ * @since 0.4.0
+ */
+export * as LiveVolume from "./LiveVolume.js";

package/dist/internal/bytePath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bytePath.d.ts","sourceRoot":"","sources":["../../src/internal/bytePath.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAE9C,gBAAgB;AAChB,eAAO,MAAM,UAAU,EAAG,2BAAoC,CAAA;AAgC9D,gBAAgB;AAChB,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,QAC4B,CAAA;AAEjF,gBAAgB;AAChB,eAAO,MAAM,IAAI,UAAW,UAAU,KAAG,QAIxC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,QAAQ,SAAU,QAAQ,KAAG,UAAU,GAAG,SAAgC,CAAA"}
+{"version":3,"file":"bytePath.d.ts","sourceRoot":"","sources":["../../src/internal/bytePath.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAG9C,gBAAgB;AAChB,eAAO,MAAM,UAAU,EAAG,2BAAoC,CAAA;AA6B9D,gBAAgB;AAChB,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,QAA6D,CAAA;AAElH,gBAAgB;AAChB,eAAO,MAAM,IAAI,UAAW,UAAU,KAAG,QAMxC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,QAAQ,SAAU,QAAQ,KAAG,UAAU,GAAG,SAAgC,CAAA"}

package/dist/internal/bytePath.js

@@ -2,6 +2,8 @@
 import * as Equal from "effect/Equal";
 import * as Hash from "effect/Hash";
 import { pipeArguments } from "effect/Pipeable";
+import * as Predicate from "effect/Predicate";
+import { sameBytes } from "./bytes.js";
 /** @internal */
 export const BytePathId = "@effect-vfs/core/BytePath";
 const bytePaths = new WeakMap();
@@ -17,15 +19,7 @@ const BytePathProto = {
     [Equal.symbol](that) {
         if (!isBytePath(that))
             return false;
-        const selfBytes = bytePaths.get(this);
-        const thatBytes = bytePaths.get(that);
-        if (selfBytes.length !== thatBytes.length)
-            return false;
-        for (let index = 0; index < selfBytes.length; index++) {
-            if (selfBytes[index] !== thatBytes[index])
-                return false;
-        }
-        return true;
+        return sameBytes(bytePaths.get(this), bytePaths.get(that));
     },
     [Hash.symbol]() {
         return hashBytes(bytePaths.get(this));
@@ -35,9 +29,10 @@ const BytePathProto = {
     }
 };
 /** @internal */
-export const isBytePath = (value) => typeof value === "object" && value !== null && bytePaths.has(value);
+export const isBytePath = (value) => Predicate.isObject(value) && bytePaths.has(value);
 /** @internal */
 export const make = (bytes) => {
+    // SAFETY: BytePathProto implements every member of the opaque BytePath contract.
     const path = Object.create(BytePathProto);
     bytePaths.set(path, bytes);
     return Object.freeze(path);

package/dist/internal/bytes.d.ts

@@ -0,0 +1,6 @@
+import * as Order from "effect/Order";
+/** @internal */
+export declare const bytesOrder: Order.Order<Uint8Array>;
+/** @internal */
+export declare const sameBytes: (left: Uint8Array | undefined, right: Uint8Array | undefined) => boolean;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/internal/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../src/internal/bytes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAerC,gBAAgB;AAChB,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAA4B,CAAA;AAG3E,gBAAgB;AAChB,eAAO,MAAM,SAAS,SAAU,UAAU,GAAG,SAAS,SAAS,UAAU,GAAG,SAAS,KAAG,OACU,CAAA"}

package/dist/internal/bytes.js

@@ -0,0 +1,17 @@
+// Byte-array comparison shared by the overlay diff, the snapshot delta, and BytePath equality.
+import * as Order from "effect/Order";
+const compareBytes = (left, right) => {
+    const length = Math.min(left.length, right.length);
+    for (let index = 0; index < length; index++) {
+        const l = left[index];
+        const r = right[index];
+        if (l !== r)
+            return l < r ? -1 : 1;
+    }
+    return left.length === right.length ? 0 : left.length < right.length ? -1 : 1;
+};
+/** @internal */
+export const bytesOrder = Order.make(compareBytes);
+// A plain loop: Equal.equals would hash both arrays and memoise the pair in a WeakMap first.
+/** @internal */
+export const sameBytes = (left, right) => left === right || (left !== undefined && right !== undefined && compareBytes(left, right) === 0);

package/dist/internal/canonicalBase64.d.ts

@@ -1,7 +1,15 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+declare const Encoded: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+type Encoded = typeof Encoded.Type;
 /** @internal */
-export declare const isCanonical: (value: string) => boolean;
-/** @internal */
-export declare const decodedLength: (value: string) => number;
-/** @internal */
-export declare const decodeTrusted: (value: string) => Uint8Array;
+export declare const CanonicalBase64: {
+    Encoded: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+    Bytes: Schema.decodeTo<Schema.Uint8Array, Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">, never, never>;
+    decode: (input: Encoded) => Effect.Effect<Uint8Array<ArrayBufferLike>, never, never>;
+    encode: (input: Uint8Array) => Encoded;
+    decodedLength: (value: Encoded) => number;
+    is: (value: string) => value is Encoded;
+};
+export {};
 //# sourceMappingURL=canonicalBase64.d.ts.map

package/dist/internal/canonicalBase64.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canonicalBase64.d.ts","sourceRoot":"","sources":["../../src/internal/canonicalBase64.ts"],"names":[],"mappings":"AAKA,gBAAgB;AAChB,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,OAGP,CAAA;AAErC,gBAAgB;AAChB,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,MACmC,CAAA;AAEjF,gBAAgB;AAChB,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,UAC4D,CAAA"}
+{"version":3,"file":"canonicalBase64.d.ts","sourceRoot":"","sources":["../../src/internal/canonicalBase64.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AA0BvC,QAAA,MAAM,OAAO,uEAGZ,CAAA;AASD,KAAK,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAElC,gBAAgB;AAChB,eAAO,MAAM,eAAe;;;oBAGV,OAAO;oBACP,UAAU,KAAG,OAAO;2BACb,OAAO,KAAG,MAAM;gBAC3B,MAAM,KAAG,KAAK,IAAI,OAAO;CACtC,CAAA"}

package/dist/internal/canonicalBase64.js

@@ -1,11 +1,33 @@
+import * as Effect from "effect/Effect";
 import * as Encoding from "effect/Encoding";
-import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as SchemaGetter from "effect/SchemaGetter";
 const canonicalTail = /^(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/][AQgw]==|[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=)?(?![\s\S])/;
-/** @internal */
-export const isCanonical = (value) => value.length % 4 === 0 &&
+const isCanonical = (value) => value.length % 4 === 0 &&
     !/[^A-Za-z0-9+/]/.test(value.slice(0, -4)) &&
     canonicalTail.test(value.slice(-4));
+const decodedLength = (value) => value.length / 4 * 3 - (value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0);
+const encode = (input) => {
+    // Join bounded chunks to avoid the encoder's intermediate string chains. Three-byte
+    // boundaries keep padding in the final chunk, preserving the canonical representation.
+    const chunkBytes = 12_288;
+    const chunks = [];
+    for (let offset = 0; offset < input.length; offset += chunkBytes) {
+        chunks.push(Encoding.encodeBase64(input.subarray(offset, offset + chunkBytes)));
+    }
+    return Encoded.make(chunks.join(""));
+};
+const Encoded = Schema.String.pipe(Schema.refine((value) => isCanonical(value), { expected: "canonical padded base64" }), Schema.brand("CanonicalBase64"));
+const Bytes = Encoded.pipe(Schema.decodeTo(Schema.Uint8Array, {
+    decode: SchemaGetter.decodeBase64(),
+    encode: SchemaGetter.transform((input) => encode(input))
+}));
 /** @internal */
-export const decodedLength = (value) => value.length / 4 * 3 - (value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0);
-/** @internal */
-export const decodeTrusted = (value) => Result.getOrThrowWith(Encoding.decodeBase64(value), () => new Error("Invalid trusted canonical base64"));
+export const CanonicalBase64 = {
+    Encoded,
+    Bytes,
+    decode: (input) => Schema.decodeEffect(Bytes)(input).pipe(Effect.orDie),
+    encode: (input) => encode(input),
+    decodedLength: (value) => decodedLength(value),
+    is: (value) => isCanonical(value)
+};

package/dist/internal/image.d.ts

@@ -2,122 +2,108 @@ import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import { ImageError, type Snapshot } from "../Snapshot.js";
-import * as CanonicalBase64 from "./canonicalBase64.js";
+import { StoredMetadata } from "./metadata.js";
 /** @internal */
-export declare const StoredMetadata: Schema.Struct<{
-    readonly uid: Schema.Natural;
-    readonly gid: Schema.Natural;
-    readonly mode: Schema.Natural;
-    readonly atimeNs: Schema.String;
-    readonly mtimeNs: Schema.String;
-    readonly ctimeNs: Schema.String;
-    readonly birthtimeNs: Schema.String;
-}>;
-/** @internal */
-export type StoredMetadata = typeof StoredMetadata.Type;
-/** @internal */
-export declare const Record: Schema.Union<readonly [Schema.Struct<{
-    readonly id: Schema.String;
-    readonly kind: Schema.Literal<"directory">;
-    readonly metadata: Schema.Struct<{
-        readonly uid: Schema.Natural;
-        readonly gid: Schema.Natural;
-        readonly mode: Schema.Natural;
-        readonly atimeNs: Schema.String;
-        readonly mtimeNs: Schema.String;
-        readonly ctimeNs: Schema.String;
-        readonly birthtimeNs: Schema.String;
-    }>;
-    readonly entries: Schema.$Array<Schema.Struct<{
-        readonly name: Schema.String;
-        readonly target: Schema.String;
-    }>>;
-}>, Schema.Struct<{
-    readonly id: Schema.String;
-    readonly kind: Schema.Literal<"file">;
-    readonly metadata: Schema.Struct<{
-        readonly uid: Schema.Natural;
-        readonly gid: Schema.Natural;
-        readonly mode: Schema.Natural;
-        readonly atimeNs: Schema.String;
-        readonly mtimeNs: Schema.String;
-        readonly ctimeNs: Schema.String;
-        readonly birthtimeNs: Schema.String;
-    }>;
-    readonly data: Schema.String;
-}>, Schema.Struct<{
-    readonly id: Schema.String;
-    readonly kind: Schema.Literal<"symlink">;
-    readonly metadata: Schema.Struct<{
-        readonly uid: Schema.Natural;
-        readonly gid: Schema.Natural;
-        readonly mode: Schema.Natural;
-        readonly atimeNs: Schema.String;
-        readonly mtimeNs: Schema.String;
-        readonly ctimeNs: Schema.String;
-        readonly birthtimeNs: Schema.String;
-    }>;
-    readonly target: Schema.String;
-}>]>;
+export { StoredMetadata };
 /** @internal */
-export type Record = typeof Record.Type;
-/** @internal */
-export declare const Document: Schema.Struct<{
-    readonly format: Schema.Literal<"effect-vfs">;
-    readonly version: Schema.Literal<1>;
-    readonly root: Schema.String;
-    readonly records: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+export declare const Record: Schema.TaggedUnion<{
+    readonly directory: Schema.TaggedStruct<"directory", {
         readonly id: Schema.String;
-        readonly kind: Schema.Literal<"directory">;
         readonly metadata: Schema.Struct<{
             readonly uid: Schema.Natural;
             readonly gid: Schema.Natural;
             readonly mode: Schema.Natural;
-            readonly atimeNs: Schema.String;
-            readonly mtimeNs: Schema.String;
-            readonly ctimeNs: Schema.String;
-            readonly birthtimeNs: Schema.String;
+            readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
         }>;
         readonly entries: Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
+            readonly name: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
             readonly target: Schema.String;
         }>>;
-    }>, Schema.Struct<{
+    }>;
+    readonly file: Schema.TaggedStruct<"file", {
         readonly id: Schema.String;
-        readonly kind: Schema.Literal<"file">;
         readonly metadata: Schema.Struct<{
             readonly uid: Schema.Natural;
             readonly gid: Schema.Natural;
             readonly mode: Schema.Natural;
-            readonly atimeNs: Schema.String;
-            readonly mtimeNs: Schema.String;
-            readonly ctimeNs: Schema.String;
-            readonly birthtimeNs: Schema.String;
+            readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
         }>;
-        readonly data: Schema.String;
-    }>, Schema.Struct<{
+        readonly data: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+    }>;
+    readonly symlink: Schema.TaggedStruct<"symlink", {
         readonly id: Schema.String;
-        readonly kind: Schema.Literal<"symlink">;
         readonly metadata: Schema.Struct<{
             readonly uid: Schema.Natural;
             readonly gid: Schema.Natural;
             readonly mode: Schema.Natural;
-            readonly atimeNs: Schema.String;
-            readonly mtimeNs: Schema.String;
-            readonly ctimeNs: Schema.String;
-            readonly birthtimeNs: Schema.String;
+            readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
         }>;
-        readonly target: Schema.String;
-    }>]>>;
+        readonly target: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+    }>;
 }>;
 /** @internal */
-export type Document = typeof Document.Type;
-/** @internal */
-export declare const decodedLength: typeof CanonicalBase64.decodedLength;
+export type Record = typeof Record.Type;
 /** @internal */
-export declare const base64: (input: Uint8Array) => string;
+export declare const Document: Schema.Struct<{
+    readonly format: Schema.Literal<"effect-vfs">;
+    readonly version: Schema.Literal<1>;
+    readonly root: Schema.String;
+    readonly records: Schema.$Array<Schema.TaggedUnion<{
+        readonly directory: Schema.TaggedStruct<"directory", {
+            readonly id: Schema.String;
+            readonly metadata: Schema.Struct<{
+                readonly uid: Schema.Natural;
+                readonly gid: Schema.Natural;
+                readonly mode: Schema.Natural;
+                readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            }>;
+            readonly entries: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+                readonly target: Schema.String;
+            }>>;
+        }>;
+        readonly file: Schema.TaggedStruct<"file", {
+            readonly id: Schema.String;
+            readonly metadata: Schema.Struct<{
+                readonly uid: Schema.Natural;
+                readonly gid: Schema.Natural;
+                readonly mode: Schema.Natural;
+                readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            }>;
+            readonly data: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+        }>;
+        readonly symlink: Schema.TaggedStruct<"symlink", {
+            readonly id: Schema.String;
+            readonly metadata: Schema.Struct<{
+                readonly uid: Schema.Natural;
+                readonly gid: Schema.Natural;
+                readonly mode: Schema.Natural;
+                readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            }>;
+            readonly target: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+        }>;
+    }>>;
+}>;
 /** @internal */
-export declare const bytes: (value: string) => Uint8Array;
+export type Document = typeof Document.Type;
 /** @internal */
 export declare const inspect: (snapshot: Snapshot) => Effect.Effect<Document, ImageError>;
 /** @internal */
@@ -126,7 +112,7 @@ export declare const capture: (input: unknown, limits?: {
     readonly maxRecords: number;
     readonly maxEntries: number;
     readonly maxDecodedBytes: ByteSize.ByteSize;
-} | undefined) => Effect.Effect<Snapshot, ImageError, never>;
+} | undefined, trusted?: any) => Effect.Effect<Snapshot, ImageError, never>;
 /** @internal */
 export declare const encodeSnapshot: (snapshot: Snapshot) => Effect.Effect<Uint8Array<ArrayBuffer>, ImageError, never>;
 /** @internal */

package/dist/internal/image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/internal/image.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAgB,UAAU,EAAE,KAAK,QAAQ,EAAkB,MAAM,gBAAgB,CAAA;AACxF,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAQvD,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;;;;EAQzB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAIvD,gBAAgB;AAChB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASjB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC,gBAAgB;AAChB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAI3C,gBAAgB;AAChB,eAAO,MAAM,aAAa,sCAAgC,CAAA;AAE1D,gBAAgB;AAChB,eAAO,MAAM,MAAM,UAAW,UAAU,KAAG,MAU1C,CAAA;AAKD,gBAAgB;AAChB,eAAO,MAAM,KAAK,UAAW,MAAM,KAAG,UAErC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,OAAO,aAAc,QAAQ,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAI3E,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,OAAO;;;;;4DAwElB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc,mFAKzB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;gDAqB1B,CAAA"}
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/internal/image.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAgB,UAAU,EAAE,KAAK,QAAQ,EAAkB,MAAM,gBAAgB,CAAA;AAExF,OAAO,EAAE,cAAc,EAAsB,MAAM,eAAe,CAAA;AAMlE,gBAAgB;AAChB,OAAO,EAAE,cAAc,EAAE,CAAA;AAIzB,gBAAgB;AAChB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQjB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC,gBAAgB;AAChB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnB,CAAA;AAwBF,gBAAgB;AAChB,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAI3C,gBAAgB;AAChB,eAAO,MAAM,OAAO,aAAc,QAAQ,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAO3E,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,OAAO;;;;;2EAiJlB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc,mFAMzB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;gDA+B1B,CAAA"}