@okfit/cli 0.2.0 → 0.4.0

package/sync/log.js

@@ -1,127 +0,0 @@
-import { writeAtomic } from "./write.js";
-import { DateTime, Effect, FileSystem, Path } from "effect";
-import { Derive } from "@okfit/core";
-
-//#region src/sync/log.ts
-const byTitle = (a, b) => a.title < b.title ? -1 : a.title > b.title ? 1 : 0;
-const renderItem = (item) => item.added ? `Added ${item.title}` : `Updated ${item.title}`;
-/**
-* S-10: takes STRUCTURED additions (`{date, title, added}`), not
-* pre-rendered strings -- this is the corrected shape of CP §2's own
-* proposal (contract §14 note 4): rendering "Added <title>"/
-* "Updated <title>" happens INSIDE `mergeLog`, so "sort by title" (design
-* §5 step 4) sorts the actual title field, never a substring of a
-* pre-rendered line. Renders a NEW group's items via
-* `Derive.renderLogEntry` (S-11's per-group renderer); an EXISTING
-* group's text (heading and items) is re-emitted verbatim by slicing
-* `existing.source` on the group's own `LogGroup.range` -- never
-* re-serialised, so a hand-written item, comment, or unusual formatting
-* inside an existing group survives byte-for-byte.
-*
-* @internal
-*/
-const mergeLog = (existing, additions) => {
-	const title = existing?.doc.title ?? "Log";
-	const byDate = /* @__PURE__ */ new Map();
-	if (existing !== void 0) for (const group of existing.doc.groups) {
-		const verbatim = existing.source.slice(group.range.offset, group.range.offset + group.range.length);
-		byDate.set(group.date, {
-			verbatim,
-			pending: []
-		});
-	}
-	for (const addition of additions) {
-		const bucket = byDate.get(addition.date) ?? {
-			verbatim: void 0,
-			pending: []
-		};
-		bucket.pending.push({
-			title: addition.title,
-			added: addition.added
-		});
-		byDate.set(addition.date, bucket);
-	}
-	const dates = [...byDate.keys()].sort((a, b) => a < b ? 1 : a > b ? -1 : 0);
-	const pieces = dates.map((date, index) => {
-		const bucket = byDate.get(date);
-		let piece;
-		if (bucket === void 0) piece = "";
-		else if (bucket.verbatim === void 0) {
-			const items = [...bucket.pending].sort(byTitle).map(renderItem);
-			piece = Derive.renderLogEntry({
-				date,
-				items
-			});
-		} else if (bucket.pending.length === 0) piece = bucket.verbatim;
-		else {
-			const trailingNewlines = /\n+$/.exec(bucket.verbatim)?.[0] ?? "";
-			const base = bucket.verbatim.slice(0, bucket.verbatim.length - trailingNewlines.length);
-			const trailer = trailingNewlines.slice(1);
-			piece = `${base}\n${[...bucket.pending].sort(byTitle).map((item) => `* ${renderItem(item)}\n`).join("")}${trailer}`;
-		}
-		return !(index === dates.length - 1) && !piece.endsWith("\n\n") ? `${piece}\n` : piece;
-	});
-	return dates.length === 0 ? `# ${title}\n` : `# ${title}\n\n${pieces.join("")}`;
-};
-/**
-* Contract §8.2. Only the root `log.md`; `bundle.concepts` is the only
-* thing scanned -- `index.md`/`log.md` are reserved files, never concepts
-* (S-22, contract §14 note 8 -- closes PB's Open question 1 outright: an
-* `Updated index`/`Updated log` line can never occur).
-*
-* @internal
-*/
-const syncLog = Effect.fn("okfit/sync/syncLog")(function* (bundle, provenance, dryRun) {
-	const fs = yield* FileSystem.FileSystem;
-	const logPath = (yield* Path.Path).join(bundle.root, "log.md");
-	const source = yield* fs.readFileString(logPath).pipe(Effect.map((text) => text), Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(void 0)));
-	const existingDoc = bundle.logs.get("");
-	if (source !== void 0 && existingDoc === void 0) return {
-		selected: true,
-		written: [],
-		unchanged: [],
-		skipped: [{
-			id: "log.md",
-			reason: "log-unparseable"
-		}]
-	};
-	const newestLogged = (existingDoc?.groups ?? []).map((entryGroup) => entryGroup.date).reduce((max, date) => max === void 0 || date > max ? date : max, void 0);
-	const additions = [];
-	for (const [id, concept] of bundle.concepts) {
-		const derived = provenance.get(id);
-		if (derived === void 0 || derived._tag !== "committed") continue;
-		const date = DateTime.formatIsoDate(derived.at);
-		if (newestLogged !== void 0 && date <= newestLogged) continue;
-		additions.push({
-			date,
-			title: Derive.title(concept),
-			added: derived.creating
-		});
-	}
-	const merged = mergeLog(source === void 0 || existingDoc === void 0 ? void 0 : {
-		doc: existingDoc,
-		source
-	}, additions);
-	if (merged === (source ?? "")) return {
-		selected: true,
-		written: [],
-		unchanged: ["log.md"],
-		skipped: []
-	};
-	if (dryRun) return {
-		selected: true,
-		written: ["log.md"],
-		unchanged: [],
-		skipped: []
-	};
-	yield* writeAtomic(logPath, merged);
-	return {
-		selected: true,
-		written: ["log.md"],
-		unchanged: [],
-		skipped: []
-	};
-});
-
-//#endregion
-export { mergeLog, syncLog };

package/sync/run.js

@@ -1,65 +0,0 @@
-import { syncGenerated } from "./generated.js";
-import { syncIndex } from "./index.js";
-import { syncLog } from "./log.js";
-import { Effect, Schema } from "effect";
-import { Bundle } from "@okfit/core";
-import { Derivation } from "@okfit/profiles";
-
-//#region src/sync/run.ts
-/**
-* S-14: a closed union, not free text. The human renderer maps each member
-* to one fixed sentence (`render/sync.ts#humanSync`); the JSON envelope's
-* `skipped[].reason` is this exact union.
-*
-* @public
-*/
-const SkipReason = Schema.Literals([
-	"untracked",
-	"dirty",
-	"unborn",
-	"generated-missing",
-	"generated-unsupported",
-	"log-unparseable"
-]);
-/** A selected-`false` placeholder for a mode `--only` excluded from (contract §5). */
-const UNSELECTED = {
-	selected: false,
-	written: [],
-	unchanged: [],
-	skipped: []
-};
-/**
-* Contract §5's six-step algorithm: one `Bundle.load`, one
-* `Derivation.generatedAt` per concept shared by the generated and log
-* modes (skipped entirely when neither is selected), then the three modes
-* in a FIXED order — generated, index, log — regardless of `--only`'s own
-* occurrence order, so a generated write never invalidates an index or log
-* rendered in the same run (design §2).
-*
-* @public
-*/
-const runSync = Effect.fn("okfit/sync/runSync")(function* (options) {
-	const bundle = yield* Bundle.load({ root: options.bundleRoot });
-	const needsGit = options.modes.has("generated") || options.modes.has("log");
-	const provenance = /* @__PURE__ */ new Map();
-	if (needsGit) for (const [id, concept] of bundle.concepts) {
-		const derived = yield* Derivation.generatedAt({ file: `${bundle.root}/${concept.path}` });
-		provenance.set(id, derived);
-	}
-	const generated = options.modes.has("generated") ? {
-		selected: true,
-		...yield* syncGenerated(bundle, provenance, options.dryRun)
-	} : UNSELECTED;
-	const index = options.modes.has("index") ? yield* syncIndex(bundle, options.dryRun) : UNSELECTED;
-	const log = options.modes.has("log") ? yield* syncLog(bundle, provenance, options.dryRun) : UNSELECTED;
-	return {
-		bundleRoot: options.bundleRoot,
-		dryRun: options.dryRun,
-		generated,
-		index,
-		log
-	};
-});
-
-//#endregion
-export { SkipReason, runSync };

package/sync/write.js

@@ -1,48 +0,0 @@
-import { Effect, FileSystem, Option, Path } from "effect";
-import { randomUUID } from "node:crypto";
-
-//#region src/sync/write.ts
-/**
-* S-33: the one atomic write every sync mode shares. Resolves `target`'s
-* real path first when it already exists (so a symlinked
-* `index.md`/`log.md`/concept file is replaced by writing through the
-* link rather than over it -- `generated` mode's own discipline, formerly
-* not shared with `index`/`log`) and falls back to `target` itself for a
-* file `sync` is about to create for the first time (`index`/`log` modes
-* both write files that may not exist yet; `generated` mode's targets
-* always exist, since they come from an already-loaded concept). Writes
-* `contents` to a uniquely-scoped temp file beside the resolved target (so
-* two concurrent `sync` runs never collide on a fixed name), preserves an
-* existing target's mode via `stat` + `chmod` (a brand-new file keeps
-* whatever mode `writeFileString` gives it), and renames the temp file
-* over the target. On any failure -- including a failed `rename` -- the
-* temp file is removed (`Effect.onError`), so a partial write never
-* leaves a stray `<file>.okfit-sync.<token>.tmp` behind (F-5/S-33).
-*
-* DISCREPANCY from S-33's literal "the temp name carries the pid": `src/`
-* outside `bin.ts`/`commands/*`/`internal/exit.ts`/`internal/tty.ts` never
-* reads the global `process` (K-39, enforced by `__test__/boundaries.test.ts`),
-* and `sync/write.ts` is not on that allowlist. A `randomUUID()` token
-* (`node:crypto`, not `process`) satisfies S-33's actual requirement --
-* two concurrent `sync` runs never collide on a fixed temp name -- without
-* widening the process-access boundary for one helper. Recorded here per
-* the Global Constraints' "record the discrepancy" instruction.
-*
-* @internal
-*/
-const writeAtomic = Effect.fn("okfit/sync/writeAtomic")(function* (target, contents) {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const resolved = yield* fs.realPath(target).pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(target)));
-	const dir = path.dirname(resolved);
-	const base = path.basename(resolved);
-	const tempPath = path.join(dir, `${base}.okfit-sync.${randomUUID()}.tmp`);
-	const originalMode = yield* fs.stat(resolved).pipe(Effect.map((info) => Option.some(info.mode)), Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(Option.none())));
-	yield* fs.writeFileString(tempPath, contents).pipe(Effect.tap(() => Option.match(originalMode, {
-		onNone: () => Effect.void,
-		onSome: (mode) => fs.chmod(tempPath, mode)
-	})), Effect.tap(() => fs.rename(tempPath, resolved)), Effect.onError(() => fs.remove(tempPath, { force: true }).pipe(Effect.ignore)));
-});
-
-//#endregion
-export { writeAtomic };

package/validate/run.js

@@ -1,63 +0,0 @@
-import { Context, Effect, Option } from "effect";
-import { Bundle, OkfitConfig, Validate } from "@okfit/core";
-import { Provenance } from "@okfit/profiles";
-
-//#region src/validate/run.ts
-/**
-* K-47's ambient clock. `bin.ts` resolves `OKFIT_NOW` (or the wall clock)
-* exactly once and provides it with `Effect.provideService(Now, value)`
-* around the whole command tree; `commands/validate.ts` and
-* `commands/init.ts` each read it with `const now = yield* Now;` before
-* building {@link RunOptions} or a scaffold's `today`. Not re-exported from
-* `index.ts`: like `internal/exit.ts` and `internal/tty.ts`, it means
-* nothing outside a spawned process (K-49). `Context.Tag` does not exist on
-* the Effect v4 line; the v4 shape is
-* `Context.Service<Self, Shape>()(id)`, the same form core and profiles use
-* for their own services (`PROFILES/GitHistory.ts:140`) — source wins over
-* the contract's literal snippet here (K-62).
-*
-* @internal
-*/
-var Now = class extends Context.Service()("@okfit/cli/Now") {};
-/**
-* Load, validate both tiers, run the profile check, then — UNLESS the
-* `generated-at-drift` lint is `off` OR `options.skipProvenance` is `true`
-* — run `Provenance.lint` and append its `Diagnostic`s to `report.lint`.
-* The "skip the git walk entirely" gate lives HERE, in `run`, not inside
-* `Provenance.lint` (S-8's own wording): a bundle configured `off`, or a
-* caller that passed `--skip-provenance`, never pays for a git spawn
-* (S-31). An `error` severity on the appended diagnostics yields exit `1`
-* through the EXISTING lint-tier rule in `render/exit.ts` — no renderer
-* branch, no new `DiagnosticSource`, since these diagnostics flow through
-* the same `report.lint` array every other core lint diagnostic already
-* does.
-*
-* K-52 holds structurally: `Bundle.load`'s failure short-circuits the
-* generator, so `profile.check` never runs on a bundle that did not load.
-*
-* This is a BREAKING signature change: `@okfit/mcp`'s `validateBundle.ts`
-* calls this function directly and must be updated to match (Task C1);
-* `commands/validate.ts` is the other caller.
-*
-* @public
-*/
-const run = (options) => Effect.gen(function* () {
-	const bundle = yield* Bundle.load({ root: options.root });
-	const report = Validate.all(bundle, options.config, { now: options.now });
-	const profileDiagnostics = Option.match(options.profile, {
-		onNone: () => [],
-		onSome: (profile) => profile.check(bundle)
-	});
-	const provenance = OkfitConfig.severityFor(options.config, "generated-at-drift") === "off" || options.skipProvenance === true ? [] : yield* Provenance.lint(bundle, options.config);
-	return {
-		bundle,
-		report: {
-			...report,
-			lint: [...report.lint, ...provenance]
-		},
-		profileDiagnostics
-	};
-});
-
-//#endregion
-export { Now, run };

package/verify/locate.js

@@ -1,249 +0,0 @@
-import { Effect } from "effect";
-import { FrontmatterSource } from "@effected/markdown";
-import { YamlAlias, YamlDocument, YamlMap, YamlScalar, YamlSeq } from "@effected/yaml";
-
-//#region src/verify/locate.ts
-/**
-* Strip a leading BOM before anything else; the caller re-prepends `bom`
-* verbatim on write (V-15). `FrontmatterSource.split`'s own remarks require
-* this: "a leading BOM means offset 0 is not a fence — strip one before
-* calling" (`FrontmatterSource.ts:123`).
-*
-* @internal
-*/
-const stripBom = (source) => source.charCodeAt(0) === 65279 ? {
-	text: source.slice(1),
-	bom: ""
-} : {
-	text: source,
-	bom: ""
-};
-/** CRLF when the document's FIRST newline is CRLF, else LF (V-15). @internal */
-const detectNewline = (source) => {
-	const index = source.indexOf("\n");
-	return index > 0 && source.charCodeAt(index - 1) === 13 ? "\r\n" : "\n";
-};
-/**
-* The terminator the spliced fragment must use: `split`'s own fidelity
-* field for the opening fence's terminator when it is LF or CRLF, else
-* {@link detectNewline}. `FrontmatterNewline` also admits a lone `"\r"`,
-* which no fragment may emit, so that case falls through to the scan.
-*
-* @internal
-*/
-const documentNewline = (text) => {
-	const newline = FrontmatterSource.split(text).frontmatter?.newline;
-	if (newline === "\r\n") return "\r\n";
-	if (newline === "\n") return "\n";
-	return detectNewline(text);
-};
-/** The run of spaces ending at `offset`, or `""` when anything else precedes it on the line. @internal */
-const indentAt = (value, offset) => {
-	const lineStart = value.lastIndexOf("\n", offset - 1) + 1;
-	const prefix = value.slice(lineStart, offset);
-	return /^ *$/.test(prefix) ? prefix : "";
-};
-/**
-* True when `node`, or any mapping directly inside a sequence `node`,
-* carries a `<<` key. That is every level a legal `Verification.List` can
-* reach; anything deeper already fails to decode as a `Verification`
-* (contract §11 item 3).
-*/
-const hasMergeKey = (node) => {
-	if (node instanceof YamlMap) return node.items.some((pair) => pair.key instanceof YamlScalar && pair.key.value === "<<");
-	if (node instanceof YamlSeq) return node.items.some((item) => item instanceof YamlMap && hasMergeKey(item));
-	return false;
-};
-/**
-* Split `source`'s frontmatter, parse its value, find the top-level
-* `verified` pair, and classify it (contract §3.1). Fails only when the
-* frontmatter YAML is fatally unparseable — impossible for a concept that
-* reached `bundle.concepts`, but typed rather than assumed.
-*
-* Offset translation is `valueStart = 3 + newline.length` — `"---".length`
-* plus the opening fence's own terminator, taken from `split`'s fidelity
-* field rather than re-derived with `indexOf` (contract §12 note 9). Every
-* whole-file offset below is `valueStart + <yaml offset>`.
-*
-* @internal
-*/
-const locate = Effect.fn("okfit/verify/locate")(function* (source) {
-	const block = FrontmatterSource.split(source).frontmatter;
-	if (block === void 0) return {
-		_tag: "unsupported",
-		shape: "no-frontmatter"
-	};
-	const value = block.value;
-	const valueStart = 3 + (block.newline ?? "\n").length;
-	const contents = (yield* YamlDocument.parse(value)).contents;
-	if (!(contents instanceof YamlMap)) return {
-		_tag: "unsupported",
-		shape: "not-a-mapping"
-	};
-	const pair = contents.items.find((item) => item.key instanceof YamlScalar && item.key.value === "verified");
-	if (pair === void 0) return {
-		_tag: "absent",
-		insertAt: valueStart + value.length
-	};
-	const key = pair.key;
-	const node = pair.value;
-	if (node === null) return {
-		_tag: "unsupported",
-		shape: "empty"
-	};
-	if (node instanceof YamlAlias) return {
-		_tag: "unsupported",
-		shape: "alias"
-	};
-	if (hasMergeKey(node)) return {
-		_tag: "unsupported",
-		shape: "merge-key"
-	};
-	if (node instanceof YamlScalar) return {
-		_tag: "unsupported",
-		shape: "scalar"
-	};
-	if (node instanceof YamlSeq) {
-		if (node.style === "flow") return {
-			_tag: "flowSeq",
-			insertAt: valueStart + node.offset + node.length - 1,
-			empty: node.items.length === 0
-		};
-		const last = node.items[node.items.length - 1];
-		if (last === void 0) return {
-			_tag: "unsupported",
-			shape: "empty"
-		};
-		const end = last.offset + last.length;
-		return {
-			_tag: "blockSeq",
-			insertAt: valueStart + end,
-			afterNewline: value[end - 1] === "\n",
-			indent: indentAt(value, node.offset),
-			lastItemStyle: last instanceof YamlMap && last.style === "flow" ? "flow" : "block"
-		};
-	}
-	if (node instanceof YamlMap) {
-		const start = valueStart + key.offset + key.length + 1;
-		const rawEnd = node.offset + node.length;
-		const raw = value.slice(node.offset, rawEnd);
-		const original = raw.replace(/(?:\r\n|\n|\r)$/, "");
-		return {
-			_tag: "bareMapping",
-			style: node.style === "flow" ? "flow" : "block",
-			start,
-			end: valueStart + rawEnd,
-			indent: `${indentAt(value, key.offset)}  `,
-			original,
-			endsWithNewline: original.length !== raw.length
-		};
-	}
-	return {
-		_tag: "unsupported",
-		shape: "not-a-mapping"
-	};
-});
-/**
-* Locate the `at` key inside a concept's top-level `generated` BLOCK
-* mapping. Callers MUST have already confirmed `generated` exists on the
-* decoded concept (`generated-missing`, S-3/design §3 rule 5, is the
-* caller's check against `concept.frontmatter.generated`, never this
-* function's) — matches how `locate` already re-parses independently of
-* whatever `Bundle.load` retained, for `verified`. The insert style is
-* one new newline-terminated line after the last key's line of the
-* mapping, at that mapping's indent, using the document newline (S-2,
-* confirmed as already correct in FW's own proposal — contract §14 note
-* 1 — with no correction needed against this file's `locate` precedent).
-*
-* @internal
-*/
-const locateGenerated = Effect.fn("okfit/verify/locateGenerated")(function* (source) {
-	const block = FrontmatterSource.split(source).frontmatter;
-	if (block === void 0) return {
-		_tag: "unsupported",
-		shape: "no-frontmatter"
-	};
-	const value = block.value;
-	const valueStart = 3 + (block.newline ?? "\n").length;
-	const contents = (yield* YamlDocument.parse(value)).contents;
-	if (!(contents instanceof YamlMap)) return {
-		_tag: "unsupported",
-		shape: "not-a-mapping"
-	};
-	const pair = contents.items.find((item) => item.key instanceof YamlScalar && item.key.value === "generated");
-	if (pair === void 0) return {
-		_tag: "unsupported",
-		shape: "no-generated-key"
-	};
-	const node = pair.value;
-	if (node === null) return {
-		_tag: "unsupported",
-		shape: "empty"
-	};
-	if (node instanceof YamlAlias) return {
-		_tag: "unsupported",
-		shape: "alias"
-	};
-	if (hasMergeKey(node)) return {
-		_tag: "unsupported",
-		shape: "merge-key"
-	};
-	if (node instanceof YamlScalar) return {
-		_tag: "unsupported",
-		shape: "scalar"
-	};
-	if (node instanceof YamlSeq) return {
-		_tag: "unsupported",
-		shape: "sequence"
-	};
-	if (!(node instanceof YamlMap)) return {
-		_tag: "unsupported",
-		shape: "not-a-mapping"
-	};
-	if (node.style === "flow") return {
-		_tag: "unsupported",
-		shape: "flow-mapping"
-	};
-	const indent = indentAt(value, node.offset);
-	const atPair = node.items.find((item) => item.key instanceof YamlScalar && item.key.value === "at");
-	if (atPair === void 0) {
-		const last = node.items[node.items.length - 1];
-		if (last === void 0) return {
-			_tag: "unsupported",
-			shape: "empty"
-		};
-		const lastEnd = last.value !== null ? last.value.offset + last.value.length : last.key.offset + last.key.length;
-		const nl = value.indexOf("\n", lastEnd);
-		return {
-			_tag: "insertAfterLastKey",
-			insertAt: valueStart + (nl === -1 ? value.length : nl + 1),
-			indent
-		};
-	}
-	const atValue = atPair.value;
-	if (atValue === null) return {
-		_tag: "unsupported",
-		shape: "at-empty"
-	};
-	if (atValue instanceof YamlAlias) return {
-		_tag: "unsupported",
-		shape: "alias"
-	};
-	if (!(atValue instanceof YamlScalar)) return {
-		_tag: "unsupported",
-		shape: "at-not-scalar"
-	};
-	if (atValue.style === "block-literal" || atValue.style === "block-folded") return {
-		_tag: "unsupported",
-		shape: "at-block-scalar"
-	};
-	return {
-		_tag: "replaceScalar",
-		start: valueStart + atValue.offset,
-		end: valueStart + atValue.offset + atValue.length,
-		quote: atValue.style
-	};
-});
-
-//#endregion
-export { detectNewline, documentNewline, indentAt, locate, locateGenerated, stripBom };

package/verify/run.js

@@ -1,106 +0,0 @@
-import { VerifyConceptNotFoundError, VerifyUnsupportedFrontmatterError } from "../errors.js";
-import { documentNewline, locate, stripBom } from "./locate.js";
-import { splice } from "./splice.js";
-import { Effect, FileSystem, Option, Path, Schema } from "effect";
-import { Bundle, ConceptId, Timestamp } from "@okfit/core";
-import { Derivation } from "@okfit/profiles";
-import { MarkdownEdit } from "@effected/markdown";
-
-//#region src/verify/run.ts
-/**
-* The only four diagnostic codes that can co-occur with a MISSING
-* `concepts` entry (V-9, contract §12 note 10): `Bundle.ts:143/164/175/186`
-* emit the three frontmatter codes and return without a concept, and
-* `internal/frontmatter.ts:73` emits `type-missing` for `decodeConcept`'s
-* only failure branch. Every other code — `family-invalid`,
-* `computation-runtime-missing`, `legacy-timestamp` — is pushed as an issue
-* while `decodeConcept` still returns a concept, so the concept IS in the
-* map (`internal/conceptDecode.ts:84-134`).
-*/
-const UNDECODABLE_CODES = /* @__PURE__ */ new Set([
-	"frontmatter-unparseable",
-	"frontmatter-unclosed",
-	"frontmatter-missing",
-	"type-missing"
-]);
-/**
-* Contract §2.3 steps 6–15. Loads the bundle, resolves the id, resolves the
-* human actor from git, splices exactly one entry into the concept's
-* frontmatter and writes it back atomically.
-*
-* Nothing here reads `status`, `stale_after`, or a type's
-* `require_verified`: `verify` is mechanical, not config-aware (V-4, V-5).
-*
-* @internal
-*/
-const runVerify = Effect.fn("okfit/verify/runVerify")(function* (options) {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const bundle = yield* Bundle.load({ root: options.bundleRoot });
-	const normalized = ConceptId.normalize(options.id);
-	if (Option.isNone(normalized)) return yield* new VerifyConceptNotFoundError({
-		id: options.id,
-		root: bundle.root,
-		reason: "not-a-concept"
-	});
-	const id = normalized.value;
-	const conceptFile = ConceptId.toPath(id);
-	if (ConceptId.isReservedFile(conceptFile)) return yield* new VerifyConceptNotFoundError({
-		id,
-		root: bundle.root,
-		reason: "reserved"
-	});
-	const concept = bundle.concepts.get(id);
-	if (concept === void 0) {
-		const diagnostic = bundle.diagnostics.find((entry) => entry.file === conceptFile && UNDECODABLE_CODES.has(entry.code));
-		return yield* new VerifyConceptNotFoundError({
-			id,
-			root: bundle.root,
-			...diagnostic === void 0 ? { reason: "not-a-concept" } : {
-				reason: "undecodable",
-				diagnosticCode: diagnostic.code
-			}
-		});
-	}
-	const actor = yield* Derivation.generatedBy({
-		writer: "human",
-		cwd: options.projectRoot,
-		config: options.config
-	});
-	const absolutePath = path.join(bundle.root, concept.path);
-	const source = yield* fs.readFileString(absolutePath);
-	const { text, bom } = stripBom(source);
-	const located = yield* locate(text);
-	if (located._tag === "unsupported") return yield* new VerifyUnsupportedFrontmatterError({
-		id,
-		shape: located.shape
-	});
-	const at = Schema.encodeSync(Timestamp)(options.at);
-	const priorAt = (concept.frontmatter.verified ?? []).filter((entry) => entry.by === actor).map((entry) => Schema.encodeSync(Timestamp)(entry.at));
-	const edit = splice(located, {
-		by: actor,
-		at
-	}, documentNewline(text));
-	const finalText = bom + MarkdownEdit.applyAll(text, [edit]);
-	if (!options.dryRun) {
-		const target = yield* fs.realPath(absolutePath);
-		const tempPath = `${target}.okfit-verify.tmp`;
-		const original = yield* fs.stat(target);
-		yield* fs.writeFileString(tempPath, finalText);
-		yield* fs.chmod(tempPath, original.mode);
-		yield* fs.rename(tempPath, target).pipe(Effect.onError(() => fs.remove(tempPath, { force: true }).pipe(Effect.ignore)));
-	}
-	return {
-		id,
-		bundleRoot: bundle.root,
-		conceptPath: concept.path,
-		by: actor,
-		at,
-		priorAt,
-		dryRun: options.dryRun,
-		fragment: edit.content
-	};
-});
-
-//#endregion
-export { runVerify };