@savvy-web/silk-effects 0.6.0 → 1.0.0

package/services/TagStrategy.js

@@ -0,0 +1,54 @@
+import { TagFormatError } from "../errors/TagFormatError.js";
+import { Context, Effect, Layer } from "effect";
+
+//#region src/services/TagStrategy.ts
+/**
+* Service that determines and applies the git-tag naming strategy for a release.
+*
+* @remarks
+* Consumes a {@link VersioningStrategyResult} to pick between `"single"` and `"scoped"`
+* tag formats, then formats tag strings accordingly. Independent versioning always
+* produces scoped tags; single and fixed-group versioning produces a single shared tag.
+*
+* @example
+* ```typescript
+* const result = await Effect.runPromise(
+*   Effect.gen(function* () {
+*     const tags = yield* TagStrategy;
+*     const strategyType = yield* tags.determine({ type: "independent", fixedGroups: [], publishablePackages: [] });
+*     return yield* tags.formatTag("@my-org/pkg", "1.2.3", strategyType);
+*   }).pipe(Effect.provide(TagStrategyLive))
+* );
+* // => "@my-org/pkg@1.2.3"
+* ```
+*
+* @since 0.1.0
+*/
+var TagStrategy = class extends Context.Tag("@savvy-web/silk-effects/TagStrategy")() {};
+/**
+* Live implementation of {@link TagStrategy} with no external dependencies.
+*
+* @remarks
+* All logic is pure: strategy determination and tag formatting involve no I/O.
+*
+* @since 0.1.0
+*/
+const TagStrategyLive = Layer.succeed(TagStrategy, TagStrategy.of({
+	determine: (versioningResult) => {
+		if (versioningResult.type === "independent") return Effect.succeed("scoped");
+		return Effect.succeed("single");
+	},
+	formatTag: (name, version, strategy) => {
+		if (version === "") return Effect.fail(new TagFormatError({
+			name,
+			version,
+			reason: "version cannot be empty"
+		}));
+		if (strategy === "single") return Effect.succeed(version);
+		if (name.startsWith("@")) return Effect.succeed(`${name}@${version}`);
+		return Effect.succeed(`${name}@${version}`);
+	}
+}));
+
+//#endregion
+export { TagStrategy, TagStrategyLive };

package/services/ToolDiscovery.js

@@ -0,0 +1,229 @@
+import { ToolNotFoundError } from "../errors/ToolNotFoundError.js";
+import { ToolResolutionError } from "../errors/ToolResolutionError.js";
+import { ResolvedTool } from "../schemas/ResolvedTool.js";
+import { Context, Effect, Layer, Option, Ref } from "effect";
+import { PackageManagerDetector, WorkspaceRoot } from "workspaces-effect";
+import { Command, CommandExecutor } from "@effect/platform";
+
+//#region src/services/ToolDiscovery.ts
+/**
+* Service that resolves CLI tools — locating them globally (PATH) or locally
+* (via package manager), extracting versions, enforcing source and version
+* constraints, and caching results.
+*
+* @example
+* ```typescript
+* const result = await Effect.runPromise(
+*   Effect.gen(function* () {
+*     const td = yield* ToolDiscovery;
+*     return yield* td.resolve(
+*       ToolDefinition.make({ name: "biome" })
+*     );
+*   }).pipe(
+*     Effect.provide(ToolDiscoveryLive),
+*     Effect.provide(NodeContext.layer),
+*   )
+* );
+* ```
+*
+* @since 0.2.0
+*/
+var ToolDiscovery = class extends Context.Tag("@savvy-web/silk-effects/ToolDiscovery")() {};
+/**
+* Build the PM exec prefix for running a local binary.
+*/
+function pmExecArgs(pmType, name) {
+	switch (pmType) {
+		case "pnpm": return [
+			"pnpm",
+			"exec",
+			name
+		];
+		case "npm": return [
+			"npx",
+			"--no",
+			"--",
+			name
+		];
+		case "yarn": return [
+			"yarn",
+			"exec",
+			name
+		];
+		case "bun": return [
+			"bun",
+			"x",
+			"--no-install",
+			name
+		];
+	}
+}
+/**
+* Run a command and return its stdout, or `Option.none()` on failure.
+*/
+function tryString(cmd) {
+	return Command.string(cmd).pipe(Effect.map((s) => Option.some(s.trim())), Effect.catchAll(() => Effect.succeed(Option.none())));
+}
+/**
+* Run a command and return true if it succeeds (exit code 0).
+*/
+function tryExists(cmd) {
+	return Command.exitCode(cmd).pipe(Effect.map((code) => code === 0), Effect.catchAll(() => Effect.succeed(false)));
+}
+/**
+* Extract version from command output using a VersionExtractor.
+*/
+function extractVersion(output, extractor) {
+	if (extractor._tag === "None" || Option.isNone(output)) return Option.none();
+	const raw = output.value;
+	if (extractor._tag === "Flag") {
+		const parsed = extractor.parse ? extractor.parse(raw) : raw.trim();
+		return Option.some(parsed);
+	}
+	try {
+		const obj = JSON.parse(raw);
+		const parts = extractor.path.split(".");
+		let current = obj;
+		for (const part of parts) {
+			if (current == null || typeof current !== "object") return Option.none();
+			current = current[part];
+		}
+		return typeof current === "string" ? Option.some(current) : Option.none();
+	} catch {
+		return Option.none();
+	}
+}
+/**
+* Live implementation of {@link ToolDiscovery}.
+*
+* @remarks
+* Requires `CommandExecutor` from `@effect/platform`, `PackageManagerDetector`
+* and `WorkspaceRoot` from `workspaces-effect`.
+*
+* @since 0.2.0
+*/
+const ToolDiscoveryLive = Layer.effect(ToolDiscovery, Effect.gen(function* () {
+	const executor = yield* CommandExecutor.CommandExecutor;
+	const wsRoot = yield* WorkspaceRoot;
+	const pmDetector = yield* PackageManagerDetector;
+	const cache = yield* Ref.make(/* @__PURE__ */ new Map());
+	const resolve = (definition) => Effect.gen(function* () {
+		const hit = (yield* Ref.get(cache)).get(definition.name);
+		if (hit) return hit;
+		const root = yield* wsRoot.find(process.cwd()).pipe(Effect.catchAll(() => Effect.fail(new ToolResolutionError({
+			name: definition.name,
+			reason: "Could not find workspace root"
+		}))));
+		const pmType = (yield* pmDetector.detect(root).pipe(Effect.catchAll(() => Effect.fail(new ToolResolutionError({
+			name: definition.name,
+			reason: "Could not detect package manager"
+		}))))).type;
+		const globalExists = yield* Effect.provideService(tryExists(Command.make("sh", "-c", `command -v ${definition.name}`)), CommandExecutor.CommandExecutor, executor);
+		let globalVersion = Option.none();
+		if (globalExists && definition.versionExtractor._tag !== "None") {
+			const flag = definition.versionExtractor.flag;
+			globalVersion = extractVersion(yield* Effect.provideService(tryString(Command.make(definition.name, flag)), CommandExecutor.CommandExecutor, executor), definition.versionExtractor);
+		}
+		let localExists = false;
+		let localVersion = Option.none();
+		const [pmBin, ...pmArgs] = pmExecArgs(pmType, definition.name);
+		if (definition.versionExtractor._tag !== "None") {
+			const flag = definition.versionExtractor.flag;
+			const localOutput = yield* Effect.provideService(tryString(Command.make(pmBin, ...pmArgs, flag)), CommandExecutor.CommandExecutor, executor);
+			if (Option.isSome(localOutput)) {
+				localExists = true;
+				localVersion = extractVersion(localOutput, definition.versionExtractor);
+			}
+		} else localExists = yield* Effect.provideService(tryExists(Command.make(pmBin, ...pmArgs, "--version")), CommandExecutor.CommandExecutor, executor);
+		if (!globalExists && !localExists) return yield* Effect.fail(new ToolResolutionError({
+			name: definition.name,
+			reason: "Tool not found globally or locally"
+		}));
+		switch (definition.source._tag) {
+			case "OnlyLocal":
+				if (!localExists) return yield* Effect.fail(new ToolResolutionError({
+					name: definition.name,
+					reason: "Tool is required locally but was only found globally"
+				}));
+				break;
+			case "OnlyGlobal":
+				if (!globalExists) return yield* Effect.fail(new ToolResolutionError({
+					name: definition.name,
+					reason: "Tool is required globally but was only found locally"
+				}));
+				break;
+			case "Both":
+				if (!globalExists || !localExists) return yield* Effect.fail(new ToolResolutionError({
+					name: definition.name,
+					reason: "Tool is required both globally and locally but was only found in one location"
+				}));
+				break;
+			case "Any": break;
+		}
+		let mismatch = false;
+		let source = localExists ? "local" : "global";
+		let version = localExists ? localVersion : globalVersion;
+		if (globalExists && localExists && Option.isSome(globalVersion) && Option.isSome(localVersion)) {
+			if (globalVersion.value !== localVersion.value) {
+				mismatch = true;
+				switch (definition.policy._tag) {
+					case "Report":
+						source = "local";
+						version = localVersion;
+						break;
+					case "PreferLocal":
+						source = "local";
+						version = localVersion;
+						break;
+					case "PreferGlobal":
+						source = "global";
+						version = globalVersion;
+						break;
+					case "RequireMatch": return yield* Effect.fail(new ToolResolutionError({
+						name: definition.name,
+						reason: `Version mismatch: global ${globalVersion.value} vs local ${localVersion.value}`
+					}));
+				}
+			}
+		}
+		const resolved = new ResolvedTool({
+			name: definition.name,
+			source,
+			version,
+			globalVersion,
+			localVersion,
+			packageManager: pmType,
+			mismatch
+		});
+		yield* Ref.update(cache, (m) => {
+			const next = new Map(m);
+			next.set(definition.name, resolved);
+			return next;
+		});
+		return resolved;
+	});
+	const require_ = (definition, message) => resolve(definition).pipe(Effect.mapError((err) => new ToolNotFoundError({
+		name: definition.name,
+		reason: message ?? err.reason
+	})));
+	const isAvailable = (definition) => Effect.gen(function* () {
+		if (yield* Effect.provideService(tryExists(Command.make("sh", "-c", `command -v ${definition.name}`)), CommandExecutor.CommandExecutor, executor)) return true;
+		const rootResult = yield* wsRoot.find(process.cwd()).pipe(Effect.option);
+		if (Option.isNone(rootResult)) return false;
+		const pmResult = yield* pmDetector.detect(rootResult.value).pipe(Effect.option);
+		if (Option.isNone(pmResult)) return false;
+		const pmType = pmResult.value.type;
+		const probeFlag = definition.versionExtractor._tag !== "None" ? definition.versionExtractor.flag : "--version";
+		const [pmBin, ...pmArgs] = pmExecArgs(pmType, definition.name);
+		return yield* Effect.provideService(tryExists(Command.make(pmBin, ...pmArgs, probeFlag)), CommandExecutor.CommandExecutor, executor);
+	});
+	return {
+		resolve,
+		require: require_,
+		isAvailable,
+		clearCache: Ref.set(cache, /* @__PURE__ */ new Map())
+	};
+}));
+
+//#endregion
+export { ToolDiscovery, ToolDiscoveryLive };

package/services/VersioningStrategy.js

@@ -0,0 +1,67 @@
+import { ChangesetConfigReader } from "./ChangesetConfigReader.js";
+import { Context, Effect, Layer } from "effect";
+
+//#region src/services/VersioningStrategy.ts
+/**
+* Service that classifies the versioning strategy used by a workspace.
+*
+* @remarks
+* Reads the changesets config to inspect `fixed` groups, then determines whether
+* the workspace uses a single-package, fixed-group, or independent versioning strategy.
+* Falls back to safe defaults when the changeset config is unavailable.
+*
+* @example
+* ```typescript
+* const result = await Effect.runPromise(
+*   Effect.gen(function* () {
+*     const strategy = yield* VersioningStrategy;
+*     return yield* strategy.detect(["@my-org/pkg-a", "@my-org/pkg-b"]);
+*   }).pipe(
+*     Effect.provide(VersioningStrategyLive),
+*     Effect.provide(ChangesetConfigReaderLive),
+*     Effect.provide(NodeContext.layer),
+*   )
+* );
+* ```
+*
+* @since 0.1.0
+*/
+var VersioningStrategy = class extends Context.Tag("@savvy-web/silk-effects/VersioningStrategy")() {};
+/**
+* Live implementation of {@link VersioningStrategy}.
+*
+* @remarks
+* Requires {@link ChangesetConfigReader} to read the workspace changeset configuration.
+* If the config file is absent, an empty `fixed` groups array is assumed.
+*
+* @since 0.1.0
+*/
+const VersioningStrategyLive = Layer.effect(VersioningStrategy, Effect.gen(function* () {
+	const configReader = yield* ChangesetConfigReader;
+	const detect = (publishablePackages, root) => Effect.gen(function* () {
+		const fixed = (yield* configReader.read(root).pipe(Effect.orElseSucceed(() => ({
+			fixed: [],
+			linked: []
+		})))).fixed ?? [];
+		const packages = [...publishablePackages];
+		if (packages.length <= 1) return {
+			type: "single",
+			fixedGroups: fixed,
+			publishablePackages: packages
+		};
+		if (fixed.find((group) => packages.every((pkg) => group.includes(pkg))) !== void 0) return {
+			type: "fixed-group",
+			fixedGroups: fixed,
+			publishablePackages: packages
+		};
+		return {
+			type: "independent",
+			fixedGroups: fixed,
+			publishablePackages: packages
+		};
+	});
+	return { detect };
+}));
+
+//#endregion
+export { VersioningStrategy, VersioningStrategyLive };

package/tsdoc-metadata.json

@@ -1,11 +1,11 @@
-// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
-// It should be published with your NPM package.  It should not be tracked by Git.
-{
-  "tsdocVersion": "0.12",
-  "toolPackages": [
-    {
-      "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.7"
-    }
-  ]
-}
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.58.7"
+    }
+  ]
+}

package/turbo/digest.js

@@ -0,0 +1,127 @@
+//#region src/turbo/digest.ts
+/**
+* Pure transforms from decoded turbo dry-run JSON to digested result shapes.
+* No dependency injection — directly unit-testable.
+*
+* @remarks All members are `static`.
+* @since 0.7.0
+*/
+var TurboDigest = class TurboDigest {
+	constructor() {}
+	/** Env vars that actually feed a task's hash: configured + inferred. */
+	static hashedEnv(task) {
+		return [...task.environmentVariables.configured, ...task.environmentVariables.inferred];
+	}
+	static cacheDiagnosis(task, dry) {
+		const statuses = dry.tasks.map((t) => ({
+			package: t.package,
+			taskId: t.taskId,
+			hash: t.hash,
+			status: t.cache.status,
+			timeSaved: t.cache.timeSaved
+		}));
+		const misses = dry.tasks.filter((t) => t.cache.status === "MISS");
+		const explanations = misses.map((t) => ({
+			package: t.package,
+			taskId: t.taskId,
+			hash: t.hash,
+			inputFileCount: Object.keys(t.inputs).length,
+			hashedEnvVars: TurboDigest.hashedEnv(t),
+			externalDependenciesHash: t.hashOfExternalDependencies,
+			dependsOn: t.dependencies
+		}));
+		const g = dry.globalCacheInputs;
+		return {
+			task,
+			totalTasks: dry.tasks.length,
+			hits: dry.tasks.length - misses.length,
+			misses: misses.length,
+			statuses,
+			explanations,
+			global: {
+				rootKey: g.rootKey,
+				globalFileCount: Object.keys(g.files).length,
+				externalDependenciesHash: g.hashOfExternalDependencies,
+				internalDependenciesHash: g.hashOfInternalDependencies,
+				globalEnvVars: [...g.environmentVariables.configured, ...g.environmentVariables.inferred]
+			}
+		};
+	}
+	static taskGraph(dry, task) {
+		const nodes = dry.tasks.map((t) => ({
+			taskId: t.taskId,
+			package: t.package,
+			dependsOn: t.dependencies
+		}));
+		return {
+			...task !== void 0 ? { task } : {},
+			nodeCount: nodes.length,
+			nodes,
+			criticalPath: TurboDigest.criticalPath(dry.tasks)
+		};
+	}
+	/** Longest dependency chain by node count (memoized DFS over the dependency edges). */
+	static criticalPath(tasks) {
+		const byId = new Map(tasks.map((t) => [t.taskId, t]));
+		const memo = /* @__PURE__ */ new Map();
+		const longest = (id, seen) => {
+			const cached = memo.get(id);
+			if (cached) return cached;
+			if (seen.has(id)) return [id];
+			const node = byId.get(id);
+			if (!node || node.dependencies.length === 0) {
+				const self = [id];
+				memo.set(id, self);
+				return self;
+			}
+			const nextSeen = new Set(seen).add(id);
+			let best = [];
+			for (const dep of node.dependencies) {
+				const chain = longest(dep, nextSeen);
+				if (chain.length > best.length) best = chain;
+			}
+			const path = [...best, id];
+			memo.set(id, path);
+			return path;
+		};
+		let overall = [];
+		for (const t of tasks) {
+			const chain = longest(t.taskId, /* @__PURE__ */ new Set());
+			if (chain.length > overall.length) overall = chain;
+		}
+		return overall;
+	}
+	/**
+	* Split an `--affected` dry-run into directly-changed packages and their dependents.
+	*
+	* @remarks
+	* `turbo run <task> --affected --dry=json` already expands the set to include the
+	* directly-changed packages *and* their transitive dependents, so every task in
+	* `dry.tasks` is in the affected set. To recover the split we need the set of files
+	* that actually changed (`changedFiles`, from `git diff --name-only <base>...HEAD`):
+	* a package is *directly changed* when a changed file lives under its `directory`,
+	* and everything else in the affected set is therefore a *dependent*. When the change
+	* is outside any affected package (e.g. a root file like `pnpm-lock.yaml`, which makes
+	* the whole graph affected), no package is directly changed and the full set is reported
+	* as dependents.
+	*/
+	static affected(base, changedFiles, dry) {
+		const packageDir = /* @__PURE__ */ new Map();
+		for (const t of dry.tasks) packageDir.set(t.package, t.directory);
+		const affectedPackages = [...packageDir.keys()];
+		const isDirectlyChanged = (pkg) => {
+			const dir = packageDir.get(pkg);
+			if (dir === void 0) return false;
+			const prefix = dir.endsWith("/") ? dir : `${dir}/`;
+			return changedFiles.some((file) => file === dir || file.startsWith(prefix));
+		};
+		return {
+			base,
+			packages: affectedPackages.filter(isDirectlyChanged),
+			dependents: affectedPackages.filter((pkg) => !isDirectlyChanged(pkg))
+		};
+	}
+};
+
+//#endregion
+export { TurboDigest };

package/turbo/errors.js

@@ -0,0 +1,48 @@
+import { Data } from "effect";
+
+//#region src/turbo/errors.ts
+/**
+* Raised when the turbo CLI cannot be resolved or executed.
+*
+* @since 0.7.0
+*/
+var TurboNotInstalledError = class extends Data.TaggedError("TurboNotInstalledError") {
+	get message() {
+		return `Turborepo is not available: ${this.reason}`;
+	}
+};
+/**
+* Raised when the resolved working directory is not a Turborepo (no turbo.json).
+*
+* @since 0.7.0
+*/
+var NotATurboRepoError = class extends Data.TaggedError("NotATurboRepoError") {
+	get message() {
+		return `Not a Turborepo: no turbo.json found in ${this.cwd}`;
+	}
+};
+/**
+* Raised when `turbo run <task> --dry=json` output cannot be parsed/decoded.
+*
+* @since 0.7.0
+*/
+var DryRunParseError = class extends Data.TaggedError("DryRunParseError") {
+	get message() {
+		return `Failed to parse turbo dry-run output for "${this.task}": ${this.reason}`;
+	}
+};
+/**
+* Raised when an invocation of the turbo CLI exits non-zero (e.g. an unknown
+* task name or a corrupt `turbo.json`). Distinct from {@link TurboNotInstalledError},
+* which signals that the binary itself could not be resolved.
+*
+* @since 0.7.0
+*/
+var TurboExecError = class extends Data.TaggedError("TurboExecError") {
+	get message() {
+		return `Turbo command failed (${this.args.join(" ")}): ${this.reason}`;
+	}
+};
+
+//#endregion
+export { DryRunParseError, NotATurboRepoError, TurboExecError, TurboNotInstalledError };

package/turbo/index.js

@@ -0,0 +1,32 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { TurboDigest } from "./digest.js";
+import { DryRunParseError, NotATurboRepoError, TurboExecError, TurboNotInstalledError } from "./errors.js";
+import { TurboCache, TurboDryRun, TurboDryTask, TurboEnvVars, TurboGlobalCacheInputs } from "./schemas/DryRun.js";
+import { AffectedResult, CacheDiagnosis, GlobalHashSummary, GraphNode, MissExplanation, PackageCacheStatus, TaskGraphResult } from "./schemas/results.js";
+import { TurboInspector, TurboInspectorLive } from "./services/TurboInspector.js";
+
+//#region src/turbo/index.ts
+var turbo_exports = /* @__PURE__ */ __exportAll({
+	AffectedResult: () => AffectedResult,
+	CacheDiagnosis: () => CacheDiagnosis,
+	DryRunParseError: () => DryRunParseError,
+	GlobalHashSummary: () => GlobalHashSummary,
+	GraphNode: () => GraphNode,
+	MissExplanation: () => MissExplanation,
+	NotATurboRepoError: () => NotATurboRepoError,
+	PackageCacheStatus: () => PackageCacheStatus,
+	TaskGraphResult: () => TaskGraphResult,
+	TurboCache: () => TurboCache,
+	TurboDigest: () => TurboDigest,
+	TurboDryRun: () => TurboDryRun,
+	TurboDryTask: () => TurboDryTask,
+	TurboEnvVars: () => TurboEnvVars,
+	TurboExecError: () => TurboExecError,
+	TurboGlobalCacheInputs: () => TurboGlobalCacheInputs,
+	TurboInspector: () => TurboInspector,
+	TurboInspectorLive: () => TurboInspectorLive,
+	TurboNotInstalledError: () => TurboNotInstalledError
+});
+
+//#endregion
+export { turbo_exports };

package/turbo/schemas/DryRun.js

@@ -0,0 +1,57 @@
+import { Schema } from "effect";
+
+//#region src/turbo/schemas/DryRun.ts
+/** turbo's per-target cache descriptor in `--dry=json`. */
+const TurboCache = Schema.Struct({
+	local: Schema.Boolean,
+	remote: Schema.Boolean,
+	status: Schema.Literal("HIT", "MISS"),
+	timeSaved: Schema.Number
+}).annotations({ identifier: "TurboCache" });
+/** turbo's environment-variable contribution block (per-task and global). */
+const TurboEnvVars = Schema.Struct({
+	specified: Schema.Struct({
+		env: Schema.Array(Schema.String),
+		passThroughEnv: Schema.NullOr(Schema.Array(Schema.String))
+	}),
+	configured: Schema.Array(Schema.String),
+	inferred: Schema.Array(Schema.String),
+	passthrough: Schema.NullOr(Schema.Array(Schema.String))
+}).annotations({ identifier: "TurboEnvVars" });
+/** A single task entry from `turbo run <task> --dry=json`. */
+const TurboDryTask = Schema.Struct({
+	taskId: Schema.String,
+	task: Schema.String,
+	package: Schema.String,
+	directory: Schema.String,
+	hash: Schema.String,
+	inputs: Schema.Record({
+		key: Schema.String,
+		value: Schema.String
+	}),
+	hashOfExternalDependencies: Schema.String,
+	cache: TurboCache,
+	dependencies: Schema.Array(Schema.String),
+	dependents: Schema.Array(Schema.String),
+	environmentVariables: TurboEnvVars
+}).annotations({ identifier: "TurboDryTask" });
+/** The `globalCacheInputs` block — the components of the global hash. */
+const TurboGlobalCacheInputs = Schema.Struct({
+	rootKey: Schema.String,
+	files: Schema.Record({
+		key: Schema.String,
+		value: Schema.String
+	}),
+	hashOfExternalDependencies: Schema.String,
+	hashOfInternalDependencies: Schema.String,
+	environmentVariables: TurboEnvVars
+}).annotations({ identifier: "TurboGlobalCacheInputs" });
+/** The subset of `turbo run <task> --dry=json` the Turbo namespace reads. */
+const TurboDryRun = Schema.Struct({
+	turboVersion: Schema.String,
+	globalCacheInputs: TurboGlobalCacheInputs,
+	tasks: Schema.Array(TurboDryTask)
+}).annotations({ identifier: "TurboDryRun" });
+
+//#endregion
+export { TurboCache, TurboDryRun, TurboDryTask, TurboEnvVars, TurboGlobalCacheInputs };