create-next-hydra 0.3.0 → 0.4.1

package/dist/composition.js

@@ -0,0 +1,420 @@
+import { Context, Effect, FileSystem, Layer, Path, Schema } from "effect";
+import { format } from "oxfmt";
+import { applicationIgnoreRules, applicationManifest, applicationWorkspace, normalizeApplicationName, readWorkspaceSettings, } from "./baseline.js";
+import { demoArchitecturePackage, eraseDemoInstrumentation, } from "./demo-instrumentation.js";
+import { InvalidComposition, SourceChanged } from "./errors.js";
+import { isEnvironmentFile, eligiblePackageFile } from "./file-policy.js";
+import { collectFiles, relativeFile, writeFile } from "./files.js";
+import { scopeApplicationHosts } from "./hosting.js";
+import { packageCatalog } from "./package-catalog.js";
+import { completePackages } from "./packages.js";
+import { acquireRegistry, registryInstructions } from "./registry.js";
+import { selectRegistryItems } from "./selection.js";
+import { Shadcn } from "./shadcn.js";
+import { SourceInventory } from "./source-inventory.js";
+import { withStaging } from "./staging.js";
+import { applicationTasks } from "./tasks.js";
+import { readTemplateDefinitions, orderBindings, renderTemplate, } from "./templates.js";
+import { applyTypeScriptAliases } from "./typescript-paths.js";
+const encodeJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
+export class Composition extends Context.Service()("create-next-hydra/Composition") {
+    static layer = Layer.effect(Composition, Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const shadcn = yield* Shadcn;
+        const inventory = yield* SourceInventory;
+        const prepare = Effect.fn("Composition.prepare")(function* (request) {
+            const applicationName = normalizeApplicationName(request.name);
+            const options = {
+                cwd: request.source.root,
+                registryFile: "registry.json",
+            };
+            const sourceRegistry = yield* shadcn.loadRegistry(options);
+            const acquired = yield* acquireRegistry(request.source.root, {
+                registry: sourceRegistry,
+                selection: request.selection,
+            }).pipe(Effect.provideService(Shadcn, shadcn), Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
+            const { registry } = acquired;
+            const { aliases, assets, ownedAssetTargets, ownedAliases, ownedRequirements, patches, references, requirements, selectedItems, } = yield* selectRegistryItems(registry, request.selection, acquired.references);
+            const captures = new Map();
+            const capture = Effect.fn("Composition.capture")(function* (input) {
+                const relative = yield* relativeFile(input);
+                const cached = captures.get(relative);
+                if (cached) {
+                    return cached;
+                }
+                const absolute = path.join(request.source.root, relative);
+                const stat = yield* fs.stat(absolute);
+                const file = {
+                    content: yield* fs.readFile(absolute),
+                    mode: stat.mode % 0o1000,
+                };
+                captures.set(relative, file);
+                return file;
+            });
+            const retained = Effect.fn("Composition.retained")(function* (input) {
+                const file = captures.get(yield* relativeFile(input));
+                if (!file) {
+                    return yield* Effect.die(new Error(`Missing captured input: ${input}`));
+                }
+                return file;
+            });
+            const rootManifest = yield* capture("package.json");
+            const initialManifest = {
+                ...rootManifest,
+                content: yield* applicationManifest(rootManifest.content, applicationName, selectedItems.some((item) => item.files?.some((file) => file.target?.replace(/^~\//u, "") === "tests/e2e/package.json"))),
+            };
+            for (const item of selectedItems) {
+                if (item.type !== "registry:item" ||
+                    item.css ||
+                    item.cssVars ||
+                    item.tailwind ||
+                    item.envVars) {
+                    return yield* new InvalidComposition({
+                        message: `Registry directives outside exact-file installation are not implemented in this entrypoint: ${item.name}`,
+                    });
+                }
+            }
+            const definitions = yield* readTemplateDefinitions(registry.items, acquired.external);
+            const templates = selectedItems.flatMap((item) => (definitions.get(item.name)?.templates ?? []).map((template) => ({
+                ...template,
+                owner: item.name,
+            })));
+            const bindings = selectedItems.flatMap((item) => (definitions.get(item.name)?.slotBindings ?? []).map((binding) => ({
+                ...binding,
+                owner: item.name,
+            })));
+            const targets = new Map();
+            const selectedManifests = new Map([["package.json", initialManifest]]);
+            const claim = (target, mode, origin) => Effect.gen(function* () {
+                const relative = yield* relativeFile(target);
+                if (isEnvironmentFile(relative)) {
+                    return yield* new InvalidComposition({
+                        message: `Composition cannot create runtime environment files: ${relative}. Keep examples as documentation; use provisioning or explicit local environment copying for values.`,
+                    });
+                }
+                if (targets.has(relative)) {
+                    return yield* new InvalidComposition({
+                        message: `Duplicate output target: ${relative}`,
+                    });
+                }
+                targets.set(relative, { mode, origin });
+            });
+            yield* claim("package.json", rootManifest.mode, {
+                kind: "policy",
+                policy: "application-manifest",
+                sources: ["package.json", "registry.json"],
+            });
+            for (const item of selectedItems) {
+                for (const file of item.files ?? []) {
+                    if (!file.target ||
+                        !["registry:file", "registry:page"].includes(file.type)) {
+                        return yield* new InvalidComposition({
+                            message: `Registry file needs an exact target: ${file.path}`,
+                        });
+                    }
+                    const remote = acquired.external.has(item.name);
+                    if (remote && file.content === undefined) {
+                        return yield* new InvalidComposition({
+                            message: `Published artifact has no file content: ${item.name}`,
+                        });
+                    }
+                    const captured = remote
+                        ? { content: new TextEncoder().encode(file.content), mode: 0o644 }
+                        : yield* capture(file.path);
+                    yield* claim(file.target, captured.mode, remote
+                        ? { kind: "registry", owner: item.name }
+                        : {
+                            kind: "source",
+                            owner: item.name,
+                            source: yield* relativeFile(file.path),
+                        });
+                    if (file.target.endsWith("/package.json")) {
+                        selectedManifests.set(yield* relativeFile(file.target), captured);
+                    }
+                }
+            }
+            for (const template of templates) {
+                const captured = yield* capture(template.source);
+                yield* claim(template.target, captured.mode, {
+                    bindings: orderBindings(bindings.filter((binding) => binding.target === template.target)),
+                    kind: "template",
+                    owner: template.owner,
+                    source: template.source,
+                });
+            }
+            for (const asset of assets) {
+                yield* claim(asset.target, (yield* capture(asset.source)).mode, {
+                    kind: "source",
+                    owner: asset.owner,
+                    source: asset.source,
+                });
+            }
+            for (const binding of bindings) {
+                if (!templates.some((template) => template.target === binding.target &&
+                    Object.hasOwn(template.slots, binding.slot))) {
+                    return yield* new InvalidComposition({
+                        message: `Missing template slot: ${binding.target}#${binding.slot}`,
+                    });
+                }
+            }
+            const governed = new Set(ownedAssetTargets);
+            for (const item of registry.items) {
+                for (const template of definitions.get(item.name)?.templates ?? []) {
+                    governed.add(yield* relativeFile(template.target));
+                }
+                for (const file of item.files ?? []) {
+                    if (file.target) {
+                        governed.add(yield* relativeFile(file.target));
+                    }
+                }
+            }
+            const sourceFiles = yield* inventory.list(request.source.root);
+            const settings = yield* readWorkspaceSettings((yield* capture("pnpm-workspace.yaml")).content);
+            const catalog = packageCatalog(sourceFiles, settings.data.packages);
+            const { baseline, directories: packageDirectories, manifests, } = yield* completePackages({
+                capture,
+                files: sourceFiles,
+                governed,
+                omittedDependencies: request.demoArchitecture
+                    ? undefined
+                    : new Set([demoArchitecturePackage]),
+                ownedRequirements,
+                packageManifests: catalog.manifests,
+                registryItems: selectedItems,
+                requirements,
+                selectedManifests,
+            });
+            for (const target of baseline) {
+                yield* claim(target, (yield* retained(target)).mode, {
+                    kind: "source",
+                    owner: null,
+                    source: target,
+                });
+            }
+            const rootFiles = yield* applicationWorkspace(settings, (yield* capture("pnpm-lock.yaml")).content, new Set(targets.keys()), patches);
+            for (const target of rootFiles.keys()) {
+                yield* claim(target, (yield* retained(target)).mode, {
+                    kind: "policy",
+                    policy: target === "pnpm-lock.yaml"
+                        ? "lockfile-seed"
+                        : "workspace-settings",
+                    sources: [target, "registry.json"],
+                });
+            }
+            yield* claim("turbo.json", 0o644, {
+                kind: "policy",
+                policy: "application-tasks",
+                sources: [],
+            });
+            yield* claim(".gitignore", 0o644, {
+                kind: "policy",
+                policy: "application-ignore",
+                sources: [],
+            });
+            const observedInventory = (files) => files.filter((file) => catalog.matchesManifest(file) ||
+                packageDirectories.some((directory) => file.startsWith(`${directory}/`) && eligiblePackageFile(file)));
+            return yield* withStaging((staging) => Effect.gen(function* () {
+                for (const item of selectedItems) {
+                    if (acquired.external.has(item.name)) {
+                        continue;
+                    }
+                    for (const file of item.files ?? []) {
+                        yield* writeFile(staging.inputs, {
+                            target: file.path,
+                            ...(yield* retained(file.path)),
+                        });
+                    }
+                }
+                for (const target of baseline) {
+                    yield* writeFile(staging.application, {
+                        target,
+                        ...(yield* retained(target)),
+                    });
+                }
+                for (const [target, content] of rootFiles) {
+                    yield* writeFile(staging.application, {
+                        ...(yield* retained(target)),
+                        content,
+                        target,
+                    });
+                }
+                yield* writeFile(staging.inputs, {
+                    content: new TextEncoder().encode(yield* encodeJson({
+                        homepage: registry.homepage,
+                        items: selectedItems,
+                        name: registry.name,
+                    })),
+                    mode: 0o600,
+                    target: "registry.json",
+                });
+                yield* writeFile(staging.application, {
+                    ...initialManifest,
+                    target: "package.json",
+                });
+                const artifacts = [];
+                for (const item of selectedItems) {
+                    artifacts.push(acquired.external.has(item.name)
+                        ? item
+                        : yield* shadcn.loadRegistryItem(item.name, {
+                            cwd: staging.inputs,
+                            registryFile: "registry.json",
+                        }));
+                }
+                const artifactPaths = new Map(artifacts.map((item, index) => [
+                    item.name,
+                    path.join(staging.registry, `${index}.json`),
+                ]));
+                for (const [index, artifact] of artifacts.entries()) {
+                    const registryDependencies = [];
+                    for (const reference of artifact.registryDependencies ?? []) {
+                        const name = references.get(reference);
+                        const target = name ? artifactPaths.get(name) : undefined;
+                        if (!target) {
+                            return yield* new InvalidComposition({
+                                message: `Unresolved registry dependency: ${reference}`,
+                            });
+                        }
+                        registryDependencies.push(target);
+                    }
+                    yield* writeFile(staging.registry, {
+                        content: new TextEncoder().encode(yield* encodeJson({
+                            ...artifact,
+                            dependencies: undefined,
+                            devDependencies: undefined,
+                            docs: undefined,
+                            registryDependencies,
+                        })),
+                        mode: 0o600,
+                        target: `${index}.json`,
+                    });
+                }
+                if (artifacts.length) {
+                    yield* shadcn.install(staging, [...artifactPaths.values()]);
+                }
+                for (const [target, file] of manifests) {
+                    yield* writeFile(staging.application, { ...file, target });
+                }
+                for (const asset of assets) {
+                    yield* writeFile(staging.application, {
+                        ...(yield* retained(asset.source)),
+                        target: asset.target,
+                    });
+                }
+                for (const template of templates) {
+                    const source = yield* retained(template.source);
+                    const content = yield* renderTemplate(template, bindings.filter((binding) => binding.target === template.target), new TextDecoder().decode(source.content));
+                    yield* writeFile(staging.application, {
+                        content: new TextEncoder().encode(content),
+                        mode: source.mode,
+                        target: template.target,
+                    });
+                }
+                yield* applyTypeScriptAliases(staging.application, aliases, ownedAliases);
+                const files = yield* scopeApplicationHosts(yield* collectFiles(staging.application), applicationName, new Set(assets.map((asset) => asset.target)), request.port);
+                const tasksSource = yield* encodeJson(yield* applicationTasks(files));
+                const tasks = yield* Effect.tryPromise({
+                    catch: () => new InvalidComposition({ message: "Cannot format turbo.json" }),
+                    try: async () => await format("turbo.json", tasksSource, { printWidth: 80 }),
+                });
+                if (tasks.errors.length) {
+                    return yield* new InvalidComposition({
+                        message: "Invalid generated turbo.json",
+                    });
+                }
+                files.push({
+                    content: new TextEncoder().encode(tasks.code),
+                    mode: 0o644,
+                    target: "turbo.json",
+                }, {
+                    content: new TextEncoder().encode(applicationIgnoreRules),
+                    mode: 0o644,
+                    target: ".gitignore",
+                });
+                const changed = [];
+                for (const [relative, captured] of captures) {
+                    const absolute = path.join(request.source.root, relative);
+                    const bytes = yield* fs.readFile(absolute);
+                    const stat = yield* fs.stat(absolute);
+                    if (stat.mode % 0o1000 !== captured.mode ||
+                        bytes.length !== captured.content.length ||
+                        bytes.some((byte, index) => byte !== captured.content[index])) {
+                        changed.push(relative);
+                    }
+                }
+                if ((yield* encodeJson(yield* shadcn.loadRegistry(options))) !==
+                    (yield* encodeJson(sourceRegistry))) {
+                    changed.push("registry.json");
+                }
+                for (const [file, content] of acquired.observed) {
+                    if ((yield* fs.readFileString(file)) !== content) {
+                        changed.push(file);
+                    }
+                }
+                const currentInventory = observedInventory(yield* inventory.list(request.source.root));
+                const capturedInventory = observedInventory(sourceFiles);
+                if (currentInventory.length !== capturedInventory.length ||
+                    currentInventory.some((file, index) => file !== capturedInventory[index])) {
+                    const before = new Set(capturedInventory);
+                    const after = new Set(currentInventory);
+                    changed.push(...currentInventory.filter((file) => !before.has(file)), ...capturedInventory.filter((file) => !after.has(file)));
+                }
+                if (changed.length) {
+                    return yield* new SourceChanged({ paths: changed });
+                }
+                const output = [];
+                for (const file of files) {
+                    const claimed = targets.get(file.target);
+                    if (!claimed) {
+                        return yield* new InvalidComposition({
+                            message: `Unplanned output target: ${file.target}`,
+                        });
+                    }
+                    if (/\.(?:tsx|jsx|ts|js|mts|cts|mjs|cjs)$/u.test(file.target) &&
+                        !assets.some((asset) => asset.target === file.target)) {
+                        const source = new TextDecoder().decode(file.content);
+                        const erased = yield* eraseDemoInstrumentation(file.target, source);
+                        if (!request.demoArchitecture && erased !== source) {
+                            const { origin } = claimed;
+                            if (origin.kind !== "source" &&
+                                origin.kind !== "template" &&
+                                origin.kind !== "registry") {
+                                return yield* new InvalidComposition({
+                                    message: `Cannot transform policy output: ${file.target}`,
+                                });
+                            }
+                            output.push({
+                                ...file,
+                                ...claimed,
+                                content: new TextEncoder().encode(erased),
+                                origin: {
+                                    ...origin,
+                                    transforms: ["remove-demo-architecture"],
+                                },
+                            });
+                            continue;
+                        }
+                    }
+                    output.push({ ...file, ...claimed });
+                }
+                return {
+                    files: output,
+                    inputs: {
+                        excluded: [...governed],
+                        files: [
+                            ...captures.keys(),
+                            ...[...acquired.observed.keys()].map((file) => path
+                                .relative(request.source.root, file)
+                                .split(path.sep)
+                                .join("/")),
+                        ],
+                        packagePatterns: catalog.patterns,
+                        packages: packageDirectories,
+                    },
+                    instructions: registryInstructions(artifacts),
+                };
+            })).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
+        });
+        return Composition.of({ prepare });
+    }));
+}

package/dist/create-command.d.ts

@@ -0,0 +1,21 @@
+import { Option, Stdio } from "effect";
+import { Command, Prompt } from "effect/unstable/cli";
+import { InvalidComposition } from "./errors.ts";
+import { Workspaces } from "./workspaces.ts";
+export declare const createCommand: (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").IncompatibleSelection | InvalidComposition | import("./errors.ts").SourceChanged | import("./errors.ts").SourceAcquisitionFailed | import("./errors.ts").SourceStorageRetained | import("./errors.ts").DestinationNotEmpty | import("./errors.ts").RegistryFailure | import("./errors.ts").StagingRetained | import("./errors.ts").RegistryWorkerFailure | 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/Schema").SchemaError | import("effect/PlatformError").PlatformError | import("./application-git.ts").ApplicationGitFailed | import("effect/Terminal").QuitError, Workspaces | Stdio.Stdio | Prompt.Environment>;
+//# sourceMappingURL=create-command.d.ts.map

package/dist/create-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-command.d.ts","sourceRoot":"","sources":["../src/create-command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,MAAM,EAAQ,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC9D,OAAO,EAAY,OAAO,EAAQ,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAEtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAgB7C,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM;;;;;;;;;;;;;;;ygCAuIqC,CAAC"}

package/dist/create-command.js

@@ -0,0 +1,128 @@
+import { Console, Effect, Option, Path, Stdio } from "effect";
+import { Argument, Command, Flag, Prompt } from "effect/unstable/cli";
+import { InvalidComposition } from "./errors.js";
+import { Workspaces } from "./workspaces.js";
+const slots = ["auth", "cms", "commerce", "search"];
+const choices = {
+    auth: [
+        { title: "WorkOS", value: "workos" },
+        { title: "Clerk", value: "clerk" },
+    ],
+    cms: [
+        { title: "Drupal", value: "drupal" },
+        { title: "Contentstack", value: "contentstack" },
+    ],
+    commerce: [{ title: "Commercetools", value: "commercetools" }],
+    search: [{ title: "Algolia", value: "algolia" }],
+};
+export const createCommand = (cwd) => Command.make("create-next-hydra", {
+    addOns: Flag.String("add-on").pipe(Flag.atLeast(0)),
+    auth: Flag.String("auth").pipe(Flag.optional),
+    cms: Flag.String("cms").pipe(Flag.optional),
+    commerce: Flag.String("commerce").pipe(Flag.optional),
+    search: Flag.String("search").pipe(Flag.optional),
+    commit: Flag.Boolean("commit").pipe(Flag.withDefault(true)),
+    directory: Argument.String("project-directory").pipe(Argument.optional),
+    preset: Flag.String("preset").pipe(Flag.optional),
+    ref: Flag.String("ref").pipe(Flag.optional),
+    repository: Flag.String("repo-url").pipe(Flag.withDefault("https://github.com/jakala-na/next-hydra.git")),
+    skipGit: Flag.Boolean("skip-git").pipe(Flag.withDefault(false)),
+    verbose: Flag.Boolean("verbose").pipe(Flag.withDefault(false)),
+    without: Flag.Literals("without", slots).pipe(Flag.atLeast(0)),
+    yes: Flag.Boolean("yes").pipe(Flag.withAlias("y"), Flag.withDefault(false)),
+}, (options) => Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const stdio = yield* Stdio.Stdio;
+    const interactive = !options.yes &&
+        (yield* stdio.stdinIsTerminal) &&
+        (yield* stdio.stdoutIsTerminal);
+    let directory = Option.getOrUndefined(options.directory)?.trim();
+    if (!directory) {
+        if (!interactive) {
+            return yield* new InvalidComposition({
+                message: "Provide a project directory for noninteractive creation.",
+            });
+        }
+        directory = yield* Prompt.String({
+            message: "Where should the project be created?",
+            validate: (value) => value.trim()
+                ? Effect.succeed(value.trim())
+                : Effect.fail("Enter a directory."),
+        });
+    }
+    const selected = {
+        auth: Option.getOrUndefined(options.auth),
+        cms: Option.getOrUndefined(options.cms),
+        commerce: Option.getOrUndefined(options.commerce),
+        search: Option.getOrUndefined(options.search),
+    };
+    if (slots.some((slot) => options.without.includes(slot) && selected[slot] !== undefined)) {
+        return yield* new InvalidComposition({
+            message: "A provider slot cannot be selected and excluded together.",
+        });
+    }
+    let selection;
+    if (Option.isSome(options.preset)) {
+        if (options.without.length || slots.some((slot) => selected[slot])) {
+            return yield* new InvalidComposition({
+                message: "--preset cannot be combined with provider or --without flags.",
+            });
+        }
+        selection = { addOns: options.addOns, preset: options.preset.value };
+    }
+    else {
+        const providers = {};
+        for (const slot of slots) {
+            if (options.without.includes(slot)) {
+                continue;
+            }
+            const explicit = selected[slot];
+            if (!explicit && !interactive) {
+                return yield* new InvalidComposition({
+                    message: "Select every provider slot or leave it empty with --without, or use --preset.",
+                });
+            }
+            providers[slot] =
+                explicit ??
+                    (yield* Prompt.Select({
+                        choices: choices[slot],
+                        message: `Choose the ${slot} provider`,
+                    }));
+        }
+        selection = { addOns: options.addOns, providers };
+    }
+    const destination = path.resolve(cwd, directory);
+    // Git treats a colon before the first slash as remote syntax (URLs or scp).
+    const repository = path.isAbsolute(options.repository) ||
+        /^[^/]+:/u.test(options.repository)
+        ? options.repository
+        : path.resolve(cwd, options.repository);
+    const workspace = yield* (yield* Workspaces).fresh({
+        destination,
+        name: path.basename(destination),
+        selection,
+        source: {
+            kind: "repository",
+            ref: Option.getOrUndefined(options.ref),
+            repository,
+        },
+    });
+    if (options.verbose) {
+        yield* Console.log("Acquiring the requested source revision, composing files, then installing dependencies.");
+    }
+    let git = "initialize";
+    if (options.skipGit) {
+        git = "skip";
+    }
+    else if (options.commit) {
+        git = "commit";
+    }
+    const result = yield* workspace.materialize({ git });
+    if (result.git?.warning) {
+        yield* Console.warn(result.git.warning);
+    }
+    for (const instruction of result.instructions) {
+        yield* Console.log(`${instruction.item}:\n${instruction.text}`);
+    }
+    yield* Console.log(`Created ${result.destination}. Dependencies ${result.dependencies}. Run pnpm dev from the project directory.`);
+})).pipe(Command.withDescription("Compose an application from the registry."));

package/dist/demo-instrumentation.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+import { InvalidComposition } from "./errors.ts";
+export declare const demoArchitecturePackage = "@repo/demo-architecture";
+export declare const eraseDemoInstrumentation: (target: string, source: string) => Effect.Effect<string, InvalidComposition, never>;
+//# sourceMappingURL=demo-instrumentation.d.ts.map

package/dist/demo-instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demo-instrumentation.d.ts","sourceRoot":"","sources":["../src/demo-instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,MAAM,EAAS,MAAM,QAAQ,CAAC;AAG7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD,eAAO,MAAM,uBAAuB,4BAA4B,CAAC;AA4KjE,eAAO,MAAM,wBAAwB,GAAI,QAAQ,MAAM,EAAE,QAAQ,MAAM,qDAsPnE,CAAC"}