create-next-hydra 0.3.0 → 0.4.2

package/dist/typescript-paths.js

@@ -0,0 +1,52 @@
+import { Effect, FileSystem, Path, Schema } from "effect";
+import { applyEdits, modify, parse } from "jsonc-parser";
+import { InvalidComposition } from "./errors.js";
+const Config = Schema.Struct({
+    compilerOptions: Schema.optionalKey(Schema.Struct({
+        baseUrl: Schema.optionalKey(Schema.String),
+        paths: Schema.optionalKey(Schema.Record(Schema.String, Schema.Array(Schema.String))),
+    })),
+});
+export const applyTypeScriptAliases = Effect.fn("Composition.applyTypeScriptAliases")(function* (root, aliases, ownedAliases) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    for (const cwd of new Set([...ownedAliases, ...aliases].map((alias) => alias.cwd))) {
+        const filename = path.join(root, cwd, "tsconfig.json");
+        const desired = aliases.filter((entry) => entry.cwd === cwd);
+        if (desired.length === 0 && !(yield* fs.exists(filename))) {
+            continue;
+        }
+        let text = yield* fs.readFileString(filename);
+        const errors = [];
+        const data = parse(text, errors, { allowTrailingComma: true });
+        if (errors.length) {
+            return yield* new InvalidComposition({
+                message: `Invalid TypeScript configuration: ${cwd}/tsconfig.json`,
+            });
+        }
+        const config = yield* Schema.decodeUnknownEffect(Config)(data);
+        const consumer = path.join(root, cwd, config.compilerOptions?.baseUrl ?? ".");
+        const updates = new Map();
+        for (const alias of ownedAliases.filter((entry) => entry.cwd === cwd)) {
+            updates.set(alias.alias, undefined);
+            updates.set(`${alias.alias}/*`, undefined);
+        }
+        for (const alias of desired) {
+            const relative = path
+                .relative(consumer, path.join(root, alias.sourcePath))
+                .split(path.sep)
+                .join("/");
+            const target = relative.startsWith(".") ? relative : `./${relative}`;
+            updates.set(alias.alias, [target]);
+            if (!/\.[cm]?[jt]sx?$/u.test(alias.sourcePath)) {
+                updates.set(`${alias.alias}/*`, [`${target}/*`]);
+            }
+        }
+        for (const [name, value] of updates) {
+            text = applyEdits(text, modify(text, ["compilerOptions", "paths", name], value, {
+                formattingOptions: { insertSpaces: true, tabSize: 2 },
+            }));
+        }
+        yield* fs.writeFileString(filename, text).pipe(Effect.uninterruptible);
+    }
+});

package/dist/workspace-dependencies.d.ts

@@ -0,0 +1,26 @@
+import { Context, Effect, FileSystem, Layer, Path } from "effect";
+import type { PlatformError } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { DependencyInstallationFailed, WorkspaceConflict } from "./errors.ts";
+import type { PreparedFile } from "./model.ts";
+import type { WorkspaceStateError, WorkspaceWriteAccess, WorkspaceObservation } from "./workspace-state.ts";
+export interface DependencyOptions {
+    readonly install?: "install" | "skip";
+    readonly offline?: boolean;
+}
+export type DependencyError = DependencyInstallationFailed | WorkspaceConflict | PlatformError.PlatformError | WorkspaceStateError;
+export interface DependencyOutcome {
+    readonly dependencies: "pending" | "current";
+    readonly dependencyReasons: readonly string[];
+}
+declare const WorkspaceDependencies_base: Context.ServiceClass<WorkspaceDependencies, "create-next-hydra/WorkspaceDependencies", {
+    readonly install: (directory: string) => Effect.Effect<void, DependencyInstallationFailed>;
+    readonly recover: (access: WorkspaceWriteAccess) => Effect.Effect<void, DependencyError>;
+    readonly inspect: (observation: Pick<WorkspaceObservation, "directory" | "entries" | "installation">, files: readonly PreparedFile[], options: Pick<DependencyOptions, "offline">) => Effect.Effect<DependencyOutcome, DependencyError>;
+    readonly reconcile: (directory: string, files: readonly PreparedFile[], options: DependencyOptions, access?: WorkspaceWriteAccess) => Effect.Effect<DependencyOutcome, DependencyError>;
+}>;
+export declare class WorkspaceDependencies extends WorkspaceDependencies_base {
+    static readonly layer: Layer.Layer<WorkspaceDependencies, never, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
+}
+export {};
+//# sourceMappingURL=workspace-dependencies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-dependencies.d.ts","sourceRoot":"","sources":["../src/workspace-dependencies.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,OAAO,EACP,MAAM,EACN,UAAU,EACV,KAAK,EAGL,IAAI,EAGL,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EAAgB,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAG5E,OAAO,EACL,4BAA4B,EAC5B,iBAAiB,EAElB,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,KAAK,EAEV,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AACD,MAAM,MAAM,eAAe,GACvB,4BAA4B,GAC5B,iBAAiB,GACjB,aAAa,CAAC,aAAa,GAC3B,mBAAmB,CAAC;AACxB,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,YAAY,EAAE,SAAS,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/C;;sBAgMqB,CAChB,SAAS,EAAE,MAAM,KACd,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,4BAA4B,CAAC;sBACpC,CAChB,MAAM,EAAE,oBAAoB,KACzB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC;sBACvB,CAChB,WAAW,EAAE,IAAI,CACf,oBAAoB,EACpB,WAAW,GAAG,SAAS,GAAG,cAAc,CACzC,EACD,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,OAAO,EAAE,IAAI,CAAC,iBAAiB,EAAE,SAAS,CAAC,KACxC,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE,eAAe,CAAC;wBAClC,CAClB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,OAAO,EAAE,iBAAiB,EAC1B,MAAM,CAAC,EAAE,oBAAoB,KAC1B,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE,eAAe,CAAC;;AAtB1D,qBAAa,qBAAsB,SAAQ,0BAwBG;IAC5C,MAAM,CAAC,QAAQ,CAAC,KAAK,yHA0fnB;CACH"}

package/dist/workspace-dependencies.js

@@ -0,0 +1,478 @@
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { isDeepStrictEqual } from "node:util";
+import { Array as EffectArray, Config, Context, Effect, FileSystem, Layer, Order, Option, Path, Schema, Stream, } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { parseDocument } from "yaml";
+import { DependencyInstallationFailed, WorkspaceConflict, WorkspaceRecoveryRequired, } from "./errors.js";
+import { relativeFile } from "./files.js";
+import { confirmStopped, groupExists } from "./process-group.js";
+import { sameFingerprint } from "./workspace-state.js";
+const fingerprint = (content, mode) => ({
+    hash: createHash("sha256").update(content).digest("hex"),
+    mode,
+});
+const ManifestDependencies = Schema.Struct({
+    dependencies: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+    devDependencies: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+    optionalDependencies: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+});
+// Hooks and local packages can read inputs outside the prepared manifest set.
+// Delegate their reconciliation to pnpm instead of inventing a second resolver.
+const hasUnboundedInputs = (value) => {
+    if (Schema.is(Schema.String)(value)) {
+        return /^(?:file|link|portal):/u.test(value);
+    }
+    if (Array.isArray(value)) {
+        return value.some(hasUnboundedInputs);
+    }
+    if (Schema.is(Schema.JsonObject)(value)) {
+        return Object.entries(value).some(([key, entry]) => ([
+            "preinstall",
+            "install",
+            "postinstall",
+            "prepare",
+            "pnpm:devPreinstall",
+            "pnpmfile",
+            "globalPnpmfile",
+        ].includes(key) &&
+            Boolean(entry)) ||
+            (["injected", "injectWorkspacePackages"].includes(key) &&
+                entry === true) ||
+            hasUnboundedInputs(entry));
+    }
+    return false;
+};
+// These structured pnpm settings can be mirrored into scripts from workspace YAML.
+// They affect installation even when they match an ancestor's configuration.
+const structuredPnpmSettings = {
+    npm_config_catalog: "catalog",
+    npm_config_catalogs: "catalogs",
+    npm_config_overrides: "overrides",
+    npm_config_patched_dependencies: "patchedDependencies",
+};
+const inputsFor = (directory, files, fs, path) => Effect.gen(function* () {
+    const settings = files.find((file) => file.target === "pnpm-workspace.yaml");
+    const document = yield* Effect.try(() => parseDocument(new TextDecoder().decode(settings?.content)));
+    if (document.errors.length) {
+        return yield* Effect.fail(document.errors[0]);
+    }
+    const decode = yield* Effect.try(() => Schema.decodeUnknownEffect(Schema.JsonObject)(document.toJS()));
+    const config = yield* decode;
+    const patches = yield* Schema.decodeEffect(Schema.Struct({
+        patchedDependencies: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+    }))(config);
+    const targets = new Set(["pnpm-workspace.yaml", "pnpm-lock.yaml"]);
+    const outputs = [];
+    let unbounded = hasUnboundedInputs(config);
+    for (const file of files) {
+        if (file.target === "package.json" ||
+            file.target.endsWith("/package.json")) {
+            targets.add(file.target);
+            const manifest = yield* Schema.decodeEffect(Schema.fromJsonString(Schema.JsonObject))(new TextDecoder().decode(file.content));
+            unbounded ||= hasUnboundedInputs(manifest);
+            const dependencies = yield* Schema.decodeEffect(ManifestDependencies)(manifest);
+            const parent = file.target.slice(0, -"package.json".length);
+            for (const name of Object.keys({
+                ...dependencies.dependencies,
+                ...dependencies.devDependencies,
+            })) {
+                if (!Object.hasOwn(dependencies.optionalDependencies ?? {}, name)) {
+                    outputs.push(`${parent}node_modules/${yield* relativeFile(name)}/package.json`);
+                }
+            }
+        }
+    }
+    for (const target of Object.values(patches.patchedDependencies ?? {})) {
+        targets.add(yield* relativeFile(target));
+    }
+    const ordered = EffectArray.sort([...targets], Order.String);
+    const selected = [];
+    for (const target of ordered) {
+        const file = files.find((candidate) => candidate.target === target);
+        if (!file) {
+            return yield* new DependencyInstallationFailed({
+                directory,
+                phase: "inputs",
+            });
+        }
+        selected.push(file);
+    }
+    const hash = createHash("sha256");
+    for (const file of selected) {
+        hash
+            .update(file.target)
+            .update("\0")
+            .update(String(file.mode))
+            .update("\0")
+            .update(String(file.content.length))
+            .update("\0")
+            .update(file.content);
+    }
+    hash.update("pnpm-environment\0");
+    for (const name of EffectArray.sort(Object.keys(process.env), Order.String)) {
+        if (Object.hasOwn(structuredPnpmSettings, name.toLowerCase())) {
+            hash
+                .update(name.toLowerCase())
+                .update("\0")
+                .update(process.env[name] ?? "")
+                .update("\0");
+            const decoded = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Json))(process.env[name]);
+            if (Option.isNone(decoded)) {
+                unbounded = true;
+                continue;
+            }
+            unbounded ||= hasUnboundedInputs(decoded.value);
+            if (name.toLowerCase() === "npm_config_patched_dependencies") {
+                const environmentPatches = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema.String))(decoded.value);
+                if (Option.isNone(environmentPatches)) {
+                    unbounded = true;
+                    continue;
+                }
+                for (const patch of EffectArray.sort(Object.values(environmentPatches.value), Order.String)) {
+                    const patchPath = path.resolve(directory, patch);
+                    if (!(yield* fs.exists(patchPath)) ||
+                        (yield* fs.stat(patchPath)).type !== "File") {
+                        unbounded = true;
+                        continue;
+                    }
+                    const content = yield* fs.readFile(patchPath);
+                    hash
+                        .update(patchPath)
+                        .update("\0")
+                        .update(String(content.length))
+                        .update("\0")
+                        .update(content);
+                }
+            }
+        }
+    }
+    return { files: selected, key: hash.digest("hex"), outputs, unbounded };
+});
+export class WorkspaceDependencies extends Context.Service()("create-next-hydra/WorkspaceDependencies") {
+    static layer = Layer.effect(WorkspaceDependencies, Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+        const runInstall = (directory, offline, lifecycle) => Effect.scoped(Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+            const failure = (phase) => new DependencyInstallationFailed({ directory, phase });
+            yield* lifecycle?.starting ?? Effect.void;
+            const handle = yield* spawner
+                .spawn(ChildProcess.make("pnpm", [
+                "install",
+                ...(offline ? ["--offline"] : []),
+                "--no-frozen-lockfile",
+            ], {
+                cwd: directory,
+                forceKillAfter: "100 millis",
+                stderr: "inherit",
+                stdin: "ignore",
+                stdout: "inherit",
+            }))
+                .pipe(Effect.mapError(() => failure("launch")), Effect.tapError(() => lifecycle?.stopped ?? Effect.void));
+            return yield* restore(handle.exitCode.pipe(Effect.mapError(() => failure("exit")))).pipe(Effect.tap(() => groupExists(handle.pid).pipe(Effect.mapError(() => failure("stop")), Effect.flatMap((exists) => exists ? Effect.fail(failure("stop")) : Effect.void))), Effect.onExit(() => confirmStopped(handle).pipe(Effect.mapError(() => failure("stop")), Effect.andThen(lifecycle?.stopped ?? Effect.void), Effect.onExit(() => handle.unref.pipe(Effect.mapError(() => failure("stop")), Effect.asVoid)))));
+        })));
+        const install = Effect.fn("WorkspaceDependencies.install")(function* (directory) {
+            const code = yield* runInstall(directory, false);
+            if (code !== 0) {
+                return yield* new DependencyInstallationFailed({
+                    directory,
+                    phase: "exit",
+                });
+            }
+        });
+        const observe = (file) => Effect.gen(function* () {
+            const stat = yield* fs.stat(file);
+            return fingerprint(yield* fs.readFile(file), stat.mode % 0o1000);
+        });
+        const optionalObservation = (file) => observe(file).pipe(Effect.orElseSucceed(() => null));
+        const manifestPresent = (file) => fs.stat(file).pipe(Effect.map((stat) => stat.type === "File"), Effect.orElseSucceed(() => false));
+        const recover = Effect.fn("WorkspaceDependencies.recover")(function* (access) {
+            const observation = yield* access.observation;
+            if (observation.pending?.kind !== "installation") {
+                return;
+            }
+            if (!observation.pending.stopped) {
+                return yield* new WorkspaceRecoveryRequired({
+                    directory: access.directory,
+                });
+            }
+            const conflicts = [];
+            for (const entry of observation.entries) {
+                if (!sameFingerprint(yield* optionalObservation(path.join(access.directory, entry.target)), entry.applied)) {
+                    conflicts.push(entry.target);
+                }
+            }
+            if (conflicts.length > 0) {
+                return yield* new WorkspaceConflict({ paths: conflicts });
+            }
+            // An interrupted lockfile rewrite is not proven pnpm normalization.
+            // Preserve all source and installed output; a later reconcile may retry.
+            yield* access.recoverInstall(observation.revision);
+        });
+        const externalConfiguration = (directory) => Effect.gen(function* () {
+            const roots = new Set([homedir()]);
+            let parent = directory;
+            while (!roots.has(parent)) {
+                roots.add(parent);
+                const next = path.dirname(parent);
+                if (next === parent) {
+                    break;
+                }
+                parent = next;
+            }
+            const mirrored = new Map();
+            for (const root of roots) {
+                const settingsPath = path.join(root, "pnpm-workspace.yaml");
+                if (yield* fs.exists(settingsPath)) {
+                    const document = parseDocument(yield* fs.readFileString(settingsPath));
+                    if (document.errors.length) {
+                        return true;
+                    }
+                    const decodedSettings = Schema.decodeUnknownOption(Schema.JsonObject)(document.toJS());
+                    if (Option.isNone(decodedSettings)) {
+                        return true;
+                    }
+                    const settings = decodedSettings.value;
+                    for (const [name, key] of Object.entries(structuredPnpmSettings)) {
+                        const values = mirrored.get(name) ?? [];
+                        values.push(settings[key]);
+                        const patches = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema.String))(settings[key]);
+                        if (key === "patchedDependencies" && Option.isSome(patches)) {
+                            values.push(Object.fromEntries(Object.entries(patches.value).map(([name, file]) => [
+                                name,
+                                path.resolve(root, file),
+                            ])));
+                        }
+                        mirrored.set(name, values);
+                    }
+                }
+                if (yield* fs.exists(path.join(root, ".pnpmfile.cjs"))) {
+                    return true;
+                }
+                const npmrc = path.join(root, ".npmrc");
+                if (yield* fs.exists(npmrc)) {
+                    // Login credentials do not change an already installed graph. Accept
+                    // only literal auth assignments/comments; unknown INI syntax and all
+                    // other settings still require pnpm. Never hash or retain values.
+                    const content = yield* fs.readFileString(npmrc);
+                    if (content.split(/\r?\n/u).some((line) => {
+                        const setting = line.trim();
+                        return (setting !== "" &&
+                            !/^[#;]/u.test(setting) &&
+                            !/^(?:\/\/[^\s=]+:)?(?:_authToken|_auth|username|_password)\s*=/u.test(setting));
+                    })) {
+                        return true;
+                    }
+                }
+            }
+            // Invocation metadata does not affect installation. Other npm configuration
+            // and PNPM_* settings may; keep values out of both hashes and diagnostics.
+            const metadata = new Set([
+                "npm_config_user_agent",
+                "npm_config_recursive",
+                "npm_config_manage_package_manager_versions",
+                "npm_config_verify_deps_before_run",
+            ]);
+            return Object.entries(process.env).some(([name, value]) => {
+                const key = name.toLowerCase();
+                // pnpm run exports workspace objects as JSON, plus default registries.
+                // Accept mirrors only when they equal declared configuration; overrides
+                // and unknown settings must still be reconciled by pnpm.
+                const candidates = mirrored.get(key);
+                if (candidates) {
+                    const decoded = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Json))(value);
+                    if (Option.isSome(decoded) &&
+                        candidates.some((candidate) => isDeepStrictEqual(candidate, decoded.value))) {
+                        return false;
+                    }
+                }
+                if ((key === "npm_config_registry" &&
+                    value === "https://registry.npmjs.org/") ||
+                    (key === "npm_config__jsr_registry" &&
+                        value === "https://npm.jsr.io/") ||
+                    (key === "npm_config_frozen_lockfile" && value === "")) {
+                    return false;
+                }
+                return ((key.startsWith("npm_config_") && !metadata.has(key)) ||
+                    (name.startsWith("PNPM_") &&
+                        ![
+                            "PNPM_HOME",
+                            "PNPM_PACKAGE_NAME",
+                            "PNPM_SCRIPT_SRC_DIR",
+                        ].includes(name)));
+            });
+        });
+        const inspect = Effect.fn("WorkspaceDependencies.inspect")(function* (observation, files, options) {
+            const { directory, installation: previous } = observation;
+            if (!previous) {
+                return {
+                    dependencies: "pending",
+                    dependencyReasons: ["No successful installation recorded"],
+                };
+            }
+            const failure = () => new DependencyInstallationFailed({ directory, phase: "inputs" });
+            const inputs = yield* inputsFor(directory, files, fs, path).pipe(Effect.mapError(failure));
+            const reasons = [];
+            if (inputs.key !== previous.inputs) {
+                reasons.push("Installation inputs changed");
+            }
+            const applied = new Map(observation.entries.map((entry) => [entry.target, entry.applied]));
+            for (const file of inputs.files) {
+                const expected = applied.get(file.target);
+                if (!expected ||
+                    !sameFingerprint(yield* optionalObservation(path.join(directory, file.target)), expected)) {
+                    reasons.push(`Applied installation input changed: ${file.target}`);
+                }
+            }
+            const environment = yield* Config.String("NODE_ENV").pipe(Config.withDefault("development"), Effect.mapError(failure));
+            // Inspection verifies recorded installation, not the executable a future install
+            // might select. Never bootstrap a package manager during read-only inspection.
+            if (!previous.toolchain.startsWith(`${process.version}/${process.platform}/${process.arch}/pnpm-`) ||
+                !previous.toolchain.endsWith(`/offline-${options.offline === true}/production-${environment === "production"}`)) {
+                reasons.push("Runtime or installation options changed");
+            }
+            if (inputs.unbounded || (yield* externalConfiguration(directory))) {
+                reasons.push("External installation inputs require reconciliation");
+            }
+            for (const [target, expected] of [
+                ["pnpm-lock.yaml", previous.lockfile],
+                ["node_modules/.modules.yaml", previous.modules],
+                ["node_modules/.pnpm/lock.yaml", previous.virtualLock],
+            ]) {
+                if (!sameFingerprint(yield* optionalObservation(path.join(directory, target)), expected)) {
+                    reasons.push(`Installation output missing or changed: ${target}`);
+                }
+            }
+            for (const target of inputs.outputs) {
+                if (!(yield* manifestPresent(path.join(directory, target)))) {
+                    reasons.push(`Installed dependency missing: ${target}`);
+                }
+            }
+            return {
+                dependencies: reasons.length ? "pending" : "current",
+                dependencyReasons: reasons,
+            };
+        });
+        const reconcile = Effect.fn("WorkspaceDependencies.reconcile")(function* (directory, files, options, access) {
+            if (options.install === "skip") {
+                return {
+                    dependencies: "pending",
+                    dependencyReasons: ["Installation skipped"],
+                };
+            }
+            const failure = (phase) => new DependencyInstallationFailed({ directory, phase });
+            if (process.platform === "win32") {
+                return yield* failure("launch");
+            }
+            const inputs = yield* inputsFor(directory, files, fs, path).pipe(Effect.mapError(() => failure("inputs")));
+            const preserved = access ? (yield* access.observation).preserved : [];
+            const workspaceOwnedInputs = inputs.files.filter((file) => preserved.includes(file.target));
+            if (workspaceOwnedInputs.length > 0) {
+                return {
+                    dependencies: "pending",
+                    dependencyReasons: [
+                        `Installation skipped for preserved pnpm inputs: ${workspaceOwnedInputs.map((file) => file.target).join(", ")}. Run pnpm install in the workspace`,
+                    ],
+                };
+            }
+            const expected = access
+                ? new Map((yield* access.appliedEntries).map((entry) => [
+                    entry.target,
+                    entry.applied,
+                ]))
+                : new Map(files.map((file) => [
+                    file.target,
+                    fingerprint(file.content, file.mode),
+                ]));
+            const verifyInputs = (includeLock) => Effect.gen(function* () {
+                for (const file of inputs.files) {
+                    if (!includeLock && file.target === "pnpm-lock.yaml") {
+                        continue;
+                    }
+                    const actual = yield* optionalObservation(path.join(directory, file.target));
+                    if (!sameFingerprint(actual, expected.get(file.target) ?? null)) {
+                        return yield* failure("inputs");
+                    }
+                }
+                const current = yield* inputsFor(directory, files, fs, path).pipe(Effect.mapError(() => failure("inputs")));
+                if (current.key !== inputs.key) {
+                    return yield* failure("inputs");
+                }
+            });
+            yield* verifyInputs(true);
+            // Version discovery uses the same executable and working directory as install.
+            const version = yield* Effect.scoped(Effect.gen(function* () {
+                const handle = yield* spawner.spawn(ChildProcess.make("pnpm", ["--version"], {
+                    cwd: directory,
+                    stderr: "ignore",
+                    stdin: "ignore",
+                }));
+                const [output, code] = yield* Effect.all([
+                    Stream.mkString(Stream.decodeText(handle.stdout)),
+                    handle.exitCode,
+                ], { concurrency: "unbounded" });
+                if (code !== 0 ||
+                    !/^\d+\.\d+\.\d+(?:-[\w.-]+)?\s*$/u.test(output)) {
+                    return yield* failure("version");
+                }
+                return output.trim();
+            })).pipe(Effect.mapError(() => failure("version")));
+            yield* verifyInputs(true);
+            const environment = yield* Config.String("NODE_ENV").pipe(Config.withDefault("development"), Effect.mapError(() => failure("inputs")));
+            const toolchain = `${process.version}/${process.platform}/${process.arch}/pnpm-${version}/offline-${options.offline === true}/production-${environment === "production"}`;
+            const previous = access ? yield* access.installation : null;
+            const modulesPath = path.join(directory, "node_modules/.modules.yaml");
+            const virtualLockPath = path.join(directory, "node_modules/.pnpm/lock.yaml");
+            const lockPath = path.join(directory, "pnpm-lock.yaml");
+            const outputsPresent = Effect.gen(function* () {
+                for (const output of inputs.outputs) {
+                    if (!(yield* manifestPresent(path.join(directory, output)))) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+            if (access && previous?.toolchain === toolchain) {
+                const observed = yield* inspect({
+                    directory,
+                    entries: yield* access.appliedEntries,
+                    installation: previous,
+                }, files, options);
+                if (observed.dependencies === "current") {
+                    return observed;
+                }
+            }
+            const code = yield* runInstall(directory, options.offline === true, access
+                ? {
+                    starting: access.beginInstall(inputs.key),
+                    stopped: access.installStopped,
+                }
+                : undefined).pipe(Effect.tapErrorTag("DependencyInstallationFailed", (error) => Effect.gen(function* () {
+                if (error.phase === "launch" && access) {
+                    yield* verifyInputs(true);
+                    yield* access.finishInstall(null, yield* observe(lockPath));
+                }
+            })));
+            yield* verifyInputs(false);
+            const lockfile = yield* observe(lockPath).pipe(Effect.mapError(() => failure("outputs")));
+            if (code !== 0) {
+                if (access &&
+                    sameFingerprint(lockfile, expected.get("pnpm-lock.yaml") ?? null)) {
+                    yield* access.finishInstall(null, lockfile);
+                }
+                return yield* failure("exit");
+            }
+            const modules = yield* observe(modulesPath).pipe(Effect.mapError(() => failure("outputs")));
+            const virtualLock = yield* observe(virtualLockPath).pipe(Effect.mapError(() => failure("outputs")));
+            if (!(yield* outputsPresent)) {
+                return yield* failure("outputs");
+            }
+            if (access) {
+                yield* access.finishInstall({ inputs: inputs.key, lockfile, modules, toolchain, virtualLock }, lockfile);
+            }
+            return { dependencies: "current", dependencyReasons: [] };
+        });
+        return WorkspaceDependencies.of({ inspect, install, reconcile, recover });
+    }));
+}

package/dist/workspace-files.d.ts

@@ -0,0 +1,24 @@
+import { Context, Effect, FileSystem, Layer, Path } from "effect";
+import type { PlatformError } from "effect";
+import { MaterializationFailed, WorkspaceConflict } from "./errors.ts";
+import type { FileChange, PreparedFile, PreparedWorkspace } from "./model.ts";
+import type { WorkspaceWriteAccess, WorkspaceStateError, WorkspaceObservation } from "./workspace-state.ts";
+export type WorkspaceFileError = WorkspaceConflict | MaterializationFailed | PlatformError.PlatformError;
+declare const WorkspaceFiles_base: Context.ServiceClass<WorkspaceFiles, "create-next-hydra/WorkspaceFiles", {
+    readonly recover: (access: WorkspaceWriteAccess) => Effect.Effect<void, WorkspaceFileError | WorkspaceStateError>;
+    readonly capture: (directory: string, entries: WorkspaceObservation["entries"]) => Effect.Effect<readonly PreparedFile[], WorkspaceFileError>;
+    readonly read: (directory: string, targets: readonly string[]) => Effect.Effect<{
+        readonly files: readonly PreparedFile[];
+        readonly conflicts: readonly string[];
+    }, WorkspaceFileError>;
+    readonly inspect: (observation: WorkspaceObservation, files: PreparedWorkspace["files"], preserve?: readonly string[]) => Effect.Effect<readonly FileChange[], WorkspaceFileError>;
+    readonly apply: (access: WorkspaceWriteAccess, files: PreparedWorkspace["files"], initialization: readonly string[], preserve?: readonly string[]) => Effect.Effect<{
+        readonly removedFiles: readonly string[];
+        readonly complete: Effect.Effect<void, WorkspaceFileError | WorkspaceStateError>;
+    }, WorkspaceFileError | WorkspaceStateError>;
+}>;
+export declare class WorkspaceFiles extends WorkspaceFiles_base {
+    static readonly layer: Layer.Layer<WorkspaceFiles, never, FileSystem.FileSystem | Path.Path>;
+}
+export {};
+//# sourceMappingURL=workspace-files.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-files.d.ts","sourceRoot":"","sources":["../src/workspace-files.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAY,MAAM,QAAQ,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EAElB,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAG9E,OAAO,KAAK,EAGV,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,sBAAsB,CAAC;AAqC9B,MAAM,MAAM,kBAAkB,GAC1B,iBAAiB,GACjB,qBAAqB,GACrB,aAAa,CAAC,aAAa,CAAC;;sBAIV,CAChB,MAAM,EAAE,oBAAoB,KACzB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,mBAAmB,CAAC;sBAChD,CAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,KACrC,MAAM,CAAC,MAAM,CAAC,SAAS,YAAY,EAAE,EAAE,kBAAkB,CAAC;mBAChD,CACb,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,SAAS,MAAM,EAAE,KACvB,MAAM,CAAC,MAAM,CAChB;QACE,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;QACxC,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;KACvC,EACD,kBAAkB,CACnB;sBACiB,CAChB,WAAW,EAAE,oBAAoB,EACjC,KAAK,EAAE,iBAAiB,CAAC,OAAO,CAAC,EACjC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,KACzB,MAAM,CAAC,MAAM,CAAC,SAAS,UAAU,EAAE,EAAE,kBAAkB,CAAC;oBAC7C,CACd,MAAM,EAAE,oBAAoB,EAC5B,KAAK,EAAE,iBAAiB,CAAC,OAAO,CAAC,EACjC,cAAc,EAAE,SAAS,MAAM,EAAE,EACjC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,KACzB,MAAM,CAAC,MAAM,CAChB;QACE,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;QACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAC9B,IAAI,EACJ,kBAAkB,GAAG,mBAAmB,CACzC,CAAC;KACH,EACD,kBAAkB,GAAG,mBAAmB,CACzC;;AAvCL,qBAAa,cAAe,SAAQ,mBAyCG;IACrC,MAAM,CAAC,QAAQ,CAAC,KAAK,wEAuenB;CACH"}