create-next-hydra 0.3.0 → 0.4.1

package/dist/commands.d.ts

@@ -0,0 +1,22 @@
+import { Effect, Option, Path, Stdio } from "effect";
+import { Command, Prompt } from "effect/unstable/cli";
+import { InvalidComposition, WorkspaceBatchFailed, WorkspaceNotCurrent } from "./errors.ts";
+import { Workspaces } from "./workspaces.ts";
+export declare function command(cwd: string): Command.Command<"create-next-hydra", {} | {
+    readonly addOns: readonly string[];
+    readonly auth: Option.Option<string>;
+    readonly cms: Option.Option<string>;
+    readonly commerce: Option.Option<string>;
+    readonly search: Option.Option<string>;
+    readonly commit: boolean;
+    readonly directory: Option.Option<string>;
+    readonly preset: Option.Option<string>;
+    readonly ref: Option.Option<string>;
+    readonly repository: string;
+    readonly skipGit: boolean;
+    readonly verbose: boolean;
+    readonly without: readonly ("search" | "auth" | "cms" | "commerce")[];
+    readonly yes: boolean;
+}, {}, import("./errors.ts").DestinationNotEmpty | import("./errors.ts").MaterializationFailed | import("./errors.ts").EnvironmentInitializationFailed | import("./errors.ts").WorkspaceBusy | import("./errors.ts").WorkspaceLockAuthorizationRequired | import("./errors.ts").WorkspaceLockChanged | import("./errors.ts").WorkspaceConflict | import("./errors.ts").WorkspaceRecoveryRequired | import("./errors.ts").WorkspaceStateInvalid | WorkspaceNotCurrent | WorkspaceBatchFailed | import("./errors.ts").SnapshotUnavailable | import("./errors.ts").WorkspaceUninitialized | import("./errors.ts").SnapshotFailed | import("./errors.ts").DependencyInstallationFailed | import("./addition.ts").AdditionChanged | import("./addition.ts").AdditionConflict | import("./addition.ts").AdditionFailed | import("./application-git.ts").ApplicationGitFailed | import("./source-changes.ts").SourceWatchFailure | (import("./errors.ts").IncompatibleSelection | InvalidComposition | import("./errors.ts").SourceChanged | import("./errors.ts").SourceAcquisitionFailed | import("./errors.ts").SourceStorageRetained | import("./errors.ts").RegistryFailure | import("./errors.ts").StagingRetained | import("./errors.ts").RegistryWorkerFailure | import("effect/Schema").SchemaError | import("effect/PlatformError").PlatformError) | import("effect/Terminal").QuitError, Workspaces | Stdio.Stdio | Prompt.Environment>;
+export declare const runCommand: (sourceRoot: string, args: readonly string[], version: string) => Effect.Effect<void, import("./errors.ts").DestinationNotEmpty | import("./errors.ts").MaterializationFailed | import("./errors.ts").EnvironmentInitializationFailed | import("./errors.ts").WorkspaceBusy | import("./errors.ts").WorkspaceLockAuthorizationRequired | import("./errors.ts").WorkspaceLockChanged | import("./errors.ts").WorkspaceConflict | import("./errors.ts").WorkspaceRecoveryRequired | import("./errors.ts").WorkspaceStateInvalid | WorkspaceNotCurrent | WorkspaceBatchFailed | import("./errors.ts").SnapshotUnavailable | import("./errors.ts").WorkspaceUninitialized | import("./errors.ts").SnapshotFailed | import("./errors.ts").DependencyInstallationFailed | import("./addition.ts").AdditionChanged | import("./addition.ts").AdditionConflict | import("./addition.ts").AdditionFailed | import("./application-git.ts").ApplicationGitFailed | import("./source-changes.ts").SourceWatchFailure | (import("./errors.ts").IncompatibleSelection | InvalidComposition | import("./errors.ts").SourceChanged | import("./errors.ts").SourceAcquisitionFailed | import("./errors.ts").SourceStorageRetained | import("./errors.ts").RegistryFailure | import("./errors.ts").StagingRetained | import("./errors.ts").RegistryWorkerFailure | import("effect/Schema").SchemaError | import("effect/PlatformError").PlatformError) | import("effect/unstable/cli/CliError").CliError, import("effect/FileSystem").FileSystem | Path.Path | import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | Workspaces | import("effect/Terminal").Terminal | Stdio.Stdio>;
+//# sourceMappingURL=commands.d.ts.map

package/dist/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,MAAM,EAAS,MAAM,EAAE,IAAI,EAAE,KAAK,EAAU,MAAM,QAAQ,CAAC;AAC7E,OAAO,EAAY,OAAO,EAAQ,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAItE,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAkE7C,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;42CA2PlC;AAED,eAAO,MAAM,UAAU,GACrB,YAAY,MAAM,EAClB,MAAM,SAAS,MAAM,EAAE,EACvB,SAAS,MAAM,0hDAoBhB,CAAC"}

package/dist/commands.js

@@ -0,0 +1,197 @@
+import { Console, Effect, Match, Option, Path, Stdio, Stream } from "effect";
+import { Argument, Command, Flag, Prompt } from "effect/unstable/cli";
+import { addCommand } from "./add-command.js";
+import { createCommand } from "./create-command.js";
+import { InvalidComposition, WorkspaceBatchFailed, WorkspaceNotCurrent, } from "./errors.js";
+import { findSourceRoot } from "./source-root.js";
+import { Workspaces } from "./workspaces.js";
+function explainFile(file, sourceRoot, path) {
+    const explanation = Match.value(file.origin).pipe(Match.discriminator("kind")("registry", (origin) => `${file.target}\n  published registry artifact: ${origin.owner}`), Match.discriminator("kind")("workspace-setting", (origin) => `${file.target}\n  workspace setting: ${path.join(sourceRoot, origin.source)}`), Match.discriminator("kind")("source", (origin) => `${file.target}\n  source: ${path.join(sourceRoot, origin.source)}${origin.owner === null ? "" : ` (${origin.owner})`}`), Match.discriminator("kind")("template", (origin) => [
+        `${file.target}\n  template: ${path.join(sourceRoot, origin.source)} (${origin.owner})`,
+        ...origin.bindings.map((binding) => `  ${binding.slot}: ${binding.module}#${binding.export}${binding.as ? ` as ${binding.as}` : ""} (${binding.owner})`),
+    ].join("\n")), Match.discriminator("kind")("policy", (origin) => [
+        `${file.target}\n  composition policy: ${origin.policy}`,
+        ...origin.sources.map((source) => `  input: ${path.join(sourceRoot, source)}`),
+    ].join("\n")), Match.exhaustive);
+    const transformations = "transforms" in file.origin ? (file.origin.transforms ?? []) : [];
+    return [
+        explanation,
+        ...transformations.map((transform) => `  transform: ${transform}`),
+    ].join("\n");
+}
+function synchronizationResult(name, result) {
+    return [
+        result.recoveryEvidence
+            ? `Broke the authorized lock; retained evidence at ${result.recoveryEvidence}.`
+            : null,
+        `${name}: materialized ${result.files.length} files; removed ${result.removedFiles.length} files; copied ${result.environmentFilesCreated.length} environment files. Dependencies ${result.dependencies}.${result.dependencyReasons.length ? ` ${result.dependencyReasons.join("; ")}.` : ""}`,
+        ...result.instructions.map(({ item, text }) => `${item}:\n${text}`),
+    ]
+        .filter((line) => line !== null)
+        .join("\n");
+}
+export function command(cwd) {
+    return createCommand(cwd).pipe(Command.withSubcommands([
+        addCommand(cwd),
+        Command.make("compose", {
+            all: Flag.Boolean("all").pipe(Flag.withDefault(false), Flag.withDescription("Select all Git-visible workspace definitions under workspaces/.")),
+            check: Flag.Boolean("check").pipe(Flag.withDefault(false), Flag.withDescription("Check composed files without changing the workspace or checking installed dependencies.")),
+            copyEnv: Flag.Boolean("copy-env").pipe(Flag.withDefault(false), Flag.withDescription("Copy missing ignored environment files from local source without replacing existing values.")),
+            diff: Flag.Boolean("diff").pipe(Flag.withDefault(false), Flag.withDescription("Show local changes against the saved composition snapshot without updating.")),
+            explain: Flag.Boolean("explain").pipe(Flag.withDefault(false), Flag.withDescription("Locate canonical sources and templates without changing the workspace.")),
+            install: Flag.Boolean("install").pipe(Flag.withDefault(true)),
+            name: Argument.String("name").pipe(Argument.optional),
+            offline: Flag.Boolean("offline").pipe(Flag.withDefault(false)),
+            target: Argument.String("file").pipe(Argument.optional, Argument.withDescription("Workspace-relative file to locate with --explain; omit to list all selected files.")),
+            watch: Flag.Boolean("watch").pipe(Flag.withDefault(false), Flag.withDescription("Keep the workspace synchronized with canonical source changes. Run development tasks separately.")),
+        }, ({ name: nameOption, all, install, copyEnv, offline, explain, target, check, diff, watch, }) => Effect.gen(function* () {
+            const requestedName = all && explain ? Option.none() : nameOption;
+            const explainTarget = all && explain ? nameOption : target;
+            if (all && Option.isSome(target)) {
+                return yield* new InvalidComposition({
+                    message: "Provide at most one file with --all --explain",
+                });
+            }
+            if (all === Option.isSome(requestedName)) {
+                return yield* new InvalidComposition({
+                    message: "Choose one workspace name or --all",
+                });
+            }
+            if ([check, explain, diff, watch].filter(Boolean).length > 1) {
+                return yield* new InvalidComposition({
+                    message: "Choose one of --check, --explain, --diff or --watch",
+                });
+            }
+            if ((explain || diff) && copyEnv) {
+                return yield* new InvalidComposition({
+                    message: "--explain and --diff are read-only; do not combine them with --copy-env.",
+                });
+            }
+            if (!explain && Option.isSome(target)) {
+                return yield* new InvalidComposition({
+                    message: "A file argument requires --explain",
+                });
+            }
+            const workspaces = yield* Workspaces;
+            const sourceRoot = yield* findSourceRoot(cwd);
+            const references = Option.isSome(requestedName)
+                ? [{ name: requestedName.value, sourceRoot }]
+                : yield* workspaces.discover(sourceRoot);
+            if (references.length === 0) {
+                return yield* new InvalidComposition({
+                    message: "No named workspace definitions found in workspaces/*/next-hydra.json",
+                });
+            }
+            const options = {
+                environment: copyEnv ? "copy-missing-local" : "preserve",
+                install: install ? "install" : "skip",
+                offline,
+            };
+            if (watch) {
+                return yield* Stream.mergeAll(references.map((reference) => Stream.unwrap(workspaces
+                    .named(reference)
+                    .pipe(Effect.map((workspace) => workspace.watch(options)))).pipe(Stream.map((event) => ({ event, name: reference.name })))), { concurrency: "unbounded" }).pipe(Stream.runForEach(({ event, name: workspaceName }) => event._tag === "Synchronized"
+                    ? Console.log(synchronizationResult(workspaceName, event.result))
+                    : Console.error(`${workspaceName}: ${event.error.message}`)));
+            }
+            const run = Effect.fn("Compose.run")(function* (reference) {
+                const { name } = reference;
+                const workspace = yield* workspaces.named(reference);
+                if (diff) {
+                    const report = yield* workspace.diff;
+                    const path = yield* Path.Path;
+                    yield* Console.log([
+                        `${name}: changes against saved composition ${report.snapshot}.`,
+                        ...(report.incomplete
+                            ? [
+                                "Synchronization is incomplete; this patch may include tool-applied changes.",
+                            ]
+                            : []),
+                        ...report.conflicts.map((file) => `conflict: ${file}`),
+                        ...report.unregisteredFiles.map((file) => `unregistered: ${file}`),
+                        ...(report.origins.length === 0
+                            ? []
+                            : [
+                                "Sources recorded with the saved composition:",
+                                ...report.origins.map((file) => explainFile(file, reference.sourceRoot, path)),
+                            ]),
+                        report.patch || "No owned-file changes.",
+                    ].join("\n"));
+                    return;
+                }
+                if (check) {
+                    const report = yield* workspace.check;
+                    yield* Console.log([
+                        `${name}: ${report.ready ? "current" : "needs attention"}.`,
+                        ...(report.initialized
+                            ? []
+                            : ["Workspace has not been initialized."]),
+                        ...report.changes.map((change) => `${change.kind}: ${change.target}`),
+                    ].join("\n"));
+                    if (!report.ready) {
+                        return yield* new WorkspaceNotCurrent({
+                            directory: report.destination,
+                        });
+                    }
+                    return;
+                }
+                if (explain) {
+                    const report = yield* workspace.explain(Option.getOrUndefined(explainTarget));
+                    const path = yield* Path.Path;
+                    yield* Console.log([
+                        `${name}: ${report.files.length} selected source files (current definition, not applied state).`,
+                        ...report.files.map((entry) => explainFile(entry, report.sourceRoot, path)),
+                    ].join("\n"));
+                    return;
+                }
+                const result = yield* workspace.sync(options).pipe(Effect.catchTag("WorkspaceLockAuthorizationRequired", (error) => Effect.gen(function* () {
+                    const stdio = yield* Stdio.Stdio;
+                    if (!(yield* stdio.stdinIsTerminal) ||
+                        !(yield* stdio.stdoutIsTerminal)) {
+                        return yield* error;
+                    }
+                    yield* Console.warn(`${name}: ${error.reason}. Stop other Compose commands for this workspace before continuing. Breaking the lock does not stop processes. It preserves recovery evidence and does not override local-file conflicts or incomplete state.`);
+                    const approved = yield* Prompt.Confirm({
+                        initial: false,
+                        message: `Other Compose commands are stopped. Break the lock for ${name}?`,
+                    });
+                    if (!approved) {
+                        return yield* error;
+                    }
+                    return yield* workspace.sync({
+                        ...options,
+                        breakLock: error.token,
+                    });
+                })));
+                yield* Console.log(synchronizationResult(name, result));
+            });
+            if (Option.isSome(requestedName)) {
+                return yield* run({ name: requestedName.value, sourceRoot });
+            }
+            const [failed] = yield* Effect.partition(references, (reference) => run(reference).pipe(Effect.tapError((error) => Console.error(`${reference.name}: ${error.message}`)), Effect.mapError(() => reference.name)), { concurrency: 1 });
+            if (failed.length > 0) {
+                return yield* new WorkspaceBatchFailed({ names: failed });
+            }
+        })),
+    ]));
+}
+export const runCommand = (sourceRoot, args, version) => {
+    // Effect CLI has optional flags, but not optional flag values. Normalize only
+    // this spelling; Effect owns parsing, validation, help and every other option.
+    const targets = [];
+    let literal = false;
+    const normalized = args.map((arg) => {
+        if (arg === "--") {
+            literal = true;
+        }
+        if (args[0] === "compose" && !literal && arg.startsWith("--explain=")) {
+            targets.push(arg.slice("--explain=".length));
+            return "--explain";
+        }
+        return arg;
+    });
+    return Command.runWith(command(sourceRoot), { version })([
+        ...normalized,
+        ...targets,
+    ]);
+};

package/dist/composition-lint.d.ts

@@ -0,0 +1,20 @@
+import { Effect, FileSystem, Path, Schema } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { ApplicationTaskFailed, InvalidComposition } from "./errors.ts";
+import type { FileExplanation } from "./model.ts";
+import { Shadcn } from "./shadcn.ts";
+import { SourceInventory } from "./source-inventory.ts";
+import { Workspaces } from "./workspaces.ts";
+export type CompositionLintScope = {
+    readonly kind: "all";
+} | {
+    readonly kind: "source";
+} | {
+    readonly kind: "workspace";
+    readonly name: string;
+};
+export declare const affectedLintWorkspaces: (sourceRoot: string, changedFiles?: readonly string[] | undefined) => Effect.Effect<string[], import("./errors.ts").IncompatibleSelection | InvalidComposition | import("./errors.ts").SourceChanged | import("./errors.ts").SourceAcquisitionFailed | import("./errors.ts").SourceStorageRetained | import("./errors.ts").RegistryFailure | import("./errors.ts").StagingRetained | import("./errors.ts").RegistryWorkerFailure | Schema.SchemaError | import("effect/PlatformError").PlatformError, Workspaces>;
+export declare const executeLintCommand: (cwd: string, executable: string, args: readonly string[], accepted?: readonly number[] | undefined) => Effect.Effect<string, ApplicationTaskFailed | import("effect/PlatformError").PlatformError, ChildProcessSpawner.ChildProcessSpawner>;
+export declare const lintWorkspaceFiles: (root: string, executable: string, files: readonly string[], origins: readonly FileExplanation[], mode?: "typed" | "syntax" | undefined) => Effect.Effect<number, ApplicationTaskFailed | InvalidComposition | Schema.SchemaError | import("effect/PlatformError").PlatformError, Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
+export declare const lintCompositions: (sourceRoot: string, requestedFiles?: readonly string[] | undefined, scope?: CompositionLintScope | undefined) => Effect.Effect<undefined, ApplicationTaskFailed | import("./errors.ts").DestinationNotEmpty | import("./errors.ts").MaterializationFailed | import("./errors.ts").EnvironmentInitializationFailed | import("./errors.ts").WorkspaceBusy | import("./errors.ts").WorkspaceLockAuthorizationRequired | import("./errors.ts").WorkspaceLockChanged | import("./errors.ts").WorkspaceConflict | import("./errors.ts").WorkspaceRecoveryRequired | import("./errors.ts").WorkspaceStateInvalid | import("./errors.ts").DependencyInstallationFailed | import("effect/PlatformError").BadArgument | import("./application-git.ts").ApplicationGitFailed | (import("./errors.ts").IncompatibleSelection | InvalidComposition | import("./errors.ts").SourceChanged | import("./errors.ts").SourceAcquisitionFailed | import("./errors.ts").SourceStorageRetained | import("./errors.ts").RegistryFailure | import("./errors.ts").StagingRetained | import("./errors.ts").RegistryWorkerFailure | Schema.SchemaError | import("effect/PlatformError").PlatformError), FileSystem.FileSystem | Path.Path | Shadcn | ChildProcessSpawner.ChildProcessSpawner | SourceInventory | Workspaces>;
+//# sourceMappingURL=composition-lint.d.ts.map

package/dist/composition-lint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition-lint.d.ts","sourceRoot":"","sources":["../src/composition-lint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AAC3E,OAAO,EAAgB,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE5E,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAExE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG7C,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CAAE,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAoB1D,eAAO,MAAM,sBAAsB,mfA2DlC,CAAC;AAuBF,eAAO,MAAM,kBAAkB,8OAoC9B,CAAC;AAiBF,eAAO,MAAM,kBAAkB,wUAoD7B,CAAC;AAEH,eAAO,MAAM,gBAAgB,quCAsN3B,CAAC"}

package/dist/composition-lint.js

@@ -0,0 +1,288 @@
+import { Console, Effect, FileSystem, Path, Schema, Stream } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { ApplicationTaskFailed, InvalidComposition } from "./errors.js";
+import { WorkspaceDefinition } from "./model.js";
+import { Shadcn } from "./shadcn.js";
+import { SourceInventory } from "./source-inventory.js";
+import { TemplateDefinition } from "./templates.js";
+import { Workspaces } from "./workspaces.js";
+const scriptExtension = /\.[cm]?[jt]sx?$/u;
+const allCompositions = { kind: "all" };
+const sharedLintInputs = new Set([
+    "package.json",
+    "pnpm-lock.yaml",
+    "pnpm-workspace.yaml",
+    "registry.json",
+    "components.json",
+    "oxlint.config.ts",
+    "tsconfig.json",
+    ".node-version",
+    ".npmrc",
+    ".github/workflows/registry-integrity.yml",
+]);
+function sourcePath(file) {
+    return "source" in file.origin ? file.origin.source : undefined;
+}
+export const affectedLintWorkspaces = Effect.fn("CompositionLint.affected")(function* (sourceRoot, changedFiles) {
+    const workspaces = yield* Workspaces;
+    const references = yield* workspaces.discover(sourceRoot);
+    if (references.length === 0) {
+        return yield* new InvalidComposition({
+            message: "Composition lint requires at least one named workspace definition.",
+        });
+    }
+    if (changedFiles === undefined ||
+        changedFiles.some((file) => sharedLintInputs.has(file) ||
+            (file.startsWith("tools/oxlint/") && !file.endsWith(".md")) ||
+            file.startsWith("packages/create-next-hydra/src/") ||
+            file === "packages/create-next-hydra/package.json")) {
+        return references.map((reference) => reference.name);
+    }
+    const changes = changedFiles.filter((file) => !file.endsWith(".md"));
+    if (changes.length === 0) {
+        return [];
+    }
+    const selected = [];
+    for (const reference of references) {
+        if (changes.some((file) => file.startsWith(`workspaces/${reference.name}/`))) {
+            selected.push(reference.name);
+            continue;
+        }
+        const workspace = yield* workspaces.named(reference);
+        const origins = (yield* workspace.explain()).files;
+        const sources = origins.flatMap((file) => {
+            const source = sourcePath(file);
+            return source === undefined ? [] : [source];
+        });
+        // Package ownership also covers additions and deletions that are absent
+        // from the current exact-file explanation. Dependencies are included.
+        const directories = new Set(sources
+            .filter((file) => /^(?:apps|packages)\//u.test(file))
+            .map((file) => `${file.split("/").slice(0, 2).join("/")}/`));
+        if (changes.some((file) => sources.includes(file) ||
+            [...directories].some((directory) => file.startsWith(directory)))) {
+            selected.push(reference.name);
+        }
+    }
+    return selected;
+});
+const LintResult = Schema.fromJsonString(Schema.Struct({
+    diagnostics: Schema.Array(Schema.Struct({
+        code: Schema.optionalKey(Schema.String),
+        filename: Schema.String,
+        labels: Schema.optionalKey(Schema.Array(Schema.Struct({
+            span: Schema.Struct({ column: Schema.Int, line: Schema.Int }),
+        }))),
+        message: Schema.String,
+        severity: Schema.String,
+    })),
+    number_of_files: Schema.Int,
+}));
+export const executeLintCommand = Effect.fn("CompositionLint.execute")(function* (cwd, executable, args, accepted = [0]) {
+    const processes = yield* ChildProcessSpawner.ChildProcessSpawner;
+    return yield* Effect.scoped(Effect.gen(function* () {
+        const child = yield* processes.spawn(ChildProcess.make(executable, args, {
+            cwd,
+            env: {
+                ...process.env,
+                GIT_COMMON_DIR: undefined,
+                GIT_DIR: undefined,
+                GIT_INDEX_FILE: undefined,
+                GIT_WORK_TREE: undefined,
+            },
+            stderr: "inherit",
+            stdin: "ignore",
+            stdout: "pipe",
+        }));
+        const [output, code] = yield* Effect.all([Stream.mkString(Stream.decodeText(child.stdout)), child.exitCode], { concurrency: "unbounded" });
+        if (!accepted.includes(code)) {
+            return yield* new ApplicationTaskFailed({ code, directory: cwd });
+        }
+        return output;
+    }));
+});
+const assertCoverage = (expected, actual) => {
+    const found = new Set(actual);
+    const missing = expected.filter((file) => !found.has(file));
+    return missing.length === 0
+        ? Effect.void
+        : Effect.fail(new InvalidComposition({
+            message: `Lint did not inspect expected files:\n${missing.join("\n")}`,
+        }));
+};
+export const lintWorkspaceFiles = Effect.fn("CompositionLint.files")(function* (root, executable, files, origins, mode = "typed") {
+    if (files.length === 0) {
+        return 0;
+    }
+    const path = yield* Path.Path;
+    const discovered = (yield* executeLintCommand(root, executable, [
+        "--debug",
+        "files",
+        ...files,
+    ]))
+        .trim()
+        .split(/\r?\n/u)
+        .filter(Boolean);
+    yield* assertCoverage(files, discovered);
+    const result = yield* executeLintCommand(root, executable, [
+        ...(mode === "typed" ? ["--type-aware", "--type-check"] : []),
+        "--format",
+        "json",
+        ...discovered,
+    ], [0, 1]).pipe(Effect.flatMap(Schema.decodeEffect(LintResult)));
+    if (result.number_of_files !== discovered.length) {
+        return yield* new InvalidComposition({
+            message: `Lint coverage changed: expected ${discovered.length} files, inspected ${result.number_of_files}.`,
+        });
+    }
+    for (const diagnostic of result.diagnostics) {
+        const target = path.isAbsolute(diagnostic.filename)
+            ? path.relative(root, diagnostic.filename)
+            : diagnostic.filename;
+        const origin = origins.find((file) => file.target === target);
+        const location = origin ? (sourcePath(origin) ?? target) : target;
+        const rendered = origin?.origin.kind === "template" ? ` (rendered ${target})` : "";
+        const span = diagnostic.labels?.[0]?.span;
+        yield* Console.error(`${location}${rendered}:${span?.line ?? 1}:${span?.column ?? 1}: ${diagnostic.severity} ${diagnostic.code ?? ""}: ${diagnostic.message}`);
+    }
+    return result.diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
+});
+export const lintCompositions = Effect.fn("CompositionLint.run")(function* (sourceRoot, requestedFiles, scope = allCompositions) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const workspaces = yield* Workspaces;
+    const inventory = yield* SourceInventory;
+    const registry = yield* Shadcn;
+    const requested = new Set(requestedFiles ?? (yield* inventory.list(sourceRoot)));
+    const executable = path.join(sourceRoot, "node_modules/.bin/oxlint");
+    const candidates = [...requested].filter((file) => scriptExtension.test(file));
+    if (candidates.length > 0) {
+        const eligible = new Set((yield* executeLintCommand(sourceRoot, executable, [
+            "--debug",
+            "files",
+            ...candidates,
+        ]))
+            .trim()
+            .split(/\r?\n/u)
+            .filter(Boolean));
+        for (const file of candidates) {
+            if (!eligible.has(file)) {
+                requested.delete(file);
+            }
+        }
+    }
+    const names = yield* workspaces.discover(sourceRoot);
+    if (names.length === 0) {
+        return yield* new InvalidComposition({
+            message: "Composition lint requires at least one named workspace definition.",
+        });
+    }
+    const selected = scope.kind === "workspace"
+        ? names.filter((reference) => reference.name === scope.name)
+        : names;
+    if (scope.kind === "workspace" && selected.length === 0) {
+        return yield* new InvalidComposition({
+            message: `Unknown lint workspace: ${scope.name}`,
+        });
+    }
+    // The source registry owns production templates. Authored CLI test inputs are
+    // not production applications and are verified by their own behavioral tests.
+    const declaredTemplates = new Set();
+    for (const item of (yield* registry.loadRegistry({
+        cwd: sourceRoot,
+        registryFile: "registry.json",
+    })).items) {
+        const definition = yield* Schema.decodeUnknownEffect(TemplateDefinition)(item.meta?.composition ?? {});
+        for (const template of definition.templates ?? []) {
+            declaredTemplates.add(template.source);
+        }
+    }
+    const covered = new Set();
+    let errors = 0;
+    for (const reference of selected) {
+        if (scope.kind === "source") {
+            // Explain establishes ownership without installing or materializing apps.
+            const workspace = yield* workspaces.named(reference);
+            for (const file of (yield* workspace.explain()).files) {
+                const source = sourcePath(file);
+                if (source !== undefined) {
+                    covered.add(source);
+                }
+            }
+            continue;
+        }
+        errors += yield* Effect.scoped(Effect.gen(function* () {
+            const definition = yield* fs
+                .readFileString(path.join(sourceRoot, "workspaces", reference.name, "next-hydra.json"))
+                .pipe(Effect.flatMap(Schema.decodeEffect(Schema.fromJsonString(WorkspaceDefinition))));
+            // Keep this disposable copy below the repository so type-aware lint's
+            // plugins can resolve maintainer tooling, never below a named workspace.
+            const temporary = yield* fs.makeTempDirectoryScoped({
+                directory: path.join(sourceRoot, "workspaces"),
+                prefix: ".lint-",
+            });
+            const destination = path.join(temporary, reference.name);
+            const fresh = yield* workspaces.fresh({
+                destination,
+                name: reference.name,
+                selection: {
+                    addOns: definition.addOns,
+                    providers: definition.providers,
+                },
+                source: { kind: "working-tree", root: sourceRoot },
+            });
+            const result = yield* fresh.materialize({ git: "initialize" });
+            yield* executeLintCommand(destination, "pnpm", [
+                "-r",
+                "--if-present",
+                "run",
+                "lint:prepare",
+            ]);
+            const web = path.join(destination, "apps/web");
+            const config = path.join(web, "next.config.ts");
+            if (yield* fs.exists(config)) {
+                yield* Effect.acquireUseRelease(fs.readFile(config), () => Effect.gen(function* () {
+                    yield* fs.writeFileString(config, 'export { baseConfig as default } from "@repo/next-config";\n');
+                    yield* executeLintCommand(web, path.join(web, "node_modules/.bin/next"), ["typegen"]);
+                }), (content) => fs.writeFile(config, content).pipe(Effect.orDie));
+            }
+            const encodeString = Schema.encodeEffect(Schema.fromJsonString(Schema.String));
+            const configuration = yield* encodeString((yield* path.toFileUrl(path.join(sourceRoot, "oxlint.config.ts")))
+                .href);
+            yield* fs.writeFileString(path.join(destination, "oxlint.config.mts"), `import path from "node:path";\nimport configuration from ${configuration};\nexport default { ...configuration, jsPlugins: configuration.jsPlugins?.map(plugin => ({ ...plugin, specifier: path.resolve(${yield* encodeString(sourceRoot)}, plugin.specifier) })) };\n`);
+            const files = result.origins
+                .filter((file) => scriptExtension.test(file.target) &&
+                (file.origin.kind === "template" ||
+                    requested.has(sourcePath(file) ?? "")))
+                .map((file) => file.target);
+            for (const file of result.origins) {
+                const source = sourcePath(file);
+                if (source !== undefined) {
+                    covered.add(source);
+                }
+            }
+            yield* Console.log(`Lint composition: ${reference.name}`);
+            return yield* lintWorkspaceFiles(destination, executable, files, result.origins);
+        }));
+    }
+    // A matrix job checks its own application. The separate source job checks
+    // files outside every composition and enforces complete application coverage.
+    if (scope.kind !== "workspace") {
+        const sourceFiles = [...requested].filter((file) => scriptExtension.test(file) && !covered.has(file));
+        yield* assertCoverage([
+            ...sourceFiles.filter((file) => file.startsWith("apps/web/") || file.startsWith("apps/api/")),
+            ...[...requested].filter((file) => declaredTemplates.has(file) && !covered.has(file)),
+        ], []);
+        // Authored examples are input trees, not installed TypeScript projects.
+        // Keep their syntax checks; real application output is checked above.
+        const examples = sourceFiles.filter((file) => file.startsWith("packages/create-next-hydra/tests/examples/"));
+        const exampleSet = new Set(examples);
+        errors += yield* lintWorkspaceFiles(sourceRoot, executable, sourceFiles.filter((file) => !exampleSet.has(file)), []);
+        errors += yield* lintWorkspaceFiles(sourceRoot, executable, examples, [], "syntax");
+    }
+    if (errors > 0) {
+        return yield* new InvalidComposition({
+            message: `Composition lint failed with ${errors} errors. Fix the reported canonical sources and templates.`,
+        });
+    }
+});

package/dist/composition.d.ts

@@ -0,0 +1,24 @@
+import { Context, Effect, FileSystem, Layer, Path, Schema } from "effect";
+import type { PlatformError } from "effect";
+import { InvalidComposition, SourceChanged } from "./errors.ts";
+import type { RegistryFailure, IncompatibleSelection, RegistryWorkerFailure, StagingRetained } from "./errors.ts";
+import type { PreparedWorkspace, SelectionRequest } from "./model.ts";
+import { Shadcn } from "./shadcn.ts";
+import { SourceInventory } from "./source-inventory.ts";
+import type { WorkspaceSource } from "./workspace-sources.ts";
+export interface PreparationRequest {
+    readonly demoArchitecture?: boolean;
+    readonly source: WorkspaceSource;
+    readonly selection: SelectionRequest;
+    readonly name: string;
+    readonly port?: number;
+}
+export type PreparationError = InvalidComposition | IncompatibleSelection | SourceChanged | RegistryFailure | RegistryWorkerFailure | StagingRetained | PlatformError.PlatformError | Schema.SchemaError;
+declare const Composition_base: Context.ServiceClass<Composition, "create-next-hydra/Composition", {
+    readonly prepare: (request: PreparationRequest) => Effect.Effect<PreparedWorkspace, PreparationError>;
+}>;
+export declare class Composition extends Composition_base {
+    static readonly layer: Layer.Layer<Composition, never, FileSystem.FileSystem | Path.Path | Shadcn | SourceInventory>;
+}
+export {};
+//# sourceMappingURL=composition.d.ts.map

package/dist/composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition.d.ts","sourceRoot":"","sources":["../src/composition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAe5C,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,EACV,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,eAAe,EAChB,MAAM,aAAa,CAAC;AAIrB,OAAO,KAAK,EAEV,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAKpB,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AASxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AACD,MAAM,MAAM,gBAAgB,GACxB,kBAAkB,GAClB,qBAAqB,GACrB,aAAa,GACb,eAAe,GACf,qBAAqB,GACrB,eAAe,GACf,aAAa,CAAC,aAAa,GAC3B,MAAM,CAAC,WAAW,CAAC;;sBAOD,CAChB,OAAO,EAAE,kBAAkB,KACxB,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE,gBAAgB,CAAC;;AAL3D,qBAAa,WAAY,SAAQ,gBAOG;IAClC,MAAM,CAAC,QAAQ,CAAC,KAAK,gGAkiBnB;CACH"}