create-next-hydra 0.2.1 → 0.4.1

package/dist/tasks.d.ts

@@ -0,0 +1,44 @@
+import { Effect, Schema } from "effect";
+import type { PreparedFile } from "./model.ts";
+/** Cache correctness is application policy, shared by customer and named workspaces regardless of deployment location. */
+export declare const applicationTasks: (files: readonly PreparedFile[]) => Effect.Effect<{
+    envMode: string;
+    futureFlags: {
+        affectedUsingTaskInputs: boolean;
+    };
+    tasks: {
+        build: {
+            dependsOn: string[];
+            env: string[];
+            inputs: string[];
+            outputs: string[];
+        };
+        dev: {
+            cache: boolean;
+            passThroughEnv: string[];
+            persistent: boolean;
+        };
+        e2e: {
+            cache: boolean;
+        };
+        "e2e:list": {
+            cache: boolean;
+        };
+        test: {
+            dependsOn: string[];
+            env: string[];
+            inputs: string[];
+        };
+        typecheck: {
+            dependsOn: string[];
+            env: string[];
+            inputs: string[];
+        };
+    } & Record<`${string}#build`, {
+        dependsOn: string[];
+        env: string[];
+        inputs: string[];
+        outputs: string[];
+    }>;
+}, Schema.SchemaError, never>;
+//# sourceMappingURL=tasks.d.ts.map

package/dist/tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../src/tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAa/C,0HAA0H;AAC1H,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA2I5B,CAAC"}

package/dist/tasks.js

@@ -0,0 +1,137 @@
+import { Effect, Schema } from "effect";
+import { cacheDirectories, environmentFileType } from "./file-policy.js";
+import { internalDependencies, ManifestJson } from "./packages.js";
+const nonSourceDirectories = [
+    ...cacheDirectories,
+    ".git",
+    "coverage",
+    ".features-gen",
+    "playwright-report",
+    "test-results",
+    ".workflow-data",
+];
+/** Cache correctness is application policy, shared by customer and named workspaces regardless of deployment location. */
+export const applicationTasks = Effect.fn("Composition.applicationTasks")(function* (files) {
+    const buildEnvironment = [
+        "ANALYZE",
+        "NODE_ENV",
+        "VERCEL",
+        "VERCEL_ENV",
+        "VERCEL_PROJECT_PRODUCTION_URL",
+        // Sentry uploads must retry when their destination or credentials change.
+        "SENTRY_ORG",
+        "SENTRY_PROJECT",
+        "SENTRY_AUTH_TOKEN",
+    ];
+    const packages = new Map();
+    const environment = new Map();
+    for (const file of files) {
+        if (file.target === "package.json" ||
+            !file.target.endsWith("/package.json")) {
+            continue;
+        }
+        const manifest = yield* Schema.decodeEffect(ManifestJson)(new TextDecoder().decode(file.content));
+        if (manifest.name !== undefined) {
+            packages.set(manifest.name, {
+                dependencies: internalDependencies(manifest),
+                directory: file.target.slice(0, -"/package.json".length),
+            });
+        }
+    }
+    for (const file of files) {
+        if (environmentFileType(file.target) === undefined) {
+            continue;
+        }
+        const directory = file.target
+            .slice(0, file.target.lastIndexOf("/") + 1)
+            .replace(/\/$/u, "");
+        const names = environment.get(directory) ?? new Set();
+        environment.set(directory, names);
+        for (const match of new TextDecoder()
+            .decode(file.content)
+            .matchAll(/^\s*(?:export\s+)?(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*=/gmu)) {
+            if (match.groups?.name &&
+                !match.groups.name.startsWith("NEXT_PUBLIC_")) {
+                names.add(match.groups.name);
+            }
+        }
+    }
+    // Explicit inputs include physical sources under Git-ignored development workspaces.
+    const inputs = [
+        "**/*",
+        ...nonSourceDirectories.map((directory) => `!**/${directory}/**`),
+        "!**/*.tsbuildinfo",
+        "!next-env.d.ts",
+        "!next.config.compiled.js",
+        "!app/.well-known/workflow/**",
+    ];
+    const build = {
+        dependsOn: ["^build", "typecheck", "test"],
+        env: buildEnvironment,
+        inputs,
+        outputs: [".next/**", "!.next/cache/**", "!.next/dev/**"],
+    };
+    const builds = {};
+    for (const [name, app] of packages) {
+        if (!app.directory.startsWith("apps/")) {
+            continue;
+        }
+        const names = new Set([
+            ...buildEnvironment,
+            ...(environment.get("") ?? []),
+        ]);
+        const visited = new Set();
+        const collect = (packageName) => {
+            if (visited.has(packageName)) {
+                return;
+            }
+            visited.add(packageName);
+            const selected = packages.get(packageName);
+            if (selected === undefined) {
+                return;
+            }
+            for (const [directory, variables] of environment) {
+                if (directory === selected.directory ||
+                    directory.startsWith(`${selected.directory}/`)) {
+                    for (const variable of variables) {
+                        names.add(variable);
+                    }
+                }
+            }
+            for (const dependency of selected.dependencies) {
+                collect(dependency);
+            }
+        };
+        collect(name);
+        // Root package-specific tasks replace the generic definition entirely.
+        builds[`${name}#build`] = { ...build, env: [...names] };
+    }
+    // Unit tests use fixtures rather than deployment environment files.
+    const testInputs = [...inputs, "!**/.env", "!**/.env.*"];
+    const tasks = {
+        build,
+        dev: {
+            cache: false,
+            passThroughEnv: ["PORTLESS_*"],
+            persistent: true,
+        },
+        e2e: { cache: false },
+        "e2e:list": { cache: false },
+        test: {
+            dependsOn: ["^test"],
+            env: ["!NEXT_PUBLIC_*"],
+            inputs: testInputs,
+        },
+        typecheck: {
+            dependsOn: ["^typecheck"],
+            env: ["!NEXT_PUBLIC_*"],
+            inputs,
+        },
+    };
+    const scopedTasks = { ...tasks, ...builds };
+    return {
+        envMode: "loose",
+        futureFlags: { affectedUsingTaskInputs: true },
+        tasks: scopedTasks,
+    };
+});

package/dist/templates.d.ts

@@ -0,0 +1,217 @@
+import { Effect, Schema } from "effect";
+import { InvalidComposition } from "./errors.ts";
+export declare const Binding: Schema.Struct<{
+    readonly as: Schema.optionalKey<Schema.String>;
+    readonly export: Schema.String;
+    readonly module: Schema.NonEmptyString;
+    readonly order: Schema.optionalKey<Schema.Int>;
+    readonly slot: Schema.NonEmptyString;
+    readonly target: Schema.NonEmptyString;
+}>;
+declare const Template: Schema.Struct<{
+    readonly slots: Schema.$Record<Schema.String, Schema.Literals<readonly ["members", "wrapper", "element", "call", "factory", "graphql"]>>;
+    readonly source: Schema.NonEmptyString;
+    readonly target: Schema.NonEmptyString;
+}>;
+export declare const TemplateDefinition: Schema.Struct<{
+    readonly slotBindings: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly as: Schema.optionalKey<Schema.String>;
+        readonly export: Schema.String;
+        readonly module: Schema.NonEmptyString;
+        readonly order: Schema.optionalKey<Schema.Int>;
+        readonly slot: Schema.NonEmptyString;
+        readonly target: Schema.NonEmptyString;
+    }>>>;
+    readonly templates: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly slots: Schema.$Record<Schema.String, Schema.Literals<readonly ["members", "wrapper", "element", "call", "factory", "graphql"]>>;
+        readonly source: Schema.NonEmptyString;
+        readonly target: Schema.NonEmptyString;
+    }>>>;
+}>;
+export type Template = typeof Template.Type;
+export type Binding = typeof Binding.Type & {
+    readonly owner: string;
+};
+export declare const readTemplateDefinitions: (items: readonly ({
+    type: "registry:base";
+    name: string;
+    tailwind?: {
+        config?: {
+            theme?: Record<string, any> | undefined;
+            content?: string[] | undefined;
+            plugins?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+    docs?: string | undefined;
+    $schema?: string | undefined;
+    config?: {
+        tailwind?: {
+            baseColor?: string | undefined;
+            config?: string | undefined;
+            css?: string | undefined;
+            cssVariables?: boolean | undefined;
+            prefix?: string | undefined;
+        } | undefined;
+        menuColor?: "default" | "inverted" | "default-translucent" | "inverted-translucent" | undefined;
+        menuAccent?: "subtle" | "bold" | undefined;
+        iconLibrary?: string | undefined;
+        style?: string | undefined;
+        $schema?: string | undefined;
+        rsc?: boolean | undefined;
+        tsx?: boolean | undefined;
+        rtl?: boolean | undefined;
+        aliases?: {
+            components?: string | undefined;
+            ui?: string | undefined;
+            utils?: string | undefined;
+            lib?: string | undefined;
+            hooks?: string | undefined;
+        } | undefined;
+        registries?: Record<string, string | {
+            url: string;
+            params?: Record<string, string> | undefined;
+            headers?: Record<string, string> | undefined;
+        }> | undefined;
+    } | undefined;
+    css?: Record<string, any> | undefined;
+    extends?: string | undefined;
+    title?: string | undefined;
+    author?: string | undefined;
+    description?: string | undefined;
+    dependencies?: string[] | undefined;
+    devDependencies?: string[] | undefined;
+    registryDependencies?: string[] | undefined;
+    files?: ({
+        path: string;
+        type: "registry:page" | "registry:file";
+        target: string;
+        content?: string | undefined;
+    } | {
+        path: string;
+        type: "registry:lib" | "registry:block" | "registry:component" | "registry:ui" | "registry:hook" | "registry:theme" | "registry:style" | "registry:item" | "registry:base" | "registry:font" | "registry:example" | "registry:internal";
+        content?: string | undefined;
+        target?: string | undefined;
+    })[] | undefined;
+    cssVars?: {
+        theme?: Record<string, string> | undefined;
+        light?: Record<string, string> | undefined;
+        dark?: Record<string, string> | undefined;
+    } | undefined;
+    envVars?: Record<string, string> | undefined;
+    meta?: Record<string, any> | undefined;
+    categories?: string[] | undefined;
+} | {
+    font: {
+        family: string;
+        provider: "google";
+        import: string;
+        variable: string;
+        weight?: string[] | undefined;
+        subsets?: string[] | undefined;
+        selector?: string | undefined;
+        dependency?: string | undefined;
+    };
+    type: "registry:font";
+    name: string;
+    tailwind?: {
+        config?: {
+            theme?: Record<string, any> | undefined;
+            content?: string[] | undefined;
+            plugins?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+    docs?: string | undefined;
+    $schema?: string | undefined;
+    css?: Record<string, any> | undefined;
+    extends?: string | undefined;
+    title?: string | undefined;
+    author?: string | undefined;
+    description?: string | undefined;
+    dependencies?: string[] | undefined;
+    devDependencies?: string[] | undefined;
+    registryDependencies?: string[] | undefined;
+    files?: ({
+        path: string;
+        type: "registry:page" | "registry:file";
+        target: string;
+        content?: string | undefined;
+    } | {
+        path: string;
+        type: "registry:lib" | "registry:block" | "registry:component" | "registry:ui" | "registry:hook" | "registry:theme" | "registry:style" | "registry:item" | "registry:base" | "registry:font" | "registry:example" | "registry:internal";
+        content?: string | undefined;
+        target?: string | undefined;
+    })[] | undefined;
+    cssVars?: {
+        theme?: Record<string, string> | undefined;
+        light?: Record<string, string> | undefined;
+        dark?: Record<string, string> | undefined;
+    } | undefined;
+    envVars?: Record<string, string> | undefined;
+    meta?: Record<string, any> | undefined;
+    categories?: string[] | undefined;
+} | {
+    type: "registry:lib" | "registry:block" | "registry:component" | "registry:ui" | "registry:hook" | "registry:page" | "registry:file" | "registry:theme" | "registry:style" | "registry:item" | "registry:example" | "registry:internal";
+    name: string;
+    tailwind?: {
+        config?: {
+            theme?: Record<string, any> | undefined;
+            content?: string[] | undefined;
+            plugins?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+    docs?: string | undefined;
+    $schema?: string | undefined;
+    css?: Record<string, any> | undefined;
+    extends?: string | undefined;
+    title?: string | undefined;
+    author?: string | undefined;
+    description?: string | undefined;
+    dependencies?: string[] | undefined;
+    devDependencies?: string[] | undefined;
+    registryDependencies?: string[] | undefined;
+    files?: ({
+        path: string;
+        type: "registry:page" | "registry:file";
+        target: string;
+        content?: string | undefined;
+    } | {
+        path: string;
+        type: "registry:lib" | "registry:block" | "registry:component" | "registry:ui" | "registry:hook" | "registry:theme" | "registry:style" | "registry:item" | "registry:base" | "registry:font" | "registry:example" | "registry:internal";
+        content?: string | undefined;
+        target?: string | undefined;
+    })[] | undefined;
+    cssVars?: {
+        theme?: Record<string, string> | undefined;
+        light?: Record<string, string> | undefined;
+        dark?: Record<string, string> | undefined;
+    } | undefined;
+    envVars?: Record<string, string> | undefined;
+    meta?: Record<string, any> | undefined;
+    categories?: string[] | undefined;
+})[], published: ReadonlySet<string>) => Effect.Effect<Map<string, {
+    readonly slotBindings?: readonly {
+        readonly export: string;
+        readonly module: string;
+        readonly slot: string;
+        readonly target: string;
+        readonly as?: string | undefined;
+        readonly order?: number | undefined;
+    }[] | undefined;
+    readonly templates?: readonly {
+        readonly slots: {
+            readonly [x: string]: "members" | "wrapper" | "element" | "call" | "factory" | "graphql";
+        };
+        readonly source: string;
+        readonly target: string;
+    }[] | undefined;
+}>, InvalidComposition | Schema.SchemaError, never>;
+export declare const orderBindings: (bindings: readonly Binding[]) => readonly Binding[];
+export declare const renderTemplate: (template: {
+    readonly slots: {
+        readonly [x: string]: "members" | "wrapper" | "element" | "call" | "factory" | "graphql";
+    };
+    readonly source: string;
+    readonly target: string;
+}, bindings: readonly Binding[], source: string) => Effect.Effect<string, InvalidComposition, never>;
+export {};
+//# sourceMappingURL=templates.d.ts.map

package/dist/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../src/templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,MAAM,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAIjD,eAAO,MAAM,OAAO;;;;;;;EAOlB,CAAC;AACH,QAAA,MAAM,QAAQ;;;;EAcZ,CAAC;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;EAG7B,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAC;AAC5C,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvE,eAAO,MAAM,uBAAuB;;;;cAyKwu6B,CAAC;iBAAqB,CAAC;mBAAsD,CAAC;mBAA2C,CAAC;;;;;;gBAAkK,CAAC;qBAAyB,CAAC;kBAAwC,CAAC;eAAqC,CAAC;wBAA8C,CAAC;kBAAyC,CAAC;;iBAA8D,CAAC;kBAAyG,CAAC;mBAAoD,CAAC;aAAmC,CAAC;eAAqC,CAAC;WAAiC,CAAC;WAAkC,CAAC;WAAkC,CAAC;eAAsC,CAAC;sBAA0B,CAAC;cAAoC,CAAC;iBAAuC,CAAC;eAAqC,CAAC;iBAAuC,CAAC;;kBAA+D,CAAC;;kBAAuE,CAAC;mBAAyD,CAAC;;;;;;;;;;;;;;;eAAwgB,CAAC;;;;eAAsT,CAAC;cAAoC,CAAC;;;aAAyE,CAAC;aAAmD,CAAC;YAAkD,CAAC;;;;;;;;;;;cAAu3P,CAAC;eAAuC,CAAC;gBAAwC,CAAC;kBAAwC,CAAC;;;;;cAAyG,CAAC;iBAAqB,CAAC;mBAAsD,CAAC;mBAA2C,CAAC;;;;;;;;;;;;;;;;;eAA0jB,CAAC;;;;eAAsT,CAAC;cAAoC,CAAC;;;aAAyE,CAAC;aAAmD,CAAC;YAAkD,CAAC;;;;;;;;;cAA49M,CAAC;iBAAqB,CAAC;mBAAsD,CAAC;mBAA2C,CAAC;;;;;;;;;;;;;;;;;eAA0jB,CAAC;;;;eAAsT,CAAC;cAAoC,CAAC;;;aAAyE,CAAC;aAAmD,CAAC;YAAkD,CAAC;;;;;;;;;;;;;;;;;;;;;mDAzI1+gD,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,UAAU,SAAS,OAAO,EAAE,KAC3B,SAAS,OAAO,EAOhB,CAAC;AAEJ,eAAO,MAAM,cAAc;;;;;;oGA2H1B,CAAC"}

package/dist/templates.js

@@ -0,0 +1,161 @@
+import { Array as EffectArray, Effect, Order, Schema } from "effect";
+import { format } from "oxfmt";
+import { InvalidComposition } from "./errors.js";
+import { relativeFile } from "./files.js";
+const Identifier = Schema.String.check(Schema.isPattern(/^[A-Za-z_$][\w$]*$/u));
+export const Binding = Schema.Struct({
+    as: Schema.optionalKey(Identifier),
+    export: Identifier,
+    module: Schema.NonEmptyString,
+    order: Schema.optionalKey(Schema.Int),
+    slot: Schema.NonEmptyString,
+    target: Schema.NonEmptyString,
+});
+const Template = Schema.Struct({
+    slots: Schema.Record(Schema.String, Schema.Literals([
+        "members",
+        "wrapper",
+        "element",
+        "call",
+        "factory",
+        "graphql",
+    ])),
+    source: Schema.NonEmptyString,
+    target: Schema.NonEmptyString,
+});
+export const TemplateDefinition = Schema.Struct({
+    slotBindings: Schema.optionalKey(Schema.Array(Binding)),
+    templates: Schema.optionalKey(Schema.Array(Template)),
+});
+export const readTemplateDefinitions = Effect.fn("Composition.templates")(function* (items, published) {
+    const definitions = new Map();
+    for (const item of items) {
+        const definition = yield* Schema.decodeUnknownEffect(TemplateDefinition)(item.meta?.composition ?? {}, { onExcessProperty: "error" });
+        if (published.has(item.name) && (definition.templates?.length ?? 0) > 0) {
+            return yield* new InvalidComposition({
+                message: `Published artifact ${item.name} cannot read source-only templates. Publish materialized files or bindings to templates owned by the source checkout.`,
+            });
+        }
+        const slotBindings = [];
+        for (const binding of definition.slotBindings ?? []) {
+            slotBindings.push({
+                ...binding,
+                target: yield* relativeFile(binding.target),
+            });
+        }
+        const templates = [];
+        for (const template of definition.templates ?? []) {
+            templates.push({
+                ...template,
+                source: yield* relativeFile(template.source),
+                target: yield* relativeFile(template.target),
+            });
+        }
+        definitions.set(item.name, { slotBindings, templates });
+    }
+    return definitions;
+});
+export const orderBindings = (bindings) => EffectArray.sort(bindings, (a, b) => Order.Number(a.order ?? 0, b.order ?? 0) ||
+    Order.String(a.owner, b.owner) ||
+    Order.String(a.export, b.export));
+export const renderTemplate = Effect.fn("Composition.renderTemplate")(function* (template, bindings, source) {
+    const selected = orderBindings(bindings);
+    const locals = selected.map((binding) => binding.as ?? binding.export);
+    if (new Set(locals).size !== locals.length) {
+        return yield* new InvalidComposition({
+            message: `Conflicting imports for ${template.target}`,
+        });
+    }
+    const importsByModule = new Map();
+    for (const binding of selected) {
+        const imports = importsByModule.get(binding.module) ?? [];
+        imports.push(`${binding.export}${binding.as ? ` as ${binding.as}` : ""}`);
+        importsByModule.set(binding.module, imports);
+    }
+    const markers = new Map([
+        [
+            "imports",
+            [...importsByModule]
+                .map(([module, imports]) => `import { ${imports.join(", ")} } from ${JSON.stringify(module)};`)
+                .join("\n"),
+        ],
+    ]);
+    for (const [slot, kind] of Object.entries(template.slots)) {
+        const slotBindings = selected.filter((binding) => binding.slot === slot);
+        const entries = slotBindings.map((binding) => binding.as ?? binding.export);
+        if (kind === "element" && entries.length > 1) {
+            return yield* new InvalidComposition({
+                message: `${template.target}#${slot} accepts at most one element`,
+            });
+        }
+        if (kind === "wrapper" || kind === "call") {
+            markers.set(`${slot}.open`, entries
+                .map((name) => (kind === "wrapper" ? `<${name}>` : `${name}(`))
+                .join(""));
+            markers.set(`${slot}.close`, EffectArray.reverse(entries)
+                .map((name) => (kind === "wrapper" ? `</${name}>` : ")"))
+                .join(""));
+        }
+        else if (kind === "graphql") {
+            markers.set(`${slot}.spreads`, slotBindings.map((binding) => `...${binding.export}`).join("\n"));
+            markers.set(`${slot}.documents`, entries.join(", "));
+        }
+        else {
+            markers.set(slot, entries
+                .map((name) => {
+                if (kind === "element") {
+                    return `<${name} />`;
+                }
+                if (kind === "factory") {
+                    return `${name}()`;
+                }
+                return name;
+            })
+                .join(", "));
+        }
+    }
+    let content = source;
+    for (const [name, value] of markers) {
+        const marker = `{{${name}}}`;
+        if (content.split(marker).length !== 2) {
+            return yield* new InvalidComposition({
+                message: `${template.source} must contain exactly one ${marker}`,
+            });
+        }
+        content = content.replace(marker, () => value);
+    }
+    for (const match of content.matchAll(/\{\{#(?<slot>\w+)\}\}(?<body>[\s\S]*?)\{\{\/\k<slot>\}\}/gu)) {
+        const slot = match.groups?.slot;
+        if (!slot || !Object.hasOwn(template.slots, slot)) {
+            return yield* new InvalidComposition({
+                message: `Undeclared conditional slot in ${template.source}`,
+            });
+        }
+        content = content.replace(match[0], () => selected.some((binding) => binding.slot === slot)
+            ? (match.groups?.body ?? "")
+            : "");
+    }
+    if (/\{\{[^}]+\}\}/u.test(content)) {
+        return yield* new InvalidComposition({
+            message: `Undeclared template marker in ${template.source}`,
+        });
+    }
+    const formatted = yield* Effect.tryPromise({
+        catch: () => new InvalidComposition({ message: `Cannot format ${template.target}` }),
+        try: async () => await format(template.target, content, {
+            printWidth: 80,
+            sortImports: {
+                ignoreCase: true,
+                newlinesBetween: true,
+                order: "asc",
+            },
+            trailingComma: "es5",
+        }),
+    });
+    if (formatted.errors.length) {
+        return yield* new InvalidComposition({
+            message: `Invalid rendered source: ${template.target}`,
+        });
+    }
+    return formatted.code;
+});

package/dist/test-reference-workspace.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-reference-workspace.d.ts.map

package/dist/test-reference-workspace.d.ts.map

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

package/dist/test-reference-workspace.js

@@ -0,0 +1,6 @@
+import { NodeRuntime } from "@effect/platform-node";
+import { Effect } from "effect";
+import { testReferenceWorkspace } from "./reference-workspace.js";
+import { runtime } from "./runtime.js";
+import { findSourceRoot } from "./source-root.js";
+NodeRuntime.runMain(findSourceRoot(process.cwd()).pipe(Effect.flatMap(testReferenceWorkspace), Effect.provide(runtime)));

package/dist/types.d.ts

@@ -9,6 +9,8 @@ export type CreateOptions = {
     auth?: string;
     cms?: string;
     commerce?: string;
+    search?: string;
+    without?: ("auth" | "cms" | "commerce" | "search")[];
     addOns?: string[];
     preset?: string;
 };
@@ -28,13 +30,4 @@ export type ScaffoldResult = {
     gitInitialized: boolean;
     committed: boolean;
 };
-export type GitInitResult = {
-    gitInitialized: boolean;
-    committed: boolean;
-    commitError?: string;
-};
-export type RunCommandResult = {
-    stdout: string;
-    stderr: string;
-};
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,CAAC,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,QAAQ,CAAC,EAAE,CAAC;IACrD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC"}

package/dist/typescript-paths.d.ts

@@ -0,0 +1,10 @@
+import { Effect, FileSystem, Path, Schema } from "effect";
+import { InvalidComposition } from "./errors.ts";
+export interface TypeScriptAlias {
+    readonly cwd: string;
+    readonly alias: string;
+    readonly sourcePath: string;
+}
+export type TypeScriptAliasTarget = Omit<TypeScriptAlias, "sourcePath">;
+export declare const applyTypeScriptAliases: (root: string, aliases: readonly TypeScriptAlias[], ownedAliases: readonly TypeScriptAliasTarget[]) => Effect.Effect<undefined, InvalidComposition | Schema.SchemaError | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=typescript-paths.d.ts.map

package/dist/typescript-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-paths.d.ts","sourceRoot":"","sources":["../src/typescript-paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAI1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AACD,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC;AAaxE,eAAO,MAAM,sBAAsB,4PAyDjC,CAAC"}