@savvy-web/silk-effects 0.1.0 → 0.2.1

package/index.js

@@ -1,6 +1,1020 @@
-export { BiomeSchemaSync, BiomeSchemaSyncLive, BiomeSyncError } from "./biome.js";
-export { ChangesetConfigError, ChangesetConfigReader, ChangesetConfigReaderLive, VersioningDetectionError, VersioningStrategy, VersioningStrategyLive } from "./versioning.js";
-export { ConfigDiscovery, ConfigDiscoveryLive, ConfigNotFoundError } from "./config.js";
-export { ManagedSection, ManagedSectionLive, ManagedSectionParseError, ManagedSectionWriteError } from "./hooks.js";
-export { PublishConfigError, SilkPublishabilityPlugin, SilkPublishabilityPluginLive, TargetResolutionError, TargetResolver, TargetResolverLive } from "./publish.js";
-export { TagFormatError, TagStrategy, TagStrategyLive } from "./tags.js";
+import { Context, Data, Effect, Equal, Function, Hash, Layer, Option, Ref, Schema } from "effect";
+import { Command, CommandExecutor, FileSystem } from "@effect/platform";
+import { parse } from "jsonc-effect";
+import { PackageManagerDetector, WorkspaceRoot } from "workspaces-effect";
+class BiomeSyncError extends Data.TaggedError("BiomeSyncError") {
+    get message() {
+        return `Failed to sync biome schema in ${this.path}: ${this.reason}`;
+    }
+}
+class ChangesetConfigError extends Data.TaggedError("ChangesetConfigError") {
+    get message() {
+        return `Failed to read changeset config at ${this.path}: ${this.reason}`;
+    }
+}
+class ConfigNotFoundError extends Data.TaggedError("ConfigNotFoundError") {
+    get message() {
+        return `Config '${this.name}' not found. Searched: ${this.searchedPaths.join(", ")}`;
+    }
+}
+class PublishConfigError extends Data.TaggedError("PublishConfigError") {
+    get message() {
+        return `Invalid publishConfig for ${this.packageName}: ${this.reason}`;
+    }
+}
+class SectionParseError extends Data.TaggedError("SectionParseError") {
+    get message() {
+        return `Failed to parse section in ${this.path}: ${this.reason}`;
+    }
+}
+class SectionValidationError extends Data.TaggedError("SectionValidationError") {
+    get message() {
+        return `Section validation failed for ${this.toolName}: ${this.reason}`;
+    }
+}
+class SectionWriteError extends Data.TaggedError("SectionWriteError") {
+    get message() {
+        return `Failed to write section to ${this.path}: ${this.reason}`;
+    }
+}
+class TagFormatError extends Data.TaggedError("TagFormatError") {
+    get message() {
+        return `Failed to format tag for ${this.name}@${this.version}: ${this.reason}`;
+    }
+}
+class TargetResolutionError extends Data.TaggedError("TargetResolutionError") {
+    get message() {
+        return `Failed to resolve publish target: ${this.reason}`;
+    }
+}
+class ToolNotFoundError extends Data.TaggedError("ToolNotFoundError") {
+    get message() {
+        return `Tool not found: ${this.name} — ${this.reason}`;
+    }
+}
+class ToolResolutionError extends Data.TaggedError("ToolResolutionError") {
+    get message() {
+        return `Tool resolution failed: ${this.name} — ${this.reason}`;
+    }
+}
+class ToolVersionMismatchError extends Data.TaggedError("ToolVersionMismatchError") {
+    get message() {
+        return `Tool version mismatch: ${this.name} — global ${this.globalVersion} vs local ${this.localVersion}`;
+    }
+}
+class VersioningDetectionError extends Data.TaggedError("VersioningDetectionError") {
+    get message() {
+        return `Failed to detect versioning strategy: ${this.reason}`;
+    }
+}
+const PublishProtocol = Schema.Literal("npm", "jsr");
+const AuthStrategy = Schema.Literal("oidc", "token");
+const PublishTargetObject = Schema.Struct({
+    protocol: Schema.optionalWith(PublishProtocol, {
+        default: ()=>"npm"
+    }),
+    registry: Schema.optional(Schema.String),
+    directory: Schema.optional(Schema.String),
+    access: Schema.optional(Schema.Literal("public", "restricted")),
+    provenance: Schema.optional(Schema.Boolean),
+    tag: Schema.optional(Schema.String)
+});
+const PublishTargetShorthand = Schema.Literal("npm", "github", "jsr");
+const PublishTarget = Schema.Union(PublishTargetShorthand, Schema.String.pipe(Schema.filter((s)=>s.startsWith("https://"))), PublishTargetObject);
+const ResolvedTarget = Schema.Struct({
+    protocol: PublishProtocol,
+    registry: Schema.NullOr(Schema.String),
+    directory: Schema.String,
+    access: Schema.Literal("public", "restricted"),
+    provenance: Schema.Boolean,
+    tag: Schema.String,
+    auth: AuthStrategy,
+    tokenEnv: Schema.NullOr(Schema.String)
+});
+class ToolCommand {
+    command;
+    constructor(command){
+        this.command = command;
+    }
+    string(encoding) {
+        return Command.string(this.command, encoding);
+    }
+    exitCode() {
+        return Command.exitCode(this.command);
+    }
+    lines(encoding) {
+        return Command.lines(this.command, encoding);
+    }
+    stream() {
+        return Command.stream(this.command);
+    }
+    env(environment) {
+        return new ToolCommand(Command.env(this.command, environment));
+    }
+    workingDirectory(cwd) {
+        return new ToolCommand(Command.workingDirectory(this.command, cwd));
+    }
+    stdin(input) {
+        return new ToolCommand(Command.feed(this.command, input));
+    }
+}
+const ToolSource = Schema.Literal("global", "local");
+const VersionExtractor = Data.taggedEnum();
+const ResolutionPolicy = Data.taggedEnum();
+const SourceRequirement = Data.taggedEnum();
+var _computedKey, _computedKey1;
+const PackageManager = Schema.Literal("npm", "pnpm", "yarn", "bun");
+_computedKey = Equal.symbol, _computedKey1 = Hash.symbol;
+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),
+    packageManager: PackageManager,
+    mismatch: Schema.Boolean
+}) {
+    get isGlobal() {
+        return "global" === this.source;
+    }
+    get isLocal() {
+        return "local" === this.source;
+    }
+    get hasVersionMismatch() {
+        return this.mismatch;
+    }
+    exec(...args) {
+        if ("global" === this.source) return new ToolCommand(Command.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));
+        }
+    }
+    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));
+        }
+    }
+    [_computedKey](that) {
+        if (!(that instanceof ResolvedTool)) return false;
+        return this.name === that.name && this.source === that.source && Equal.equals(this.version, that.version);
+    }
+    [_computedKey1]() {
+        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);
+    }
+}
+const CommentStyle = Schema.Literal("#", "//");
+const SectionDiff = Data.taggedEnum();
+const SyncResult = Data.taggedEnum();
+const CheckResult = Data.taggedEnum();
+var SectionBlock_computedKey, SectionBlock_computedKey1;
+SectionBlock_computedKey = Equal.symbol, SectionBlock_computedKey1 = Hash.symbol;
+class SectionBlock extends Schema.TaggedClass()("SectionBlock", {
+    toolName: Schema.String,
+    commentStyle: CommentStyle,
+    content: Schema.String
+}) {
+    static diff = Function.dual(2, (self, that)=>self.diff(that));
+    static prepend = Function.dual(2, (self, lines)=>self.prepend(lines));
+    static append = Function.dual(2, (self, lines)=>self.append(lines));
+    get text() {
+        return this.content;
+    }
+    get normalized() {
+        return this.content.trim().replace(/\s+/g, " ");
+    }
+    get rendered() {
+        const begin = `${this.commentStyle} --- BEGIN ${this.toolName.toUpperCase()} MANAGED SECTION ---`;
+        const end = `${this.commentStyle} --- END ${this.toolName.toUpperCase()} MANAGED SECTION ---`;
+        return `${begin}${this.content}${end}`;
+    }
+    prepend(lines) {
+        return SectionBlock.make({
+            toolName: this.toolName,
+            commentStyle: this.commentStyle,
+            content: `${lines}\n${this.content}`
+        });
+    }
+    append(lines) {
+        return SectionBlock.make({
+            toolName: this.toolName,
+            commentStyle: this.commentStyle,
+            content: `${this.content}\n${lines}`
+        });
+    }
+    diff(that) {
+        if (this.normalized === that.normalized) return SectionDiff.Unchanged();
+        const selfLines = this.content.trim().split("\n");
+        const thatLines = that.content.trim().split("\n");
+        const selfSet = new Set(selfLines);
+        const thatSet = new Set(thatLines);
+        const removed = selfLines.filter((line)=>!thatSet.has(line));
+        const added = thatLines.filter((line)=>!selfSet.has(line));
+        return SectionDiff.Changed({
+            added,
+            removed
+        });
+    }
+    [SectionBlock_computedKey](that) {
+        if (!(that instanceof SectionBlock)) return false;
+        return this.normalized === that.normalized;
+    }
+    [SectionBlock_computedKey1]() {
+        return Hash.cached(this)(Hash.hash(this.normalized));
+    }
+}
+var SectionDefinition_computedKey, SectionDefinition_computedKey1;
+SectionDefinition_computedKey = Equal.symbol, SectionDefinition_computedKey1 = Hash.symbol;
+class SectionDefinition extends Schema.TaggedClass()("SectionDefinition", {
+    toolName: Schema.String,
+    commentStyle: Schema.optionalWith(CommentStyle, {
+        default: ()=>"#"
+    })
+}) {
+    _validate;
+    static generate = Function.dual(2, (self, fn)=>(config)=>self.block(fn(config)));
+    static generateEffect = Function.dual(2, (self, fn)=>(config)=>Effect.flatMap(fn(config), (content)=>{
+                try {
+                    return Effect.succeed(self.block(content));
+                } catch (e) {
+                    return Effect.fail(e);
+                }
+            }));
+    static withValidation = Function.dual(2, (self, fn)=>{
+        const copy = SectionDefinition.make({
+            toolName: self.toolName,
+            commentStyle: self.commentStyle
+        });
+        copy._validate = fn;
+        return copy;
+    });
+    static diff = Function.dual(2, (self, that)=>self.diff(that));
+    block(content) {
+        const block = SectionBlock.make({
+            toolName: this.toolName,
+            commentStyle: this.commentStyle,
+            content
+        });
+        if (this._validate && !this._validate(block)) throw new SectionValidationError({
+            toolName: this.toolName,
+            reason: "Content failed validation"
+        });
+        return block;
+    }
+    generate(fn) {
+        return (config)=>this.block(fn(config));
+    }
+    generateEffect(fn) {
+        return (config)=>Effect.flatMap(fn(config), (content)=>{
+                try {
+                    return Effect.succeed(this.block(content));
+                } catch (e) {
+                    return Effect.fail(e);
+                }
+            });
+    }
+    diff(that) {
+        if (Equal.equals(this, that)) return SectionDiff.Unchanged();
+        return SectionDiff.Changed({
+            added: [
+                that.toolName !== this.toolName ? `toolName: ${that.toolName}` : "",
+                that.commentStyle !== this.commentStyle ? `commentStyle: ${that.commentStyle}` : ""
+            ].filter(Boolean),
+            removed: [
+                that.toolName !== this.toolName ? `toolName: ${this.toolName}` : "",
+                that.commentStyle !== this.commentStyle ? `commentStyle: ${this.commentStyle}` : ""
+            ].filter(Boolean)
+        });
+    }
+    get beginMarker() {
+        return `${this.commentStyle} --- BEGIN ${this.toolName.toUpperCase()} MANAGED SECTION ---`;
+    }
+    get endMarker() {
+        return `${this.commentStyle} --- END ${this.toolName.toUpperCase()} MANAGED SECTION ---`;
+    }
+    [SectionDefinition_computedKey](that) {
+        if (!(that instanceof SectionDefinition)) return false;
+        return this.toolName === that.toolName && this.commentStyle === that.commentStyle;
+    }
+    [SectionDefinition_computedKey1]() {
+        return Hash.cached(this)(Hash.combine(Hash.hash(this.toolName))(Hash.hash(this.commentStyle)));
+    }
+}
+class ShellSectionDefinition extends Schema.TaggedClass()("ShellSectionDefinition", {
+    toolName: Schema.String
+}) {
+    get commentStyle() {
+        return "#";
+    }
+    block(content) {
+        return SectionBlock.make({
+            toolName: this.toolName,
+            commentStyle: "#",
+            content
+        });
+    }
+    generate(fn) {
+        return (config)=>this.block(fn(config));
+    }
+    generateEffect(fn) {
+        return (config)=>Effect.map(fn(config), (content)=>this.block(content));
+    }
+    get beginMarker() {
+        return `# --- BEGIN ${this.toolName.toUpperCase()} MANAGED SECTION ---`;
+    }
+    get endMarker() {
+        return `# --- END ${this.toolName.toUpperCase()} MANAGED SECTION ---`;
+    }
+}
+var ToolDefinition_computedKey, ToolDefinition_computedKey1;
+const NameSchema = Schema.Struct({
+    name: Schema.String
+});
+ToolDefinition_computedKey = Equal.symbol, ToolDefinition_computedKey1 = Hash.symbol;
+class ToolDefinition {
+    _tag = "ToolDefinition";
+    name;
+    versionExtractor;
+    policy;
+    source;
+    constructor(name, versionExtractor, policy, source){
+        this.name = name;
+        this.versionExtractor = versionExtractor;
+        this.policy = policy;
+        this.source = source;
+    }
+    static make(options) {
+        Schema.decodeUnknownSync(NameSchema)({
+            name: options.name
+        });
+        return new ToolDefinition(options.name, options.versionExtractor ?? VersionExtractor.Flag({
+            flag: "--version"
+        }), options.policy ?? ResolutionPolicy.Report(), options.source ?? SourceRequirement.Any());
+    }
+    [ToolDefinition_computedKey](that) {
+        if (!(that instanceof ToolDefinition)) return false;
+        return this.name === that.name;
+    }
+    [ToolDefinition_computedKey1]() {
+        return Hash.cached(this)(Hash.hash(this.name));
+    }
+}
+function extractSemver(version) {
+    return version.replace(/^[\^~>=<v]+/, "");
+}
+function buildSchemaUrl(version) {
+    return `https://biomejs.dev/schemas/${version}/schema.json`;
+}
+const BIOME_SCHEMA_HOSTNAME = "biomejs.dev";
+function findBiomeConfigs(cwd, fs) {
+    const candidates = [
+        `${cwd}/biome.json`,
+        `${cwd}/biome.jsonc`
+    ];
+    return Effect.gen(function*() {
+        const results = [];
+        for (const candidate of candidates){
+            const exists = yield* fs.exists(candidate).pipe(Effect.orElseSucceed(()=>false));
+            if (exists) results.push(candidate);
+        }
+        return results;
+    });
+}
+class BiomeSchemaSync extends Context.Tag("@savvy-web/silk-effects/BiomeSchemaSync")() {
+}
+const BiomeSchemaSyncLive = Layer.effect(BiomeSchemaSync, Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
+    const run = (version, options, write)=>Effect.gen(function*() {
+            const cwd = options?.cwd ?? process.cwd();
+            const semver = extractSemver(version);
+            const expectedUrl = buildSchemaUrl(semver);
+            const configs = yield* findBiomeConfigs(cwd, fs);
+            const updated = [];
+            const skipped = [];
+            const current = [];
+            for (const configPath of configs){
+                const raw = yield* fs.readFileString(configPath).pipe(Effect.mapError((cause)=>new BiomeSyncError({
+                        path: configPath,
+                        reason: String(cause)
+                    })));
+                const parsed = yield* parse(raw).pipe(Effect.mapError((e)=>new BiomeSyncError({
+                        path: configPath,
+                        reason: `Failed to parse JSONC: ${String(e)}`
+                    })));
+                const schema = parsed.$schema;
+                if ("string" != typeof schema) {
+                    skipped.push(configPath);
+                    continue;
+                }
+                if (!schema.includes(BIOME_SCHEMA_HOSTNAME)) {
+                    skipped.push(configPath);
+                    continue;
+                }
+                if (schema === expectedUrl) {
+                    current.push(configPath);
+                    continue;
+                }
+                if (write) {
+                    const updated_content = raw.replaceAll(schema, expectedUrl);
+                    yield* fs.writeFileString(configPath, updated_content).pipe(Effect.mapError((cause)=>new BiomeSyncError({
+                            path: configPath,
+                            reason: String(cause)
+                        })));
+                }
+                updated.push(configPath);
+            }
+            return {
+                updated,
+                skipped,
+                current
+            };
+        });
+    return {
+        sync: (version, options)=>run(version, options, true),
+        check: (version, options)=>run(version, options, false)
+    };
+}));
+const ChangesetConfig = Schema.Struct({
+    changelog: Schema.optional(Schema.Union(Schema.String, Schema.Array(Schema.Unknown))),
+    commit: Schema.optional(Schema.Boolean),
+    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")),
+    baseBranch: Schema.optional(Schema.String),
+    updateInternalDependencies: Schema.optional(Schema.Literal("patch", "minor", "major")),
+    ignore: Schema.optional(Schema.Array(Schema.String))
+});
+const SilkChangesetConfig = Schema.extend(ChangesetConfig, Schema.Struct({
+    _isSilk: Schema.optionalWith(Schema.Boolean, {
+        default: ()=>true
+    })
+}));
+const VersioningStrategyType = Schema.Literal("single", "fixed-group", "independent");
+Schema.Struct({
+    type: VersioningStrategyType,
+    fixedGroups: Schema.Array(Schema.Array(Schema.String)),
+    publishablePackages: Schema.Array(Schema.String)
+});
+const SILK_CHANGELOG_MARKER = "@savvy-web/changesets";
+function isSilkChangelog(changelog) {
+    if ("string" == typeof changelog) return changelog.includes(SILK_CHANGELOG_MARKER);
+    if (Array.isArray(changelog) && changelog.length > 0) return "string" == typeof changelog[0] && changelog[0].includes(SILK_CHANGELOG_MARKER);
+    return false;
+}
+class ChangesetConfigReader extends Context.Tag("@savvy-web/silk-effects/ChangesetConfigReader")() {
+}
+const ChangesetConfigReaderLive = Layer.effect(ChangesetConfigReader, Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
+    const read = (root)=>{
+        const configPath = `${root}/.changeset/config.json`;
+        return Effect.gen(function*() {
+            const exists = yield* fs.exists(configPath).pipe(Effect.mapError((cause)=>new ChangesetConfigError({
+                    path: configPath,
+                    reason: String(cause)
+                })));
+            if (!exists) return yield* Effect.fail(new ChangesetConfigError({
+                path: configPath,
+                reason: "File not found"
+            }));
+            const raw = yield* fs.readFileString(configPath).pipe(Effect.mapError((cause)=>new ChangesetConfigError({
+                    path: configPath,
+                    reason: String(cause)
+                })));
+            const parsed = yield* Effect["try"]({
+                try: ()=>JSON.parse(raw),
+                catch: (cause)=>new ChangesetConfigError({
+                        path: configPath,
+                        reason: `Invalid JSON: ${String(cause)}`
+                    })
+            });
+            const rawConfig = parsed;
+            if (isSilkChangelog(rawConfig.changelog)) return yield* Schema.decodeUnknown(SilkChangesetConfig)(parsed).pipe(Effect.mapError((cause)=>new ChangesetConfigError({
+                    path: configPath,
+                    reason: `Schema decode failed: ${String(cause)}`
+                })));
+            return yield* Schema.decodeUnknown(ChangesetConfig)(parsed).pipe(Effect.mapError((cause)=>new ChangesetConfigError({
+                    path: configPath,
+                    reason: `Schema decode failed: ${String(cause)}`
+                })));
+        });
+    };
+    return {
+        read
+    };
+}));
+class ConfigDiscovery extends Context.Tag("@savvy-web/silk-effects/ConfigDiscovery")() {
+}
+function safeExists(fs, path) {
+    return fs.exists(path).pipe(Effect.orElseSucceed(()=>false));
+}
+const ConfigDiscoveryLive = Layer.effect(ConfigDiscovery, Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
+    const findAll = (name, options)=>Effect.gen(function*() {
+            const cwd = options?.cwd ?? process.cwd();
+            const results = [];
+            const libPath = `${cwd}/lib/configs/${name}`;
+            const libExists = yield* safeExists(fs, libPath);
+            if (libExists) results.push({
+                path: libPath,
+                source: "lib"
+            });
+            const rootPath = `${cwd}/${name}`;
+            const rootExists = yield* safeExists(fs, rootPath);
+            if (rootExists) results.push({
+                path: rootPath,
+                source: "root"
+            });
+            return results;
+        });
+    const find = (name, options)=>findAll(name, options).pipe(Effect.map((results)=>results[0] ?? null));
+    return {
+        find,
+        findAll
+    };
+}));
+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 (-1 === beginIndex || -1 === endIndex || endIndex <= beginIndex) return null;
+    return {
+        before: content.slice(0, beginIndex),
+        managed: content.slice(beginIndex + begin.length, endIndex),
+        after: content.slice(endIndex + end.length)
+    };
+}
+function assembleContent(before, managed, after, toolName, commentStyle) {
+    const begin = beginMarker(toolName, commentStyle);
+    const end = endMarker(toolName, commentStyle);
+    return `${before}${begin}${managed}${end}${after}`;
+}
+class ManagedSection extends Context.Tag("@savvy-web/silk-effects/ManagedSection")() {
+}
+const ManagedSectionLive = Layer.effect(ManagedSection, Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
+    const read = Function.dual(2, (path, definition)=>Effect.gen(function*() {
+            const exists = yield* fs.exists(path).pipe(Effect.orElseSucceed(()=>false));
+            if (!exists) return null;
+            const raw = yield* fs.readFileString(path).pipe(Effect.mapError((cause)=>new SectionParseError({
+                    path,
+                    reason: String(cause)
+                })));
+            const parsed = parseContent(raw, definition.toolName, definition.commentStyle);
+            if (null === parsed) return null;
+            return SectionBlock.make({
+                toolName: definition.toolName,
+                commentStyle: definition.commentStyle,
+                content: parsed.managed
+            });
+        }));
+    const isManaged = Function.dual(2, (path, definition)=>Effect.gen(function*() {
+            const exists = yield* fs.exists(path).pipe(Effect.orElseSucceed(()=>false));
+            if (!exists) 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 -1 !== beginIdx && -1 !== endIdx && 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 (null !== parsed) 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}${block.content}${end}\n`;
+                }
+            } else {
+                const begin = beginMarker(block.toolName, block.commentStyle);
+                const end = endMarker(block.toolName, block.commentStyle);
+                fileContent = `${begin}${block.content}${end}\n`;
+            }
+            yield* fs.writeFileString(path, fileContent).pipe(Effect.mapError((cause)=>new SectionWriteError({
+                    path,
+                    reason: String(cause)
+                })));
+        }));
+    const 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 (null === onDisk) {
+                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
+            });
+        }));
+    const check = Function.dual(2, (path, block)=>Effect.gen(function*() {
+            const onDisk = yield* read(path, {
+                toolName: block.toolName,
+                commentStyle: block.commentStyle
+            });
+            if (null === onDisk) return CheckResult.NotFound();
+            const isUpToDate = Equal.equals(onDisk, block);
+            const d = SectionBlock.diff(onDisk, block);
+            return CheckResult.Found({
+                isUpToDate,
+                diff: d
+            });
+        }));
+    return {
+        read,
+        write,
+        isManaged,
+        sync,
+        check
+    };
+}));
+class TargetResolver extends Context.Tag("@savvy-web/silk-effects/TargetResolver")() {
+}
+const DEFAULTS = {
+    directory: "dist/npm",
+    access: "public",
+    provenance: false,
+    tag: "latest"
+};
+function deriveTokenEnv(registryUrl) {
+    try {
+        const hostname = new URL(registryUrl).hostname;
+        return `NPM_TOKEN_${hostname.replace(/\./g, "_").toUpperCase()}`;
+    } catch  {
+        return "NPM_TOKEN";
+    }
+}
+function resolveOne(target) {
+    if ("npm" === target) return Effect.succeed({
+        ...DEFAULTS,
+        protocol: "npm",
+        registry: "https://registry.npmjs.org/",
+        auth: "oidc",
+        tokenEnv: null
+    });
+    if ("github" === target) return Effect.succeed({
+        ...DEFAULTS,
+        protocol: "npm",
+        registry: "https://npm.pkg.github.com/",
+        auth: "token",
+        tokenEnv: "GITHUB_TOKEN"
+    });
+    if ("jsr" === target) return Effect.succeed({
+        ...DEFAULTS,
+        protocol: "jsr",
+        registry: null,
+        auth: "oidc",
+        tokenEnv: null
+    });
+    if ("string" == typeof target && target.startsWith("https://")) return Effect.succeed({
+        ...DEFAULTS,
+        protocol: "npm",
+        registry: target,
+        auth: "token",
+        tokenEnv: deriveTokenEnv(target)
+    });
+    if ("object" == typeof target && null !== target && !Array.isArray(target)) {
+        const obj = target;
+        const protocol = obj.protocol ?? "npm";
+        const registry = obj.registry ?? null;
+        const directory = obj.directory ?? DEFAULTS.directory;
+        const access = obj.access ?? DEFAULTS.access;
+        const provenance = obj.provenance ?? DEFAULTS.provenance;
+        const tag = obj.tag ?? DEFAULTS.tag;
+        let auth;
+        let tokenEnv;
+        if (null !== registry) try {
+            const hostname = new URL(registry).hostname;
+            if ("npm.pkg.github.com" === hostname) {
+                auth = "token";
+                tokenEnv = "GITHUB_TOKEN";
+            } else {
+                auth = "oidc";
+                tokenEnv = null;
+            }
+        } catch  {
+            auth = "oidc";
+            tokenEnv = null;
+        }
+        else {
+            auth = "oidc";
+            tokenEnv = null;
+        }
+        return Effect.succeed({
+            protocol,
+            registry,
+            directory,
+            access,
+            provenance,
+            tag,
+            auth,
+            tokenEnv
+        });
+    }
+    return Effect.fail(new TargetResolutionError({
+        target,
+        reason: `Unsupported target type: ${typeof target}. Expected "npm", "github", "jsr", an https:// URL, or an object.`
+    }));
+}
+const TargetResolverLive = Layer.succeed(TargetResolver, {
+    resolve: (target)=>{
+        if (Array.isArray(target)) return Effect.all(target.map(resolveOne));
+        return resolveOne(target).pipe(Effect.map((resolved)=>[
+                resolved
+            ]));
+    }
+});
+class SilkPublishabilityPlugin extends Context.Tag("@savvy-web/silk-effects/SilkPublishabilityPlugin")() {
+}
+const SilkPublishabilityPluginLive = Layer.effect(SilkPublishabilityPlugin, Effect.gen(function*() {
+    const resolver = yield* TargetResolver;
+    return {
+        detect: (pkgJson)=>{
+            const isPrivate = true === pkgJson.private;
+            const publishConfig = pkgJson.publishConfig;
+            if (isPrivate && !publishConfig) return Effect.succeed([]);
+            if (!publishConfig || !publishConfig.access && !publishConfig.targets) return Effect.succeed([]);
+            if (Array.isArray(publishConfig.targets)) return resolver.resolve(publishConfig.targets);
+            if (publishConfig.registry) return resolver.resolve(publishConfig.registry);
+            return resolver.resolve("npm");
+        }
+    };
+}));
+class TagStrategy extends Context.Tag("@savvy-web/silk-effects/TagStrategy")() {
+}
+const TagStrategyLive = Layer.succeed(TagStrategy, TagStrategy.of({
+    determine: (versioningResult)=>{
+        if ("independent" === versioningResult.type) 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 ("single" === strategy) return Effect.succeed(version);
+        name.startsWith("@");
+        return Effect.succeed(`${name}@${version}`);
+    }
+}));
+class ToolDiscovery extends Context.Tag("@savvy-web/silk-effects/ToolDiscovery")() {
+}
+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
+            ];
+    }
+}
+function tryString(cmd) {
+    return Command.string(cmd).pipe(Effect.map((s)=>Option.some(s.trim())), Effect.catchAll(()=>Effect.succeed(Option.none())));
+}
+function tryExists(cmd) {
+    return Command.exitCode(cmd).pipe(Effect.map((code)=>0 === code), Effect.catchAll(()=>Effect.succeed(false)));
+}
+function extractVersion(output, extractor) {
+    if ("None" === extractor._tag || Option.isNone(output)) return Option.none();
+    const raw = output.value;
+    if ("Flag" === extractor._tag) {
+        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 (null == current || "object" != typeof current) return Option.none();
+            current = current[part];
+        }
+        return "string" == typeof current ? Option.some(current) : Option.none();
+    } catch  {
+        return Option.none();
+    }
+}
+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(new Map());
+    const resolve = (definition)=>Effect.gen(function*() {
+            const cached = yield* Ref.get(cache);
+            const hit = cached.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 pm = yield* pmDetector.detect(root).pipe(Effect.catchAll(()=>Effect.fail(new ToolResolutionError({
+                    name: definition.name,
+                    reason: "Could not detect package manager"
+                }))));
+            const pmType = pm.type;
+            const globalExists = yield* Effect.provideService(tryExists(Command.make("sh", "-c", `command -v ${definition.name}`)), CommandExecutor.CommandExecutor, executor);
+            let globalVersion = Option.none();
+            if (globalExists && "None" !== definition.versionExtractor._tag) {
+                const flag = definition.versionExtractor.flag;
+                const globalOutput = yield* Effect.provideService(tryString(Command.make(definition.name, flag)), CommandExecutor.CommandExecutor, executor);
+                globalVersion = extractVersion(globalOutput, definition.versionExtractor);
+            }
+            let localExists = false;
+            let localVersion = Option.none();
+            const [pmBin, ...pmArgs] = pmExecArgs(pmType, definition.name);
+            if ("None" !== definition.versionExtractor._tag) {
+                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*() {
+            const globalFound = yield* Effect.provideService(tryExists(Command.make("sh", "-c", `command -v ${definition.name}`)), CommandExecutor.CommandExecutor, executor);
+            if (globalFound) 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 = "None" !== definition.versionExtractor._tag ? definition.versionExtractor.flag : "--version";
+            const [pmBin, ...pmArgs] = pmExecArgs(pmType, definition.name);
+            return yield* Effect.provideService(tryExists(Command.make(pmBin, ...pmArgs, probeFlag)), CommandExecutor.CommandExecutor, executor);
+        });
+    const clearCache = Ref.set(cache, new Map());
+    return {
+        resolve,
+        require: require_,
+        isAvailable,
+        clearCache
+    };
+}));
+class VersioningStrategy extends Context.Tag("@savvy-web/silk-effects/VersioningStrategy")() {
+}
+const VersioningStrategyLive = Layer.effect(VersioningStrategy, Effect.gen(function*() {
+    const configReader = yield* ChangesetConfigReader;
+    const detect = (publishablePackages, root)=>Effect.gen(function*() {
+            const config = yield* configReader.read(root).pipe(Effect.orElseSucceed(()=>({
+                    fixed: [],
+                    linked: []
+                })));
+            const fixed = config.fixed ?? [];
+            const packages = [
+                ...publishablePackages
+            ];
+            if (packages.length <= 1) return {
+                type: "single",
+                fixedGroups: fixed,
+                publishablePackages: packages
+            };
+            const containingGroup = fixed.find((group)=>packages.every((pkg)=>group.includes(pkg)));
+            if (void 0 !== containingGroup) return {
+                type: "fixed-group",
+                fixedGroups: fixed,
+                publishablePackages: packages
+            };
+            return {
+                type: "independent",
+                fixedGroups: fixed,
+                publishablePackages: packages
+            };
+        });
+    return {
+        detect
+    };
+}));
+export { BiomeSchemaSync, BiomeSchemaSyncLive, BiomeSyncError, ChangesetConfigError, ChangesetConfigReader, ChangesetConfigReaderLive, CheckResult, ConfigDiscovery, ConfigDiscoveryLive, ConfigNotFoundError, ManagedSection, ManagedSectionLive, PublishConfigError, PublishTarget as PublishTargetSchema, PublishTargetShorthand as PublishTargetShorthandSchema, ResolutionPolicy, ResolvedTarget as ResolvedTargetSchema, ResolvedTool, SectionBlock, SectionDefinition, SectionDiff, SectionParseError, SectionValidationError, SectionWriteError, ShellSectionDefinition, SilkPublishabilityPlugin, SilkPublishabilityPluginLive, SourceRequirement, SyncResult, TagFormatError, TagStrategy, TagStrategyLive, TargetResolutionError, TargetResolver, TargetResolverLive, ToolCommand, ToolDefinition, ToolDiscovery, ToolDiscoveryLive, ToolNotFoundError, ToolResolutionError, ToolSource, ToolVersionMismatchError, VersionExtractor, VersioningDetectionError, VersioningStrategy, VersioningStrategyLive, buildSchemaUrl, extractSemver };