create-next-hydra 0.2.1 → 0.4.1

package/dist/workspace-snapshots.js

@@ -0,0 +1,218 @@
+import { createHash } from "node:crypto";
+import { Context, Effect, FileSystem, Layer, Path, Schema, Stream, } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { SnapshotFailed, SnapshotUnavailable } from "./errors.js";
+import { cacheDirectories, isEnvironmentFile } from "./file-policy.js";
+import { relativeFile, writeFile } from "./files.js";
+export const snapshotTarget = (target) => !target
+    .split("/")
+    .some((part) => cacheDirectories.has(part) ||
+    isEnvironmentFile(part) ||
+    [".git", ".npmrc", ".netrc", ".ssh", ".aws", ".azure"].includes(part) ||
+    /\.(?:pem|key|p12|pfx|keystore|tsbuildinfo)$/iu.test(part) ||
+    /^id_(?:rsa|ed25519|ecdsa)(?:\.|$)/u.test(part));
+export class WorkspaceSnapshots extends Context.Service()("create-next-hydra/WorkspaceSnapshots") {
+    static layer = Layer.effect(WorkspaceSnapshots, Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const processes = yield* ChildProcessSpawner.ChildProcessSpawner;
+        const directoryFor = (identity) => path.join(identity.sourceRoot, ".cache", "workspace-snapshots", `${createHash("sha256").update(path.resolve(identity.directory)).digest("hex")}.git`);
+        const use = (identity, operation, callback) => Effect.scoped(Effect.gen(function* () {
+            const temporary = yield* Effect.acquireRelease(fs.makeTempDirectory({ prefix: "composition-snapshot-" }), (directory) => fs.remove(directory, { recursive: true }).pipe(Effect.orDie));
+            const tree = path.join(temporary, "tree");
+            yield* fs.makeDirectory(tree).pipe(Effect.uninterruptible);
+            const repository = directoryFor(identity);
+            // Private Git commands must never inherit an index, object store or config
+            // selected by the maintainer's shell/hooks. No live workspace is staged.
+            const env = Object.fromEntries(Object.entries(process.env).filter(([name]) => !name.startsWith("GIT_")));
+            Object.assign(env, {
+                GIT_ATTR_NOSYSTEM: "1",
+                GIT_CONFIG_GLOBAL: "/dev/null",
+                GIT_CONFIG_NOSYSTEM: "1",
+                GIT_INDEX_FILE: path.join(temporary, "index"),
+                GIT_OPTIONAL_LOCKS: "0",
+            });
+            if (operation === "diff") {
+                const objects = path.join(temporary, "objects");
+                yield* fs.makeDirectory(objects).pipe(Effect.uninterruptible);
+                // Intent-to-add may create an empty blob. Keep all inspection writes in
+                // disposable storage; read saved objects through an explicit alternate.
+                Object.assign(env, {
+                    GIT_ALTERNATE_OBJECT_DIRECTORIES: yield* Schema.encodeEffect(Schema.fromJsonString(Schema.String))(path.join(repository, "objects")).pipe(Effect.mapError(() => new SnapshotFailed({
+                        directory: identity.directory,
+                        operation,
+                    }))),
+                    GIT_OBJECT_DIRECTORY: objects,
+                });
+            }
+            const git = (args) => Effect.scoped(Effect.gen(function* () {
+                const handle = yield* processes.spawn(ChildProcess.make("git", [
+                    `--git-dir=${repository}`,
+                    ...(args[0] === "init" ? [] : [`--work-tree=${tree}`]),
+                    "--literal-pathspecs",
+                    "-c",
+                    "core.hooksPath=/dev/null",
+                    "-c",
+                    "core.attributesFile=/dev/null",
+                    "-c",
+                    "core.autocrlf=false",
+                    "-c",
+                    "core.fileMode=true",
+                    "-c",
+                    "core.fsmonitor=false",
+                    "-c",
+                    "commit.gpgsign=false",
+                    "-c",
+                    "user.name=Workspace composition",
+                    "-c",
+                    "user.email=workspace@localhost",
+                    ...args,
+                ], { cwd: tree, env, stderr: "ignore", stdin: "ignore" }));
+                const [output, code] = yield* Effect.all([
+                    Stream.mkString(Stream.decodeText(handle.stdout)),
+                    handle.exitCode,
+                ], { concurrency: "unbounded" });
+                if (code !== 0) {
+                    return yield* new SnapshotFailed({
+                        directory: identity.directory,
+                        operation,
+                    });
+                }
+                return output;
+            })).pipe(Effect.mapError(() => new SnapshotFailed({
+                directory: identity.directory,
+                operation: `${operation}:${args[0]}`,
+            })), Effect.uninterruptible);
+            return yield* callback({ git, repository, tree });
+        }));
+        const populate = (tree, files) => Effect.gen(function* () {
+            for (const file of files) {
+                if (snapshotTarget(file.target)) {
+                    yield* writeFile(tree, file, true);
+                }
+            }
+        }).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
+        const capture = Effect.fn("WorkspaceSnapshots.capture")(function* (identity, files, previous) {
+            return yield* use(identity, "capture", ({ git, repository, tree }) => Effect.gen(function* () {
+                yield* fs
+                    .makeDirectory(repository, { mode: 0o700, recursive: true })
+                    .pipe(Effect.uninterruptible);
+                yield* git([
+                    "init",
+                    "--bare",
+                    "--template=",
+                    "--object-format=sha1",
+                    "--initial-branch=composition",
+                    repository,
+                ]);
+                yield* fs
+                    .makeDirectory(path.join(repository, "info"), { recursive: true })
+                    .pipe(Effect.uninterruptible);
+                yield* fs
+                    .writeFileString(path.join(repository, "info/attributes"), "* -text -filter -ident -working-tree-encoding !diff\n")
+                    .pipe(Effect.uninterruptible);
+                yield* populate(tree, files).pipe(Effect.mapError(() => new SnapshotFailed({
+                    directory: identity.directory,
+                    operation: "capture",
+                })));
+                yield* git(["read-tree", "--empty"]);
+                yield* git(["add", "--force", "--all", "--", "."]);
+                const treeId = (yield* git(["write-tree"])).trim();
+                const previousTree = previous
+                    ? yield* git([
+                        "rev-parse",
+                        "--verify",
+                        `${previous}^{tree}`,
+                    ]).pipe(Effect.map((value) => value.trim()), Effect.orElseSucceed(() => null))
+                    : null;
+                const commit = previous && previousTree === treeId
+                    ? previous
+                    : (yield* git([
+                        "commit-tree",
+                        treeId,
+                        "-m",
+                        "Compose workspace",
+                    ])).trim();
+                if (!/^[a-f0-9]{40}$/u.test(commit)) {
+                    return yield* new SnapshotFailed({
+                        directory: identity.directory,
+                        operation: "capture",
+                    });
+                }
+                // Each checkpoint stays reachable, including the old receipt's commit
+                // if publishing a newer receipt fails. HEAD is never baseline authority.
+                yield* git(["update-ref", `refs/snapshots/${commit}`, commit]);
+                return commit;
+            }));
+        });
+        const diff = Effect.fn("WorkspaceSnapshots.diff")(function* (identity, commit, files) {
+            if (!(yield* fs.exists(path.join(directoryFor(identity), "HEAD")))) {
+                return yield* new SnapshotUnavailable({
+                    directory: identity.directory,
+                });
+            }
+            return yield* use(identity, "diff", ({ git, tree }) => Effect.gen(function* () {
+                const saved = yield* git([
+                    "ls-tree",
+                    "--name-only",
+                    "-rz",
+                    commit,
+                ]).pipe(Effect.mapError(() => new SnapshotUnavailable({ directory: identity.directory })));
+                const targets = new Set(saved.split("\0").filter(Boolean));
+                for (const target of targets) {
+                    if (!snapshotTarget(target) ||
+                        (yield* relativeFile(target).pipe(Effect.orElseSucceed(() => ""))) !== target) {
+                        return yield* new SnapshotUnavailable({
+                            directory: identity.directory,
+                        });
+                    }
+                }
+                yield* populate(tree, files).pipe(Effect.mapError(() => new SnapshotFailed({
+                    directory: identity.directory,
+                    operation: "diff",
+                })));
+                yield* git(["read-tree", commit]);
+                for (const file of files) {
+                    if (snapshotTarget(file.target) && !targets.has(file.target)) {
+                        yield* git([
+                            "add",
+                            "--intent-to-add",
+                            "--force",
+                            "--",
+                            file.target,
+                        ]);
+                    }
+                }
+                const flags = [
+                    "--no-ext-diff",
+                    "--no-textconv",
+                    "--no-renames",
+                    "--no-color",
+                    "--src-prefix=a/",
+                    "--dst-prefix=b/",
+                ];
+                const names = (yield* git([
+                    "diff",
+                    ...flags,
+                    "--name-status",
+                    "-z",
+                    commit,
+                    "--",
+                ])).split("\0");
+                const changes = [];
+                for (let index = 0; index + 1 < names.length; index += 2) {
+                    const target = names[index + 1];
+                    const status = names[index];
+                    if (target && status) {
+                        changes.push({ status, target });
+                    }
+                }
+                return {
+                    changes,
+                    patch: yield* git(["diff", ...flags, commit, "--"]),
+                };
+            }));
+        });
+        return WorkspaceSnapshots.of({ capture, diff });
+    }));
+}

package/dist/workspace-sources.d.ts

@@ -0,0 +1,27 @@
+import { Context, Effect, FileSystem, Layer, Path } from "effect";
+import type { PlatformError, Scope } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { SourceAcquisitionFailed, SourceStorageRetained } from "./errors.ts";
+export interface WorkingTree {
+    readonly kind: "working-tree";
+    readonly root: string;
+}
+export type SourceRequest = WorkingTree | {
+    readonly kind: "repository";
+    readonly repository: string;
+    readonly ref?: string;
+};
+export type WorkspaceSource = WorkingTree | {
+    readonly kind: "repository";
+    readonly root: string;
+    readonly commit: string;
+};
+export type SourceError = PlatformError.PlatformError | SourceAcquisitionFailed | SourceStorageRetained;
+declare const WorkspaceSources_base: Context.ServiceClass<WorkspaceSources, "create-next-hydra/WorkspaceSources", {
+    readonly use: <A, E, R>(request: SourceRequest, use: (source: WorkspaceSource) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | SourceError, Exclude<R, Scope.Scope>>;
+}>;
+export declare class WorkspaceSources extends WorkspaceSources_base {
+    static readonly layer: Layer.Layer<WorkspaceSources, never, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
+}
+export {};
+//# sourceMappingURL=workspace-sources.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-sources.d.ts","sourceRoot":"","sources":["../src/workspace-sources.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,MAAM,EACN,UAAU,EACV,KAAK,EACL,IAAI,EAIL,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACnD,OAAO,EAAgB,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE5E,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAG7E,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,aAAa,GACrB,WAAW,GACX;IACE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AACN,MAAM,MAAM,eAAe,GACvB,WAAW,GACX;IACE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AACN,MAAM,MAAM,WAAW,GACnB,aAAa,CAAC,aAAa,GAC3B,uBAAuB,GACvB,qBAAqB,CAAC;;kBAKR,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACpB,OAAO,EAAE,aAAa,EACtB,GAAG,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KACrD,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;;AANnE,qBAAa,gBAAiB,SAAQ,qBAQG;IACvC,MAAM,CAAC,QAAQ,CAAC,KAAK,oHAoJnB;CACH"}

package/dist/workspace-sources.js

@@ -0,0 +1,88 @@
+import { Context, Effect, FileSystem, Layer, Path, Redacted, Ref, Stream, } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { SourceAcquisitionFailed, SourceStorageRetained } from "./errors.js";
+import { confirmStopped } from "./process-group.js";
+export class WorkspaceSources extends Context.Service()("create-next-hydra/WorkspaceSources") {
+    static layer = Layer.effect(WorkspaceSources, Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const processes = yield* ChildProcessSpawner.ChildProcessSpawner;
+        return WorkspaceSources.of({
+            use: (request, use) => Effect.gen(function* () {
+                if (request.kind === "working-tree") {
+                    const root = path.resolve(request.root);
+                    yield* fs.access(root);
+                    return yield* Effect.scoped(use({ kind: "working-tree", root }));
+                }
+                if (process.platform === "win32" || request.ref?.startsWith("-")) {
+                    return yield* new SourceAcquisitionFailed({
+                        diagnostic: Redacted.make("Unsupported platform or revision"),
+                        phase: "validation",
+                    });
+                }
+                return yield* Effect.acquireUseRelease(Effect.gen(function* () {
+                    const directory = yield* fs.makeTempDirectory({
+                        prefix: "hydra-source-",
+                    });
+                    return { active: yield* Ref.make(false), directory };
+                }), (storage) => Effect.gen(function* () {
+                    const root = path.join(storage.directory, "checkout");
+                    const git = Effect.fn("WorkspaceSources.git")((phase, args, cwd) => Effect.scoped(Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+                        yield* Ref.set(storage.active, true);
+                        const handle = yield* processes
+                            .spawn(ChildProcess.make("git", args, {
+                            cwd,
+                            forceKillAfter: "100 millis",
+                            stderr: "ignore",
+                            stdin: "ignore",
+                        }))
+                            .pipe(Effect.tapError(() => Ref.set(storage.active, false)), Effect.mapError((error) => new SourceAcquisitionFailed({
+                            diagnostic: Redacted.make(error),
+                            phase,
+                        })));
+                        return yield* restore(Effect.gen(function* () {
+                            const [output, code] = yield* Effect.all([
+                                Stream.mkString(Stream.decodeText(handle.stdout)),
+                                handle.exitCode,
+                            ], { concurrency: "unbounded" });
+                            if (code !== 0) {
+                                return yield* new SourceAcquisitionFailed({
+                                    diagnostic: Redacted.make({
+                                        exitCode: code,
+                                    }),
+                                    phase,
+                                });
+                            }
+                            return output.trim();
+                        })).pipe(Effect.mapError((error) => new SourceAcquisitionFailed({
+                            diagnostic: Redacted.make(error),
+                            phase,
+                        })), Effect.onExit(() => confirmStopped(handle).pipe(Effect.mapError((error) => new SourceAcquisitionFailed({
+                            diagnostic: Redacted.make(error),
+                            phase: "stop",
+                        })), Effect.andThen(Ref.set(storage.active, false)), Effect.onExit(() => handle.unref.pipe(Effect.asVoid)))));
+                    }))));
+                    yield* git("clone", [
+                        "clone",
+                        ...(request.ref ? [] : ["--depth", "1"]),
+                        "--",
+                        request.repository,
+                        root,
+                    ], storage.directory);
+                    if (request.ref) {
+                        yield* git("checkout", ["checkout", "--detach", request.ref], root);
+                    }
+                    const commit = yield* git("revision", ["rev-parse", "HEAD"], root);
+                    return yield* Effect.scoped(use({ commit, kind: "repository", root }));
+                }), (storage) => Effect.gen(function* () {
+                    if (yield* Ref.get(storage.active)) {
+                        return yield* new SourceStorageRetained({
+                            directory: storage.directory,
+                        });
+                    }
+                    yield* fs.remove(storage.directory, { recursive: true });
+                }));
+            }),
+        });
+    }));
+}

package/dist/workspace-state.d.ts

@@ -0,0 +1,325 @@
+import { Context, Effect, FileSystem, Layer, Path, Schema } from "effect";
+import type { PlatformError } from "effect";
+import type { WorkspaceLockAuthorizationRequired, WorkspaceLockChanged } from "./errors.ts";
+import { WorkspaceBusy, WorkspaceRecoveryRequired, WorkspaceStateInvalid } from "./errors.ts";
+declare const Fingerprint: Schema.Struct<{
+    readonly hash: Schema.String;
+    readonly mode: Schema.Int;
+}>;
+export type Fingerprint = typeof Fingerprint.Type;
+export declare const sameFingerprint: (left: Fingerprint | null, right: Fingerprint | null) => boolean;
+declare const Intent: Schema.Struct<{
+    readonly after: Schema.NullOr<Schema.Struct<{
+        readonly hash: Schema.String;
+        readonly mode: Schema.Int;
+    }>>;
+    readonly before: Schema.NullOr<Schema.Struct<{
+        readonly hash: Schema.String;
+        readonly mode: Schema.Int;
+    }>>;
+    readonly desired: Schema.NullOr<Schema.Struct<{
+        readonly hash: Schema.String;
+        readonly mode: Schema.Int;
+    }>>;
+    readonly origin: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"registry">;
+        readonly owner: Schema.String;
+        readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"workspace-setting">;
+        readonly source: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"source">;
+        readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+        readonly owner: Schema.NullOr<Schema.String>;
+        readonly source: Schema.String;
+    }>, Schema.Struct<{
+        readonly bindings: Schema.$Array<Schema.Struct<{
+            readonly owner: Schema.String;
+            readonly as: Schema.optionalKey<Schema.String>;
+            readonly export: Schema.String;
+            readonly module: Schema.NonEmptyString;
+            readonly order: Schema.optionalKey<Schema.Int>;
+            readonly slot: Schema.NonEmptyString;
+            readonly target: Schema.NonEmptyString;
+        }>>;
+        readonly kind: Schema.Literal<"template">;
+        readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+        readonly owner: Schema.String;
+        readonly source: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"policy">;
+        readonly policy: Schema.Literals<readonly ["application-manifest", "workspace-settings", "lockfile-seed", "application-tasks", "application-ignore"]>;
+        readonly sources: Schema.$Array<Schema.String>;
+    }>]>>;
+    readonly target: Schema.String;
+    readonly temporary: Schema.NullOr<Schema.String>;
+}>;
+export type FileIntent = typeof Intent.Type;
+declare const Installation: Schema.Struct<{
+    readonly inputs: Schema.String;
+    readonly lockfile: Schema.Struct<{
+        readonly hash: Schema.String;
+        readonly mode: Schema.Int;
+    }>;
+    readonly modules: Schema.Struct<{
+        readonly hash: Schema.String;
+        readonly mode: Schema.Int;
+    }>;
+    readonly toolchain: Schema.String;
+    readonly virtualLock: Schema.Struct<{
+        readonly hash: Schema.String;
+        readonly mode: Schema.Int;
+    }>;
+}>;
+declare const Snapshot: Schema.Struct<{
+    readonly commit: Schema.String;
+    readonly filesRevision: Schema.Int;
+    readonly origins: Schema.$Array<Schema.Struct<{
+        readonly origin: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"registry">;
+            readonly owner: Schema.String;
+            readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"workspace-setting">;
+            readonly source: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"source">;
+            readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+            readonly owner: Schema.NullOr<Schema.String>;
+            readonly source: Schema.String;
+        }>, Schema.Struct<{
+            readonly bindings: Schema.$Array<Schema.Struct<{
+                readonly owner: Schema.String;
+                readonly as: Schema.optionalKey<Schema.String>;
+                readonly export: Schema.String;
+                readonly module: Schema.NonEmptyString;
+                readonly order: Schema.optionalKey<Schema.Int>;
+                readonly slot: Schema.NonEmptyString;
+                readonly target: Schema.NonEmptyString;
+            }>>;
+            readonly kind: Schema.Literal<"template">;
+            readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+            readonly owner: Schema.String;
+            readonly source: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"policy">;
+            readonly policy: Schema.Literals<readonly ["application-manifest", "workspace-settings", "lockfile-seed", "application-tasks", "application-ignore"]>;
+            readonly sources: Schema.$Array<Schema.String>;
+        }>]>;
+        readonly target: Schema.String;
+    }>>;
+    readonly revision: Schema.Int;
+}>;
+export type Installation = typeof Installation.Type;
+declare const Receipt: Schema.Struct<{
+    readonly directory: Schema.String;
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly applied: Schema.Struct<{
+            readonly hash: Schema.String;
+            readonly mode: Schema.Int;
+        }>;
+        readonly desired: Schema.Struct<{
+            readonly hash: Schema.String;
+            readonly mode: Schema.Int;
+        }>;
+        readonly origin: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"registry">;
+            readonly owner: Schema.String;
+            readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"workspace-setting">;
+            readonly source: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"source">;
+            readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+            readonly owner: Schema.NullOr<Schema.String>;
+            readonly source: Schema.String;
+        }>, Schema.Struct<{
+            readonly bindings: Schema.$Array<Schema.Struct<{
+                readonly owner: Schema.String;
+                readonly as: Schema.optionalKey<Schema.String>;
+                readonly export: Schema.String;
+                readonly module: Schema.NonEmptyString;
+                readonly order: Schema.optionalKey<Schema.Int>;
+                readonly slot: Schema.NonEmptyString;
+                readonly target: Schema.NonEmptyString;
+            }>>;
+            readonly kind: Schema.Literal<"template">;
+            readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+            readonly owner: Schema.String;
+            readonly source: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"policy">;
+            readonly policy: Schema.Literals<readonly ["application-manifest", "workspace-settings", "lockfile-seed", "application-tasks", "application-ignore"]>;
+            readonly sources: Schema.$Array<Schema.String>;
+        }>]>;
+        readonly target: Schema.String;
+    }>>;
+    readonly filesRevision: Schema.Int;
+    readonly format: Schema.Literal<"effect-workspace">;
+    readonly installation: Schema.NullOr<Schema.Struct<{
+        readonly inputs: Schema.String;
+        readonly lockfile: Schema.Struct<{
+            readonly hash: Schema.String;
+            readonly mode: Schema.Int;
+        }>;
+        readonly modules: Schema.Struct<{
+            readonly hash: Schema.String;
+            readonly mode: Schema.Int;
+        }>;
+        readonly toolchain: Schema.String;
+        readonly virtualLock: Schema.Struct<{
+            readonly hash: Schema.String;
+            readonly mode: Schema.Int;
+        }>;
+    }>>;
+    readonly pending: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+        readonly files: Schema.$Array<Schema.Struct<{
+            readonly after: Schema.NullOr<Schema.Struct<{
+                readonly hash: Schema.String;
+                readonly mode: Schema.Int;
+            }>>;
+            readonly before: Schema.NullOr<Schema.Struct<{
+                readonly hash: Schema.String;
+                readonly mode: Schema.Int;
+            }>>;
+            readonly desired: Schema.NullOr<Schema.Struct<{
+                readonly hash: Schema.String;
+                readonly mode: Schema.Int;
+            }>>;
+            readonly origin: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"registry">;
+                readonly owner: Schema.String;
+                readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"workspace-setting">;
+                readonly source: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"source">;
+                readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+                readonly owner: Schema.NullOr<Schema.String>;
+                readonly source: Schema.String;
+            }>, Schema.Struct<{
+                readonly bindings: Schema.$Array<Schema.Struct<{
+                    readonly owner: Schema.String;
+                    readonly as: Schema.optionalKey<Schema.String>;
+                    readonly export: Schema.String;
+                    readonly module: Schema.NonEmptyString;
+                    readonly order: Schema.optionalKey<Schema.Int>;
+                    readonly slot: Schema.NonEmptyString;
+                    readonly target: Schema.NonEmptyString;
+                }>>;
+                readonly kind: Schema.Literal<"template">;
+                readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+                readonly owner: Schema.String;
+                readonly source: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"policy">;
+                readonly policy: Schema.Literals<readonly ["application-manifest", "workspace-settings", "lockfile-seed", "application-tasks", "application-ignore"]>;
+                readonly sources: Schema.$Array<Schema.String>;
+            }>]>>;
+            readonly target: Schema.String;
+            readonly temporary: Schema.NullOr<Schema.String>;
+        }>>;
+        readonly initialization: Schema.$Array<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["planned", "started", "completed"]>;
+            readonly target: Schema.String;
+        }>>;
+        readonly kind: Schema.Literal<"files">;
+        readonly preserved: Schema.withDecodingDefaultKey<Schema.$Array<Schema.String>, never>;
+    }>, Schema.Struct<{
+        readonly inputs: Schema.String;
+        readonly kind: Schema.Literal<"installation">;
+        readonly stopped: Schema.Boolean;
+    }>]>>;
+    readonly preserved: Schema.withDecodingDefaultKey<Schema.$Array<Schema.String>, never>;
+    readonly revision: Schema.Int;
+    readonly snapshot: Schema.NullOr<Schema.Struct<{
+        readonly commit: Schema.String;
+        readonly filesRevision: Schema.Int;
+        readonly origins: Schema.$Array<Schema.Struct<{
+            readonly origin: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"registry">;
+                readonly owner: Schema.String;
+                readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"workspace-setting">;
+                readonly source: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"source">;
+                readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+                readonly owner: Schema.NullOr<Schema.String>;
+                readonly source: Schema.String;
+            }>, Schema.Struct<{
+                readonly bindings: Schema.$Array<Schema.Struct<{
+                    readonly owner: Schema.String;
+                    readonly as: Schema.optionalKey<Schema.String>;
+                    readonly export: Schema.String;
+                    readonly module: Schema.NonEmptyString;
+                    readonly order: Schema.optionalKey<Schema.Int>;
+                    readonly slot: Schema.NonEmptyString;
+                    readonly target: Schema.NonEmptyString;
+                }>>;
+                readonly kind: Schema.Literal<"template">;
+                readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+                readonly owner: Schema.String;
+                readonly source: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"policy">;
+                readonly policy: Schema.Literals<readonly ["application-manifest", "workspace-settings", "lockfile-seed", "application-tasks", "application-ignore"]>;
+                readonly sources: Schema.$Array<Schema.String>;
+            }>]>;
+            readonly target: Schema.String;
+        }>>;
+        readonly revision: Schema.Int;
+    }>>;
+    readonly sourceRoot: Schema.String;
+    readonly version: Schema.Literal<1>;
+}>;
+type Receipt = typeof Receipt.Type;
+export type WorkspaceStateError = WorkspaceLockAuthorizationRequired | WorkspaceLockChanged | PlatformError.PlatformError | WorkspaceStateInvalid | WorkspaceRecoveryRequired | WorkspaceBusy;
+export interface WorkspaceIdentity {
+    readonly directory: string;
+    readonly sourceRoot: string;
+}
+export interface WorkspaceObservation {
+    readonly directory: string;
+    readonly initialized: boolean;
+    readonly entries: Receipt["entries"];
+    readonly installation: Installation | null;
+    readonly snapshot: typeof Snapshot.Type | null;
+    readonly revision: number;
+    readonly filesRevision: number;
+    readonly pending: Receipt["pending"];
+    readonly preserved: readonly string[];
+}
+export interface WorkspaceWriteAccess {
+    readonly recoveryEvidence: string | null;
+    readonly directory: string;
+    readonly observation: Effect.Effect<WorkspaceObservation>;
+    readonly recoverFiles: (observed: ReadonlyMap<string, Fingerprint | null>, expectedRevision: number) => Effect.Effect<void, WorkspaceStateError>;
+    readonly publishSnapshot: (commit: string, expectedRevision: number) => Effect.Effect<void, WorkspaceStateError>;
+    readonly begin: (files: readonly FileIntent[], initialization: readonly string[], preserved?: readonly string[]) => Effect.Effect<void, WorkspaceStateError>;
+    readonly complete: Effect.Effect<void, WorkspaceStateError>;
+    readonly initialize: <A, E, R>(target: string, write: Effect.Effect<A, E, R>) => Effect.Effect<A, E | WorkspaceStateError, R>;
+    readonly installation: Effect.Effect<Installation | null>;
+    readonly appliedEntries: Effect.Effect<Receipt["entries"]>;
+    readonly beginInstall: (inputs: string) => Effect.Effect<void, WorkspaceStateError>;
+    readonly installStopped: Effect.Effect<void, WorkspaceStateError>;
+    readonly recoverInstall: (expectedRevision: number) => Effect.Effect<void, WorkspaceStateError>;
+    readonly finishInstall: (evidence: Installation | null, lockfile: Fingerprint) => Effect.Effect<void, WorkspaceStateError>;
+}
+declare const WorkspaceState_base: Context.ServiceClass<WorkspaceState, "create-next-hydra/WorkspaceState", {
+    readonly withRead: <A, E, R>(identity: WorkspaceIdentity, use: (observation: WorkspaceObservation) => Effect.Effect<A, E, R>, options?: {
+        readonly allowIncomplete: boolean;
+    }) => Effect.Effect<A, E | WorkspaceStateError, R>;
+    readonly withWrite: <A, E, R>(identity: WorkspaceIdentity, use: (access: WorkspaceWriteAccess) => Effect.Effect<A, E, R>, options?: {
+        readonly breakLock?: string;
+    }) => Effect.Effect<A, E | WorkspaceStateError, R>;
+}>;
+export declare class WorkspaceState extends WorkspaceState_base {
+    static readonly layer: Layer.Layer<WorkspaceState, never, FileSystem.FileSystem | Path.Path>;
+}
+export {};
+//# sourceMappingURL=workspace-state.d.ts.map