@savvy-web/silk-effects 3.3.1 → 4.0.1

package/schemas/ResolvedTool.js

@@ -1,10 +1,15 @@
 import { ToolCommand } from "../utils/ToolCommand.js";
 import { ToolSource } from "./ToolResults.js";
 import { Equal, Hash, Schema } from "effect";
-import { Command } from "@effect/platform";
+import { ChildProcess } from "effect/unstable/process";
 
 //#region src/schemas/ResolvedTool.ts
-const PackageManager = Schema.Literal("npm", "pnpm", "yarn", "bun");
+const PackageManager = Schema.Literals([
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun"
+]);
 /**
 * Result of resolving a {@link ToolDefinition}.
 *
@@ -16,9 +21,9 @@ const PackageManager = Schema.Literal("npm", "pnpm", "yarn", "bun");
 var ResolvedTool = class ResolvedTool extends Schema.TaggedClass()("ResolvedTool", {
 	name: Schema.String,
 	source: ToolSource,
-	version: Schema.OptionFromSelf(Schema.String),
-	globalVersion: Schema.OptionFromSelf(Schema.String),
-	localVersion: Schema.OptionFromSelf(Schema.String),
+	version: Schema.Option(Schema.String),
+	globalVersion: Schema.Option(Schema.String),
+	localVersion: Schema.Option(Schema.String),
 	packageManager: PackageManager,
 	mismatch: Schema.Boolean
 }) {
@@ -32,20 +37,50 @@ var ResolvedTool = class ResolvedTool extends Schema.TaggedClass()("ResolvedTool
 		return this.mismatch;
 	}
 	exec(...args) {
-		if (this.source === "global") return new ToolCommand(Command.make(this.name, ...args));
+		if (this.source === "global") return new ToolCommand(ChildProcess.make(this.name, args));
 		switch (this.packageManager) {
-			case "pnpm": return new ToolCommand(Command.make("pnpm", "exec", this.name, ...args));
-			case "npm": return new ToolCommand(Command.make("npx", "--no", "--", this.name, ...args));
-			case "yarn": return new ToolCommand(Command.make("yarn", "exec", this.name, ...args));
-			case "bun": return new ToolCommand(Command.make("bun", "x", "--no-install", this.name, ...args));
+			case "pnpm": return new ToolCommand(ChildProcess.make("pnpm", [
+				"exec",
+				this.name,
+				...args
+			]));
+			case "npm": return new ToolCommand(ChildProcess.make("npx", [
+				"--no",
+				"--",
+				this.name,
+				...args
+			]));
+			case "yarn": return new ToolCommand(ChildProcess.make("yarn", [
+				"exec",
+				this.name,
+				...args
+			]));
+			case "bun": return new ToolCommand(ChildProcess.make("bun", [
+				"x",
+				"--no-install",
+				this.name,
+				...args
+			]));
 		}
 	}
 	dlx(...args) {
 		switch (this.packageManager) {
-			case "pnpm": return new ToolCommand(Command.make("pnpm", "dlx", this.name, ...args));
-			case "npm": return new ToolCommand(Command.make("npx", this.name, ...args));
-			case "yarn": return new ToolCommand(Command.make("yarn", "dlx", this.name, ...args));
-			case "bun": return new ToolCommand(Command.make("bun", "x", this.name, ...args));
+			case "pnpm": return new ToolCommand(ChildProcess.make("pnpm", [
+				"dlx",
+				this.name,
+				...args
+			]));
+			case "npm": return new ToolCommand(ChildProcess.make("npx", [this.name, ...args]));
+			case "yarn": return new ToolCommand(ChildProcess.make("yarn", [
+				"dlx",
+				this.name,
+				...args
+			]));
+			case "bun": return new ToolCommand(ChildProcess.make("bun", [
+				"x",
+				this.name,
+				...args
+			]));
 		}
 	}
 	[Equal.symbol](that) {
@@ -54,9 +89,9 @@ var ResolvedTool = class ResolvedTool extends Schema.TaggedClass()("ResolvedTool
 	}
 	[Hash.symbol]() {
 		let h = Hash.hash(this.name);
-		h = Hash.combine(h)(Hash.hash(this.source));
-		h = Hash.combine(h)(Hash.hash(this.version));
-		return Hash.cached(this)(h);
+		h = Hash.combine(h, Hash.hash(this.source));
+		h = Hash.combine(h, Hash.hash(this.version));
+		return Hash.optimize(h);
 	}
 };
 

package/schemas/SectionBlock.js

@@ -63,7 +63,7 @@ var SectionBlock = class SectionBlock extends Schema.TaggedClass()("SectionBlock
 		return this.normalized === that.normalized;
 	}
 	[Hash.symbol]() {
-		return Hash.cached(this)(Hash.hash(this.normalized));
+		return Hash.optimize(Hash.hash(this.normalized));
 	}
 };
 

package/schemas/SectionDefinition.js

@@ -17,7 +17,7 @@ import { Effect, Equal, Function, Hash, Schema } from "effect";
 */
 var SectionDefinition = class SectionDefinition extends Schema.TaggedClass()("SectionDefinition", {
 	toolName: Schema.String,
-	commentStyle: Schema.optionalWith(CommentStyle, { default: () => "#" })
+	commentStyle: CommentStyle.pipe(Schema.withDecodingDefaultType(Effect.succeed("#")), Schema.withConstructorDefault(Effect.succeed("#")))
 }) {
 	_validate;
 	static generate = Function.dual(2, (self, fn) => {
@@ -83,7 +83,7 @@ var SectionDefinition = class SectionDefinition extends Schema.TaggedClass()("Se
 		return this.toolName === that.toolName && this.commentStyle === that.commentStyle;
 	}
 	[Hash.symbol]() {
-		return Hash.cached(this)(Hash.combine(Hash.hash(this.toolName))(Hash.hash(this.commentStyle)));
+		return Hash.optimize(Hash.combine(Hash.hash(this.toolName), Hash.hash(this.commentStyle)));
 	}
 };
 /**

package/schemas/TagStrategySchemas.js

@@ -13,7 +13,7 @@ import { Schema } from "effect";
 * @since 0.1.0
 * @public
 */
-const TagStrategyType = Schema.Literal("single", "scoped");
+const TagStrategyType = Schema.Literals(["single", "scoped"]);
 
 //#endregion
 export { TagStrategyType };

package/schemas/ToolDefinition.js

@@ -32,7 +32,7 @@ var ToolDefinition = class ToolDefinition {
 		return this.name === that.name;
 	}
 	[Hash.symbol]() {
-		return Hash.cached(this)(Hash.hash(this.name));
+		return Hash.optimize(Hash.hash(this.name));
 	}
 };
 

package/schemas/ToolResults.js

@@ -7,7 +7,7 @@ import { Data, Schema } from "effect";
 * @since 0.2.0
 * @public
 */
-const ToolSource = Schema.Literal("global", "local");
+const ToolSource = Schema.Literals(["global", "local"]);
 /**
 * @since 0.2.0
 * @public

package/schemas/VersioningSchemas.js

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import { Effect, Schema } from "effect";
 
 //#region src/schemas/VersioningSchemas.ts
 /**
@@ -11,10 +11,10 @@ import { Schema } from "effect";
 *
 * @since 0.2.0
 */
-const PrivatePackagesConfig = Schema.Union(Schema.Struct({
+const PrivatePackagesConfig = Schema.Union([Schema.Struct({
 	tag: Schema.optional(Schema.Boolean),
 	version: Schema.optional(Schema.Boolean)
-}), Schema.Literal(false));
+}), Schema.Literal(false)]);
 /**
 * Snapshot release configuration for changesets.
 *
@@ -41,13 +41,25 @@ const SnapshotConfig = Schema.Struct({
 */
 /** @public */
 const ChangesetConfigFile = Schema.Struct({
-	changelog: Schema.optional(Schema.Union(Schema.String, Schema.Array(Schema.Unknown), Schema.Literal(false))),
-	commit: Schema.optional(Schema.Union(Schema.Boolean, Schema.String, Schema.Array(Schema.Unknown))),
+	changelog: Schema.optional(Schema.Union([
+		Schema.String,
+		Schema.Array(Schema.Unknown),
+		Schema.Literal(false)
+	])),
+	commit: Schema.optional(Schema.Union([
+		Schema.Boolean,
+		Schema.String,
+		Schema.Array(Schema.Unknown)
+	])),
 	fixed: Schema.optional(Schema.Array(Schema.Array(Schema.String))),
 	linked: Schema.optional(Schema.Array(Schema.Array(Schema.String))),
-	access: Schema.optional(Schema.Literal("public", "restricted")),
+	access: Schema.optional(Schema.Literals(["public", "restricted"])),
 	baseBranch: Schema.optional(Schema.String),
-	updateInternalDependencies: Schema.optional(Schema.Literal("patch", "minor", "major")),
+	updateInternalDependencies: Schema.optional(Schema.Literals([
+		"patch",
+		"minor",
+		"major"
+	])),
 	ignore: Schema.optional(Schema.Array(Schema.String)),
 	privatePackages: Schema.optional(PrivatePackagesConfig),
 	prettier: Schema.optional(Schema.Boolean),
@@ -66,7 +78,10 @@ const ChangesetConfigFile = Schema.Struct({
 * @since 0.1.0
 */
 /** @public */
-const SilkChangesetConfigFile = Schema.extend(ChangesetConfigFile, Schema.Struct({ _isSilk: Schema.optionalWith(Schema.Boolean, { default: () => true }) }));
+const SilkChangesetConfigFile = Schema.Struct({
+	...ChangesetConfigFile.fields,
+	_isSilk: Schema.Boolean.pipe(Schema.withDecodingDefaultType(Effect.succeed(true)), Schema.withConstructorDefault(Effect.succeed(true)))
+});
 /**
 * Versioning strategy classification for a workspace.
 *
@@ -78,7 +93,11 @@ const SilkChangesetConfigFile = Schema.extend(ChangesetConfigFile, Schema.Struct
 * @since 0.1.0
 * @public
 */
-const VersioningStrategyType = Schema.Literal("single", "fixed-group", "independent");
+const VersioningStrategyType = Schema.Literals([
+	"single",
+	"fixed-group",
+	"independent"
+]);
 /**
 * Output of the versioning strategy detection, combining the strategy type with group metadata.
 *

package/schemas/WorkspaceAnalysisSchemas.js

@@ -1,17 +1,21 @@
 import { ChangesetConfigFile, SilkChangesetConfigFile, VersioningStrategyResult } from "./VersioningSchemas.js";
 import { trimTrailingSlashes } from "../utils/TrailingSlash.js";
 import { TagStrategyType } from "./TagStrategySchemas.js";
-import { Equal, Function, Hash, Option, Pretty, Schema } from "effect";
-import { PublishConfig, PublishTarget } from "workspaces-effect";
+import { Effect, Equal, Function, Hash, Option, Schema } from "effect";
+import { PublishConfig, PublishTarget } from "@effected/workspaces";
 
 //#region src/schemas/WorkspaceAnalysisSchemas.ts
-const PublishProtocol = Schema.Literal("npm", "jsr");
-const PublishTargetShorthand = Schema.Literal("npm", "github", "jsr");
+const PublishProtocol = Schema.Literals(["npm", "jsr"]);
+const PublishTargetShorthand = Schema.Literals([
+	"npm",
+	"github",
+	"jsr"
+]);
 const PublishTargetObject = Schema.Struct({
-	protocol: Schema.optionalWith(PublishProtocol, { default: () => "npm" }),
+	protocol: PublishProtocol.pipe(Schema.withDecodingDefaultType(Effect.succeed("npm")), Schema.withConstructorDefault(Effect.succeed("npm"))),
 	registry: Schema.optional(Schema.String),
 	directory: Schema.optional(Schema.String),
-	access: Schema.optional(Schema.Literal("public", "restricted")),
+	access: Schema.optional(Schema.Literals(["public", "restricted"])),
 	provenance: Schema.optional(Schema.Boolean),
 	tag: Schema.optional(Schema.String)
 });
@@ -19,14 +23,15 @@ const PublishTargetObject = Schema.Struct({
 * Silk-extended publishConfig schema.
 *
 * @remarks
-* Extends the base PublishConfig from workspaces-effect (which covers npm
-* standard fields: access, registry, directory, tag, linkDirectory) with the
-* Silk `targets` extension for multi-registry publishing.
+* Extends the base PublishConfig from `@effected/workspaces` (which covers the
+* npm standard fields — access, registry, directory, tag — and, as of kit
+* round 3, `linkDirectory`) with the Silk `targets` extension for
+* multi-registry publishing.
 *
 * @since 0.2.0
 * @public
 */
-var SilkPublishConfig = class extends PublishConfig.extend("SilkPublishConfig")({ targets: Schema.optional(Schema.Array(Schema.Union(PublishTargetShorthand, PublishTargetObject))) }) {};
+var SilkPublishConfig = class extends PublishConfig.extend("SilkPublishConfig")({ targets: Schema.optional(Schema.Array(Schema.Union([PublishTargetShorthand, PublishTargetObject]))) }) {};
 const KNOWN_REGISTRIES = {
 	npm: "https://registry.npmjs.org/",
 	github: "https://npm.pkg.github.com/",
@@ -94,7 +99,7 @@ var AnalyzedWorkspace = class AnalyzedWorkspace extends Schema.TaggedClass()("An
 		return this.name === that.name && this.path === that.path;
 	}
 	[Hash.symbol]() {
-		return Hash.cached(this)(Hash.combine(Hash.hash(this.name))(Hash.hash(this.path)));
+		return Hash.optimize(Hash.combine(Hash.hash(this.name), Hash.hash(this.path)));
 	}
 	toString() {
 		return `${this.name}@${this.version.current}`;
@@ -127,9 +132,14 @@ AnalyzedWorkspace.findByName = Function.dual(2, (workspaces, name) => {
 	const found = workspaces.find((w) => w.name === name);
 	return found ? Option.some(found) : Option.none();
 });
-AnalyzedWorkspace.pretty = Pretty.make(AnalyzedWorkspace);
+AnalyzedWorkspace.pretty = Schema.toFormatter(AnalyzedWorkspace);
 const PackageManagerInfo = Schema.Struct({
-	type: Schema.Literal("npm", "pnpm", "yarn", "bun"),
+	type: Schema.Literals([
+		"npm",
+		"pnpm",
+		"yarn",
+		"bun"
+	]),
 	version: Schema.optional(Schema.String)
 });
 /**
@@ -141,10 +151,10 @@ const PackageManagerInfo = Schema.Struct({
 */
 var WorkspaceAnalysis = class WorkspaceAnalysis extends Schema.TaggedClass()("WorkspaceAnalysis", {
 	root: Schema.String,
-	runtime: Schema.Literal("node", "bun"),
+	runtime: Schema.Literals(["node", "bun"]),
 	packageManager: PackageManagerInfo,
 	workspaces: Schema.Array(AnalyzedWorkspace),
-	changesetConfig: Schema.NullOr(Schema.Union(SilkChangesetConfigFile, ChangesetConfigFile)),
+	changesetConfig: Schema.NullOr(Schema.Union([SilkChangesetConfigFile, ChangesetConfigFile])),
 	versioning: Schema.NullOr(VersioningStrategyResult),
 	tagStrategy: Schema.NullOr(TagStrategyType)
 }) {
@@ -180,7 +190,7 @@ var WorkspaceAnalysis = class WorkspaceAnalysis extends Schema.TaggedClass()("Wo
 		return this.root === that.root;
 	}
 	[Hash.symbol]() {
-		return Hash.cached(this)(Hash.hash(this.root));
+		return Hash.optimize(Hash.hash(this.root));
 	}
 	toString() {
 		return `WorkspaceAnalysis(${this.root}, ${this.workspaces.length} workspaces)`;
@@ -188,7 +198,7 @@ var WorkspaceAnalysis = class WorkspaceAnalysis extends Schema.TaggedClass()("Wo
 	/** Pretty-print a WorkspaceAnalysis instance. */
 	static pretty;
 };
-WorkspaceAnalysis.pretty = Pretty.make(WorkspaceAnalysis);
+WorkspaceAnalysis.pretty = Schema.toFormatter(WorkspaceAnalysis);
 
 //#endregion
 export { AnalyzedWorkspace, SilkPublishConfig, WorkspaceAnalysis };

package/services/BiomeSchemaSync.js

@@ -1,7 +1,6 @@
 import { BiomeSyncError } from "../errors/BiomeSyncError.js";
-import { Context, Effect, Layer } from "effect";
-import { FileSystem } from "@effect/platform";
-import { parse } from "jsonc-effect";
+import { Context, Effect, FileSystem, Layer } from "effect";
+import { Jsonc } from "@effected/jsonc";
 
 //#region src/services/BiomeSchemaSync.ts
 /**
@@ -54,7 +53,7 @@ function findBiomeConfigs(cwd, fs) {
 *     return yield* syncer.sync("^1.9.3");
 *   }).pipe(
 *     Effect.provide(BiomeSchemaSyncLive),
-*     Effect.provide(NodeContext.layer),
+*     Effect.provide(NodeServices.layer),
 *   )
 * );
 * ```
@@ -62,13 +61,13 @@ function findBiomeConfigs(cwd, fs) {
 * @since 0.1.0
 * @public
 */
-var BiomeSchemaSync = class extends Context.Tag("@savvy-web/silk-effects/BiomeSchemaSync")() {};
+var BiomeSchemaSync = class extends Context.Service()("@savvy-web/silk-effects/BiomeSchemaSync") {};
 /**
 * Live implementation of {@link BiomeSchemaSync}.
 *
 * @remarks
-* Requires `FileSystem` from `@effect/platform`. Provide `NodeContext.layer` or
-* `BunContext.layer` to satisfy this dependency.
+* Requires the core `FileSystem` service. Provide `NodeServices.layer` (or
+* `NodeFileSystem.layer`) from `@effect/platform-node` to satisfy this dependency.
 *
 * @since 0.1.0
 * @public
@@ -90,7 +89,7 @@ const BiomeSchemaSyncLive = Layer.effect(BiomeSchemaSync, Effect.gen(function* (
 					reason: String(cause)
 				})
 			));
-			const schema = (yield* parse(raw).pipe(Effect.mapError(
+			const schema = (yield* Jsonc.parse(raw).pipe(Effect.mapError(
 				/* v8 ignore next 4 -- error path requires a JSONC parse failure */
 				(e) => new BiomeSyncError({
 					path: configPath,

package/services/ChangesetConfig.js

@@ -13,7 +13,7 @@ import { Context, Effect, Layer, Option } from "effect";
 * @since 0.4.0
 * @public
 */
-var ChangesetConfig = class extends Context.Tag("@savvy-web/silk-effects/ChangesetConfig")() {
+var ChangesetConfig = class extends Context.Service()("@savvy-web/silk-effects/ChangesetConfig") {
 	/**
 	* The one ignore matcher: exact name match, or `@scope/*` wildcard.
 	*
@@ -34,7 +34,7 @@ const isSilk = (cfg) => "_isSilk" in cfg && cfg._isSilk === true;
 *
 * @remarks
 * Requires `ChangesetConfigReader` (which requires `FileSystem`). Provide
-* `ChangesetConfigReaderLive` + a platform layer (`NodeContext.layer`).
+* `ChangesetConfigReaderLive` + a platform layer (`NodeServices.layer`).
 *
 * @since 0.4.0
 * @public

package/services/ChangesetConfigReader.js

@@ -1,7 +1,6 @@
 import { ChangesetConfigError } from "../errors/ChangesetConfigError.js";
 import { ChangesetConfigFile, SilkChangesetConfigFile } from "../schemas/VersioningSchemas.js";
-import { Context, Effect, Layer, Schema } from "effect";
-import { FileSystem } from "@effect/platform";
+import { Context, Effect, FileSystem, Layer, Schema } from "effect";
 
 //#region src/services/ChangesetConfigReader.ts
 /**
@@ -43,7 +42,7 @@ function isSilkChangelog(changelog) {
 *     return yield* reader.read(process.cwd());
 *   }).pipe(
 *     Effect.provide(ChangesetConfigReaderLive),
-*     Effect.provide(NodeContext.layer),
+*     Effect.provide(NodeServices.layer),
 *   )
 * );
 * ```
@@ -51,13 +50,13 @@ function isSilkChangelog(changelog) {
 * @since 0.1.0
 * @public
 */
-var ChangesetConfigReader = class extends Context.Tag("@savvy-web/silk-effects/ChangesetConfigReader")() {};
+var ChangesetConfigReader = class extends Context.Service()("@savvy-web/silk-effects/ChangesetConfigReader") {};
 /**
 * Live implementation of {@link ChangesetConfigReader}.
 *
 * @remarks
-* Requires `FileSystem` from `@effect/platform`. Provide `NodeContext.layer` or
-* `BunContext.layer` to satisfy this dependency.
+* Requires the core `FileSystem` service. Provide `NodeServices.layer` (or
+* `NodeFileSystem.layer`) from `@effect/platform-node` to satisfy this dependency.
 *
 * @since 0.1.0
 * @public
@@ -91,14 +90,14 @@ const ChangesetConfigReaderLive = Layer.effect(ChangesetConfigReader, Effect.gen
 					reason: `Invalid JSON: ${String(cause)}`
 				})
 			});
-			if (isSilkChangelog(parsed.changelog)) return yield* Schema.decodeUnknown(SilkChangesetConfigFile)(parsed).pipe(Effect.mapError(
+			if (isSilkChangelog(parsed.changelog)) return yield* Schema.decodeUnknownEffect(SilkChangesetConfigFile)(parsed).pipe(Effect.mapError(
 				/* v8 ignore next 4 -- error path requires schema decode failure */
 				(cause) => new ChangesetConfigError({
 					path: configPath,
 					reason: `Schema decode failed: ${String(cause)}`
 				})
 			));
-			return yield* Schema.decodeUnknown(ChangesetConfigFile)(parsed).pipe(Effect.mapError(
+			return yield* Schema.decodeUnknownEffect(ChangesetConfigFile)(parsed).pipe(Effect.mapError(
 				/* v8 ignore next 4 -- error path requires schema decode failure */
 				(cause) => new ChangesetConfigError({
 					path: configPath,

package/services/ConfigDiscovery.js

@@ -1,5 +1,4 @@
-import { Context, Effect, Layer } from "effect";
-import { FileSystem } from "@effect/platform";
+import { Context, Effect, FileSystem, Layer } from "effect";
 
 //#region src/services/ConfigDiscovery.ts
 /**
@@ -20,7 +19,7 @@ import { FileSystem } from "@effect/platform";
 *     return yield* discovery.find("biome.json");
 *   }).pipe(
 *     Effect.provide(ConfigDiscoveryLive),
-*     Effect.provide(NodeContext.layer),
+*     Effect.provide(NodeServices.layer),
 *   )
 * );
 * ```
@@ -28,7 +27,7 @@ import { FileSystem } from "@effect/platform";
 * @since 0.1.0
 * @public
 */
-var ConfigDiscovery = class extends Context.Tag("@savvy-web/silk-effects/ConfigDiscovery")() {};
+var ConfigDiscovery = class extends Context.Service()("@savvy-web/silk-effects/ConfigDiscovery") {};
 /**
 * Check whether a path exists, treating any PlatformError as "not found".
 */
@@ -39,8 +38,8 @@ function safeExists(fs, path) {
 * Live implementation of {@link ConfigDiscovery}.
 *
 * @remarks
-* Requires `FileSystem` from `@effect/platform`. Provide `NodeContext.layer` or
-* `BunContext.layer` to satisfy this dependency.
+* Requires the core `FileSystem` service. Provide `NodeServices.layer` (or
+* `NodeFileSystem.layer`) from `@effect/platform-node` to satisfy this dependency.
 *
 * @since 0.1.0
 * @public

package/services/ManagedSection.js

@@ -2,8 +2,7 @@ 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";
+import { Context, Effect, Equal, FileSystem, Function, Layer } from "effect";
 
 //#region src/services/ManagedSection.ts
 function beginMarker(toolName, commentStyle) {
@@ -72,9 +71,9 @@ function findAllSections(content) {
 * @since 0.2.0
 * @public
 */
-var ManagedSection = class extends Context.Tag("@savvy-web/silk-effects/ManagedSection")() {};
+var ManagedSection = class extends Context.Service()("@savvy-web/silk-effects/ManagedSection") {};
 /**
-* Live implementation of {@link ManagedSection} backed by `@effect/platform` FileSystem.
+* Live implementation of {@link ManagedSection} backed by the core `FileSystem` service.
 *
 * @since 0.2.0
 * @public

package/services/SilkPublishability.js

@@ -1,10 +1,9 @@
 import { PublishTargetBindingError } from "../errors/PublishTargetBindingError.js";
 import { trimTrailingSlashes } from "../utils/TrailingSlash.js";
 import { ChangesetConfig } from "./ChangesetConfig.js";
-import { Effect, Layer } from "effect";
+import { Effect, FileSystem, Layer } from "effect";
 import { isAbsolute, join, relative } from "node:path";
-import { FileSystem } from "@effect/platform";
-import { PublishTarget, PublishabilityDetector, PublishabilityDetectorLive, WorkspaceDiscovery } from "workspaces-effect";
+import { PublishTarget, PublishabilityDetector, WorkspaceDiscovery } from "@effected/workspaces";
 
 //#region src/services/SilkPublishability.ts
 const NPM_DEFAULT = "https://registry.npmjs.org/";
@@ -38,7 +37,7 @@ const provenanceForRegistry = (registry) => {
 	return hostname === "registry.npmjs.org" || hostname === "npm.pkg.github.com";
 };
 /**
-* Silk publishability rules over `workspaces-effect`'s `PublishTarget`.
+* Silk publishability rules over `@effected/workspaces`' `PublishTarget`.
 *
 * @remarks
 * In silk mode `private: true` is the norm on workspace `package.json`; publishability is
@@ -133,11 +132,11 @@ var SilkPublishability = class {
 	* Before the prod build runs there is no binding, and the detector's
 	* placeholder directories are left alone.
 	*/
-	static resolveTargets(pkg, root) {
+	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 targets = yield* detector.detect(pkg);
 			const kept = [];
 			for (const t of targets) {
 				const dir = isAbsolute(t.directory) ? t.directory : join(pkg.path, t.directory);
@@ -162,14 +161,14 @@ var SilkPublishability = class {
 	* The publishable, non-ignored packages, resolved through the single
 	* {@link SilkPublishability} (which already honors changeset ignore in adaptive mode).
 	*/
-	static listPublishable(root) {
+	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);
+				const targets = yield* detector.detect(pkg);
 				if (targets.length > 0) out.push({
 					name: pkg.name,
 					version: pkg.version,
@@ -227,7 +226,7 @@ const readTargetsBinding = (fs, pkgPath) => fs.readFileString(join(pkgPath, "dis
 	catch: () => /* @__PURE__ */ new Error("invalid targets.json")
 })), Effect.orElseSucceed(() => null));
 /**
-* Override of `workspaces-effect`'s {@link SilkPublishability} Tag with pure silk rules.
+* Override of `@effected/workspaces`' `PublishabilityDetector` Tag with pure silk rules.
 *
 * @remarks Requires `FileSystem` (captured at layer build); `detect` reads the raw
 * `package.json` from `pkg.packageJsonPath` and applies `SilkPublishability.detect`.
@@ -237,7 +236,7 @@ const readTargetsBinding = (fs, pkgPath) => fs.readFileString(join(pkgPath, "dis
 */
 const SilkPublishabilityDetectorLive = Layer.effect(PublishabilityDetector, Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
-	return { detect: (pkg, _root) => Effect.gen(function* () {
+	return { detect: (pkg) => Effect.gen(function* () {
 		const raw = yield* readRaw(fs, pkg.packageJsonPath);
 		if (!raw) return [];
 		const binding = yield* readTargetsBinding(fs, pkg.path);
@@ -245,11 +244,34 @@ const SilkPublishabilityDetectorLive = Layer.effect(PublishabilityDetector, Effe
 	}) };
 }));
 /**
-* Ignore-aware override of {@link SilkPublishability}. `detect` short-circuits to `[]`
+* The workspace root a package was discovered against, derived from its own
+* coordinates: `relativePath` is the package directory relative to the
+* discovery root (POSIX, `"."` for the root package), so ascending one level
+* per path segment from `pkg.path` lands exactly on that root.
+*
+* @remarks
+* Derivation is deliberate — probing the filesystem for workspace markers
+* (`WorkspaceRoot.find`) can walk PAST the intended root when that root
+* carries no marker (a fixture tree, a bare directory) and land on an
+* enclosing workspace, silently swapping in that outer root's
+* `.changeset/config.json` and dropping the ignore/mode gating (the #209
+* regression class). The discovery root needs no probing: whoever built the
+* `WorkspacePackage` already knew it.
+*/
+const packageRoot = (pkg) => {
+	const segments = pkg.relativePath.split("/").filter((segment) => segment !== "" && segment !== ".");
+	return segments.length === 0 ? pkg.path : join(pkg.path, ...segments.map(() => ".."));
+};
+/**
+* Ignore-aware override of `PublishabilityDetector`. `detect` short-circuits to `[]`
 * for changeset-ignored packages, then dispatches on `ChangesetConfig.mode`:
 * `none` → `[]`; `silk` → `SilkPublishability.detect`; `vanilla` → the library default.
 *
-* @remarks Requires `FileSystem` + {@link ChangesetConfig} at build.
+* @remarks Requires `FileSystem` and {@link ChangesetConfig} at build.
+* The kit's `detect` contract no longer receives the workspace root, so the changeset
+* lookups derive it per package from the package's own discovery coordinates
+* (`pkg.path` ascended by `pkg.relativePath` — never a filesystem marker walk,
+* which could escape an unmarked root and read the wrong `.changeset/config.json`).
 *
 * @since 0.4.0
 * @public
@@ -257,8 +279,9 @@ const SilkPublishabilityDetectorLive = Layer.effect(PublishabilityDetector, Effe
 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* () {
+	const vanilla = yield* Effect.provide(PublishabilityDetector, PublishabilityDetector.layer);
+	return { detect: (pkg) => Effect.gen(function* () {
+		const root = packageRoot(pkg);
 		if (yield* config.isIgnored(pkg.name, root)) return [];
 		const mode = yield* config.mode(root);
 		if (mode === "none") return [];
@@ -268,7 +291,7 @@ const PublishabilityDetectorAdaptiveLive = Layer.effect(PublishabilityDetector,
 			const binding = yield* readTargetsBinding(fs, pkg.path);
 			return SilkPublishability.detect(pkg.name, raw, binding);
 		}
-		return yield* vanilla.detect(pkg, root);
+		return yield* vanilla.detect(pkg);
 	}) };
 }));