create-next-hydra 0.3.0 → 0.4.1

package/dist/demo-instrumentation.js

@@ -0,0 +1,300 @@
+import { Array as EffectArray, Effect, Order } from "effect";
+import ts from "typescript";
+import { InvalidComposition } from "./errors.js";
+export const demoArchitecturePackage = "@repo/demo-architecture";
+function isDemoModule(value) {
+    return (value === demoArchitecturePackage ||
+        value.startsWith(`${demoArchitecturePackage}/`));
+}
+function importKind(moduleName) {
+    if (moduleName === `${demoArchitecturePackage}/boundary`) {
+        return "boundary";
+    }
+    if (moduleName === `${demoArchitecturePackage}/toolbar`) {
+        return "toolbar";
+    }
+    return undefined;
+}
+function metadataImportEdits(file, removed) {
+    const references = new Map();
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node)) {
+            return;
+        }
+        if (ts.isIdentifier(node)) {
+            const matches = references.get(node.text) ?? [];
+            matches.push(node);
+            references.set(node.text, matches);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(file);
+    const edits = [];
+    const printer = ts.createPrinter();
+    for (const statement of file.statements) {
+        if (!ts.isImportDeclaration(statement) ||
+            removed.some((edit) => edit.start === statement.getStart(file))) {
+            continue;
+        }
+        const clause = statement.importClause;
+        const bindings = clause?.namedBindings;
+        if (!(clause && bindings && ts.isNamedImports(bindings))) {
+            continue;
+        }
+        // Retain any binding referenced outside erased metadata. Unused imports
+        // that predate this transform are not part of annotation removal.
+        const retained = bindings.elements.filter((binding) => {
+            const uses = references.get(binding.name.text) ?? [];
+            return (uses.length === 0 ||
+                uses.some((use) => !removed.some((edit) => edit.start <= use.getStart(file) && use.end <= edit.end)));
+        });
+        if (retained.length === bindings.elements.length) {
+            continue;
+        }
+        let text = "";
+        if (clause.name || retained.length > 0) {
+            const updated = ts.factory.updateImportDeclaration(statement, statement.modifiers, ts.factory.updateImportClause(clause, clause.phaseModifier, clause.name, retained.length > 0
+                ? ts.factory.updateNamedImports(bindings, retained)
+                : undefined), statement.moduleSpecifier, statement.attributes);
+            text = printer.printNode(ts.EmitHint.Unspecified, updated, file);
+        }
+        edits.push({ end: statement.end, start: statement.getStart(file), text });
+    }
+    return edits;
+}
+const metadataProps = new Set([
+    "caching",
+    "cacheTags",
+    "composition",
+    "description",
+    "getCaching",
+    "getCacheLife",
+    "getCacheTags",
+    "name",
+    "streaming",
+]);
+// Values describe the demo, never drive application work. Suppliers are lazy:
+// their bodies run only in the demo runtime, so erasing them has no side effects.
+function isMetadataValue(node) {
+    if (ts.isIdentifier(node) ||
+        ts.isLiteralExpression(node) ||
+        ts.isArrowFunction(node) ||
+        node.kind === ts.SyntaxKind.TrueKeyword ||
+        node.kind === ts.SyntaxKind.FalseKeyword ||
+        node.kind === ts.SyntaxKind.NullKeyword) {
+        return true;
+    }
+    if (ts.isParenthesizedExpression(node) ||
+        ts.isAsExpression(node) ||
+        ts.isNonNullExpression(node)) {
+        return isMetadataValue(node.expression);
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        return isMetadataValue(node.expression);
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        return node.elements.every(isMetadataValue);
+    }
+    if (ts.isConditionalExpression(node)) {
+        return (isMetadataValue(node.condition) &&
+            isMetadataValue(node.whenTrue) &&
+            isMetadataValue(node.whenFalse));
+    }
+    return false;
+}
+function validateMetadata(attributes) {
+    for (const property of attributes.properties) {
+        if (!ts.isJsxAttribute(property) ||
+            !ts.isIdentifier(property.name) ||
+            !metadataProps.has(property.name.text)) {
+            throw new Error("Only demo metadata props can be erased; move keys, refs, layout and spread props onto application elements.");
+        }
+        const value = property.initializer;
+        if (value &&
+            !ts.isStringLiteral(value) &&
+            (!ts.isJsxExpression(value) ||
+                !value.expression ||
+                !isMetadataValue(value.expression))) {
+            throw new Error("Metadata must be a value or lazy supplier, not an eager operation.");
+        }
+    }
+}
+// Only the explicit demo import contract is erasable. This is not dead-code
+// elimination, and must never remove application cache or Suspense boundaries.
+export const eraseDemoInstrumentation = (target, source) => Effect.try({
+    catch: (error) => new InvalidComposition({
+        message: `Cannot remove demo instrumentation from ${target}: ${error instanceof Error ? error.message : String(error)}`,
+    }),
+    try: () => {
+        if (!source.includes(demoArchitecturePackage)) {
+            return source;
+        }
+        const file = ts.createSourceFile(target, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+        const diagnostics = ts.transpileModule(source, {
+            compilerOptions: {
+                jsx: ts.JsxEmit.Preserve,
+                target: ts.ScriptTarget.ESNext,
+            },
+            fileName: target,
+            reportDiagnostics: true,
+        }).diagnostics ?? [];
+        if (diagnostics.some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error)) {
+            throw new Error("Invalid source syntax.");
+        }
+        const bindings = new Map();
+        const allowed = new Set();
+        const edits = [];
+        for (const statement of file.statements) {
+            if (!ts.isImportDeclaration(statement) ||
+                !ts.isStringLiteral(statement.moduleSpecifier)) {
+                continue;
+            }
+            const moduleName = statement.moduleSpecifier.text;
+            if (!isDemoModule(moduleName)) {
+                continue;
+            }
+            if (moduleName === `${demoArchitecturePackage}/styles.css` &&
+                !statement.importClause) {
+                allowed.add(statement.moduleSpecifier);
+                edits.push({
+                    end: statement.end,
+                    start: statement.getStart(file),
+                    text: "",
+                });
+                continue;
+            }
+            const kind = importKind(moduleName);
+            const clause = statement.importClause;
+            if (!kind ||
+                !clause ||
+                clause.name ||
+                clause.phaseModifier === ts.SyntaxKind.TypeKeyword ||
+                !clause.namedBindings ||
+                !ts.isNamedImports(clause.namedBindings)) {
+                throw new Error("Use named imports from the demo boundary or toolbar module.");
+            }
+            for (const element of clause.namedBindings.elements) {
+                if (/^[a-z]/u.test(element.name.text)) {
+                    throw new Error("Demo import aliases must use component names, not lowercase HTML tag names.");
+                }
+                const name = kind === "boundary"
+                    ? "ArchitectureBoundary"
+                    : "ArchitectureToolbar";
+                if ((element.propertyName ?? element.name).text !== name ||
+                    element.isTypeOnly) {
+                    throw new Error("Demo types and helpers must not enter application interfaces.");
+                }
+                bindings.set(element.name.text, kind);
+                allowed.add(element.name);
+                if (element.propertyName) {
+                    allowed.add(element.propertyName);
+                }
+            }
+            allowed.add(statement.moduleSpecifier);
+            edits.push({
+                end: statement.end,
+                start: statement.getStart(file),
+                text: "",
+            });
+        }
+        const visit = (node, inJsxChildren = false, canSplice = false) => {
+            if (ts.isJsxElement(node) &&
+                ts.isIdentifier(node.openingElement.tagName) &&
+                bindings.get(node.openingElement.tagName.text) === "boundary") {
+                validateMetadata(node.openingElement.attributes);
+                allowed.add(node.openingElement.tagName);
+                allowed.add(node.closingElement.tagName);
+                const children = node.children.filter((child) => !(ts.isJsxText(child) &&
+                    child.containsOnlyTriviaWhiteSpaces &&
+                    /[\r\n]/u.test(child.text)));
+                const child = children.length === 1 ? children[0] : undefined;
+                const lastChild = children.at(-1);
+                const singleElement = child !== undefined &&
+                    (ts.isJsxElement(child) ||
+                        ts.isJsxSelfClosingElement(child) ||
+                        ts.isJsxFragment(child));
+                const elementChildren = children.length > 0 &&
+                    children.every((element) => ts.isJsxElement(element) ||
+                        ts.isJsxSelfClosingElement(element) ||
+                        ts.isJsxFragment(element));
+                // Keep text token boundaries and the single-child contract of custom
+                // components. Only element groups under intrinsic parents can flatten.
+                const splice = inJsxChildren && (singleElement || (canSplice && elementChildren));
+                // Parentheses preserve return/newline semantics when a single JSX
+                // child becomes an expression. JSX parents accept siblings directly.
+                let opening = "<>";
+                let closing = "</>";
+                if (splice) {
+                    opening = "";
+                    closing = "";
+                }
+                else if (singleElement && !inJsxChildren) {
+                    opening = "(";
+                    closing = ")";
+                }
+                edits.push({
+                    end: splice && children[0] !== undefined
+                        ? children[0].getStart(file)
+                        : node.openingElement.end,
+                    start: node.openingElement.getStart(file),
+                    text: opening,
+                }, {
+                    end: node.closingElement.end,
+                    start: splice && lastChild !== undefined
+                        ? lastChild.end
+                        : node.closingElement.getStart(file),
+                    text: closing,
+                });
+                for (const element of node.children) {
+                    visit(element, splice || !singleElement, splice ? canSplice : !singleElement);
+                }
+                return;
+            }
+            if (ts.isJsxSelfClosingElement(node) &&
+                ts.isIdentifier(node.tagName) &&
+                bindings.get(node.tagName.text) === "toolbar") {
+                if (node.attributes.properties.length) {
+                    throw new Error("The demo toolbar must not receive application props.");
+                }
+                allowed.add(node.tagName);
+                edits.push({
+                    end: node.end,
+                    start: node.getStart(file),
+                    text: inJsxChildren ? "{null}" : "null",
+                });
+            }
+            ts.forEachChild(node, (child) => {
+                const childPosition = (ts.isJsxElement(node) || ts.isJsxFragment(node)) &&
+                    node.children.some((element) => element === child);
+                const intrinsicParent = ts.isJsxFragment(node) ||
+                    (ts.isJsxElement(node) &&
+                        ts.isIdentifier(node.openingElement.tagName) &&
+                        /^[a-z]/u.test(node.openingElement.tagName.text));
+                visit(child, childPosition, childPosition && intrinsicParent);
+            });
+        };
+        visit(file);
+        const check = (node) => {
+            if ((ts.isStringLiteralLike(node) || ts.isTemplateHead(node)) &&
+                isDemoModule(node.text) &&
+                !allowed.has(node)) {
+                throw new Error("Demo modules must use the supported static imports.");
+            }
+            if (ts.isIdentifier(node) &&
+                bindings.has(node.text) &&
+                !allowed.has(node)) {
+                throw new Error(`Unsupported use of demo import ${node.text}. Use an explicit JSX boundary.`);
+            }
+            ts.forEachChild(node, check);
+        };
+        check(file);
+        edits.push(...metadataImportEdits(file, edits));
+        let output = source;
+        const descendingPosition = Order.mapInput(Order.Number, (edit) => -edit.start);
+        for (const edit of EffectArray.sort(edits, descendingPosition)) {
+            output =
+                output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+        }
+        return output;
+    },
+});

package/dist/environment.d.ts

@@ -0,0 +1,7 @@
+import { Effect, FileSystem, Path } from "effect";
+import { EnvironmentInitializationFailed, InvalidComposition } from "./errors.ts";
+import type { PreparedFile } from "./model.ts";
+import type { LocalEnvironmentFile } from "./source-inventory.ts";
+export declare const planEnvironmentCopy: (destination: string, files: readonly PreparedFile[], local: readonly LocalEnvironmentFile[]) => Effect.Effect<LocalEnvironmentFile[], InvalidComposition | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
+export declare const copyEnvironment: (destination: string, inputs: readonly LocalEnvironmentFile[], initialize?: (<A, E, R>(target: string, write: Effect.Effect<A, E, R>) => Effect.Effect<A, E | import("./workspace-state.ts").WorkspaceStateError, R>) | undefined) => Effect.Effect<string[], EnvironmentInitializationFailed | import("./workspace-state.ts").WorkspaceStateError, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=environment.d.ts.map

package/dist/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAY,MAAM,QAAQ,CAAC;AAE5D,OAAO,EACL,+BAA+B,EAC/B,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAGlE,eAAO,MAAM,mBAAmB,8OA6C/B,CAAC;AAEF,eAAO,MAAM,eAAe,wXA2D3B,CAAC"}

package/dist/environment.js

@@ -0,0 +1,81 @@
+import { Effect, FileSystem, Path, Redacted } from "effect";
+import { EnvironmentInitializationFailed, InvalidComposition, } from "./errors.js";
+import { isEnvironmentFile } from "./file-policy.js";
+import { relativeFile } from "./files.js";
+export const planEnvironmentCopy = Effect.fn("Workspaces.planEnvironmentCopy")(function* (destination, files, local) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const directories = new Set(["."]);
+    for (const file of files) {
+        let directory = path.dirname(file.target);
+        while (directory !== ".") {
+            directories.add(directory);
+            directory = path.dirname(directory);
+        }
+    }
+    const pending = [];
+    for (const file of local) {
+        const target = yield* relativeFile(file.target);
+        if (!isEnvironmentFile(target)) {
+            return yield* new InvalidComposition({
+                message: `Not an environment file: ${target}`,
+            });
+        }
+        if (!directories.has(path.dirname(target))) {
+            continue;
+        }
+        const absolute = path.join(destination, target);
+        if (yield* fs.exists(absolute)) {
+            if ((yield* fs.stat(absolute)).type !== "File") {
+                return yield* new InvalidComposition({
+                    message: `Environment target is not a file: ${file.target}`,
+                });
+            }
+            continue;
+        }
+        if ((yield* fs.stat(file.source)).type !== "File") {
+            return yield* new InvalidComposition({
+                message: `Environment source is not a file: ${file.target}`,
+            });
+        }
+        pending.push(file);
+    }
+    return pending;
+});
+export const copyEnvironment = Effect.fn("Workspaces.copyEnvironment")(function* (destination, inputs, initialize) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const created = [];
+    for (const file of inputs) {
+        const target = path.join(destination, file.target);
+        const copy = Effect.gen(function* () {
+            if (yield* fs.exists(target)) {
+                if ((yield* fs.stat(target)).type === "File") {
+                    return;
+                }
+                return yield* new InvalidComposition({
+                    message: `Environment target is not a file: ${file.target}`,
+                });
+            }
+            yield* fs.makeDirectory(path.dirname(target), { recursive: true });
+            const content = yield* fs.readFile(file.source);
+            const written = yield* fs
+                .writeFile(target, content, { flag: "wx", mode: 0o600 })
+                .pipe(Effect.as(true), Effect.catchIf((error) => error.reason._tag === "AlreadyExists", (error) => fs
+                .stat(target)
+                .pipe(Effect.flatMap((stat) => stat.type === "File"
+                ? Effect.succeed(false)
+                : Effect.fail(error)))));
+            if (written) {
+                created.push(file.target);
+            }
+        }).pipe(Effect.uninterruptible, Effect.mapError((error) => new EnvironmentInitializationFailed({
+            createdFiles: [...created],
+            diagnostic: Redacted.make(error),
+            directory: destination,
+            failedFile: file.target,
+        })));
+        yield* initialize ? initialize(file.target, copy) : copy;
+    }
+    return created;
+});

package/dist/errors.d.ts

@@ -0,0 +1,156 @@
+import { Runtime, Schema } from "effect";
+declare const ApplicationTaskFailed_base: Schema.Class<ApplicationTaskFailed, Schema.TaggedStruct<"ApplicationTaskFailed", {
+    readonly code: Schema.Int;
+    readonly directory: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ApplicationTaskFailed extends ApplicationTaskFailed_base {
+    get message(): string;
+    get [Runtime.errorExitCode](): number;
+}
+declare const IncompatibleSelection_base: Schema.Class<IncompatibleSelection, Schema.TaggedStruct<"IncompatibleSelection", {
+    readonly conflicts: Schema.$Array<Schema.String>;
+    readonly missing: Schema.$Array<Schema.String>;
+    readonly selection: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class IncompatibleSelection extends IncompatibleSelection_base {
+    get message(): string;
+}
+declare const InvalidComposition_base: Schema.Class<InvalidComposition, Schema.TaggedStruct<"InvalidComposition", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidComposition extends InvalidComposition_base {
+}
+declare const SourceChanged_base: Schema.Class<SourceChanged, Schema.TaggedStruct<"SourceChanged", {
+    readonly paths: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class SourceChanged extends SourceChanged_base {
+}
+declare const SourceAcquisitionFailed_base: Schema.Class<SourceAcquisitionFailed, Schema.TaggedStruct<"SourceAcquisitionFailed", {
+    readonly diagnostic: Schema.Redacted<Schema.Unknown>;
+    readonly phase: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SourceAcquisitionFailed extends SourceAcquisitionFailed_base {
+    get message(): string;
+}
+declare const SourceStorageRetained_base: Schema.Class<SourceStorageRetained, Schema.TaggedStruct<"SourceStorageRetained", {
+    readonly directory: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SourceStorageRetained extends SourceStorageRetained_base {
+}
+declare const DestinationNotEmpty_base: Schema.Class<DestinationNotEmpty, Schema.TaggedStruct<"DestinationNotEmpty", {
+    readonly directory: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class DestinationNotEmpty extends DestinationNotEmpty_base {
+}
+declare const RegistryFailure_base: Schema.Class<RegistryFailure, Schema.TaggedStruct<"RegistryFailure", {
+    readonly diagnostic: Schema.Redacted<Schema.String>;
+    readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RegistryFailure extends RegistryFailure_base {
+}
+declare const StagingRetained_base: Schema.Class<StagingRetained, Schema.TaggedStruct<"StagingRetained", {
+    readonly directory: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class StagingRetained extends StagingRetained_base {
+}
+declare const RegistryWorkerFailure_base: Schema.Class<RegistryWorkerFailure, Schema.TaggedStruct<"RegistryWorkerFailure", {
+    readonly phase: Schema.Literals<readonly ["launch", "exit", "protocol", "stop"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class RegistryWorkerFailure extends RegistryWorkerFailure_base {
+}
+declare const MaterializationFailed_base: Schema.Class<MaterializationFailed, Schema.TaggedStruct<"MaterializationFailed", {
+    readonly completedFiles: Schema.$Array<Schema.String>;
+    readonly diagnostic: Schema.Redacted<Schema.Unknown>;
+    readonly directory: Schema.String;
+    readonly failedFile: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class MaterializationFailed extends MaterializationFailed_base {
+}
+declare const EnvironmentInitializationFailed_base: Schema.Class<EnvironmentInitializationFailed, Schema.TaggedStruct<"EnvironmentInitializationFailed", {
+    readonly createdFiles: Schema.$Array<Schema.String>;
+    readonly diagnostic: Schema.Redacted<Schema.Unknown>;
+    readonly directory: Schema.String;
+    readonly failedFile: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EnvironmentInitializationFailed extends EnvironmentInitializationFailed_base {
+    get message(): string;
+}
+declare const WorkspaceBusy_base: Schema.Class<WorkspaceBusy, Schema.TaggedStruct<"WorkspaceBusy", {
+    readonly directory: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceBusy extends WorkspaceBusy_base {
+    get message(): string;
+}
+declare const WorkspaceLockAuthorizationRequired_base: Schema.Class<WorkspaceLockAuthorizationRequired, Schema.TaggedStruct<"WorkspaceLockAuthorizationRequired", {
+    readonly directory: Schema.String;
+    readonly reason: Schema.String;
+    readonly token: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceLockAuthorizationRequired extends WorkspaceLockAuthorizationRequired_base {
+    get message(): string;
+}
+declare const WorkspaceLockChanged_base: Schema.Class<WorkspaceLockChanged, Schema.TaggedStruct<"WorkspaceLockChanged", {
+    readonly directory: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceLockChanged extends WorkspaceLockChanged_base {
+    get message(): string;
+}
+declare const WorkspaceConflict_base: Schema.Class<WorkspaceConflict, Schema.TaggedStruct<"WorkspaceConflict", {
+    readonly paths: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceConflict extends WorkspaceConflict_base {
+    get message(): string;
+}
+declare const WorkspaceRecoveryRequired_base: Schema.Class<WorkspaceRecoveryRequired, Schema.TaggedStruct<"WorkspaceRecoveryRequired", {
+    readonly directory: Schema.String;
+    readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceRecoveryRequired extends WorkspaceRecoveryRequired_base {
+    get message(): string;
+}
+declare const WorkspaceStateInvalid_base: Schema.Class<WorkspaceStateInvalid, Schema.TaggedStruct<"WorkspaceStateInvalid", {
+    readonly directory: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceStateInvalid extends WorkspaceStateInvalid_base {
+    get message(): string;
+}
+declare const WorkspaceNotCurrent_base: Schema.Class<WorkspaceNotCurrent, Schema.TaggedStruct<"WorkspaceNotCurrent", {
+    readonly directory: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceNotCurrent extends WorkspaceNotCurrent_base {
+    get message(): string;
+}
+declare const WorkspaceBatchFailed_base: Schema.Class<WorkspaceBatchFailed, Schema.TaggedStruct<"WorkspaceBatchFailed", {
+    readonly names: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceBatchFailed extends WorkspaceBatchFailed_base {
+    get message(): string;
+}
+declare const SnapshotUnavailable_base: Schema.Class<SnapshotUnavailable, Schema.TaggedStruct<"SnapshotUnavailable", {
+    readonly directory: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SnapshotUnavailable extends SnapshotUnavailable_base {
+    get message(): string;
+}
+declare const WorkspaceUninitialized_base: Schema.Class<WorkspaceUninitialized, Schema.TaggedStruct<"WorkspaceUninitialized", {
+    readonly directory: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceUninitialized extends WorkspaceUninitialized_base {
+    get message(): string;
+}
+declare const SnapshotFailed_base: Schema.Class<SnapshotFailed, Schema.TaggedStruct<"SnapshotFailed", {
+    readonly directory: Schema.String;
+    readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SnapshotFailed extends SnapshotFailed_base {
+    get message(): string;
+}
+declare const DependencyInstallationFailed_base: Schema.Class<DependencyInstallationFailed, Schema.TaggedStruct<"DependencyInstallationFailed", {
+    readonly directory: Schema.String;
+    readonly phase: Schema.Literals<readonly ["launch", "exit", "stop", "inputs", "outputs", "version"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class DependencyInstallationFailed extends DependencyInstallationFailed_base {
+    get message(): string;
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;;;;;AAEzC,qBAAa,qBAAsB,SAAQ,0BAM1C;IACC,IAAI,OAAO,WAEV;IACD,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,WAE1B;CACF;;;;;;AAED,qBAAa,qBAAsB,SAAQ,0BAO1C;IACC,IAAI,OAAO,WASV;CACF;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAGvC;CAAG;;;;AAEJ,qBAAa,aAAc,SAAQ,kBAGlC;CAAG;;;;;AAEJ,qBAAa,uBAAwB,SAAQ,4BAG5C;IACC,IAAI,OAAO,WAEV;CACF;;;;AACD,qBAAa,qBAAsB,SAAQ,0BAG1C;CAAG;;;;AAEJ,qBAAa,mBAAoB,SAAQ,wBAGxC;CAAG;;;;;AAEJ,qBAAa,eAAgB,SAAQ,oBAGpC;CAAG;;;;AAEJ,qBAAa,eAAgB,SAAQ,oBAGpC;CAAG;;;;AAEJ,qBAAa,qBAAsB,SAAQ,0BAG1C;CAAG;;;;;;;AAEJ,qBAAa,qBAAsB,SAAQ,0BAQ1C;CAAG;;;;;;;AAEJ,qBAAa,+BAAgC,SAAQ,oCAQpD;IACC,IAAI,OAAO,WAEV;CACF;;;;AAED,qBAAa,aAAc,SAAQ,kBAGlC;IACC,IAAI,OAAO,WAEV;CACF;;;;;;AAED,qBAAa,kCAAmC,SAAQ,uCAGvD;IACC,IAAI,OAAO,WAEV;CACF;;;;AAED,qBAAa,oBAAqB,SAAQ,yBAGzC;IACC,IAAI,OAAO,WAEV;CACF;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAGtC;IACC,IAAI,OAAO,WAEV;CACF;;;;;AAED,qBAAa,yBAA0B,SAAQ,8BAM9C;IACC,IAAI,OAAO,WAKV;CACF;;;;AAED,qBAAa,qBAAsB,SAAQ,0BAG1C;IACC,IAAI,OAAO,WAEV;CACF;;;;AAED,qBAAa,mBAAoB,SAAQ,wBAGxC;IACC,IAAI,OAAO,WAEV;CACF;;;;AAED,qBAAa,oBAAqB,SAAQ,yBAGzC;IACC,IAAI,OAAO,WAEV;CACF;;;;AAED,qBAAa,mBAAoB,SAAQ,wBAGxC;IACC,IAAI,OAAO,WAEV;CACF;;;;AAED,qBAAa,sBAAuB,SAAQ,2BAG3C;IACC,IAAI,OAAO,WAEV;CACF;;;;;AAED,qBAAa,cAAe,SAAQ,mBAGnC;IACC,IAAI,OAAO,WAEV;CACF;;;;;AAED,qBAAa,4BAA6B,SAAQ,iCAajD;IACC,IAAI,OAAO,WAEV;CACF"}