@effect-vfs/core 0.5.0 → 0.6.0

package/dist/internal/budget.d.ts

@@ -0,0 +1,90 @@
+import * as Schema from "effect/Schema";
+/** @internal */
+export declare const Budget: Schema.Struct<{
+    readonly encodedBytes: Schema.ByteSize;
+    readonly records: Schema.Natural;
+    readonly entries: Schema.Natural;
+    readonly decodedBytes: Schema.ByteSize;
+    readonly lineBytes: Schema.ByteSize;
+}>;
+/** @internal */
+export type Budget = typeof Budget.Type;
+/** @internal */
+export declare const DeltaBudget: Schema.Struct<{
+    readonly encodedBytes: Schema.ByteSize;
+    readonly records: Schema.Natural;
+    readonly entries: Schema.Natural;
+    readonly decodedBytes: Schema.ByteSize;
+    readonly identityBytes: Schema.ByteSize;
+    readonly baseRecords: Schema.Natural;
+    readonly targetRecords: Schema.Natural;
+    readonly outputRecords: Schema.Natural;
+    readonly outputBytes: Schema.ByteSize;
+    readonly inheritedRecords: Schema.Natural;
+}>;
+/** @internal */
+export type DeltaBudget = typeof DeltaBudget.Type;
+/** @internal */
+export declare const BudgetFromDecodeLimits: Schema.decodeTo<Schema.Struct<{
+    readonly encodedBytes: Schema.ByteSize;
+    readonly records: Schema.Natural;
+    readonly entries: Schema.Natural;
+    readonly decodedBytes: Schema.ByteSize;
+    readonly lineBytes: Schema.ByteSize;
+}>, Schema.Struct<{
+    readonly maxEncodedBytes: Schema.ByteSize;
+    readonly maxRecords: Schema.Natural;
+    readonly maxEntries: Schema.Natural;
+    readonly maxDecodedBytes: Schema.ByteSize;
+    readonly maxLineBytes: Schema.optionalKey<Schema.ByteSize>;
+}>, never, never>;
+/** @internal */
+export declare const DeltaBudgetFromLimits: Schema.decodeTo<Schema.Struct<{
+    readonly encodedBytes: Schema.ByteSize;
+    readonly records: Schema.Natural;
+    readonly entries: Schema.Natural;
+    readonly decodedBytes: Schema.ByteSize;
+    readonly identityBytes: Schema.ByteSize;
+    readonly baseRecords: Schema.Natural;
+    readonly targetRecords: Schema.Natural;
+    readonly outputRecords: Schema.Natural;
+    readonly outputBytes: Schema.ByteSize;
+    readonly inheritedRecords: Schema.Natural;
+}>, Schema.Struct<{
+    readonly maxEncodedBytes: Schema.ByteSize;
+    readonly maxIdentityBytes: Schema.ByteSize;
+    readonly maxDeltaRecords: Schema.Natural;
+    readonly maxDecodedDeltaBytes: Schema.ByteSize;
+    readonly maxBaseRecords: Schema.Natural;
+    readonly maxTargetRecords: Schema.Natural;
+    readonly maxEntries: Schema.Natural;
+    readonly maxOutputRecords: Schema.Natural;
+    readonly maxOutputBytes: Schema.ByteSize;
+    readonly maxInheritedRecords: Schema.Natural;
+}> & {
+    constrained: {
+        readonly maxEncodedBytes: import("effect/ByteSize").ByteSize;
+        readonly maxIdentityBytes: import("effect/ByteSize").ByteSize;
+        readonly maxDeltaRecords: number;
+        readonly maxDecodedDeltaBytes: import("effect/ByteSize").ByteSize;
+        readonly maxBaseRecords: number;
+        readonly maxTargetRecords: number;
+        readonly maxEntries: number;
+        readonly maxOutputRecords: number;
+        readonly maxOutputBytes: import("effect/ByteSize").ByteSize;
+        readonly maxInheritedRecords: number;
+    };
+    default: {
+        readonly maxEncodedBytes: import("effect/ByteSize").ByteSize;
+        readonly maxIdentityBytes: import("effect/ByteSize").ByteSize;
+        readonly maxDeltaRecords: number;
+        readonly maxDecodedDeltaBytes: import("effect/ByteSize").ByteSize;
+        readonly maxBaseRecords: number;
+        readonly maxTargetRecords: number;
+        readonly maxEntries: number;
+        readonly maxOutputRecords: number;
+        readonly maxOutputBytes: import("effect/ByteSize").ByteSize;
+        readonly maxInheritedRecords: number;
+    };
+}, never, never>;
+//# sourceMappingURL=budget.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"budget.d.ts","sourceRoot":"","sources":["../../src/internal/budget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAYvC,gBAAgB;AAChB,eAAO,MAAM,MAAM;;;;;;EAGjB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC,gBAAgB;AAChB,eAAO,MAAM,WAAW;;;;;;;;;;;EAQtB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEjD,gBAAgB;AAChB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;iBAmBjC,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA4BhC,CAAA"}

package/dist/internal/budget.js

@@ -0,0 +1,70 @@
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import { DecodeLimits } from "../Snapshot.js";
+import { SnapshotDeltaLimits } from "../SnapshotDelta.js";
+const documentFields = {
+    encodedBytes: Schema.ByteSize,
+    records: Schema.Natural,
+    entries: Schema.Natural,
+    decodedBytes: Schema.ByteSize
+};
+/** @internal */
+export const Budget = Schema.Struct({
+    ...documentFields,
+    lineBytes: Schema.ByteSize
+});
+/** @internal */
+export const DeltaBudget = Schema.Struct({
+    ...documentFields,
+    identityBytes: Schema.ByteSize,
+    baseRecords: Schema.Natural,
+    targetRecords: Schema.Natural,
+    outputRecords: Schema.Natural,
+    outputBytes: Schema.ByteSize,
+    inheritedRecords: Schema.Natural
+});
+/** @internal */
+export const BudgetFromDecodeLimits = DecodeLimits.pipe(Schema.decodeTo(Budget, SchemaTransformation.transform({
+    decode: (limits) => ({
+        encodedBytes: limits.maxEncodedBytes,
+        records: limits.maxRecords,
+        entries: limits.maxEntries,
+        decodedBytes: limits.maxDecodedBytes,
+        // The encoded input bounds any line when maxLineBytes is absent.
+        lineBytes: limits.maxLineBytes ?? limits.maxEncodedBytes
+    }),
+    encode: (budget) => ({
+        maxEncodedBytes: budget.encodedBytes,
+        maxRecords: budget.records,
+        maxEntries: budget.entries,
+        maxDecodedBytes: budget.decodedBytes,
+        maxLineBytes: budget.lineBytes
+    })
+})));
+/** @internal */
+export const DeltaBudgetFromLimits = SnapshotDeltaLimits.pipe(Schema.decodeTo(DeltaBudget, SchemaTransformation.transform({
+    decode: (limits) => ({
+        encodedBytes: limits.maxEncodedBytes,
+        records: limits.maxDeltaRecords,
+        entries: limits.maxEntries,
+        decodedBytes: limits.maxDecodedDeltaBytes,
+        identityBytes: limits.maxIdentityBytes,
+        baseRecords: limits.maxBaseRecords,
+        targetRecords: limits.maxTargetRecords,
+        outputRecords: limits.maxOutputRecords,
+        outputBytes: limits.maxOutputBytes,
+        inheritedRecords: limits.maxInheritedRecords
+    }),
+    encode: (budget) => ({
+        maxEncodedBytes: budget.encodedBytes,
+        maxIdentityBytes: budget.identityBytes,
+        maxDeltaRecords: budget.records,
+        maxDecodedDeltaBytes: budget.decodedBytes,
+        maxBaseRecords: budget.baseRecords,
+        maxTargetRecords: budget.targetRecords,
+        maxEntries: budget.entries,
+        maxOutputRecords: budget.outputRecords,
+        maxOutputBytes: budget.outputBytes,
+        maxInheritedRecords: budget.inheritedRecords
+    })
+})));

package/dist/internal/bytePath.d.ts

@@ -4,6 +4,8 @@ export declare const BytePathId: "@effect-vfs/core/BytePath";
 /** @internal */
 export declare const isBytePath: (value: unknown) => value is BytePath;
 /** @internal */
+export declare const isPathBytes: (bytes: Uint8Array) => boolean;
+/** @internal */
 export declare const make: (bytes: Uint8Array) => BytePath;
 /** @internal */
 export declare const getBytes: (path: BytePath) => Uint8Array | undefined;

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"bytePath.d.ts","sourceRoot":"","sources":["../../src/internal/bytePath.ts"],"names":[],"mappings":"AAIA,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,WAAW,UAAW,UAAU,KAAG,OAAiD,CAAA;AAEjG,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

@@ -1,4 +1,3 @@
-// Opaque byte path representation and value protocols.
 import * as Equal from "effect/Equal";
 import * as Hash from "effect/Hash";
 import { pipeArguments } from "effect/Pipeable";
@@ -31,8 +30,10 @@ const BytePathProto = {
 /** @internal */
 export const isBytePath = (value) => Predicate.isObject(value) && bytePaths.has(value);
 /** @internal */
+export const isPathBytes = (bytes) => bytes.length > 0 && !bytes.includes(0);
+/** @internal */
 export const make = (bytes) => {
-    // SAFETY: BytePathProto implements every member of the opaque BytePath contract.
+    // SAFETY: BytePathProto implements the opaque BytePath contract.
     const path = Object.create(BytePathProto);
     bytePaths.set(path, bytes);
     return Object.freeze(path);

package/dist/internal/bytes.d.ts

@@ -1,6 +1,9 @@
+import * as Effect from "effect/Effect";
 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;
+/** @internal */
+export declare const decodeUtf8: <E>(bytes: Uint8Array, onInvalid: (cause: unknown) => E) => Effect.Effect<string, E>;
 //# sourceMappingURL=bytes.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../src/internal/bytes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAerC,gBAAgB;AAChB,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAA4B,CAAA;AAE3E,gBAAgB;AAChB,eAAO,MAAM,SAAS,SAAU,UAAU,GAAG,SAAS,SAAS,UAAU,GAAG,SAAS,KAAG,OACU,CAAA;AAGlG,gBAAgB;AAChB,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,UAAU,aAAa,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CACW,CAAA"}

package/dist/internal/bytes.js

@@ -1,4 +1,4 @@
-// Byte-array comparison shared by the overlay diff, the snapshot delta, and BytePath equality.
+import * as Effect from "effect/Effect";
 import * as Order from "effect/Order";
 const compareBytes = (left, right) => {
     const length = Math.min(left.length, right.length);
@@ -12,6 +12,8 @@ const compareBytes = (left, right) => {
 };
 /** @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);
+// Copy the input to prevent a shared buffer changing during decoding.
+/** @internal */
+export const decodeUtf8 = (bytes, onInvalid) => Effect.try({ try: () => new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(bytes)), catch: onInvalid });

package/dist/internal/canonicalBase64.d.ts

@@ -1,15 +1,12 @@
-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 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>;
+    toBytes: (input: Encoded) => Uint8Array;
     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":"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"}
+{"version":3,"file":"canonicalBase64.d.ts","sourceRoot":"","sources":["../../src/internal/canonicalBase64.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAyBvC,QAAA,MAAM,OAAO,uEAMZ,CAAA;AAED,KAAK,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAElC,gBAAgB;AAChB,eAAO,MAAM,eAAe;;qBAET,OAAO,KAAG,UAAU;oBACrB,UAAU,KAAG,OAAO;2BACb,OAAO,KAAG,MAAM;CACxC,CAAA"}

package/dist/internal/canonicalBase64.js

@@ -1,15 +1,14 @@
-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";
+import { ENCODING_CHECK } from "./errors.js";
 const canonicalTail = /^(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/][AQgw]==|[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=)?(?![\s\S])/;
 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.
+    // Chunk boundaries must be multiples of three to keep padding in the final chunk.
     const chunkBytes = 12_288;
     const chunks = [];
     for (let offset = 0; offset < input.length; offset += chunkBytes) {
@@ -17,17 +16,14 @@ const encode = (input) => {
     }
     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))
-}));
+const Encoded = Schema.String.pipe(Schema.refine((value) => isCanonical(value), {
+    expected: "canonical padded base64",
+    [ENCODING_CHECK]: true
+}), Schema.brand("CanonicalBase64"));
 /** @internal */
 export const CanonicalBase64 = {
     Encoded,
-    Bytes,
-    decode: (input) => Schema.decodeEffect(Bytes)(input).pipe(Effect.orDie),
+    toBytes: (input) => Result.getOrThrow(Encoding.decodeBase64(input)),
     encode: (input) => encode(input),
-    decodedLength: (value) => decodedLength(value),
-    is: (value) => isCanonical(value)
+    decodedLength: (value) => decodedLength(value)
 };

package/dist/internal/errors.d.ts

@@ -1,12 +1,54 @@
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import { ConfigurationError, FsError } from "../VirtualFileSystemError.js";
+import type * as SchemaAST from "effect/SchemaAST";
+import type * as SchemaIssue from "effect/SchemaIssue";
+import type { BytePath } from "../BytePath.js";
+import { type ArgumentFailure, type FsCode, type FsFailure, type ImageCode, type ImageFailure, VfsError } from "../VfsError.js";
+import type { PathInput } from "../VirtualFileSystem.js";
 /** @internal */
-export { ConfigurationError, FsError };
+export { VfsError };
 /** @internal */
-export declare const FsCode: Schema.Literals<readonly ["NotFound", "AlreadyExists", "NotEmpty", "NotDirectory", "AccessDenied", "InvalidHandle", "ForeignHandle", "InvalidReference", "ForeignReference", "StaleReference", "ClosedCaller", "InvalidArgument", "InvalidPathEncoding", "PathTooLong", "NoSpace", "IsDirectory", "FileTooLarge", "NoData", "SymlinkLoop", "UnrepresentableName", "StorageRejected", "OutcomeUnknown", "VolumeUnavailable", "VolumeBusy"]>;
+export declare const errorPath: (input: PathInput) => BytePath | undefined;
+interface Details {
+    readonly path?: PathInput;
+    readonly field?: string;
+    readonly cause?: unknown;
+}
 /** @internal */
-export type FsCode = typeof FsCode.Type;
+export declare const argumentFailure: (operation: string, field: string, cause?: unknown) => ArgumentFailure;
 /** @internal */
-export declare const decodeConfiguration: <A>(schema: Schema.Codec<A>, value: typeof Schema.Unknown.Type) => Result.Result<A, ConfigurationError>;
+export declare const decodeConfiguration: <A, I>(schema: Schema.Codec<A, I>, value: typeof Schema.Unknown.Type, operation: string) => Result.Result<A, ArgumentFailure>;
+/** @internal */
+export declare const ENCODING_CHECK = "@effect-vfs/core/encodingCheck";
+/** @internal */
+export interface IssueSite {
+    readonly path: ReadonlyArray<PropertyKey>;
+    readonly checks: ReadonlyArray<SchemaAST.Filter<unknown>>;
+}
+/** @internal */
+export declare const issueSite: (issue: SchemaIssue.Issue) => IssueSite;
+/** @internal */
+export declare const isEncodingIssue: (site: IssueSite) => boolean;
+/** @internal */
+export declare const fsFailure: (code: FsCode, operation: string, details?: Details) => FsFailure;
+/** @internal */
+export declare const imageFailure: (operation: string, code: ImageCode, details?: {
+    readonly field?: string;
+    readonly cause?: unknown;
+}) => ImageFailure;
+/** @internal */
+export declare const retargetFailure: <E>(operation: string, error: E) => E;
+/** @internal */
+export interface OpContext {
+    readonly operation: string;
+    readonly fail: (code: FsCode, details?: {
+        readonly cause?: unknown;
+        readonly field?: string;
+    }) => FsFailure;
+    readonly at: (path: PathInput) => OpContext;
+}
+/** @internal */
+export declare const OpContext: {
+    make: (operation: string) => OpContext;
+};
 //# sourceMappingURL=errors.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/internal/errors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAA;AAE1E,gBAAgB;AAChB,OAAO,EAAE,kBAAkB,EAAE,OAAO,EAAE,CAAA;AAEtC,gBAAgB;AAChB,eAAO,MAAM,MAAM,4aA4BjB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAWvC,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,GAAI,CAAC,UAAU,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,yCAG9F,CAAA"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/internal/errors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,SAAS,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,KAAK,WAAW,MAAM,oBAAoB,CAAA;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,MAAM,EACX,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,YAAY,EAGjB,QAAQ,EACT,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGxD,gBAAgB;AAChB,OAAO,EAAE,QAAQ,EAAE,CAAA;AAKnB,gBAAgB;AAChB,eAAO,MAAM,SAAS,UAAW,SAAS,KAAG,QAAQ,GAAG,SAMvD,CAAA;AAYD,UAAU,OAAO;IACf,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CACzB;AAWD,gBAAgB;AAChB,eAAO,MAAM,eAAe,cAAe,MAAM,SAAS,MAAM,UAAU,OAAO,KAAG,eAC7B,CAAA;AAEvD,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,GAAI,CAAC,EAAE,CAAC,UAC9B,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,SACnB,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,aACtB,MAAM,KAChB,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,eAAe,CAGhC,CAAA;AAGH,gBAAgB;AAChB,eAAO,MAAM,cAAc,mCAAmC,CAAA;AAE9D,gBAAgB;AAChB,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,CAAA;IACzC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAA;CAC1D;AAGD,gBAAgB;AAChB,eAAO,MAAM,SAAS,UAAW,WAAW,CAAC,KAAK,KAAG,SAmBpD,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,eAAe,SAAU,SAAS,KAAG,OACyB,CAAA;AAE3E,gBAAgB;AAChB,eAAO,MAAM,SAAS,SAAU,MAAM,aAAa,MAAM,YAAY,OAAO,KAAG,SAC9C,CAAA;AAEjC,gBAAgB;AAChB,eAAO,MAAM,YAAY,cACZ,MAAM,QACX,SAAS,YACL;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,KAC9D,YAA+C,CAAA;AAQlD,gBAAgB;AAChB,eAAO,MAAM,eAAe,GAAI,CAAC,aAAa,MAAM,SAAS,CAAC,KAAG,CAMhE,CAAA;AAED,gBAAgB;AAChB,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,SAAS,CAAA;IAC3G,QAAQ,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,SAAS,CAAA;CAC5C;AAQD,gBAAgB;AAChB,eAAO,MAAM,SAAS;IACpB,IAAI,cAAc,MAAM,KAAG,SAAS;CACrC,CAAA"}

package/dist/internal/errors.js

@@ -1,47 +1,91 @@
-// Virtual filesystem failure schemas and identities shared by the runtime implementation.
 import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import { ConfigurationError, FsError } from "../VirtualFileSystemError.js";
-/** @internal */
-export { ConfigurationError, FsError };
-/** @internal */
-export const FsCode = Schema.Literals([
-    "NotFound",
-    "AlreadyExists",
-    "NotEmpty",
-    "NotDirectory",
-    "AccessDenied",
-    "InvalidHandle",
-    "ForeignHandle",
-    "InvalidReference",
-    "ForeignReference",
-    "StaleReference",
-    "ClosedCaller",
-    "InvalidArgument",
-    "InvalidPathEncoding",
-    "PathTooLong",
-    "NoSpace",
-    "IsDirectory",
-    "FileTooLarge",
-    "NoData",
-    "SymlinkLoop",
-    "UnrepresentableName",
-    // A durable provider knows the mutation was not committed.
-    "StorageRejected",
-    // A commit or publication failed after its outcome ceased to be knowable to the caller.
-    "OutcomeUnknown",
-    // The provider stopped serving operations until recovery establishes its state.
-    "VolumeUnavailable",
-    "VolumeBusy"
-]);
-// Names the offending option so the caller learns which key it got wrong, not just that decoding failed.
+import { make as makeError, VfsError } from "../VfsError.js";
+import { getBytes, isBytePath, isPathBytes, make } from "./bytePath.js";
+/** @internal */
+export { VfsError };
+const encoder = new TextEncoder();
+// Omit invalid paths rather than attach a BytePath that breaks its invariant.
+/** @internal */
+export const errorPath = (input) => {
+    const bytes = Predicate.isString(input) ? encoder.encode(input) : isBytePath(input) ? getBytes(input) : undefined;
+    if (bytes === undefined || !isPathBytes(bytes))
+        return undefined;
+    return isBytePath(input) ? input : make(bytes);
+};
 const configurationField = (issue) => {
     if (Predicate.isTagged("Pointer")(issue))
         return issue.path.map(String).join(".");
     if (Predicate.isTagged("Composite")(issue))
         return configurationField(issue.issues[0]);
+    if (Predicate.isTagged("Encoding")(issue))
+        return configurationField(issue.issue);
     return "options";
 };
+const build = (code, operation, details) => makeError({
+    code,
+    operation,
+    field: details?.field,
+    path: details?.path === undefined ? undefined : errorPath(details.path),
+    cause: details?.cause
+});
+/** @internal */
+export const argumentFailure = (operation, field, cause) => build("InvalidArgument", operation, { field, cause });
+/** @internal */
+export const decodeConfiguration = (schema, value, operation) => Schema.decodeUnknownResult(schema, { onExcessProperty: "error" })(value).pipe(Result.mapError((error) => argumentFailure(operation, configurationField(error.issue), error)));
+// Distinguishes invalid value encoding from invalid structure.
+/** @internal */
+export const ENCODING_CHECK = "@effect-vfs/core/encodingCheck";
+// Decoding stops at the first failure; composite issues put it in their first branch.
+/** @internal */
+export const issueSite = (issue) => {
+    const path = [];
+    const checks = [];
+    let current = issue;
+    while (current !== undefined) {
+        if (Predicate.isTagged("Pointer")(current)) {
+            path.push(...current.path);
+            current = current.issue;
+        }
+        else if (Predicate.isTagged("Filter")(current)) {
+            checks.push(current.filter);
+            current = current.issue;
+        }
+        else if (Predicate.isTagged("Encoding")(current))
+            current = current.issue;
+        else if (Predicate.isTagged("Composite")(current) || Predicate.isTagged("AnyOf")(current)) {
+            current = current.issues[0];
+        }
+        else
+            current = undefined;
+    }
+    return { path, checks };
+};
 /** @internal */
-export const decodeConfiguration = (schema, value) => Schema.decodeUnknownResult(schema, { onExcessProperty: "error" })(value).pipe(Result.mapError((error) => new ConfigurationError({ field: configurationField(error.issue) })));
+export const isEncodingIssue = (site) => site.checks.some((check) => check.annotations?.[ENCODING_CHECK] === true);
+/** @internal */
+export const fsFailure = (code, operation, details) => build(code, operation, details);
+/** @internal */
+export const imageFailure = (operation, code, details) => build(code, operation, details);
+/** @internal */
+const retarget = (operation, error) => error.operation === operation
+    ? error
+    : makeError({ code: error.code, operation, field: error.field, path: error.path, cause: error.cause });
+/** @internal */
+export const retargetFailure = (operation, error) => {
+    if (!Schema.is(VfsError)(error))
+        return error;
+    // SAFETY: retarget changes only the operation, preserving E's error variant.
+    // oxlint-disable-next-line effecttsgo/unsafe-effect-type-assertion -- see the invariant above.
+    return retarget(operation, error);
+};
+const makeOpContext = (operation, located) => ({
+    operation,
+    fail: (code, details) => fsFailure(code, operation, located === undefined ? details : { ...details, path: located }),
+    at: (path) => makeOpContext(operation, Predicate.isString(path) || isBytePath(path) ? path : undefined)
+});
+/** @internal */
+export const OpContext = {
+    make: (operation) => makeOpContext(operation)
+};

package/dist/internal/fixture.d.ts

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect";
-import { ImageError } from "../Snapshot.js";
+import { VfsError } from "./errors.js";
 /** @internal */
 export declare const fromFixture: (fixture: {
     readonly rootMetadata?: {
@@ -62,5 +62,5 @@ export declare const fromFixture: (fixture: {
     readonly maxBytes?: import("effect/ByteSize").ByteSize;
     readonly maxFileBytes?: import("effect/ByteSize").ByteSize;
     readonly maxPathBytes?: import("effect/ByteSize").ByteSize;
-} | undefined) => Effect.Effect<import("../VirtualFileSystem.js").Volume, import("./errors.js").ConfigurationError | ImageError | import("effect/PlatformError").PlatformError, import("effect/Crypto").Crypto>;
+} | undefined) => Effect.Effect<import("../VirtualFileSystem.js").Volume, import("../VfsError.js").ArgumentFailure | import("../VfsError.js").ImageFailure | (void & VfsError), never>;
 //# sourceMappingURL=fixture.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fixture.d.ts","sourceRoot":"","sources":["../../src/internal/fixture.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAoB3C,gBAAgB;AAChB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+MAwLvB,CAAA"}
+{"version":3,"file":"fixture.d.ts","sourceRoot":"","sources":["../../src/internal/fixture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAMvC,OAAO,EAAgD,QAAQ,EAAE,MAAM,aAAa,CAAA;AAgBpF,gBAAgB;AAChB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sLAiLvB,CAAA"}