create-next-hydra 0.3.0 → 0.4.2

package/dist/workspace-files.js

@@ -0,0 +1,395 @@
+import { createHash, randomUUID } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+import { Context, Effect, FileSystem, Layer, Path, Redacted } from "effect";
+import { MaterializationFailed, WorkspaceConflict, WorkspaceRecoveryRequired, } from "./errors.js";
+import { writeFile } from "./files.js";
+import { snapshotTarget } from "./workspace-snapshots.js";
+import { sameFingerprint as same } from "./workspace-state.js";
+const fingerprint = (content, mode) => ({
+    hash: createHash("sha256").update(content).digest("hex"),
+    mode,
+});
+function compareFile(previous, wanted, before, returning = false) {
+    const desired = wanted ? fingerprint(wanted.content, wanted.mode) : null;
+    const after = previous &&
+        same(desired, previous.desired) &&
+        same(before, previous.applied)
+        ? previous.applied
+        : desired;
+    let conflict = !same(before, desired);
+    if (!returning) {
+        // A clean checkout can already contain the committed generated task policy.
+        // Adopt only exact output; differing unowned files still require reconciliation.
+        conflict = previous
+            ? !same(before, previous.applied) && !same(before, after)
+            : before !== null &&
+                !(wanted?.target === "turbo.json" &&
+                    wanted.origin.kind === "policy" &&
+                    wanted.origin.policy === "application-tasks" &&
+                    same(before, desired));
+    }
+    return { after, conflict, desired };
+}
+export class WorkspaceFiles extends Context.Service()("create-next-hydra/WorkspaceFiles") {
+    static layer = Layer.effect(WorkspaceFiles, Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const observe = (directory, target) => Effect.gen(function* () {
+            const absolute = path.join(directory, target);
+            if (!(yield* fs.exists(absolute))) {
+                return null;
+            }
+            const stat = yield* fs.stat(absolute);
+            if (stat.type !== "File") {
+                return yield* new WorkspaceConflict({ paths: [target] });
+            }
+            return fingerprint(yield* fs.readFile(absolute), stat.mode % 0o1000);
+        }).pipe(Effect.uninterruptible);
+        const blockingAncestor = (directory, target, targets) => Effect.gen(function* () {
+            const parts = target.split("/");
+            for (let end = 1; end < parts.length; end += 1) {
+                const ancestor = parts.slice(0, end).join("/");
+                if (targets.has(ancestor) ||
+                    ((yield* fs.exists(path.join(directory, ancestor))) &&
+                        (yield* fs.stat(path.join(directory, ancestor))).type !==
+                            "Directory")) {
+                    return ancestor;
+                }
+            }
+            return null;
+        });
+        const read = Effect.fn("WorkspaceFiles.read")(function* (directory, targets) {
+            const files = [];
+            const conflicts = new Set();
+            for (const target of targets.filter(snapshotTarget)) {
+                const ancestor = yield* blockingAncestor(directory, target, new Set());
+                if (ancestor !== null) {
+                    conflicts.add(ancestor);
+                    continue;
+                }
+                const absolute = path.join(directory, target);
+                if (!(yield* fs.exists(absolute))) {
+                    continue;
+                }
+                const stat = yield* fs.stat(absolute);
+                if (stat.type !== "File") {
+                    conflicts.add(target);
+                    continue;
+                }
+                files.push({
+                    content: yield* fs.readFile(absolute),
+                    mode: stat.mode % 0o1000,
+                    target,
+                });
+            }
+            return { conflicts: [...conflicts], files };
+        });
+        const capture = Effect.fn("WorkspaceFiles.capture")(function* (directory, entries) {
+            const { files, conflicts } = yield* read(directory, entries.map((entry) => entry.target));
+            const observed = new Map(files.map((file) => [
+                file.target,
+                fingerprint(file.content, file.mode),
+            ]));
+            const changed = entries
+                .filter((entry) => snapshotTarget(entry.target) &&
+                !same(entry.applied, observed.get(entry.target) ?? null))
+                .map((entry) => entry.target);
+            if (conflicts.length || changed.length) {
+                return yield* new WorkspaceConflict({
+                    paths: [...new Set([...conflicts, ...changed])],
+                });
+            }
+            return files;
+        });
+        const preservation = Effect.fn("WorkspaceFiles.preservation")(function* (observation, files, preserve) {
+            const desired = new Map(files.map((file) => [file.target, file]));
+            const previouslyManaged = new Set(observation.entries.map((entry) => entry.target));
+            const handedOff = new Set(observation.preserved);
+            const preserved = preserve.filter((target) => desired.has(target) ||
+                previouslyManaged.has(target) ||
+                handedOff.has(target));
+            const initialization = [];
+            for (const target of preserved) {
+                // A completed handoff includes local deletions. Do not inspect these files again.
+                if (previouslyManaged.has(target) || handedOff.has(target)) {
+                    continue;
+                }
+                const ancestor = yield* blockingAncestor(observation.directory, target, new Set());
+                if (ancestor !== null) {
+                    return yield* new WorkspaceConflict({ paths: [ancestor] });
+                }
+                const absolute = path.join(observation.directory, target);
+                if (yield* fs.exists(absolute)) {
+                    if ((yield* fs.stat(absolute)).type !== "File") {
+                        return yield* new WorkspaceConflict({ paths: [target] });
+                    }
+                }
+                else {
+                    const file = desired.get(target);
+                    if (file) {
+                        initialization.push(file);
+                    }
+                }
+            }
+            return { initialization, preserved };
+        });
+        const inspect = Effect.fn("WorkspaceFiles.inspect")(function* (observation, files, preserve = []) {
+            const handoff = yield* preservation(observation, files, preserve);
+            const desired = new Map(files.map((file) => [file.target, file]));
+            const applied = new Map(observation.entries.map((entry) => [entry.target, entry]));
+            const changes = new Map();
+            const targets = new Set([
+                ...applied.keys(),
+                ...desired.keys(),
+                ...observation.preserved,
+            ]);
+            for (const target of targets) {
+                if (handoff.preserved.includes(target)) {
+                    if (!observation.preserved.includes(target)) {
+                        changes.set(target, {
+                            kind: handoff.initialization.some((file) => file.target === target)
+                                ? "create"
+                                : "record",
+                            target,
+                        });
+                    }
+                    continue;
+                }
+                if (observation.preserved.includes(target) && !desired.has(target)) {
+                    changes.set(target, { kind: "record", target });
+                    continue;
+                }
+                if (changes.get(target)?.kind === "conflict") {
+                    continue;
+                }
+                const ancestor = yield* blockingAncestor(observation.directory, target, targets);
+                if (ancestor !== null) {
+                    changes.set(ancestor, { kind: "conflict", target: ancestor });
+                    continue;
+                }
+                const before = yield* observe(observation.directory, target).pipe(Effect.catchTag("WorkspaceConflict", () => Effect.void));
+                if (before === undefined) {
+                    changes.set(target, { kind: "conflict", target });
+                    continue;
+                }
+                const previous = applied.get(target);
+                const { after, conflict, desired: wanted, } = compareFile(previous, desired.get(target), before, observation.preserved.includes(target));
+                if (conflict) {
+                    changes.set(target, {
+                        kind: previous || observation.preserved.includes(target)
+                            ? "conflict"
+                            : "unregistered",
+                        target,
+                    });
+                }
+                else if (!same(before, after)) {
+                    let kind = "update";
+                    if (after === null) {
+                        kind = "remove";
+                    }
+                    else if (before === null) {
+                        kind = "create";
+                    }
+                    changes.set(target, { kind, target });
+                }
+                else if (previous
+                    ? !same(previous.desired, wanted) ||
+                        !same(previous.applied, after) ||
+                        !isDeepStrictEqual(previous.origin, desired.get(target)?.origin)
+                    : wanted !== null) {
+                    changes.set(target, { kind: "record", target });
+                }
+            }
+            return [...changes.values()];
+        });
+        const recover = Effect.fn("WorkspaceFiles.recover")(function* (access) {
+            const observation = yield* access.observation;
+            const { pending } = observation;
+            if (pending === null) {
+                return;
+            }
+            if (pending.kind !== "files") {
+                return yield* new WorkspaceRecoveryRequired({
+                    directory: access.directory,
+                });
+            }
+            // Initial-only files become workspace-owned after creation. Never read or
+            // fingerprint credentials, or mistake an existing partial write for success.
+            for (const file of pending.initialization) {
+                const ancestor = yield* blockingAncestor(access.directory, file.target, new Set());
+                if (ancestor !== null) {
+                    return yield* new WorkspaceConflict({ paths: [ancestor] });
+                }
+                const absolute = path.join(access.directory, file.target);
+                if (!(yield* fs.exists(absolute))) {
+                    continue;
+                }
+                if (file.status === "started") {
+                    return yield* new WorkspaceRecoveryRequired({
+                        directory: access.directory,
+                        paths: [file.target],
+                    });
+                }
+                if ((yield* fs.stat(absolute)).type !== "File") {
+                    return yield* new WorkspaceConflict({ paths: [file.target] });
+                }
+            }
+            const observed = new Map();
+            const temporary = new Map();
+            const conflicts = [];
+            for (const file of pending.files) {
+                const ancestor = yield* blockingAncestor(access.directory, file.target, new Set());
+                if (ancestor !== null) {
+                    conflicts.push(ancestor);
+                    continue;
+                }
+                const current = yield* observe(access.directory, file.target);
+                observed.set(file.target, current);
+                if (!same(current, file.before) && !same(current, file.after)) {
+                    conflicts.push(file.target);
+                }
+                if (file.temporary !== null) {
+                    const saved = yield* observe(access.directory, file.temporary);
+                    if (saved !== null) {
+                        if (same(saved, file.after)) {
+                            temporary.set(file.temporary, saved);
+                        }
+                        else {
+                            conflicts.push(file.temporary);
+                        }
+                    }
+                }
+            }
+            if (conflicts.length > 0) {
+                return yield* new WorkspaceConflict({
+                    paths: [...new Set(conflicts)],
+                });
+            }
+            // No cleanup until every owned path and retained replacement is explained.
+            // A retry can repeat this after cleanup fails; the receipt still has intent.
+            for (const [target, expected] of temporary) {
+                yield* Effect.gen(function* () {
+                    if (!same(yield* observe(access.directory, target), expected)) {
+                        return yield* new WorkspaceConflict({ paths: [target] });
+                    }
+                    yield* fs.remove(path.join(access.directory, target));
+                }).pipe(Effect.uninterruptible);
+            }
+            for (const [target, expected] of observed) {
+                if (!same(yield* observe(access.directory, target), expected)) {
+                    return yield* new WorkspaceConflict({ paths: [target] });
+                }
+            }
+            yield* access.recoverFiles(observed, observation.revision);
+        });
+        const apply = Effect.fn("WorkspaceFiles.apply")(function* (access, files, initialization, preserve = []) {
+            const observation = yield* access.observation;
+            const handoff = yield* preservation(observation, files, preserve);
+            const desired = new Map(files.map((file) => [file.target, file]));
+            const applied = new Map((yield* access.appliedEntries).map((entry) => [entry.target, entry]));
+            const targets = new Set([...applied.keys(), ...desired.keys()]);
+            const operation = yield* Effect.sync(randomUUID);
+            const intent = [];
+            const conflicts = [];
+            for (const target of targets) {
+                if (handoff.preserved.includes(target)) {
+                    continue;
+                }
+                // File-to-directory transitions require a separate, explicitly designed
+                // operation. Never remove parents recursively during ordinary refresh.
+                const ancestor = yield* blockingAncestor(access.directory, target, targets);
+                if (ancestor !== null) {
+                    return yield* new WorkspaceConflict({ paths: [ancestor, target] });
+                }
+                const before = yield* observe(access.directory, target);
+                const wanted = desired.get(target);
+                const previous = applied.get(target);
+                const { after, conflict, desired: desiredFingerprint, } = compareFile(previous, wanted, before, observation.preserved.includes(target));
+                if (conflict) {
+                    conflicts.push(target);
+                }
+                const temporary = before !== null && after !== null && !same(before, after)
+                    ? `${target}.${operation}.pending`
+                    : null;
+                if (temporary !== null &&
+                    (targets.has(temporary) ||
+                        (yield* fs.exists(path.join(access.directory, temporary))))) {
+                    conflicts.push(temporary);
+                }
+                intent.push({
+                    after,
+                    before,
+                    desired: desiredFingerprint,
+                    origin: wanted?.origin ?? null,
+                    target,
+                    temporary,
+                });
+            }
+            if (conflicts.length) {
+                return yield* new WorkspaceConflict({ paths: conflicts });
+            }
+            // The entire before/after set, including unchanged files, is durable before
+            // the first application write. A failure leaves that intent for inspection.
+            yield* access.begin(intent, [
+                ...initialization,
+                ...handoff.initialization.map((file) => file.target),
+            ], handoff.preserved);
+            const completedFiles = [];
+            const removedFiles = [];
+            for (const item of intent) {
+                if (same(item.before, item.after)) {
+                    continue;
+                }
+                yield* Effect.gen(function* () {
+                    const file = desired.get(item.target);
+                    if (file && item.temporary) {
+                        yield* writeFile(access.directory, { ...file, target: item.temporary }, true);
+                    }
+                    if (!same(yield* observe(access.directory, item.target), item.before)) {
+                        return yield* new WorkspaceConflict({ paths: [item.target] });
+                    }
+                    if (!file) {
+                        yield* fs.remove(path.join(access.directory, item.target));
+                        removedFiles.push(item.target);
+                    }
+                    else if (item.temporary) {
+                        yield* fs.rename(path.join(access.directory, item.temporary), path.join(access.directory, item.target));
+                    }
+                    else {
+                        // Exclusive creation can leave a partial file on an I/O failure;
+                        // the pending receipt prevents a retry from adopting it as complete.
+                        yield* writeFile(access.directory, file, true);
+                    }
+                    completedFiles.push(item.target);
+                }).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path), Effect.uninterruptible, Effect.mapError((error) => new MaterializationFailed({
+                    completedFiles: [...completedFiles],
+                    diagnostic: Redacted.make(error),
+                    directory: access.directory,
+                    failedFile: item.target,
+                })));
+            }
+            for (const file of handoff.initialization) {
+                yield* access.initialize(file.target, writeFile(access.directory, file, true).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path), Effect.mapError((error) => new MaterializationFailed({
+                    completedFiles,
+                    diagnostic: Redacted.make(error),
+                    directory: access.directory,
+                    failedFile: file.target,
+                }))));
+            }
+            const complete = Effect.gen(function* () {
+                const changed = [];
+                for (const item of intent) {
+                    if (!same(yield* observe(access.directory, item.target), item.after)) {
+                        changed.push(item.target);
+                    }
+                }
+                if (changed.length) {
+                    return yield* new WorkspaceConflict({ paths: changed });
+                }
+                yield* access.complete;
+            });
+            return { complete, removedFiles };
+        });
+        return WorkspaceFiles.of({ apply, capture, inspect, read, recover });
+    }));
+}

package/dist/workspace-lock.d.ts

@@ -0,0 +1,12 @@
+import { Effect, FileSystem, Path, Ref } from "effect";
+import type { PlatformError } from "effect";
+import { WorkspaceLockAuthorizationRequired, WorkspaceLockChanged, WorkspaceRecoveryRequired, WorkspaceStateInvalid } from "./errors.ts";
+export interface WriteLock {
+    readonly writer: Ref.Ref<boolean>;
+    readonly recoveryEvidence: string | null;
+    readonly assertOwner: Effect.Effect<void, WorkspaceLockChanged | PlatformError.PlatformError>;
+}
+export declare const withWriteLock: <A, E, R>(directory: string, use: (lock: WriteLock) => Effect.Effect<A, E, R>, options?: {
+    readonly breakLock?: string;
+}) => Effect.Effect<A, WorkspaceLockAuthorizationRequired | WorkspaceLockChanged | WorkspaceRecoveryRequired | WorkspaceStateInvalid | PlatformError.PlatformError | E, FileSystem.FileSystem | Path.Path | R>;
+//# sourceMappingURL=workspace-lock.d.ts.map

package/dist/workspace-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-lock.d.ts","sourceRoot":"","sources":["../src/workspace-lock.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,MAAM,EACN,UAAU,EAEV,IAAI,EACJ,GAAG,EAEJ,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,OAAO,EACL,kCAAkC,EAClC,oBAAoB,EACpB,yBAAyB,EACzB,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAoBrB,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CACjC,IAAI,EACJ,oBAAoB,GAAG,aAAa,CAAC,aAAa,CACnD,CAAC;CACH;AAGD,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EACnC,WAAW,MAAM,EACjB,KAAK,CAAC,IAAI,EAAE,SAAS,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAChD,UAAU;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,6MA2HvC,CAAC"}

package/dist/workspace-lock.js

@@ -0,0 +1,104 @@
+import { createHash, randomUUID } from "node:crypto";
+import { Array as EffectArray, DateTime, Effect, FileSystem, Order, Path, Ref, Schema, } from "effect";
+import { WorkspaceLockAuthorizationRequired, WorkspaceLockChanged, WorkspaceRecoveryRequired, WorkspaceStateInvalid, } from "./errors.js";
+const LockOwner = Schema.fromJsonString(Schema.Struct({
+    operation: Schema.Literal("sync"),
+    pid: Schema.Int,
+    startedAt: Schema.String,
+    token: Schema.String,
+}));
+const LockObservation = Schema.fromJsonString(Schema.Struct({
+    candidate: Schema.NullOr(Schema.String),
+    directory: Schema.String,
+    names: Schema.Array(Schema.String),
+    ownerText: Schema.NullOr(Schema.String),
+    stored: Schema.NullOr(Schema.String),
+}));
+// Coordination only: acquiring this lock never creates a composition receipt.
+export const withWriteLock = (directory, use, options) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const lock = path.join(directory, ".workspace-composition.lock");
+    const ownerPath = path.join(lock, "owner.json");
+    const receiptPath = path.join(directory, ".workspace-composition.json");
+    const invalid = () => new WorkspaceStateInvalid({ directory });
+    const inspectLock = Effect.gen(function* () {
+        if (!(yield* fs.exists(lock))) {
+            return yield* new WorkspaceLockChanged({ directory });
+        }
+        const names = EffectArray.sort(yield* fs.readDirectory(lock), Order.String);
+        const ownerText = names.includes("owner.json") &&
+            (yield* fs.stat(ownerPath)).type === "File"
+            ? yield* fs.readFileString(ownerPath)
+            : null;
+        const owner = ownerText === null
+            ? null
+            : yield* Schema.decodeEffect(LockOwner)(ownerText).pipe(Effect.orElseSucceed(() => null));
+        const stored = (yield* fs.exists(receiptPath))
+            ? yield* fs.readFileString(receiptPath)
+            : null;
+        const candidatePath = path.join(lock, "receipt.json");
+        const candidate = names.includes("receipt.json") &&
+            (yield* fs.stat(candidatePath)).type === "File"
+            ? yield* fs.readFileString(candidatePath)
+            : null;
+        const token = createHash("sha256")
+            .update(yield* Schema.encodeEffect(LockObservation)({
+            candidate,
+            directory,
+            names,
+            ownerText,
+            stored,
+        }).pipe(Effect.mapError(invalid)))
+            .digest("hex");
+        return new WorkspaceLockAuthorizationRequired({
+            directory,
+            reason: owner === null
+                ? "another operation may be running; the lock has no readable owner"
+                : `process ${owner.pid} started ${owner.operation} at ${owner.startedAt} and may still be running`,
+            token,
+        });
+    });
+    const assertOwner = (owner) => Effect.gen(function* () {
+        const current = yield* fs.readFileString(ownerPath).pipe(Effect.catchIf((error) => error.reason._tag === "NotFound", () => Effect.succeed(null)));
+        if (current !== owner) {
+            return yield* new WorkspaceLockChanged({ directory });
+        }
+    });
+    return yield* Effect.acquireUseRelease(Effect.gen(function* () {
+        let recoveryEvidence = null;
+        if (options?.breakLock !== undefined) {
+            const observed = yield* inspectLock;
+            if (observed.token !== options.breakLock) {
+                return yield* new WorkspaceLockChanged({ directory });
+            }
+            const archive = path.join(directory, ".workspace-composition.recovery");
+            yield* fs.makeDirectory(archive, { mode: 0o700, recursive: true });
+            recoveryEvidence = path.join(archive, randomUUID());
+            yield* fs.rename(lock, recoveryEvidence);
+        }
+        yield* fs.makeDirectory(lock, { mode: 0o700 }).pipe(Effect.catchIf((error) => error.reason._tag === "AlreadyExists", () => inspectLock.pipe(Effect.flatMap(Effect.fail))));
+        const owner = yield* Schema.encodeEffect(LockOwner)({
+            operation: "sync",
+            pid: process.pid,
+            startedAt: DateTime.formatIso(yield* DateTime.now),
+            token: randomUUID(),
+        }).pipe(Effect.mapError(invalid));
+        yield* fs.writeFileString(ownerPath, owner, {
+            flag: "wx",
+            mode: 0o600,
+        });
+        return { owner, recoveryEvidence, writer: yield* Ref.make(false) };
+    }), (held) => use({
+        assertOwner: assertOwner(held.owner),
+        recoveryEvidence: held.recoveryEvidence,
+        writer: held.writer,
+    }), (held) => Effect.gen(function* () {
+        yield* assertOwner(held.owner);
+        if ((yield* Ref.get(held.writer)) ||
+            (yield* fs.readDirectory(lock)).some((name) => name !== "owner.json")) {
+            return yield* new WorkspaceRecoveryRequired({ directory });
+        }
+        yield* fs.remove(lock, { recursive: true });
+    }));
+});

package/dist/workspace-snapshots.d.ts

@@ -0,0 +1,24 @@
+import { Context, Effect, FileSystem, Layer, Path } from "effect";
+import type { PlatformError } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { SnapshotFailed, SnapshotUnavailable } from "./errors.ts";
+import type { PreparedFile } from "./model.ts";
+import type { WorkspaceIdentity } from "./workspace-state.ts";
+export declare const snapshotTarget: (target: string) => boolean;
+export type SnapshotError = SnapshotFailed | SnapshotUnavailable | PlatformError.PlatformError;
+export interface SnapshotDiff {
+    readonly changes: readonly {
+        readonly target: string;
+        readonly status: string;
+    }[];
+    readonly patch: string;
+}
+declare const WorkspaceSnapshots_base: Context.ServiceClass<WorkspaceSnapshots, "create-next-hydra/WorkspaceSnapshots", {
+    readonly capture: (identity: WorkspaceIdentity, files: readonly PreparedFile[], previous?: string) => Effect.Effect<string, SnapshotError>;
+    readonly diff: (identity: WorkspaceIdentity, commit: string, files: readonly PreparedFile[]) => Effect.Effect<SnapshotDiff, SnapshotError>;
+}>;
+export declare class WorkspaceSnapshots extends WorkspaceSnapshots_base {
+    static readonly layer: Layer.Layer<WorkspaceSnapshots, never, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
+}
+export {};
+//# sourceMappingURL=workspace-snapshots.d.ts.map

package/dist/workspace-snapshots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-snapshots.d.ts","sourceRoot":"","sources":["../src/workspace-snapshots.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,OAAO,EACP,MAAM,EACN,UAAU,EACV,KAAK,EACL,IAAI,EAGL,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EAAgB,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE5E,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGlE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,eAAO,MAAM,cAAc,GAAI,QAAQ,MAAM,KAAG,OAU3C,CAAC;AAEN,MAAM,MAAM,aAAa,GACrB,cAAc,GACd,mBAAmB,GACnB,aAAa,CAAC,aAAa,CAAC;AAChC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS;QACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB,EAAE,CAAC;IACJ,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;;sBAKqB,CAChB,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,QAAQ,CAAC,EAAE,MAAM,KACd,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;mBAC1B,CACb,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,YAAY,EAAE,KAC3B,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,aAAa,CAAC;;AAZnD,qBAAa,kBAAmB,SAAQ,uBAcG;IACzC,MAAM,CAAC,QAAQ,CAAC,KAAK,sHA0SnB;CACH"}