@savvy-web/silk-effects 0.6.1 → 1.0.0

package/services/ManagedSection.js

@@ -0,0 +1,288 @@
+import { SectionParseError } from "../errors/SectionParseError.js";
+import { SectionWriteError } from "../errors/SectionWriteError.js";
+import { CheckResult, SyncResult } from "../schemas/SectionResults.js";
+import { SectionBlock } from "../schemas/SectionBlock.js";
+import { Context, Effect, Equal, Function, Layer } from "effect";
+import { FileSystem } from "@effect/platform";
+
+//#region src/services/ManagedSection.ts
+function beginMarker(toolName, commentStyle) {
+	return `${commentStyle} --- BEGIN ${toolName.toUpperCase()} MANAGED SECTION ---`;
+}
+function endMarker(toolName, commentStyle) {
+	return `${commentStyle} --- END ${toolName.toUpperCase()} MANAGED SECTION ---`;
+}
+function parseContent(content, toolName, commentStyle) {
+	const begin = beginMarker(toolName, commentStyle);
+	const end = endMarker(toolName, commentStyle);
+	const beginIndex = content.indexOf(begin);
+	const endIndex = content.indexOf(end);
+	if (beginIndex === -1 || endIndex === -1 || endIndex <= beginIndex) return null;
+	let managed = content.slice(beginIndex + begin.length, endIndex);
+	if (managed.startsWith("\n")) managed = managed.slice(1);
+	if (managed.endsWith("\n")) managed = managed.slice(0, -1);
+	return {
+		before: content.slice(0, beginIndex),
+		managed,
+		after: content.slice(endIndex + end.length)
+	};
+}
+function assembleContent(before, managed, after, toolName, commentStyle) {
+	return `${before}${beginMarker(toolName, commentStyle)}\n${managed}\n${endMarker(toolName, commentStyle)}${after}`;
+}
+const BEGIN_MARKER_RE = /^(#|\/\/) --- BEGIN (.+?) MANAGED SECTION ---$/gm;
+function sectionKey(toolName, commentStyle) {
+	return `${toolName.toUpperCase()}::${commentStyle}`;
+}
+/**
+* Locate every managed section in `content`, in document order, across all tools and
+* comment styles. Unterminated begin markers are skipped.
+*/
+function findAllSections(content) {
+	const results = [];
+	for (const match of content.matchAll(BEGIN_MARKER_RE)) {
+		const style = match[1];
+		const name = match[2];
+		const beginStart = match.index;
+		const beginEnd = beginStart + match[0].length;
+		const end = `${style} --- END ${name} MANAGED SECTION ---`;
+		const endIdx = content.indexOf(end, beginEnd);
+		if (endIdx === -1) continue;
+		let inner = content.slice(beginEnd, endIdx);
+		if (inner.startsWith("\n")) inner = inner.slice(1);
+		if (inner.endsWith("\n")) inner = inner.slice(0, -1);
+		results.push({
+			key: sectionKey(name, style),
+			commentStyle: style,
+			content: inner,
+			raw: content.slice(beginStart, endIdx + end.length),
+			start: beginStart,
+			end: endIdx + end.length
+		});
+	}
+	return results;
+}
+/**
+* Service for managing delimited sections in user-editable files.
+*
+* All methods use dual API (data-first and data-last).
+* Identity-only operations (`read`, `isManaged`) take a {@link SectionDefinition}.
+* Content operations (`write`, `sync`, `check`) take a {@link SectionBlock}.
+*
+* @since 0.2.0
+*/
+var ManagedSection = class extends Context.Tag("@savvy-web/silk-effects/ManagedSection")() {};
+/**
+* Live implementation of {@link ManagedSection} backed by `@effect/platform` FileSystem.
+*
+* @since 0.2.0
+*/
+const ManagedSectionLive = Layer.effect(ManagedSection, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const read = Function.dual(2, (path, definition) => Effect.gen(function* () {
+		if (!(yield* fs.exists(path).pipe(Effect.orElseSucceed(() => false)))) return null;
+		const parsed = parseContent(yield* fs.readFileString(path).pipe(Effect.mapError((cause) => new SectionParseError({
+			path,
+			reason: String(cause)
+		}))), definition.toolName, definition.commentStyle);
+		if (parsed === null) return null;
+		return SectionBlock.make({
+			toolName: definition.toolName,
+			commentStyle: definition.commentStyle,
+			content: parsed.managed
+		});
+	}));
+	const isManaged = Function.dual(2, (path, definition) => Effect.gen(function* () {
+		if (!(yield* fs.exists(path).pipe(Effect.orElseSucceed(() => false)))) return false;
+		const raw = yield* fs.readFileString(path).pipe(Effect.orElseSucceed(() => ""));
+		const begin = beginMarker(definition.toolName, definition.commentStyle);
+		const end = endMarker(definition.toolName, definition.commentStyle);
+		const beginIdx = raw.indexOf(begin);
+		const endIdx = raw.indexOf(end);
+		return beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx;
+	}));
+	const write = Function.dual(2, (path, block) => Effect.gen(function* () {
+		const exists = yield* fs.exists(path).pipe(Effect.orElseSucceed(() => false));
+		let fileContent;
+		if (exists) {
+			const raw = yield* fs.readFileString(path).pipe(Effect.mapError((cause) => new SectionWriteError({
+				path,
+				reason: String(cause)
+			})));
+			const parsed = parseContent(raw, block.toolName, block.commentStyle);
+			if (parsed !== null) fileContent = assembleContent(parsed.before, block.content, parsed.after, block.toolName, block.commentStyle);
+			else {
+				const trimmed = raw.trimEnd();
+				const begin = beginMarker(block.toolName, block.commentStyle);
+				const end = endMarker(block.toolName, block.commentStyle);
+				fileContent = `${trimmed}\n\n${begin}\n${block.content}\n${end}\n`;
+			}
+		} else {
+			const begin = beginMarker(block.toolName, block.commentStyle);
+			const end = endMarker(block.toolName, block.commentStyle);
+			fileContent = `${begin}\n${block.content}\n${end}\n`;
+		}
+		yield* fs.writeFileString(path, fileContent).pipe(Effect.mapError((cause) => new SectionWriteError({
+			path,
+			reason: String(cause)
+		})));
+	}));
+	return {
+		read,
+		write,
+		isManaged,
+		sync: Function.dual(2, (path, block) => Effect.gen(function* () {
+			const onDisk = yield* read(path, {
+				toolName: block.toolName,
+				commentStyle: block.commentStyle
+			}).pipe(Effect.mapError((cause) => new SectionWriteError({
+				path,
+				reason: String(cause)
+			})));
+			if (onDisk === null) {
+				yield* write(path, block);
+				return SyncResult.Created();
+			}
+			if (Equal.equals(onDisk, block)) return SyncResult.Unchanged();
+			const d = SectionBlock.diff(onDisk, block);
+			yield* write(path, block);
+			return SyncResult.Updated({ diff: d });
+		})),
+		syncMany: Function.dual(2, (path, blocks) => Effect.gen(function* () {
+			const original = (yield* fs.exists(path).pipe(Effect.orElseSucceed(() => false))) ? yield* fs.readFileString(path).pipe(Effect.mapError((cause) => new SectionWriteError({
+				path,
+				reason: String(cause)
+			}))) : "";
+			const keyOf = (b) => sectionKey(b.toolName, b.commentStyle);
+			const found = findAllSections(original);
+			const onDiskByKey = /* @__PURE__ */ new Map();
+			for (const f of found) if (!onDiskByKey.has(f.key)) onDiskByKey.set(f.key, f);
+			const results = blocks.map((block) => {
+				const onDisk = onDiskByKey.get(keyOf(block));
+				if (onDisk === void 0) return SyncResult.Created();
+				const current = SectionBlock.make({
+					toolName: block.toolName,
+					commentStyle: block.commentStyle,
+					content: onDisk.content
+				});
+				if (Equal.equals(current, block)) return SyncResult.Unchanged();
+				return SyncResult.Updated({ diff: SectionBlock.diff(current, block) });
+			});
+			const items = [];
+			let cursor = 0;
+			for (const f of found) {
+				items.push({
+					kind: "text",
+					value: original.slice(cursor, f.start)
+				});
+				items.push({
+					kind: "section",
+					key: f.key,
+					raw: f.raw,
+					render: null
+				});
+				cursor = f.end;
+			}
+			items.push({
+				kind: "text",
+				value: original.slice(cursor)
+			});
+			const targetKeys = new Set(blocks.map(keyOf));
+			const slotIndices = [];
+			items.forEach((item, idx) => {
+				if (item.kind === "section" && targetKeys.has(item.key)) slotIndices.push(idx);
+			});
+			const itemIndexByDeclared = /* @__PURE__ */ new Map();
+			let slotCursor = 0;
+			blocks.forEach((block, declaredIdx) => {
+				if (!onDiskByKey.has(keyOf(block))) return;
+				if (slotCursor >= slotIndices.length) return;
+				const itemIdx = slotIndices[slotCursor];
+				const item = items[itemIdx];
+				if (item.kind === "section") item.render = block;
+				itemIndexByDeclared.set(declaredIdx, itemIdx);
+				slotCursor += 1;
+			});
+			const beforeAnchor = /* @__PURE__ */ new Map();
+			const afterAnchor = /* @__PURE__ */ new Map();
+			const appendList = [];
+			const pushInto = (map, anchor, block) => {
+				const arr = map.get(anchor) ?? [];
+				arr.push(block);
+				map.set(anchor, arr);
+			};
+			blocks.forEach((block, i) => {
+				if (onDiskByKey.has(keyOf(block))) return;
+				let placed = false;
+				for (let j = i + 1; j < blocks.length && !placed; j += 1) {
+					const itemIdx = itemIndexByDeclared.get(j);
+					if (itemIdx !== void 0) {
+						pushInto(beforeAnchor, itemIdx, block);
+						placed = true;
+					}
+				}
+				for (let j = i - 1; j >= 0 && !placed; j -= 1) {
+					const itemIdx = itemIndexByDeclared.get(j);
+					if (itemIdx !== void 0) {
+						pushInto(afterAnchor, itemIdx, block);
+						placed = true;
+					}
+				}
+				if (!placed) appendList.push(block);
+			});
+			const out = [];
+			items.forEach((item, idx) => {
+				if (item.kind === "text") {
+					out.push(item.value);
+					return;
+				}
+				for (const block of beforeAnchor.get(idx) ?? []) out.push(block.rendered, "\n\n");
+				out.push(item.render === null ? item.raw : item.render.rendered);
+				for (const block of afterAnchor.get(idx) ?? []) out.push("\n\n", block.rendered);
+			});
+			let output = out.join("");
+			for (const block of appendList) output = output.trim() === "" ? `${block.rendered}\n` : `${output.replace(/\n+$/, "")}\n\n${block.rendered}\n`;
+			if (output !== "" && !output.endsWith("\n")) output += "\n";
+			if (output !== original) yield* fs.writeFileString(path, output).pipe(Effect.mapError((cause) => new SectionWriteError({
+				path,
+				reason: String(cause)
+			})));
+			return results;
+		})),
+		check: Function.dual(2, (path, block) => Effect.gen(function* () {
+			const onDisk = yield* read(path, {
+				toolName: block.toolName,
+				commentStyle: block.commentStyle
+			});
+			if (onDisk === null) return CheckResult.NotFound();
+			const isUpToDate = Equal.equals(onDisk, block);
+			const d = SectionBlock.diff(onDisk, block);
+			return CheckResult.Found({
+				isUpToDate,
+				diff: d
+			});
+		})),
+		remove: Function.dual(2, (path, definition) => Effect.gen(function* () {
+			if (!(yield* fs.exists(path).pipe(Effect.orElseSucceed(() => false)))) return false;
+			const parsed = parseContent(yield* fs.readFileString(path).pipe(Effect.mapError((cause) => new SectionWriteError({
+				path,
+				reason: String(cause)
+			}))), definition.toolName, definition.commentStyle);
+			if (parsed === null) return false;
+			const before = parsed.before.replace(/\n+$/, "");
+			const after = parsed.after.replace(/^\n+/, "");
+			let next;
+			if (before !== "" && after !== "") next = `${before}\n\n${after}`;
+			else if (before !== "") next = `${before}\n`;
+			else next = after;
+			yield* fs.writeFileString(path, next).pipe(Effect.mapError((cause) => new SectionWriteError({
+				path,
+				reason: String(cause)
+			})));
+			return true;
+		}))
+	};
+}));
+
+//#endregion
+export { ManagedSection, ManagedSectionLive };

package/services/SilkPublishability.js

@@ -0,0 +1,193 @@
+import { ChangesetConfig } from "./ChangesetConfig.js";
+import { Effect, Layer } from "effect";
+import { isAbsolute, join } from "node:path";
+import { PublishTarget, PublishabilityDetector, PublishabilityDetectorLive, WorkspaceDiscovery } from "workspaces-effect";
+import { FileSystem } from "@effect/platform";
+
+//#region src/services/SilkPublishability.ts
+const NPM_DEFAULT = "https://registry.npmjs.org/";
+/**
+* Default registry endpoints for the well-known target keys. Kept in sync with the
+* bundler's `resolveTargets` so the pre-build fallback matches what the binding will carry
+* (no trailing slash).
+*/
+const DEFAULT_REGISTRIES = {
+	npm: "https://registry.npmjs.org",
+	github: "https://npm.pkg.github.com"
+};
+/**
+* Silk publishability rules over `workspaces-effect`'s {@link PublishTarget}.
+*
+* @remarks
+* In silk mode `private: true` is the norm on workspace `package.json`; publishability is
+* derived from `publishConfig`, with the `private` flag consulted only as a last-resort
+* default. All helpers are static so a consumer sees the full rule surface in one place.
+*
+* @since 0.4.0
+*/
+var SilkPublishability = class {
+	/**
+	* Apply silk publishability rules to a raw `package.json` and the bundler's resolved
+	* target binding. Targets-first precedence:
+	*
+	* - A non-empty `publishConfig.targets` map (the bundler's Record-map form) makes the
+	*   package publishable regardless of `private`. With a `binding` (post-prod-build), one
+	*   {@link PublishTarget} is emitted per resolved registry target, its `directory` set to
+	*   the bound group's `dist/prod/<group>/pkg` dir. Without a binding (pre-build), one
+	*   placeholder target is emitted per declared key so publishability and target counts
+	*   are correct; the directory is best-effort and unused until the build writes the
+	*   binding.
+	* - Else `publishConfig.access` → one target at `publishConfig.directory`.
+	* - Else `private !== true` → one default public target.
+	* - Else `[]`.
+	*
+	* @param pkgName - The package's name (the base name for `true`/empty-object targets).
+	* @param raw - The raw `package.json` (silk reads the unschematized `publishConfig`).
+	* @param binding - The parsed `dist/prod/targets.json` binding, or `null` when the prod
+	*   build has not run yet. See {@link readTargetsBinding}.
+	*/
+	static detect(pkgName, raw, binding) {
+		const pc = raw.publishConfig;
+		const targets = pc?.targets;
+		if (targets && typeof targets === "object" && !Array.isArray(targets) && Object.keys(targets).length > 0) {
+			const access = pc?.access ?? "public";
+			if (binding) {
+				const dirByGroup = new Map(binding.groups.map((g) => [g.id, g.dir]));
+				return binding.targets.map((t) => new PublishTarget({
+					name: t.name,
+					registry: t.registry,
+					directory: dirByGroup.get(t.group) ?? `dist/prod/${t.group}/pkg`,
+					access
+				}));
+			}
+			return Object.keys(targets).map((id) => new PublishTarget({
+				name: pkgName,
+				registry: DEFAULT_REGISTRIES[id] ?? pc?.registry ?? NPM_DEFAULT,
+				directory: `dist/prod/${id}/pkg`,
+				access
+			}));
+		}
+		if (pc && (pc.access === "public" || pc.access === "restricted")) return [new PublishTarget({
+			name: pkgName,
+			registry: pc.registry ?? NPM_DEFAULT,
+			directory: pc.directory ?? ".",
+			access: pc.access
+		})];
+		if (raw.private !== true) return [new PublishTarget({
+			name: pkgName,
+			registry: pc?.registry ?? NPM_DEFAULT,
+			directory: pc?.directory ?? ".",
+			access: pc?.access ?? "public"
+		})];
+		return [];
+	}
+	/**
+	* Resolve a package's publish targets via {@link PublishabilityDetector}, then drop any
+	* whose built `directory` package.json is `private: true`. Returned targets keep the
+	* detector's original (possibly package-relative) `directory`.
+	*/
+	static resolveTargets(pkg, root) {
+		return Effect.gen(function* () {
+			const detector = yield* PublishabilityDetector;
+			const fs = yield* FileSystem.FileSystem;
+			const targets = yield* detector.detect(pkg, root);
+			const kept = [];
+			for (const t of targets) if (!(yield* isTargetPrivate(fs, isAbsolute(t.directory) ? t.directory : join(pkg.path, t.directory)))) kept.push(t);
+			return kept;
+		});
+	}
+	/**
+	* The publishable, non-ignored packages, resolved through the single
+	* {@link PublishabilityDetector} (which already honors changeset ignore in adaptive mode).
+	*/
+	static listPublishable(root) {
+		return Effect.gen(function* () {
+			const discovery = yield* WorkspaceDiscovery;
+			const detector = yield* PublishabilityDetector;
+			const packages = yield* discovery.listPackages().pipe(Effect.orDie);
+			const out = [];
+			for (const pkg of packages) {
+				const targets = yield* detector.detect(pkg, root);
+				if (targets.length > 0) out.push({
+					name: pkg.name,
+					version: pkg.version,
+					path: pkg.path,
+					targetCount: targets.length
+				});
+			}
+			return out;
+		});
+	}
+};
+/** True when a built target directory's package.json is `private: true`. Missing/unreadable/malformed → false. */
+const isTargetPrivate = (fs, targetDir) => fs.readFileString(join(targetDir, "package.json")).pipe(Effect.flatMap((content) => Effect.try({
+	try: () => JSON.parse(content).private === true,
+	catch: () => /* @__PURE__ */ new Error("invalid package.json")
+})), Effect.orElseSucceed(() => false));
+/** Read a raw `package.json` from disk via FileSystem; missing/unreadable/malformed → null. */
+const readRaw = (fs, packageJsonPath) => fs.readFileString(packageJsonPath).pipe(Effect.flatMap((content) => Effect.try({
+	try: () => JSON.parse(content),
+	catch: () => /* @__PURE__ */ new Error("invalid package.json")
+})), Effect.orElseSucceed(() => null));
+/**
+* Read the bundler's `<pkgPath>/dist/prod/targets.json` binding via FileSystem.
+*
+* @remarks
+* Returns `null` when the file is missing/unreadable/malformed — i.e. before the prod build
+* has run. {@link SilkPublishability.detect} falls back to declared-key placeholders in that
+* case. Used by the silk {@link PublishabilityDetector} layers and the workspace analyzer.
+*
+* @param fs - The FileSystem service.
+* @param pkgPath - Absolute path to the package directory.
+* @since 1.0.0
+*/
+const readTargetsBinding = (fs, pkgPath) => fs.readFileString(join(pkgPath, "dist", "prod", "targets.json")).pipe(Effect.flatMap((content) => Effect.try({
+	try: () => JSON.parse(content),
+	catch: () => /* @__PURE__ */ new Error("invalid targets.json")
+})), Effect.orElseSucceed(() => null));
+/**
+* Override of `workspaces-effect`'s {@link PublishabilityDetector} Tag with pure silk rules.
+*
+* @remarks Requires `FileSystem` (captured at layer build); `detect` reads the raw
+* `package.json` from `pkg.packageJsonPath` and applies {@link SilkPublishability.detect}.
+*
+* @since 0.4.0
+*/
+const SilkPublishabilityDetectorLive = Layer.effect(PublishabilityDetector, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	return { detect: (pkg, _root) => Effect.gen(function* () {
+		const raw = yield* readRaw(fs, pkg.packageJsonPath);
+		if (!raw) return [];
+		const binding = yield* readTargetsBinding(fs, pkg.path);
+		return SilkPublishability.detect(pkg.name, raw, binding);
+	}) };
+}));
+/**
+* Ignore-aware override of {@link PublishabilityDetector}. `detect` short-circuits to `[]`
+* for changeset-ignored packages, then dispatches on {@link ChangesetConfig.mode}:
+* `none` → `[]`; `silk` → {@link SilkPublishability.detect}; `vanilla` → the library default.
+*
+* @remarks Requires `FileSystem` + {@link ChangesetConfig} at build.
+*
+* @since 0.4.0
+*/
+const PublishabilityDetectorAdaptiveLive = Layer.effect(PublishabilityDetector, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const config = yield* ChangesetConfig;
+	const vanilla = yield* Effect.provide(PublishabilityDetector, PublishabilityDetectorLive);
+	return { detect: (pkg, root) => Effect.gen(function* () {
+		if (yield* config.isIgnored(pkg.name, root)) return [];
+		const mode = yield* config.mode(root);
+		if (mode === "none") return [];
+		if (mode === "silk") {
+			const raw = yield* readRaw(fs, pkg.packageJsonPath);
+			if (!raw) return [];
+			const binding = yield* readTargetsBinding(fs, pkg.path);
+			return SilkPublishability.detect(pkg.name, raw, binding);
+		}
+		return yield* vanilla.detect(pkg, root);
+	}) };
+}));
+
+//#endregion
+export { PublishabilityDetectorAdaptiveLive, SilkPublishability, SilkPublishabilityDetectorLive, readTargetsBinding };

package/services/SilkWorkspaceAnalyzer.js

@@ -0,0 +1,213 @@
+import { ChangesetConfigReader } from "./ChangesetConfigReader.js";
+import { WorkspaceAnalysisError } from "../errors/WorkspaceAnalysisError.js";
+import { AnalyzedWorkspace, WorkspaceAnalysis } from "../schemas/WorkspaceAnalysisSchemas.js";
+import { ChangesetConfig } from "./ChangesetConfig.js";
+import { SilkPublishability, readTargetsBinding } from "./SilkPublishability.js";
+import { TagStrategy } from "./TagStrategy.js";
+import { VersioningStrategy } from "./VersioningStrategy.js";
+import { Context, Effect, Layer, Option } from "effect";
+import { PackageManagerDetector, TopologicalSorter, WorkspaceDiscovery } from "workspaces-effect";
+import { FileSystem } from "@effect/platform";
+
+//#region src/services/SilkWorkspaceAnalyzer.ts
+/**
+* Service that performs a full workspace analysis — discovering packages,
+* detecting publishability, computing versioning/tag strategies, and
+* wiring up fixed/linked release groups.
+*
+* @remarks
+* Orchestrates {@link WorkspaceDiscovery}, {@link PackageManagerDetector},
+* {@link ChangesetConfigReader}, {@link VersioningStrategy}, and
+* {@link TagStrategy} to produce a complete {@link WorkspaceAnalysis} for a
+* given workspace root.
+*
+* @example
+* ```typescript
+* const result = await Effect.runPromise(
+*   Effect.gen(function* () {
+*     const analyzer = yield* SilkWorkspaceAnalyzer;
+*     return yield* analyzer.analyze("/path/to/monorepo");
+*   }).pipe(
+*     Effect.provide(SilkWorkspaceAnalyzerLive),
+*     // ... provide all transitive layers
+*   )
+* );
+* ```
+*
+* @since 0.2.0
+*/
+var SilkWorkspaceAnalyzer = class extends Context.Tag("@savvy-web/silk-effects/SilkWorkspaceAnalyzer")() {};
+/**
+* Read the raw package.json from disk as an untyped record.
+*
+* @remarks
+* We read from disk rather than using WorkspacePackage.publishConfig because
+* the upstream PublishConfig schema strips unknown fields (like Silk `targets`).
+* SilkPublishability.detect needs the full raw publishConfig.
+*/
+const readRawPkgJson = (fs, packageJsonPath) => fs.readFileString(packageJsonPath).pipe(Effect.flatMap((content) => Effect.try({
+	try: () => JSON.parse(content),
+	catch: () => new WorkspaceAnalysisError({
+		root: packageJsonPath,
+		reason: "Invalid JSON in package.json"
+	})
+})), Effect.mapError((err) => err instanceof WorkspaceAnalysisError ? err : new WorkspaceAnalysisError({
+	root: packageJsonPath,
+	reason: `Failed to read package.json: ${String(err)}`
+})));
+/**
+* Determine the release status flags (versioned, tagged, released) for a workspace
+* based on the changeset config.
+*
+* @param pkgName - The package name.
+* @param isPrivate - Whether package.json has `private: true`.
+* @param isPublishable - Whether the package has resolved publish targets.
+*   A package with `private: true` + `publishConfig.access` is publishable
+*   in Silk convention and should be versioned/tagged like a public package.
+* @param config - The changeset config, or null if no changesets.
+*/
+function computeReleaseStatus(pkgName, isPrivate, isPublishable, config) {
+	if (config == null) return {
+		versioned: false,
+		tagged: false,
+		released: false
+	};
+	if ((config.ignore ?? []).some((p) => ChangesetConfig.matches(pkgName, p))) return {
+		versioned: false,
+		tagged: false,
+		released: false
+	};
+	if (!isPrivate || isPublishable) return {
+		versioned: true,
+		tagged: true,
+		released: true
+	};
+	const pp = config.privatePackages;
+	if (pp === void 0) return {
+		versioned: false,
+		tagged: false,
+		released: false
+	};
+	if (pp === false) return {
+		versioned: false,
+		tagged: false,
+		released: false
+	};
+	const versioned = pp.version === true;
+	const tagged = pp.tag === true;
+	return {
+		versioned,
+		tagged,
+		released: versioned && tagged
+	};
+}
+/**
+* Live implementation of {@link SilkWorkspaceAnalyzer}.
+*
+* @remarks
+* Requires {@link WorkspaceDiscovery}, {@link PackageManagerDetector},
+* {@link ChangesetConfigReader}, {@link VersioningStrategy}, and {@link TagStrategy}.
+*
+* @since 0.2.0
+*/
+const SilkWorkspaceAnalyzerLive = Layer.effect(SilkWorkspaceAnalyzer, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const discovery = yield* WorkspaceDiscovery;
+	const sorter = yield* TopologicalSorter;
+	const pmDetector = yield* PackageManagerDetector;
+	const configReader = yield* ChangesetConfigReader;
+	const versioningStrategy = yield* VersioningStrategy;
+	const tagStrategy = yield* TagStrategy;
+	const analyze = (root) => Effect.gen(function* () {
+		const pm = yield* pmDetector.detect(root).pipe(Effect.mapError((err) => new WorkspaceAnalysisError({
+			root,
+			reason: `Package manager detection failed: ${String(err)}`
+		})));
+		const packages = yield* discovery.listPackages(root).pipe(Effect.mapError((err) => new WorkspaceAnalysisError({
+			root,
+			reason: `Workspace discovery failed: ${String(err)}`
+		})));
+		const topoOrder = yield* sorter.sort().pipe(Effect.mapError((err) => new WorkspaceAnalysisError({
+			root,
+			reason: `Cyclic dependency detected: ${String(err)}`
+		})));
+		const packagesByName = new Map(packages.map((p) => [p.name, p]));
+		const reordered = topoOrder.flatMap((name) => {
+			const pkg = packagesByName.get(name);
+			return pkg ? [pkg] : [];
+		});
+		const sortedPackages = reordered.length > 0 ? reordered : [...packages];
+		const changesetConfigOption = yield* configReader.read(root).pipe(Effect.option);
+		const changesetConfig = Option.getOrNull(changesetConfigOption);
+		const analyzedWorkspaces = [];
+		for (const pkg of sortedPackages) {
+			const pkgJson = yield* readRawPkgJson(fs, pkg.packageJsonPath);
+			const binding = yield* readTargetsBinding(fs, pkg.path);
+			const targets = SilkPublishability.detect(pkg.name, pkgJson, binding);
+			const isPublishable = targets.length > 0;
+			const isRoot = pkg.relativePath === ".";
+			const { versioned, tagged, released } = computeReleaseStatus(pkg.name, pkg.private, isPublishable, changesetConfig);
+			const analyzed = new AnalyzedWorkspace({
+				name: pkg.name,
+				version: { current: pkg.version },
+				path: pkg.path,
+				root: isRoot,
+				publishConfig: null,
+				publishable: isPublishable,
+				targets: [...targets],
+				versioned,
+				tagged,
+				released,
+				linked: [],
+				fixed: []
+			});
+			analyzedWorkspaces.push(analyzed);
+		}
+		if (changesetConfig) {
+			const fixedGroups = changesetConfig.fixed ?? [];
+			const linkedGroups = changesetConfig.linked ?? [];
+			const fixedByName = /* @__PURE__ */ new Map();
+			for (const group of fixedGroups) {
+				const members = analyzedWorkspaces.filter((w) => group.includes(w.name));
+				for (const member of members) fixedByName.set(member.name, members.filter((m) => m !== member));
+			}
+			const linkedByName = /* @__PURE__ */ new Map();
+			for (const group of linkedGroups) {
+				const members = analyzedWorkspaces.filter((w) => group.includes(w.name));
+				for (const member of members) linkedByName.set(member.name, members.filter((m) => m !== member));
+			}
+			for (let i = 0; i < analyzedWorkspaces.length; i++) {
+				const ws = analyzedWorkspaces[i];
+				const fixedRefs = fixedByName.get(ws.name) ?? [];
+				const linkedRefs = linkedByName.get(ws.name) ?? [];
+				if (fixedRefs.length > 0 || linkedRefs.length > 0) analyzedWorkspaces[i] = new AnalyzedWorkspace({
+					...ws,
+					fixed: fixedRefs,
+					linked: linkedRefs
+				});
+			}
+		}
+		const publishableNames = analyzedWorkspaces.filter((w) => w.publishable).map((w) => w.name);
+		const versioning = yield* versioningStrategy.detect(publishableNames, root).pipe(Effect.mapError((err) => new WorkspaceAnalysisError({
+			root,
+			reason: `Versioning strategy detection failed: ${String(err)}`
+		})));
+		const tagStrategyType = yield* tagStrategy.determine(versioning);
+		return new WorkspaceAnalysis({
+			root,
+			runtime: pm.runtime,
+			packageManager: {
+				type: pm.type,
+				version: pm.version
+			},
+			workspaces: analyzedWorkspaces,
+			changesetConfig,
+			versioning,
+			tagStrategy: tagStrategyType
+		});
+	});
+	return { analyze };
+}));
+
+//#endregion
+export { SilkWorkspaceAnalyzer, SilkWorkspaceAnalyzerLive };