create-next-hydra 0.3.0 → 0.4.2

package/dist/initialization.js

@@ -0,0 +1,266 @@
+import { Effect, FileSystem, Path } from "effect";
+import { DestinationNotEmpty, InvalidComposition, SourceChanged, } from "./errors.js";
+import { cacheDirectories, isEnvironmentFile } from "./file-policy.js";
+import { relativeFile } from "./files.js";
+// A wildcard represents exactly one directory, never a recursive file pattern.
+// Ownership and initial Git visibility are derived from the same declaration.
+const settings = [
+    {
+        directory: [],
+        files: {
+            ".gitignore": "ignore",
+            "README.md": "readme",
+            "next-hydra.json": "definition",
+        },
+    },
+    {
+        directory: ["apps", "*"],
+        files: { ".gitignore": "ignore", "vercel.json": "deployment" },
+    },
+];
+export function workspaceSetting(target) {
+    const parts = target.split("/");
+    const name = parts.pop();
+    if (!name) {
+        return undefined;
+    }
+    const group = settings.find(({ directory }) => directory.length === parts.length &&
+        directory.every((segment, index) => segment === "*" ? Boolean(parts[index]) : segment === parts[index]));
+    return group && Object.hasOwn(group.files, name)
+        ? group.files[name]
+        : undefined;
+}
+export const validatePreservedFiles = Effect.fn("Workspaces.validatePreservedFiles")(function* (targets) {
+    const unique = new Set(targets);
+    for (const target of targets) {
+        const normalized = yield* relativeFile(target);
+        const parts = target.split("/");
+        if (normalized !== target ||
+            /[*?\[\]{}!\r\n]/u.test(target) ||
+            target.startsWith(".workspace-composition") ||
+            workspaceSetting(target) !== undefined ||
+            isEnvironmentFile(target) ||
+            parts.some((part) => cacheDirectories.has(part)) ||
+            parts.some((_, index) => {
+                const ancestor = parts.slice(0, index).join("/");
+                return (unique.has(ancestor) ||
+                    workspaceSetting(ancestor) !== undefined ||
+                    isEnvironmentFile(ancestor));
+            })) {
+            return yield* new InvalidComposition({
+                message: `Expected an exact application file in preserve: ${target}`,
+            });
+        }
+    }
+    if (unique.size !== targets.length) {
+        return yield* new InvalidComposition({
+            message: "Preserve paths must be unique",
+        });
+    }
+});
+function namedIgnoreRules(preserve) {
+    const rules = new Set([
+        "# Commit workspace settings and generated Turbo config; Compose owns the materialized application.",
+        "/*",
+    ]);
+    const allow = new Set(["!/turbo.json"]);
+    for (const { directory, files } of settings) {
+        let prefix = "/";
+        for (const segment of directory) {
+            prefix += `${segment}/`;
+            rules.add(`!${prefix}`);
+            rules.add(`${prefix}*`);
+        }
+        for (const name of Object.keys(files)) {
+            allow.add(`!${prefix}${name}`);
+        }
+    }
+    for (const target of preserve) {
+        const parts = target.split("/");
+        for (let end = 1; end < parts.length; end += 1) {
+            const prefix = `/${parts.slice(0, end).join("/")}/`;
+            rules.add(`!${prefix}`);
+            rules.add(`${prefix}*`);
+        }
+        allow.add(`!/${target}`);
+    }
+    return `${[...rules, ...allow].join("\n")}\n`;
+}
+export const namedInitializationFiles = Effect.fn("Workspaces.namedInitializationFiles")(function* (files, preserved, preserve = []) {
+    const targets = new Set(files.map((file) => file.target));
+    for (const target of preserved) {
+        if (workspaceSetting(target) === "deployment" &&
+            !targets.has(`${target.slice(0, target.lastIndexOf("/"))}/package.json`)) {
+            return yield* new InvalidComposition({
+                message: `Deployment settings target an unselected application: ${target}`,
+            });
+        }
+    }
+    const output = [];
+    for (const file of files) {
+        const parts = file.target.split("/");
+        if (parts[0]?.startsWith(".workspace-composition")) {
+            return yield* new InvalidComposition({
+                message: `Composition cannot own workspace state: ${file.target}`,
+            });
+        }
+        if (parts.some((part) => cacheDirectories.has(part))) {
+            return yield* new InvalidComposition({
+                message: `Composition cannot own cache paths: ${file.target}`,
+            });
+        }
+        for (let end = 1; end < parts.length; end += 1) {
+            const ancestor = parts.slice(0, end).join("/");
+            if (workspaceSetting(ancestor) || isEnvironmentFile(ancestor)) {
+                return yield* new InvalidComposition({
+                    message: `Composition cannot write below workspace settings: ${file.target}`,
+                });
+            }
+        }
+        const setting = workspaceSetting(file.target);
+        if (setting === "ignore" || setting === "deployment") {
+            continue;
+        }
+        if (setting !== undefined) {
+            return yield* new InvalidComposition({
+                message: `Composition cannot own workspace settings: ${file.target}`,
+            });
+        }
+        output.push(file);
+    }
+    if (!preserved.has(".gitignore")) {
+        output.push({
+            content: new TextEncoder().encode(namedIgnoreRules(preserve)),
+            mode: 0o644,
+            origin: { kind: "policy", policy: "application-ignore", sources: [] },
+            target: ".gitignore",
+        });
+    }
+    return output;
+});
+export const listUnregisteredFiles = Effect.fn("Workspaces.listUnregisteredFiles")(function* (destination, owned) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const unexpected = [];
+    if (!(yield* fs.exists(destination))) {
+        return unexpected;
+    }
+    if ((yield* fs.stat(destination)).type !== "Directory") {
+        return yield* new DestinationNotEmpty({ directory: destination });
+    }
+    const pending = [""];
+    while (pending.length) {
+        const directory = pending.pop();
+        if (directory === undefined) {
+            break;
+        }
+        for (const name of yield* fs.readDirectory(path.join(destination, directory))) {
+            const target = directory ? `${directory}/${name}` : name;
+            const stat = yield* fs.stat(path.join(destination, target));
+            if (target === ".git") {
+                unexpected.push(target);
+                continue;
+            }
+            if (([
+                ".workspace-composition.lock",
+                ".workspace-composition.recovery",
+            ].includes(target) &&
+                stat.type === "Directory") ||
+                (target === ".workspace-composition.json" && stat.type === "File")) {
+                continue;
+            }
+            if (owned.has(target)) {
+                if (stat.type !== "File") {
+                    unexpected.push(target);
+                }
+                continue;
+            }
+            if (cacheDirectories.has(name)) {
+                if (stat.type !== "Directory") {
+                    unexpected.push(target);
+                }
+                continue;
+            }
+            if (workspaceSetting(target) || isEnvironmentFile(target)) {
+                if (stat.type !== "File") {
+                    unexpected.push(target);
+                }
+            }
+            else if (stat.type === "Directory") {
+                pending.push(target);
+            }
+            else {
+                unexpected.push(target);
+            }
+        }
+    }
+    return unexpected;
+});
+const settingDirectories = Effect.fn("Workspaces.settingDirectories")(function* (destination, pattern) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    let directories = [""];
+    for (const segment of pattern) {
+        const next = [];
+        for (const directory of directories) {
+            const names = segment === "*"
+                ? yield* fs.readDirectory(path.join(destination, directory))
+                : [segment];
+            for (const name of names) {
+                const target = directory ? `${directory}/${name}` : name;
+                const absolute = path.join(destination, target);
+                if ((yield* fs.exists(absolute)) &&
+                    (yield* fs.stat(absolute)).type === "Directory") {
+                    next.push(target);
+                }
+            }
+        }
+        directories = next;
+    }
+    return directories;
+});
+export const inspectInitialization = Effect.fn("Workspaces.inspectInitialization")(function* (destination, definition) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const preserved = new Set();
+    if (!(yield* fs.exists(destination))) {
+        if (definition !== undefined) {
+            return yield* new SourceChanged({ paths: ["next-hydra.json"] });
+        }
+        return preserved;
+    }
+    if ((yield* fs.stat(destination)).type !== "Directory") {
+        return yield* new DestinationNotEmpty({ directory: destination });
+    }
+    if (definition === undefined) {
+        if ((yield* fs.readDirectory(destination)).length) {
+            return yield* new DestinationNotEmpty({ directory: destination });
+        }
+        return preserved;
+    }
+    if (yield* fs.exists(path.join(destination, ".git"))) {
+        return yield* new DestinationNotEmpty({ directory: destination });
+    }
+    // Probe declared settings directly; unrelated output need not be readable.
+    // WorkspaceFiles separately verifies owned files and publication targets.
+    for (const group of settings) {
+        for (const directory of yield* settingDirectories(destination, group.directory)) {
+            for (const name of Object.keys(group.files)) {
+                const target = directory ? `${directory}/${name}` : name;
+                const absolute = path.join(destination, target);
+                if (!(yield* fs.exists(absolute))) {
+                    continue;
+                }
+                if ((yield* fs.stat(absolute)).type !== "File") {
+                    return yield* new DestinationNotEmpty({ directory: destination });
+                }
+                preserved.add(target);
+            }
+        }
+    }
+    if ((yield* fs.readFileString(path.join(destination, "next-hydra.json"))) !==
+        definition) {
+        return yield* new SourceChanged({ paths: ["next-hydra.json"] });
+    }
+    return preserved;
+});

package/dist/lint-workspaces.d.ts

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

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

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

package/dist/lint-workspaces.js

@@ -0,0 +1,62 @@
+import { NodeRuntime } from "@effect/platform-node";
+import { Console, Effect, Path, Schema } from "effect";
+import { affectedLintWorkspaces, executeLintCommand, lintCompositions, } from "./composition-lint.js";
+import { InvalidComposition } from "./errors.js";
+import { runtime } from "./runtime.js";
+import { findSourceRoot } from "./source-root.js";
+const program = Effect.gen(function* () {
+    const root = yield* findSourceRoot(process.cwd());
+    const path = yield* Path.Path;
+    const args = process.argv.slice(2);
+    const selections = args.filter((arg) => arg === "--source" || arg.startsWith("--workspace="));
+    const positional = args.filter((arg) => !arg.startsWith("--"));
+    const revisions = args.filter((arg) => arg.startsWith("--changed-from="));
+    const invalid = args.filter((arg) => arg.startsWith("--") &&
+        !["--staged", "--list", ...selections, ...revisions].includes(arg));
+    if (invalid.length > 0 ||
+        selections.length > 1 ||
+        selections.includes("--workspace=") ||
+        revisions.length > 1 ||
+        (revisions.length > 0 &&
+            (args.includes("--staged") || positional.length > 0)) ||
+        revisions.some((arg) => !/^[a-f\d]{40,64}$/u.test(arg.slice("--changed-from=".length))) ||
+        (args.includes("--list") &&
+            (selections.length > 0 || args.includes("--staged"))) ||
+        (args.includes("--staged") && positional.length > 0)) {
+        return yield* new InvalidComposition({
+            message: "Usage: lint-workspaces.js [--source | --workspace=<name>] [--staged | --changed-from=<commit-sha> | files...] or --list [--changed-from=<commit-sha> | files...]",
+        });
+    }
+    const [selection] = selections;
+    let scope = { kind: "all" };
+    if (selection === "--source") {
+        scope = { kind: "source" };
+    }
+    else if (selection !== undefined) {
+        scope = { kind: "workspace", name: selection.slice("--workspace=".length) };
+    }
+    const staged = args.includes("--staged");
+    const revision = revisions[0]?.slice("--changed-from=".length);
+    const files = staged || revision !== undefined
+        ? (yield* executeLintCommand(root, "git", [
+            "diff",
+            ...(staged ? ["--cached"] : []),
+            ...(args.includes("--list") ? ["--no-renames"] : []),
+            "--name-only",
+            args.includes("--list")
+                ? "--diff-filter=ACMRD"
+                : "--diff-filter=ACMR",
+            "-z",
+            ...(revision === undefined ? [] : [revision, "HEAD", "--"]),
+        ]))
+            .split("\0")
+            .filter(Boolean)
+        : positional.map((file) => path.relative(root, path.resolve(file)));
+    if (args.includes("--list")) {
+        const names = yield* affectedLintWorkspaces(root, revision !== undefined || positional.length > 0 ? files : undefined);
+        yield* Console.log(yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Array(Schema.String)))(names));
+        return;
+    }
+    yield* lintCompositions(root, staged || revision !== undefined || files.length > 0 ? files : undefined, scope);
+});
+NodeRuntime.runMain(program.pipe(Effect.provide(runtime)));

package/dist/model.d.ts

@@ -0,0 +1,143 @@
+import { Schema } from "effect";
+export declare const Selection: Schema.Struct<{
+    readonly addOns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.NonEmptyString>, never>;
+    readonly providers: Schema.withDecodingDefaultKey<Schema.Struct<{
+        readonly auth: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly cms: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly commerce: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly search: Schema.optionalKey<Schema.NonEmptyString>;
+    }>, never>;
+}>;
+export type Selection = typeof Selection.Type;
+export declare const SelectionRequest: Schema.Union<readonly [Schema.Struct<{
+    readonly addOns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.NonEmptyString>, never>;
+    readonly providers: Schema.withDecodingDefaultKey<Schema.Struct<{
+        readonly auth: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly cms: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly commerce: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly search: Schema.optionalKey<Schema.NonEmptyString>;
+    }>, never>;
+}>, Schema.Struct<{
+    readonly addOns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.NonEmptyString>, never>;
+    readonly preset: Schema.NonEmptyString;
+}>]>;
+export type SelectionRequest = typeof SelectionRequest.Type;
+export declare const DevelopmentPort: Schema.Finite;
+export declare const WorkspaceDefinition: Schema.Struct<{
+    readonly demo: Schema.optionalKey<Schema.Struct<{
+        readonly architecture: Schema.Boolean;
+    }>>;
+    readonly development: Schema.optionalKey<Schema.Struct<{
+        readonly port: Schema.optionalKey<Schema.Finite>;
+    }>>;
+    readonly preserve: Schema.withDecodingDefaultKey<Schema.$Array<Schema.NonEmptyString>, never>;
+    readonly addOns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.NonEmptyString>, never>;
+    readonly providers: Schema.withDecodingDefaultKey<Schema.Struct<{
+        readonly auth: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly cms: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly commerce: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly search: Schema.optionalKey<Schema.NonEmptyString>;
+    }>, never>;
+}>;
+export interface PreparedFile {
+    readonly target: string;
+    readonly content: Uint8Array;
+    readonly mode: number;
+}
+export interface PreparedWorkspace {
+    readonly files: readonly (PreparedFile & {
+        readonly origin: FileOrigin;
+    })[];
+    readonly instructions: readonly RegistryInstruction[];
+    readonly inputs: SourceInputs;
+}
+export interface RegistryInstruction {
+    readonly item: string;
+    readonly text: string;
+}
+export interface SourceInputs {
+    readonly files: readonly string[];
+    readonly packagePatterns: readonly string[];
+    readonly packages: readonly string[];
+    readonly excluded: readonly string[];
+}
+export declare const FileOrigin: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"registry">;
+    readonly owner: Schema.String;
+    readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"workspace-setting">;
+    readonly source: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"source">;
+    readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+    readonly owner: Schema.NullOr<Schema.String>;
+    readonly source: Schema.String;
+}>, Schema.Struct<{
+    readonly bindings: Schema.$Array<Schema.Struct<{
+        readonly owner: Schema.String;
+        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 kind: Schema.Literal<"template">;
+    readonly transforms: Schema.optionalKey<Schema.$Array<Schema.Literal<"remove-demo-architecture">>>;
+    readonly owner: Schema.String;
+    readonly source: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"policy">;
+    readonly policy: Schema.Literals<readonly ["application-manifest", "workspace-settings", "lockfile-seed", "application-tasks", "application-ignore"]>;
+    readonly sources: Schema.$Array<Schema.String>;
+}>]>;
+export type FileOrigin = typeof FileOrigin.Type;
+export interface FileExplanation {
+    readonly target: string;
+    readonly origin: FileOrigin;
+}
+export interface ExplanationReport {
+    readonly sourceRoot: string;
+    readonly destination: string;
+    readonly files: readonly FileExplanation[];
+}
+export interface MaterializationReport {
+    readonly instructions: readonly RegistryInstruction[];
+    readonly origins: readonly FileExplanation[];
+    readonly git?: {
+        readonly initialized: boolean;
+        readonly committed: boolean;
+        readonly warning?: string;
+    };
+    readonly recoveryEvidence?: string | null;
+    readonly environmentFilesCreated: readonly string[];
+    readonly destination: string;
+    readonly files: readonly string[];
+    readonly removedFiles: readonly string[];
+    readonly dependencies: "pending" | "current";
+    readonly dependencyReasons: readonly string[];
+}
+export interface FileChange {
+    readonly target: string;
+    readonly kind: "create" | "update" | "remove" | "record" | "conflict" | "unregistered" | "setting";
+}
+export interface CheckReport {
+    readonly destination: string;
+    readonly initialized: boolean;
+    readonly ready: boolean;
+    readonly changes: readonly FileChange[];
+}
+export interface DiffReport {
+    readonly origins: readonly FileExplanation[];
+    readonly snapshot: string;
+    readonly incomplete: boolean;
+    readonly patch: string;
+    readonly changes: readonly {
+        readonly target: string;
+        readonly status: string;
+    }[];
+    readonly unregisteredFiles: readonly string[];
+    readonly conflicts: readonly string[];
+}
+//# sourceMappingURL=model.d.ts.map

package/dist/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIxC,eAAO,MAAM,SAAS;;;;;;;;EAUpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAC;AAE9C,eAAO,MAAM,gBAAgB;;;;;;;;;;;IAM3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAC;AAE5D,eAAO,MAAM,eAAe,eAG3B,CAAC;AACF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAS9B,CAAC;AAEH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,YAAY,GAAG;QAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;KAAE,CAAC,EAAE,CAAC;IAC5E,QAAQ,CAAC,YAAY,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACtD,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAGD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAMD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoCrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAC;AAEhD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAC7B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,YAAY,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACtD,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IAC7C,QAAQ,CAAC,GAAG,CAAC,EAAE;QACb,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;QAC9B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;QAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C,QAAQ,CAAC,uBAAuB,EAAE,SAAS,MAAM,EAAE,CAAC;IACpD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,YAAY,EAAE,SAAS,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/C;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EACT,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,cAAc,GACd,SAAS,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IAC7C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,SAAS;QACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB,EAAE,CAAC;IACJ,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC"}

package/dist/model.js

@@ -0,0 +1,61 @@
+import { Effect, Schema } from "effect";
+import { Binding } from "./templates.js";
+export const Selection = Schema.Struct({
+    addOns: Schema.Array(Schema.NonEmptyString).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+    providers: Schema.Struct({
+        auth: Schema.optionalKey(Schema.NonEmptyString),
+        cms: Schema.optionalKey(Schema.NonEmptyString),
+        commerce: Schema.optionalKey(Schema.NonEmptyString),
+        search: Schema.optionalKey(Schema.NonEmptyString),
+    }).pipe(Schema.withDecodingDefaultKey(Effect.succeed({}))),
+});
+export const SelectionRequest = Schema.Union([
+    Selection,
+    Schema.Struct({
+        addOns: Selection.fields.addOns,
+        preset: Schema.NonEmptyString,
+    }),
+]);
+export const DevelopmentPort = Schema.Finite.check(Schema.isInt(), Schema.isBetween({ maximum: 65_533, minimum: 1024 }));
+export const WorkspaceDefinition = Schema.Struct({
+    ...Selection.fields,
+    demo: Schema.optionalKey(Schema.Struct({ architecture: Schema.Boolean })),
+    development: Schema.optionalKey(Schema.Struct({ port: Schema.optionalKey(DevelopmentPort) })),
+    preserve: Schema.Array(Schema.NonEmptyString).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+});
+const SourceTransforms = Schema.optionalKey(Schema.Array(Schema.Literal("remove-demo-architecture")));
+export const FileOrigin = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("registry"),
+        owner: Schema.String,
+        transforms: SourceTransforms,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("workspace-setting"),
+        source: Schema.String,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("source"),
+        transforms: SourceTransforms,
+        owner: Schema.NullOr(Schema.String),
+        source: Schema.String,
+    }),
+    Schema.Struct({
+        bindings: Schema.Array(Schema.Struct({ ...Binding.fields, owner: Schema.String })),
+        kind: Schema.Literal("template"),
+        transforms: SourceTransforms,
+        owner: Schema.String,
+        source: Schema.String,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("policy"),
+        policy: Schema.Literals([
+            "application-manifest",
+            "workspace-settings",
+            "lockfile-seed",
+            "application-tasks",
+            "application-ignore",
+        ]),
+        sources: Schema.Array(Schema.String),
+    }),
+]);

package/dist/package-catalog.d.ts

@@ -0,0 +1,8 @@
+export declare function packageManifestMatcher(sourcePatterns: readonly string[]): (file: string) => boolean;
+export declare function applicationPackagePatterns(sourcePatterns: readonly string[], targets: ReadonlySet<string>): readonly string[];
+export declare function packageCatalog(files: readonly string[], sourcePatterns: readonly string[]): {
+    manifests: string[];
+    matchesManifest: (file: string) => boolean;
+    patterns: readonly string[];
+};
+//# sourceMappingURL=package-catalog.d.ts.map

package/dist/package-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-catalog.d.ts","sourceRoot":"","sources":["../src/package-catalog.ts"],"names":[],"mappings":"AAuBA,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,SAAS,MAAM,EAAE,GAChC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAgB3B;AAED,wBAAgB,0BAA0B,CACxC,cAAc,EAAE,SAAS,MAAM,EAAE,EACjC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAC3B,SAAS,MAAM,EAAE,CAyBnB;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,cAAc,EAAE,SAAS,MAAM,EAAE;;4BAlDzB,MAAM,KAAK,OAAO;;EA2D3B"}

package/dist/package-catalog.js

@@ -0,0 +1,61 @@
+import path from "node:path";
+import { isCanonicalSource } from "./file-policy.js";
+function normalizePackagePatterns(patterns) {
+    return patterns.map((input) => {
+        const excluded = input.startsWith("!");
+        let pattern = excluded ? input.slice(1) : input;
+        while (pattern.startsWith("./")) {
+            pattern = pattern.slice(2);
+        }
+        while (pattern.endsWith("/")) {
+            pattern = pattern.slice(0, -1);
+        }
+        return excluded ? `!${pattern}` : pattern;
+    });
+}
+// pnpm declarations describe discovery, not selection. Registry ownership still
+// determines which discovered packages may enter a particular composition.
+// Effect Path has no glob matcher; Node's pure POSIX matcher needs no filesystem access.
+export function packageManifestMatcher(sourcePatterns) {
+    const patterns = normalizePackagePatterns(sourcePatterns);
+    const included = patterns.filter((pattern) => !pattern.startsWith("!"));
+    const excluded = patterns
+        .filter((pattern) => pattern.startsWith("!"))
+        .map((pattern) => pattern.slice(1));
+    return (file) => {
+        if (!file.endsWith("/package.json") || !isCanonicalSource(file)) {
+            return false;
+        }
+        const directory = file.slice(0, -"/package.json".length);
+        return (included.some((pattern) => path.posix.matchesGlob(directory, pattern)) &&
+            !excluded.some((pattern) => path.posix.matchesGlob(directory, pattern)));
+    };
+}
+export function applicationPackagePatterns(sourcePatterns, targets) {
+    const patterns = [
+        "apps/*",
+        "packages/*",
+        ...(targets.has("tests/e2e/package.json") ? ["tests/*"] : []),
+    ];
+    const directories = [...targets]
+        .filter((target) => target.endsWith("/package.json"))
+        .map((target) => target.slice(0, -"/package.json".length));
+    // Keep customary locations open for new application code, and retain source
+    // declarations needed by selected packages in other or nested locations.
+    for (const pattern of normalizePackagePatterns(sourcePatterns)) {
+        if (pattern.startsWith("!") ||
+            directories.some((directory) => !patterns.some((existing) => path.posix.matchesGlob(directory, existing)) && path.posix.matchesGlob(directory, pattern))) {
+            patterns.push(pattern);
+        }
+    }
+    return patterns;
+}
+export function packageCatalog(files, sourcePatterns) {
+    const patterns = normalizePackagePatterns(sourcePatterns);
+    const matchesManifest = packageManifestMatcher(patterns);
+    return {
+        manifests: files.filter(matchesManifest),
+        matchesManifest,
+        patterns,
+    };
+}