@effect-vfs/core 0.4.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

@@ -0,0 +1,54 @@
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+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 { VfsError };
+/** @internal */
+export declare const errorPath: (input: PathInput) => BytePath | undefined;
+interface Details {
+    readonly path?: PathInput;
+    readonly field?: string;
+    readonly cause?: unknown;
+}
+/** @internal */
+export declare const argumentFailure: (operation: string, field: string, cause?: unknown) => ArgumentFailure;
+/** @internal */
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,91 @@
+import * as Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+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 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/{virtualFileSystem/fixture.d.ts → 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?: {
@@ -13,7 +13,7 @@ export declare const fromFixture: (fixture: {
     };
     readonly entries: readonly ({
         readonly kind: "directory";
-        readonly path: string | import("../../BytePath.js").BytePath;
+        readonly path: string | import("../BytePath.js").BytePath;
         readonly metadata?: {
             readonly uid?: number;
             readonly gid?: number;
@@ -25,7 +25,7 @@ export declare const fromFixture: (fixture: {
         };
     } | {
         readonly kind: "file";
-        readonly path: string | import("../../BytePath.js").BytePath;
+        readonly path: string | import("../BytePath.js").BytePath;
         readonly bytes: Uint8Array<ArrayBufferLike>;
         readonly metadata?: {
             readonly uid?: number;
@@ -38,8 +38,8 @@ export declare const fromFixture: (fixture: {
         };
     } | {
         readonly kind: "symlink";
-        readonly path: string | import("../../BytePath.js").BytePath;
-        readonly target: string | import("../../BytePath.js").BytePath;
+        readonly path: string | import("../BytePath.js").BytePath;
+        readonly target: string | import("../BytePath.js").BytePath;
         readonly metadata?: {
             readonly uid?: number;
             readonly gid?: number;
@@ -51,8 +51,8 @@ export declare const fromFixture: (fixture: {
         };
     } | {
         readonly kind: "hardLink";
-        readonly path: string | import("../../BytePath.js").BytePath;
-        readonly target: string | import("../../BytePath.js").BytePath;
+        readonly path: string | import("../BytePath.js").BytePath;
+        readonly target: string | import("../BytePath.js").BytePath;
     })[];
 }, options?: {
     readonly identity?: string & import("effect/Brand").Brand<"@effect-vfs/core/VolumeIdentity">;
@@ -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

@@ -0,0 +1 @@
+{"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"}

package/dist/internal/fixture.js

@@ -0,0 +1,133 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { Fixture as FixtureSchema, FixtureEntry } from "../Fixture.js";
+import { VolumeIdentity, VolumeOptions as VolumeOptionsSchema } from "../Volume.js";
+import { decodeConfiguration, imageFailure, OpContext, VfsError } from "./errors.js";
+import { inputBytes, isAttachedBytes, isDotComponent, preparePath } from "./path.js";
+import { makeVolume, VolumeSource } from "./virtualFileSystem.js";
+import { assemble, Ino, ROOT_INO } from "./volumeState.js";
+const DEFAULT_MODE = { directory: 0o755, file: 0o644, symlink: 0o777 };
+const EPOCH_NS = 0n;
+/** @internal */
+export const fromFixture = Effect.fn("VirtualFileSystem.fromFixture")(function* (fixture, options) {
+    const config = yield* Effect.fromResult(decodeConfiguration(VolumeOptionsSchema, options ?? {}, "fromFixture"));
+    const source = yield* Schema.decodeEffect(FixtureSchema, { onExcessProperty: "error" })(fixture).pipe(Effect.mapError((cause) => imageFailure("fromFixture", "InvalidStructure", { field: "fixture", cause })));
+    if (source.entries.some((entry) => FixtureEntry.match(entry, {
+        directory: () => false,
+        file: ({ bytes }) => !isAttachedBytes(bytes),
+        symlink: () => false,
+        hardLink: () => false
+    }))) {
+        return yield* imageFailure("fromFixture", "InvalidEncoding", { field: "bytes" });
+    }
+    const metadata = (kind, overrides) => ({
+        uid: overrides?.uid ?? 0,
+        gid: overrides?.gid ?? 0,
+        mode: overrides?.mode ?? DEFAULT_MODE[kind],
+        atimeNs: overrides?.atimeNs ?? EPOCH_NS,
+        mtimeNs: overrides?.mtimeNs ?? EPOCH_NS,
+        ctimeNs: overrides?.ctimeNs ?? EPOCH_NS,
+        birthtimeNs: overrides?.birthtimeNs ?? EPOCH_NS
+    });
+    // Assign inode numbers in declaration order, before resolving hard links.
+    const declarations = new Map();
+    const aliases = new Map();
+    const paths = new Map();
+    let nextInode = ROOT_INO;
+    const declare = (declared) => {
+        nextInode = Ino(nextInode + 1);
+        return { ...declared, ino: nextInode };
+    };
+    declarations.set("", { kind: "directory", ino: ROOT_INO, metadata: metadata("directory", source.rootMetadata) });
+    const op = OpContext.make("fixture");
+    const fixturePath = (input) => preparePath(input, op.operation, config.maxPathBytes).pipe(Result.flatMap((path) => !path.absolute || path.components.length === 0 ||
+        path.components.some(isDotComponent)
+        ? Result.fail(op.at(input).fail("InvalidArgument")) :
+        Result.succeed(path.components)));
+    // Copy caller-owned bytes before storing them.
+    for (const entry of source.entries) {
+        const components = yield* Effect.fromResult(fixturePath(entry.path)).pipe(Effect.mapError((cause) => imageFailure("fromFixture", "InvalidStructure", { field: "path", cause })));
+        const key = components.join("/");
+        if (paths.has(key))
+            return yield* imageFailure("fromFixture", "InvalidStructure", { field: "duplicate" });
+        paths.set(key, components);
+        const error = FixtureEntry.match(entry, {
+            hardLink: ({ target }) => {
+                const parsedTarget = fixturePath(target);
+                if (Result.isFailure(parsedTarget)) {
+                    return imageFailure("fromFixture", "InvalidStructure", { field: "target", cause: parsedTarget.failure });
+                }
+                aliases.set(key, parsedTarget.success.join("/"));
+            },
+            directory: (entry) => {
+                declarations.set(key, declare({ kind: "directory", metadata: metadata("directory", entry.metadata) }));
+            },
+            file: (entry) => {
+                declarations.set(key, declare({ kind: "file", metadata: metadata("file", entry.metadata), payload: entry.bytes.slice() }));
+            },
+            symlink: ({ metadata: overrides, target: input }) => {
+                const target = inputBytes(input);
+                if (Result.isFailure(target)) {
+                    return imageFailure("fromFixture", target.failure === "InvalidPathEncoding" ? "InvalidEncoding" : "InvalidStructure", { field: "target" });
+                }
+                if (target.success.includes(0))
+                    return imageFailure("fromFixture", "InvalidStructure", { field: "target" });
+                declarations.set(key, declare({ kind: "symlink", metadata: metadata("symlink", overrides), payload: target.success.slice() }));
+            }
+        });
+        if (Schema.is(VfsError)(error))
+            return yield* error;
+    }
+    for (const [key] of aliases) {
+        let target = key;
+        const seen = new Set();
+        while (!declarations.has(target)) {
+            if (seen.has(target))
+                return yield* imageFailure("fromFixture", "InvalidStructure", { field: "hardLink" });
+            seen.add(target);
+            const next = aliases.get(target);
+            if (next === undefined)
+                return yield* imageFailure("fromFixture", "InvalidStructure", { field: "hardLink" });
+            target = next;
+        }
+        const node = declarations.get(target);
+        if (node === undefined || node.kind === "directory") {
+            return yield* imageFailure("fromFixture", "InvalidStructure", { field: "hardLink" });
+        }
+        for (const alias of seen)
+            declarations.set(alias, node);
+    }
+    const names = new Map();
+    for (const [key, components] of paths) {
+        const parent = declarations.get(components.slice(0, -1).join("/"));
+        const child = declarations.get(key);
+        const name = components.at(-1);
+        if (parent?.kind !== "directory" || child === undefined || name === undefined) {
+            return yield* imageFailure("fromFixture", "InvalidStructure", { field: "parent" });
+        }
+        names.set(child, [...(names.get(child) ?? []), { parent: parent.ino, name }]);
+    }
+    const specs = [...new Set(declarations.values())].map((declared) => {
+        const links = names.get(declared) ?? [];
+        const common = { ino: declared.ino, metadata: declared.metadata, revision: 1n };
+        if (declared.kind === "directory") {
+            // The root has no path; directories cannot have hard links.
+            const [link = { parent: ROOT_INO, name: "" }] = links;
+            return { ...common, kind: "directory", parent: link.parent, name: link.name };
+        }
+        const payload = declared.payload ?? new Uint8Array();
+        return declared.kind === "file"
+            ? { ...common, kind: "file", links, data: payload }
+            : { ...common, kind: "symlink", links, target: payload };
+    });
+    const restored = VolumeSource.Restored({ value: assemble(specs) });
+    const { identity, ...volumeOptions } = config;
+    if (identity === undefined)
+        return (yield* makeVolume(restored, volumeOptions)).volume;
+    const { volume } = yield* makeVolume(restored, {
+        ...volumeOptions,
+        identity: VolumeIdentity.make(identity)
+    });
+    return volume;
+});