@effect-vfs/core 0.3.0 → 0.4.0

package/dist/internal/liveImage.js

@@ -0,0 +1,176 @@
+// Private, versioned image for a live volume. Unlike a public snapshot, this
+// retains inode numbers, revisions, allocator state, and open unlinked files.
+import * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import { ImageError } from "../Snapshot.js";
+import { CanonicalBase64 } from "./canonicalBase64.js";
+import { StoredMetadata } from "./metadata.js";
+const NaturalBigInt = Schema.String.check(Schema.isPattern(/^(0|[1-9][0-9]{0,127})$/)).pipe(Schema.decodeTo(Schema.BigInt, SchemaTransformation.bigintFromString));
+const Common = {
+    ino: NaturalBigInt,
+    revision: NaturalBigInt,
+    lineage: Schema.optionalKey(Schema.String),
+    metadata: Schema.Struct({
+        ...StoredMetadata.fields,
+        nlink: Schema.Natural,
+        size: NaturalBigInt
+    })
+};
+/** @internal */
+export const Record = Schema.TaggedUnion({
+    directory: {
+        ...Common,
+        entries: Schema.Array(Schema.Struct({ name: CanonicalBase64.Encoded, target: NaturalBigInt }))
+    },
+    file: { ...Common, data: CanonicalBase64.Encoded },
+    symlink: { ...Common, target: CanonicalBase64.Encoded }
+});
+/** @internal */
+export const Document = Schema.Struct({
+    format: Schema.Literal("effect-vfs-live"),
+    version: Schema.Literal(1),
+    identity: Schema.String.check(Schema.isPattern(/^[0-9a-f]{32}$/)),
+    root: NaturalBigInt,
+    nextInode: NaturalBigInt,
+    revisionCounter: NaturalBigInt,
+    entries: Schema.Natural,
+    usedBytes: NaturalBigInt,
+    limits: Schema.Struct({
+        maxEntries: Schema.optionalKey(Schema.Natural),
+        maxBytes: Schema.optionalKey(NaturalBigInt),
+        maxFileBytes: Schema.optionalKey(NaturalBigInt),
+        maxPathBytes: Schema.optionalKey(NaturalBigInt)
+    }),
+    retainedFiles: Schema.Array(NaturalBigInt),
+    records: Schema.Array(Record)
+});
+const invalid = () => new ImageError({ code: "InvalidStructure", field: "liveImage" });
+const validate = Effect.fnUntraced(function* (document) {
+    const records = new Map();
+    for (const record of document.records) {
+        if (record.ino < 1n || records.has(record.ino) || record.revision < 1n ||
+            record.revision > document.revisionCounter || record.ino >= document.nextInode)
+            return yield* invalid();
+        records.set(record.ino, record);
+    }
+    const root = records.get(document.root);
+    if (document.root !== 1n || root?._tag !== "directory" || document.revisionCounter < 1n) {
+        return yield* invalid();
+    }
+    const links = new Map();
+    const pending = [[root, 1n]];
+    const seenDirectories = new Set();
+    const reachable = new Set();
+    let entries = 0;
+    for (let index = 0; index < pending.length; index++) {
+        const current = pending[index];
+        if (current === undefined)
+            return yield* invalid();
+        const [directory, pathBytes] = current;
+        if (seenDirectories.has(directory.ino))
+            return yield* invalid();
+        seenDirectories.add(directory.ino);
+        reachable.add(directory.ino);
+        const names = new Set();
+        for (const entry of directory.entries) {
+            if (names.has(entry.name) || entry.target === document.root)
+                return yield* invalid();
+            names.add(entry.name);
+            const name = yield* CanonicalBase64.decode(entry.name);
+            if (name.length < 1 || name.length > 255 || name.includes(0) || name.includes(47) ||
+                (name.length === 1 && name[0] === 46) ||
+                (name.length === 2 && name[0] === 46 && name[1] === 46))
+                return yield* invalid();
+            const childPathBytes = pathBytes + BigInt(name.length) + (pathBytes === 1n ? 0n : 1n);
+            if (document.limits.maxPathBytes !== undefined && childPathBytes > document.limits.maxPathBytes) {
+                return yield* invalid();
+            }
+            const target = records.get(entry.target);
+            if (target === undefined)
+                return yield* invalid();
+            entries++;
+            links.set(target.ino, (links.get(target.ino) ?? 0) + 1);
+            reachable.add(target.ino);
+            if (Record.guards.directory(target))
+                pending.push([target, childPathBytes]);
+        }
+    }
+    if (entries !== document.entries || links.has(root.ino))
+        return yield* invalid();
+    const retained = new Set(document.retainedFiles);
+    if (retained.size !== document.retainedFiles.length)
+        return yield* invalid();
+    let usedBytes = 0n;
+    for (const record of document.records) {
+        const actualLinks = links.get(record.ino) ?? 0;
+        if (Record.guards.directory(record)) {
+            const childDirectories = record.entries.filter((entry) => {
+                const child = records.get(entry.target);
+                return child !== undefined && Record.guards.directory(child);
+            }).length;
+            if (!seenDirectories.has(record.ino) || (record.ino !== root.ino && actualLinks !== 1) ||
+                record.metadata.nlink !== 2 + childDirectories || record.metadata.size !== 0n)
+                return yield* invalid();
+        }
+        else {
+            const payload = Record.guards.file(record) ? record.data : record.target;
+            const length = BigInt(CanonicalBase64.decodedLength(payload));
+            if (record.metadata.size !== length || record.metadata.nlink !== actualLinks)
+                return yield* invalid();
+            if (Record.guards.file(record)) {
+                if (document.limits.maxFileBytes !== undefined && length > document.limits.maxFileBytes) {
+                    return yield* invalid();
+                }
+                if (actualLinks === 0 && !retained.has(record.ino))
+                    return yield* invalid();
+                if (actualLinks > 0 && retained.has(record.ino))
+                    return yield* invalid();
+            }
+            else {
+                if (actualLinks === 0 || retained.has(record.ino) || (yield* CanonicalBase64.decode(record.target)).includes(0)) {
+                    return yield* invalid();
+                }
+            }
+            usedBytes += length;
+        }
+        if (!reachable.has(record.ino) && !retained.has(record.ino))
+            return yield* invalid();
+    }
+    if (document.limits.maxPathBytes !== undefined && document.limits.maxPathBytes < 1n)
+        return yield* invalid();
+    if (usedBytes !== document.usedBytes ||
+        (document.limits.maxEntries !== undefined && entries > document.limits.maxEntries) ||
+        (document.limits.maxBytes !== undefined && usedBytes > document.limits.maxBytes))
+        return yield* invalid();
+    for (const ino of retained) {
+        if (records.get(ino)?._tag !== "file" || reachable.has(ino))
+            return yield* invalid();
+    }
+    return document;
+});
+/** @internal */
+export const encode = Effect.fnUntraced(function* (document) {
+    const text = yield* Schema.encodeEffect(Schema.fromJsonString(Document))(yield* validate(document)).pipe(Effect.mapError(() => new ImageError({ code: "InvalidStructure", field: "liveImage" })));
+    return new TextEncoder().encode(text);
+});
+/** @internal */
+export const decode = Effect.fnUntraced(function* (bytes, maxEncodedBytes) {
+    if (!(bytes instanceof Uint8Array) || !(bytes.buffer instanceof ArrayBuffer)) {
+        return yield* new ImageError({ code: "InvalidEncoding", field: "liveImage" });
+    }
+    if (ByteSize.isGreaterThan(ByteSize.bytes(bytes.byteLength), maxEncodedBytes)) {
+        return yield* new ImageError({ code: "LimitExceeded", field: "encodedBytes" });
+    }
+    const text = yield* Effect.try({
+        try: () => new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(bytes)),
+        catch: () => new ImageError({ code: "InvalidEncoding", field: "liveImage" })
+    });
+    const parsed = yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Unknown))(text).pipe(Effect.mapError(() => new ImageError({ code: "InvalidEncoding", field: "liveImage" })));
+    const document = Schema.decodeUnknownResult(Document, { onExcessProperty: "error" })(parsed);
+    if (Result.isFailure(document))
+        return yield* new ImageError({ code: "InvalidStructure", field: "liveImage" });
+    return yield* validate(document.success);
+});

package/dist/internal/metadata.d.ts

@@ -0,0 +1,28 @@
+import * as Schema from "effect/Schema";
+/** @internal */
+export declare const Timestamp: Schema.BigInt;
+/** @internal */
+export declare const TimestampFromString: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+/** @internal */
+export declare const WireStoredMetadata: 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 declare const StoredMetadata: 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>;
+}>;
+/** @internal */
+export type StoredMetadata = typeof StoredMetadata.Type;
+//# sourceMappingURL=metadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/internal/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,gBAAgB;AAChB,eAAO,MAAM,SAAS,eAGrB,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,6DAE0C,CAAA;AAE1E,gBAAgB;AAChB,eAAO,MAAM,kBAAkB;;;;;;;;EAQ7B,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;;;;EAQzB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA"}

package/dist/internal/metadata.js

@@ -0,0 +1,29 @@
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+const MAX_TIMESTAMP = 10n ** 128n - 1n;
+/** @internal */
+export const Timestamp = Schema.BigInt.check(Schema.isGreaterThanOrEqualToBigInt(-MAX_TIMESTAMP), Schema.isLessThanOrEqualToBigInt(MAX_TIMESTAMP));
+/** @internal */
+export const TimestampFromString = Schema.String
+    .check(Schema.isPattern(/^-?[0-9]{1,128}$/))
+    .pipe(Schema.decodeTo(Timestamp, SchemaTransformation.bigintFromString));
+/** @internal */
+export const WireStoredMetadata = Schema.Struct({
+    uid: Schema.Natural,
+    gid: Schema.Natural,
+    mode: Schema.Natural.check(Schema.isLessThanOrEqualTo(0o7777)),
+    atimeNs: Schema.String,
+    mtimeNs: Schema.String,
+    ctimeNs: Schema.String,
+    birthtimeNs: Schema.String
+});
+/** @internal */
+export const StoredMetadata = Schema.Struct({
+    uid: Schema.Natural,
+    gid: Schema.Natural,
+    mode: Schema.Natural.check(Schema.isLessThanOrEqualTo(0o7777)),
+    atimeNs: TimestampFromString,
+    mtimeNs: TimestampFromString,
+    ctimeNs: TimestampFromString,
+    birthtimeNs: TimestampFromString
+});

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

@@ -1 +1 @@
-{"version":3,"file":"snapshotDelta.d.ts","sourceRoot":"","sources":["../../src/internal/snapshotDelta.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,OAAO,EAAE,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,EAGL,KAAK,aAAa,EAClB,kBAAkB,EAInB,MAAM,qBAAqB,CAAA;AA6e5B,gBAAgB;AAChB,eAAO,MAAM,aAAa;;;;;;;;;;;4GAgDzB,CAAA;AAyBD,gBAAgB;AAChB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;oGAgBhC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;+DAS9B,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;qDAkB9B,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,kBAAkB;;;;;;;;;;;4HAI9B,CAAA"}
+{"version":3,"file":"snapshotDelta.d.ts","sourceRoot":"","sources":["../../src/internal/snapshotDelta.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAOvC,OAAO,EAAE,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,EAGL,KAAK,aAAa,EAClB,kBAAkB,EAInB,MAAM,qBAAqB,CAAA;AAmuB5B,gBAAgB;AAChB,eAAO,MAAM,aAAa;;;;;;;;;;;4GAgDzB,CAAA;AAyBD,gBAAgB;AAChB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;oGAoBhC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;+DAe9B,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;qDAkC9B,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,kBAAkB;;;;;;;;;;;4HAI9B,CAAA"}