create-next-hydra 0.2.1 → 0.4.1

package/dist/source-changes.d.ts

@@ -0,0 +1,55 @@
+/*!
+ * Subscription lifecycle adapted from Effect's Parcel watcher:
+ * https://github.com/Effect-TS/effect/blob/d5e25b237f05670ee42b386cb40b2cb448fc11d7/packages/platform-node-shared/src/internal/fileSystem/parcelWatcher.ts
+ *
+ * MIT License
+ *
+ * Copyright (c) 2023 Effectful Technologies Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { Cause, Context, Effect, FileSystem, Layer, Path, Schema, Stream } from "effect";
+import type { Scope } from "effect";
+import type { SourceInputs } from "./model.ts";
+import { SourceInventory } from "./source-inventory.ts";
+export interface SourceCoverage {
+    readonly root: string;
+    readonly files: readonly string[];
+    readonly inputs: SourceInputs | null;
+}
+declare const SourceWatchFailure_base: Schema.Class<SourceWatchFailure, Schema.TaggedStruct<"SourceWatchFailure", {
+    readonly diagnostic: Schema.Redacted<Schema.Unknown>;
+    readonly path: Schema.String;
+    readonly phase: Schema.Literals<readonly ["connect", "observe", "update"]>;
+}>, Cause.YieldableError>;
+export declare class SourceWatchFailure extends SourceWatchFailure_base {
+    get message(): string;
+}
+export interface SourceSubscription {
+    readonly invalidations: Stream.Stream<void, SourceWatchFailure>;
+    readonly update: (coverage: SourceCoverage) => Effect.Effect<void, SourceWatchFailure>;
+}
+declare const SourceChanges_base: Context.ServiceClass<SourceChanges, "create-next-hydra/SourceChanges", {
+    readonly open: (coverage: SourceCoverage) => Effect.Effect<SourceSubscription, SourceWatchFailure, Scope.Scope>;
+}>;
+export declare class SourceChanges extends SourceChanges_base {
+    static readonly layer: Layer.Layer<SourceChanges, never, FileSystem.FileSystem | Path.Path | SourceInventory>;
+}
+export {};
+//# sourceMappingURL=source-changes.d.ts.map

package/dist/source-changes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-changes.d.ts","sourceRoot":"","sources":["../src/source-changes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,EAEL,KAAK,EACL,OAAO,EACP,MAAM,EAEN,UAAU,EACV,KAAK,EAEL,IAAI,EAIJ,MAAM,EAEN,MAAM,EACP,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAGpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EACL,eAAe,EAGhB,MAAM,uBAAuB,CAAC;AAU/B,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAElC,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;CACtC;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAOvC;IACC,IAAI,OAAO,WAEV;CACF;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC;IAChE,QAAQ,CAAC,MAAM,EAAE,CACf,QAAQ,EAAE,cAAc,KACrB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC;CAC9C;;mBAKkB,CACb,QAAQ,EAAE,cAAc,KACrB,MAAM,CAAC,MAAM,CAAC,kBAAkB,EAAE,kBAAkB,EAAE,KAAK,CAAC,KAAK,CAAC;;AAL3E,qBAAa,aAAc,SAAQ,kBAOG;IACpC,MAAM,CAAC,QAAQ,CAAC,KAAK,yFAyRnB;CACH"}

package/dist/source-changes.js

@@ -0,0 +1,225 @@
+/*!
+ * Subscription lifecycle adapted from Effect's Parcel watcher:
+ * https://github.com/Effect-TS/effect/blob/d5e25b237f05670ee42b386cb40b2cb448fc11d7/packages/platform-node-shared/src/internal/fileSystem/parcelWatcher.ts
+ *
+ * MIT License
+ *
+ * Copyright (c) 2023 Effectful Technologies Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { Array as EffectArray, Cause, Context, Effect, Equivalence, FileSystem, Layer, Order, Path, Queue, Redacted, RegExp as EffectRegExp, Schema, ScopedRef, Stream, } from "effect";
+import { isCanonicalSource } from "./file-policy.js";
+import { SourceInventory, sourceInputMatcher, sourceWatchIgnores, } from "./source-inventory.js";
+const sameControls = Equivalence.Array(Equivalence.Struct({
+    directory: Equivalence.String,
+    files: Equivalence.Array(Equivalence.String),
+}));
+export class SourceWatchFailure extends Schema.TaggedError()("SourceWatchFailure", {
+    diagnostic: Schema.Redacted(Schema.Unknown, { disallowJsonEncode: true }),
+    path: Schema.String,
+    phase: Schema.Literals(["connect", "observe", "update"]),
+}) {
+    get message() {
+        return `Source observation failed during ${this.phase}: ${this.path}`;
+    }
+}
+export class SourceChanges extends Context.Service()("create-next-hydra/SourceChanges") {
+    static layer = Layer.effect(SourceChanges, Effect.gen(function* () {
+        const path = yield* Path.Path;
+        const fs = yield* FileSystem.FileSystem;
+        const inventory = yield* SourceInventory;
+        return SourceChanges.of({
+            open: Effect.fn("SourceChanges.open")(function* (initial) {
+                const root = path.resolve(initial.root);
+                const candidates = new Map();
+                const pending = yield* Queue.dropping(1);
+                const failure = (phase, diagnostic) => new SourceWatchFailure({
+                    diagnostic,
+                    path: root,
+                    phase,
+                });
+                const matcher = (coverage) => {
+                    const files = coverage.files.map((file) => path.resolve(root, file));
+                    const selected = sourceInputMatcher(coverage.inputs);
+                    return (file) => files.some((exact) => exact === file || exact.startsWith(`${file}${path.sep}`)) ||
+                        selected(path.relative(root, file).split(path.sep).join("/"));
+                };
+                let matches = matcher(initial);
+                const outsideInputs = (coverage) => (coverage.inputs?.files ?? [])
+                    .map((file) => path.resolve(root, file))
+                    .filter((file) => {
+                    const relative = path.relative(root, file);
+                    return (relative === ".." ||
+                        relative.startsWith(`..${path.sep}`) ||
+                        path.isAbsolute(relative));
+                });
+                let externalFiles = outsideInputs(initial);
+                const withAncestors = (files, directory = root) => {
+                    const paths = new Set();
+                    const prefix = directory.endsWith(path.sep)
+                        ? directory
+                        : `${directory}${path.sep}`;
+                    for (const file of files) {
+                        let absolute = path.resolve(directory, file);
+                        while (absolute !== directory && absolute.startsWith(prefix)) {
+                            paths.add(absolute);
+                            absolute = path.dirname(absolute);
+                        }
+                    }
+                    return paths;
+                };
+                const capturedPaths = (coverage) => withAncestors([
+                    ...coverage.files,
+                    ...(coverage.inputs?.files ?? []),
+                ]);
+                let captured = capturedPaths(initial);
+                const visiblePaths = (phase) => inventory.list(root).pipe(Effect.map((files) => withAncestors(files)), Effect.mapError((error) => failure(phase, Redacted.make(error))));
+                let visible = yield* visiblePaths("connect");
+                // Load native code only when Watch is consumed, not for one-shot commands.
+                const parcel = yield* Effect.tryPromise({
+                    catch: (error) => failure("connect", Redacted.make(error)),
+                    try: async () => await import("@parcel/watcher"),
+                });
+                // Parcel has no cancellation signal. Acquire/release waits for setup
+                // before honoring interruption so a late subscription cannot leak.
+                const observe = (directory, receive, ignore) => Effect.acquireRelease(Effect.tryPromise({
+                    catch: (error) => failure("connect", Redacted.make(error)),
+                    try: async () => await parcel.subscribe(directory, (error, events) => {
+                        if (error) {
+                            Queue.failCauseUnsafe(pending, Cause.fail(failure("observe", Redacted.make(error))));
+                            return;
+                        }
+                        // Do not short-circuit: retain every candidate in the batch.
+                        let relevant = false;
+                        for (const event of events) {
+                            relevant = receive(event.path, event.type) || relevant;
+                        }
+                        if (relevant) {
+                            Queue.offerUnsafe(pending, undefined);
+                        }
+                    }, { ignore }),
+                }), (subscription) => Effect.promise(async () => {
+                    await subscription.unsubscribe();
+                }));
+                yield* observe(root, (file, type) => {
+                    if (!matches(file)) {
+                        // Linux can report only a directory when its contents arrive
+                        // before recursive observation connects. Reconcile structural
+                        // events through visibility without selecting unrelated paths.
+                        return (type !== "update" &&
+                            isCanonicalSource(path.relative(root, file).split(path.sep).join("/")));
+                    }
+                    // Remember explicit inputs at arrival, before coverage can narrow.
+                    candidates.set(file, candidates.get(file) === true || captured.has(file));
+                    return true;
+                }, sourceWatchIgnores);
+                const controlPaths = (phase) => Effect.gen(function* () {
+                    const controls = [
+                        ...(yield* inventory.controlFiles(root)),
+                        ...externalFiles.map((file) => ({
+                            directory: path.dirname(file),
+                            files: [file],
+                        })),
+                    ];
+                    const directories = new Map();
+                    for (const control of controls) {
+                        let { directory } = control;
+                        // A configured ignore file may not have a parent directory yet.
+                        // Watch its exact ancestor chain, without crawling sibling trees.
+                        while (!(yield* fs.exists(directory))) {
+                            directory = path.dirname(directory);
+                        }
+                        const files = directories.get(directory) ?? new Set();
+                        for (const file of control.files) {
+                            files.add(file);
+                        }
+                        directories.set(directory, files);
+                    }
+                    return EffectArray.sortWith([...directories].map(([directory, files]) => ({
+                        directory,
+                        files: EffectArray.sort(files, Order.String),
+                    })), (control) => control.directory, Order.String);
+                }).pipe(Effect.mapError((error) => failure(phase, Redacted.make(error))));
+                let controlsChanged = false;
+                const connectControls = (controls) => Effect.forEach(controls, ({ directory, files }) => {
+                    const paths = withAncestors(files, directory);
+                    const allowed = [...paths]
+                        .map((file) => EffectRegExp.escape(path.relative(directory, file).split(path.sep).join("/")))
+                        .join("|");
+                    // Observe exact controls without crawling Git objects or home directories.
+                    return observe(directory, (file) => {
+                        if (!paths.has(file)) {
+                            return false;
+                        }
+                        controlsChanged = true;
+                        if (externalFiles.some((input) => input === file ||
+                            input.startsWith(`${file}${path.sep}`))) {
+                            candidates.set(file, true);
+                        }
+                        return true;
+                    }, [`!(${allowed})`]);
+                }, { discard: true }).pipe(Effect.as(controls));
+                const controls = yield* ScopedRef.fromAcquire(connectControls(yield* controlPaths("connect")));
+                const update = (coverage) => Effect.gen(function* () {
+                    if (path.resolve(coverage.root) !== root) {
+                        return yield* failure("update", Redacted.make("An observation subscription cannot change its source root"));
+                    }
+                    // The root remains connected. Callers broaden before preparation
+                    // and narrow afterward; coverage updates are not source changes.
+                    matches = matcher(coverage);
+                    captured = capturedPaths(coverage);
+                    // Keep last-known external artifacts connected while preparation
+                    // is broken, so restoring a deleted artifact can repair Watch.
+                    if (coverage.inputs !== null) {
+                        const next = outsideInputs(coverage);
+                        if (!Equivalence.Array(Equivalence.String)(externalFiles, next)) {
+                            externalFiles = next;
+                            const current = yield* controlPaths("update");
+                            yield* ScopedRef.set(controls, connectControls(current));
+                        }
+                    }
+                });
+                const invalidations = Stream.fromQueue(pending).pipe(Stream.filterEffect(() => Effect.gen(function* () {
+                    // Drain before yielding: events arriving during Git inspection
+                    // stay queued for the next pass. Coalesce paths, not event history.
+                    const batch = [...candidates];
+                    candidates.clear();
+                    if (controlsChanged) {
+                        controlsChanged = false;
+                        const current = yield* controlPaths("observe");
+                        if (!sameControls(current, yield* ScopedRef.get(controls))) {
+                            // Acquire the new subscriptions before releasing the old set.
+                            yield* ScopedRef.set(controls, connectControls(current));
+                        }
+                    }
+                    const current = yield* visiblePaths("observe");
+                    // Any scan can discover a Git change before its native event
+                    // arrives. Never consume that visibility change without signaling.
+                    const relevant = batch.some(([file, explicit]) => explicit || visible.has(file) || current.has(file)) ||
+                        [...visible].some((file) => !current.has(file) && matches(file)) ||
+                        [...current].some((file) => !visible.has(file) && matches(file));
+                    visible = current;
+                    return relevant;
+                })));
+                return { invalidations, update };
+            }),
+        });
+    }));
+}

package/dist/source-inventory.d.ts

@@ -0,0 +1,25 @@
+import { Context, Effect, Layer, Path } from "effect";
+import type { PlatformError } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { InvalidComposition } from "./errors.ts";
+import type { SourceInputs } from "./model.ts";
+export declare const sourceWatchIgnores: string[];
+export declare function sourceInputMatcher(inputs: SourceInputs | null): (file: string) => boolean;
+export interface LocalEnvironmentFile {
+    readonly source: string;
+    readonly target: string;
+}
+export interface SourceControlFiles {
+    readonly directory: string;
+    readonly files: readonly string[];
+}
+declare const SourceInventory_base: Context.ServiceClass<SourceInventory, "create-next-hydra/SourceInventory", {
+    readonly controlFiles: (root: string) => Effect.Effect<readonly SourceControlFiles[], PlatformError.PlatformError | InvalidComposition>;
+    readonly list: (root: string) => Effect.Effect<readonly string[], PlatformError.PlatformError | InvalidComposition>;
+    readonly localEnvironment: (root: string) => Effect.Effect<readonly LocalEnvironmentFile[], PlatformError.PlatformError | InvalidComposition>;
+}>;
+export declare class SourceInventory extends SourceInventory_base {
+    static readonly layer: Layer.Layer<SourceInventory, InvalidComposition, Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
+}
+export {};
+//# sourceMappingURL=source-inventory.d.ts.map

package/dist/source-inventory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-inventory.d.ts","sourceRoot":"","sources":["../src/source-inventory.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,OAAO,EACP,MAAM,EACN,KAAK,EAEL,IAAI,EAEL,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EAAgB,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAQjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAK/C,eAAO,MAAM,kBAAkB,UAK9B,CAAC;AAEF,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,GAAG,IAAI,GAC1B,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAoC3B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;;2BAK0B,CACrB,IAAI,EAAE,MAAM,KACT,MAAM,CAAC,MAAM,CAChB,SAAS,kBAAkB,EAAE,EAC7B,aAAa,CAAC,aAAa,GAAG,kBAAkB,CACjD;mBACc,CACb,IAAI,EAAE,MAAM,KACT,MAAM,CAAC,MAAM,CAChB,SAAS,MAAM,EAAE,EACjB,aAAa,CAAC,aAAa,GAAG,kBAAkB,CACjD;+BAC0B,CACzB,IAAI,EAAE,MAAM,KACT,MAAM,CAAC,MAAM,CAChB,SAAS,oBAAoB,EAAE,EAC/B,aAAa,CAAC,aAAa,GAAG,kBAAkB,CACjD;;AApBL,qBAAa,eAAgB,SAAQ,oBAsBG;IACtC,MAAM,CAAC,QAAQ,CAAC,KAAK,wGAmNnB;CACH"}

package/dist/source-inventory.js

@@ -0,0 +1,212 @@
+import { Array as EffectArray, Config, Context, Effect, Layer, Order, Path, Stream, } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { InvalidComposition } from "./errors.js";
+import { cacheDirectories, eligiblePackageFile, isEnvironmentFile, isCanonicalSource, } from "./file-policy.js";
+import { relativeFile } from "./files.js";
+import { packageManifestMatcher } from "./package-catalog.js";
+// Prune recursive observation before reaching dependency trees or composed apps.
+// Definitions remain observable; SourceChanges filters them by exact coverage.
+export const sourceWatchIgnores = [
+    "**/.git",
+    "**/.workspace-composition*",
+    ...[...cacheDirectories].map((directory) => `**/${directory}`),
+    "workspaces/*/!(next-hydra.json)",
+];
+export function sourceInputMatcher(inputs) {
+    const files = new Set(inputs?.files);
+    const excluded = new Set(inputs?.excluded);
+    const matchesManifest = packageManifestMatcher(inputs?.packagePatterns ?? []);
+    const ancestors = new Set();
+    for (const file of files) {
+        const parts = file.split("/");
+        for (let end = 1; end < parts.length; end += 1) {
+            ancestors.add(parts.slice(0, end).join("/"));
+        }
+    }
+    return (file) => {
+        if (!isCanonicalSource(file)) {
+            return false;
+        }
+        if (inputs === null || files.has(file) || ancestors.has(file)) {
+            return true;
+        }
+        // ShadCN includes explicitly name registry.json files. Package manifests
+        // and ignore rules can change discovery even outside the selected closure.
+        const name = file.split("/").at(-1);
+        if (name === "registry.json" ||
+            name === ".gitignore" ||
+            matchesManifest(file)) {
+            return true;
+        }
+        return (!excluded.has(file) &&
+            eligiblePackageFile(file) &&
+            inputs.packages.some((directory) => file === directory || file.startsWith(`${directory}/`)));
+    };
+}
+export class SourceInventory extends Context.Service()("create-next-hydra/SourceInventory") {
+    static layer = Layer.effect(SourceInventory, Effect.gen(function* () {
+        const processes = yield* ChildProcessSpawner.ChildProcessSpawner;
+        const path = yield* Path.Path;
+        const configHome = yield* Config.String("XDG_CONFIG_HOME").pipe(Config.withDefault(""), Effect.mapError(() => new InvalidComposition({
+            message: "Could not read XDG_CONFIG_HOME for Git source inventory",
+        })));
+        const defaultIgnore = configHome
+            ? path.join(configHome, "git/ignore")
+            : "~/.config/git/ignore";
+        const git = (root, args, accepted = [0]) => Effect.scoped(Effect.gen(function* () {
+            const process = yield* processes.spawn(ChildProcess.make("git", args, { cwd: root, stderr: "ignore" }));
+            const [output, code] = yield* Effect.all([
+                Stream.mkString(Stream.decodeText(process.stdout)),
+                process.exitCode,
+            ], { concurrency: "unbounded" });
+            if (!accepted.includes(code)) {
+                return yield* new InvalidComposition({
+                    message: `Git source inventory failed (exit ${code})`,
+                });
+            }
+            return output;
+        }));
+        return SourceInventory.of({
+            controlFiles: Effect.fn("SourceInventory.controlFiles")(function* (root) {
+                const index = (yield* git(root, [
+                    "rev-parse",
+                    "--path-format=absolute",
+                    "--git-path",
+                    "index",
+                ])).trim();
+                const common = (yield* git(root, [
+                    "rev-parse",
+                    "--path-format=absolute",
+                    "--git-common-dir",
+                ])).trim();
+                const directory = (yield* git(root, [
+                    "rev-parse",
+                    "--absolute-git-dir",
+                ])).trim();
+                const excludes = (yield* git(root, [
+                    "config",
+                    "--path",
+                    "--default",
+                    defaultIgnore,
+                    "--get",
+                    "core.excludesFile",
+                ])).trim();
+                // Git expands configured paths and evaluates conditional includes.
+                // Retain include targets even while empty/missing, without reading
+                // unrelated configuration values or interpreting config syntax.
+                const configuration = (yield* git(root, [
+                    "config",
+                    "--null",
+                    "--path",
+                    "--show-origin",
+                    "--get-regexp",
+                    "^(include|includeif\\..*)\\.path$",
+                ], [0, 1])).split("\0");
+                const controls = [
+                    { directory: path.dirname(index), files: [index] },
+                    {
+                        directory,
+                        files: [
+                            path.join(directory, "HEAD"),
+                            path.join(directory, "config.worktree"),
+                        ],
+                    },
+                    {
+                        directory: common,
+                        files: [
+                            path.join(common, "info/exclude"),
+                            path.join(common, "config"),
+                        ],
+                    },
+                ];
+                // Git reports the platform's config paths even before they exist.
+                for (const variable of ["GIT_CONFIG_GLOBAL", "GIT_CONFIG_SYSTEM"]) {
+                    const locations = yield* git(root, ["var", variable], [0, 1]);
+                    for (const location of locations.split("\n").filter(Boolean)) {
+                        const file = path.resolve(root, location);
+                        controls.push({ directory: path.dirname(file), files: [file] });
+                    }
+                }
+                for (let offset = 0; offset < configuration.length; offset += 2) {
+                    const origin = configuration[offset];
+                    const entry = configuration[offset + 1];
+                    if (origin && entry) {
+                        const include = entry.slice(entry.indexOf("\n") + 1);
+                        const base = origin.startsWith("file:")
+                            ? path.dirname(path.resolve(root, origin.slice(5)))
+                            : root;
+                        const file = path.resolve(base, include);
+                        controls.push({ directory: path.dirname(file), files: [file] });
+                    }
+                }
+                if (excludes) {
+                    const file = path.resolve(root, excludes);
+                    controls.push({ directory: path.dirname(file), files: [file] });
+                }
+                return controls;
+            }),
+            list: Effect.fn("SourceInventory.list")(function* (root) {
+                const inventory = yield* git(root, [
+                    "ls-files",
+                    "--cached",
+                    "--others",
+                    "--exclude-standard",
+                    "-z",
+                ]);
+                const deleted = new Set((yield* git(root, ["ls-files", "--deleted", "-z"])).split("\0"));
+                return EffectArray.sort([...new Set(inventory.split("\0"))].filter((file) => file.length > 0 && !file.endsWith("/") && !deleted.has(file)), Order.String);
+            }),
+            localEnvironment: Effect.fn("SourceInventory.localEnvironment")(function* (root) {
+                const worktrees = yield* git(root, [
+                    "worktree",
+                    "list",
+                    "--porcelain",
+                    "-z",
+                ]);
+                const primary = worktrees
+                    .split("\0")
+                    .find((field) => field.startsWith("worktree "))
+                    ?.slice(9);
+                if (!primary) {
+                    return yield* new InvalidComposition({
+                        message: "Git source inventory did not identify the primary worktree",
+                    });
+                }
+                const selected = new Map();
+                for (const directory of new Set([primary, path.resolve(root)])) {
+                    const ignored = yield* git(directory, [
+                        "ls-files",
+                        "--others",
+                        "--ignored",
+                        "--exclude-standard",
+                        "-z",
+                        "--",
+                        ":(glob).env",
+                        ":(glob).env.*",
+                        ":(glob)apps/**/.env",
+                        ":(glob)apps/**/.env.*",
+                        ":(glob)packages/**/.env",
+                        ":(glob)packages/**/.env.*",
+                        ":(glob)tests/**/.env",
+                        ":(glob)tests/**/.env.*",
+                    ]);
+                    for (const candidate of ignored.split("\0")) {
+                        if (!candidate ||
+                            !isEnvironmentFile(candidate) ||
+                            candidate
+                                .split("/")
+                                .some((part) => part === ".git" || cacheDirectories.has(part))) {
+                            continue;
+                        }
+                        const target = yield* relativeFile(candidate);
+                        selected.set(target, {
+                            source: path.join(directory, target),
+                            target,
+                        });
+                    }
+                }
+                return EffectArray.sortWith(selected.values(), (file) => file.target, Order.String);
+            }),
+        });
+    }));
+}

package/dist/source-root.d.ts

@@ -0,0 +1,4 @@
+import { Effect, FileSystem, Path } from "effect";
+import { InvalidComposition } from "./errors.ts";
+export declare const findSourceRoot: (cwd: string) => Effect.Effect<string, InvalidComposition | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=source-root.d.ts.map

package/dist/source-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-root.d.ts","sourceRoot":"","sources":["../src/source-root.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAElD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD,eAAO,MAAM,cAAc,8IAsBzB,CAAC"}

package/dist/source-root.js

@@ -0,0 +1,20 @@
+import { Effect, FileSystem, Path } from "effect";
+import { InvalidComposition } from "./errors.js";
+export const findSourceRoot = Effect.fn("WorkspaceSources.findRoot")(function* (cwd) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    let candidate = path.resolve(cwd);
+    while (true) {
+        if ((yield* fs.exists(path.join(candidate, "registry.json"))) &&
+            (yield* fs.exists(path.join(candidate, "pnpm-workspace.yaml")))) {
+            return candidate;
+        }
+        const parent = path.dirname(candidate);
+        if (parent === candidate) {
+            return yield* new InvalidComposition({
+                message: "Run workspace commands inside a source checkout containing registry.json and pnpm-workspace.yaml.",
+            });
+        }
+        candidate = parent;
+    }
+});

package/dist/staging.d.ts

@@ -0,0 +1,19 @@
+import { Effect, FileSystem, Path, Ref } from "effect";
+import { StagingRetained } from "./errors.ts";
+declare const writer: unique symbol;
+export interface RegistryInstallation {
+    readonly application: string;
+    readonly registry: string;
+    readonly control: string;
+    readonly [writer]: Ref.Ref<boolean>;
+}
+export interface Staging extends RegistryInstallation {
+    readonly root: string;
+    readonly inputs: string;
+}
+export declare const writing: (staging: RegistryInstallation) => Effect.Effect<void, never, never>;
+export declare const stopped: (staging: RegistryInstallation) => Effect.Effect<void, never, never>;
+export declare const withStaging: <A, E, R>(use: (staging: Staging) => Effect.Effect<A, E, R>) => Effect.Effect<A, StagingRetained | import("effect/PlatformError").PlatformError | E, FileSystem.FileSystem | Path.Path | R>;
+export declare const withRegistryInstallation: <A, E, R>(application: string, use: (installation: RegistryInstallation) => Effect.Effect<A, E, R>) => Effect.Effect<A, StagingRetained | import("effect/PlatformError").PlatformError | E, FileSystem.FileSystem | Path.Path | R>;
+export {};
+//# sourceMappingURL=staging.d.ts.map

package/dist/staging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staging.d.ts","sourceRoot":"","sources":["../src/staging.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAEvD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,QAAA,MAAM,MAAM,eAA2B,CAAC;AAExC,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;CACrC;AACD,MAAM,WAAW,OAAQ,SAAQ,oBAAoB;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAGD,eAAO,MAAM,OAAO,GAAI,SAAS,oBAAoB,sCACrB,CAAC;AACjC,eAAO,MAAM,OAAO,GAAI,SAAS,oBAAoB,sCACpB,CAAC;AA+ClC,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EACjC,KAAK,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,gIAC9B,CAAC;AAEtB,eAAO,MAAM,wBAAwB,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAC9C,aAAa,MAAM,EACnB,KAAK,CAAC,YAAY,EAAE,oBAAoB,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,gIACnC,CAAC"}

package/dist/staging.js

@@ -0,0 +1,42 @@
+import { Effect, FileSystem, Path, Ref } from "effect";
+import { StagingRetained } from "./errors.js";
+const writer = Symbol("staging writer");
+// Only the adapter participates in this private lifetime protocol.
+export const writing = (staging) => Ref.set(staging[writer], true);
+export const stopped = (staging) => Ref.set(staging[writer], false);
+const withStorage = (use, application) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    return yield* Effect.acquireUseRelease(Effect.gen(function* () {
+        const root = yield* fs.makeTempDirectory({
+            prefix: "hydra-preparation-",
+        });
+        return {
+            application: application ?? path.join(root, "application"),
+            control: path.join(root, "control"),
+            inputs: path.join(root, "inputs"),
+            registry: path.join(root, "registry"),
+            root,
+            [writer]: yield* Ref.make(false),
+        };
+    }), (staging) => Effect.gen(function* () {
+        for (const directory of [
+            ...(application === undefined ? [staging.application] : []),
+            staging.inputs,
+            staging.registry,
+            staging.control,
+        ]) {
+            yield* fs
+                .makeDirectory(directory, { mode: 0o700 })
+                .pipe(Effect.uninterruptible);
+        }
+        return yield* use(staging);
+    }), (staging) => Effect.gen(function* () {
+        if (yield* Ref.get(staging[writer])) {
+            return yield* new StagingRetained({ directory: staging.root });
+        }
+        yield* fs.remove(staging.root, { recursive: true });
+    }));
+});
+export const withStaging = (use) => withStorage(use);
+export const withRegistryInstallation = (application, use) => withStorage(use, application);