create-next-hydra 0.3.0 → 0.4.2

package/dist/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../src/selection.ts"],"names":[],"mappings":"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"}

package/dist/selection.js

@@ -0,0 +1,424 @@
+import { Effect, Schema } from "effect";
+import { IncompatibleSelection, InvalidComposition } from "./errors.js";
+import { relativeFile } from "./files.js";
+import { Selection, SelectionRequest } from "./model.js";
+import { DependencySection } from "./packages.js";
+const manifestTarget = Effect.fn("Composition.manifestTarget")(function* (cwd) {
+    return cwd === "."
+        ? "package.json"
+        : `${yield* relativeFile(cwd)}/package.json`;
+});
+const SlotRequirement = Schema.Literals(["required", "optional", "forbidden"]);
+const ProviderSlot = Schema.Literals(["auth", "cms", "commerce", "search"]);
+export const providerAliases = {
+    auth: "@repo/auth",
+    cms: "@repo/cms",
+    commerce: "@repo/commerce-provider",
+    search: "@repo/search-provider",
+};
+const officialReferences = {
+    algolia: "next-hydra/search/algolia",
+    clerk: "next-hydra/auth/clerk",
+    commercetools: "next-hydra/commerce/commercetools",
+    contentstack: "next-hydra/cms/contentstack",
+    drupal: "next-hydra/cms/drupal",
+    standard: "next-hydra/preset/standard",
+    workos: "next-hydra/auth/workos",
+};
+const Metadata = Schema.Struct({
+    assets: Schema.optionalKey(Schema.Array(Schema.Struct({
+        source: Schema.NonEmptyString,
+        target: Schema.NonEmptyString,
+    }))),
+    binding: Schema.optionalKey(Schema.Struct({
+        sourcePath: Schema.optionalKey(Schema.NonEmptyString),
+        specifier: Schema.NonEmptyString,
+    })),
+    compatibility: Schema.optionalKey(Schema.Struct({
+        conflicts: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
+        requires: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
+    })),
+    conditionalDependencies: Schema.optionalKey(Schema.Array(Schema.Struct({
+        items: Schema.NonEmptyArray(Schema.NonEmptyString),
+        providers: Schema.NonEmptyArray(ProviderSlot),
+    }))),
+    id: Schema.NonEmptyString,
+    kind: Schema.Literals(["provider", "package", "recipe", "add-on", "preset"]),
+    packages: Schema.optionalKey(Schema.Array(Schema.Struct({
+        cwd: Schema.NonEmptyString,
+        name: Schema.NonEmptyString,
+        section: DependencySection,
+        specifier: Schema.NonEmptyString,
+    }))),
+    pnpmPatches: Schema.optionalKey(Schema.Array(Schema.Struct({
+        dependency: Schema.NonEmptyString,
+        path: Schema.NonEmptyString,
+    }))),
+    providerDependencies: Schema.optionalKey(Schema.Array(Schema.Struct({
+        cwd: Schema.NonEmptyString,
+        section: DependencySection,
+        slot: ProviderSlot,
+    }))),
+    providerSlots: Schema.optionalKey(Schema.Struct({
+        auth: Schema.optionalKey(SlotRequirement),
+        cms: Schema.optionalKey(SlotRequirement),
+        commerce: Schema.optionalKey(SlotRequirement),
+        search: Schema.optionalKey(SlotRequirement),
+    })),
+    selections: Schema.optionalKey(Schema.Struct({
+        addOns: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
+        providers: Schema.optionalKey(Selection.fields.providers),
+    })),
+    slot: Schema.optionalKey(ProviderSlot),
+    typeScriptAliases: Schema.optionalKey(Schema.Array(Schema.Struct({
+        alias: Schema.NonEmptyString,
+        cwd: Schema.NonEmptyString,
+        sourcePath: Schema.NonEmptyString,
+    }))),
+});
+const validateProviderRequirements = Effect.fn("Composition.validateProviderRequirements")(function* (metadata, selection) {
+    for (const slot of ["auth", "cms", "commerce", "search"]) {
+        const requirement = metadata.providerSlots?.[slot];
+        const present = selection.providers[slot] !== undefined;
+        if ((requirement === "required" && !present) ||
+            (requirement === "forbidden" && present)) {
+            return yield* new InvalidComposition({
+                message: `${metadata.id} ${requirement === "required" ? "requires" : "forbids"} ${slot === "auth" ? "an" : "a"} ${slot} provider`,
+            });
+        }
+    }
+});
+const resolvePackageBindings = Effect.fn("Composition.resolvePackageBindings")(function* (metadataByName, references, selectedItems, selection) {
+    const ownedRequirements = [];
+    const ownedAliases = [];
+    for (const metadata of metadataByName.values()) {
+        for (const alias of metadata.typeScriptAliases ?? []) {
+            ownedAliases.push({
+                alias: alias.alias,
+                cwd: alias.cwd === "." ? "." : yield* relativeFile(alias.cwd),
+            });
+        }
+        for (const requirement of metadata.packages ?? []) {
+            ownedRequirements.push({
+                name: requirement.name,
+                section: requirement.section,
+                target: yield* manifestTarget(requirement.cwd),
+            });
+        }
+        for (const dependency of metadata.providerDependencies ?? []) {
+            ownedAliases.push({
+                alias: providerAliases[dependency.slot],
+                cwd: dependency.cwd === "." ? "." : yield* relativeFile(dependency.cwd),
+            });
+            ownedRequirements.push({
+                name: providerAliases[dependency.slot],
+                section: dependency.section,
+                target: yield* manifestTarget(dependency.cwd),
+            });
+        }
+    }
+    const requirements = [];
+    const aliases = [];
+    for (const item of selectedItems) {
+        const metadata = metadataByName.get(item.name);
+        if (metadata) {
+            yield* validateProviderRequirements(metadata, selection);
+        }
+        for (const alias of metadata?.typeScriptAliases ?? []) {
+            aliases.push({
+                alias: alias.alias,
+                cwd: alias.cwd === "." ? "." : yield* relativeFile(alias.cwd),
+                sourcePath: yield* relativeFile(alias.sourcePath),
+            });
+        }
+        for (const requirement of metadata?.packages ?? []) {
+            requirements.push({
+                name: requirement.name,
+                section: requirement.section,
+                specifier: requirement.specifier,
+                target: yield* manifestTarget(requirement.cwd),
+            });
+        }
+        for (const dependency of metadata?.providerDependencies ?? []) {
+            const reference = selection.providers[dependency.slot];
+            const binding = metadataByName.get(references.get(reference ?? "") ?? "")?.binding;
+            if (!binding) {
+                return yield* new InvalidComposition({
+                    message: `${metadata?.id} needs a ${dependency.slot} provider binding`,
+                });
+            }
+            requirements.push({
+                name: providerAliases[dependency.slot],
+                section: dependency.section,
+                specifier: binding.specifier,
+                target: yield* manifestTarget(dependency.cwd),
+            });
+            if (binding.sourcePath) {
+                aliases.push({
+                    alias: providerAliases[dependency.slot],
+                    cwd: dependency.cwd === "."
+                        ? "."
+                        : yield* relativeFile(dependency.cwd),
+                    sourcePath: yield* relativeFile(binding.sourcePath),
+                });
+            }
+        }
+    }
+    const uniqueAliases = new Map();
+    for (const alias of aliases) {
+        const key = `${alias.cwd}\0${alias.alias}`;
+        const previous = uniqueAliases.get(key);
+        if (previous && previous.sourcePath !== alias.sourcePath) {
+            return yield* new InvalidComposition({
+                message: `${alias.cwd} maps ${alias.alias} to both ${previous.sourcePath} and ${alias.sourcePath}`,
+            });
+        }
+        uniqueAliases.set(key, alias);
+    }
+    return {
+        aliases: [...uniqueAliases.values()],
+        ownedAliases,
+        ownedRequirements,
+        requirements,
+    };
+});
+const validateCompatibility = Effect.fn("Composition.validateCompatibility")(function* (metadataByName, selectedItems) {
+    const selectedIds = new Set(selectedItems.flatMap((item) => {
+        const metadata = metadataByName.get(item.name);
+        return metadata ? [metadata.id] : [];
+    }));
+    for (const item of selectedItems) {
+        const metadata = metadataByName.get(item.name);
+        const missing = (metadata?.compatibility?.requires ?? []).filter((id) => !selectedIds.has(id));
+        const conflicts = (metadata?.compatibility?.conflicts ?? []).filter((id) => selectedIds.has(id));
+        if (metadata && (missing.length || conflicts.length)) {
+            return yield* new IncompatibleSelection({
+                conflicts,
+                missing,
+                selection: metadata.id,
+            });
+        }
+    }
+});
+const resolveAssets = Effect.fn("Composition.resolveAssets")(function* (metadataByName, selected) {
+    const assets = [];
+    const patches = new Map();
+    const ownedAssetTargets = new Set();
+    for (const [name, metadata] of metadataByName) {
+        for (const asset of metadata.assets ?? []) {
+            const target = yield* relativeFile(asset.target);
+            ownedAssetTargets.add(target);
+            if (selected.has(name)) {
+                assets.push({
+                    owner: name,
+                    source: yield* relativeFile(asset.source),
+                    target,
+                });
+            }
+        }
+        if (selected.has(name)) {
+            for (const patch of metadata.pnpmPatches ?? []) {
+                const target = yield* relativeFile(patch.path);
+                const previous = patches.get(patch.dependency);
+                if (previous && previous !== target) {
+                    return yield* new InvalidComposition({
+                        message: `Conflicting patches for ${patch.dependency}: ${previous}, ${target}`,
+                    });
+                }
+                patches.set(patch.dependency, target);
+            }
+        }
+    }
+    const assetTargets = new Set(assets.map((asset) => asset.target));
+    for (const [dependency, target] of patches) {
+        if (!assetTargets.has(target)) {
+            return yield* new InvalidComposition({
+                message: `${dependency} references ${target}, which is not a selected asset`,
+            });
+        }
+    }
+    return { assets, ownedAssetTargets, patches };
+});
+export const registryIndex = Effect.fn("Composition.registryIndex")(function* (registry, acquiredReferences = new Map()) {
+    const items = new Map(registry.items.map((item) => [item.name, item]));
+    if (items.size !== registry.items.length) {
+        return yield* new InvalidComposition({
+            message: "Registry item names must be unique.",
+        });
+    }
+    const references = new Map([
+        ...registry.items.map((item) => [item.name, item.name]),
+        ...acquiredReferences,
+    ]);
+    const repository = /^https:\/\/github\.com\/(?<repository>[^/]+\/[^/]+?)(?:\.git)?\/?$/u.exec(registry.homepage ?? "")?.groups?.repository;
+    if (repository) {
+        for (const item of registry.items) {
+            references.set(`${repository}/${item.name}`, item.name);
+        }
+    }
+    const metadataByName = new Map();
+    for (const item of registry.items) {
+        if (item.meta?.nextHydra !== undefined) {
+            const metadata = yield* Schema.decodeUnknownEffect(Metadata)(item.meta.nextHydra, { onExcessProperty: "error" }).pipe(Effect.mapError(() => new InvalidComposition({
+                message: `Unsupported or invalid selection metadata: ${item.name}`,
+            })));
+            if (metadata.kind !== "provider" && (metadata.slot || metadata.binding)) {
+                return yield* new InvalidComposition({
+                    message: `${metadata.id}: only providers may declare a slot or binding`,
+                });
+            }
+            if (metadata.kind === "provider" &&
+                (!metadata.slot || !metadata.binding)) {
+                return yield* new InvalidComposition({
+                    message: `${metadata.id}: a provider requires both a slot and binding`,
+                });
+            }
+            if ((metadata.kind === "preset") !==
+                (metadata.selections !== undefined)) {
+                return yield* new InvalidComposition({
+                    message: `${metadata.id}: selections belong to presets and are required for them`,
+                });
+            }
+            if (metadata.kind === "preset" &&
+                (metadata.providerDependencies?.length ?? 0) > 0) {
+                return yield* new InvalidComposition({
+                    message: `${metadata.id}: a preset cannot declare provider dependencies`,
+                });
+            }
+            for (const requirement of metadata.packages ?? []) {
+                if (Object.values(providerAliases).some((alias) => alias === requirement.name)) {
+                    return yield* new InvalidComposition({
+                        message: `${requirement.name} must be declared through providerDependencies`,
+                    });
+                }
+            }
+            if (references.has(metadata.id) &&
+                references.get(metadata.id) !== item.name) {
+                return yield* new InvalidComposition({
+                    message: `Duplicate selection ID: ${metadata.id}`,
+                });
+            }
+            references.set(metadata.id, item.name);
+            metadataByName.set(item.name, metadata);
+            if (metadata.providerSlots &&
+                metadata.kind !== "package" &&
+                metadata.kind !== "recipe") {
+                return yield* new InvalidComposition({
+                    message: `${metadata.id} must be a package or recipe to declare provider requirements`,
+                });
+            }
+        }
+    }
+    for (const [alias, id] of Object.entries(officialReferences)) {
+        const name = references.get(id);
+        if (name) {
+            references.set(alias, name);
+        }
+    }
+    return { items, metadataByName, references };
+});
+export const resolveSelection = Effect.fn("Composition.resolveSelection")(function* (index, request) {
+    const decoded = yield* Schema.decodeEffect(SelectionRequest)(request, {
+        onExcessProperty: "error",
+    });
+    if (!("preset" in decoded)) {
+        return decoded;
+    }
+    const metadata = index.metadataByName.get(index.references.get(decoded.preset) ?? "");
+    if (metadata?.kind !== "preset" || !metadata.selections) {
+        return yield* new InvalidComposition({
+            message: `${decoded.preset} is not a preset`,
+        });
+    }
+    return {
+        addOns: [
+            ...new Set([...(metadata.selections.addOns ?? []), ...decoded.addOns]),
+        ],
+        providers: metadata.selections.providers ?? {},
+    };
+});
+export const selectedConditionalDependencies = (metadata, selection) => (metadata?.conditionalDependencies ?? []).flatMap((dependency) => dependency.providers.every((slot) => selection.providers[slot] !== undefined)
+    ? dependency.items
+    : []);
+export const selectRegistryItems = Effect.fn("Composition.selectRegistryItems")(function* (registry, request, acquiredReferences = new Map()) {
+    const { items, metadataByName, references } = yield* registryIndex(registry, acquiredReferences);
+    const selection = yield* resolveSelection({ items, metadataByName, references }, request);
+    for (const [slot, reference] of Object.entries(selection.providers)) {
+        const metadata = metadataByName.get(references.get(reference) ?? "");
+        if (metadata?.kind !== "provider" ||
+            metadata.slot !== slot ||
+            !metadata.binding) {
+            return yield* new InvalidComposition({
+                message: `${reference} is not a ${slot} provider`,
+            });
+        }
+    }
+    for (const reference of selection.addOns) {
+        const metadata = metadataByName.get(references.get(reference) ?? "");
+        if (metadata?.kind !== "add-on") {
+            return yield* new InvalidComposition({
+                message: `${reference} is not an add-on`,
+            });
+        }
+    }
+    if (!references.has("app-web")) {
+        return yield* new InvalidComposition({
+            message: "The source registry must include the shared app-web application",
+        });
+    }
+    const pending = [
+        "app-web",
+        ...Object.values(selection.providers),
+        ...selection.addOns,
+    ];
+    const selected = new Set();
+    const selectedItems = [];
+    while (pending.length > 0) {
+        const reference = pending.pop();
+        if (reference === undefined) {
+            break;
+        }
+        const name = references.get(reference);
+        if (!name) {
+            return yield* new InvalidComposition({
+                message: `Unknown registry selection: ${reference}`,
+            });
+        }
+        if (selected.has(name)) {
+            continue;
+        }
+        selected.add(name);
+        const item = items.get(name);
+        if (!item) {
+            return yield* new InvalidComposition({
+                message: `Missing registry item: ${name}`,
+            });
+        }
+        selectedItems.push(item);
+        pending.push(...(item.registryDependencies ?? []));
+        const metadata = metadataByName.get(name);
+        if (metadata?.kind === "preset") {
+            return yield* new InvalidComposition({
+                message: `${metadata.id} is a preset, not a materializable selection; resolve its selections first`,
+            });
+        }
+        for (const recipeReference of selectedConditionalDependencies(metadata, selection)) {
+            const target = metadataByName.get(references.get(recipeReference) ?? "");
+            if (target?.kind !== "recipe" && target?.kind !== "package") {
+                return yield* new InvalidComposition({
+                    message: `${recipeReference} must be a package or composition recipe`,
+                });
+            }
+            pending.push(recipeReference);
+        }
+    }
+    yield* validateCompatibility(metadataByName, selectedItems);
+    const bindings = yield* resolvePackageBindings(metadataByName, references, selectedItems, selection);
+    const assets = yield* resolveAssets(metadataByName, selected);
+    return {
+        ...bindings,
+        ...assets,
+        references,
+        selectedItems,
+    };
+});

package/dist/shadcn-protocol.d.ts

@@ -0,0 +1,22 @@
+import { Schema } from "effect";
+export declare const Request: Schema.Struct<{
+    readonly application: Schema.String;
+    readonly entries: Schema.$Array<Schema.String>;
+    readonly overwrite: Schema.Boolean;
+}>;
+export declare const Outcome: Schema.Union<readonly [Schema.TaggedStruct<"Success", {}>, Schema.TaggedStruct<"RegistryFailure", {
+    readonly diagnostic: Schema.String;
+}>, Schema.TaggedStruct<"WorkerDefect", {
+    readonly diagnostic: Schema.String;
+}>]>;
+export declare const RequestJson: Schema.fromJsonString<Schema.Struct<{
+    readonly application: Schema.String;
+    readonly entries: Schema.$Array<Schema.String>;
+    readonly overwrite: Schema.Boolean;
+}>>;
+export declare const OutcomeJson: Schema.fromJsonString<Schema.Union<readonly [Schema.TaggedStruct<"Success", {}>, Schema.TaggedStruct<"RegistryFailure", {
+    readonly diagnostic: Schema.String;
+}>, Schema.TaggedStruct<"WorkerDefect", {
+    readonly diagnostic: Schema.String;
+}>]>>;
+//# sourceMappingURL=shadcn-protocol.d.ts.map

package/dist/shadcn-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadcn-protocol.d.ts","sourceRoot":"","sources":["../src/shadcn-protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,eAAO,MAAM,OAAO;;;;EAIlB,CAAC;AACH,eAAO,MAAM,OAAO;;;;IAIlB,CAAC;AACH,eAAO,MAAM,WAAW;;;;GAAiC,CAAC;AAC1D,eAAO,MAAM,WAAW;;;;KAAiC,CAAC"}

package/dist/shadcn-protocol.js

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+export const Request = Schema.Struct({
+    application: Schema.String,
+    entries: Schema.Array(Schema.String),
+    overwrite: Schema.Boolean,
+});
+export const Outcome = Schema.Union([
+    Schema.TaggedStruct("Success", {}),
+    Schema.TaggedStruct("RegistryFailure", { diagnostic: Schema.String }),
+    Schema.TaggedStruct("WorkerDefect", { diagnostic: Schema.String }),
+]);
+export const RequestJson = Schema.fromJsonString(Request);
+export const OutcomeJson = Schema.fromJsonString(Outcome);

package/dist/shadcn-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shadcn-worker.d.ts.map

package/dist/shadcn-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadcn-worker.d.ts","sourceRoot":"","sources":["../src/shadcn-worker.ts"],"names":[],"mappings":""}

package/dist/shadcn-worker.js

@@ -0,0 +1,43 @@
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import { Cause, Effect, FileSystem, Schema } from "effect";
+import { addRegistryItems } from "shadcn/registry";
+import { OutcomeJson, RequestJson } from "./shadcn-protocol.js";
+const main = Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const [requestPath, resultPath] = process.argv.slice(2);
+    if (!requestPath || !resultPath) {
+        return yield* Effect.die(new Error("Missing worker control paths"));
+    }
+    const result = yield* Effect.gen(function* () {
+        const request = yield* fs
+            .readFileString(requestPath)
+            .pipe(Effect.flatMap(Schema.decodeEffect(RequestJson)));
+        return yield* Effect.tryPromise({
+            catch: (error) => error instanceof Error
+                ? error.message.slice(0, 8192)
+                : "Registry operation failed",
+            try: async () => {
+                await addRegistryItems([...request.entries], {
+                    config: {},
+                    cwd: request.application,
+                    overwrite: request.overwrite,
+                    silent: true,
+                });
+            },
+        }).pipe(Effect.match({
+            onFailure: (diagnostic) => ({
+                _tag: "RegistryFailure",
+                diagnostic,
+            }),
+            onSuccess: () => ({ _tag: "Success" }),
+        }));
+    }).pipe(Effect.catchCause((cause) => Cause.hasInterrupts(cause)
+        ? Effect.failCause(cause)
+        : Effect.succeed({
+            _tag: "WorkerDefect",
+            diagnostic: Cause.pretty(cause).slice(0, 8192),
+        })));
+    const encoded = yield* Schema.encodeEffect(OutcomeJson)(result);
+    yield* fs.writeFileString(resultPath, encoded, { mode: 0o600 });
+});
+NodeRuntime.runMain(main.pipe(Effect.provide(NodeServices.layer)));

package/dist/shadcn.d.ts

@@ -0,0 +1,22 @@
+import { Context, Effect, FileSystem, Layer, Path, Schema } from "effect";
+import type { PlatformError } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { getRegistryItems, loadRegistry, loadRegistryItem } from "shadcn/registry";
+import type { RegistryItem } from "shadcn/schema";
+import { RegistryFailure, RegistryWorkerFailure } from "./errors.ts";
+import type { RegistryInstallation } from "./staging.ts";
+type LoadOptions = Parameters<typeof loadRegistry>[0];
+export type RegistryCatalog = Omit<Awaited<ReturnType<typeof loadRegistry>>, "items"> & {
+    readonly items: readonly RegistryItem[];
+};
+declare const Shadcn_base: Context.ServiceClass<Shadcn, "create-next-hydra/Shadcn", {
+    readonly getRegistryItems: (references: readonly string[], cwd: string) => Effect.Effect<Awaited<ReturnType<typeof getRegistryItems>>, RegistryFailure>;
+    readonly loadRegistry: (options: LoadOptions) => Effect.Effect<Awaited<ReturnType<typeof loadRegistry>>, RegistryFailure>;
+    readonly loadRegistryItem: (name: string, options: LoadOptions) => Effect.Effect<Awaited<ReturnType<typeof loadRegistryItem>>, RegistryFailure>;
+    readonly install: (staging: RegistryInstallation, entries: readonly string[], overwrite?: boolean) => Effect.Effect<void, RegistryFailure | RegistryWorkerFailure | PlatformError.PlatformError | Schema.SchemaError>;
+}>;
+export declare class Shadcn extends Shadcn_base {
+    static layer: (worker?: import("url").URL) => Layer.Layer<Shadcn, never, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
+}
+export {};
+//# sourceMappingURL=shadcn.d.ts.map

package/dist/shadcn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadcn.d.ts","sourceRoot":"","sources":["../src/shadcn.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,OAAO,EACP,MAAM,EACN,UAAU,EACV,KAAK,EACL,IAAI,EAEJ,MAAM,EACP,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EAAgB,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC5E,OAAO,EAEL,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EACjB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAIrE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AACtD,MAAM,MAAM,eAAe,GAAG,IAAI,CAChC,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,EACxC,OAAO,CACR,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAA;CAAE,CAAC;;+BAKjB,CACzB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,GAAG,EAAE,MAAM,KACR,MAAM,CAAC,MAAM,CAChB,OAAO,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,EAC5C,eAAe,CAChB;2BACsB,CACrB,OAAO,EAAE,WAAW,KACjB,MAAM,CAAC,MAAM,CAChB,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,EACxC,eAAe,CAChB;+BAC0B,CACzB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,WAAW,KACjB,MAAM,CAAC,MAAM,CAChB,OAAO,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,EAC5C,eAAe,CAChB;sBACiB,CAChB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,SAAS,CAAC,EAAE,OAAO,KAChB,MAAM,CAAC,MAAM,CAChB,IAAI,EACF,eAAe,GACf,qBAAqB,GACrB,aAAa,CAAC,aAAa,GAC3B,MAAM,CAAC,WAAW,CACrB;;AAjCL,qBAAa,MAAO,SAAQ,WAmCG;IAC7B,MAAM,CAAC,KAAK,GAAI,0BAAqD,6GAwJjE;CACL"}

package/dist/shadcn.js

@@ -0,0 +1,101 @@
+import { fileURLToPath } from "node:url";
+import { Context, Effect, FileSystem, Layer, Path, Redacted, Schema, } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { getRegistriesConfig, getRegistryItems, loadRegistry, loadRegistryItem, } from "shadcn/registry";
+import { RegistryFailure, RegistryWorkerFailure } from "./errors.js";
+import { confirmStopped, groupExists } from "./process-group.js";
+import { OutcomeJson, RequestJson } from "./shadcn-protocol.js";
+import { stopped, writing } from "./staging.js";
+export class Shadcn extends Context.Service()("create-next-hydra/Shadcn") {
+    static layer = (worker = new URL("shadcn-worker.js", import.meta.url)) => Layer.effect(Shadcn, Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+        return Shadcn.of({
+            getRegistryItems: (references, cwd) => Effect.tryPromise({
+                catch: (error) => new RegistryFailure({
+                    diagnostic: Redacted.make(error instanceof Error
+                        ? error.message
+                        : "Registry acquisition failed"),
+                    operation: "acquire registry artifacts",
+                }),
+                try: async () => await getRegistryItems([...references], {
+                    config: await getRegistriesConfig(cwd),
+                }),
+            }).pipe(Effect.uninterruptible),
+            install: Effect.fn("Shadcn.install")(function* (staging, entries, overwrite = true) {
+                if (process.platform === "win32") {
+                    return yield* new RegistryWorkerFailure({ phase: "launch" });
+                }
+                const requestPath = path.join(staging.control, "request.json");
+                const resultPath = path.join(staging.control, "result.json");
+                const request = yield* Schema.encodeEffect(RequestJson)({
+                    application: staging.application,
+                    entries,
+                    overwrite,
+                });
+                yield* fs
+                    .writeFileString(requestPath, request, { mode: 0o600 })
+                    .pipe(Effect.uninterruptible);
+                yield* Effect.scoped(Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+                    yield* writing(staging);
+                    const handle = yield* spawner
+                        .spawn(ChildProcess.make(process.execPath, [fileURLToPath(worker), requestPath, resultPath], {
+                        cwd: staging.application,
+                        forceKillAfter: "100 millis",
+                        stderr: "ignore",
+                        stdin: "ignore",
+                        stdout: "ignore",
+                    }))
+                        .pipe(Effect.tapError(() => stopped(staging)), Effect.mapError(() => new RegistryWorkerFailure({ phase: "launch" })));
+                    yield* restore(Effect.gen(function* () {
+                        const code = yield* handle.exitCode.pipe(Effect.mapError(() => new RegistryWorkerFailure({ phase: "exit" })));
+                        if (code !== 0 ||
+                            (yield* groupExists(handle.pid).pipe(Effect.mapError(() => new RegistryWorkerFailure({ phase: "stop" }))))) {
+                            return yield* new RegistryWorkerFailure({
+                                phase: "exit",
+                            });
+                        }
+                    })).pipe(Effect.onExit(() => confirmStopped(handle).pipe(Effect.mapError(() => new RegistryWorkerFailure({ phase: "stop" })), Effect.andThen(stopped(staging)), 
+                    // Prevent an unbounded second termination attempt by the process scope.
+                    Effect.onExit(() => handle.unref.pipe(Effect.asVoid)))));
+                })));
+                if ((yield* fs.stat(resultPath)).size > 65_536) {
+                    return yield* new RegistryWorkerFailure({ phase: "protocol" });
+                }
+                const outcome = yield* fs.readFileString(resultPath).pipe(Effect.flatMap(Schema.decodeEffect(OutcomeJson)), Effect.mapError(() => new RegistryWorkerFailure({ phase: "protocol" })));
+                if (outcome._tag === "RegistryFailure") {
+                    return yield* new RegistryFailure({
+                        diagnostic: Redacted.make(outcome.diagnostic),
+                        operation: "install registry items",
+                    });
+                }
+                if (outcome._tag === "WorkerDefect") {
+                    return yield* Effect.die({
+                        diagnostic: Redacted.make(outcome.diagnostic),
+                        message: "Registry worker defect",
+                    });
+                }
+            }),
+            // The upstream read API has no cancellation signal. Join before releasing inputs.
+            loadRegistry: (options) => Effect.tryPromise({
+                catch: (error) => new RegistryFailure({
+                    diagnostic: Redacted.make(error instanceof Error
+                        ? error.message
+                        : "Registry loading failed"),
+                    operation: "load registry",
+                }),
+                try: async () => await loadRegistry(options),
+            }).pipe(Effect.uninterruptible),
+            loadRegistryItem: (name, options) => Effect.tryPromise({
+                catch: (error) => new RegistryFailure({
+                    diagnostic: Redacted.make(error instanceof Error
+                        ? error.message
+                        : "Registry hydration failed"),
+                    operation: "hydrate registry item",
+                }),
+                try: async () => await loadRegistryItem(name, options),
+            }).pipe(Effect.uninterruptible),
+        });
+    }));
+}