@okfit/engine 0.6.0 → 0.7.1

package/verify/run.js

@@ -1,4 +1,4 @@
-import { VerifyConceptNotFoundError, VerifyUnsupportedFrontmatterError } from "../errors.js";
+import { VerifyConceptNotFoundError, VerifySelectionError, VerifyUnsupportedFrontmatterError } from "../errors.js";
 import { documentNewline, locate, stripBom } from "./locate.js";
 import { splice } from "./splice.js";
 import { Bundle, ConceptId, Timestamp } from "@okfit/core";
@@ -23,6 +23,39 @@ const UNDECODABLE_CODES = /* @__PURE__ */ new Set([
 	"frontmatter-missing",
 	"type-missing"
 ]);
+/** Steps 9-14 of runVerify: read, locate (fail closed), splice; no write. */
+const prepareVerify = Effect.fn("okfit/verify/prepareVerify")(function* (bundle, concept, actor, at) {
+	const fs = yield* FileSystem.FileSystem;
+	const absolutePath = (yield* Path.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: concept.id,
+		shape: located.shape
+	});
+	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));
+	return {
+		absolutePath,
+		finalText: bom + MarkdownEdit.applyAll(text, [edit]),
+		fragment: edit.content,
+		priorAt
+	};
+});
+/** The I4/V-16 atomic write: real path, temp beside it, mode preserved, rename. */
+const writeVerified = Effect.fn("okfit/verify/writeVerified")(function* (absolutePath, finalText) {
+	const fs = yield* FileSystem.FileSystem;
+	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)));
+});
 /**
 * 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
@@ -34,8 +67,6 @@ const UNDECODABLE_CODES = /* @__PURE__ */ new Set([
 * @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({
@@ -67,40 +98,85 @@ const runVerify = Effect.fn("okfit/verify/runVerify")(function* (options) {
 		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({
+	const at = Schema.encodeSync(Timestamp)(options.at);
+	const prepared = yield* prepareVerify(bundle, concept, actor, at);
+	if (!options.dryRun) yield* writeVerified(prepared.absolutePath, prepared.finalText);
+	return {
 		id,
-		shape: located.shape
+		bundleRoot: bundle.root,
+		conceptPath: concept.path,
+		by: actor,
+		at,
+		priorAt: prepared.priorAt,
+		dryRun: options.dryRun,
+		fragment: prepared.fragment
+	};
+});
+/**
+* Issue #138. Attests every concept selected by `options.types` (or, when
+* empty, every type whose declaration sets `require_verified = true`) that
+* is not a draft and does not already carry a `verified` entry by the
+* resolved actor. Every candidate is located FIRST -- an unsupported
+* `verified` shape on any one of them fails the whole batch with nothing
+* written, mirroring `runVerify`'s own fail-closed rule at batch scale.
+*
+* @public
+*/
+const runVerifyBatch = Effect.fn("okfit/verify/runVerifyBatch")(function* (options) {
+	const bundle = yield* Bundle.load({ root: options.bundleRoot });
+	const declared = options.config.types ?? {};
+	let types;
+	if (options.types.length > 0) {
+		for (const type of options.types) if (!Object.hasOwn(declared, type)) return yield* new VerifySelectionError({
+			reason: "unknown-type",
+			detail: type
+		});
+		types = new Set(options.types);
+	} else types = new Set(Object.entries(declared).flatMap(([name, spec]) => spec.require_verified === true ? [name] : []));
+	const actor = yield* Derivation.generatedBy({
+		writer: "human",
+		cwd: options.projectRoot,
+		config: options.config
 	});
 	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)));
+	const skipped = [];
+	const prepared = [];
+	for (const [id, concept] of bundle.concepts) {
+		if (!types.has(concept.frontmatter.type)) continue;
+		if (concept.frontmatter.status === "draft") {
+			skipped.push({
+				id,
+				reason: "draft"
+			});
+			continue;
+		}
+		if ((concept.frontmatter.verified ?? []).some((entry) => entry.by === actor)) {
+			skipped.push({
+				id,
+				reason: "already-verified"
+			});
+			continue;
+		}
+		prepared.push({
+			id,
+			conceptPath: concept.path,
+			...yield* prepareVerify(bundle, concept, actor, at)
+		});
 	}
+	if (!options.dryRun) for (const entry of prepared) yield* writeVerified(entry.absolutePath, entry.finalText);
 	return {
-		id,
 		bundleRoot: bundle.root,
-		conceptPath: concept.path,
 		by: actor,
 		at,
-		priorAt,
 		dryRun: options.dryRun,
-		fragment: edit.content
+		verified: prepared.map(({ id, conceptPath, fragment }) => ({
+			id,
+			conceptPath,
+			fragment
+		})),
+		skipped
 	};
 });
 
 //#endregion
-export { runVerify };
+export { runVerify, runVerifyBatch };

package/verify/splice.js

@@ -92,6 +92,18 @@ const spliceGeneratedFields = (atTarget, bodySha256Target, encodedAt, bodySha256
 	})];
 	return [spliceGenerated(atTarget, encodedAt, newline, "at"), spliceGenerated(bodySha256Target, bodySha256, newline, "body_sha256")];
 };
+/**
+* A whole `generated:` block mapping, appended as the LAST top-level key
+* (issue #73) — block style, matching how this repository writes every
+* `generated:` and how `splice`'s own `absent` case writes `verified:`.
+*
+* @internal
+*/
+const spliceGeneratedBlock = (target, fields, newline) => MarkdownEdit.make({
+	offset: target.insertAt,
+	length: 0,
+	content: `generated:${newline}  by: ${fields.by}${newline}  at: ${fields.at}${newline}  body_sha256: ${fields.bodySha256}${newline}`
+});
 
 //#endregion
-export { splice, spliceGenerated, spliceGeneratedFields };
+export { splice, spliceGenerated, spliceGeneratedBlock, spliceGeneratedFields };

package/version.js

@@ -0,0 +1,17 @@
+//#region src/version.ts
+/**
+* The version this engine reports as `engine_version` in every JSON
+* envelope. `@savvy-web/bundler` replaces `process.env.__PACKAGE_VERSION__`
+* with this package's own version at build time (K-32), so a release can
+* never desync from the printed version. `"0.0.0"` is the unbuilt-source
+* fallback and reads as dev mode. This is the ONE `process` read this
+* package's own `boundaries.test.ts` allowlists — see that file and this
+* package's `CLAUDE.md` for why it is safe here even though every other
+* `process` read is forbidden.
+*
+* @public
+*/
+const ENGINE_VERSION = "0.7.1";
+
+//#endregion
+export { ENGINE_VERSION };