@savvy-web/silk-effects 4.2.5 → 5.0.0

package/schemas/ResolvedTool.js

@@ -1,99 +0,0 @@
-import { ToolCommand } from "../utils/ToolCommand.js";
-import { ToolSource } from "./ToolResults.js";
-import { Equal, Hash, Schema } from "effect";
-import { ChildProcess } from "effect/unstable/process";
-
-//#region src/schemas/ResolvedTool.ts
-const PackageManager = Schema.Literals([
-	"npm",
-	"pnpm",
-	"yarn",
-	"bun"
-]);
-/**
-* Result of resolving a {@link ToolDefinition}.
-*
-* Provides `exec` and `dlx` to build commands for the resolved tool.
-*
-* @since 0.2.0
-* @public
-*/
-var ResolvedTool = class ResolvedTool extends Schema.TaggedClass()("ResolvedTool", {
-	name: Schema.String,
-	source: ToolSource,
-	version: Schema.Option(Schema.String),
-	globalVersion: Schema.Option(Schema.String),
-	localVersion: Schema.Option(Schema.String),
-	packageManager: PackageManager,
-	mismatch: Schema.Boolean
-}) {
-	get isGlobal() {
-		return this.source === "global";
-	}
-	get isLocal() {
-		return this.source === "local";
-	}
-	get hasVersionMismatch() {
-		return this.mismatch;
-	}
-	exec(...args) {
-		if (this.source === "global") return new ToolCommand(ChildProcess.make(this.name, args));
-		switch (this.packageManager) {
-			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(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) {
-		if (!(that instanceof ResolvedTool)) return false;
-		return this.name === that.name && this.source === that.source && Equal.equals(this.version, that.version);
-	}
-	[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.optimize(h);
-	}
-};
-
-//#endregion
-export { ResolvedTool };

package/schemas/SectionBlock.js

@@ -1,71 +0,0 @@
-import { CommentStyle } from "./CommentStyle.js";
-import { SectionDiff } from "./SectionResults.js";
-import { Equal, Function, Hash, Schema } from "effect";
-
-//#region src/schemas/SectionBlock.ts
-/**
-* The content between managed section markers.
-*
-* `Equal` compares normalized content only (trimmed, whitespace-collapsed).
-* Use `diff` to compute line-level differences.
-*
-* @since 0.2.0
-* @public
-*/
-var SectionBlock = 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}\n${this.content}\n${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
-		});
-	}
-	[Equal.symbol](that) {
-		if (!(that instanceof SectionBlock)) return false;
-		return this.normalized === that.normalized;
-	}
-	[Hash.symbol]() {
-		return Hash.optimize(Hash.hash(this.normalized));
-	}
-};
-
-//#endregion
-export { SectionBlock };

package/schemas/SectionDefinition.js

@@ -1,123 +0,0 @@
-import { SectionValidationError } from "../errors/SectionValidationError.js";
-import { CommentStyle } from "./CommentStyle.js";
-import { SectionDiff } from "./SectionResults.js";
-import { SectionBlock } from "./SectionBlock.js";
-import { Effect, Equal, Function, Hash, Schema } from "effect";
-
-//#region src/schemas/SectionDefinition.ts
-/**
-* Identity envelope for a managed section type.
-*
-* `Equal` compares on `toolName` + `commentStyle`.
-* Use {@link SectionDefinition.block | block()} to create a {@link SectionBlock},
-* or `generate()` for a typed factory.
-*
-* @since 0.2.0
-* @public
-*/
-var SectionDefinition = class SectionDefinition extends Schema.TaggedClass()("SectionDefinition", {
-	toolName: Schema.String,
-	commentStyle: CommentStyle.pipe(Schema.withDecodingDefaultType(Effect.succeed("#")), Schema.withConstructorDefault(Effect.succeed("#")))
-}) {
-	_validate;
-	static generate = Function.dual(2, (self, fn) => {
-		return (config) => self.block(fn(config));
-	});
-	static generateEffect = Function.dual(2, (self, fn) => {
-		return (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 ---`;
-	}
-	[Equal.symbol](that) {
-		if (!(that instanceof SectionDefinition)) return false;
-		return this.toolName === that.toolName && this.commentStyle === that.commentStyle;
-	}
-	[Hash.symbol]() {
-		return Hash.optimize(Hash.combine(Hash.hash(this.toolName), Hash.hash(this.commentStyle)));
-	}
-};
-/**
-* Convenience section definition for shell hooks.
-*
-* `commentStyle` is always `"#"` — only `toolName` is required.
-*
-* @since 0.2.0
-* @public
-*/
-var ShellSectionDefinition = class 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 ---`;
-	}
-};
-
-//#endregion
-export { SectionDefinition, ShellSectionDefinition };

package/schemas/SectionResults.js

@@ -1,21 +0,0 @@
-import { Data } from "effect";
-
-//#region src/schemas/SectionResults.ts
-/**
-* @since 0.2.0
-* @public
-*/
-const SectionDiff = Data.taggedEnum();
-/**
-* @since 0.2.0
-* @public
-*/
-const SyncResult = Data.taggedEnum();
-/**
-* @since 0.2.0
-* @public
-*/
-const CheckResult = Data.taggedEnum();
-
-//#endregion
-export { CheckResult, SectionDiff, SyncResult };

package/schemas/TagStrategySchemas.js

@@ -1,19 +0,0 @@
-import { Schema } from "effect";
-
-//#region src/schemas/TagStrategySchemas.ts
-/**
-* Git tag naming strategy for a workspace.
-*
-* @remarks
-* - `"single"` — one shared tag for the entire release (e.g. `1.2.3`).
-* - `"scoped"` — a per-package tag that includes the package name (e.g. `@my-org/pkg@1.2.3`).
-*
-* Determined by `TagStrategy.determine` based on the {@link (VersioningStrategyResult:type)}.
-*
-* @since 0.1.0
-* @public
-*/
-const TagStrategyType = Schema.Literals(["single", "scoped"]);
-
-//#endregion
-export { TagStrategyType };

package/schemas/ToolDefinition.js

@@ -1,40 +0,0 @@
-import { ResolutionPolicy, SourceRequirement, VersionExtractor } from "./ToolResults.js";
-import { Equal, Hash, Schema } from "effect";
-
-//#region src/schemas/ToolDefinition.ts
-const NameSchema = Schema.Struct({ name: Schema.String });
-/**
-* Declares a CLI tool's identity and resolution constraints.
-*
-* `Equal` compares on `name` only (identity).
-*
-* @since 0.2.0
-* @public
-*/
-var ToolDefinition = 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());
-	}
-	[Equal.symbol](that) {
-		if (!(that instanceof ToolDefinition)) return false;
-		return this.name === that.name;
-	}
-	[Hash.symbol]() {
-		return Hash.optimize(Hash.hash(this.name));
-	}
-};
-
-//#endregion
-export { ToolDefinition };

package/schemas/ToolResults.js

@@ -1,28 +0,0 @@
-import { Data, Schema } from "effect";
-
-//#region src/schemas/ToolResults.ts
-/**
-* Where a tool was resolved from.
-*
-* @since 0.2.0
-* @public
-*/
-const ToolSource = Schema.Literals(["global", "local"]);
-/**
-* @since 0.2.0
-* @public
-*/
-const VersionExtractor = Data.taggedEnum();
-/**
-* @since 0.2.0
-* @public
-*/
-const ResolutionPolicy = Data.taggedEnum();
-/**
-* @since 0.2.0
-* @public
-*/
-const SourceRequirement = Data.taggedEnum();
-
-//#endregion
-export { ResolutionPolicy, SourceRequirement, ToolSource, VersionExtractor };

package/services/ManagedSection.js

@@ -1,289 +0,0 @@
-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, FileSystem, Function, Layer } from "effect";
-
-//#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
-* @public
-*/
-var ManagedSection = class extends Context.Service()("@savvy-web/silk-effects/ManagedSection") {};
-/**
-* Live implementation of {@link ManagedSection} backed by the core `FileSystem` service.
-*
-* @since 0.2.0
-* @public
-*/
-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 };