@effect-vfs/core 0.4.0 → 0.6.0

package/dist/internal/hex128.d.ts

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+/** @internal */
+export declare const Hex128: Schema.String;
+/** @internal */
+export declare const VolumeEpoch: Schema.brand<Schema.String, "@effect-vfs/core/VolumeEpoch">;
+/** @internal */
+export type VolumeEpoch = typeof VolumeEpoch.Type;
+/** @internal */
+export declare const KeySecret: Schema.brand<Schema.String, "@effect-vfs/core/KeySecret">;
+/** @internal */
+export type KeySecret = typeof KeySecret.Type;
+//# sourceMappingURL=hex128.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hex128.d.ts","sourceRoot":"","sources":["../../src/internal/hex128.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,gBAAgB;AAChB,eAAO,MAAM,MAAM,eAA0D,CAAA;AAE7E,gBAAgB;AAChB,eAAO,MAAM,WAAW,6DAA4D,CAAA;AAEpF,gBAAgB;AAChB,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEjD,gBAAgB;AAChB,eAAO,MAAM,SAAS,2DAA0D,CAAA;AAEhF,gBAAgB;AAChB,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA"}

package/dist/internal/hex128.js

@@ -0,0 +1,7 @@
+import * as Schema from "effect/Schema";
+/** @internal */
+export const Hex128 = Schema.String.check(Schema.isPattern(/^[0-9a-f]{32}$/));
+/** @internal */
+export const VolumeEpoch = Hex128.pipe(Schema.brand("@effect-vfs/core/VolumeEpoch"));
+/** @internal */
+export const KeySecret = Hex128.pipe(Schema.brand("@effect-vfs/core/KeySecret"));

package/dist/internal/hmac.d.ts

@@ -0,0 +1,5 @@
+/** @internal */
+export declare const hmacSha256: (key: Uint8Array, message: Uint8Array) => Uint8Array;
+/** @internal */
+export declare const sameTag: (left: Uint8Array, right: Uint8Array) => boolean;
+//# sourceMappingURL=hmac.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.d.ts","sourceRoot":"","sources":["../../src/internal/hmac.ts"],"names":[],"mappings":"AAqJA,gBAAgB;AAChB,eAAO,MAAM,UAAU,QAAS,UAAU,WAAW,UAAU,KAAG,UAOjE,CAAA;AAGD,gBAAgB;AAChB,eAAO,MAAM,OAAO,SAAU,UAAU,SAAS,UAAU,KAAG,OAQ7D,CAAA"}

package/dist/internal/hmac.js

@@ -0,0 +1,150 @@
+// Synchronous HMAC keeps reference-key methods free of Crypto service requirements.
+const BLOCK_BYTES = 64;
+const ROUND_CONSTANTS = new Uint32Array([
+    0x428a2f98,
+    0x71374491,
+    0xb5c0fbcf,
+    0xe9b5dba5,
+    0x3956c25b,
+    0x59f111f1,
+    0x923f82a4,
+    0xab1c5ed5,
+    0xd807aa98,
+    0x12835b01,
+    0x243185be,
+    0x550c7dc3,
+    0x72be5d74,
+    0x80deb1fe,
+    0x9bdc06a7,
+    0xc19bf174,
+    0xe49b69c1,
+    0xefbe4786,
+    0x0fc19dc6,
+    0x240ca1cc,
+    0x2de92c6f,
+    0x4a7484aa,
+    0x5cb0a9dc,
+    0x76f988da,
+    0x983e5152,
+    0xa831c66d,
+    0xb00327c8,
+    0xbf597fc7,
+    0xc6e00bf3,
+    0xd5a79147,
+    0x06ca6351,
+    0x14292967,
+    0x27b70a85,
+    0x2e1b2138,
+    0x4d2c6dfc,
+    0x53380d13,
+    0x650a7354,
+    0x766a0abb,
+    0x81c2c92e,
+    0x92722c85,
+    0xa2bfe8a1,
+    0xa81a664b,
+    0xc24b8b70,
+    0xc76c51a3,
+    0xd192e819,
+    0xd6990624,
+    0xf40e3585,
+    0x106aa070,
+    0x19a4c116,
+    0x1e376c08,
+    0x2748774c,
+    0x34b0bcb5,
+    0x391c0cb3,
+    0x4ed8aa4a,
+    0x5b9cca4f,
+    0x682e6ff3,
+    0x748f82ee,
+    0x78a5636f,
+    0x84c87814,
+    0x8cc70208,
+    0x90befffa,
+    0xa4506ceb,
+    0xbef9a3f7,
+    0xc67178f2
+]);
+const INITIAL_STATE = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+const rotr = (value, bits) => (value >>> bits) | (value << (32 - bits));
+const sha256 = (message) => {
+    const padded = new Uint8Array(Math.ceil((message.length + 9) / BLOCK_BYTES) * BLOCK_BYTES);
+    padded.set(message);
+    padded[message.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setBigUint64(padded.length - 8, BigInt(message.length) * 8n);
+    const state = Int32Array.from(INITIAL_STATE);
+    const schedule = new Uint32Array(64);
+    for (let block = 0; block < padded.length; block += BLOCK_BYTES) {
+        for (let t = 0; t < 16; t++)
+            schedule[t] = view.getUint32(block + t * 4);
+        for (let t = 16; t < 64; t++) {
+            const w15 = schedule[t - 15];
+            const w2 = schedule[t - 2];
+            const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ (w15 >>> 3);
+            const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ (w2 >>> 10);
+            schedule[t] = (schedule[t - 16] + s0 + schedule[t - 7] + s1) | 0;
+        }
+        let a = state[0];
+        let b = state[1];
+        let c = state[2];
+        let d = state[3];
+        let e = state[4];
+        let f = state[5];
+        let g = state[6];
+        let h = state[7];
+        for (let t = 0; t < 64; t++) {
+            const t1 = (h + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + ((e & f) ^ (~e & g)) + ROUND_CONSTANTS[t]
+                + schedule[t]) | 0;
+            const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) | 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + t1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) | 0;
+        }
+        state.set([
+            state[0] + a,
+            state[1] + b,
+            state[2] + c,
+            state[3] + d,
+            state[4] + e,
+            state[5] + f,
+            state[6] + g,
+            state[7] + h
+        ]);
+    }
+    const digest = new Uint8Array(32);
+    const out = new DataView(digest.buffer);
+    for (let word = 0; word < 8; word++)
+        out.setUint32(word * 4, state[word]);
+    return digest;
+};
+const concat = (left, right) => {
+    const joined = new Uint8Array(left.length + right.length);
+    joined.set(left);
+    joined.set(right, left.length);
+    return joined;
+};
+/** @internal */
+export const hmacSha256 = (key, message) => {
+    const block = new Uint8Array(BLOCK_BYTES);
+    block.set(key.length > BLOCK_BYTES ? sha256(key) : key);
+    const inner = block.map((byte) => byte ^ 0x36);
+    const outer = block.map((byte) => byte ^ 0x5c);
+    return sha256(concat(outer, sha256(concat(inner, message))));
+};
+// Compare every byte regardless of the first difference to avoid leaking a matching prefix.
+/** @internal */
+export const sameTag = (left, right) => {
+    if (left.length !== right.length)
+        return false;
+    let difference = 0;
+    for (let index = 0; index < left.length; index++)
+        difference |= left[index] ^ right[index];
+    return difference === 0;
+};

package/dist/internal/image.d.ts

@@ -1,125 +1,22 @@
-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 { StoredMetadata } from "./metadata.js";
+import type * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import type { FixtureEntry } from "../Fixture.js";
+import { type Snapshot } from "../Snapshot.js";
+import type { FsFailure, ImageFailure } from "../VfsError.js";
+import type { PathInput } from "../VirtualFileSystem.js";
+import type { Budget } from "./budget.js";
+import { type VolumeState } from "./volumeState.js";
 /** @internal */
-export { StoredMetadata };
+export declare const make: (value: VolumeState) => Snapshot;
 /** @internal */
-export declare const Record: 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">;
-    }>;
-}>;
+export declare const valueOf: (snapshot: Snapshot) => Effect.Effect<VolumeState, ImageFailure>;
 /** @internal */
-export type Record = typeof Record.Type;
+export declare const encodeSnapshotStream: (snapshot: Snapshot, budget?: Budget) => Stream.Stream<Uint8Array, ImageFailure>;
 /** @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.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">;
-        }>;
-    }>>;
-}>;
+export declare const encodeSnapshot: (snapshot: Snapshot, budget?: Budget) => Effect.Effect<Uint8Array, ImageFailure>;
 /** @internal */
-export type Document = typeof Document.Type;
+export declare const decodeSnapshotSink: (budget: Budget) => Sink.Sink<Snapshot, Uint8Array, never, ImageFailure>;
 /** @internal */
-export declare const inspect: (snapshot: Snapshot) => Effect.Effect<Document, ImageError>;
-/** @internal */
-export declare const capture: (input: unknown, limits?: {
-    readonly maxEncodedBytes: ByteSize.ByteSize;
-    readonly maxRecords: number;
-    readonly maxEntries: number;
-    readonly maxDecodedBytes: ByteSize.ByteSize;
-} | undefined, trusted?: any) => Effect.Effect<Snapshot, ImageError, never>;
-/** @internal */
-export declare const encodeSnapshot: (snapshot: Snapshot) => Effect.Effect<Uint8Array<ArrayBuffer>, ImageError, never>;
-/** @internal */
-export declare const decodeSnapshot: (input: Uint8Array<ArrayBufferLike>, limits: {
-    readonly maxEncodedBytes: ByteSize.ByteSize;
-    readonly maxRecords: number;
-    readonly maxEntries: number;
-    readonly maxDecodedBytes: ByteSize.ByteSize;
-}) => Effect.Effect<Snapshot, ImageError, never>;
+export declare const snapshotEntries: (snapshot: Snapshot, root: PathInput) => Stream.Stream<FixtureEntry, FsFailure | ImageFailure>;
 //# sourceMappingURL=image.d.ts.map

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;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"}
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/internal/image.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,OAAO,KAAK,KAAK,IAAI,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AACjD,OAAO,EAAE,KAAK,QAAQ,EAAkB,MAAM,gBAAgB,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAezC,OAAO,EAQL,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAA;AAgBzB,gBAAgB;AAChB,eAAO,MAAM,IAAI,UAAW,WAAW,KAAG,QAAkD,CAAA;AAE5F,gBAAgB;AAChB,eAAO,MAAM,OAAO,aAAc,QAAQ,KAAG,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,YAAY,CAOhF,CAAA;AAOJ,gBAAgB;AAChB,eAAO,MAAM,oBAAoB,aACrB,QAAQ,WACT,MAAM,KACd,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,YAAY,CAapC,CAAA;AAEL,gBAAgB;AAChB,eAAO,MAAM,cAAc,aAAc,QAAQ,WAAW,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,YAAY,CACpD,CAAA;AAEvD,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,WAAY,MAAM,KAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,CAYtG,CAAA;AA0GD,gBAAgB;AAChB,eAAO,MAAM,eAAe,aAChB,QAAQ,QACZ,SAAS,KACd,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,GAAG,YAAY,CAOlD,CAAA"}